568 files changed, 29033 insertions, 7392 deletions

diff --git a/include/acpi/acnames.h b/include/acpi/acnames.h
index 273de709495c..b52c0dc4b492 100644
--- a/include/acpi/acnames.h
+++ b/include/acpi/acnames.h
@@ -51,6 +51,7 @@
 #define METHOD_NAME__BBN        "_BBN"
 #define METHOD_NAME__CBA        "_CBA"
 #define METHOD_NAME__CID        "_CID"
+#define METHOD_NAME__CLS        "_CLS"
 #define METHOD_NAME__CRS        "_CRS"
 #define METHOD_NAME__DDN        "_DDN"
 #define METHOD_NAME__HID        "_HID"
diff --git a/include/acpi/acoutput.h b/include/acpi/acoutput.h
index a8f344363e77..f56de8c5d844 100644
--- a/include/acpi/acoutput.h
+++ b/include/acpi/acoutput.h
@@ -294,8 +294,12 @@
 
 /* DEBUG_PRINT functions */
 
-#define ACPI_DEBUG_PRINT(plist)         ACPI_ACTUAL_DEBUG plist
-#define ACPI_DEBUG_PRINT_RAW(plist)     ACPI_ACTUAL_DEBUG_RAW plist
+#ifndef COMPILER_VA_MACRO
+
+#define ACPI_DEBUG_PRINT(plist)         acpi_debug_print plist
+#define ACPI_DEBUG_PRINT_RAW(plist)     acpi_debug_print_raw plist
+
+#else
 
 /* Helper macros for DEBUG_PRINT */
 
@@ -315,6 +319,11 @@
         ACPI_DO_DEBUG_PRINT (acpi_debug_print_raw, level, line, \
                 filename, modulename, component, __VA_ARGS__)
 
+#define ACPI_DEBUG_PRINT(plist)         ACPI_ACTUAL_DEBUG plist
+#define ACPI_DEBUG_PRINT_RAW(plist)     ACPI_ACTUAL_DEBUG_RAW plist
+
+#endif
+
 /*
  * Function entry tracing
  *
diff --git a/include/acpi/acpi_bus.h b/include/acpi/acpi_bus.h
index 8de4fa90e8c4..83061cac719b 100644
--- a/include/acpi/acpi_bus.h
+++ b/include/acpi/acpi_bus.h
@@ -208,7 +208,10 @@ struct acpi_device_flags {
         u32 visited:1;
         u32 hotplug_notify:1;
         u32 is_dock_station:1;
-        u32 reserved:23;
+        u32 of_compatible_ok:1;
+        u32 coherent_dma:1;
+        u32 cca_seen:1;
+        u32 reserved:20;
 };
 
 /* File System */
@@ -271,7 +274,6 @@ struct acpi_device_power_flags {
 struct acpi_device_power_state {
         struct {
                 u8 valid:1;
-                u8 os_accessible:1;
                 u8 explicit_set:1;      /* _PSx present? */
                 u8 reserved:6;
         } flags;
@@ -380,12 +382,45 @@ struct acpi_device {
         void (*remove)(struct acpi_device *);
 };
 
+static inline bool acpi_check_dma(struct acpi_device *adev, bool *coherent)
+{
+        bool ret = false;
+
+        if (!adev)
+                return ret;
+
+        /**
+         * Currently, we only support _CCA=1 (i.e. coherent_dma=1)
+         * This should be equivalent to specifyig dma-coherent for
+         * a device in OF.
+         *
+         * For the case when _CCA=0 (i.e. coherent_dma=0 && cca_seen=1),
+         * There are two cases:
+         * case 1. Do not support and disable DMA.
+         * case 2. Support but rely on arch-specific cache maintenance for
+         *         non-coherence DMA operations.
+         * Currently, we implement case 1 above.
+         *
+         * For the case when _CCA is missing (i.e. cca_seen=0) and
+         * platform specifies ACPI_CCA_REQUIRED, we do not support DMA,
+         * and fallback to arch-specific default handling.
+         *
+         * See acpi_init_coherency() for more info.
+         */
+        if (adev->flags.coherent_dma) {
+                ret = true;
+                if (coherent)
+                        *coherent = adev->flags.coherent_dma;
+        }
+        return ret;
+}
+
 static inline bool is_acpi_node(struct fwnode_handle *fwnode)
 {
         return fwnode && fwnode->type == FWNODE_ACPI;
 }
 
-static inline struct acpi_device *acpi_node(struct fwnode_handle *fwnode)
+static inline struct acpi_device *to_acpi_node(struct fwnode_handle *fwnode)
 {
         return is_acpi_node(fwnode) ?
                 container_of(fwnode, struct acpi_device, fwnode) : NULL;
@@ -601,7 +636,7 @@ static inline bool acpi_device_can_wakeup(struct acpi_device *adev)
 
 static inline bool acpi_device_can_poweroff(struct acpi_device *adev)
 {
-        return adev->power.states[ACPI_STATE_D3_COLD].flags.os_accessible;
+        return adev->power.states[ACPI_STATE_D3_COLD].flags.valid;
 }
 
 #else   /* CONFIG_ACPI */
diff --git a/include/acpi/acpiosxf.h b/include/acpi/acpiosxf.h
index 0bc78df66d4b..d02df0a49d98 100644
--- a/include/acpi/acpiosxf.h
+++ b/include/acpi/acpiosxf.h
@@ -95,7 +95,7 @@ acpi_physical_address acpi_os_get_root_pointer(void);
 #ifndef ACPI_USE_ALTERNATE_PROTOTYPE_acpi_os_predefined_override
 acpi_status
 acpi_os_predefined_override(const struct acpi_predefined_names *init_val,
-                            acpi_string * new_val);
+                            char **new_val);
 #endif
 
 #ifndef ACPI_USE_ALTERNATE_PROTOTYPE_acpi_os_table_override
diff --git a/include/acpi/acpixf.h b/include/acpi/acpixf.h
index 08ef57bc8d63..e8ec18a4a634 100644
--- a/include/acpi/acpixf.h
+++ b/include/acpi/acpixf.h
@@ -46,7 +46,7 @@
 
 /* Current ACPICA subsystem version in YYYYMMDD format */
 
-#define ACPI_CA_VERSION                 0x20150410
+#define ACPI_CA_VERSION                 0x20150619
 
 #include <acpi/acconfig.h>
 #include <acpi/actypes.h>
@@ -195,9 +195,18 @@ ACPI_INIT_GLOBAL(u8, acpi_gbl_do_not_use_xsdt, FALSE);
  * address. Although ACPICA adheres to the ACPI specification which
  * requires the use of the corresponding 64-bit address if it is non-zero,
  * some machines have been found to have a corrupted non-zero 64-bit
- * address. Default is TRUE, favor the 32-bit addresses.
+ * address. Default is FALSE, do not favor the 32-bit addresses.
  */
-ACPI_INIT_GLOBAL(u8, acpi_gbl_use32_bit_fadt_addresses, TRUE);
+ACPI_INIT_GLOBAL(u8, acpi_gbl_use32_bit_fadt_addresses, FALSE);
+
+/*
+ * Optionally use 32-bit FACS table addresses.
+ * It is reported that some platforms fail to resume from system suspending
+ * if 64-bit FACS table address is selected:
+ * https://bugzilla.kernel.org/show_bug.cgi?id=74021
+ * Default is TRUE, favor the 32-bit addresses.
+ */
+ACPI_INIT_GLOBAL(u8, acpi_gbl_use32_bit_facs_addresses, TRUE);
 
 /*
  * Optionally truncate I/O addresses to 16 bits. Provides compatibility
@@ -220,6 +229,11 @@ ACPI_INIT_GLOBAL(u8, acpi_gbl_disable_auto_repair, FALSE);
 ACPI_INIT_GLOBAL(u8, acpi_gbl_disable_ssdt_table_install, FALSE);
 
 /*
+ * Optionally enable runtime namespace override.
+ */
+ACPI_INIT_GLOBAL(u8, acpi_gbl_runtime_namespace_override, TRUE);
+
+/*
  * We keep track of the latest version of Windows that has been requested by
  * the BIOS. ACPI 5.0.
  */
@@ -814,8 +828,12 @@ ACPI_EXTERNAL_RETURN_STATUS(acpi_status
 ACPI_EXTERNAL_RETURN_STATUS(acpi_status acpi_leave_sleep_state(u8 sleep_state))
 
 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
-                                acpi_set_firmware_waking_vector(u32
-                                                                physical_address))
+                                acpi_set_firmware_waking_vectors
+                                (acpi_physical_address physical_address,
+                                 acpi_physical_address physical_address64))
+ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
+                                 acpi_set_firmware_waking_vector(u32
+                                                                 physical_address))
 #if ACPI_MACHINE_WIDTH == 64
 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
                                 acpi_set_firmware_waking_vector64(u64
diff --git a/include/acpi/actbl.h b/include/acpi/actbl.h
index d4081fef1095..2d5faf508cad 100644
--- a/include/acpi/actbl.h
+++ b/include/acpi/actbl.h
@@ -65,6 +65,7 @@
 #define ACPI_SIG_DSDT           "DSDT"  /* Differentiated System Description Table */
 #define ACPI_SIG_FADT           "FACP"  /* Fixed ACPI Description Table */
 #define ACPI_SIG_FACS           "FACS"  /* Firmware ACPI Control Structure */
+#define ACPI_SIG_OSDT           "OSDT"  /* Override System Description Table */
 #define ACPI_SIG_PSDT           "PSDT"  /* Persistent System Description Table */
 #define ACPI_SIG_RSDP           "RSD PTR "      /* Root System Description Pointer */
 #define ACPI_SIG_RSDT           "RSDT"  /* Root System Description Table */
@@ -284,6 +285,7 @@ struct acpi_table_fadt {
         struct acpi_generic_address xgpe1_block;        /* 64-bit Extended General Purpose Event 1 Reg Blk address */
         struct acpi_generic_address sleep_control;      /* 64-bit Sleep Control register (ACPI 5.0) */
         struct acpi_generic_address sleep_status;       /* 64-bit Sleep Status register (ACPI 5.0) */
+        u64 hypervisor_id;      /* Hypervisor Vendor ID (ACPI 6.0) */
 };
 
 /* Masks for FADT IA-PC Boot Architecture Flags (boot_flags) [Vx]=Introduced in this FADT revision */
@@ -341,7 +343,7 @@ enum acpi_preferred_pm_profiles {
         PM_TABLET = 8
 };
 
-/* Values for sleep_status and sleep_control registers (V5 FADT) */
+/* Values for sleep_status and sleep_control registers (V5+ FADT) */
 
 #define ACPI_X_WAKE_STATUS          0x80
 #define ACPI_X_SLEEP_TYPE_MASK      0x1C
@@ -398,15 +400,17 @@ struct acpi_table_desc {
  * FADT is the bottom line as to what the version really is.
  *
  * For reference, the values below are as follows:
- *     FADT V1  size: 0x074
- *     FADT V2  size: 0x084
- *     FADT V3  size: 0x0F4
- *     FADT V4  size: 0x0F4
- *     FADT V5  size: 0x10C
+ *     FADT V1 size: 0x074
+ *     FADT V2 size: 0x084
+ *     FADT V3 size: 0x0F4
+ *     FADT V4 size: 0x0F4
+ *     FADT V5 size: 0x10C
+ *     FADT V6 size: 0x114
  */
 #define ACPI_FADT_V1_SIZE       (u32) (ACPI_FADT_OFFSET (flags) + 4)
 #define ACPI_FADT_V2_SIZE       (u32) (ACPI_FADT_OFFSET (minor_revision) + 1)
 #define ACPI_FADT_V3_SIZE       (u32) (ACPI_FADT_OFFSET (sleep_control))
-#define ACPI_FADT_V5_SIZE       (u32) (sizeof (struct acpi_table_fadt))
+#define ACPI_FADT_V5_SIZE       (u32) (ACPI_FADT_OFFSET (hypervisor_id))
+#define ACPI_FADT_V6_SIZE       (u32) (sizeof (struct acpi_table_fadt))
 
 #endif                          /* __ACTBL_H__ */
diff --git a/include/acpi/actbl1.h b/include/acpi/actbl1.h
index b80b0e6dabc5..fcd570999f35 100644
--- a/include/acpi/actbl1.h
+++ b/include/acpi/actbl1.h
@@ -71,6 +71,7 @@
 #define ACPI_SIG_SBST           "SBST"  /* Smart Battery Specification Table */
 #define ACPI_SIG_SLIT           "SLIT"  /* System Locality Distance Information Table */
 #define ACPI_SIG_SRAT           "SRAT"  /* System Resource Affinity Table */
+#define ACPI_SIG_NFIT           "NFIT"  /* NVDIMM Firmware Interface Table */
 
 /*
  * All tables must be byte-packed to match the ACPI specification, since
@@ -673,7 +674,8 @@ enum acpi_madt_type {
         ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR = 12,
         ACPI_MADT_TYPE_GENERIC_MSI_FRAME = 13,
         ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR = 14,
-        ACPI_MADT_TYPE_RESERVED = 15    /* 15 and greater are reserved */
+        ACPI_MADT_TYPE_GENERIC_TRANSLATOR = 15,
+        ACPI_MADT_TYPE_RESERVED = 16    /* 16 and greater are reserved */
 };
 
 /*
@@ -794,7 +796,7 @@ struct acpi_madt_local_x2apic_nmi {
         u8 reserved[3];         /* reserved - must be zero */
 };
 
-/* 11: Generic Interrupt (ACPI 5.0) */
+/* 11: Generic Interrupt (ACPI 5.0 + ACPI 6.0 changes) */
 
 struct acpi_madt_generic_interrupt {
         struct acpi_subtable_header header;
@@ -811,6 +813,8 @@ struct acpi_madt_generic_interrupt {
         u32 vgic_interrupt;
         u64 gicr_base_address;
         u64 arm_mpidr;
+        u8 efficiency_class;
+        u8 reserved2[3];
 };
 
 /* Masks for Flags field above */
@@ -819,7 +823,7 @@ struct acpi_madt_generic_interrupt {
 #define ACPI_MADT_PERFORMANCE_IRQ_MODE  (1<<1)  /* 01: Performance Interrupt Mode */
 #define ACPI_MADT_VGIC_IRQ_MODE         (1<<2)  /* 02: VGIC Maintenance Interrupt mode */
 
-/* 12: Generic Distributor (ACPI 5.0) */
+/* 12: Generic Distributor (ACPI 5.0 + ACPI 6.0 changes) */
 
 struct acpi_madt_generic_distributor {
         struct acpi_subtable_header header;
@@ -827,7 +831,19 @@ struct acpi_madt_generic_distributor {
         u32 gic_id;
         u64 base_address;
         u32 global_irq_base;
-        u32 reserved2;          /* reserved - must be zero */
+        u8 version;
+        u8 reserved2[3];        /* reserved - must be zero */
+};
+
+/* Values for Version field above */
+
+enum acpi_madt_gic_version {
+        ACPI_MADT_GIC_VERSION_NONE = 0,
+        ACPI_MADT_GIC_VERSION_V1 = 1,
+        ACPI_MADT_GIC_VERSION_V2 = 2,
+        ACPI_MADT_GIC_VERSION_V3 = 3,
+        ACPI_MADT_GIC_VERSION_V4 = 4,
+        ACPI_MADT_GIC_VERSION_RESERVED = 5      /* 5 and greater are reserved */
 };
 
 /* 13: Generic MSI Frame (ACPI 5.1) */
@@ -855,6 +871,16 @@ struct acpi_madt_generic_redistributor {
         u32 length;
 };
 
+/* 15: Generic Translator (ACPI 6.0) */
+
+struct acpi_madt_generic_translator {
+        struct acpi_subtable_header header;
+        u16 reserved;           /* reserved - must be zero */
+        u32 translation_id;
+        u64 base_address;
+        u32 reserved2;
+};
+
 /*
  * Common flags fields for MADT subtables
  */
@@ -908,6 +934,159 @@ struct acpi_msct_proximity {
 
 /*******************************************************************************
  *
+ * NFIT - NVDIMM Interface Table (ACPI 6.0)
+ *        Version 1
+ *
+ ******************************************************************************/
+
+struct acpi_table_nfit {
+        struct acpi_table_header header;        /* Common ACPI table header */
+        u32 reserved;           /* Reserved, must be zero */
+};
+
+/* Subtable header for NFIT */
+
+struct acpi_nfit_header {
+        u16 type;
+        u16 length;
+};
+
+/* Values for subtable type in struct acpi_nfit_header */
+
+enum acpi_nfit_type {
+        ACPI_NFIT_TYPE_SYSTEM_ADDRESS = 0,
+        ACPI_NFIT_TYPE_MEMORY_MAP = 1,
+        ACPI_NFIT_TYPE_INTERLEAVE = 2,
+        ACPI_NFIT_TYPE_SMBIOS = 3,
+        ACPI_NFIT_TYPE_CONTROL_REGION = 4,
+        ACPI_NFIT_TYPE_DATA_REGION = 5,
+        ACPI_NFIT_TYPE_FLUSH_ADDRESS = 6,
+        ACPI_NFIT_TYPE_RESERVED = 7     /* 7 and greater are reserved */
+};
+
+/*
+ * NFIT Subtables
+ */
+
+/* 0: System Physical Address Range Structure */
+
+struct acpi_nfit_system_address {
+        struct acpi_nfit_header header;
+        u16 range_index;
+        u16 flags;
+        u32 reserved;           /* Reseved, must be zero */
+        u32 proximity_domain;
+        u8 range_guid[16];
+        u64 address;
+        u64 length;
+        u64 memory_mapping;
+};
+
+/* Flags */
+
+#define ACPI_NFIT_ADD_ONLINE_ONLY       (1)     /* 00: Add/Online Operation Only */
+#define ACPI_NFIT_PROXIMITY_VALID       (1<<1)  /* 01: Proximity Domain Valid */
+
+/* Range Type GUIDs appear in the include/acuuid.h file */
+
+/* 1: Memory Device to System Address Range Map Structure */
+
+struct acpi_nfit_memory_map {
+        struct acpi_nfit_header header;
+        u32 device_handle;
+        u16 physical_id;
+        u16 region_id;
+        u16 range_index;
+        u16 region_index;
+        u64 region_size;
+        u64 region_offset;
+        u64 address;
+        u16 interleave_index;
+        u16 interleave_ways;
+        u16 flags;
+        u16 reserved;           /* Reserved, must be zero */
+};
+
+/* Flags */
+
+#define ACPI_NFIT_MEM_SAVE_FAILED       (1)     /* 00: Last SAVE to Memory Device failed */
+#define ACPI_NFIT_MEM_RESTORE_FAILED    (1<<1)  /* 01: Last RESTORE from Memory Device failed */
+#define ACPI_NFIT_MEM_FLUSH_FAILED      (1<<2)  /* 02: Platform flush failed */
+#define ACPI_NFIT_MEM_ARMED             (1<<3)  /* 03: Memory Device observed to be not armed */
+#define ACPI_NFIT_MEM_HEALTH_OBSERVED   (1<<4)  /* 04: Memory Device observed SMART/health events */
+#define ACPI_NFIT_MEM_HEALTH_ENABLED    (1<<5)  /* 05: SMART/health events enabled */
+
+/* 2: Interleave Structure */
+
+struct acpi_nfit_interleave {
+        struct acpi_nfit_header header;
+        u16 interleave_index;
+        u16 reserved;           /* Reserved, must be zero */
+        u32 line_count;
+        u32 line_size;
+        u32 line_offset[1];     /* Variable length */
+};
+
+/* 3: SMBIOS Management Information Structure */
+
+struct acpi_nfit_smbios {
+        struct acpi_nfit_header header;
+        u32 reserved;           /* Reserved, must be zero */
+        u8 data[1];             /* Variable length */
+};
+
+/* 4: NVDIMM Control Region Structure */
+
+struct acpi_nfit_control_region {
+        struct acpi_nfit_header header;
+        u16 region_index;
+        u16 vendor_id;
+        u16 device_id;
+        u16 revision_id;
+        u16 subsystem_vendor_id;
+        u16 subsystem_device_id;
+        u16 subsystem_revision_id;
+        u8 reserved[6];         /* Reserved, must be zero */
+        u32 serial_number;
+        u16 code;
+        u16 windows;
+        u64 window_size;
+        u64 command_offset;
+        u64 command_size;
+        u64 status_offset;
+        u64 status_size;
+        u16 flags;
+        u8 reserved1[6];        /* Reserved, must be zero */
+};
+
+/* Flags */
+
+#define ACPI_NFIT_CONTROL_BUFFERED      (1)     /* Block Data Windows implementation is buffered */
+
+/* 5: NVDIMM Block Data Window Region Structure */
+
+struct acpi_nfit_data_region {
+        struct acpi_nfit_header header;
+        u16 region_index;
+        u16 windows;
+        u64 offset;
+        u64 size;
+        u64 capacity;
+        u64 start_address;
+};
+
+/* 6: Flush Hint Address Structure */
+
+struct acpi_nfit_flush_address {
+        struct acpi_nfit_header header;
+        u32 device_handle;
+        u16 hint_count;
+        u8 reserved[6];         /* Reserved, must be zero */
+        u64 hint_address[1];    /* Variable length */
+};
+
+/*******************************************************************************
+ *
  * SBST - Smart Battery Specification Table
  *        Version 1
  *
diff --git a/include/acpi/actbl2.h b/include/acpi/actbl2.h
index cafdeb50fbdf..a948fc586b9b 100644
--- a/include/acpi/actbl2.h
+++ b/include/acpi/actbl2.h
@@ -51,8 +51,8 @@
  * These tables are not consumed directly by the ACPICA subsystem, but are
  * included here to support device drivers and the AML disassembler.
  *
- * The tables in this file are defined by third-party specifications, and are
- * not defined directly by the ACPI specification itself.
+ * Generally, the tables in this file are defined by third-party specifications,
+ * and are not defined directly by the ACPI specification itself.
  *
  ******************************************************************************/
 
@@ -69,6 +69,7 @@
 #define ACPI_SIG_DMAR           "DMAR"  /* DMA Remapping table */
 #define ACPI_SIG_HPET           "HPET"  /* High Precision Event Timer table */
 #define ACPI_SIG_IBFT           "IBFT"  /* iSCSI Boot Firmware Table */
+#define ACPI_SIG_IORT           "IORT"  /* IO Remapping Table */
 #define ACPI_SIG_IVRS           "IVRS"  /* I/O Virtualization Reporting Structure */
 #define ACPI_SIG_LPIT           "LPIT"  /* Low Power Idle Table */
 #define ACPI_SIG_MCFG           "MCFG"  /* PCI Memory Mapped Configuration table */
@@ -79,6 +80,7 @@
 #define ACPI_SIG_SPCR           "SPCR"  /* Serial Port Console Redirection table */
 #define ACPI_SIG_SPMI           "SPMI"  /* Server Platform Management Interface table */
 #define ACPI_SIG_TCPA           "TCPA"  /* Trusted Computing Platform Alliance table */
+#define ACPI_SIG_TPM2           "TPM2"  /* Trusted Platform Module 2.0 H/W interface table */
 #define ACPI_SIG_UEFI           "UEFI"  /* Uefi Boot Optimization Table */
 #define ACPI_SIG_VRTC           "VRTC"  /* Virtual Real Time Clock Table */
 #define ACPI_SIG_WAET           "WAET"  /* Windows ACPI Emulated devices Table */
@@ -650,6 +652,131 @@ struct acpi_ibft_target {
 
 /*******************************************************************************
  *
+ * IORT - IO Remapping Table
+ *
+ * Conforms to "IO Remapping Table System Software on ARM Platforms",
+ * Document number: ARM DEN 0049A, 2015
+ *
+ ******************************************************************************/
+
+struct acpi_table_iort {
+        struct acpi_table_header header;
+        u32 node_count;
+        u32 node_offset;
+        u32 reserved;
+};
+
+/*
+ * IORT subtables
+ */
+struct acpi_iort_node {
+        u8 type;
+        u16 length;
+        u8 revision;
+        u32 reserved;
+        u32 mapping_count;
+        u32 mapping_offset;
+        char node_data[1];
+};
+
+/* Values for subtable Type above */
+
+enum acpi_iort_node_type {
+        ACPI_IORT_NODE_ITS_GROUP = 0x00,
+        ACPI_IORT_NODE_NAMED_COMPONENT = 0x01,
+        ACPI_IORT_NODE_PCI_ROOT_COMPLEX = 0x02,
+        ACPI_IORT_NODE_SMMU = 0x03
+};
+
+struct acpi_iort_id_mapping {
+        u32 input_base;         /* Lowest value in input range */
+        u32 id_count;           /* Number of IDs */
+        u32 output_base;        /* Lowest value in output range */
+        u32 output_reference;   /* A reference to the output node */
+        u32 flags;
+};
+
+/* Masks for Flags field above for IORT subtable */
+
+#define ACPI_IORT_ID_SINGLE_MAPPING (1)
+
+struct acpi_iort_memory_access {
+        u32 cache_coherency;
+        u8 hints;
+        u16 reserved;
+        u8 memory_flags;
+};
+
+/* Values for cache_coherency field above */
+
+#define ACPI_IORT_NODE_COHERENT         0x00000001      /* The device node is fully coherent */
+#define ACPI_IORT_NODE_NOT_COHERENT     0x00000000      /* The device node is not coherent */
+
+/* Masks for Hints field above */
+
+#define ACPI_IORT_HT_TRANSIENT          (1)
+#define ACPI_IORT_HT_WRITE              (1<<1)
+#define ACPI_IORT_HT_READ               (1<<2)
+#define ACPI_IORT_HT_OVERRIDE           (1<<3)
+
+/* Masks for memory_flags field above */
+
+#define ACPI_IORT_MF_COHERENCY          (1)
+#define ACPI_IORT_MF_ATTRIBUTES         (1<<1)
+
+/*
+ * IORT node specific subtables
+ */
+struct acpi_iort_its_group {
+        u32 its_count;
+        u32 identifiers[1];     /* GIC ITS identifier arrary */
+};
+
+struct acpi_iort_named_component {
+        u32 node_flags;
+        u64 memory_properties;  /* Memory access properties */
+        u8 memory_address_limit;        /* Memory address size limit */
+        char device_name[1];    /* Path of namespace object */
+};
+
+struct acpi_iort_root_complex {
+        u64 memory_properties;  /* Memory access properties */
+        u32 ats_attribute;
+        u32 pci_segment_number;
+};
+
+/* Values for ats_attribute field above */
+
+#define ACPI_IORT_ATS_SUPPORTED         0x00000001      /* The root complex supports ATS */
+#define ACPI_IORT_ATS_UNSUPPORTED       0x00000000      /* The root complex doesn't support ATS */
+
+struct acpi_iort_smmu {
+        u64 base_address;       /* SMMU base address */
+        u64 span;               /* Length of memory range */
+        u32 model;
+        u32 flags;
+        u32 global_interrupt_offset;
+        u32 context_interrupt_count;
+        u32 context_interrupt_offset;
+        u32 pmu_interrupt_count;
+        u32 pmu_interrupt_offset;
+        u64 interrupts[1];      /* Interrupt array */
+};
+
+/* Values for Model field above */
+
+#define ACPI_IORT_SMMU_V1               0x00000000      /* Generic SMMUv1 */
+#define ACPI_IORT_SMMU_V2               0x00000001      /* Generic SMMUv2 */
+#define ACPI_IORT_SMMU_CORELINK_MMU400  0x00000002      /* ARM Corelink MMU-400 */
+#define ACPI_IORT_SMMU_CORELINK_MMU500  0x00000003      /* ARM Corelink MMU-500 */
+
+/* Masks for Flags field above */
+
+#define ACPI_IORT_SMMU_DVM_SUPPORTED    (1)
+#define ACPI_IORT_SMMU_COHERENT_WALK    (1<<1)
+
+/*******************************************************************************
+ *
  * IVRS - I/O Virtualization Reporting Structure
  *        Version 1
  *
@@ -824,7 +951,7 @@ struct acpi_ivrs_memory {
  *
  * LPIT - Low Power Idle Table
  *
- * Conforms to "ACPI Low Power Idle Table (LPIT) and _LPD Proposal (DRAFT)"
+ * Conforms to "ACPI Low Power Idle Table (LPIT)" July 2014.
  *
  ******************************************************************************/
 
@@ -846,8 +973,7 @@ struct acpi_lpit_header {
 
 enum acpi_lpit_type {
         ACPI_LPIT_TYPE_NATIVE_CSTATE = 0x00,
-        ACPI_LPIT_TYPE_SIMPLE_IO = 0x01,
-        ACPI_LPIT_TYPE_RESERVED = 0x02  /* 2 and above are reserved */
+        ACPI_LPIT_TYPE_RESERVED = 0x01  /* 1 and above are reserved */
 };
 
 /* Masks for Flags field above  */
@@ -870,21 +996,6 @@ struct acpi_lpit_native {
         u64 counter_frequency;
 };
 
-/* 0x01: Simple I/O based LPI structure */
-
-struct acpi_lpit_io {
-        struct acpi_lpit_header header;
-        struct acpi_generic_address entry_trigger;
-        u32 trigger_action;
-        u64 trigger_value;
-        u64 trigger_mask;
-        struct acpi_generic_address minimum_idle_state;
-        u32 residency;
-        u32 latency;
-        struct acpi_generic_address residency_counter;
-        u64 counter_frequency;
-};
-
 /*******************************************************************************
  *
  * MCFG - PCI Memory Mapped Configuration table and subtable
@@ -1069,20 +1180,85 @@ enum acpi_spmi_interface_types {
 /*******************************************************************************
  *
  * TCPA - Trusted Computing Platform Alliance table
- *        Version 1
+ *        Version 2
  *
- * Conforms to "TCG PC Specific Implementation Specification",
- * Version 1.1, August 18, 2003
+ * Conforms to "TCG ACPI Specification, Family 1.2 and 2.0",
+ * December 19, 2014
+ *
+ * NOTE: There are two versions of the table with the same signature --
+ * the client version and the server version.
  *
  ******************************************************************************/
 
-struct acpi_table_tcpa {
+struct acpi_table_tcpa_client {
+        struct acpi_table_header header;        /* Common ACPI table header */
+        u16 platform_class;
+        u32 minimum_log_length; /* Minimum length for the event log area */
+        u64 log_address;        /* Address of the event log area */
+};
+
+struct acpi_table_tcpa_server {
         struct acpi_table_header header;        /* Common ACPI table header */
+        u16 platform_class;
         u16 reserved;
-        u32 max_log_length;     /* Maximum length for the event log area */
+        u64 minimum_log_length; /* Minimum length for the event log area */
         u64 log_address;        /* Address of the event log area */
+        u16 spec_revision;
+        u8 device_flags;
+        u8 interrupt_flags;
+        u8 gpe_number;
+        u8 reserved2[3];
+        u32 global_interrupt;
+        struct acpi_generic_address address;
+        u32 reserved3;
+        struct acpi_generic_address config_address;
+        u8 group;
+        u8 bus;                 /* PCI Bus/Segment/Function numbers */
+        u8 device;
+        u8 function;
+};
+
+/* Values for device_flags above */
+
+#define ACPI_TCPA_PCI_DEVICE            (1)
+#define ACPI_TCPA_BUS_PNP               (1<<1)
+#define ACPI_TCPA_ADDRESS_VALID         (1<<2)
+
+/* Values for interrupt_flags above */
+
+#define ACPI_TCPA_INTERRUPT_MODE        (1)
+#define ACPI_TCPA_INTERRUPT_POLARITY    (1<<1)
+#define ACPI_TCPA_SCI_VIA_GPE           (1<<2)
+#define ACPI_TCPA_GLOBAL_INTERRUPT      (1<<3)
+
+/*******************************************************************************
+ *
+ * TPM2 - Trusted Platform Module (TPM) 2.0 Hardware Interface Table
+ *        Version 4
+ *
+ * Conforms to "TCG ACPI Specification, Family 1.2 and 2.0",
+ * December 19, 2014
+ *
+ ******************************************************************************/
+
+struct acpi_table_tpm2 {
+        struct acpi_table_header header;        /* Common ACPI table header */
+        u16 platform_class;
+        u16 reserved;
+        u64 control_address;
+        u32 start_method;
+
+        /* Platform-specific data follows */
 };
 
+/* Values for start_method above */
+
+#define ACPI_TPM2_NOT_ALLOWED                       0
+#define ACPI_TPM2_START_METHOD                      2
+#define ACPI_TPM2_MEMORY_MAPPED                     6
+#define ACPI_TPM2_COMMAND_BUFFER                    7
+#define ACPI_TPM2_COMMAND_BUFFER_WITH_START_METHOD  8
+
 /*******************************************************************************
  *
  * UEFI - UEFI Boot optimization Table
diff --git a/include/acpi/actbl3.h b/include/acpi/actbl3.h
index 440ca8104b43..1df891660f43 100644
--- a/include/acpi/actbl3.h
+++ b/include/acpi/actbl3.h
@@ -51,7 +51,8 @@
  * These tables are not consumed directly by the ACPICA subsystem, but are
  * included here to support device drivers and the AML disassembler.
  *
- * The tables in this file are fully defined within the ACPI specification.
+ * In general, the tables in this file are fully defined within the ACPI
+ * specification.
  *
  ******************************************************************************/
 
@@ -68,7 +69,9 @@
 #define ACPI_SIG_PCCT           "PCCT"  /* Platform Communications Channel Table */
 #define ACPI_SIG_PMTT           "PMTT"  /* Platform Memory Topology Table */
 #define ACPI_SIG_RASF           "RASF"  /* RAS Feature table */
-#define ACPI_SIG_TPM2           "TPM2"  /* Trusted Platform Module 2.0 H/W interface table */
+#define ACPI_SIG_STAO           "STAO"  /* Status Override table */
+#define ACPI_SIG_WPBT           "WPBT"  /* Windows Platform Binary Table */
+#define ACPI_SIG_XENV           "XENV"  /* Xen Environment table */
 
 #define ACPI_SIG_S3PT           "S3PT"  /* S3 Performance (sub)Table */
 #define ACPI_SIG_PCCS           "PCC"   /* PCC Shared Memory Region */
@@ -77,7 +80,6 @@
 
 #define ACPI_SIG_MATR           "MATR"  /* Memory Address Translation Table */
 #define ACPI_SIG_MSDM           "MSDM"  /* Microsoft Data Management Table */
-#define ACPI_SIG_WPBT           "WPBT"  /* Windows Platform Binary Table */
 
 /*
  * All tables must be byte-packed to match the ACPI specification, since
@@ -117,6 +119,8 @@ struct acpi_table_bgrt {
 /*******************************************************************************
  *
  * DRTM - Dynamic Root of Trust for Measurement table
+ * Conforms to "TCG D-RTM Architecture" June 17 2013, Version 1.0.0
+ * Table version 1
  *
  ******************************************************************************/
 
@@ -133,22 +137,40 @@ struct acpi_table_drtm {
         u32 flags;
 };
 
-/* 1) Validated Tables List */
+/* Flag Definitions for above */
+
+#define ACPI_DRTM_ACCESS_ALLOWED            (1)
+#define ACPI_DRTM_ENABLE_GAP_CODE           (1<<1)
+#define ACPI_DRTM_INCOMPLETE_MEASUREMENTS   (1<<2)
+#define ACPI_DRTM_AUTHORITY_ORDER           (1<<3)
+
+/* 1) Validated Tables List (64-bit addresses) */
 
-struct acpi_drtm_vtl_list {
-        u32 validated_table_list_count;
+struct acpi_drtm_vtable_list {
+        u32 validated_table_count;
+        u64 validated_tables[1];
 };
 
-/* 2) Resources List */
+/* 2) Resources List (of Resource Descriptors) */
+
+/* Resource Descriptor */
+
+struct acpi_drtm_resource {
+        u8 size[7];
+        u8 type;
+        u64 address;
+};
 
 struct acpi_drtm_resource_list {
-        u32 resource_list_count;
+        u32 resource_count;
+        struct acpi_drtm_resource resources[1];
 };
 
 /* 3) Platform-specific Identifiers List */
 
-struct acpi_drtm_id_list {
-        u32 id_list_count;
+struct acpi_drtm_dps_id {
+        u32 dps_id_length;
+        u8 dps_id[16];
 };
 
 /*******************************************************************************
@@ -685,32 +707,52 @@ enum acpi_rasf_status {
 
 /*******************************************************************************
  *
- * TPM2 - Trusted Platform Module (TPM) 2.0 Hardware Interface Table
- *        Version 3
+ * STAO - Status Override Table (_STA override) - ACPI 6.0
+ *        Version 1
  *
- * Conforms to "TPM 2.0 Hardware Interface Table (TPM2)" 29 November 2011
+ * Conforms to "ACPI Specification for Status Override Table"
+ * 6 January 2015
  *
  ******************************************************************************/
 
-struct acpi_table_tpm2 {
+struct acpi_table_stao {
         struct acpi_table_header header;        /* Common ACPI table header */
-        u32 flags;
-        u64 control_address;
-        u32 start_method;
+        u8 ignore_uart;
+};
+
+/*******************************************************************************
+ *
+ * WPBT - Windows Platform Environment Table (ACPI 6.0)
+ *        Version 1
+ *
+ * Conforms to "Windows Platform Binary Table (WPBT)" 29 November 2011
+ *
+ ******************************************************************************/
+
+struct acpi_table_wpbt {
+        struct acpi_table_header header;        /* Common ACPI table header */
+        u32 handoff_size;
+        u64 handoff_address;
+        u8 layout;
+        u8 type;
+        u16 arguments_length;
 };
 
-/* Control area structure (not part of table, pointed to by control_address) */
+/*******************************************************************************
+ *
+ * XENV - Xen Environment Table (ACPI 6.0)
+ *        Version 1
+ *
+ * Conforms to "ACPI Specification for Xen Environment Table" 4 January 2015
+ *
+ ******************************************************************************/
 
-struct acpi_tpm2_control {
-        u32 reserved;
-        u32 error;
-        u32 cancel;
-        u32 start;
-        u64 interrupt_control;
-        u32 command_size;
-        u64 command_address;
-        u32 response_size;
-        u64 response_address;
+struct acpi_table_xenv {
+        struct acpi_table_header header;        /* Common ACPI table header */
+        u64 grant_table_address;
+        u64 grant_table_size;
+        u32 event_interrupt;
+        u8 event_flags;
 };
 
 /* Reset to default packing */
diff --git a/include/acpi/actypes.h b/include/acpi/actypes.h
index 1c3002e1db20..c2a41d223162 100644
--- a/include/acpi/actypes.h
+++ b/include/acpi/actypes.h
@@ -471,11 +471,6 @@ typedef u8 acpi_owner_id;
 
 #define ACPI_INTEGER_BIT_SIZE           64
 #define ACPI_MAX_DECIMAL_DIGITS         20      /* 2^64 = 18,446,744,073,709,551,616 */
-
-#if ACPI_MACHINE_WIDTH == 64
-#define ACPI_USE_NATIVE_DIVIDE  /* Use compiler native 64-bit divide */
-#endif
-
 #define ACPI_MAX64_DECIMAL_DIGITS       20
 #define ACPI_MAX32_DECIMAL_DIGITS       10
 #define ACPI_MAX16_DECIMAL_DIGITS        5
@@ -530,6 +525,7 @@ typedef u64 acpi_integer;
 #define ACPI_CAST_PTR(t, p)             ((t *) (acpi_uintptr_t) (p))
 #define ACPI_CAST_INDIRECT_PTR(t, p)    ((t **) (acpi_uintptr_t) (p))
 #define ACPI_ADD_PTR(t, a, b)           ACPI_CAST_PTR (t, (ACPI_CAST_PTR (u8, (a)) + (acpi_size)(b)))
+#define ACPI_SUB_PTR(t, a, b)           ACPI_CAST_PTR (t, (ACPI_CAST_PTR (u8, (a)) - (acpi_size)(b)))
 #define ACPI_PTR_DIFF(a, b)             (acpi_size) (ACPI_CAST_PTR (u8, (a)) - ACPI_CAST_PTR (u8, (b)))
 
 /* Pointer/Integer type conversions */
@@ -546,14 +542,14 @@ typedef u64 acpi_integer;
 #define ACPI_COMPARE_NAME(a,b)          (*ACPI_CAST_PTR (u32, (a)) == *ACPI_CAST_PTR (u32, (b)))
 #define ACPI_MOVE_NAME(dest,src)        (*ACPI_CAST_PTR (u32, (dest)) = *ACPI_CAST_PTR (u32, (src)))
 #else
-#define ACPI_COMPARE_NAME(a,b)          (!ACPI_STRNCMP (ACPI_CAST_PTR (char, (a)), ACPI_CAST_PTR (char, (b)), ACPI_NAME_SIZE))
-#define ACPI_MOVE_NAME(dest,src)        (ACPI_STRNCPY (ACPI_CAST_PTR (char, (dest)), ACPI_CAST_PTR (char, (src)), ACPI_NAME_SIZE))
+#define ACPI_COMPARE_NAME(a,b)          (!strncmp (ACPI_CAST_PTR (char, (a)), ACPI_CAST_PTR (char, (b)), ACPI_NAME_SIZE))
+#define ACPI_MOVE_NAME(dest,src)        (strncpy (ACPI_CAST_PTR (char, (dest)), ACPI_CAST_PTR (char, (src)), ACPI_NAME_SIZE))
 #endif
 
 /* Support for the special RSDP signature (8 characters) */
 
-#define ACPI_VALIDATE_RSDP_SIG(a)       (!ACPI_STRNCMP (ACPI_CAST_PTR (char, (a)), ACPI_SIG_RSDP, 8))
-#define ACPI_MAKE_RSDP_SIG(dest)        (ACPI_MEMCPY (ACPI_CAST_PTR (char, (dest)), ACPI_SIG_RSDP, 8))
+#define ACPI_VALIDATE_RSDP_SIG(a)       (!strncmp (ACPI_CAST_PTR (char, (a)), ACPI_SIG_RSDP, 8))
+#define ACPI_MAKE_RSDP_SIG(dest)        (memcpy (ACPI_CAST_PTR (char, (dest)), ACPI_SIG_RSDP, 8))
 
 /*******************************************************************************
  *
@@ -572,6 +568,7 @@ typedef u64 acpi_integer;
 #define ACPI_NO_ACPI_ENABLE             0x10
 #define ACPI_NO_DEVICE_INIT             0x20
 #define ACPI_NO_OBJECT_INIT             0x40
+#define ACPI_NO_FACS_INIT               0x80
 
 /*
  * Initialization state
@@ -1144,6 +1141,10 @@ u32 (*acpi_interface_handler) (acpi_string interface_name, u32 supported);
 
 #define ACPI_UUID_LENGTH                16
 
+/* Length of 3-byte PCI class code values when converted back to a string */
+
+#define ACPI_PCICLS_STRING_SIZE         7       /* Includes null terminator */
+
 /* Structures used for device/processor HID, UID, CID, and SUB */
 
 struct acpi_pnp_device_id {
@@ -1166,7 +1167,7 @@ struct acpi_device_info {
         u32 name;               /* ACPI object Name */
         acpi_object_type type;  /* ACPI object Type */
         u8 param_count;         /* If a method, required parameter count */
-        u8 valid;               /* Indicates which optional fields are valid */
+        u16 valid;              /* Indicates which optional fields are valid */
         u8 flags;               /* Miscellaneous info */
         u8 highest_dstates[4];  /* _sx_d values: 0xFF indicates not valid */
         u8 lowest_dstates[5];   /* _sx_w values: 0xFF indicates not valid */
@@ -1175,6 +1176,7 @@ struct acpi_device_info {
         struct acpi_pnp_device_id hardware_id;  /* _HID value */
         struct acpi_pnp_device_id unique_id;    /* _UID value */
         struct acpi_pnp_device_id subsystem_id; /* _SUB value */
+        struct acpi_pnp_device_id class_code;   /* _CLS value */
         struct acpi_pnp_device_id_list compatible_id_list;      /* _CID list <must be last> */
 };
 
@@ -1184,14 +1186,15 @@ struct acpi_device_info {
 
 /* Flags for Valid field above (acpi_get_object_info) */
 
-#define ACPI_VALID_STA                  0x01
-#define ACPI_VALID_ADR                  0x02
-#define ACPI_VALID_HID                  0x04
-#define ACPI_VALID_UID                  0x08
-#define ACPI_VALID_SUB                  0x10
-#define ACPI_VALID_CID                  0x20
-#define ACPI_VALID_SXDS                 0x40
-#define ACPI_VALID_SXWS                 0x80
+#define ACPI_VALID_STA                  0x0001
+#define ACPI_VALID_ADR                  0x0002
+#define ACPI_VALID_HID                  0x0004
+#define ACPI_VALID_UID                  0x0008
+#define ACPI_VALID_SUB                  0x0010
+#define ACPI_VALID_CID                  0x0020
+#define ACPI_VALID_CLS                  0x0040
+#define ACPI_VALID_SXDS                 0x0100
+#define ACPI_VALID_SXWS                 0x0200
 
 /* Flags for _STA return value (current_status above) */
 
diff --git a/include/acpi/acuuid.h b/include/acpi/acuuid.h
new file mode 100644
index 000000000000..80fe8cf74d7a
--- /dev/null
+++ b/include/acpi/acuuid.h
@@ -0,0 +1,89 @@
+/******************************************************************************
+ *
+ * Name: acuuid.h - ACPI-related UUID/GUID definitions
+ *
+ *****************************************************************************/
+
+/*
+ * Copyright (C) 2000 - 2015, Intel Corp.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions, and the following disclaimer,
+ *    without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ *    substantially similar to the "NO WARRANTY" disclaimer below
+ *    ("Disclaimer") and any redistribution must be conditioned upon
+ *    including a substantially similar Disclaimer requirement for further
+ *    binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ *    of any contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#ifndef __ACUUID_H__
+#define __ACUUID_H__
+
+/*
+ * Note1: UUIDs and GUIDs are defined to be identical in ACPI.
+ *
+ * Note2: This file is standalone and should remain that way.
+ */
+
+/* Controllers */
+
+#define UUID_GPIO_CONTROLLER            "4f248f40-d5e2-499f-834c-27758ea1cd3f"
+#define UUID_USB_CONTROLLER             "ce2ee385-00e6-48cb-9f05-2edb927c4899"
+#define UUID_SATA_CONTROLLER            "e4db149b-fcfe-425b-a6d8-92357d78fc7f"
+
+/* Devices */
+
+#define UUID_PCI_HOST_BRIDGE            "33db4d5b-1ff7-401c-9657-7441c03dd766"
+#define UUID_I2C_DEVICE                 "3cdff6f7-4267-4555-ad05-b30a3d8938de"
+#define UUID_POWER_BUTTON               "dfbcf3c5-e7a5-44e6-9c1f-29c76f6e059c"
+
+/* Interfaces */
+
+#define UUID_DEVICE_LABELING            "e5c937d0-3553-4d7a-9117-ea4d19c3434d"
+#define UUID_PHYSICAL_PRESENCE          "3dddfaa6-361b-4eb4-a424-8d10089d1653"
+
+/* NVDIMM - NFIT table */
+
+#define UUID_VOLATILE_MEMORY            "7305944f-fdda-44e3-b16c-3f22d252e5d0"
+#define UUID_PERSISTENT_MEMORY          "66f0d379-b4f3-4074-ac43-0d3318b78cdb"
+#define UUID_CONTROL_REGION             "92f701f6-13b4-405d-910b-299367e8234c"
+#define UUID_DATA_REGION                "91af0530-5d86-470e-a6b0-0a2db9408249"
+#define UUID_VOLATILE_VIRTUAL_DISK      "77ab535a-45fc-624b-5560-f7b281d1f96e"
+#define UUID_VOLATILE_VIRTUAL_CD        "3d5abd30-4175-87ce-6d64-d2ade523c4bb"
+#define UUID_PERSISTENT_VIRTUAL_DISK    "5cea02c9-4d07-69d3-269f-4496fbe096f9"
+#define UUID_PERSISTENT_VIRTUAL_CD      "08018188-42cd-bb48-100f-5387d53ded3d"
+
+/* Miscellaneous */
+
+#define UUID_PLATFORM_CAPABILITIES      "0811b06e-4a27-44f9-8d60-3cbbc22e7b48"
+#define UUID_DYNAMIC_ENUMERATION        "d8c1a3a6-be9b-4c9b-91bf-c3cb81fc5daf"
+#define UUID_BATTERY_THERMAL_LIMIT      "4c2067e3-887d-475c-9720-4af1d3ed602e"
+#define UUID_THERMAL_EXTENSIONS         "14d399cd-7a27-4b18-8fb4-7cb7b9f4e500"
+#define UUID_DEVICE_PROPERTIES          "daffd814-6eba-4d8c-8a91-bc9bbf4aa301"
+
+#endif                          /* __AUUID_H__ */
diff --git a/include/acpi/platform/acenv.h b/include/acpi/platform/acenv.h
index ecdf9405dd3a..3cedd43943f4 100644
--- a/include/acpi/platform/acenv.h
+++ b/include/acpi/platform/acenv.h
@@ -175,6 +175,9 @@
 #elif defined(_APPLE) || defined(__APPLE__)
 #include "acmacosx.h"
 
+#elif defined(__DragonFly__)
+#include "acdragonfly.h"
+
 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
 #include "acfreebsd.h"
 
@@ -343,29 +346,6 @@
 
 /* We will be linking to the standard Clib functions */
 
-#define ACPI_STRSTR(s1,s2)      strstr((s1), (s2))
-#define ACPI_STRCHR(s1,c)       strchr((s1), (c))
-#define ACPI_STRLEN(s)          (acpi_size) strlen((s))
-#define ACPI_STRCPY(d,s)        (void) strcpy((d), (s))
-#define ACPI_STRNCPY(d,s,n)     (void) strncpy((d), (s), (acpi_size)(n))
-#define ACPI_STRNCMP(d,s,n)     strncmp((d), (s), (acpi_size)(n))
-#define ACPI_STRCMP(d,s)        strcmp((d), (s))
-#define ACPI_STRCAT(d,s)        (void) strcat((d), (s))
-#define ACPI_STRNCAT(d,s,n)     strncat((d), (s), (acpi_size)(n))
-#define ACPI_STRTOUL(d,s,n)     strtoul((d), (s), (acpi_size)(n))
-#define ACPI_MEMCMP(s1,s2,n)    memcmp((const char *)(s1), (const char *)(s2), (acpi_size)(n))
-#define ACPI_MEMCPY(d,s,n)      (void) memcpy((d), (s), (acpi_size)(n))
-#define ACPI_MEMSET(d,s,n)      (void) memset((d), (s), (acpi_size)(n))
-
-#define ACPI_TOUPPER(i)         toupper((int) (i))
-#define ACPI_TOLOWER(i)         tolower((int) (i))
-#define ACPI_IS_XDIGIT(i)       isxdigit((int) (i))
-#define ACPI_IS_DIGIT(i)        isdigit((int) (i))
-#define ACPI_IS_SPACE(i)        isspace((int) (i))
-#define ACPI_IS_UPPER(i)        isupper((int) (i))
-#define ACPI_IS_PRINT(i)        isprint((int) (i))
-#define ACPI_IS_ALPHA(i)        isalpha((int) (i))
-
 #else
 
 /******************************************************************************
@@ -403,22 +383,6 @@ typedef char *va_list;
 
 /* Use the local (ACPICA) definitions of the clib functions */
 
-#define ACPI_STRSTR(s1,s2)      acpi_ut_strstr ((s1), (s2))
-#define ACPI_STRCHR(s1,c)       acpi_ut_strchr ((s1), (c))
-#define ACPI_STRLEN(s)          (acpi_size) acpi_ut_strlen ((s))
-#define ACPI_STRCPY(d,s)        (void) acpi_ut_strcpy ((d), (s))
-#define ACPI_STRNCPY(d,s,n)     (void) acpi_ut_strncpy ((d), (s), (acpi_size)(n))
-#define ACPI_STRNCMP(d,s,n)     acpi_ut_strncmp ((d), (s), (acpi_size)(n))
-#define ACPI_STRCMP(d,s)        acpi_ut_strcmp ((d), (s))
-#define ACPI_STRCAT(d,s)        (void) acpi_ut_strcat ((d), (s))
-#define ACPI_STRNCAT(d,s,n)     acpi_ut_strncat ((d), (s), (acpi_size)(n))
-#define ACPI_STRTOUL(d,s,n)     acpi_ut_strtoul ((d), (s), (acpi_size)(n))
-#define ACPI_MEMCMP(s1,s2,n)    acpi_ut_memcmp((const char *)(s1), (const char *)(s2), (acpi_size)(n))
-#define ACPI_MEMCPY(d,s,n)      (void) acpi_ut_memcpy ((d), (s), (acpi_size)(n))
-#define ACPI_MEMSET(d,v,n)      (void) acpi_ut_memset ((d), (v), (acpi_size)(n))
-#define ACPI_TOUPPER(c)         acpi_ut_to_upper ((int) (c))
-#define ACPI_TOLOWER(c)         acpi_ut_to_lower ((int) (c))
-
 #endif                          /* ACPI_USE_SYSTEM_CLIBRARY */
 
 #ifndef ACPI_FILE
diff --git a/include/acpi/platform/acenvex.h b/include/acpi/platform/acenvex.h
index 71e5ec5b07a3..0a7dc8e583b1 100644
--- a/include/acpi/platform/acenvex.h
+++ b/include/acpi/platform/acenvex.h
@@ -56,6 +56,15 @@
 #if defined(_LINUX) || defined(__linux__)
 #include <acpi/platform/aclinuxex.h>
 
+#elif defined(_AED_EFI)
+#include "acefiex.h"
+
+#elif defined(_GNU_EFI)
+#include "acefiex.h"
+
+#elif defined(__DragonFly__)
+#include "acdragonflyex.h"
+
 #endif
 
 /*! [End] no source code translation !*/
diff --git a/include/acpi/platform/acgcc.h b/include/acpi/platform/acgcc.h
index f54de0a63558..5457a06cb528 100644
--- a/include/acpi/platform/acgcc.h
+++ b/include/acpi/platform/acgcc.h
@@ -75,4 +75,8 @@
 #undef strchr
 #endif
 
+/* GCC supports __VA_ARGS__ in macros */
+
+#define COMPILER_VA_MACRO               1
+
 #endif                          /* __ACGCC_H__ */
diff --git a/include/acpi/video.h b/include/acpi/video.h
index 843ef1adfbfa..e840b294c6f5 100644
--- a/include/acpi/video.h
+++ b/include/acpi/video.h
@@ -16,23 +16,36 @@ struct acpi_device;
 #define ACPI_VIDEO_DISPLAY_LEGACY_PANEL   0x0110
 #define ACPI_VIDEO_DISPLAY_LEGACY_TV      0x0200
 
+enum acpi_backlight_type {
+        acpi_backlight_undef = -1,
+        acpi_backlight_none = 0,
+        acpi_backlight_video,
+        acpi_backlight_vendor,
+        acpi_backlight_native,
+};
+
 #if (defined CONFIG_ACPI_VIDEO || defined CONFIG_ACPI_VIDEO_MODULE)
 extern int acpi_video_register(void);
 extern void acpi_video_unregister(void);
-extern void acpi_video_unregister_backlight(void);
 extern int acpi_video_get_edid(struct acpi_device *device, int type,
                                int device_id, void **edid);
-extern bool acpi_video_verify_backlight_support(void);
+extern enum acpi_backlight_type acpi_video_get_backlight_type(void);
+extern void acpi_video_set_dmi_backlight_type(enum acpi_backlight_type type);
 #else
 static inline int acpi_video_register(void) { return 0; }
 static inline void acpi_video_unregister(void) { return; }
-static inline void acpi_video_unregister_backlight(void) { return; }
 static inline int acpi_video_get_edid(struct acpi_device *device, int type,
                                       int device_id, void **edid)
 {
         return -ENODEV;
 }
-static inline bool acpi_video_verify_backlight_support(void) { return false; }
+static inline enum acpi_backlight_type acpi_video_get_backlight_type(void)
+{
+        return acpi_backlight_vendor;
+}
+static inline void acpi_video_set_dmi_backlight_type(enum acpi_backlight_type type)
+{
+}
 #endif
 
 #endif
diff --git a/include/asm-generic/asm-offsets.h b/include/asm-generic/asm-offsets.h
new file mode 100644
index 000000000000..d370ee36a182
--- /dev/null
+++ b/include/asm-generic/asm-offsets.h
@@ -0,0 +1 @@
+#include <generated/asm-offsets.h>
diff --git a/include/asm-generic/barrier.h b/include/asm-generic/barrier.h
index e6a83d712ef6..55e3abc2d027 100644
--- a/include/asm-generic/barrier.h
+++ b/include/asm-generic/barrier.h
@@ -55,17 +55,43 @@
 #endif
 
 #ifdef CONFIG_SMP
+
+#ifndef smp_mb
 #define smp_mb()        mb()
+#endif
+
+#ifndef smp_rmb
 #define smp_rmb()       rmb()
+#endif
+
+#ifndef smp_wmb
 #define smp_wmb()       wmb()
+#endif
+
+#ifndef smp_read_barrier_depends
 #define smp_read_barrier_depends()      read_barrier_depends()
-#else
+#endif
+
+#else   /* !CONFIG_SMP */
+
+#ifndef smp_mb
 #define smp_mb()        barrier()
+#endif
+
+#ifndef smp_rmb
 #define smp_rmb()       barrier()
+#endif
+
+#ifndef smp_wmb
 #define smp_wmb()       barrier()
+#endif
+
+#ifndef smp_read_barrier_depends
 #define smp_read_barrier_depends()      do { } while (0)
 #endif
 
+#endif  /* CONFIG_SMP */
+
 #ifndef smp_store_mb
 #define smp_store_mb(var, value)  do { WRITE_ONCE(var, value); mb(); } while (0)
 #endif
diff --git a/include/asm-generic/mm-arch-hooks.h b/include/asm-generic/mm-arch-hooks.h
new file mode 100644
index 000000000000..5ff0e5193f85
--- /dev/null
+++ b/include/asm-generic/mm-arch-hooks.h
@@ -0,0 +1,16 @@
+/*
+ * Architecture specific mm hooks
+ */
+
+#ifndef _ASM_GENERIC_MM_ARCH_HOOKS_H
+#define _ASM_GENERIC_MM_ARCH_HOOKS_H
+
+/*
+ * This file should be included through arch/../include/asm/Kbuild for
+ * the architecture which doesn't need specific mm hooks.
+ *
+ * In that case, the generic hooks defined in include/linux/mm-arch-hooks.h
+ * are used.
+ */
+
+#endif /* _ASM_GENERIC_MM_ARCH_HOOKS_H */
diff --git a/include/asm-generic/pgtable.h b/include/asm-generic/pgtable.h
index bd910ceaccfa..29c57b2cb344 100644
--- a/include/asm-generic/pgtable.h
+++ b/include/asm-generic/pgtable.h
@@ -96,11 +96,11 @@ static inline pte_t ptep_get_and_clear(struct mm_struct *mm,
 }
 #endif
 
-#ifndef __HAVE_ARCH_PMDP_GET_AND_CLEAR
+#ifndef __HAVE_ARCH_PMDP_HUGE_GET_AND_CLEAR
 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
-static inline pmd_t pmdp_get_and_clear(struct mm_struct *mm,
-                                       unsigned long address,
-                                       pmd_t *pmdp)
+static inline pmd_t pmdp_huge_get_and_clear(struct mm_struct *mm,
+                                            unsigned long address,
+                                            pmd_t *pmdp)
 {
         pmd_t pmd = *pmdp;
         pmd_clear(pmdp);
@@ -109,13 +109,13 @@ static inline pmd_t pmdp_get_and_clear(struct mm_struct *mm,
 #endif /* CONFIG_TRANSPARENT_HUGEPAGE */
 #endif
 
-#ifndef __HAVE_ARCH_PMDP_GET_AND_CLEAR_FULL
+#ifndef __HAVE_ARCH_PMDP_HUGE_GET_AND_CLEAR_FULL
 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
-static inline pmd_t pmdp_get_and_clear_full(struct mm_struct *mm,
+static inline pmd_t pmdp_huge_get_and_clear_full(struct mm_struct *mm,
                                             unsigned long address, pmd_t *pmdp,
                                             int full)
 {
-        return pmdp_get_and_clear(mm, address, pmdp);
+        return pmdp_huge_get_and_clear(mm, address, pmdp);
 }
 #endif /* CONFIG_TRANSPARENT_HUGEPAGE */
 #endif
@@ -152,8 +152,8 @@ extern pte_t ptep_clear_flush(struct vm_area_struct *vma,
                               pte_t *ptep);
 #endif
 
-#ifndef __HAVE_ARCH_PMDP_CLEAR_FLUSH
-extern pmd_t pmdp_clear_flush(struct vm_area_struct *vma,
+#ifndef __HAVE_ARCH_PMDP_HUGE_CLEAR_FLUSH
+extern pmd_t pmdp_huge_clear_flush(struct vm_area_struct *vma,
                               unsigned long address,
                               pmd_t *pmdp);
 #endif
@@ -189,6 +189,22 @@ extern void pmdp_splitting_flush(struct vm_area_struct *vma,
                                  unsigned long address, pmd_t *pmdp);
 #endif
 
+#ifndef pmdp_collapse_flush
+#ifdef CONFIG_TRANSPARENT_HUGEPAGE
+extern pmd_t pmdp_collapse_flush(struct vm_area_struct *vma,
+                                 unsigned long address, pmd_t *pmdp);
+#else
+static inline pmd_t pmdp_collapse_flush(struct vm_area_struct *vma,
+                                        unsigned long address,
+                                        pmd_t *pmdp)
+{
+        BUILD_BUG();
+        return *pmdp;
+}
+#define pmdp_collapse_flush pmdp_collapse_flush
+#endif /* CONFIG_TRANSPARENT_HUGEPAGE */
+#endif
+
 #ifndef __HAVE_ARCH_PGTABLE_DEPOSIT
 extern void pgtable_trans_huge_deposit(struct mm_struct *mm, pmd_t *pmdp,
                                        pgtable_t pgtable);
diff --git a/include/asm-generic/scatterlist.h b/include/asm-generic/scatterlist.h
deleted file mode 100644
index 5de07355fad4..000000000000
--- a/include/asm-generic/scatterlist.h
+++ /dev/null
@@ -1,34 +0,0 @@
-#ifndef __ASM_GENERIC_SCATTERLIST_H
-#define __ASM_GENERIC_SCATTERLIST_H
-
-#include <linux/types.h>
-
-struct scatterlist {
-#ifdef CONFIG_DEBUG_SG
-        unsigned long   sg_magic;
-#endif
-        unsigned long   page_link;
-        unsigned int    offset;
-        unsigned int    length;
-        dma_addr_t      dma_address;
-#ifdef CONFIG_NEED_SG_DMA_LENGTH
-        unsigned int    dma_length;
-#endif
-};
-
-/*
- * These macros should be used after a dma_map_sg call has been done
- * to get bus addresses of each of the SG entries and their lengths.
- * You should only work with the number of sg entries pci_map_sg
- * returns, or alternatively stop on the first sg_dma_len(sg) which
- * is 0.
- */
-#define sg_dma_address(sg)      ((sg)->dma_address)
-
-#ifdef CONFIG_NEED_SG_DMA_LENGTH
-#define sg_dma_len(sg)          ((sg)->dma_length)
-#else
-#define sg_dma_len(sg)          ((sg)->length)
-#endif
-
-#endif /* __ASM_GENERIC_SCATTERLIST_H */
diff --git a/include/clocksource/timer-sp804.h b/include/clocksource/timer-sp804.h
new file mode 100644
index 000000000000..1f8a1caa7cb4
--- /dev/null
+++ b/include/clocksource/timer-sp804.h
@@ -0,0 +1,28 @@
+#ifndef __CLKSOURCE_TIMER_SP804_H
+#define __CLKSOURCE_TIMER_SP804_H
+
+struct clk;
+
+void __sp804_clocksource_and_sched_clock_init(void __iomem *,
+                                              const char *, struct clk *, int);
+void __sp804_clockevents_init(void __iomem *, unsigned int,
+                              struct clk *, const char *);
+void sp804_timer_disable(void __iomem *);
+
+static inline void sp804_clocksource_init(void __iomem *base, const char *name)
+{
+        __sp804_clocksource_and_sched_clock_init(base, name, NULL, 0);
+}
+
+static inline void sp804_clocksource_and_sched_clock_init(void __iomem *base,
+                                                          const char *name)
+{
+        __sp804_clocksource_and_sched_clock_init(base, name, NULL, 1);
+}
+
+static inline void sp804_clockevents_init(void __iomem *base, unsigned int irq, const char *name)
+{
+        __sp804_clockevents_init(base, irq, NULL, name);
+
+}
+#endif
diff --git a/include/drm/bridge/ptn3460.h b/include/drm/bridge/ptn3460.h
deleted file mode 100644
index b11f8e17e72f..000000000000
--- a/include/drm/bridge/ptn3460.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright (C) 2013 Google, Inc.
- *
- * This software is licensed under the terms of the GNU General Public
- * License version 2, as published by the Free Software Foundation, and
- * may be copied, distributed, and modified under those terms.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- */
-
-#ifndef _DRM_BRIDGE_PTN3460_H_
-#define _DRM_BRIDGE_PTN3460_H_
-
-struct drm_device;
-struct drm_bridge;
-struct drm_encoder;
-struct i2c_client;
-struct device_node;
-
-#if defined(CONFIG_DRM_PTN3460) || defined(CONFIG_DRM_PTN3460_MODULE)
-
-int ptn3460_init(struct drm_device *dev, struct drm_encoder *encoder,
-                struct i2c_client *client, struct device_node *node);
-
-void ptn3460_destroy(struct drm_bridge *bridge);
-
-#else
-
-static inline int ptn3460_init(struct drm_device *dev,
-                struct drm_encoder *encoder, struct i2c_client *client,
-                struct device_node *node)
-{
-        return 0;
-}
-
-static inline void ptn3460_destroy(struct drm_bridge *bridge)
-{
-}
-
-#endif
-
-#endif
diff --git a/include/drm/drmP.h b/include/drm/drmP.h
index 62c40777c009..5aa519711e0b 100644
--- a/include/drm/drmP.h
+++ b/include/drm/drmP.h
@@ -326,6 +326,10 @@ struct drm_file {
         struct list_head fbs;
         struct mutex fbs_lock;
 
+        /** User-created blob properties; this retains a reference on the
+         *  property. */
+        struct list_head blobs;
+
         wait_queue_head_t event_wait;
         struct list_head event_list;
         int event_space;
@@ -355,8 +359,7 @@ struct drm_lock_data {
  * @minor: Link back to minor char device we are master for. Immutable.
  * @unique: Unique identifier: e.g. busid. Protected by drm_global_mutex.
  * @unique_len: Length of unique field. Protected by drm_global_mutex.
- * @magiclist: Hash of used authentication tokens. Protected by struct_mutex.
- * @magicfree: List of used authentication tokens. Protected by struct_mutex.
+ * @magic_map: Map of used authentication tokens. Protected by struct_mutex.
  * @lock: DRI lock information.
  * @driver_priv: Pointer to driver-private information.
  */
@@ -365,8 +368,7 @@ struct drm_master {
         struct drm_minor *minor;
         char *unique;
         int unique_len;
-        struct drm_open_hash magiclist;
-        struct list_head magicfree;
+        struct idr magic_map;
         struct drm_lock_data lock;
         void *driver_priv;
 };
@@ -686,9 +688,13 @@ struct drm_pending_vblank_event {
 struct drm_vblank_crtc {
         struct drm_device *dev;         /* pointer to the drm_device */
         wait_queue_head_t queue;        /**< VBLANK wait queue */
-        struct timeval time[DRM_VBLANKTIME_RBSIZE];     /**< timestamp of current count */
         struct timer_list disable_timer;                /* delayed disable timer */
-        atomic_t count;                 /**< number of VBLANK interrupts */
+
+        /* vblank counter, protected by dev->vblank_time_lock for writes */
+        u32 count;
+        /* vblank timestamps, protected by dev->vblank_time_lock for writes */
+        struct timeval time[DRM_VBLANKTIME_RBSIZE];
+
         atomic_t refcount;              /* number of users of vblank interruptsper crtc */
         u32 last;                       /* protected by dev->vbl_lock, used */
                                         /* for wraparound handling */
@@ -812,6 +818,7 @@ struct drm_device {
 #endif
 
         struct platform_device *platformdev; /**< Platform device struture */
+        struct virtio_device *virtdev;
 
         struct drm_sg_mem *sg;  /**< Scatter gather memory */
         unsigned int num_crtcs;                  /**< Number of CRTCs on this device */
diff --git a/include/drm/drm_atomic.h b/include/drm/drm_atomic.h
index c157103492b0..8a3a913320eb 100644
--- a/include/drm/drm_atomic.h
+++ b/include/drm/drm_atomic.h
@@ -35,6 +35,11 @@ drm_atomic_state_alloc(struct drm_device *dev);
 void drm_atomic_state_clear(struct drm_atomic_state *state);
 void drm_atomic_state_free(struct drm_atomic_state *state);
 
+int  __must_check
+drm_atomic_state_init(struct drm_device *dev, struct drm_atomic_state *state);
+void drm_atomic_state_default_clear(struct drm_atomic_state *state);
+void drm_atomic_state_default_release(struct drm_atomic_state *state);
+
 struct drm_crtc_state * __must_check
 drm_atomic_get_crtc_state(struct drm_atomic_state *state,
                           struct drm_crtc *crtc);
@@ -54,6 +59,62 @@ int drm_atomic_connector_set_property(struct drm_connector *connector,
                 struct drm_connector_state *state, struct drm_property *property,
                 uint64_t val);
 
+/**
+ * drm_atomic_get_existing_crtc_state - get crtc state, if it exists
+ * @state: global atomic state object
+ * @crtc: crtc to grab
+ *
+ * This function returns the crtc state for the given crtc, or NULL
+ * if the crtc is not part of the global atomic state.
+ */
+static inline struct drm_crtc_state *
+drm_atomic_get_existing_crtc_state(struct drm_atomic_state *state,
+                                   struct drm_crtc *crtc)
+{
+        return state->crtc_states[drm_crtc_index(crtc)];
+}
+
+/**
+ * drm_atomic_get_existing_plane_state - get plane state, if it exists
+ * @state: global atomic state object
+ * @plane: plane to grab
+ *
+ * This function returns the plane state for the given plane, or NULL
+ * if the plane is not part of the global atomic state.
+ */
+static inline struct drm_plane_state *
+drm_atomic_get_existing_plane_state(struct drm_atomic_state *state,
+                                    struct drm_plane *plane)
+{
+        return state->plane_states[drm_plane_index(plane)];
+}
+
+/**
+ * drm_atomic_get_existing_connector_state - get connector state, if it exists
+ * @state: global atomic state object
+ * @connector: connector to grab
+ *
+ * This function returns the connector state for the given connector,
+ * or NULL if the connector is not part of the global atomic state.
+ */
+static inline struct drm_connector_state *
+drm_atomic_get_existing_connector_state(struct drm_atomic_state *state,
+                                        struct drm_connector *connector)
+{
+        int index = drm_connector_index(connector);
+
+        if (index >= state->num_connector)
+                return NULL;
+
+        return state->connector_states[index];
+}
+
+int __must_check
+drm_atomic_set_mode_for_crtc(struct drm_crtc_state *state,
+                             struct drm_display_mode *mode);
+int __must_check
+drm_atomic_set_mode_prop_for_crtc(struct drm_crtc_state *state,
+                                  struct drm_property_blob *blob);
 int __must_check
 drm_atomic_set_crtc_for_plane(struct drm_plane_state *plane_state,
                               struct drm_crtc *crtc);
@@ -65,6 +126,10 @@ drm_atomic_set_crtc_for_connector(struct drm_connector_state *conn_state,
 int __must_check
 drm_atomic_add_affected_connectors(struct drm_atomic_state *state,
                                    struct drm_crtc *crtc);
+int __must_check
+drm_atomic_add_affected_planes(struct drm_atomic_state *state,
+                               struct drm_crtc *crtc);
+
 int
 drm_atomic_connectors_for_crtc(struct drm_atomic_state *state,
                                struct drm_crtc *crtc);
@@ -77,26 +142,32 @@ int __must_check drm_atomic_async_commit(struct drm_atomic_state *state);
 
 #define for_each_connector_in_state(state, connector, connector_state, __i) \
         for ((__i) = 0;                                                 \
-             (connector) = (state)->connectors[__i],                    \
-             (connector_state) = (state)->connector_states[__i],        \
-             (__i) < (state)->num_connector;                            \
+             (__i) < (state)->num_connector &&                          \
+             ((connector) = (state)->connectors[__i],                   \
+             (connector_state) = (state)->connector_states[__i], 1);    \
              (__i)++)                                                   \
                 if (connector)
 
 #define for_each_crtc_in_state(state, crtc, crtc_state, __i)    \
         for ((__i) = 0;                                         \
-             (crtc) = (state)->crtcs[__i],                      \
-             (crtc_state) = (state)->crtc_states[__i],          \
-             (__i) < (state)->dev->mode_config.num_crtc;        \
+             (__i) < (state)->dev->mode_config.num_crtc &&      \
+             ((crtc) = (state)->crtcs[__i],                     \
+             (crtc_state) = (state)->crtc_states[__i], 1);      \
              (__i)++)                                           \
                 if (crtc_state)
 
-#define for_each_plane_in_state(state, plane, plane_state, __i) \
-        for ((__i) = 0;                                         \
-             (plane) = (state)->planes[__i],                    \
-             (plane_state) = (state)->plane_states[__i],        \
-             (__i) < (state)->dev->mode_config.num_total_plane; \
-             (__i)++)                                           \
+#define for_each_plane_in_state(state, plane, plane_state, __i)         \
+        for ((__i) = 0;                                                 \
+             (__i) < (state)->dev->mode_config.num_total_plane &&       \
+             ((plane) = (state)->planes[__i],                           \
+             (plane_state) = (state)->plane_states[__i], 1);            \
+             (__i)++)                                                   \
                 if (plane_state)
+static inline bool
+drm_atomic_crtc_needs_modeset(struct drm_crtc_state *state)
+{
+        return state->mode_changed || state->active_changed;
+}
+
 
 #endif /* DRM_ATOMIC_H_ */
diff --git a/include/drm/drm_atomic_helper.h b/include/drm/drm_atomic_helper.h
index d665781eb542..cc1fee8a12d0 100644
--- a/include/drm/drm_atomic_helper.h
+++ b/include/drm/drm_atomic_helper.h
@@ -43,6 +43,10 @@ int drm_atomic_helper_commit(struct drm_device *dev,
 void drm_atomic_helper_wait_for_vblanks(struct drm_device *dev,
                                         struct drm_atomic_state *old_state);
 
+void
+drm_atomic_helper_update_legacy_modeset_state(struct drm_device *dev,
+                                              struct drm_atomic_state *old_state);
+
 void drm_atomic_helper_commit_modeset_disables(struct drm_device *dev,
                                                struct drm_atomic_state *state);
 void drm_atomic_helper_commit_modeset_enables(struct drm_device *dev,
@@ -54,6 +58,7 @@ void drm_atomic_helper_commit_planes(struct drm_device *dev,
                                      struct drm_atomic_state *state);
 void drm_atomic_helper_cleanup_planes(struct drm_device *dev,
                                       struct drm_atomic_state *old_state);
+void drm_atomic_helper_commit_planes_on_crtc(struct drm_crtc_state *old_crtc_state);
 
 void drm_atomic_helper_swap_state(struct drm_device *dev,
                                   struct drm_atomic_state *state);
diff --git a/include/drm/drm_crtc.h b/include/drm/drm_crtc.h
index ca71c03143d1..57ca8cc383a6 100644
--- a/include/drm/drm_crtc.h
+++ b/include/drm/drm_crtc.h
@@ -216,7 +216,10 @@ struct drm_framebuffer {
 
 struct drm_property_blob {
         struct drm_mode_object base;
-        struct list_head head;
+        struct drm_device *dev;
+        struct kref refcount;
+        struct list_head head_global;
+        struct list_head head_file;
         size_t length;
         unsigned char data[];
 };
@@ -296,6 +299,9 @@ struct drm_crtc_state {
 
         struct drm_display_mode mode;
 
+        /* blob property to expose current mode to atomic userspace */
+        struct drm_property_blob *mode_blob;
+
         struct drm_pending_vblank_event *event;
 
         struct drm_atomic_state *state;
@@ -647,6 +653,7 @@ struct drm_encoder {
  * @audio_latency: audio latency info from ELD, if found
  * @null_edid_counter: track sinks that give us all zeros for the EDID
  * @bad_edid_counter: track sinks that give us an EDID with invalid checksum
+ * @edid_corrupt: indicates whether the last read EDID was corrupt
  * @debugfs_entry: debugfs directory for this connector
  * @state: current atomic state for this connector
  * @has_tile: is this connector connected to a tiled monitor
@@ -719,6 +726,11 @@ struct drm_connector {
         int null_edid_counter; /* needed to workaround some HW bugs where we get all 0s */
         unsigned bad_edid_counter;
 
+        /* Flag for raw EDID header corruption - used in Displayport
+         * compliance testing - * Displayport Link CTS Core 1.2 rev1.1 4.2.2.6
+         */
+        bool edid_corrupt;
+
         struct dentry *debugfs_entry;
 
         struct drm_connector_state *state;
@@ -731,6 +743,8 @@ struct drm_connector {
         uint8_t num_h_tile, num_v_tile;
         uint8_t tile_h_loc, tile_v_loc;
         uint16_t tile_h_size, tile_v_size;
+
+        struct list_head destroy_list;
 };
 
 /**
@@ -895,6 +909,8 @@ struct drm_bridge_funcs {
 /**
  * struct drm_bridge - central DRM bridge control structure
  * @dev: DRM device this bridge belongs to
+ * @encoder: encoder to which this bridge is connected
+ * @next: the next bridge in the encoder chain
  * @of_node: device node pointer to the bridge
  * @list: to keep track of all added bridges
  * @base: base mode object
@@ -904,6 +920,7 @@ struct drm_bridge_funcs {
 struct drm_bridge {
         struct drm_device *dev;
         struct drm_encoder *encoder;
+        struct drm_bridge *next;
 #ifdef CONFIG_OF
         struct device_node *of_node;
 #endif
@@ -977,6 +994,9 @@ struct drm_mode_set {
  * @atomic_check: check whether a given atomic state update is possible
  * @atomic_commit: commit an atomic state update previously verified with
  *      atomic_check()
+ * @atomic_state_alloc: allocate a new atomic state
+ * @atomic_state_clear: clear the atomic state
+ * @atomic_state_free: free the atomic state
  *
  * Some global (i.e. not per-CRTC, connector, etc) mode setting functions that
  * involve drivers.
@@ -992,6 +1012,9 @@ struct drm_mode_config_funcs {
         int (*atomic_commit)(struct drm_device *dev,
                              struct drm_atomic_state *a,
                              bool async);
+        struct drm_atomic_state *(*atomic_state_alloc)(struct drm_device *dev);
+        void (*atomic_state_clear)(struct drm_atomic_state *state);
+        void (*atomic_state_free)(struct drm_atomic_state *state);
 };
 
 /**
@@ -1048,6 +1071,7 @@ struct drm_mode_group {
  * @poll_running: track polling status for this device
  * @output_poll_work: delayed work for polling in process context
  * @property_blob_list: list of all the blob property objects
+ * @blob_lock: mutex for blob property allocation and management
  * @*_property: core property tracking
  * @preferred_depth: preferred RBG pixel depth, used by fb helpers
  * @prefer_shadow: hint to userspace to prefer shadow-fb rendering
@@ -1103,6 +1127,8 @@ struct drm_mode_config {
         bool delayed_event;
         struct delayed_work output_poll_work;
 
+        struct mutex blob_lock;
+
         /* pointers to standard properties */
         struct list_head property_blob_list;
         struct drm_property *edid_property;
@@ -1122,6 +1148,7 @@ struct drm_mode_config {
         struct drm_property *prop_fb_id;
         struct drm_property *prop_crtc_id;
         struct drm_property *prop_active;
+        struct drm_property *prop_mode_id;
 
         /* DVI-I properties */
         struct drm_property *dvi_i_subconnector_property;
@@ -1230,6 +1257,17 @@ extern void drm_bridge_remove(struct drm_bridge *bridge);
 extern struct drm_bridge *of_drm_find_bridge(struct device_node *np);
 extern int drm_bridge_attach(struct drm_device *dev, struct drm_bridge *bridge);
 
+bool drm_bridge_mode_fixup(struct drm_bridge *bridge,
+                        const struct drm_display_mode *mode,
+                        struct drm_display_mode *adjusted_mode);
+void drm_bridge_disable(struct drm_bridge *bridge);
+void drm_bridge_post_disable(struct drm_bridge *bridge);
+void drm_bridge_mode_set(struct drm_bridge *bridge,
+                        struct drm_display_mode *mode,
+                        struct drm_display_mode *adjusted_mode);
+void drm_bridge_pre_enable(struct drm_bridge *bridge);
+void drm_bridge_enable(struct drm_bridge *bridge);
+
 extern int drm_encoder_init(struct drm_device *dev,
                             struct drm_encoder *encoder,
                             const struct drm_encoder_funcs *funcs,
@@ -1263,6 +1301,7 @@ extern int drm_plane_init(struct drm_device *dev,
                           bool is_primary);
 extern void drm_plane_cleanup(struct drm_plane *plane);
 extern unsigned int drm_plane_index(struct drm_plane *plane);
+extern struct drm_plane * drm_plane_from_index(struct drm_device *dev, int idx);
 extern void drm_plane_force_disable(struct drm_plane *plane);
 extern int drm_plane_check_pixel_format(const struct drm_plane *plane,
                                         u32 format);
@@ -1283,6 +1322,8 @@ extern const char *drm_get_dvi_i_select_name(int val);
 extern const char *drm_get_tv_subconnector_name(int val);
 extern const char *drm_get_tv_select_name(int val);
 extern void drm_fb_release(struct drm_file *file_priv);
+extern void drm_property_destroy_user_blobs(struct drm_device *dev,
+                                            struct drm_file *file_priv);
 extern int drm_mode_group_init_legacy_group(struct drm_device *dev, struct drm_mode_group *group);
 extern void drm_mode_group_destroy(struct drm_mode_group *group);
 extern void drm_reinit_primary_mode_group(struct drm_device *dev);
@@ -1362,6 +1403,13 @@ struct drm_property *drm_property_create_object(struct drm_device *dev,
                                          int flags, const char *name, uint32_t type);
 struct drm_property *drm_property_create_bool(struct drm_device *dev, int flags,
                                          const char *name);
+struct drm_property_blob *drm_property_create_blob(struct drm_device *dev,
+                                                   size_t length,
+                                                   const void *data);
+struct drm_property_blob *drm_property_lookup_blob(struct drm_device *dev,
+                                                   uint32_t id);
+struct drm_property_blob *drm_property_reference_blob(struct drm_property_blob *blob);
+void drm_property_unreference_blob(struct drm_property_blob *blob);
 extern void drm_property_destroy(struct drm_device *dev, struct drm_property *property);
 extern int drm_property_add_enum(struct drm_property *property, int index,
                                  uint64_t value, const char *name);
@@ -1421,6 +1469,10 @@ extern int drm_mode_getproperty_ioctl(struct drm_device *dev,
                                       void *data, struct drm_file *file_priv);
 extern int drm_mode_getblob_ioctl(struct drm_device *dev,
                                   void *data, struct drm_file *file_priv);
+extern int drm_mode_createblob_ioctl(struct drm_device *dev,
+                                     void *data, struct drm_file *file_priv);
+extern int drm_mode_destroyblob_ioctl(struct drm_device *dev,
+                                      void *data, struct drm_file *file_priv);
 extern int drm_mode_connector_property_set_ioctl(struct drm_device *dev,
                                               void *data, struct drm_file *file_priv);
 extern int drm_mode_getencoder(struct drm_device *dev,
@@ -1442,7 +1494,8 @@ extern void drm_set_preferred_mode(struct drm_connector *connector,
                                    int hpref, int vpref);
 
 extern int drm_edid_header_is_valid(const u8 *raw_edid);
-extern bool drm_edid_block_valid(u8 *raw_edid, int block, bool print_bad_edid);
+extern bool drm_edid_block_valid(u8 *raw_edid, int block, bool print_bad_edid,
+                                 bool *edid_corrupt);
 extern bool drm_edid_is_valid(struct edid *edid);
 
 extern struct drm_tile_group *drm_mode_create_tile_group(struct drm_device *dev,
@@ -1525,14 +1578,6 @@ static inline struct drm_property *drm_property_find(struct drm_device *dev,
         return mo ? obj_to_property(mo) : NULL;
 }
 
-static inline struct drm_property_blob *
-drm_property_blob_find(struct drm_device *dev, uint32_t id)
-{
-        struct drm_mode_object *mo;
-        mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_BLOB);
-        return mo ? obj_to_blob(mo) : NULL;
-}
-
 /* Plane list iterator for legacy (overlay only) planes. */
 #define drm_for_each_legacy_plane(plane, planelist) \
         list_for_each_entry(plane, planelist, head) \
diff --git a/include/drm/drm_crtc_helper.h b/include/drm/drm_crtc_helper.h
index c8fc187061de..918aa68b5199 100644
--- a/include/drm/drm_crtc_helper.h
+++ b/include/drm/drm_crtc_helper.h
@@ -168,6 +168,7 @@ struct drm_encoder_helper_funcs {
  * @get_modes: get mode list for this connector
  * @mode_valid: is this mode valid on the given connector? (optional)
  * @best_encoder: return the preferred encoder for this connector
+ * @atomic_best_encoder: atomic version of @best_encoder
  *
  * The helper operations are called by the mid-layer CRTC helper.
  */
@@ -176,6 +177,8 @@ struct drm_connector_helper_funcs {
         enum drm_mode_status (*mode_valid)(struct drm_connector *connector,
                                            struct drm_display_mode *mode);
         struct drm_encoder *(*best_encoder)(struct drm_connector *connector);
+        struct drm_encoder *(*atomic_best_encoder)(struct drm_connector *connector,
+                                                   struct drm_connector_state *connector_state);
 };
 
 extern void drm_helper_disable_unused_functions(struct drm_device *dev);
diff --git a/include/drm/drm_dp_helper.h b/include/drm/drm_dp_helper.h
index 523f04c90dea..2e86f642fc33 100644
--- a/include/drm/drm_dp_helper.h
+++ b/include/drm/drm_dp_helper.h
@@ -679,9 +679,9 @@ struct drm_dp_aux_msg {
  * An AUX channel can also be used to transport I2C messages to a sink. A
  * typical application of that is to access an EDID that's present in the
  * sink device. The .transfer() function can also be used to execute such
- * transactions. The drm_dp_aux_register_i2c_bus() function registers an
- * I2C adapter that can be passed to drm_probe_ddc(). Upon removal, drivers
- * should call drm_dp_aux_unregister_i2c_bus() to remove the I2C adapter.
+ * transactions. The drm_dp_aux_register() function registers an I2C
+ * adapter that can be passed to drm_probe_ddc(). Upon removal, drivers
+ * should call drm_dp_aux_unregister() to remove the I2C adapter.
  * The I2C adapter uses long transfers by default; if a partial response is
  * received, the adapter will drop down to the size given by the partial
  * response for this transaction only.
diff --git a/include/drm/drm_dp_mst_helper.h b/include/drm/drm_dp_mst_helper.h
index a2507817be41..86d0b25ed054 100644
--- a/include/drm/drm_dp_mst_helper.h
+++ b/include/drm/drm_dp_mst_helper.h
@@ -463,6 +463,10 @@ struct drm_dp_mst_topology_mgr {
         struct work_struct work;
 
         struct work_struct tx_work;
+
+        struct list_head destroy_connector_list;
+        struct mutex destroy_connector_lock;
+        struct work_struct destroy_connector_work;
 };
 
 int drm_dp_mst_topology_mgr_init(struct drm_dp_mst_topology_mgr *mgr, struct device *dev, struct drm_dp_aux *aux, int max_dpcd_transaction_bytes, int max_payloads, int conn_base_id);
diff --git a/include/drm/drm_mem_util.h b/include/drm/drm_mem_util.h
index 19a240446fca..e42495ad8136 100644
--- a/include/drm/drm_mem_util.h
+++ b/include/drm/drm_mem_util.h
@@ -56,10 +56,7 @@ static __inline__ void *drm_malloc_ab(size_t nmemb, size_t size)
 
 static __inline void drm_free_large(void *ptr)
 {
-        if (!is_vmalloc_addr(ptr))
-                return kfree(ptr);
-
-        vfree(ptr);
+        kvfree(ptr);
 }
 
 #endif
diff --git a/include/drm/drm_modes.h b/include/drm/drm_modes.h
index 0616188c7801..08a8cac9e555 100644
--- a/include/drm/drm_modes.h
+++ b/include/drm/drm_modes.h
@@ -182,6 +182,10 @@ struct drm_cmdline_mode;
 
 struct drm_display_mode *drm_mode_create(struct drm_device *dev);
 void drm_mode_destroy(struct drm_device *dev, struct drm_display_mode *mode);
+void drm_mode_convert_to_umode(struct drm_mode_modeinfo *out,
+                               const struct drm_display_mode *in);
+int drm_mode_convert_umode(struct drm_display_mode *out,
+                           const struct drm_mode_modeinfo *in);
 void drm_mode_probed_add(struct drm_connector *connector, struct drm_display_mode *mode);
 void drm_mode_debug_printmodeline(const struct drm_display_mode *mode);
 
diff --git a/include/drm/i915_component.h b/include/drm/i915_component.h
index 3e2f22e5bf3c..c9a8b64aa33b 100644
--- a/include/drm/i915_component.h
+++ b/include/drm/i915_component.h
@@ -31,6 +31,7 @@ struct i915_audio_component {
                 struct module *owner;
                 void (*get_power)(struct device *);
                 void (*put_power)(struct device *);
+                void (*codec_wake_override)(struct device *, bool enable);
                 int (*get_cdclk_freq)(struct device *);
         } *ops;
 };
diff --git a/include/drm/i915_pciids.h b/include/drm/i915_pciids.h
index 613372375ada..17c445612e01 100644
--- a/include/drm/i915_pciids.h
+++ b/include/drm/i915_pciids.h
@@ -286,5 +286,9 @@
         INTEL_SKL_GT2_IDS(info), \
         INTEL_SKL_GT3_IDS(info)
 
+#define INTEL_BXT_IDS(info) \
+        INTEL_VGA_DEVICE(0x0A84, info), \
+        INTEL_VGA_DEVICE(0x1A84, info), \
+        INTEL_VGA_DEVICE(0x5A84, info)
 
 #endif /* _I915_PCIIDS_H */
diff --git a/include/dt-bindings/clock/bcm-cygnus.h b/include/dt-bindings/clock/bcm-cygnus.h
new file mode 100644
index 000000000000..32fbc475087a
--- /dev/null
+++ b/include/dt-bindings/clock/bcm-cygnus.h
@@ -0,0 +1,68 @@
+/*
+ *  BSD LICENSE
+ *
+ *  Copyright(c) 2014 Broadcom Corporation.  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above copyright
+ *      notice, this list of conditions and the following disclaimer in
+ *      the documentation and/or other materials provided with the
+ *      distribution.
+ *    * Neither the name of Broadcom Corporation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _CLOCK_BCM_CYGNUS_H
+#define _CLOCK_BCM_CYGNUS_H
+
+/* GENPLL clock ID */
+#define BCM_CYGNUS_GENPLL                     0
+#define BCM_CYGNUS_GENPLL_AXI21_CLK           1
+#define BCM_CYGNUS_GENPLL_250MHZ_CLK          2
+#define BCM_CYGNUS_GENPLL_IHOST_SYS_CLK       3
+#define BCM_CYGNUS_GENPLL_ENET_SW_CLK         4
+#define BCM_CYGNUS_GENPLL_AUDIO_125_CLK       5
+#define BCM_CYGNUS_GENPLL_CAN_CLK             6
+
+/* LCPLL0 clock ID */
+#define BCM_CYGNUS_LCPLL0                     0
+#define BCM_CYGNUS_LCPLL0_PCIE_PHY_REF_CLK    1
+#define BCM_CYGNUS_LCPLL0_DDR_PHY_CLK         2
+#define BCM_CYGNUS_LCPLL0_SDIO_CLK            3
+#define BCM_CYGNUS_LCPLL0_USB_PHY_REF_CLK     4
+#define BCM_CYGNUS_LCPLL0_SMART_CARD_CLK      5
+#define BCM_CYGNUS_LCPLL0_CH5_UNUSED          6
+
+/* MIPI PLL clock ID */
+#define BCM_CYGNUS_MIPIPLL                    0
+#define BCM_CYGNUS_MIPIPLL_CH0_UNUSED         1
+#define BCM_CYGNUS_MIPIPLL_CH1_LCD            2
+#define BCM_CYGNUS_MIPIPLL_CH2_V3D            3
+#define BCM_CYGNUS_MIPIPLL_CH3_UNUSED         4
+#define BCM_CYGNUS_MIPIPLL_CH4_UNUSED         5
+#define BCM_CYGNUS_MIPIPLL_CH5_UNUSED         6
+
+/* ASIU clock ID */
+#define BCM_CYGNUS_ASIU_KEYPAD_CLK    0
+#define BCM_CYGNUS_ASIU_ADC_CLK       1
+#define BCM_CYGNUS_ASIU_PWM_CLK       2
+
+#endif /* _CLOCK_BCM_CYGNUS_H */
diff --git a/include/dt-bindings/clock/hi6220-clock.h b/include/dt-bindings/clock/hi6220-clock.h
new file mode 100644
index 000000000000..70ee3833a7a0
--- /dev/null
+++ b/include/dt-bindings/clock/hi6220-clock.h
@@ -0,0 +1,173 @@
+/*
+ * Copyright (c) 2015 Hisilicon Limited.
+ *
+ * Author: Bintian Wang <bintian.wang@huawei.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef __DT_BINDINGS_CLOCK_HI6220_H
+#define __DT_BINDINGS_CLOCK_HI6220_H
+
+/* clk in Hi6220 AO (always on) controller */
+#define HI6220_NONE_CLOCK       0
+
+/* fixed rate clocks */
+#define HI6220_REF32K           1
+#define HI6220_CLK_TCXO         2
+#define HI6220_MMC1_PAD         3
+#define HI6220_MMC2_PAD         4
+#define HI6220_MMC0_PAD         5
+#define HI6220_PLL_BBP          6
+#define HI6220_PLL_GPU          7
+#define HI6220_PLL1_DDR         8
+#define HI6220_PLL_SYS          9
+#define HI6220_PLL_SYS_MEDIA    10
+#define HI6220_DDR_SRC          11
+#define HI6220_PLL_MEDIA        12
+#define HI6220_PLL_DDR          13
+
+/* fixed factor clocks */
+#define HI6220_300M             14
+#define HI6220_150M             15
+#define HI6220_PICOPHY_SRC      16
+#define HI6220_MMC0_SRC_SEL     17
+#define HI6220_MMC1_SRC_SEL     18
+#define HI6220_MMC2_SRC_SEL     19
+#define HI6220_VPU_CODEC        20
+#define HI6220_MMC0_SMP         21
+#define HI6220_MMC1_SMP         22
+#define HI6220_MMC2_SMP         23
+
+/* gate clocks */
+#define HI6220_WDT0_PCLK        24
+#define HI6220_WDT1_PCLK        25
+#define HI6220_WDT2_PCLK        26
+#define HI6220_TIMER0_PCLK      27
+#define HI6220_TIMER1_PCLK      28
+#define HI6220_TIMER2_PCLK      29
+#define HI6220_TIMER3_PCLK      30
+#define HI6220_TIMER4_PCLK      31
+#define HI6220_TIMER5_PCLK      32
+#define HI6220_TIMER6_PCLK      33
+#define HI6220_TIMER7_PCLK      34
+#define HI6220_TIMER8_PCLK      35
+#define HI6220_UART0_PCLK       36
+
+#define HI6220_AO_NR_CLKS       37
+
+/* clk in Hi6220 systrl */
+/* gate clock */
+#define HI6220_MMC0_CLK         1
+#define HI6220_MMC0_CIUCLK      2
+#define HI6220_MMC1_CLK         3
+#define HI6220_MMC1_CIUCLK      4
+#define HI6220_MMC2_CLK         5
+#define HI6220_MMC2_CIUCLK      6
+#define HI6220_USBOTG_HCLK      7
+#define HI6220_CLK_PICOPHY      8
+#define HI6220_HIFI             9
+#define HI6220_DACODEC_PCLK     10
+#define HI6220_EDMAC_ACLK       11
+#define HI6220_CS_ATB           12
+#define HI6220_I2C0_CLK         13
+#define HI6220_I2C1_CLK         14
+#define HI6220_I2C2_CLK         15
+#define HI6220_I2C3_CLK         16
+#define HI6220_UART1_PCLK       17
+#define HI6220_UART2_PCLK       18
+#define HI6220_UART3_PCLK       19
+#define HI6220_UART4_PCLK       20
+#define HI6220_SPI_CLK          21
+#define HI6220_TSENSOR_CLK      22
+#define HI6220_MMU_CLK          23
+#define HI6220_HIFI_SEL         24
+#define HI6220_MMC0_SYSPLL      25
+#define HI6220_MMC1_SYSPLL      26
+#define HI6220_MMC2_SYSPLL      27
+#define HI6220_MMC0_SEL         28
+#define HI6220_MMC1_SEL         29
+#define HI6220_BBPPLL_SEL       30
+#define HI6220_MEDIA_PLL_SRC    31
+#define HI6220_MMC2_SEL         32
+#define HI6220_CS_ATB_SYSPLL    33
+
+/* mux clocks */
+#define HI6220_MMC0_SRC         34
+#define HI6220_MMC0_SMP_IN      35
+#define HI6220_MMC1_SRC         36
+#define HI6220_MMC1_SMP_IN      37
+#define HI6220_MMC2_SRC         38
+#define HI6220_MMC2_SMP_IN      39
+#define HI6220_HIFI_SRC         40
+#define HI6220_UART1_SRC        41
+#define HI6220_UART2_SRC        42
+#define HI6220_UART3_SRC        43
+#define HI6220_UART4_SRC        44
+#define HI6220_MMC0_MUX0        45
+#define HI6220_MMC1_MUX0        46
+#define HI6220_MMC2_MUX0        47
+#define HI6220_MMC0_MUX1        48
+#define HI6220_MMC1_MUX1        49
+#define HI6220_MMC2_MUX1        50
+
+/* divider clocks */
+#define HI6220_CLK_BUS          51
+#define HI6220_MMC0_DIV         52
+#define HI6220_MMC1_DIV         53
+#define HI6220_MMC2_DIV         54
+#define HI6220_HIFI_DIV         55
+#define HI6220_BBPPLL0_DIV      56
+#define HI6220_CS_DAPB          57
+#define HI6220_CS_ATB_DIV       58
+
+#define HI6220_SYS_NR_CLKS      59
+
+/* clk in Hi6220 media controller */
+/* gate clocks */
+#define HI6220_DSI_PCLK         1
+#define HI6220_G3D_PCLK         2
+#define HI6220_ACLK_CODEC_VPU   3
+#define HI6220_ISP_SCLK         4
+#define HI6220_ADE_CORE         5
+#define HI6220_MED_MMU          6
+#define HI6220_CFG_CSI4PHY      7
+#define HI6220_CFG_CSI2PHY      8
+#define HI6220_ISP_SCLK_GATE    9
+#define HI6220_ISP_SCLK_GATE1   10
+#define HI6220_ADE_CORE_GATE    11
+#define HI6220_CODEC_VPU_GATE   12
+#define HI6220_MED_SYSPLL       13
+
+/* mux clocks */
+#define HI6220_1440_1200        14
+#define HI6220_1000_1200        15
+#define HI6220_1000_1440        16
+
+/* divider clocks */
+#define HI6220_CODEC_JPEG       17
+#define HI6220_ISP_SCLK_SRC     18
+#define HI6220_ISP_SCLK1        19
+#define HI6220_ADE_CORE_SRC     20
+#define HI6220_ADE_PIX_SRC      21
+#define HI6220_G3D_CLK          22
+#define HI6220_CODEC_VPU_SRC    23
+
+#define HI6220_MEDIA_NR_CLKS    24
+
+/* clk in Hi6220 power controller */
+/* gate clocks */
+#define HI6220_PLL_GPU_GATE     1
+#define HI6220_PLL1_DDR_GATE    2
+#define HI6220_PLL_DDR_GATE     3
+#define HI6220_PLL_MEDIA_GATE   4
+#define HI6220_PLL0_BBP_GATE    5
+
+/* divider clocks */
+#define HI6220_DDRC_SRC         6
+#define HI6220_DDRC_AXI1        7
+
+#define HI6220_POWER_NR_CLKS    8
+#endif
diff --git a/include/dt-bindings/clock/imx7d-clock.h b/include/dt-bindings/clock/imx7d-clock.h
new file mode 100644
index 000000000000..728df28b00d5
--- /dev/null
+++ b/include/dt-bindings/clock/imx7d-clock.h
@@ -0,0 +1,450 @@
+/*
+ * Copyright (C) 2014-2015 Freescale Semiconductor, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ */
+
+#ifndef __DT_BINDINGS_CLOCK_IMX7D_H
+#define __DT_BINDINGS_CLOCK_IMX7D_H
+
+#define IMX7D_OSC_24M_CLK               0
+#define IMX7D_PLL_ARM_MAIN              1
+#define IMX7D_PLL_ARM_MAIN_CLK          2
+#define IMX7D_PLL_ARM_MAIN_SRC          3
+#define IMX7D_PLL_ARM_MAIN_BYPASS       4
+#define IMX7D_PLL_SYS_MAIN              5
+#define IMX7D_PLL_SYS_MAIN_CLK          6
+#define IMX7D_PLL_SYS_MAIN_SRC          7
+#define IMX7D_PLL_SYS_MAIN_BYPASS       8
+#define IMX7D_PLL_SYS_MAIN_480M         9
+#define IMX7D_PLL_SYS_MAIN_240M         10
+#define IMX7D_PLL_SYS_MAIN_120M         11
+#define IMX7D_PLL_SYS_MAIN_480M_CLK     12
+#define IMX7D_PLL_SYS_MAIN_240M_CLK     13
+#define IMX7D_PLL_SYS_MAIN_120M_CLK     14
+#define IMX7D_PLL_SYS_PFD0_392M_CLK     15
+#define IMX7D_PLL_SYS_PFD0_196M         16
+#define IMX7D_PLL_SYS_PFD0_196M_CLK     17
+#define IMX7D_PLL_SYS_PFD1_332M_CLK     18
+#define IMX7D_PLL_SYS_PFD1_166M         19
+#define IMX7D_PLL_SYS_PFD1_166M_CLK     20
+#define IMX7D_PLL_SYS_PFD2_270M_CLK     21
+#define IMX7D_PLL_SYS_PFD2_135M         22
+#define IMX7D_PLL_SYS_PFD2_135M_CLK     23
+#define IMX7D_PLL_SYS_PFD3_CLK          24
+#define IMX7D_PLL_SYS_PFD4_CLK          25
+#define IMX7D_PLL_SYS_PFD5_CLK          26
+#define IMX7D_PLL_SYS_PFD6_CLK          27
+#define IMX7D_PLL_SYS_PFD7_CLK          28
+#define IMX7D_PLL_ENET_MAIN             29
+#define IMX7D_PLL_ENET_MAIN_CLK         30
+#define IMX7D_PLL_ENET_MAIN_SRC         31
+#define IMX7D_PLL_ENET_MAIN_BYPASS      32
+#define IMX7D_PLL_ENET_MAIN_500M        33
+#define IMX7D_PLL_ENET_MAIN_250M        34
+#define IMX7D_PLL_ENET_MAIN_125M        35
+#define IMX7D_PLL_ENET_MAIN_100M        36
+#define IMX7D_PLL_ENET_MAIN_50M         37
+#define IMX7D_PLL_ENET_MAIN_40M         38
+#define IMX7D_PLL_ENET_MAIN_25M         39
+#define IMX7D_PLL_ENET_MAIN_500M_CLK    40
+#define IMX7D_PLL_ENET_MAIN_250M_CLK    41
+#define IMX7D_PLL_ENET_MAIN_125M_CLK    42
+#define IMX7D_PLL_ENET_MAIN_100M_CLK    43
+#define IMX7D_PLL_ENET_MAIN_50M_CLK     44
+#define IMX7D_PLL_ENET_MAIN_40M_CLK     45
+#define IMX7D_PLL_ENET_MAIN_25M_CLK     46
+#define IMX7D_PLL_DRAM_MAIN             47
+#define IMX7D_PLL_DRAM_MAIN_CLK         48
+#define IMX7D_PLL_DRAM_MAIN_SRC         49
+#define IMX7D_PLL_DRAM_MAIN_BYPASS      50
+#define IMX7D_PLL_DRAM_MAIN_533M        51
+#define IMX7D_PLL_DRAM_MAIN_533M_CLK    52
+#define IMX7D_PLL_AUDIO_MAIN            53
+#define IMX7D_PLL_AUDIO_MAIN_CLK        54
+#define IMX7D_PLL_AUDIO_MAIN_SRC        55
+#define IMX7D_PLL_AUDIO_MAIN_BYPASS     56
+#define IMX7D_PLL_VIDEO_MAIN_CLK        57
+#define IMX7D_PLL_VIDEO_MAIN            58
+#define IMX7D_PLL_VIDEO_MAIN_SRC        59
+#define IMX7D_PLL_VIDEO_MAIN_BYPASS     60
+#define IMX7D_USB_MAIN_480M_CLK         61
+#define IMX7D_ARM_A7_ROOT_CLK           62
+#define IMX7D_ARM_A7_ROOT_SRC           63
+#define IMX7D_ARM_A7_ROOT_CG            64
+#define IMX7D_ARM_A7_ROOT_DIV           65
+#define IMX7D_ARM_M4_ROOT_CLK           66
+#define IMX7D_ARM_M4_ROOT_SRC           67
+#define IMX7D_ARM_M4_ROOT_CG            68
+#define IMX7D_ARM_M4_ROOT_DIV           69
+#define IMX7D_ARM_M0_ROOT_CLK           70
+#define IMX7D_ARM_M0_ROOT_SRC           71
+#define IMX7D_ARM_M0_ROOT_CG            72
+#define IMX7D_ARM_M0_ROOT_DIV           73
+#define IMX7D_MAIN_AXI_ROOT_CLK         74
+#define IMX7D_MAIN_AXI_ROOT_SRC         75
+#define IMX7D_MAIN_AXI_ROOT_CG          76
+#define IMX7D_MAIN_AXI_ROOT_DIV         77
+#define IMX7D_DISP_AXI_ROOT_CLK         78
+#define IMX7D_DISP_AXI_ROOT_SRC         79
+#define IMX7D_DISP_AXI_ROOT_CG          80
+#define IMX7D_DISP_AXI_ROOT_DIV         81
+#define IMX7D_ENET_AXI_ROOT_CLK         82
+#define IMX7D_ENET_AXI_ROOT_SRC         83
+#define IMX7D_ENET_AXI_ROOT_CG          84
+#define IMX7D_ENET_AXI_ROOT_DIV         85
+#define IMX7D_NAND_USDHC_BUS_ROOT_CLK   86
+#define IMX7D_NAND_USDHC_BUS_ROOT_SRC   87
+#define IMX7D_NAND_USDHC_BUS_ROOT_CG    88
+#define IMX7D_NAND_USDHC_BUS_ROOT_DIV   89
+#define IMX7D_AHB_CHANNEL_ROOT_CLK      90
+#define IMX7D_AHB_CHANNEL_ROOT_SRC      91
+#define IMX7D_AHB_CHANNEL_ROOT_CG       92
+#define IMX7D_AHB_CHANNEL_ROOT_DIV      93
+#define IMX7D_DRAM_PHYM_ROOT_CLK        94
+#define IMX7D_DRAM_PHYM_ROOT_SRC        95
+#define IMX7D_DRAM_PHYM_ROOT_CG         96
+#define IMX7D_DRAM_PHYM_ROOT_DIV        97
+#define IMX7D_DRAM_ROOT_CLK             98
+#define IMX7D_DRAM_ROOT_SRC             99
+#define IMX7D_DRAM_ROOT_CG              100
+#define IMX7D_DRAM_ROOT_DIV             101
+#define IMX7D_DRAM_PHYM_ALT_ROOT_CLK    102
+#define IMX7D_DRAM_PHYM_ALT_ROOT_SRC    103
+#define IMX7D_DRAM_PHYM_ALT_ROOT_CG     104
+#define IMX7D_DRAM_PHYM_ALT_ROOT_DIV    105
+#define IMX7D_DRAM_ALT_ROOT_CLK         106
+#define IMX7D_DRAM_ALT_ROOT_SRC         107
+#define IMX7D_DRAM_ALT_ROOT_CG          108
+#define IMX7D_DRAM_ALT_ROOT_DIV         109
+#define IMX7D_USB_HSIC_ROOT_CLK         110
+#define IMX7D_USB_HSIC_ROOT_SRC         111
+#define IMX7D_USB_HSIC_ROOT_CG          112
+#define IMX7D_USB_HSIC_ROOT_DIV         113
+#define IMX7D_PCIE_CTRL_ROOT_CLK        114
+#define IMX7D_PCIE_CTRL_ROOT_SRC        115
+#define IMX7D_PCIE_CTRL_ROOT_CG         116
+#define IMX7D_PCIE_CTRL_ROOT_DIV        117
+#define IMX7D_PCIE_PHY_ROOT_CLK         118
+#define IMX7D_PCIE_PHY_ROOT_SRC         119
+#define IMX7D_PCIE_PHY_ROOT_CG          120
+#define IMX7D_PCIE_PHY_ROOT_DIV         121
+#define IMX7D_EPDC_PIXEL_ROOT_CLK       122
+#define IMX7D_EPDC_PIXEL_ROOT_SRC       123
+#define IMX7D_EPDC_PIXEL_ROOT_CG        124
+#define IMX7D_EPDC_PIXEL_ROOT_DIV       125
+#define IMX7D_LCDIF_PIXEL_ROOT_CLK      126
+#define IMX7D_LCDIF_PIXEL_ROOT_SRC      127
+#define IMX7D_LCDIF_PIXEL_ROOT_CG       128
+#define IMX7D_LCDIF_PIXEL_ROOT_DIV      129
+#define IMX7D_MIPI_DSI_ROOT_CLK         130
+#define IMX7D_MIPI_DSI_ROOT_SRC         131
+#define IMX7D_MIPI_DSI_ROOT_CG          132
+#define IMX7D_MIPI_DSI_ROOT_DIV         133
+#define IMX7D_MIPI_CSI_ROOT_CLK         134
+#define IMX7D_MIPI_CSI_ROOT_SRC         135
+#define IMX7D_MIPI_CSI_ROOT_CG          136
+#define IMX7D_MIPI_CSI_ROOT_DIV         137
+#define IMX7D_MIPI_DPHY_ROOT_CLK        138
+#define IMX7D_MIPI_DPHY_ROOT_SRC        139
+#define IMX7D_MIPI_DPHY_ROOT_CG         140
+#define IMX7D_MIPI_DPHY_ROOT_DIV        141
+#define IMX7D_SAI1_ROOT_CLK             142
+#define IMX7D_SAI1_ROOT_SRC             143
+#define IMX7D_SAI1_ROOT_CG              144
+#define IMX7D_SAI1_ROOT_DIV             145
+#define IMX7D_SAI2_ROOT_CLK             146
+#define IMX7D_SAI2_ROOT_SRC             147
+#define IMX7D_SAI2_ROOT_CG              148
+#define IMX7D_SAI2_ROOT_DIV             149
+#define IMX7D_SAI3_ROOT_CLK             150
+#define IMX7D_SAI3_ROOT_SRC             151
+#define IMX7D_SAI3_ROOT_CG              152
+#define IMX7D_SAI3_ROOT_DIV             153
+#define IMX7D_SPDIF_ROOT_CLK            154
+#define IMX7D_SPDIF_ROOT_SRC            155
+#define IMX7D_SPDIF_ROOT_CG             156
+#define IMX7D_SPDIF_ROOT_DIV            157
+#define IMX7D_ENET1_REF_ROOT_CLK        158
+#define IMX7D_ENET1_REF_ROOT_SRC        159
+#define IMX7D_ENET1_REF_ROOT_CG         160
+#define IMX7D_ENET1_REF_ROOT_DIV        161
+#define IMX7D_ENET1_TIME_ROOT_CLK       162
+#define IMX7D_ENET1_TIME_ROOT_SRC       163
+#define IMX7D_ENET1_TIME_ROOT_CG        164
+#define IMX7D_ENET1_TIME_ROOT_DIV       165
+#define IMX7D_ENET2_REF_ROOT_CLK        166
+#define IMX7D_ENET2_REF_ROOT_SRC        167
+#define IMX7D_ENET2_REF_ROOT_CG         168
+#define IMX7D_ENET2_REF_ROOT_DIV        169
+#define IMX7D_ENET2_TIME_ROOT_CLK       170
+#define IMX7D_ENET2_TIME_ROOT_SRC       171
+#define IMX7D_ENET2_TIME_ROOT_CG        172
+#define IMX7D_ENET2_TIME_ROOT_DIV       173
+#define IMX7D_ENET_PHY_REF_ROOT_CLK     174
+#define IMX7D_ENET_PHY_REF_ROOT_SRC     175
+#define IMX7D_ENET_PHY_REF_ROOT_CG      176
+#define IMX7D_ENET_PHY_REF_ROOT_DIV     177
+#define IMX7D_EIM_ROOT_CLK              178
+#define IMX7D_EIM_ROOT_SRC              179
+#define IMX7D_EIM_ROOT_CG               180
+#define IMX7D_EIM_ROOT_DIV              181
+#define IMX7D_NAND_ROOT_CLK             182
+#define IMX7D_NAND_ROOT_SRC             183
+#define IMX7D_NAND_ROOT_CG              184
+#define IMX7D_NAND_ROOT_DIV             185
+#define IMX7D_QSPI_ROOT_CLK             186
+#define IMX7D_QSPI_ROOT_SRC             187
+#define IMX7D_QSPI_ROOT_CG              188
+#define IMX7D_QSPI_ROOT_DIV             189
+#define IMX7D_USDHC1_ROOT_CLK           190
+#define IMX7D_USDHC1_ROOT_SRC           191
+#define IMX7D_USDHC1_ROOT_CG            192
+#define IMX7D_USDHC1_ROOT_DIV           193
+#define IMX7D_USDHC2_ROOT_CLK           194
+#define IMX7D_USDHC2_ROOT_SRC           195
+#define IMX7D_USDHC2_ROOT_CG            196
+#define IMX7D_USDHC2_ROOT_DIV           197
+#define IMX7D_USDHC3_ROOT_CLK           198
+#define IMX7D_USDHC3_ROOT_SRC           199
+#define IMX7D_USDHC3_ROOT_CG            200
+#define IMX7D_USDHC3_ROOT_DIV           201
+#define IMX7D_CAN1_ROOT_CLK             202
+#define IMX7D_CAN1_ROOT_SRC             203
+#define IMX7D_CAN1_ROOT_CG              204
+#define IMX7D_CAN1_ROOT_DIV             205
+#define IMX7D_CAN2_ROOT_CLK             206
+#define IMX7D_CAN2_ROOT_SRC             207
+#define IMX7D_CAN2_ROOT_CG              208
+#define IMX7D_CAN2_ROOT_DIV             209
+#define IMX7D_I2C1_ROOT_CLK             210
+#define IMX7D_I2C1_ROOT_SRC             211
+#define IMX7D_I2C1_ROOT_CG              212
+#define IMX7D_I2C1_ROOT_DIV             213
+#define IMX7D_I2C2_ROOT_CLK             214
+#define IMX7D_I2C2_ROOT_SRC             215
+#define IMX7D_I2C2_ROOT_CG              216
+#define IMX7D_I2C2_ROOT_DIV             217
+#define IMX7D_I2C3_ROOT_CLK             218
+#define IMX7D_I2C3_ROOT_SRC             219
+#define IMX7D_I2C3_ROOT_CG              220
+#define IMX7D_I2C3_ROOT_DIV             221
+#define IMX7D_I2C4_ROOT_CLK             222
+#define IMX7D_I2C4_ROOT_SRC             223
+#define IMX7D_I2C4_ROOT_CG              224
+#define IMX7D_I2C4_ROOT_DIV             225
+#define IMX7D_UART1_ROOT_CLK            226
+#define IMX7D_UART1_ROOT_SRC            227
+#define IMX7D_UART1_ROOT_CG             228
+#define IMX7D_UART1_ROOT_DIV            229
+#define IMX7D_UART2_ROOT_CLK            230
+#define IMX7D_UART2_ROOT_SRC            231
+#define IMX7D_UART2_ROOT_CG             232
+#define IMX7D_UART2_ROOT_DIV            233
+#define IMX7D_UART3_ROOT_CLK            234
+#define IMX7D_UART3_ROOT_SRC            235
+#define IMX7D_UART3_ROOT_CG             236
+#define IMX7D_UART3_ROOT_DIV            237
+#define IMX7D_UART4_ROOT_CLK            238
+#define IMX7D_UART4_ROOT_SRC            239
+#define IMX7D_UART4_ROOT_CG             240
+#define IMX7D_UART4_ROOT_DIV            241
+#define IMX7D_UART5_ROOT_CLK            242
+#define IMX7D_UART5_ROOT_SRC            243
+#define IMX7D_UART5_ROOT_CG             244
+#define IMX7D_UART5_ROOT_DIV            245
+#define IMX7D_UART6_ROOT_CLK            246
+#define IMX7D_UART6_ROOT_SRC            247
+#define IMX7D_UART6_ROOT_CG             248
+#define IMX7D_UART6_ROOT_DIV            249
+#define IMX7D_UART7_ROOT_CLK            250
+#define IMX7D_UART7_ROOT_SRC            251
+#define IMX7D_UART7_ROOT_CG             252
+#define IMX7D_UART7_ROOT_DIV            253
+#define IMX7D_ECSPI1_ROOT_CLK           254
+#define IMX7D_ECSPI1_ROOT_SRC           255
+#define IMX7D_ECSPI1_ROOT_CG            256
+#define IMX7D_ECSPI1_ROOT_DIV           257
+#define IMX7D_ECSPI2_ROOT_CLK           258
+#define IMX7D_ECSPI2_ROOT_SRC           259
+#define IMX7D_ECSPI2_ROOT_CG            260
+#define IMX7D_ECSPI2_ROOT_DIV           261
+#define IMX7D_ECSPI3_ROOT_CLK           262
+#define IMX7D_ECSPI3_ROOT_SRC           263
+#define IMX7D_ECSPI3_ROOT_CG            264
+#define IMX7D_ECSPI3_ROOT_DIV           265
+#define IMX7D_ECSPI4_ROOT_CLK           266
+#define IMX7D_ECSPI4_ROOT_SRC           267
+#define IMX7D_ECSPI4_ROOT_CG            268
+#define IMX7D_ECSPI4_ROOT_DIV           269
+#define IMX7D_PWM1_ROOT_CLK             270
+#define IMX7D_PWM1_ROOT_SRC             271
+#define IMX7D_PWM1_ROOT_CG              272
+#define IMX7D_PWM1_ROOT_DIV             273
+#define IMX7D_PWM2_ROOT_CLK             274
+#define IMX7D_PWM2_ROOT_SRC             275
+#define IMX7D_PWM2_ROOT_CG              276
+#define IMX7D_PWM2_ROOT_DIV             277
+#define IMX7D_PWM3_ROOT_CLK             278
+#define IMX7D_PWM3_ROOT_SRC             279
+#define IMX7D_PWM3_ROOT_CG              280
+#define IMX7D_PWM3_ROOT_DIV             281
+#define IMX7D_PWM4_ROOT_CLK             282
+#define IMX7D_PWM4_ROOT_SRC             283
+#define IMX7D_PWM4_ROOT_CG              284
+#define IMX7D_PWM4_ROOT_DIV             285
+#define IMX7D_FLEXTIMER1_ROOT_CLK       286
+#define IMX7D_FLEXTIMER1_ROOT_SRC       287
+#define IMX7D_FLEXTIMER1_ROOT_CG        288
+#define IMX7D_FLEXTIMER1_ROOT_DIV       289
+#define IMX7D_FLEXTIMER2_ROOT_CLK       290
+#define IMX7D_FLEXTIMER2_ROOT_SRC       291
+#define IMX7D_FLEXTIMER2_ROOT_CG        292
+#define IMX7D_FLEXTIMER2_ROOT_DIV       293
+#define IMX7D_SIM1_ROOT_CLK             294
+#define IMX7D_SIM1_ROOT_SRC             295
+#define IMX7D_SIM1_ROOT_CG              296
+#define IMX7D_SIM1_ROOT_DIV             297
+#define IMX7D_SIM2_ROOT_CLK             298
+#define IMX7D_SIM2_ROOT_SRC             299
+#define IMX7D_SIM2_ROOT_CG              300
+#define IMX7D_SIM2_ROOT_DIV             301
+#define IMX7D_GPT1_ROOT_CLK             302
+#define IMX7D_GPT1_ROOT_SRC             303
+#define IMX7D_GPT1_ROOT_CG              304
+#define IMX7D_GPT1_ROOT_DIV             305
+#define IMX7D_GPT2_ROOT_CLK             306
+#define IMX7D_GPT2_ROOT_SRC             307
+#define IMX7D_GPT2_ROOT_CG              308
+#define IMX7D_GPT2_ROOT_DIV             309
+#define IMX7D_GPT3_ROOT_CLK             310
+#define IMX7D_GPT3_ROOT_SRC             311
+#define IMX7D_GPT3_ROOT_CG              312
+#define IMX7D_GPT3_ROOT_DIV             313
+#define IMX7D_GPT4_ROOT_CLK             314
+#define IMX7D_GPT4_ROOT_SRC             315
+#define IMX7D_GPT4_ROOT_CG              316
+#define IMX7D_GPT4_ROOT_DIV             317
+#define IMX7D_TRACE_ROOT_CLK            318
+#define IMX7D_TRACE_ROOT_SRC            319
+#define IMX7D_TRACE_ROOT_CG             320
+#define IMX7D_TRACE_ROOT_DIV            321
+#define IMX7D_WDOG1_ROOT_CLK            322
+#define IMX7D_WDOG_ROOT_SRC             323
+#define IMX7D_WDOG_ROOT_CG              324
+#define IMX7D_WDOG_ROOT_DIV             325
+#define IMX7D_CSI_MCLK_ROOT_CLK         326
+#define IMX7D_CSI_MCLK_ROOT_SRC         327
+#define IMX7D_CSI_MCLK_ROOT_CG          328
+#define IMX7D_CSI_MCLK_ROOT_DIV         329
+#define IMX7D_AUDIO_MCLK_ROOT_CLK       330
+#define IMX7D_AUDIO_MCLK_ROOT_SRC       331
+#define IMX7D_AUDIO_MCLK_ROOT_CG        332
+#define IMX7D_AUDIO_MCLK_ROOT_DIV       333
+#define IMX7D_WRCLK_ROOT_CLK            334
+#define IMX7D_WRCLK_ROOT_SRC            335
+#define IMX7D_WRCLK_ROOT_CG             336
+#define IMX7D_WRCLK_ROOT_DIV            337
+#define IMX7D_CLKO1_ROOT_SRC            338
+#define IMX7D_CLKO1_ROOT_CG             339
+#define IMX7D_CLKO1_ROOT_DIV            340
+#define IMX7D_CLKO2_ROOT_SRC            341
+#define IMX7D_CLKO2_ROOT_CG             342
+#define IMX7D_CLKO2_ROOT_DIV            343
+#define IMX7D_MAIN_AXI_ROOT_PRE_DIV     344
+#define IMX7D_DISP_AXI_ROOT_PRE_DIV     345
+#define IMX7D_ENET_AXI_ROOT_PRE_DIV     346
+#define IMX7D_NAND_USDHC_BUS_ROOT_PRE_DIV 347
+#define IMX7D_AHB_CHANNEL_ROOT_PRE_DIV  348
+#define IMX7D_USB_HSIC_ROOT_PRE_DIV     349
+#define IMX7D_PCIE_CTRL_ROOT_PRE_DIV    350
+#define IMX7D_PCIE_PHY_ROOT_PRE_DIV     351
+#define IMX7D_EPDC_PIXEL_ROOT_PRE_DIV   352
+#define IMX7D_LCDIF_PIXEL_ROOT_PRE_DIV  353
+#define IMX7D_MIPI_DSI_ROOT_PRE_DIV     354
+#define IMX7D_MIPI_CSI_ROOT_PRE_DIV     355
+#define IMX7D_MIPI_DPHY_ROOT_PRE_DIV    356
+#define IMX7D_SAI1_ROOT_PRE_DIV         357
+#define IMX7D_SAI2_ROOT_PRE_DIV         358
+#define IMX7D_SAI3_ROOT_PRE_DIV         359
+#define IMX7D_SPDIF_ROOT_PRE_DIV        360
+#define IMX7D_ENET1_REF_ROOT_PRE_DIV    361
+#define IMX7D_ENET1_TIME_ROOT_PRE_DIV   362
+#define IMX7D_ENET2_REF_ROOT_PRE_DIV    363
+#define IMX7D_ENET2_TIME_ROOT_PRE_DIV   364
+#define IMX7D_ENET_PHY_REF_ROOT_PRE_DIV 365
+#define IMX7D_EIM_ROOT_PRE_DIV          366
+#define IMX7D_NAND_ROOT_PRE_DIV         367
+#define IMX7D_QSPI_ROOT_PRE_DIV         368
+#define IMX7D_USDHC1_ROOT_PRE_DIV       369
+#define IMX7D_USDHC2_ROOT_PRE_DIV       370
+#define IMX7D_USDHC3_ROOT_PRE_DIV       371
+#define IMX7D_CAN1_ROOT_PRE_DIV         372
+#define IMX7D_CAN2_ROOT_PRE_DIV         373
+#define IMX7D_I2C1_ROOT_PRE_DIV         374
+#define IMX7D_I2C2_ROOT_PRE_DIV         375
+#define IMX7D_I2C3_ROOT_PRE_DIV         376
+#define IMX7D_I2C4_ROOT_PRE_DIV         377
+#define IMX7D_UART1_ROOT_PRE_DIV        378
+#define IMX7D_UART2_ROOT_PRE_DIV        379
+#define IMX7D_UART3_ROOT_PRE_DIV        380
+#define IMX7D_UART4_ROOT_PRE_DIV        381
+#define IMX7D_UART5_ROOT_PRE_DIV        382
+#define IMX7D_UART6_ROOT_PRE_DIV        383
+#define IMX7D_UART7_ROOT_PRE_DIV        384
+#define IMX7D_ECSPI1_ROOT_PRE_DIV       385
+#define IMX7D_ECSPI2_ROOT_PRE_DIV       386
+#define IMX7D_ECSPI3_ROOT_PRE_DIV       387
+#define IMX7D_ECSPI4_ROOT_PRE_DIV       388
+#define IMX7D_PWM1_ROOT_PRE_DIV         389
+#define IMX7D_PWM2_ROOT_PRE_DIV         390
+#define IMX7D_PWM3_ROOT_PRE_DIV         391
+#define IMX7D_PWM4_ROOT_PRE_DIV         392
+#define IMX7D_FLEXTIMER1_ROOT_PRE_DIV   393
+#define IMX7D_FLEXTIMER2_ROOT_PRE_DIV   394
+#define IMX7D_SIM1_ROOT_PRE_DIV         395
+#define IMX7D_SIM2_ROOT_PRE_DIV         396
+#define IMX7D_GPT1_ROOT_PRE_DIV         397
+#define IMX7D_GPT2_ROOT_PRE_DIV         398
+#define IMX7D_GPT3_ROOT_PRE_DIV         399
+#define IMX7D_GPT4_ROOT_PRE_DIV         400
+#define IMX7D_TRACE_ROOT_PRE_DIV        401
+#define IMX7D_WDOG_ROOT_PRE_DIV         402
+#define IMX7D_CSI_MCLK_ROOT_PRE_DIV     403
+#define IMX7D_AUDIO_MCLK_ROOT_PRE_DIV   404
+#define IMX7D_WRCLK_ROOT_PRE_DIV        405
+#define IMX7D_CLKO1_ROOT_PRE_DIV        406
+#define IMX7D_CLKO2_ROOT_PRE_DIV        407
+#define IMX7D_DRAM_PHYM_ALT_ROOT_PRE_DIV 408
+#define IMX7D_DRAM_ALT_ROOT_PRE_DIV     409
+#define IMX7D_LVDS1_IN_CLK              410
+#define IMX7D_LVDS1_OUT_SEL             411
+#define IMX7D_LVDS1_OUT_CLK             412
+#define IMX7D_CLK_DUMMY                 413
+#define IMX7D_GPT_3M_CLK                414
+#define IMX7D_OCRAM_CLK                 415
+#define IMX7D_OCRAM_S_CLK               416
+#define IMX7D_WDOG2_ROOT_CLK            417
+#define IMX7D_WDOG3_ROOT_CLK            418
+#define IMX7D_WDOG4_ROOT_CLK            419
+#define IMX7D_SDMA_CORE_CLK             420
+#define IMX7D_USB1_MAIN_480M_CLK        421
+#define IMX7D_USB_CTRL_CLK              422
+#define IMX7D_USB_PHY1_CLK              423
+#define IMX7D_USB_PHY2_CLK              424
+#define IMX7D_IPG_ROOT_CLK              425
+#define IMX7D_SAI1_IPG_CLK              426
+#define IMX7D_SAI2_IPG_CLK              427
+#define IMX7D_SAI3_IPG_CLK              428
+#define IMX7D_PLL_AUDIO_TEST_DIV        429
+#define IMX7D_PLL_AUDIO_POST_DIV        430
+#define IMX7D_PLL_VIDEO_TEST_DIV        431
+#define IMX7D_PLL_VIDEO_POST_DIV        432
+#define IMX7D_MU_ROOT_CLK               433
+#define IMX7D_SEMA4_HS_ROOT_CLK         434
+#define IMX7D_PLL_DRAM_TEST_DIV         435
+#define IMX7D_CLK_END                   436
+#endif /* __DT_BINDINGS_CLOCK_IMX7D_H */
diff --git a/include/dt-bindings/clock/jz4740-cgu.h b/include/dt-bindings/clock/jz4740-cgu.h
new file mode 100644
index 000000000000..43153d3e9bd2
--- /dev/null
+++ b/include/dt-bindings/clock/jz4740-cgu.h
@@ -0,0 +1,37 @@
+/*
+ * This header provides clock numbers for the ingenic,jz4740-cgu DT binding.
+ *
+ * They are roughly ordered as:
+ *   - external clocks
+ *   - PLLs
+ *   - muxes/dividers in the order they appear in the jz4740 programmers manual
+ *   - gates in order of their bit in the CLKGR* registers
+ */
+
+#ifndef __DT_BINDINGS_CLOCK_JZ4740_CGU_H__
+#define __DT_BINDINGS_CLOCK_JZ4740_CGU_H__
+
+#define JZ4740_CLK_EXT          0
+#define JZ4740_CLK_RTC          1
+#define JZ4740_CLK_PLL          2
+#define JZ4740_CLK_PLL_HALF     3
+#define JZ4740_CLK_CCLK         4
+#define JZ4740_CLK_HCLK         5
+#define JZ4740_CLK_PCLK         6
+#define JZ4740_CLK_MCLK         7
+#define JZ4740_CLK_LCD          8
+#define JZ4740_CLK_LCD_PCLK     9
+#define JZ4740_CLK_I2S          10
+#define JZ4740_CLK_SPI          11
+#define JZ4740_CLK_MMC          12
+#define JZ4740_CLK_UHC          13
+#define JZ4740_CLK_UDC          14
+#define JZ4740_CLK_UART0        15
+#define JZ4740_CLK_UART1        16
+#define JZ4740_CLK_DMA          17
+#define JZ4740_CLK_IPU          18
+#define JZ4740_CLK_ADC          19
+#define JZ4740_CLK_I2C          20
+#define JZ4740_CLK_AIC          21
+
+#endif /* __DT_BINDINGS_CLOCK_JZ4740_CGU_H__ */
diff --git a/include/dt-bindings/clock/jz4780-cgu.h b/include/dt-bindings/clock/jz4780-cgu.h
new file mode 100644
index 000000000000..467165e3cfee
--- /dev/null
+++ b/include/dt-bindings/clock/jz4780-cgu.h
@@ -0,0 +1,88 @@
+/*
+ * This header provides clock numbers for the ingenic,jz4780-cgu DT binding.
+ *
+ * They are roughly ordered as:
+ *   - external clocks
+ *   - PLLs
+ *   - muxes/dividers in the order they appear in the jz4780 programmers manual
+ *   - gates in order of their bit in the CLKGR* registers
+ */
+
+#ifndef __DT_BINDINGS_CLOCK_JZ4780_CGU_H__
+#define __DT_BINDINGS_CLOCK_JZ4780_CGU_H__
+
+#define JZ4780_CLK_EXCLK        0
+#define JZ4780_CLK_RTCLK        1
+#define JZ4780_CLK_APLL         2
+#define JZ4780_CLK_MPLL         3
+#define JZ4780_CLK_EPLL         4
+#define JZ4780_CLK_VPLL         5
+#define JZ4780_CLK_OTGPHY       6
+#define JZ4780_CLK_SCLKA        7
+#define JZ4780_CLK_CPUMUX       8
+#define JZ4780_CLK_CPU          9
+#define JZ4780_CLK_L2CACHE      10
+#define JZ4780_CLK_AHB0         11
+#define JZ4780_CLK_AHB2PMUX     12
+#define JZ4780_CLK_AHB2         13
+#define JZ4780_CLK_PCLK         14
+#define JZ4780_CLK_DDR          15
+#define JZ4780_CLK_VPU          16
+#define JZ4780_CLK_I2SPLL       17
+#define JZ4780_CLK_I2S          18
+#define JZ4780_CLK_LCD0PIXCLK   19
+#define JZ4780_CLK_LCD1PIXCLK   20
+#define JZ4780_CLK_MSCMUX       21
+#define JZ4780_CLK_MSC0         22
+#define JZ4780_CLK_MSC1         23
+#define JZ4780_CLK_MSC2         24
+#define JZ4780_CLK_UHC          25
+#define JZ4780_CLK_SSIPLL       26
+#define JZ4780_CLK_SSI          27
+#define JZ4780_CLK_CIMMCLK      28
+#define JZ4780_CLK_PCMPLL       29
+#define JZ4780_CLK_PCM          30
+#define JZ4780_CLK_GPU          31
+#define JZ4780_CLK_HDMI         32
+#define JZ4780_CLK_BCH          33
+#define JZ4780_CLK_NEMC         34
+#define JZ4780_CLK_OTG0         35
+#define JZ4780_CLK_SSI0         36
+#define JZ4780_CLK_SMB0         37
+#define JZ4780_CLK_SMB1         38
+#define JZ4780_CLK_SCC          39
+#define JZ4780_CLK_AIC          40
+#define JZ4780_CLK_TSSI0        41
+#define JZ4780_CLK_OWI          42
+#define JZ4780_CLK_KBC          43
+#define JZ4780_CLK_SADC         44
+#define JZ4780_CLK_UART0        45
+#define JZ4780_CLK_UART1        46
+#define JZ4780_CLK_UART2        47
+#define JZ4780_CLK_UART3        48
+#define JZ4780_CLK_SSI1         49
+#define JZ4780_CLK_SSI2         50
+#define JZ4780_CLK_PDMA         51
+#define JZ4780_CLK_GPS          52
+#define JZ4780_CLK_MAC          53
+#define JZ4780_CLK_SMB2         54
+#define JZ4780_CLK_CIM          55
+#define JZ4780_CLK_LCD          56
+#define JZ4780_CLK_TVE          57
+#define JZ4780_CLK_IPU          58
+#define JZ4780_CLK_DDR0         59
+#define JZ4780_CLK_DDR1         60
+#define JZ4780_CLK_SMB3         61
+#define JZ4780_CLK_TSSI1        62
+#define JZ4780_CLK_COMPRESS     63
+#define JZ4780_CLK_AIC1         64
+#define JZ4780_CLK_GPVLC        65
+#define JZ4780_CLK_OTG1         66
+#define JZ4780_CLK_UART4        67
+#define JZ4780_CLK_AHBMON       68
+#define JZ4780_CLK_SMB4         69
+#define JZ4780_CLK_DES          70
+#define JZ4780_CLK_X2D          71
+#define JZ4780_CLK_CORE1        72
+
+#endif /* __DT_BINDINGS_CLOCK_JZ4780_CGU_H__ */
diff --git a/include/dt-bindings/clock/lpc18xx-ccu.h b/include/dt-bindings/clock/lpc18xx-ccu.h
new file mode 100644
index 000000000000..bbfe00b6ab7d
--- /dev/null
+++ b/include/dt-bindings/clock/lpc18xx-ccu.h
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2015 Joachim Eastwood <manabian@gmail.com>
+ *
+ * This code is released using a dual license strategy: BSD/GPL
+ * You can choose the licence that better fits your requirements.
+ *
+ * Released under the terms of 3-clause BSD License
+ * Released under the terms of GNU General Public License Version 2.0
+ *
+ */
+
+/* Clock Control Unit 1 (CCU1) clock offsets */
+#define CLK_APB3_BUS            0x100
+#define CLK_APB3_I2C1           0x108
+#define CLK_APB3_DAC            0x110
+#define CLK_APB3_ADC0           0x118
+#define CLK_APB3_ADC1           0x120
+#define CLK_APB3_CAN0           0x128
+#define CLK_APB1_BUS            0x200
+#define CLK_APB1_MOTOCON_PWM    0x208
+#define CLK_APB1_I2C0           0x210
+#define CLK_APB1_I2S            0x218
+#define CLK_APB1_CAN1           0x220
+#define CLK_SPIFI               0x300
+#define CLK_CPU_BUS             0x400
+#define CLK_CPU_SPIFI           0x408
+#define CLK_CPU_GPIO            0x410
+#define CLK_CPU_LCD             0x418
+#define CLK_CPU_ETHERNET        0x420
+#define CLK_CPU_USB0            0x428
+#define CLK_CPU_EMC             0x430
+#define CLK_CPU_SDIO            0x438
+#define CLK_CPU_DMA             0x440
+#define CLK_CPU_CORE            0x448
+#define CLK_CPU_SCT             0x468
+#define CLK_CPU_USB1            0x470
+#define CLK_CPU_EMCDIV          0x478
+#define CLK_CPU_FLASHA          0x480
+#define CLK_CPU_FLASHB          0x488
+#define CLK_CPU_M0APP           0x490
+#define CLK_CPU_ADCHS           0x498
+#define CLK_CPU_EEPROM          0x4a0
+#define CLK_CPU_WWDT            0x500
+#define CLK_CPU_UART0           0x508
+#define CLK_CPU_UART1           0x510
+#define CLK_CPU_SSP0            0x518
+#define CLK_CPU_TIMER0          0x520
+#define CLK_CPU_TIMER1          0x528
+#define CLK_CPU_SCU             0x530
+#define CLK_CPU_CREG            0x538
+#define CLK_CPU_RITIMER         0x600
+#define CLK_CPU_UART2           0x608
+#define CLK_CPU_UART3           0x610
+#define CLK_CPU_TIMER2          0x618
+#define CLK_CPU_TIMER3          0x620
+#define CLK_CPU_SSP1            0x628
+#define CLK_CPU_QEI             0x630
+#define CLK_PERIPH_BUS          0x700
+#define CLK_PERIPH_CORE         0x710
+#define CLK_PERIPH_SGPIO        0x718
+#define CLK_USB0                0x800
+#define CLK_USB1                0x900
+#define CLK_SPI                 0xA00
+#define CLK_ADCHS               0xB00
+
+/* Clock Control Unit 2 (CCU2) clock offsets */
+#define CLK_AUDIO               0x100
+#define CLK_APB2_UART3          0x200
+#define CLK_APB2_UART2          0x300
+#define CLK_APB0_UART1          0x400
+#define CLK_APB0_UART0          0x500
+#define CLK_APB2_SSP1           0x600
+#define CLK_APB0_SSP0           0x700
+#define CLK_SDIO                0x800
diff --git a/include/dt-bindings/clock/lpc18xx-cgu.h b/include/dt-bindings/clock/lpc18xx-cgu.h
new file mode 100644
index 000000000000..6e57c6d2ca66
--- /dev/null
+++ b/include/dt-bindings/clock/lpc18xx-cgu.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2015 Joachim Eastwood <manabian@gmail.com>
+ *
+ * This code is released using a dual license strategy: BSD/GPL
+ * You can choose the licence that better fits your requirements.
+ *
+ * Released under the terms of 3-clause BSD License
+ * Released under the terms of GNU General Public License Version 2.0
+ *
+ */
+
+/* LPC18xx/43xx base clock ids */
+#define BASE_SAFE_CLK           0
+#define BASE_USB0_CLK           1
+#define BASE_PERIPH_CLK         2
+#define BASE_USB1_CLK           3
+#define BASE_CPU_CLK            4
+#define BASE_SPIFI_CLK          5
+#define BASE_SPI_CLK            6
+#define BASE_PHY_RX_CLK         7
+#define BASE_PHY_TX_CLK         8
+#define BASE_APB1_CLK           9
+#define BASE_APB3_CLK           10
+#define BASE_LCD_CLK            11
+#define BASE_ADCHS_CLK          12
+#define BASE_SDIO_CLK           13
+#define BASE_SSP0_CLK           14
+#define BASE_SSP1_CLK           15
+#define BASE_UART0_CLK          16
+#define BASE_UART1_CLK          17
+#define BASE_UART2_CLK          18
+#define BASE_UART3_CLK          19
+#define BASE_OUT_CLK            20
+#define BASE_RES1_CLK           21
+#define BASE_RES2_CLK           22
+#define BASE_RES3_CLK           23
+#define BASE_RES4_CLK           24
+#define BASE_AUDIO_CLK          25
+#define BASE_CGU_OUT0_CLK       26
+#define BASE_CGU_OUT1_CLK       27
+#define BASE_CLK_MAX            (BASE_CGU_OUT1_CLK + 1)
diff --git a/include/dt-bindings/clock/marvell,mmp2.h b/include/dt-bindings/clock/marvell,mmp2.h
index 591f7fba89e2..7a510384a82a 100644
--- a/include/dt-bindings/clock/marvell,mmp2.h
+++ b/include/dt-bindings/clock/marvell,mmp2.h
@@ -48,6 +48,7 @@
 #define MMP2_CLK_SSP1                   78
 #define MMP2_CLK_SSP2                   79
 #define MMP2_CLK_SSP3                   80
+#define MMP2_CLK_TIMER                  81
 
 /* axi periphrals */
 #define MMP2_CLK_SDH0                   101
diff --git a/include/dt-bindings/clock/marvell,pxa168.h b/include/dt-bindings/clock/marvell,pxa168.h
index 79630b9d74b8..3e45bdfe1aa4 100644
--- a/include/dt-bindings/clock/marvell,pxa168.h
+++ b/include/dt-bindings/clock/marvell,pxa168.h
@@ -18,7 +18,9 @@
 #define PXA168_CLK_PLL1_13_1_5          18
 #define PXA168_CLK_PLL1_2_1_5           19
 #define PXA168_CLK_PLL1_3_16            20
+#define PXA168_CLK_PLL1_192             21
 #define PXA168_CLK_UART_PLL             27
+#define PXA168_CLK_USB_PLL              28
 
 /* apb periphrals */
 #define PXA168_CLK_TWSI0                60
@@ -40,6 +42,7 @@
 #define PXA168_CLK_SSP2                 76
 #define PXA168_CLK_SSP3                 77
 #define PXA168_CLK_SSP4                 78
+#define PXA168_CLK_TIMER                79
 
 /* axi periphrals */
 #define PXA168_CLK_DFC                  100
diff --git a/include/dt-bindings/clock/marvell,pxa1928.h b/include/dt-bindings/clock/marvell,pxa1928.h
new file mode 100644
index 000000000000..d4f2e18919ff
--- /dev/null
+++ b/include/dt-bindings/clock/marvell,pxa1928.h
@@ -0,0 +1,57 @@
+#ifndef __DTS_MARVELL_PXA1928_CLOCK_H
+#define __DTS_MARVELL_PXA1928_CLOCK_H
+
+/*
+ * Clock ID values here correspond to the control register offset/4.
+ */
+
+/* apb peripherals */
+#define PXA1928_CLK_RTC                 0x00
+#define PXA1928_CLK_TWSI0               0x01
+#define PXA1928_CLK_TWSI1               0x02
+#define PXA1928_CLK_TWSI2               0x03
+#define PXA1928_CLK_TWSI3               0x04
+#define PXA1928_CLK_OWIRE               0x05
+#define PXA1928_CLK_KPC                 0x06
+#define PXA1928_CLK_TB_ROTARY           0x07
+#define PXA1928_CLK_SW_JTAG             0x08
+#define PXA1928_CLK_TIMER1              0x09
+#define PXA1928_CLK_UART0               0x0b
+#define PXA1928_CLK_UART1               0x0c
+#define PXA1928_CLK_UART2               0x0d
+#define PXA1928_CLK_GPIO                0x0e
+#define PXA1928_CLK_PWM0                0x0f
+#define PXA1928_CLK_PWM1                0x10
+#define PXA1928_CLK_PWM2                0x11
+#define PXA1928_CLK_PWM3                0x12
+#define PXA1928_CLK_SSP0                0x13
+#define PXA1928_CLK_SSP1                0x14
+#define PXA1928_CLK_SSP2                0x15
+
+#define PXA1928_CLK_TWSI4               0x1f
+#define PXA1928_CLK_TWSI5               0x20
+#define PXA1928_CLK_UART3               0x22
+#define PXA1928_CLK_THSENS_GLOB         0x24
+#define PXA1928_CLK_THSENS_CPU          0x26
+#define PXA1928_CLK_THSENS_VPU          0x27
+#define PXA1928_CLK_THSENS_GC           0x28
+#define PXA1928_APBC_NR_CLKS            0x30
+
+
+/* axi peripherals */
+#define PXA1928_CLK_SDH0                0x15
+#define PXA1928_CLK_SDH1                0x16
+#define PXA1928_CLK_USB                 0x17
+#define PXA1928_CLK_NAND                0x18
+#define PXA1928_CLK_DMA                 0x19
+
+#define PXA1928_CLK_SDH2                0x3a
+#define PXA1928_CLK_SDH3                0x3b
+#define PXA1928_CLK_HSIC                0x3e
+#define PXA1928_CLK_SDH4                0x57
+#define PXA1928_CLK_GC3D                0x5d
+#define PXA1928_CLK_GC2D                0x5f
+
+#define PXA1928_APMU_NR_CLKS            0x60
+
+#endif
diff --git a/include/dt-bindings/clock/marvell,pxa910.h b/include/dt-bindings/clock/marvell,pxa910.h
index 719cffb2bea2..135082a0b62f 100644
--- a/include/dt-bindings/clock/marvell,pxa910.h
+++ b/include/dt-bindings/clock/marvell,pxa910.h
@@ -18,7 +18,9 @@
 #define PXA910_CLK_PLL1_13_1_5          18
 #define PXA910_CLK_PLL1_2_1_5           19
 #define PXA910_CLK_PLL1_3_16            20
+#define PXA910_CLK_PLL1_192             21
 #define PXA910_CLK_UART_PLL             27
+#define PXA910_CLK_USB_PLL              28
 
 /* apb periphrals */
 #define PXA910_CLK_TWSI0                60
@@ -37,6 +39,8 @@
 #define PXA910_CLK_UART2                73
 #define PXA910_CLK_SSP0                 74
 #define PXA910_CLK_SSP1                 75
+#define PXA910_CLK_TIMER0               76
+#define PXA910_CLK_TIMER1               77
 
 /* axi periphrals */
 #define PXA910_CLK_DFC                  100
diff --git a/include/dt-bindings/clock/meson8b-clkc.h b/include/dt-bindings/clock/meson8b-clkc.h
new file mode 100644
index 000000000000..bd2720d58e0c
--- /dev/null
+++ b/include/dt-bindings/clock/meson8b-clkc.h
@@ -0,0 +1,25 @@
+/*
+ * Meson8b clock tree IDs
+ */
+
+#ifndef __MESON8B_CLKC_H
+#define __MESON8B_CLKC_H
+
+#define CLKID_UNUSED            0
+#define CLKID_XTAL              1
+#define CLKID_PLL_FIXED         2
+#define CLKID_PLL_VID           3
+#define CLKID_PLL_SYS           4
+#define CLKID_FCLK_DIV2         5
+#define CLKID_FCLK_DIV3         6
+#define CLKID_FCLK_DIV4         7
+#define CLKID_FCLK_DIV5         8
+#define CLKID_FCLK_DIV7         9
+#define CLKID_CLK81             10
+#define CLKID_MALI              11
+#define CLKID_CPUCLK            12
+#define CLKID_ZERO              13
+
+#define CLK_NR_CLKS             (CLKID_ZERO + 1)
+
+#endif /* __MESON8B_CLKC_H */
diff --git a/include/dt-bindings/clock/mt8135-clk.h b/include/dt-bindings/clock/mt8135-clk.h
new file mode 100644
index 000000000000..6dac6c091dd2
--- /dev/null
+++ b/include/dt-bindings/clock/mt8135-clk.h
@@ -0,0 +1,194 @@
+/*
+ * Copyright (c) 2014 MediaTek Inc.
+ * Author: James Liao <jamesjj.liao@mediatek.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef _DT_BINDINGS_CLK_MT8135_H
+#define _DT_BINDINGS_CLK_MT8135_H
+
+/* TOPCKGEN */
+
+#define CLK_TOP_DSI0_LNTC_DSICLK        1
+#define CLK_TOP_HDMITX_CLKDIG_CTS       2
+#define CLK_TOP_CLKPH_MCK               3
+#define CLK_TOP_CPUM_TCK_IN             4
+#define CLK_TOP_MAINPLL_806M            5
+#define CLK_TOP_MAINPLL_537P3M          6
+#define CLK_TOP_MAINPLL_322P4M          7
+#define CLK_TOP_MAINPLL_230P3M          8
+#define CLK_TOP_UNIVPLL_624M            9
+#define CLK_TOP_UNIVPLL_416M            10
+#define CLK_TOP_UNIVPLL_249P6M          11
+#define CLK_TOP_UNIVPLL_178P3M          12
+#define CLK_TOP_UNIVPLL_48M             13
+#define CLK_TOP_MMPLL_D2                14
+#define CLK_TOP_MMPLL_D3                15
+#define CLK_TOP_MMPLL_D5                16
+#define CLK_TOP_MMPLL_D7                17
+#define CLK_TOP_MMPLL_D4                18
+#define CLK_TOP_MMPLL_D6                19
+#define CLK_TOP_SYSPLL_D2               20
+#define CLK_TOP_SYSPLL_D4               21
+#define CLK_TOP_SYSPLL_D6               22
+#define CLK_TOP_SYSPLL_D8               23
+#define CLK_TOP_SYSPLL_D10              24
+#define CLK_TOP_SYSPLL_D12              25
+#define CLK_TOP_SYSPLL_D16              26
+#define CLK_TOP_SYSPLL_D24              27
+#define CLK_TOP_SYSPLL_D3               28
+#define CLK_TOP_SYSPLL_D2P5             29
+#define CLK_TOP_SYSPLL_D5               30
+#define CLK_TOP_SYSPLL_D3P5             31
+#define CLK_TOP_UNIVPLL1_D2             32
+#define CLK_TOP_UNIVPLL1_D4             33
+#define CLK_TOP_UNIVPLL1_D6             34
+#define CLK_TOP_UNIVPLL1_D8             35
+#define CLK_TOP_UNIVPLL1_D10            36
+#define CLK_TOP_UNIVPLL2_D2             37
+#define CLK_TOP_UNIVPLL2_D4             38
+#define CLK_TOP_UNIVPLL2_D6             39
+#define CLK_TOP_UNIVPLL2_D8             40
+#define CLK_TOP_UNIVPLL_D3              41
+#define CLK_TOP_UNIVPLL_D5              42
+#define CLK_TOP_UNIVPLL_D7              43
+#define CLK_TOP_UNIVPLL_D10             44
+#define CLK_TOP_UNIVPLL_D26             45
+#define CLK_TOP_APLL                    46
+#define CLK_TOP_APLL_D4                 47
+#define CLK_TOP_APLL_D8                 48
+#define CLK_TOP_APLL_D16                49
+#define CLK_TOP_APLL_D24                50
+#define CLK_TOP_LVDSPLL_D2              51
+#define CLK_TOP_LVDSPLL_D4              52
+#define CLK_TOP_LVDSPLL_D8              53
+#define CLK_TOP_LVDSTX_CLKDIG_CT        54
+#define CLK_TOP_VPLL_DPIX               55
+#define CLK_TOP_TVHDMI_H                56
+#define CLK_TOP_HDMITX_CLKDIG_D2        57
+#define CLK_TOP_HDMITX_CLKDIG_D3        58
+#define CLK_TOP_TVHDMI_D2               59
+#define CLK_TOP_TVHDMI_D4               60
+#define CLK_TOP_MEMPLL_MCK_D4           61
+#define CLK_TOP_AXI_SEL                 62
+#define CLK_TOP_SMI_SEL                 63
+#define CLK_TOP_MFG_SEL                 64
+#define CLK_TOP_IRDA_SEL                65
+#define CLK_TOP_CAM_SEL                 66
+#define CLK_TOP_AUD_INTBUS_SEL          67
+#define CLK_TOP_JPG_SEL                 68
+#define CLK_TOP_DISP_SEL                69
+#define CLK_TOP_MSDC30_1_SEL            70
+#define CLK_TOP_MSDC30_2_SEL            71
+#define CLK_TOP_MSDC30_3_SEL            72
+#define CLK_TOP_MSDC30_4_SEL            73
+#define CLK_TOP_USB20_SEL               74
+#define CLK_TOP_VENC_SEL                75
+#define CLK_TOP_SPI_SEL                 76
+#define CLK_TOP_UART_SEL                77
+#define CLK_TOP_MEM_SEL                 78
+#define CLK_TOP_CAMTG_SEL               79
+#define CLK_TOP_AUDIO_SEL               80
+#define CLK_TOP_FIX_SEL                 81
+#define CLK_TOP_VDEC_SEL                82
+#define CLK_TOP_DDRPHYCFG_SEL           83
+#define CLK_TOP_DPILVDS_SEL             84
+#define CLK_TOP_PMICSPI_SEL             85
+#define CLK_TOP_MSDC30_0_SEL            86
+#define CLK_TOP_SMI_MFG_AS_SEL          87
+#define CLK_TOP_GCPU_SEL                88
+#define CLK_TOP_DPI1_SEL                89
+#define CLK_TOP_CCI_SEL                 90
+#define CLK_TOP_APLL_SEL                91
+#define CLK_TOP_HDMIPLL_SEL             92
+#define CLK_TOP_NR_CLK                  93
+
+/* APMIXED_SYS */
+
+#define CLK_APMIXED_ARMPLL1             1
+#define CLK_APMIXED_ARMPLL2             2
+#define CLK_APMIXED_MAINPLL             3
+#define CLK_APMIXED_UNIVPLL             4
+#define CLK_APMIXED_MMPLL               5
+#define CLK_APMIXED_MSDCPLL             6
+#define CLK_APMIXED_TVDPLL              7
+#define CLK_APMIXED_LVDSPLL             8
+#define CLK_APMIXED_AUDPLL              9
+#define CLK_APMIXED_VDECPLL             10
+#define CLK_APMIXED_NR_CLK              11
+
+/* INFRA_SYS */
+
+#define CLK_INFRA_PMIC_WRAP             1
+#define CLK_INFRA_PMICSPI               2
+#define CLK_INFRA_CCIF1_AP_CTRL         3
+#define CLK_INFRA_CCIF0_AP_CTRL         4
+#define CLK_INFRA_KP                    5
+#define CLK_INFRA_CPUM                  6
+#define CLK_INFRA_M4U                   7
+#define CLK_INFRA_MFGAXI                8
+#define CLK_INFRA_DEVAPC                9
+#define CLK_INFRA_AUDIO                 10
+#define CLK_INFRA_MFG_BUS               11
+#define CLK_INFRA_SMI                   12
+#define CLK_INFRA_DBGCLK                13
+#define CLK_INFRA_NR_CLK                14
+
+/* PERI_SYS */
+
+#define CLK_PERI_I2C5                   1
+#define CLK_PERI_I2C4                   2
+#define CLK_PERI_I2C3                   3
+#define CLK_PERI_I2C2                   4
+#define CLK_PERI_I2C1                   5
+#define CLK_PERI_I2C0                   6
+#define CLK_PERI_UART3                  7
+#define CLK_PERI_UART2                  8
+#define CLK_PERI_UART1                  9
+#define CLK_PERI_UART0                  10
+#define CLK_PERI_IRDA                   11
+#define CLK_PERI_NLI                    12
+#define CLK_PERI_MD_HIF                 13
+#define CLK_PERI_AP_HIF                 14
+#define CLK_PERI_MSDC30_3               15
+#define CLK_PERI_MSDC30_2               16
+#define CLK_PERI_MSDC30_1               17
+#define CLK_PERI_MSDC20_2               18
+#define CLK_PERI_MSDC20_1               19
+#define CLK_PERI_AP_DMA                 20
+#define CLK_PERI_USB1                   21
+#define CLK_PERI_USB0                   22
+#define CLK_PERI_PWM                    23
+#define CLK_PERI_PWM7                   24
+#define CLK_PERI_PWM6                   25
+#define CLK_PERI_PWM5                   26
+#define CLK_PERI_PWM4                   27
+#define CLK_PERI_PWM3                   28
+#define CLK_PERI_PWM2                   29
+#define CLK_PERI_PWM1                   30
+#define CLK_PERI_THERM                  31
+#define CLK_PERI_NFI                    32
+#define CLK_PERI_USBSLV                 33
+#define CLK_PERI_USB1_MCU               34
+#define CLK_PERI_USB0_MCU               35
+#define CLK_PERI_GCPU                   36
+#define CLK_PERI_FHCTL                  37
+#define CLK_PERI_SPI1                   38
+#define CLK_PERI_AUXADC                 39
+#define CLK_PERI_PERI_PWRAP             40
+#define CLK_PERI_I2C6                   41
+#define CLK_PERI_UART0_SEL              42
+#define CLK_PERI_UART1_SEL              43
+#define CLK_PERI_UART2_SEL              44
+#define CLK_PERI_UART3_SEL              45
+#define CLK_PERI_NR_CLK                 46
+
+#endif /* _DT_BINDINGS_CLK_MT8135_H */
diff --git a/include/dt-bindings/clock/mt8173-clk.h b/include/dt-bindings/clock/mt8173-clk.h
new file mode 100644
index 000000000000..4ad76ed882ad
--- /dev/null
+++ b/include/dt-bindings/clock/mt8173-clk.h
@@ -0,0 +1,235 @@
+/*
+ * Copyright (c) 2014 MediaTek Inc.
+ * Author: James Liao <jamesjj.liao@mediatek.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef _DT_BINDINGS_CLK_MT8173_H
+#define _DT_BINDINGS_CLK_MT8173_H
+
+/* TOPCKGEN */
+
+#define CLK_TOP_CLKPH_MCK_O             1
+#define CLK_TOP_DPI                     2
+#define CLK_TOP_USB_SYSPLL_125M         3
+#define CLK_TOP_HDMITX_DIG_CTS          4
+#define CLK_TOP_ARMCA7PLL_754M          5
+#define CLK_TOP_ARMCA7PLL_502M          6
+#define CLK_TOP_MAIN_H546M              7
+#define CLK_TOP_MAIN_H364M              8
+#define CLK_TOP_MAIN_H218P4M            9
+#define CLK_TOP_MAIN_H156M              10
+#define CLK_TOP_TVDPLL_445P5M           11
+#define CLK_TOP_TVDPLL_594M             12
+#define CLK_TOP_UNIV_624M               13
+#define CLK_TOP_UNIV_416M               14
+#define CLK_TOP_UNIV_249P6M             15
+#define CLK_TOP_UNIV_178P3M             16
+#define CLK_TOP_UNIV_48M                17
+#define CLK_TOP_CLKRTC_EXT              18
+#define CLK_TOP_CLKRTC_INT              19
+#define CLK_TOP_FPC                     20
+#define CLK_TOP_HDMITXPLL_D2            21
+#define CLK_TOP_HDMITXPLL_D3            22
+#define CLK_TOP_ARMCA7PLL_D2            23
+#define CLK_TOP_ARMCA7PLL_D3            24
+#define CLK_TOP_APLL1                   25
+#define CLK_TOP_APLL2                   26
+#define CLK_TOP_DMPLL                   27
+#define CLK_TOP_DMPLL_D2                28
+#define CLK_TOP_DMPLL_D4                29
+#define CLK_TOP_DMPLL_D8                30
+#define CLK_TOP_DMPLL_D16               31
+#define CLK_TOP_LVDSPLL_D2              32
+#define CLK_TOP_LVDSPLL_D4              33
+#define CLK_TOP_LVDSPLL_D8              34
+#define CLK_TOP_MMPLL                   35
+#define CLK_TOP_MMPLL_D2                36
+#define CLK_TOP_MSDCPLL                 37
+#define CLK_TOP_MSDCPLL_D2              38
+#define CLK_TOP_MSDCPLL_D4              39
+#define CLK_TOP_MSDCPLL2                40
+#define CLK_TOP_MSDCPLL2_D2             41
+#define CLK_TOP_MSDCPLL2_D4             42
+#define CLK_TOP_SYSPLL_D2               43
+#define CLK_TOP_SYSPLL1_D2              44
+#define CLK_TOP_SYSPLL1_D4              45
+#define CLK_TOP_SYSPLL1_D8              46
+#define CLK_TOP_SYSPLL1_D16             47
+#define CLK_TOP_SYSPLL_D3               48
+#define CLK_TOP_SYSPLL2_D2              49
+#define CLK_TOP_SYSPLL2_D4              50
+#define CLK_TOP_SYSPLL_D5               51
+#define CLK_TOP_SYSPLL3_D2              52
+#define CLK_TOP_SYSPLL3_D4              53
+#define CLK_TOP_SYSPLL_D7               54
+#define CLK_TOP_SYSPLL4_D2              55
+#define CLK_TOP_SYSPLL4_D4              56
+#define CLK_TOP_TVDPLL                  57
+#define CLK_TOP_TVDPLL_D2               58
+#define CLK_TOP_TVDPLL_D4               59
+#define CLK_TOP_TVDPLL_D8               60
+#define CLK_TOP_TVDPLL_D16              61
+#define CLK_TOP_UNIVPLL_D2              62
+#define CLK_TOP_UNIVPLL1_D2             63
+#define CLK_TOP_UNIVPLL1_D4             64
+#define CLK_TOP_UNIVPLL1_D8             65
+#define CLK_TOP_UNIVPLL_D3              66
+#define CLK_TOP_UNIVPLL2_D2             67
+#define CLK_TOP_UNIVPLL2_D4             68
+#define CLK_TOP_UNIVPLL2_D8             69
+#define CLK_TOP_UNIVPLL_D5              70
+#define CLK_TOP_UNIVPLL3_D2             71
+#define CLK_TOP_UNIVPLL3_D4             72
+#define CLK_TOP_UNIVPLL3_D8             73
+#define CLK_TOP_UNIVPLL_D7              74
+#define CLK_TOP_UNIVPLL_D26             75
+#define CLK_TOP_UNIVPLL_D52             76
+#define CLK_TOP_VCODECPLL               77
+#define CLK_TOP_VCODECPLL_370P5         78
+#define CLK_TOP_VENCPLL                 79
+#define CLK_TOP_VENCPLL_D2              80
+#define CLK_TOP_VENCPLL_D4              81
+#define CLK_TOP_AXI_SEL                 82
+#define CLK_TOP_MEM_SEL                 83
+#define CLK_TOP_DDRPHYCFG_SEL           84
+#define CLK_TOP_MM_SEL                  85
+#define CLK_TOP_PWM_SEL                 86
+#define CLK_TOP_VDEC_SEL                87
+#define CLK_TOP_VENC_SEL                88
+#define CLK_TOP_MFG_SEL                 89
+#define CLK_TOP_CAMTG_SEL               90
+#define CLK_TOP_UART_SEL                91
+#define CLK_TOP_SPI_SEL                 92
+#define CLK_TOP_USB20_SEL               93
+#define CLK_TOP_USB30_SEL               94
+#define CLK_TOP_MSDC50_0_H_SEL          95
+#define CLK_TOP_MSDC50_0_SEL            96
+#define CLK_TOP_MSDC30_1_SEL            97
+#define CLK_TOP_MSDC30_2_SEL            98
+#define CLK_TOP_MSDC30_3_SEL            99
+#define CLK_TOP_AUDIO_SEL               100
+#define CLK_TOP_AUD_INTBUS_SEL          101
+#define CLK_TOP_PMICSPI_SEL             102
+#define CLK_TOP_SCP_SEL                 103
+#define CLK_TOP_ATB_SEL                 104
+#define CLK_TOP_VENC_LT_SEL             105
+#define CLK_TOP_DPI0_SEL                106
+#define CLK_TOP_IRDA_SEL                107
+#define CLK_TOP_CCI400_SEL              108
+#define CLK_TOP_AUD_1_SEL               109
+#define CLK_TOP_AUD_2_SEL               110
+#define CLK_TOP_MEM_MFG_IN_SEL          111
+#define CLK_TOP_AXI_MFG_IN_SEL          112
+#define CLK_TOP_SCAM_SEL                113
+#define CLK_TOP_SPINFI_IFR_SEL          114
+#define CLK_TOP_HDMI_SEL                115
+#define CLK_TOP_DPILVDS_SEL             116
+#define CLK_TOP_MSDC50_2_H_SEL          117
+#define CLK_TOP_HDCP_SEL                118
+#define CLK_TOP_HDCP_24M_SEL            119
+#define CLK_TOP_RTC_SEL                 120
+#define CLK_TOP_APLL1_DIV0              121
+#define CLK_TOP_APLL1_DIV1              122
+#define CLK_TOP_APLL1_DIV2              123
+#define CLK_TOP_APLL1_DIV3              124
+#define CLK_TOP_APLL1_DIV4              125
+#define CLK_TOP_APLL1_DIV5              126
+#define CLK_TOP_APLL2_DIV0              127
+#define CLK_TOP_APLL2_DIV1              128
+#define CLK_TOP_APLL2_DIV2              129
+#define CLK_TOP_APLL2_DIV3              130
+#define CLK_TOP_APLL2_DIV4              131
+#define CLK_TOP_APLL2_DIV5              132
+#define CLK_TOP_I2S0_M_SEL              133
+#define CLK_TOP_I2S1_M_SEL              134
+#define CLK_TOP_I2S2_M_SEL              135
+#define CLK_TOP_I2S3_M_SEL              136
+#define CLK_TOP_I2S3_B_SEL              137
+#define CLK_TOP_NR_CLK                  138
+
+/* APMIXED_SYS */
+
+#define CLK_APMIXED_ARMCA15PLL  1
+#define CLK_APMIXED_ARMCA7PLL   2
+#define CLK_APMIXED_MAINPLL             3
+#define CLK_APMIXED_UNIVPLL             4
+#define CLK_APMIXED_MMPLL               5
+#define CLK_APMIXED_MSDCPLL             6
+#define CLK_APMIXED_VENCPLL             7
+#define CLK_APMIXED_TVDPLL              8
+#define CLK_APMIXED_MPLL                9
+#define CLK_APMIXED_VCODECPLL           10
+#define CLK_APMIXED_APLL1               11
+#define CLK_APMIXED_APLL2               12
+#define CLK_APMIXED_LVDSPLL             13
+#define CLK_APMIXED_MSDCPLL2            14
+#define CLK_APMIXED_NR_CLK              15
+
+/* INFRA_SYS */
+
+#define CLK_INFRA_DBGCLK                1
+#define CLK_INFRA_SMI                   2
+#define CLK_INFRA_AUDIO                 3
+#define CLK_INFRA_GCE                   4
+#define CLK_INFRA_L2C_SRAM              5
+#define CLK_INFRA_M4U                   6
+#define CLK_INFRA_CPUM                  7
+#define CLK_INFRA_KP                    8
+#define CLK_INFRA_CEC                   9
+#define CLK_INFRA_PMICSPI               10
+#define CLK_INFRA_PMICWRAP              11
+#define CLK_INFRA_NR_CLK                12
+
+/* PERI_SYS */
+
+#define CLK_PERI_NFI                    1
+#define CLK_PERI_THERM                  2
+#define CLK_PERI_PWM1                   3
+#define CLK_PERI_PWM2                   4
+#define CLK_PERI_PWM3                   5
+#define CLK_PERI_PWM4                   6
+#define CLK_PERI_PWM5                   7
+#define CLK_PERI_PWM6                   8
+#define CLK_PERI_PWM7                   9
+#define CLK_PERI_PWM                    10
+#define CLK_PERI_USB0                   11
+#define CLK_PERI_USB1                   12
+#define CLK_PERI_AP_DMA                 13
+#define CLK_PERI_MSDC30_0               14
+#define CLK_PERI_MSDC30_1               15
+#define CLK_PERI_MSDC30_2               16
+#define CLK_PERI_MSDC30_3               17
+#define CLK_PERI_NLI_ARB                18
+#define CLK_PERI_IRDA                   19
+#define CLK_PERI_UART0                  20
+#define CLK_PERI_UART1                  21
+#define CLK_PERI_UART2                  22
+#define CLK_PERI_UART3                  23
+#define CLK_PERI_I2C0                   24
+#define CLK_PERI_I2C1                   25
+#define CLK_PERI_I2C2                   26
+#define CLK_PERI_I2C3                   27
+#define CLK_PERI_I2C4                   28
+#define CLK_PERI_AUXADC                 29
+#define CLK_PERI_SPI0                   30
+#define CLK_PERI_I2C5                   31
+#define CLK_PERI_NFIECC                 32
+#define CLK_PERI_SPI                    33
+#define CLK_PERI_IRRX                   34
+#define CLK_PERI_I2C6                   35
+#define CLK_PERI_UART0_SEL              36
+#define CLK_PERI_UART1_SEL              37
+#define CLK_PERI_UART2_SEL              38
+#define CLK_PERI_UART3_SEL              39
+#define CLK_PERI_NR_CLK                 40
+
+#endif /* _DT_BINDINGS_CLK_MT8173_H */
diff --git a/include/dt-bindings/clock/qcom,gcc-ipq806x.h b/include/dt-bindings/clock/qcom,gcc-ipq806x.h
index ebd63fd05649..dc4254b8cbbc 100644
--- a/include/dt-bindings/clock/qcom,gcc-ipq806x.h
+++ b/include/dt-bindings/clock/qcom,gcc-ipq806x.h
@@ -289,5 +289,7 @@
 #define UBI32_CORE1_CLK                         279
 #define UBI32_CORE2_CLK                         280
 #define EBI2_AON_CLK                            281
+#define NSSTCM_CLK_SRC                          282
+#define NSSTCM_CLK                              283
 
 #endif
diff --git a/include/dt-bindings/clock/r8a73a4-clock.h b/include/dt-bindings/clock/r8a73a4-clock.h
index 9a4b4c9ca44a..dd11ecdf837e 100644
--- a/include/dt-bindings/clock/r8a73a4-clock.h
+++ b/include/dt-bindings/clock/r8a73a4-clock.h
@@ -54,6 +54,7 @@
 #define R8A73A4_CLK_IIC3        11
 #define R8A73A4_CLK_IIC4        10
 #define R8A73A4_CLK_IIC5        9
+#define R8A73A4_CLK_IRQC        7
 
 /* MSTP5 */
 #define R8A73A4_CLK_THERMAL     22
diff --git a/include/dt-bindings/clock/r8a7790-clock.h b/include/dt-bindings/clock/r8a7790-clock.h
index 3f2c6b198d4a..ff7ca3584e16 100644
--- a/include/dt-bindings/clock/r8a7790-clock.h
+++ b/include/dt-bindings/clock/r8a7790-clock.h
@@ -79,6 +79,9 @@
 #define R8A7790_CLK_USBDMAC0            30
 #define R8A7790_CLK_USBDMAC1            31
 
+/* MSTP4 */
+#define R8A7790_CLK_IRQC                7
+
 /* MSTP5 */
 #define R8A7790_CLK_AUDIO_DMAC1         1
 #define R8A7790_CLK_AUDIO_DMAC0         2
diff --git a/include/dt-bindings/clock/r8a7791-clock.h b/include/dt-bindings/clock/r8a7791-clock.h
index 8fc5dc8faeea..402268384b99 100644
--- a/include/dt-bindings/clock/r8a7791-clock.h
+++ b/include/dt-bindings/clock/r8a7791-clock.h
@@ -70,6 +70,9 @@
 #define R8A7791_CLK_USBDMAC0            30
 #define R8A7791_CLK_USBDMAC1            31
 
+/* MSTP4 */
+#define R8A7791_CLK_IRQC                7
+
 /* MSTP5 */
 #define R8A7791_CLK_AUDIO_DMAC1         1
 #define R8A7791_CLK_AUDIO_DMAC0         2
diff --git a/include/dt-bindings/clock/r8a7794-clock.h b/include/dt-bindings/clock/r8a7794-clock.h
index d63323032d6e..09da38a58776 100644
--- a/include/dt-bindings/clock/r8a7794-clock.h
+++ b/include/dt-bindings/clock/r8a7794-clock.h
@@ -60,6 +60,9 @@
 #define R8A7794_CLK_USBDMAC0            30
 #define R8A7794_CLK_USBDMAC1            31
 
+/* MSTP4 */
+#define R8A7794_CLK_IRQC                7
+
 /* MSTP5 */
 #define R8A7794_CLK_THERMAL             22
 #define R8A7794_CLK_PWM                 23
diff --git a/include/dt-bindings/clock/samsung,s2mps11.h b/include/dt-bindings/clock/samsung,s2mps11.h
new file mode 100644
index 000000000000..b903d7de27c9
--- /dev/null
+++ b/include/dt-bindings/clock/samsung,s2mps11.h
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2015 Markus Reichl
+ *
+ * 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.
+ *
+ * Device Tree binding constants clocks for the Samsung S2MPS11 PMIC.
+ */
+
+#ifndef _DT_BINDINGS_CLOCK_SAMSUNG_S2MPS11_CLOCK_H
+#define _DT_BINDINGS_CLOCK_SAMSUNG_S2MPS11_CLOCK_H
+
+/* Fixed rate clocks. */
+
+#define S2MPS11_CLK_AP          0
+#define S2MPS11_CLK_CP          1
+#define S2MPS11_CLK_BT          2
+
+/* Total number of clocks. */
+#define S2MPS11_CLKS_NUM                (S2MPS11_CLK_BT + 1)
+
+#endif /* _DT_BINDINGS_CLOCK_SAMSUNG_S2MPS11_CLOCK_H */
diff --git a/include/dt-bindings/clock/vf610-clock.h b/include/dt-bindings/clock/vf610-clock.h
index 979d24a6799f..d19763439472 100644
--- a/include/dt-bindings/clock/vf610-clock.h
+++ b/include/dt-bindings/clock/vf610-clock.h
@@ -193,6 +193,7 @@
 #define VF610_PLL6_BYPASS               180
 #define VF610_PLL7_BYPASS               181
 #define VF610_CLK_SNVS                  182
-#define VF610_CLK_END                   183
+#define VF610_CLK_DAP                   183
+#define VF610_CLK_END                   184
 
 #endif /* __DT_BINDINGS_CLOCK_VF610_H */
diff --git a/include/dt-bindings/clock/zx296702-clock.h b/include/dt-bindings/clock/zx296702-clock.h
new file mode 100644
index 000000000000..e683dbb7e7c5
--- /dev/null
+++ b/include/dt-bindings/clock/zx296702-clock.h
@@ -0,0 +1,170 @@
+/*
+ * Copyright 2014 Linaro Ltd.
+ * Copyright (C) 2014 ZTE 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.
+ */
+
+#ifndef __DT_BINDINGS_CLOCK_ZX296702_H
+#define __DT_BINDINGS_CLOCK_ZX296702_H
+
+#define ZX296702_OSC                            0
+#define ZX296702_PLL_A9                         1
+#define ZX296702_PLL_A9_350M                    2
+#define ZX296702_PLL_MAC_1000M                  3
+#define ZX296702_PLL_MAC_333M                   4
+#define ZX296702_PLL_MM0_1188M                  5
+#define ZX296702_PLL_MM0_396M                   6
+#define ZX296702_PLL_MM0_198M                   7
+#define ZX296702_PLL_MM1_108M                   8
+#define ZX296702_PLL_MM1_72M                    9
+#define ZX296702_PLL_MM1_54M                    10
+#define ZX296702_PLL_LSP_104M                   11
+#define ZX296702_PLL_LSP_26M                    12
+#define ZX296702_PLL_AUDIO_294M912              13
+#define ZX296702_PLL_DDR_266M                   14
+#define ZX296702_CLK_148M5                      15
+#define ZX296702_MATRIX_ACLK                    16
+#define ZX296702_MAIN_HCLK                      17
+#define ZX296702_MAIN_PCLK                      18
+#define ZX296702_CLK_500                        19
+#define ZX296702_CLK_250                        20
+#define ZX296702_CLK_125                        21
+#define ZX296702_CLK_74M25                      22
+#define ZX296702_A9_WCLK                        23
+#define ZX296702_A9_AS1_ACLK_MUX                24
+#define ZX296702_A9_TRACE_CLKIN_MUX             25
+#define ZX296702_A9_AS1_ACLK_DIV                26
+#define ZX296702_CLK_2                          27
+#define ZX296702_CLK_27                         28
+#define ZX296702_DECPPU_ACLK_MUX                29
+#define ZX296702_PPU_ACLK_MUX                   30
+#define ZX296702_MALI400_ACLK_MUX               31
+#define ZX296702_VOU_ACLK_MUX                   32
+#define ZX296702_VOU_MAIN_WCLK_MUX              33
+#define ZX296702_VOU_AUX_WCLK_MUX               34
+#define ZX296702_VOU_SCALER_WCLK_MUX            35
+#define ZX296702_R2D_ACLK_MUX                   36
+#define ZX296702_R2D_WCLK_MUX                   37
+#define ZX296702_CLK_50                         38
+#define ZX296702_CLK_25                         39
+#define ZX296702_CLK_12                         40
+#define ZX296702_CLK_16M384                     41
+#define ZX296702_CLK_32K768                     42
+#define ZX296702_SEC_WCLK_DIV                   43
+#define ZX296702_DDR_WCLK_MUX                   44
+#define ZX296702_NAND_WCLK_MUX                  45
+#define ZX296702_LSP_26_WCLK_MUX                46
+#define ZX296702_A9_AS0_ACLK                    47
+#define ZX296702_A9_AS1_ACLK                    48
+#define ZX296702_A9_TRACE_CLKIN                 49
+#define ZX296702_DECPPU_AXI_M_ACLK              50
+#define ZX296702_DECPPU_AHB_S_HCLK              51
+#define ZX296702_PPU_AXI_M_ACLK                 52
+#define ZX296702_PPU_AHB_S_HCLK                 53
+#define ZX296702_VOU_AXI_M_ACLK                 54
+#define ZX296702_VOU_APB_PCLK                   55
+#define ZX296702_VOU_MAIN_CHANNEL_WCLK          56
+#define ZX296702_VOU_AUX_CHANNEL_WCLK           57
+#define ZX296702_VOU_HDMI_OSCLK_CEC             58
+#define ZX296702_VOU_SCALER_WCLK                59
+#define ZX296702_MALI400_AXI_M_ACLK             60
+#define ZX296702_MALI400_APB_PCLK               61
+#define ZX296702_R2D_WCLK                       62
+#define ZX296702_R2D_AXI_M_ACLK                 63
+#define ZX296702_R2D_AHB_HCLK                   64
+#define ZX296702_DDR3_AXI_S0_ACLK               65
+#define ZX296702_DDR3_APB_PCLK                  66
+#define ZX296702_DDR3_WCLK                      67
+#define ZX296702_USB20_0_AHB_HCLK               68
+#define ZX296702_USB20_0_EXTREFCLK              69
+#define ZX296702_USB20_1_AHB_HCLK               70
+#define ZX296702_USB20_1_EXTREFCLK              71
+#define ZX296702_USB20_2_AHB_HCLK               72
+#define ZX296702_USB20_2_EXTREFCLK              73
+#define ZX296702_GMAC_AXI_M_ACLK                74
+#define ZX296702_GMAC_APB_PCLK                  75
+#define ZX296702_GMAC_125_CLKIN                 76
+#define ZX296702_GMAC_RMII_CLKIN                77
+#define ZX296702_GMAC_25M_CLK                   78
+#define ZX296702_NANDFLASH_AHB_HCLK             79
+#define ZX296702_NANDFLASH_WCLK                 80
+#define ZX296702_LSP0_APB_PCLK                  81
+#define ZX296702_LSP0_AHB_HCLK                  82
+#define ZX296702_LSP0_26M_WCLK                  83
+#define ZX296702_LSP0_104M_WCLK                 84
+#define ZX296702_LSP0_16M384_WCLK               85
+#define ZX296702_LSP1_APB_PCLK                  86
+#define ZX296702_LSP1_26M_WCLK                  87
+#define ZX296702_LSP1_104M_WCLK                 88
+#define ZX296702_LSP1_32K_CLK                   89
+#define ZX296702_AON_HCLK                       90
+#define ZX296702_SYS_CTRL_PCLK                  91
+#define ZX296702_DMA_PCLK                       92
+#define ZX296702_DMA_ACLK                       93
+#define ZX296702_SEC_HCLK                       94
+#define ZX296702_AES_WCLK                       95
+#define ZX296702_DES_WCLK                       96
+#define ZX296702_IRAM_ACLK                      97
+#define ZX296702_IROM_ACLK                      98
+#define ZX296702_BOOT_CTRL_HCLK                 99
+#define ZX296702_EFUSE_CLK_30                   100
+#define ZX296702_VOU_MAIN_CHANNEL_DIV           101
+#define ZX296702_VOU_AUX_CHANNEL_DIV            102
+#define ZX296702_VOU_TV_ENC_HD_DIV              103
+#define ZX296702_VOU_TV_ENC_SD_DIV              104
+#define ZX296702_VL0_MUX                        105
+#define ZX296702_VL1_MUX                        106
+#define ZX296702_VL2_MUX                        107
+#define ZX296702_GL0_MUX                        108
+#define ZX296702_GL1_MUX                        109
+#define ZX296702_GL2_MUX                        110
+#define ZX296702_WB_MUX                         111
+#define ZX296702_HDMI_MUX                       112
+#define ZX296702_VOU_TV_ENC_HD_MUX              113
+#define ZX296702_VOU_TV_ENC_SD_MUX              114
+#define ZX296702_VL0_CLK                        115
+#define ZX296702_VL1_CLK                        116
+#define ZX296702_VL2_CLK                        117
+#define ZX296702_GL0_CLK                        118
+#define ZX296702_GL1_CLK                        119
+#define ZX296702_GL2_CLK                        120
+#define ZX296702_WB_CLK                         121
+#define ZX296702_CL_CLK                         122
+#define ZX296702_MAIN_MIX_CLK                   123
+#define ZX296702_AUX_MIX_CLK                    124
+#define ZX296702_HDMI_CLK                       125
+#define ZX296702_VOU_TV_ENC_HD_DAC_CLK          126
+#define ZX296702_VOU_TV_ENC_SD_DAC_CLK          127
+#define ZX296702_A9_PERIPHCLK                   128
+#define ZX296702_TOPCLK_END                     129
+
+#define ZX296702_SDMMC1_WCLK_MUX                0
+#define ZX296702_SDMMC1_WCLK_DIV                1
+#define ZX296702_SDMMC1_WCLK                    2
+#define ZX296702_SDMMC1_PCLK                    3
+#define ZX296702_SPDIF0_WCLK_MUX                4
+#define ZX296702_SPDIF0_WCLK                    5
+#define ZX296702_SPDIF0_PCLK                    6
+#define ZX296702_SPDIF0_DIV                     7
+#define ZX296702_I2S0_WCLK_MUX                  8
+#define ZX296702_I2S0_WCLK                      9
+#define ZX296702_I2S0_PCLK                      10
+#define ZX296702_I2S0_DIV                       11
+#define ZX296702_LSP0CLK_END                    12
+
+#define ZX296702_UART0_WCLK_MUX                 0
+#define ZX296702_UART0_WCLK                     1
+#define ZX296702_UART0_PCLK                     2
+#define ZX296702_UART1_WCLK_MUX                 3
+#define ZX296702_UART1_WCLK                     4
+#define ZX296702_UART1_PCLK                     5
+#define ZX296702_SDMMC0_WCLK_MUX                6
+#define ZX296702_SDMMC0_WCLK_DIV                7
+#define ZX296702_SDMMC0_WCLK                    8
+#define ZX296702_SDMMC0_PCLK                    9
+#define ZX296702_LSP1CLK_END                    10
+
+#endif /* __DT_BINDINGS_CLOCK_ZX296702_H */
diff --git a/include/dt-bindings/mfd/arizona.h b/include/dt-bindings/mfd/arizona.h
index c7af7c7ef793..7b2000cead43 100644
--- a/include/dt-bindings/mfd/arizona.h
+++ b/include/dt-bindings/mfd/arizona.h
@@ -90,4 +90,22 @@
 #define ARIZONA_INMODE_SE   1
 #define ARIZONA_INMODE_DMIC 2
 
+#define ARIZONA_MICD_TIME_CONTINUOUS                 0
+#define ARIZONA_MICD_TIME_250US                      1
+#define ARIZONA_MICD_TIME_500US                      2
+#define ARIZONA_MICD_TIME_1MS                        3
+#define ARIZONA_MICD_TIME_2MS                        4
+#define ARIZONA_MICD_TIME_4MS                        5
+#define ARIZONA_MICD_TIME_8MS                        6
+#define ARIZONA_MICD_TIME_16MS                       7
+#define ARIZONA_MICD_TIME_32MS                       8
+#define ARIZONA_MICD_TIME_64MS                       9
+#define ARIZONA_MICD_TIME_128MS                      10
+#define ARIZONA_MICD_TIME_256MS                      11
+#define ARIZONA_MICD_TIME_512MS                      12
+
+#define ARIZONA_ACCDET_MODE_MIC 0
+#define ARIZONA_ACCDET_MODE_HPL 1
+#define ARIZONA_ACCDET_MODE_HPR 2
+
 #endif
diff --git a/include/dt-bindings/mfd/st-lpc.h b/include/dt-bindings/mfd/st-lpc.h
new file mode 100644
index 000000000000..e3e6c75d8822
--- /dev/null
+++ b/include/dt-bindings/mfd/st-lpc.h
@@ -0,0 +1,15 @@
+/*
+ * This header provides shared DT/Driver defines for ST's LPC device
+ *
+ * Copyright (C) 2014 STMicroelectronics -- All Rights Reserved
+ *
+ * Author: Lee Jones <lee.jones@linaro.org> for STMicroelectronics
+ */
+
+#ifndef __DT_BINDINGS_ST_LPC_H__
+#define __DT_BINDINGS_ST_LPC_H__
+
+#define ST_LPC_MODE_RTC         0
+#define ST_LPC_MODE_WDT         1
+
+#endif /* __DT_BINDINGS_ST_LPC_H__ */
diff --git a/include/dt-bindings/net/ti-dp83867.h b/include/dt-bindings/net/ti-dp83867.h
new file mode 100644
index 000000000000..172744a72eb7
--- /dev/null
+++ b/include/dt-bindings/net/ti-dp83867.h
@@ -0,0 +1,45 @@
+/*
+ * Device Tree constants for the Texas Instruments DP83867 PHY
+ *
+ * Author: Dan Murphy <dmurphy@ti.com>
+ *
+ * Copyright:   (C) 2015 Texas Instruments, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ */
+
+#ifndef _DT_BINDINGS_TI_DP83867_H
+#define _DT_BINDINGS_TI_DP83867_H
+
+/* PHY CTRL bits */
+#define DP83867_PHYCR_FIFO_DEPTH_3_B_NIB        0x00
+#define DP83867_PHYCR_FIFO_DEPTH_4_B_NIB        0x01
+#define DP83867_PHYCR_FIFO_DEPTH_6_B_NIB        0x02
+#define DP83867_PHYCR_FIFO_DEPTH_8_B_NIB        0x03
+
+/* RGMIIDCTL internal delay for rx and tx */
+#define DP83867_RGMIIDCTL_250_PS        0x0
+#define DP83867_RGMIIDCTL_500_PS        0x1
+#define DP83867_RGMIIDCTL_750_PS        0x2
+#define DP83867_RGMIIDCTL_1_NS          0x3
+#define DP83867_RGMIIDCTL_1_25_NS       0x4
+#define DP83867_RGMIIDCTL_1_50_NS       0x5
+#define DP83867_RGMIIDCTL_1_75_NS       0x6
+#define DP83867_RGMIIDCTL_2_00_NS       0x7
+#define DP83867_RGMIIDCTL_2_25_NS       0x8
+#define DP83867_RGMIIDCTL_2_50_NS       0x9
+#define DP83867_RGMIIDCTL_2_75_NS       0xa
+#define DP83867_RGMIIDCTL_3_00_NS       0xb
+#define DP83867_RGMIIDCTL_3_25_NS       0xc
+#define DP83867_RGMIIDCTL_3_50_NS       0xd
+#define DP83867_RGMIIDCTL_3_75_NS       0xe
+#define DP83867_RGMIIDCTL_4_00_NS       0xf
+
+#endif
diff --git a/include/dt-bindings/phy/phy-pistachio-usb.h b/include/dt-bindings/phy/phy-pistachio-usb.h
new file mode 100644
index 000000000000..d1877aa0a3f5
--- /dev/null
+++ b/include/dt-bindings/phy/phy-pistachio-usb.h
@@ -0,0 +1,16 @@
+/*
+ * Copyright (C) 2015 Google, Inc.
+ *
+ * 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.
+ */
+
+#ifndef _DT_BINDINGS_PHY_PISTACHIO
+#define _DT_BINDINGS_PHY_PISTACHIO
+
+#define REFCLK_XO_CRYSTAL       0x0
+#define REFCLK_X0_EXT_CLK       0x1
+#define REFCLK_CLK_CORE         0x2
+
+#endif /* _DT_BINDINGS_PHY_PISTACHIO */
diff --git a/include/dt-bindings/pinctrl/am43xx.h b/include/dt-bindings/pinctrl/am43xx.h
index 5f4d01898c9c..b00bbc9c60b4 100644
--- a/include/dt-bindings/pinctrl/am43xx.h
+++ b/include/dt-bindings/pinctrl/am43xx.h
@@ -21,6 +21,7 @@
 #define SLEWCTRL_SLOW           (1 << 19)
 #define SLEWCTRL_FAST           0
 #define DS0_PULL_UP_DOWN_EN     (1 << 27)
+#define WAKEUP_ENABLE           (1 << 29)
 
 #define PIN_OUTPUT              (PULL_DISABLE)
 #define PIN_OUTPUT_PULLUP       (PULL_UP)
diff --git a/include/dt-bindings/pinctrl/bcm2835.h b/include/dt-bindings/pinctrl/bcm2835.h
new file mode 100644
index 000000000000..6f0bc37af39c
--- /dev/null
+++ b/include/dt-bindings/pinctrl/bcm2835.h
@@ -0,0 +1,27 @@
+/*
+ * Header providing constants for bcm2835 pinctrl bindings.
+ *
+ * Copyright (C) 2015 Stefan Wahren <stefan.wahren@i2se.com>
+ *
+ * The code contained herein is licensed under the GNU General Public
+ * License. You may obtain a copy of the GNU General Public License
+ * Version 2 at the following locations:
+ *
+ * http://www.opensource.org/licenses/gpl-license.html
+ * http://www.gnu.org/copyleft/gpl.html
+ */
+
+#ifndef __DT_BINDINGS_PINCTRL_BCM2835_H__
+#define __DT_BINDINGS_PINCTRL_BCM2835_H__
+
+/* brcm,function property */
+#define BCM2835_FSEL_GPIO_IN    0
+#define BCM2835_FSEL_GPIO_OUT   1
+#define BCM2835_FSEL_ALT5       2
+#define BCM2835_FSEL_ALT4       3
+#define BCM2835_FSEL_ALT0       4
+#define BCM2835_FSEL_ALT1       5
+#define BCM2835_FSEL_ALT2       6
+#define BCM2835_FSEL_ALT3       7
+
+#endif /* __DT_BINDINGS_PINCTRL_BCM2835_H__ */
diff --git a/include/dt-bindings/pinctrl/mt6397-pinfunc.h b/include/dt-bindings/pinctrl/mt6397-pinfunc.h
new file mode 100644
index 000000000000..85739b308c2f
--- /dev/null
+++ b/include/dt-bindings/pinctrl/mt6397-pinfunc.h
@@ -0,0 +1,256 @@
+#ifndef __DTS_MT6397_PINFUNC_H
+#define __DTS_MT6397_PINFUNC_H
+
+#include <dt-bindings/pinctrl/mt65xx.h>
+
+#define MT6397_PIN_0_INT__FUNC_GPIO0 (MTK_PIN_NO(0) | 0)
+#define MT6397_PIN_0_INT__FUNC_INT (MTK_PIN_NO(0) | 1)
+
+#define MT6397_PIN_1_SRCVOLTEN__FUNC_GPIO1 (MTK_PIN_NO(1) | 0)
+#define MT6397_PIN_1_SRCVOLTEN__FUNC_SRCVOLTEN (MTK_PIN_NO(1) | 1)
+#define MT6397_PIN_1_SRCVOLTEN__FUNC_TEST_CK1 (MTK_PIN_NO(1) | 6)
+
+#define MT6397_PIN_2_SRCLKEN_PERI__FUNC_GPIO2 (MTK_PIN_NO(2) | 0)
+#define MT6397_PIN_2_SRCLKEN_PERI__FUNC_SRCLKEN_PERI (MTK_PIN_NO(2) | 1)
+#define MT6397_PIN_2_SRCLKEN_PERI__FUNC_TEST_CK2 (MTK_PIN_NO(2) | 6)
+
+#define MT6397_PIN_3_RTC_32K1V8__FUNC_GPIO3 (MTK_PIN_NO(3) | 0)
+#define MT6397_PIN_3_RTC_32K1V8__FUNC_RTC_32K1V8 (MTK_PIN_NO(3) | 1)
+#define MT6397_PIN_3_RTC_32K1V8__FUNC_TEST_CK3 (MTK_PIN_NO(3) | 6)
+
+#define MT6397_PIN_4_WRAP_EVENT__FUNC_GPIO4 (MTK_PIN_NO(4) | 0)
+#define MT6397_PIN_4_WRAP_EVENT__FUNC_WRAP_EVENT (MTK_PIN_NO(4) | 1)
+
+#define MT6397_PIN_5_SPI_CLK__FUNC_GPIO5 (MTK_PIN_NO(5) | 0)
+#define MT6397_PIN_5_SPI_CLK__FUNC_SPI_CLK (MTK_PIN_NO(5) | 1)
+
+#define MT6397_PIN_6_SPI_CSN__FUNC_GPIO6 (MTK_PIN_NO(6) | 0)
+#define MT6397_PIN_6_SPI_CSN__FUNC_SPI_CSN (MTK_PIN_NO(6) | 1)
+
+#define MT6397_PIN_7_SPI_MOSI__FUNC_GPIO7 (MTK_PIN_NO(7) | 0)
+#define MT6397_PIN_7_SPI_MOSI__FUNC_SPI_MOSI (MTK_PIN_NO(7) | 1)
+
+#define MT6397_PIN_8_SPI_MISO__FUNC_GPIO8 (MTK_PIN_NO(8) | 0)
+#define MT6397_PIN_8_SPI_MISO__FUNC_SPI_MISO (MTK_PIN_NO(8) | 1)
+
+#define MT6397_PIN_9_AUD_CLK_MOSI__FUNC_GPIO9 (MTK_PIN_NO(9) | 0)
+#define MT6397_PIN_9_AUD_CLK_MOSI__FUNC_AUD_CLK (MTK_PIN_NO(9) | 1)
+#define MT6397_PIN_9_AUD_CLK_MOSI__FUNC_TEST_IN0 (MTK_PIN_NO(9) | 6)
+#define MT6397_PIN_9_AUD_CLK_MOSI__FUNC_TEST_OUT0 (MTK_PIN_NO(9) | 7)
+
+#define MT6397_PIN_10_AUD_DAT_MISO__FUNC_GPIO10 (MTK_PIN_NO(10) | 0)
+#define MT6397_PIN_10_AUD_DAT_MISO__FUNC_AUD_MISO (MTK_PIN_NO(10) | 1)
+#define MT6397_PIN_10_AUD_DAT_MISO__FUNC_TEST_IN1 (MTK_PIN_NO(10) | 6)
+#define MT6397_PIN_10_AUD_DAT_MISO__FUNC_TEST_OUT1 (MTK_PIN_NO(10) | 7)
+
+#define MT6397_PIN_11_AUD_DAT_MOSI__FUNC_GPIO11 (MTK_PIN_NO(11) | 0)
+#define MT6397_PIN_11_AUD_DAT_MOSI__FUNC_AUD_MOSI (MTK_PIN_NO(11) | 1)
+#define MT6397_PIN_11_AUD_DAT_MOSI__FUNC_TEST_IN2 (MTK_PIN_NO(11) | 6)
+#define MT6397_PIN_11_AUD_DAT_MOSI__FUNC_TEST_OUT2 (MTK_PIN_NO(11) | 7)
+
+#define MT6397_PIN_12_COL0__FUNC_GPIO12 (MTK_PIN_NO(12) | 0)
+#define MT6397_PIN_12_COL0__FUNC_COL0_USBDL (MTK_PIN_NO(12) | 1)
+#define MT6397_PIN_12_COL0__FUNC_EINT10_1X (MTK_PIN_NO(12) | 2)
+#define MT6397_PIN_12_COL0__FUNC_PWM1_3X (MTK_PIN_NO(12) | 3)
+#define MT6397_PIN_12_COL0__FUNC_TEST_IN3 (MTK_PIN_NO(12) | 6)
+#define MT6397_PIN_12_COL0__FUNC_TEST_OUT3 (MTK_PIN_NO(12) | 7)
+
+#define MT6397_PIN_13_COL1__FUNC_GPIO13 (MTK_PIN_NO(13) | 0)
+#define MT6397_PIN_13_COL1__FUNC_COL1 (MTK_PIN_NO(13) | 1)
+#define MT6397_PIN_13_COL1__FUNC_EINT11_1X (MTK_PIN_NO(13) | 2)
+#define MT6397_PIN_13_COL1__FUNC_SCL0_2X (MTK_PIN_NO(13) | 3)
+#define MT6397_PIN_13_COL1__FUNC_TEST_IN4 (MTK_PIN_NO(13) | 6)
+#define MT6397_PIN_13_COL1__FUNC_TEST_OUT4 (MTK_PIN_NO(13) | 7)
+
+#define MT6397_PIN_14_COL2__FUNC_GPIO14 (MTK_PIN_NO(14) | 0)
+#define MT6397_PIN_14_COL2__FUNC_COL2 (MTK_PIN_NO(14) | 1)
+#define MT6397_PIN_14_COL2__FUNC_EINT12_1X (MTK_PIN_NO(14) | 2)
+#define MT6397_PIN_14_COL2__FUNC_SDA0_2X (MTK_PIN_NO(14) | 3)
+#define MT6397_PIN_14_COL2__FUNC_TEST_IN5 (MTK_PIN_NO(14) | 6)
+#define MT6397_PIN_14_COL2__FUNC_TEST_OUT5 (MTK_PIN_NO(14) | 7)
+
+#define MT6397_PIN_15_COL3__FUNC_GPIO15 (MTK_PIN_NO(15) | 0)
+#define MT6397_PIN_15_COL3__FUNC_COL3 (MTK_PIN_NO(15) | 1)
+#define MT6397_PIN_15_COL3__FUNC_EINT13_1X (MTK_PIN_NO(15) | 2)
+#define MT6397_PIN_15_COL3__FUNC_SCL1_2X (MTK_PIN_NO(15) | 3)
+#define MT6397_PIN_15_COL3__FUNC_TEST_IN6 (MTK_PIN_NO(15) | 6)
+#define MT6397_PIN_15_COL3__FUNC_TEST_OUT6 (MTK_PIN_NO(15) | 7)
+
+#define MT6397_PIN_16_COL4__FUNC_GPIO16 (MTK_PIN_NO(16) | 0)
+#define MT6397_PIN_16_COL4__FUNC_COL4 (MTK_PIN_NO(16) | 1)
+#define MT6397_PIN_16_COL4__FUNC_EINT14_1X (MTK_PIN_NO(16) | 2)
+#define MT6397_PIN_16_COL4__FUNC_SDA1_2X (MTK_PIN_NO(16) | 3)
+#define MT6397_PIN_16_COL4__FUNC_TEST_IN7 (MTK_PIN_NO(16) | 6)
+#define MT6397_PIN_16_COL4__FUNC_TEST_OUT7 (MTK_PIN_NO(16) | 7)
+
+#define MT6397_PIN_17_COL5__FUNC_GPIO17 (MTK_PIN_NO(17) | 0)
+#define MT6397_PIN_17_COL5__FUNC_COL5 (MTK_PIN_NO(17) | 1)
+#define MT6397_PIN_17_COL5__FUNC_EINT15_1X (MTK_PIN_NO(17) | 2)
+#define MT6397_PIN_17_COL5__FUNC_SCL2_2X (MTK_PIN_NO(17) | 3)
+#define MT6397_PIN_17_COL5__FUNC_TEST_IN8 (MTK_PIN_NO(17) | 6)
+#define MT6397_PIN_17_COL5__FUNC_TEST_OUT8 (MTK_PIN_NO(17) | 7)
+
+#define MT6397_PIN_18_COL6__FUNC_GPIO18 (MTK_PIN_NO(18) | 0)
+#define MT6397_PIN_18_COL6__FUNC_COL6 (MTK_PIN_NO(18) | 1)
+#define MT6397_PIN_18_COL6__FUNC_EINT16_1X (MTK_PIN_NO(18) | 2)
+#define MT6397_PIN_18_COL6__FUNC_SDA2_2X (MTK_PIN_NO(18) | 3)
+#define MT6397_PIN_18_COL6__FUNC_GPIO32K_0 (MTK_PIN_NO(18) | 4)
+#define MT6397_PIN_18_COL6__FUNC_GPIO26M_0 (MTK_PIN_NO(18) | 5)
+#define MT6397_PIN_18_COL6__FUNC_TEST_IN9 (MTK_PIN_NO(18) | 6)
+#define MT6397_PIN_18_COL6__FUNC_TEST_OUT9 (MTK_PIN_NO(18) | 7)
+
+#define MT6397_PIN_19_COL7__FUNC_GPIO19 (MTK_PIN_NO(19) | 0)
+#define MT6397_PIN_19_COL7__FUNC_COL7 (MTK_PIN_NO(19) | 1)
+#define MT6397_PIN_19_COL7__FUNC_EINT17_1X (MTK_PIN_NO(19) | 2)
+#define MT6397_PIN_19_COL7__FUNC_PWM2_3X (MTK_PIN_NO(19) | 3)
+#define MT6397_PIN_19_COL7__FUNC_GPIO32K_1 (MTK_PIN_NO(19) | 4)
+#define MT6397_PIN_19_COL7__FUNC_GPIO26M_1 (MTK_PIN_NO(19) | 5)
+#define MT6397_PIN_19_COL7__FUNC_TEST_IN10 (MTK_PIN_NO(19) | 6)
+#define MT6397_PIN_19_COL7__FUNC_TEST_OUT10 (MTK_PIN_NO(19) | 7)
+
+#define MT6397_PIN_20_ROW0__FUNC_GPIO20 (MTK_PIN_NO(20) | 0)
+#define MT6397_PIN_20_ROW0__FUNC_ROW0 (MTK_PIN_NO(20) | 1)
+#define MT6397_PIN_20_ROW0__FUNC_EINT18_1X (MTK_PIN_NO(20) | 2)
+#define MT6397_PIN_20_ROW0__FUNC_SCL0_3X (MTK_PIN_NO(20) | 3)
+#define MT6397_PIN_20_ROW0__FUNC_TEST_IN11 (MTK_PIN_NO(20) | 6)
+#define MT6397_PIN_20_ROW0__FUNC_TEST_OUT11 (MTK_PIN_NO(20) | 7)
+
+#define MT6397_PIN_21_ROW1__FUNC_GPIO21 (MTK_PIN_NO(21) | 0)
+#define MT6397_PIN_21_ROW1__FUNC_ROW1 (MTK_PIN_NO(21) | 1)
+#define MT6397_PIN_21_ROW1__FUNC_EINT19_1X (MTK_PIN_NO(21) | 2)
+#define MT6397_PIN_21_ROW1__FUNC_SDA0_3X (MTK_PIN_NO(21) | 3)
+#define MT6397_PIN_21_ROW1__FUNC_AUD_TSTCK (MTK_PIN_NO(21) | 4)
+#define MT6397_PIN_21_ROW1__FUNC_TEST_IN12 (MTK_PIN_NO(21) | 6)
+#define MT6397_PIN_21_ROW1__FUNC_TEST_OUT12 (MTK_PIN_NO(21) | 7)
+
+#define MT6397_PIN_22_ROW2__FUNC_GPIO22 (MTK_PIN_NO(22) | 0)
+#define MT6397_PIN_22_ROW2__FUNC_ROW2 (MTK_PIN_NO(22) | 1)
+#define MT6397_PIN_22_ROW2__FUNC_EINT20_1X (MTK_PIN_NO(22) | 2)
+#define MT6397_PIN_22_ROW2__FUNC_SCL1_3X (MTK_PIN_NO(22) | 3)
+#define MT6397_PIN_22_ROW2__FUNC_TEST_IN13 (MTK_PIN_NO(22) | 6)
+#define MT6397_PIN_22_ROW2__FUNC_TEST_OUT13 (MTK_PIN_NO(22) | 7)
+
+#define MT6397_PIN_23_ROW3__FUNC_GPIO23 (MTK_PIN_NO(23) | 0)
+#define MT6397_PIN_23_ROW3__FUNC_ROW3 (MTK_PIN_NO(23) | 1)
+#define MT6397_PIN_23_ROW3__FUNC_EINT21_1X (MTK_PIN_NO(23) | 2)
+#define MT6397_PIN_23_ROW3__FUNC_SDA1_3X (MTK_PIN_NO(23) | 3)
+#define MT6397_PIN_23_ROW3__FUNC_TEST_IN14 (MTK_PIN_NO(23) | 6)
+#define MT6397_PIN_23_ROW3__FUNC_TEST_OUT14 (MTK_PIN_NO(23) | 7)
+
+#define MT6397_PIN_24_ROW4__FUNC_GPIO24 (MTK_PIN_NO(24) | 0)
+#define MT6397_PIN_24_ROW4__FUNC_ROW4 (MTK_PIN_NO(24) | 1)
+#define MT6397_PIN_24_ROW4__FUNC_EINT22_1X (MTK_PIN_NO(24) | 2)
+#define MT6397_PIN_24_ROW4__FUNC_SCL2_3X (MTK_PIN_NO(24) | 3)
+#define MT6397_PIN_24_ROW4__FUNC_TEST_IN15 (MTK_PIN_NO(24) | 6)
+#define MT6397_PIN_24_ROW4__FUNC_TEST_OUT15 (MTK_PIN_NO(24) | 7)
+
+#define MT6397_PIN_25_ROW5__FUNC_GPIO25 (MTK_PIN_NO(25) | 0)
+#define MT6397_PIN_25_ROW5__FUNC_ROW5 (MTK_PIN_NO(25) | 1)
+#define MT6397_PIN_25_ROW5__FUNC_EINT23_1X (MTK_PIN_NO(25) | 2)
+#define MT6397_PIN_25_ROW5__FUNC_SDA2_3X (MTK_PIN_NO(25) | 3)
+#define MT6397_PIN_25_ROW5__FUNC_TEST_IN16 (MTK_PIN_NO(25) | 6)
+#define MT6397_PIN_25_ROW5__FUNC_TEST_OUT16 (MTK_PIN_NO(25) | 7)
+
+#define MT6397_PIN_26_ROW6__FUNC_GPIO26 (MTK_PIN_NO(26) | 0)
+#define MT6397_PIN_26_ROW6__FUNC_ROW6 (MTK_PIN_NO(26) | 1)
+#define MT6397_PIN_26_ROW6__FUNC_EINT24_1X (MTK_PIN_NO(26) | 2)
+#define MT6397_PIN_26_ROW6__FUNC_PWM3_3X (MTK_PIN_NO(26) | 3)
+#define MT6397_PIN_26_ROW6__FUNC_GPIO32K_2 (MTK_PIN_NO(26) | 4)
+#define MT6397_PIN_26_ROW6__FUNC_GPIO26M_2 (MTK_PIN_NO(26) | 5)
+#define MT6397_PIN_26_ROW6__FUNC_TEST_IN17 (MTK_PIN_NO(26) | 6)
+#define MT6397_PIN_26_ROW6__FUNC_TEST_OUT17 (MTK_PIN_NO(26) | 7)
+
+#define MT6397_PIN_27_ROW7__FUNC_GPIO27 (MTK_PIN_NO(27) | 0)
+#define MT6397_PIN_27_ROW7__FUNC_ROW7 (MTK_PIN_NO(27) | 1)
+#define MT6397_PIN_27_ROW7__FUNC_EINT3_1X (MTK_PIN_NO(27) | 2)
+#define MT6397_PIN_27_ROW7__FUNC_CBUS (MTK_PIN_NO(27) | 3)
+#define MT6397_PIN_27_ROW7__FUNC_GPIO32K_3 (MTK_PIN_NO(27) | 4)
+#define MT6397_PIN_27_ROW7__FUNC_GPIO26M_3 (MTK_PIN_NO(27) | 5)
+#define MT6397_PIN_27_ROW7__FUNC_TEST_IN18 (MTK_PIN_NO(27) | 6)
+#define MT6397_PIN_27_ROW7__FUNC_TEST_OUT18 (MTK_PIN_NO(27) | 7)
+
+#define MT6397_PIN_28_PWM1__FUNC_GPIO28 (MTK_PIN_NO(28) | 0)
+#define MT6397_PIN_28_PWM1__FUNC_PWM1 (MTK_PIN_NO(28) | 1)
+#define MT6397_PIN_28_PWM1__FUNC_EINT4_1X (MTK_PIN_NO(28) | 2)
+#define MT6397_PIN_28_PWM1__FUNC_GPIO32K_4 (MTK_PIN_NO(28) | 4)
+#define MT6397_PIN_28_PWM1__FUNC_GPIO26M_4 (MTK_PIN_NO(28) | 5)
+#define MT6397_PIN_28_PWM1__FUNC_TEST_IN19 (MTK_PIN_NO(28) | 6)
+#define MT6397_PIN_28_PWM1__FUNC_TEST_OUT19 (MTK_PIN_NO(28) | 7)
+
+#define MT6397_PIN_29_PWM2__FUNC_GPIO29 (MTK_PIN_NO(29) | 0)
+#define MT6397_PIN_29_PWM2__FUNC_PWM2 (MTK_PIN_NO(29) | 1)
+#define MT6397_PIN_29_PWM2__FUNC_EINT5_1X (MTK_PIN_NO(29) | 2)
+#define MT6397_PIN_29_PWM2__FUNC_GPIO32K_5 (MTK_PIN_NO(29) | 4)
+#define MT6397_PIN_29_PWM2__FUNC_GPIO26M_5 (MTK_PIN_NO(29) | 5)
+#define MT6397_PIN_29_PWM2__FUNC_TEST_IN20 (MTK_PIN_NO(29) | 6)
+#define MT6397_PIN_29_PWM2__FUNC_TEST_OUT20 (MTK_PIN_NO(29) | 7)
+
+#define MT6397_PIN_30_PWM3__FUNC_GPIO30 (MTK_PIN_NO(30) | 0)
+#define MT6397_PIN_30_PWM3__FUNC_PWM3 (MTK_PIN_NO(30) | 1)
+#define MT6397_PIN_30_PWM3__FUNC_EINT6_1X (MTK_PIN_NO(30) | 2)
+#define MT6397_PIN_30_PWM3__FUNC_COL0 (MTK_PIN_NO(30) | 3)
+#define MT6397_PIN_30_PWM3__FUNC_GPIO32K_6 (MTK_PIN_NO(30) | 4)
+#define MT6397_PIN_30_PWM3__FUNC_GPIO26M_6 (MTK_PIN_NO(30) | 5)
+#define MT6397_PIN_30_PWM3__FUNC_TEST_IN21 (MTK_PIN_NO(30) | 6)
+#define MT6397_PIN_30_PWM3__FUNC_TEST_OUT21 (MTK_PIN_NO(30) | 7)
+
+#define MT6397_PIN_31_SCL0__FUNC_GPIO31 (MTK_PIN_NO(31) | 0)
+#define MT6397_PIN_31_SCL0__FUNC_SCL0 (MTK_PIN_NO(31) | 1)
+#define MT6397_PIN_31_SCL0__FUNC_EINT7_1X (MTK_PIN_NO(31) | 2)
+#define MT6397_PIN_31_SCL0__FUNC_PWM1_2X (MTK_PIN_NO(31) | 3)
+#define MT6397_PIN_31_SCL0__FUNC_TEST_IN22 (MTK_PIN_NO(31) | 6)
+#define MT6397_PIN_31_SCL0__FUNC_TEST_OUT22 (MTK_PIN_NO(31) | 7)
+
+#define MT6397_PIN_32_SDA0__FUNC_GPIO32 (MTK_PIN_NO(32) | 0)
+#define MT6397_PIN_32_SDA0__FUNC_SDA0 (MTK_PIN_NO(32) | 1)
+#define MT6397_PIN_32_SDA0__FUNC_EINT8_1X (MTK_PIN_NO(32) | 2)
+#define MT6397_PIN_32_SDA0__FUNC_TEST_IN23 (MTK_PIN_NO(32) | 6)
+#define MT6397_PIN_32_SDA0__FUNC_TEST_OUT23 (MTK_PIN_NO(32) | 7)
+
+#define MT6397_PIN_33_SCL1__FUNC_GPIO33 (MTK_PIN_NO(33) | 0)
+#define MT6397_PIN_33_SCL1__FUNC_SCL1 (MTK_PIN_NO(33) | 1)
+#define MT6397_PIN_33_SCL1__FUNC_EINT9_1X (MTK_PIN_NO(33) | 2)
+#define MT6397_PIN_33_SCL1__FUNC_PWM2_2X (MTK_PIN_NO(33) | 3)
+#define MT6397_PIN_33_SCL1__FUNC_TEST_IN24 (MTK_PIN_NO(33) | 6)
+#define MT6397_PIN_33_SCL1__FUNC_TEST_OUT24 (MTK_PIN_NO(33) | 7)
+
+#define MT6397_PIN_34_SDA1__FUNC_GPIO34 (MTK_PIN_NO(34) | 0)
+#define MT6397_PIN_34_SDA1__FUNC_SDA1 (MTK_PIN_NO(34) | 1)
+#define MT6397_PIN_34_SDA1__FUNC_EINT0_1X (MTK_PIN_NO(34) | 2)
+#define MT6397_PIN_34_SDA1__FUNC_TEST_IN25 (MTK_PIN_NO(34) | 6)
+#define MT6397_PIN_34_SDA1__FUNC_TEST_OUT25 (MTK_PIN_NO(34) | 7)
+
+#define MT6397_PIN_35_SCL2__FUNC_GPIO35 (MTK_PIN_NO(35) | 0)
+#define MT6397_PIN_35_SCL2__FUNC_SCL2 (MTK_PIN_NO(35) | 1)
+#define MT6397_PIN_35_SCL2__FUNC_EINT1_1X (MTK_PIN_NO(35) | 2)
+#define MT6397_PIN_35_SCL2__FUNC_PWM3_2X (MTK_PIN_NO(35) | 3)
+#define MT6397_PIN_35_SCL2__FUNC_TEST_IN26 (MTK_PIN_NO(35) | 6)
+#define MT6397_PIN_35_SCL2__FUNC_TEST_OUT26 (MTK_PIN_NO(35) | 7)
+
+#define MT6397_PIN_36_SDA2__FUNC_GPIO36 (MTK_PIN_NO(36) | 0)
+#define MT6397_PIN_36_SDA2__FUNC_SDA2 (MTK_PIN_NO(36) | 1)
+#define MT6397_PIN_36_SDA2__FUNC_EINT2_1X (MTK_PIN_NO(36) | 2)
+#define MT6397_PIN_36_SDA2__FUNC_TEST_IN27 (MTK_PIN_NO(36) | 6)
+#define MT6397_PIN_36_SDA2__FUNC_TEST_OUT27 (MTK_PIN_NO(36) | 7)
+
+#define MT6397_PIN_37_HDMISD__FUNC_GPIO37 (MTK_PIN_NO(37) | 0)
+#define MT6397_PIN_37_HDMISD__FUNC_HDMISD (MTK_PIN_NO(37) | 1)
+#define MT6397_PIN_37_HDMISD__FUNC_TEST_IN28 (MTK_PIN_NO(37) | 6)
+#define MT6397_PIN_37_HDMISD__FUNC_TEST_OUT28 (MTK_PIN_NO(37) | 7)
+
+#define MT6397_PIN_38_HDMISCK__FUNC_GPIO38 (MTK_PIN_NO(38) | 0)
+#define MT6397_PIN_38_HDMISCK__FUNC_HDMISCK (MTK_PIN_NO(38) | 1)
+#define MT6397_PIN_38_HDMISCK__FUNC_TEST_IN29 (MTK_PIN_NO(38) | 6)
+#define MT6397_PIN_38_HDMISCK__FUNC_TEST_OUT29 (MTK_PIN_NO(38) | 7)
+
+#define MT6397_PIN_39_HTPLG__FUNC_GPIO39 (MTK_PIN_NO(39) | 0)
+#define MT6397_PIN_39_HTPLG__FUNC_HTPLG (MTK_PIN_NO(39) | 1)
+#define MT6397_PIN_39_HTPLG__FUNC_TEST_IN30 (MTK_PIN_NO(39) | 6)
+#define MT6397_PIN_39_HTPLG__FUNC_TEST_OUT30 (MTK_PIN_NO(39) | 7)
+
+#define MT6397_PIN_40_CEC__FUNC_GPIO40 (MTK_PIN_NO(40) | 0)
+#define MT6397_PIN_40_CEC__FUNC_CEC (MTK_PIN_NO(40) | 1)
+#define MT6397_PIN_40_CEC__FUNC_TEST_IN31 (MTK_PIN_NO(40) | 6)
+#define MT6397_PIN_40_CEC__FUNC_TEST_OUT31 (MTK_PIN_NO(40) | 7)
+
+#endif /* __DTS_MT6397_PINFUNC_H */
diff --git a/include/dt-bindings/reset-controller/mt8135-resets.h b/include/dt-bindings/reset-controller/mt8135-resets.h
new file mode 100644
index 000000000000..1fb629508db2
--- /dev/null
+++ b/include/dt-bindings/reset-controller/mt8135-resets.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2014 MediaTek Inc.
+ * Author: Flora Fu, MediaTek
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef _DT_BINDINGS_RESET_CONTROLLER_MT8135
+#define _DT_BINDINGS_RESET_CONTROLLER_MT8135
+
+/* INFRACFG resets */
+#define MT8135_INFRA_EMI_REG_RST        0
+#define MT8135_INFRA_DRAMC0_A0_RST      1
+#define MT8135_INFRA_CCIF0_RST          2
+#define MT8135_INFRA_APCIRQ_EINT_RST    3
+#define MT8135_INFRA_APXGPT_RST         4
+#define MT8135_INFRA_SCPSYS_RST         5
+#define MT8135_INFRA_CCIF1_RST          6
+#define MT8135_INFRA_PMIC_WRAP_RST      7
+#define MT8135_INFRA_KP_RST             8
+#define MT8135_INFRA_EMI_RST            32
+#define MT8135_INFRA_DRAMC0_RST         34
+#define MT8135_INFRA_SMI_RST            35
+#define MT8135_INFRA_M4U_RST            36
+
+/*  PERICFG resets */
+#define MT8135_PERI_UART0_SW_RST        0
+#define MT8135_PERI_UART1_SW_RST        1
+#define MT8135_PERI_UART2_SW_RST        2
+#define MT8135_PERI_UART3_SW_RST        3
+#define MT8135_PERI_IRDA_SW_RST         4
+#define MT8135_PERI_PTP_SW_RST          5
+#define MT8135_PERI_AP_HIF_SW_RST       6
+#define MT8135_PERI_GPCU_SW_RST         7
+#define MT8135_PERI_MD_HIF_SW_RST       8
+#define MT8135_PERI_NLI_SW_RST          9
+#define MT8135_PERI_AUXADC_SW_RST       10
+#define MT8135_PERI_DMA_SW_RST          11
+#define MT8135_PERI_NFI_SW_RST          14
+#define MT8135_PERI_PWM_SW_RST          15
+#define MT8135_PERI_THERM_SW_RST        16
+#define MT8135_PERI_MSDC0_SW_RST        17
+#define MT8135_PERI_MSDC1_SW_RST        18
+#define MT8135_PERI_MSDC2_SW_RST        19
+#define MT8135_PERI_MSDC3_SW_RST        20
+#define MT8135_PERI_I2C0_SW_RST         22
+#define MT8135_PERI_I2C1_SW_RST         23
+#define MT8135_PERI_I2C2_SW_RST         24
+#define MT8135_PERI_I2C3_SW_RST         25
+#define MT8135_PERI_I2C4_SW_RST         26
+#define MT8135_PERI_I2C5_SW_RST         27
+#define MT8135_PERI_I2C6_SW_RST         28
+#define MT8135_PERI_USB_SW_RST          29
+#define MT8135_PERI_SPI1_SW_RST         33
+#define MT8135_PERI_PWRAP_BRIDGE_SW_RST 34
+
+#endif  /* _DT_BINDINGS_RESET_CONTROLLER_MT8135 */
diff --git a/include/dt-bindings/reset-controller/mt8173-resets.h b/include/dt-bindings/reset-controller/mt8173-resets.h
new file mode 100644
index 000000000000..9464b37cf68c
--- /dev/null
+++ b/include/dt-bindings/reset-controller/mt8173-resets.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2014 MediaTek Inc.
+ * Author: Flora Fu, MediaTek
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef _DT_BINDINGS_RESET_CONTROLLER_MT8173
+#define _DT_BINDINGS_RESET_CONTROLLER_MT8173
+
+/* INFRACFG resets */
+#define MT8173_INFRA_EMI_REG_RST        0
+#define MT8173_INFRA_DRAMC0_A0_RST      1
+#define MT8173_INFRA_APCIRQ_EINT_RST    3
+#define MT8173_INFRA_APXGPT_RST         4
+#define MT8173_INFRA_SCPSYS_RST         5
+#define MT8173_INFRA_KP_RST             6
+#define MT8173_INFRA_PMIC_WRAP_RST      7
+#define MT8173_INFRA_MPIP_RST           8
+#define MT8173_INFRA_CEC_RST            9
+#define MT8173_INFRA_EMI_RST            32
+#define MT8173_INFRA_DRAMC0_RST         34
+#define MT8173_INFRA_APMIXEDSYS_RST     35
+#define MT8173_INFRA_MIPI_DSI_RST       36
+#define MT8173_INFRA_TRNG_RST           37
+#define MT8173_INFRA_SYSIRQ_RST         38
+#define MT8173_INFRA_MIPI_CSI_RST       39
+#define MT8173_INFRA_GCE_FAXI_RST       40
+#define MT8173_INFRA_MMIOMMURST         47
+
+
+/*  PERICFG resets */
+#define MT8173_PERI_UART0_SW_RST        0
+#define MT8173_PERI_UART1_SW_RST        1
+#define MT8173_PERI_UART2_SW_RST        2
+#define MT8173_PERI_UART3_SW_RST        3
+#define MT8173_PERI_IRRX_SW_RST         4
+#define MT8173_PERI_PWM_SW_RST          8
+#define MT8173_PERI_AUXADC_SW_RST       10
+#define MT8173_PERI_DMA_SW_RST          11
+#define MT8173_PERI_I2C6_SW_RST         13
+#define MT8173_PERI_NFI_SW_RST          14
+#define MT8173_PERI_THERM_SW_RST        16
+#define MT8173_PERI_MSDC2_SW_RST        17
+#define MT8173_PERI_MSDC3_SW_RST        18
+#define MT8173_PERI_MSDC0_SW_RST        19
+#define MT8173_PERI_MSDC1_SW_RST        20
+#define MT8173_PERI_I2C0_SW_RST         22
+#define MT8173_PERI_I2C1_SW_RST         23
+#define MT8173_PERI_I2C2_SW_RST         24
+#define MT8173_PERI_I2C3_SW_RST         25
+#define MT8173_PERI_I2C4_SW_RST         26
+#define MT8173_PERI_HDMI_SW_RST         29
+#define MT8173_PERI_SPI0_SW_RST         33
+
+#endif  /* _DT_BINDINGS_RESET_CONTROLLER_MT8173 */
diff --git a/include/dt-bindings/reset/qcom,gcc-ipq806x.h b/include/dt-bindings/reset/qcom,gcc-ipq806x.h
index 0ad5ef930b5d..de9c8140931a 100644
--- a/include/dt-bindings/reset/qcom,gcc-ipq806x.h
+++ b/include/dt-bindings/reset/qcom,gcc-ipq806x.h
@@ -129,4 +129,47 @@
 #define USB30_1_PHY_RESET                               112
 #define NSSFB0_RESET                                    113
 #define NSSFB1_RESET                                    114
+#define UBI32_CORE1_CLKRST_CLAMP_RESET                  115
+#define UBI32_CORE1_CLAMP_RESET                         116
+#define UBI32_CORE1_AHB_RESET                           117
+#define UBI32_CORE1_AXI_RESET                           118
+#define UBI32_CORE2_CLKRST_CLAMP_RESET                  119
+#define UBI32_CORE2_CLAMP_RESET                         120
+#define UBI32_CORE2_AHB_RESET                           121
+#define UBI32_CORE2_AXI_RESET                           122
+#define GMAC_CORE1_RESET                                123
+#define GMAC_CORE2_RESET                                124
+#define GMAC_CORE3_RESET                                125
+#define GMAC_CORE4_RESET                                126
+#define GMAC_AHB_RESET                                  127
+#define NSS_CH0_RST_RX_CLK_N_RESET                      128
+#define NSS_CH0_RST_TX_CLK_N_RESET                      129
+#define NSS_CH0_RST_RX_125M_N_RESET                     130
+#define NSS_CH0_HW_RST_RX_125M_N_RESET                  131
+#define NSS_CH0_RST_TX_125M_N_RESET                     132
+#define NSS_CH1_RST_RX_CLK_N_RESET                      133
+#define NSS_CH1_RST_TX_CLK_N_RESET                      134
+#define NSS_CH1_RST_RX_125M_N_RESET                     135
+#define NSS_CH1_HW_RST_RX_125M_N_RESET                  136
+#define NSS_CH1_RST_TX_125M_N_RESET                     137
+#define NSS_CH2_RST_RX_CLK_N_RESET                      138
+#define NSS_CH2_RST_TX_CLK_N_RESET                      139
+#define NSS_CH2_RST_RX_125M_N_RESET                     140
+#define NSS_CH2_HW_RST_RX_125M_N_RESET                  141
+#define NSS_CH2_RST_TX_125M_N_RESET                     142
+#define NSS_CH3_RST_RX_CLK_N_RESET                      143
+#define NSS_CH3_RST_TX_CLK_N_RESET                      144
+#define NSS_CH3_RST_RX_125M_N_RESET                     145
+#define NSS_CH3_HW_RST_RX_125M_N_RESET                  146
+#define NSS_CH3_RST_TX_125M_N_RESET                     147
+#define NSS_RST_RX_250M_125M_N_RESET                    148
+#define NSS_RST_TX_250M_125M_N_RESET                    149
+#define NSS_QSGMII_TXPI_RST_N_RESET                     150
+#define NSS_QSGMII_CDR_RST_N_RESET                      151
+#define NSS_SGMII2_CDR_RST_N_RESET                      152
+#define NSS_SGMII3_CDR_RST_N_RESET                      153
+#define NSS_CAL_PRBS_RST_N_RESET                        154
+#define NSS_LCKDT_RST_N_RESET                           155
+#define NSS_SRDS_N_RESET                                156
+
 #endif
diff --git a/include/dt-bindings/sound/apq8016-lpass.h b/include/dt-bindings/sound/apq8016-lpass.h
new file mode 100644
index 000000000000..499076e980a3
--- /dev/null
+++ b/include/dt-bindings/sound/apq8016-lpass.h
@@ -0,0 +1,9 @@
+#ifndef __DT_APQ8016_LPASS_H
+#define __DT_APQ8016_LPASS_H
+
+#define MI2S_PRIMARY    0
+#define MI2S_SECONDARY  1
+#define MI2S_TERTIARY   2
+#define MI2S_QUATERNARY 3
+
+#endif /* __DT_APQ8016_LPASS_H */
diff --git a/include/dt-bindings/sound/audio-jack-events.h b/include/dt-bindings/sound/audio-jack-events.h
new file mode 100644
index 000000000000..378349f28069
--- /dev/null
+++ b/include/dt-bindings/sound/audio-jack-events.h
@@ -0,0 +1,9 @@
+#ifndef __AUDIO_JACK_EVENTS_H
+#define __AUDIO_JACK_EVENTS_H
+
+#define JACK_HEADPHONE          1
+#define JACK_MICROPHONE         2
+#define JACK_LINEOUT            3
+#define JACK_LINEIN             4
+
+#endif /* __AUDIO_JACK_EVENTS_H */
diff --git a/include/dt-bindings/sound/tas2552.h b/include/dt-bindings/sound/tas2552.h
new file mode 100644
index 000000000000..a4e1a079980b
--- /dev/null
+++ b/include/dt-bindings/sound/tas2552.h
@@ -0,0 +1,18 @@
+#ifndef __DT_TAS2552_H
+#define __DT_TAS2552_H
+
+#define TAS2552_PLL_CLKIN               (0)
+#define TAS2552_PDM_CLK                 (1)
+#define TAS2552_CLK_TARGET_MASK         (1)
+
+#define TAS2552_PLL_CLKIN_MCLK          ((0 << 1) | TAS2552_PLL_CLKIN)
+#define TAS2552_PLL_CLKIN_BCLK          ((1 << 1) | TAS2552_PLL_CLKIN)
+#define TAS2552_PLL_CLKIN_IVCLKIN       ((2 << 1) | TAS2552_PLL_CLKIN)
+#define TAS2552_PLL_CLKIN_1_8_FIXED     ((3 << 1) | TAS2552_PLL_CLKIN)
+
+#define TAS2552_PDM_CLK_PLL             ((0 << 1) | TAS2552_PDM_CLK)
+#define TAS2552_PDM_CLK_IVCLKIN         ((1 << 1) | TAS2552_PDM_CLK)
+#define TAS2552_PDM_CLK_BCLK            ((2 << 1) | TAS2552_PDM_CLK)
+#define TAS2552_PDM_CLK_MCLK            ((3 << 1) | TAS2552_PDM_CLK)
+
+#endif /* __DT_TAS2552_H */
diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index f57c440642cd..d2445fa9999f 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -53,11 +53,24 @@ static inline acpi_handle acpi_device_handle(struct acpi_device *adev)
         return adev ? adev->handle : NULL;
 }
 
-#define ACPI_COMPANION(dev)             acpi_node((dev)->fwnode)
+#define ACPI_COMPANION(dev)             to_acpi_node((dev)->fwnode)
 #define ACPI_COMPANION_SET(dev, adev)   set_primary_fwnode(dev, (adev) ? \
         acpi_fwnode_handle(adev) : NULL)
 #define ACPI_HANDLE(dev)                acpi_device_handle(ACPI_COMPANION(dev))
 
+/**
+ * ACPI_DEVICE_CLASS - macro used to describe an ACPI device with
+ * the PCI-defined class-code information
+ *
+ * @_cls : the class, subclass, prog-if triple for this device
+ * @_msk : the class mask for this device
+ *
+ * This macro is used to create a struct acpi_device_id that matches a
+ * specific PCI class. The .id and .driver_data fields will be left
+ * initialized with the default value.
+ */
+#define ACPI_DEVICE_CLASS(_cls, _msk)   .cls = (_cls), .cls_msk = (_msk),
+
 static inline bool has_acpi_companion(struct device *dev)
 {
         return is_acpi_node(dev->fwnode);
@@ -158,6 +171,16 @@ typedef u32 phys_cpuid_t;
 #define PHYS_CPUID_INVALID (phys_cpuid_t)(-1)
 #endif
 
+static inline bool invalid_logical_cpuid(u32 cpuid)
+{
+        return (int)cpuid < 0;
+}
+
+static inline bool invalid_phys_cpuid(phys_cpuid_t phys_id)
+{
+        return phys_id == PHYS_CPUID_INVALID;
+}
+
 #ifdef CONFIG_ACPI_HOTPLUG_CPU
 /* Arch dependent functions for cpu hotplug support */
 int acpi_map_cpu(acpi_handle handle, phys_cpuid_t physid, int *pcpu);
@@ -243,54 +266,21 @@ extern bool wmi_has_guid(const char *guid);
 #define ACPI_VIDEO_OUTPUT_SWITCHING_DMI_VENDOR          0x0400
 #define ACPI_VIDEO_OUTPUT_SWITCHING_DMI_VIDEO           0x0800
 
-#if defined(CONFIG_ACPI_VIDEO) || defined(CONFIG_ACPI_VIDEO_MODULE)
-
-extern long acpi_video_get_capabilities(acpi_handle graphics_dev_handle);
+extern char acpi_video_backlight_string[];
 extern long acpi_is_video_device(acpi_handle handle);
-extern void acpi_video_dmi_promote_vendor(void);
-extern void acpi_video_dmi_demote_vendor(void);
-extern int acpi_video_backlight_support(void);
-extern int acpi_video_display_switch_support(void);
-
-#else
-
-static inline long acpi_video_get_capabilities(acpi_handle graphics_dev_handle)
-{
-        return 0;
-}
-
-static inline long acpi_is_video_device(acpi_handle handle)
-{
-        return 0;
-}
-
-static inline void acpi_video_dmi_promote_vendor(void)
-{
-}
-
-static inline void acpi_video_dmi_demote_vendor(void)
-{
-}
-
-static inline int acpi_video_backlight_support(void)
-{
-        return 0;
-}
-
-static inline int acpi_video_display_switch_support(void)
-{
-        return 0;
-}
-
-#endif /* defined(CONFIG_ACPI_VIDEO) || defined(CONFIG_ACPI_VIDEO_MODULE) */
-
 extern int acpi_blacklisted(void);
 extern void acpi_dmi_osi_linux(int enable, const struct dmi_system_id *d);
 extern void acpi_osi_setup(char *str);
+extern bool acpi_osi_is_win8(void);
 
 #ifdef CONFIG_ACPI_NUMA
+int acpi_map_pxm_to_online_node(int pxm);
 int acpi_get_node(acpi_handle handle);
 #else
+static inline int acpi_map_pxm_to_online_node(int pxm)
+{
+        return 0;
+}
 static inline int acpi_get_node(acpi_handle handle)
 {
         return 0;
@@ -440,6 +430,7 @@ extern acpi_status acpi_pci_osc_control_set(acpi_handle handle,
 #define ACPI_OST_SC_INSERT_NOT_SUPPORTED        0x82
 
 extern void acpi_early_init(void);
+extern void acpi_subsystem_init(void);
 
 extern int acpi_nvs_register(__u64 start, __u64 size);
 
@@ -465,6 +456,7 @@ struct platform_device *acpi_create_platform_device(struct acpi_device *);
 #define ACPI_COMPANION(dev)             (NULL)
 #define ACPI_COMPANION_SET(dev, adev)   do { } while (0)
 #define ACPI_HANDLE(dev)                (NULL)
+#define ACPI_DEVICE_CLASS(_cls, _msk)   .cls = (0), .cls_msk = (0),
 
 struct fwnode_handle;
 
@@ -473,7 +465,7 @@ static inline bool is_acpi_node(struct fwnode_handle *fwnode)
         return false;
 }
 
-static inline struct acpi_device *acpi_node(struct fwnode_handle *fwnode)
+static inline struct acpi_device *to_acpi_node(struct fwnode_handle *fwnode)
 {
         return NULL;
 }
@@ -494,6 +486,7 @@ static inline const char *acpi_dev_name(struct acpi_device *adev)
 }
 
 static inline void acpi_early_init(void) { }
+static inline void acpi_subsystem_init(void) { }
 
 static inline int early_acpi_boot_init(void)
 {
@@ -569,6 +562,11 @@ static inline int acpi_device_modalias(struct device *dev,
         return -ENODEV;
 }
 
+static inline bool acpi_check_dma(struct acpi_device *adev, bool *coherent)
+{
+        return false;
+}
+
 #define ACPI_PTR(_ptr)  (NULL)
 
 #endif  /* !CONFIG_ACPI */
diff --git a/include/linux/amba/sp810.h b/include/linux/amba/sp810.h
index c7df89f99115..58fe9e8b6fd7 100644
--- a/include/linux/amba/sp810.h
+++ b/include/linux/amba/sp810.h
@@ -2,7 +2,7 @@
  * ARM PrimeXsys System Controller SP810 header file
  *
  * Copyright (C) 2009 ST Microelectronics
- * Viresh Kumar <viresh.linux@gmail.com>
+ * Viresh Kumar <vireshk@kernel.org>
  *
  * This file is licensed under the terms of the GNU General Public
  * License version 2. This program is licensed "as is" without any
diff --git a/include/linux/ata.h b/include/linux/ata.h
index b666b773e111..6c78956aa470 100644
--- a/include/linux/ata.h
+++ b/include/linux/ata.h
@@ -45,6 +45,7 @@ enum {
         ATA_SECT_SIZE           = 512,
         ATA_MAX_SECTORS_128     = 128,
         ATA_MAX_SECTORS         = 256,
+        ATA_MAX_SECTORS_1024    = 1024,
         ATA_MAX_SECTORS_LBA48   = 65535,/* TODO: 65536? */
         ATA_MAX_SECTORS_TAPE    = 65535,
 
@@ -704,9 +705,19 @@ static inline bool ata_id_wcache_enabled(const u16 *id)
 
 static inline bool ata_id_has_read_log_dma_ext(const u16 *id)
 {
+        /* Word 86 must have bit 15 set */
         if (!(id[ATA_ID_CFS_ENABLE_2] & (1 << 15)))
                 return false;
-        return id[ATA_ID_COMMAND_SET_3] & (1 << 3);
+
+        /* READ LOG DMA EXT support can be signaled either from word 119
+         * or from word 120. The format is the same for both words: Bit
+         * 15 must be cleared, bit 14 set and bit 3 set.
+         */
+        if ((id[ATA_ID_COMMAND_SET_3] & 0xC008) == 0x4008 ||
+            (id[ATA_ID_COMMAND_SET_4] & 0xC008) == 0x4008)
+                return true;
+
+        return false;
 }
 
 static inline bool ata_id_has_sense_reporting(const u16 *id)
diff --git a/include/linux/backing-dev-defs.h b/include/linux/backing-dev-defs.h
new file mode 100644
index 000000000000..a23209b43842
--- /dev/null
+++ b/include/linux/backing-dev-defs.h
@@ -0,0 +1,256 @@
+#ifndef __LINUX_BACKING_DEV_DEFS_H
+#define __LINUX_BACKING_DEV_DEFS_H
+
+#include <linux/list.h>
+#include <linux/radix-tree.h>
+#include <linux/rbtree.h>
+#include <linux/spinlock.h>
+#include <linux/percpu_counter.h>
+#include <linux/percpu-refcount.h>
+#include <linux/flex_proportions.h>
+#include <linux/timer.h>
+#include <linux/workqueue.h>
+
+struct page;
+struct device;
+struct dentry;
+
+/*
+ * Bits in bdi_writeback.state
+ */
+enum wb_state {
+        WB_registered,          /* bdi_register() was done */
+        WB_writeback_running,   /* Writeback is in progress */
+        WB_has_dirty_io,        /* Dirty inodes on ->b_{dirty|io|more_io} */
+};
+
+enum wb_congested_state {
+        WB_async_congested,     /* The async (write) queue is getting full */
+        WB_sync_congested,      /* The sync queue is getting full */
+};
+
+typedef int (congested_fn)(void *, int);
+
+enum wb_stat_item {
+        WB_RECLAIMABLE,
+        WB_WRITEBACK,
+        WB_DIRTIED,
+        WB_WRITTEN,
+        NR_WB_STAT_ITEMS
+};
+
+#define WB_STAT_BATCH (8*(1+ilog2(nr_cpu_ids)))
+
+/*
+ * For cgroup writeback, multiple wb's may map to the same blkcg.  Those
+ * wb's can operate mostly independently but should share the congested
+ * state.  To facilitate such sharing, the congested state is tracked using
+ * the following struct which is created on demand, indexed by blkcg ID on
+ * its bdi, and refcounted.
+ */
+struct bdi_writeback_congested {
+        unsigned long state;            /* WB_[a]sync_congested flags */
+        atomic_t refcnt;                /* nr of attached wb's and blkg */
+
+#ifdef CONFIG_CGROUP_WRITEBACK
+        struct backing_dev_info *bdi;   /* the associated bdi */
+        int blkcg_id;                   /* ID of the associated blkcg */
+        struct rb_node rb_node;         /* on bdi->cgwb_congestion_tree */
+#endif
+};
+
+/*
+ * Each wb (bdi_writeback) can perform writeback operations, is measured
+ * and throttled, independently.  Without cgroup writeback, each bdi
+ * (bdi_writeback) is served by its embedded bdi->wb.
+ *
+ * On the default hierarchy, blkcg implicitly enables memcg.  This allows
+ * using memcg's page ownership for attributing writeback IOs, and every
+ * memcg - blkcg combination can be served by its own wb by assigning a
+ * dedicated wb to each memcg, which enables isolation across different
+ * cgroups and propagation of IO back pressure down from the IO layer upto
+ * the tasks which are generating the dirty pages to be written back.
+ *
+ * A cgroup wb is indexed on its bdi by the ID of the associated memcg,
+ * refcounted with the number of inodes attached to it, and pins the memcg
+ * and the corresponding blkcg.  As the corresponding blkcg for a memcg may
+ * change as blkcg is disabled and enabled higher up in the hierarchy, a wb
+ * is tested for blkcg after lookup and removed from index on mismatch so
+ * that a new wb for the combination can be created.
+ */
+struct bdi_writeback {
+        struct backing_dev_info *bdi;   /* our parent bdi */
+
+        unsigned long state;            /* Always use atomic bitops on this */
+        unsigned long last_old_flush;   /* last old data flush */
+
+        struct list_head b_dirty;       /* dirty inodes */
+        struct list_head b_io;          /* parked for writeback */
+        struct list_head b_more_io;     /* parked for more writeback */
+        struct list_head b_dirty_time;  /* time stamps are dirty */
+        spinlock_t list_lock;           /* protects the b_* lists */
+
+        struct percpu_counter stat[NR_WB_STAT_ITEMS];
+
+        struct bdi_writeback_congested *congested;
+
+        unsigned long bw_time_stamp;    /* last time write bw is updated */
+        unsigned long dirtied_stamp;
+        unsigned long written_stamp;    /* pages written at bw_time_stamp */
+        unsigned long write_bandwidth;  /* the estimated write bandwidth */
+        unsigned long avg_write_bandwidth; /* further smoothed write bw, > 0 */
+
+        /*
+         * The base dirty throttle rate, re-calculated on every 200ms.
+         * All the bdi tasks' dirty rate will be curbed under it.
+         * @dirty_ratelimit tracks the estimated @balanced_dirty_ratelimit
+         * in small steps and is much more smooth/stable than the latter.
+         */
+        unsigned long dirty_ratelimit;
+        unsigned long balanced_dirty_ratelimit;
+
+        struct fprop_local_percpu completions;
+        int dirty_exceeded;
+
+        spinlock_t work_lock;           /* protects work_list & dwork scheduling */
+        struct list_head work_list;
+        struct delayed_work dwork;      /* work item used for writeback */
+
+#ifdef CONFIG_CGROUP_WRITEBACK
+        struct percpu_ref refcnt;       /* used only for !root wb's */
+        struct fprop_local_percpu memcg_completions;
+        struct cgroup_subsys_state *memcg_css; /* the associated memcg */
+        struct cgroup_subsys_state *blkcg_css; /* and blkcg */
+        struct list_head memcg_node;    /* anchored at memcg->cgwb_list */
+        struct list_head blkcg_node;    /* anchored at blkcg->cgwb_list */
+
+        union {
+                struct work_struct release_work;
+                struct rcu_head rcu;
+        };
+#endif
+};
+
+struct backing_dev_info {
+        struct list_head bdi_list;
+        unsigned long ra_pages; /* max readahead in PAGE_CACHE_SIZE units */
+        unsigned int capabilities; /* Device capabilities */
+        congested_fn *congested_fn; /* Function pointer if device is md/dm */
+        void *congested_data;   /* Pointer to aux data for congested func */
+
+        char *name;
+
+        unsigned int min_ratio;
+        unsigned int max_ratio, max_prop_frac;
+
+        /*
+         * Sum of avg_write_bw of wbs with dirty inodes.  > 0 if there are
+         * any dirty wbs, which is depended upon by bdi_has_dirty().
+         */
+        atomic_long_t tot_write_bandwidth;
+
+        struct bdi_writeback wb;  /* the root writeback info for this bdi */
+#ifdef CONFIG_CGROUP_WRITEBACK
+        struct radix_tree_root cgwb_tree; /* radix tree of active cgroup wbs */
+        struct rb_root cgwb_congested_tree; /* their congested states */
+        atomic_t usage_cnt; /* counts both cgwbs and cgwb_contested's */
+#else
+        struct bdi_writeback_congested *wb_congested;
+#endif
+        wait_queue_head_t wb_waitq;
+
+        struct device *dev;
+
+        struct timer_list laptop_mode_wb_timer;
+
+#ifdef CONFIG_DEBUG_FS
+        struct dentry *debug_dir;
+        struct dentry *debug_stats;
+#endif
+};
+
+enum {
+        BLK_RW_ASYNC    = 0,
+        BLK_RW_SYNC     = 1,
+};
+
+void clear_wb_congested(struct bdi_writeback_congested *congested, int sync);
+void set_wb_congested(struct bdi_writeback_congested *congested, int sync);
+
+static inline void clear_bdi_congested(struct backing_dev_info *bdi, int sync)
+{
+        clear_wb_congested(bdi->wb.congested, sync);
+}
+
+static inline void set_bdi_congested(struct backing_dev_info *bdi, int sync)
+{
+        set_wb_congested(bdi->wb.congested, sync);
+}
+
+#ifdef CONFIG_CGROUP_WRITEBACK
+
+/**
+ * wb_tryget - try to increment a wb's refcount
+ * @wb: bdi_writeback to get
+ */
+static inline bool wb_tryget(struct bdi_writeback *wb)
+{
+        if (wb != &wb->bdi->wb)
+                return percpu_ref_tryget(&wb->refcnt);
+        return true;
+}
+
+/**
+ * wb_get - increment a wb's refcount
+ * @wb: bdi_writeback to get
+ */
+static inline void wb_get(struct bdi_writeback *wb)
+{
+        if (wb != &wb->bdi->wb)
+                percpu_ref_get(&wb->refcnt);
+}
+
+/**
+ * wb_put - decrement a wb's refcount
+ * @wb: bdi_writeback to put
+ */
+static inline void wb_put(struct bdi_writeback *wb)
+{
+        if (wb != &wb->bdi->wb)
+                percpu_ref_put(&wb->refcnt);
+}
+
+/**
+ * wb_dying - is a wb dying?
+ * @wb: bdi_writeback of interest
+ *
+ * Returns whether @wb is unlinked and being drained.
+ */
+static inline bool wb_dying(struct bdi_writeback *wb)
+{
+        return percpu_ref_is_dying(&wb->refcnt);
+}
+
+#else   /* CONFIG_CGROUP_WRITEBACK */
+
+static inline bool wb_tryget(struct bdi_writeback *wb)
+{
+        return true;
+}
+
+static inline void wb_get(struct bdi_writeback *wb)
+{
+}
+
+static inline void wb_put(struct bdi_writeback *wb)
+{
+}
+
+static inline bool wb_dying(struct bdi_writeback *wb)
+{
+        return false;
+}
+
+#endif  /* CONFIG_CGROUP_WRITEBACK */
+
+#endif  /* __LINUX_BACKING_DEV_DEFS_H */
diff --git a/include/linux/backing-dev.h b/include/linux/backing-dev.h
index d87d8eced064..0fe9df983ab7 100644
--- a/include/linux/backing-dev.h
+++ b/include/linux/backing-dev.h
@@ -8,106 +8,14 @@
 #ifndef _LINUX_BACKING_DEV_H
 #define _LINUX_BACKING_DEV_H
 
-#include <linux/percpu_counter.h>
-#include <linux/log2.h>
-#include <linux/flex_proportions.h>
 #include <linux/kernel.h>
 #include <linux/fs.h>
 #include <linux/sched.h>
-#include <linux/timer.h>
+#include <linux/blkdev.h>
 #include <linux/writeback.h>
-#include <linux/atomic.h>
-#include <linux/sysctl.h>
-#include <linux/workqueue.h>
-
-struct page;
-struct device;
-struct dentry;
-
-/*
- * Bits in backing_dev_info.state
- */
-enum bdi_state {
-        BDI_async_congested,    /* The async (write) queue is getting full */
-        BDI_sync_congested,     /* The sync queue is getting full */
-        BDI_registered,         /* bdi_register() was done */
-        BDI_writeback_running,  /* Writeback is in progress */
-};
-
-typedef int (congested_fn)(void *, int);
-
-enum bdi_stat_item {
-        BDI_RECLAIMABLE,
-        BDI_WRITEBACK,
-        BDI_DIRTIED,
-        BDI_WRITTEN,
-        NR_BDI_STAT_ITEMS
-};
-
-#define BDI_STAT_BATCH (8*(1+ilog2(nr_cpu_ids)))
-
-struct bdi_writeback {
-        struct backing_dev_info *bdi;   /* our parent bdi */
-
-        unsigned long last_old_flush;   /* last old data flush */
-
-        struct delayed_work dwork;      /* work item used for writeback */
-        struct list_head b_dirty;       /* dirty inodes */
-        struct list_head b_io;          /* parked for writeback */
-        struct list_head b_more_io;     /* parked for more writeback */
-        struct list_head b_dirty_time;  /* time stamps are dirty */
-        spinlock_t list_lock;           /* protects the b_* lists */
-};
-
-struct backing_dev_info {
-        struct list_head bdi_list;
-        unsigned long ra_pages; /* max readahead in PAGE_CACHE_SIZE units */
-        unsigned long state;    /* Always use atomic bitops on this */
-        unsigned int capabilities; /* Device capabilities */
-        congested_fn *congested_fn; /* Function pointer if device is md/dm */
-        void *congested_data;   /* Pointer to aux data for congested func */
-
-        char *name;
-
-        struct percpu_counter bdi_stat[NR_BDI_STAT_ITEMS];
-
-        unsigned long bw_time_stamp;    /* last time write bw is updated */
-        unsigned long dirtied_stamp;
-        unsigned long written_stamp;    /* pages written at bw_time_stamp */
-        unsigned long write_bandwidth;  /* the estimated write bandwidth */
-        unsigned long avg_write_bandwidth; /* further smoothed write bw */
-
-        /*
-         * The base dirty throttle rate, re-calculated on every 200ms.
-         * All the bdi tasks' dirty rate will be curbed under it.
-         * @dirty_ratelimit tracks the estimated @balanced_dirty_ratelimit
-         * in small steps and is much more smooth/stable than the latter.
-         */
-        unsigned long dirty_ratelimit;
-        unsigned long balanced_dirty_ratelimit;
-
-        struct fprop_local_percpu completions;
-        int dirty_exceeded;
-
-        unsigned int min_ratio;
-        unsigned int max_ratio, max_prop_frac;
-
-        struct bdi_writeback wb;  /* default writeback info for this bdi */
-        spinlock_t wb_lock;       /* protects work_list & wb.dwork scheduling */
-
-        struct list_head work_list;
-
-        struct device *dev;
-
-        struct timer_list laptop_mode_wb_timer;
-
-#ifdef CONFIG_DEBUG_FS
-        struct dentry *debug_dir;
-        struct dentry *debug_stats;
-#endif
-};
-
-struct backing_dev_info *inode_to_bdi(struct inode *inode);
+#include <linux/blk-cgroup.h>
+#include <linux/backing-dev-defs.h>
+#include <linux/slab.h>
 
 int __must_check bdi_init(struct backing_dev_info *bdi);
 void bdi_destroy(struct backing_dev_info *bdi);
@@ -117,97 +25,99 @@ int bdi_register(struct backing_dev_info *bdi, struct device *parent,
                 const char *fmt, ...);
 int bdi_register_dev(struct backing_dev_info *bdi, dev_t dev);
 int __must_check bdi_setup_and_register(struct backing_dev_info *, char *);
-void bdi_start_writeback(struct backing_dev_info *bdi, long nr_pages,
-                        enum wb_reason reason);
-void bdi_start_background_writeback(struct backing_dev_info *bdi);
-void bdi_writeback_workfn(struct work_struct *work);
-int bdi_has_dirty_io(struct backing_dev_info *bdi);
-void bdi_wakeup_thread_delayed(struct backing_dev_info *bdi);
+void wb_start_writeback(struct bdi_writeback *wb, long nr_pages,
+                        bool range_cyclic, enum wb_reason reason);
+void wb_start_background_writeback(struct bdi_writeback *wb);
+void wb_workfn(struct work_struct *work);
+void wb_wakeup_delayed(struct bdi_writeback *wb);
 
 extern spinlock_t bdi_lock;
 extern struct list_head bdi_list;
 
 extern struct workqueue_struct *bdi_wq;
 
-static inline int wb_has_dirty_io(struct bdi_writeback *wb)
+static inline bool wb_has_dirty_io(struct bdi_writeback *wb)
 {
-        return !list_empty(&wb->b_dirty) ||
-               !list_empty(&wb->b_io) ||
-               !list_empty(&wb->b_more_io);
+        return test_bit(WB_has_dirty_io, &wb->state);
+}
+
+static inline bool bdi_has_dirty_io(struct backing_dev_info *bdi)
+{
+        /*
+         * @bdi->tot_write_bandwidth is guaranteed to be > 0 if there are
+         * any dirty wbs.  See wb_update_write_bandwidth().
+         */
+        return atomic_long_read(&bdi->tot_write_bandwidth);
 }
 
-static inline void __add_bdi_stat(struct backing_dev_info *bdi,
-                enum bdi_stat_item item, s64 amount)
+static inline void __add_wb_stat(struct bdi_writeback *wb,
+                                 enum wb_stat_item item, s64 amount)
 {
-        __percpu_counter_add(&bdi->bdi_stat[item], amount, BDI_STAT_BATCH);
+        __percpu_counter_add(&wb->stat[item], amount, WB_STAT_BATCH);
 }
 
-static inline void __inc_bdi_stat(struct backing_dev_info *bdi,
-                enum bdi_stat_item item)
+static inline void __inc_wb_stat(struct bdi_writeback *wb,
+                                 enum wb_stat_item item)
 {
-        __add_bdi_stat(bdi, item, 1);
+        __add_wb_stat(wb, item, 1);
 }
 
-static inline void inc_bdi_stat(struct backing_dev_info *bdi,
-                enum bdi_stat_item item)
+static inline void inc_wb_stat(struct bdi_writeback *wb, enum wb_stat_item item)
 {
         unsigned long flags;
 
         local_irq_save(flags);
-        __inc_bdi_stat(bdi, item);
+        __inc_wb_stat(wb, item);
         local_irq_restore(flags);
 }
 
-static inline void __dec_bdi_stat(struct backing_dev_info *bdi,
-                enum bdi_stat_item item)
+static inline void __dec_wb_stat(struct bdi_writeback *wb,
+                                 enum wb_stat_item item)
 {
-        __add_bdi_stat(bdi, item, -1);
+        __add_wb_stat(wb, item, -1);
 }
 
-static inline void dec_bdi_stat(struct backing_dev_info *bdi,
-                enum bdi_stat_item item)
+static inline void dec_wb_stat(struct bdi_writeback *wb, enum wb_stat_item item)
 {
         unsigned long flags;
 
         local_irq_save(flags);
-        __dec_bdi_stat(bdi, item);
+        __dec_wb_stat(wb, item);
         local_irq_restore(flags);
 }
 
-static inline s64 bdi_stat(struct backing_dev_info *bdi,
-                enum bdi_stat_item item)
+static inline s64 wb_stat(struct bdi_writeback *wb, enum wb_stat_item item)
 {
-        return percpu_counter_read_positive(&bdi->bdi_stat[item]);
+        return percpu_counter_read_positive(&wb->stat[item]);
 }
 
-static inline s64 __bdi_stat_sum(struct backing_dev_info *bdi,
-                enum bdi_stat_item item)
+static inline s64 __wb_stat_sum(struct bdi_writeback *wb,
+                                enum wb_stat_item item)
 {
-        return percpu_counter_sum_positive(&bdi->bdi_stat[item]);
+        return percpu_counter_sum_positive(&wb->stat[item]);
 }
 
-static inline s64 bdi_stat_sum(struct backing_dev_info *bdi,
-                enum bdi_stat_item item)
+static inline s64 wb_stat_sum(struct bdi_writeback *wb, enum wb_stat_item item)
 {
         s64 sum;
         unsigned long flags;
 
         local_irq_save(flags);
-        sum = __bdi_stat_sum(bdi, item);
+        sum = __wb_stat_sum(wb, item);
         local_irq_restore(flags);
 
         return sum;
 }
 
-extern void bdi_writeout_inc(struct backing_dev_info *bdi);
+extern void wb_writeout_inc(struct bdi_writeback *wb);
 
 /*
  * maximal error of a stat counter.
  */
-static inline unsigned long bdi_stat_error(struct backing_dev_info *bdi)
+static inline unsigned long wb_stat_error(struct bdi_writeback *wb)
 {
 #ifdef CONFIG_SMP
-        return nr_cpu_ids * BDI_STAT_BATCH;
+        return nr_cpu_ids * WB_STAT_BATCH;
 #else
         return 1;
 #endif
@@ -231,50 +141,57 @@ int bdi_set_max_ratio(struct backing_dev_info *bdi, unsigned int max_ratio);
  * BDI_CAP_NO_WRITEBACK:   Don't write pages back
  * BDI_CAP_NO_ACCT_WB:     Don't automatically account writeback pages
  * BDI_CAP_STRICTLIMIT:    Keep number of dirty pages below bdi threshold.
+ *
+ * BDI_CAP_CGROUP_WRITEBACK: Supports cgroup-aware writeback.
  */
 #define BDI_CAP_NO_ACCT_DIRTY   0x00000001
 #define BDI_CAP_NO_WRITEBACK    0x00000002
 #define BDI_CAP_NO_ACCT_WB      0x00000004
 #define BDI_CAP_STABLE_WRITES   0x00000008
 #define BDI_CAP_STRICTLIMIT     0x00000010
+#define BDI_CAP_CGROUP_WRITEBACK 0x00000020
 
 #define BDI_CAP_NO_ACCT_AND_WRITEBACK \
         (BDI_CAP_NO_WRITEBACK | BDI_CAP_NO_ACCT_DIRTY | BDI_CAP_NO_ACCT_WB)
 
 extern struct backing_dev_info noop_backing_dev_info;
 
-int writeback_in_progress(struct backing_dev_info *bdi);
-
-static inline int bdi_congested(struct backing_dev_info *bdi, int bdi_bits)
+/**
+ * writeback_in_progress - determine whether there is writeback in progress
+ * @wb: bdi_writeback of interest
+ *
+ * Determine whether there is writeback waiting to be handled against a
+ * bdi_writeback.
+ */
+static inline bool writeback_in_progress(struct bdi_writeback *wb)
 {
-        if (bdi->congested_fn)
-                return bdi->congested_fn(bdi->congested_data, bdi_bits);
-        return (bdi->state & bdi_bits);
+        return test_bit(WB_writeback_running, &wb->state);
 }
 
-static inline int bdi_read_congested(struct backing_dev_info *bdi)
+static inline struct backing_dev_info *inode_to_bdi(struct inode *inode)
 {
-        return bdi_congested(bdi, 1 << BDI_sync_congested);
-}
+        struct super_block *sb;
 
-static inline int bdi_write_congested(struct backing_dev_info *bdi)
-{
-        return bdi_congested(bdi, 1 << BDI_async_congested);
+        if (!inode)
+                return &noop_backing_dev_info;
+
+        sb = inode->i_sb;
+#ifdef CONFIG_BLOCK
+        if (sb_is_blkdev_sb(sb))
+                return blk_get_backing_dev_info(I_BDEV(inode));
+#endif
+        return sb->s_bdi;
 }
 
-static inline int bdi_rw_congested(struct backing_dev_info *bdi)
+static inline int wb_congested(struct bdi_writeback *wb, int cong_bits)
 {
-        return bdi_congested(bdi, (1 << BDI_sync_congested) |
-                                  (1 << BDI_async_congested));
-}
+        struct backing_dev_info *bdi = wb->bdi;
 
-enum {
-        BLK_RW_ASYNC    = 0,
-        BLK_RW_SYNC     = 1,
-};
+        if (bdi->congested_fn)
+                return bdi->congested_fn(bdi->congested_data, cong_bits);
+        return wb->congested->state & cong_bits;
+}
 
-void clear_bdi_congested(struct backing_dev_info *bdi, int sync);
-void set_bdi_congested(struct backing_dev_info *bdi, int sync);
 long congestion_wait(int sync, long timeout);
 long wait_iff_congested(struct zone *zone, int sync, long timeout);
 int pdflush_proc_obsolete(struct ctl_table *table, int write,
@@ -318,4 +235,336 @@ static inline int bdi_sched_wait(void *word)
         return 0;
 }
 
-#endif          /* _LINUX_BACKING_DEV_H */
+#ifdef CONFIG_CGROUP_WRITEBACK
+
+struct bdi_writeback_congested *
+wb_congested_get_create(struct backing_dev_info *bdi, int blkcg_id, gfp_t gfp);
+void wb_congested_put(struct bdi_writeback_congested *congested);
+struct bdi_writeback *wb_get_create(struct backing_dev_info *bdi,
+                                    struct cgroup_subsys_state *memcg_css,
+                                    gfp_t gfp);
+void wb_memcg_offline(struct mem_cgroup *memcg);
+void wb_blkcg_offline(struct blkcg *blkcg);
+int inode_congested(struct inode *inode, int cong_bits);
+
+/**
+ * inode_cgwb_enabled - test whether cgroup writeback is enabled on an inode
+ * @inode: inode of interest
+ *
+ * cgroup writeback requires support from both the bdi and filesystem.
+ * Test whether @inode has both.
+ */
+static inline bool inode_cgwb_enabled(struct inode *inode)
+{
+        struct backing_dev_info *bdi = inode_to_bdi(inode);
+
+        return bdi_cap_account_dirty(bdi) &&
+                (bdi->capabilities & BDI_CAP_CGROUP_WRITEBACK) &&
+                (inode->i_sb->s_iflags & SB_I_CGROUPWB);
+}
+
+/**
+ * wb_find_current - find wb for %current on a bdi
+ * @bdi: bdi of interest
+ *
+ * Find the wb of @bdi which matches both the memcg and blkcg of %current.
+ * Must be called under rcu_read_lock() which protects the returend wb.
+ * NULL if not found.
+ */
+static inline struct bdi_writeback *wb_find_current(struct backing_dev_info *bdi)
+{
+        struct cgroup_subsys_state *memcg_css;
+        struct bdi_writeback *wb;
+
+        memcg_css = task_css(current, memory_cgrp_id);
+        if (!memcg_css->parent)
+                return &bdi->wb;
+
+        wb = radix_tree_lookup(&bdi->cgwb_tree, memcg_css->id);
+
+        /*
+         * %current's blkcg equals the effective blkcg of its memcg.  No
+         * need to use the relatively expensive cgroup_get_e_css().
+         */
+        if (likely(wb && wb->blkcg_css == task_css(current, blkio_cgrp_id)))
+                return wb;
+        return NULL;
+}
+
+/**
+ * wb_get_create_current - get or create wb for %current on a bdi
+ * @bdi: bdi of interest
+ * @gfp: allocation mask
+ *
+ * Equivalent to wb_get_create() on %current's memcg.  This function is
+ * called from a relatively hot path and optimizes the common cases using
+ * wb_find_current().
+ */
+static inline struct bdi_writeback *
+wb_get_create_current(struct backing_dev_info *bdi, gfp_t gfp)
+{
+        struct bdi_writeback *wb;
+
+        rcu_read_lock();
+        wb = wb_find_current(bdi);
+        if (wb && unlikely(!wb_tryget(wb)))
+                wb = NULL;
+        rcu_read_unlock();
+
+        if (unlikely(!wb)) {
+                struct cgroup_subsys_state *memcg_css;
+
+                memcg_css = task_get_css(current, memory_cgrp_id);
+                wb = wb_get_create(bdi, memcg_css, gfp);
+                css_put(memcg_css);
+        }
+        return wb;
+}
+
+/**
+ * inode_to_wb_is_valid - test whether an inode has a wb associated
+ * @inode: inode of interest
+ *
+ * Returns %true if @inode has a wb associated.  May be called without any
+ * locking.
+ */
+static inline bool inode_to_wb_is_valid(struct inode *inode)
+{
+        return inode->i_wb;
+}
+
+/**
+ * inode_to_wb - determine the wb of an inode
+ * @inode: inode of interest
+ *
+ * Returns the wb @inode is currently associated with.  The caller must be
+ * holding either @inode->i_lock, @inode->i_mapping->tree_lock, or the
+ * associated wb's list_lock.
+ */
+static inline struct bdi_writeback *inode_to_wb(struct inode *inode)
+{
+#ifdef CONFIG_LOCKDEP
+        WARN_ON_ONCE(debug_locks &&
+                     (!lockdep_is_held(&inode->i_lock) &&
+                      !lockdep_is_held(&inode->i_mapping->tree_lock) &&
+                      !lockdep_is_held(&inode->i_wb->list_lock)));
+#endif
+        return inode->i_wb;
+}
+
+/**
+ * unlocked_inode_to_wb_begin - begin unlocked inode wb access transaction
+ * @inode: target inode
+ * @lockedp: temp bool output param, to be passed to the end function
+ *
+ * The caller wants to access the wb associated with @inode but isn't
+ * holding inode->i_lock, mapping->tree_lock or wb->list_lock.  This
+ * function determines the wb associated with @inode and ensures that the
+ * association doesn't change until the transaction is finished with
+ * unlocked_inode_to_wb_end().
+ *
+ * The caller must call unlocked_inode_to_wb_end() with *@lockdep
+ * afterwards and can't sleep during transaction.  IRQ may or may not be
+ * disabled on return.
+ */
+static inline struct bdi_writeback *
+unlocked_inode_to_wb_begin(struct inode *inode, bool *lockedp)
+{
+        rcu_read_lock();
+
+        /*
+         * Paired with store_release in inode_switch_wb_work_fn() and
+         * ensures that we see the new wb if we see cleared I_WB_SWITCH.
+         */
+        *lockedp = smp_load_acquire(&inode->i_state) & I_WB_SWITCH;
+
+        if (unlikely(*lockedp))
+                spin_lock_irq(&inode->i_mapping->tree_lock);
+
+        /*
+         * Protected by either !I_WB_SWITCH + rcu_read_lock() or tree_lock.
+         * inode_to_wb() will bark.  Deref directly.
+         */
+        return inode->i_wb;
+}
+
+/**
+ * unlocked_inode_to_wb_end - end inode wb access transaction
+ * @inode: target inode
+ * @locked: *@lockedp from unlocked_inode_to_wb_begin()
+ */
+static inline void unlocked_inode_to_wb_end(struct inode *inode, bool locked)
+{
+        if (unlikely(locked))
+                spin_unlock_irq(&inode->i_mapping->tree_lock);
+
+        rcu_read_unlock();
+}
+
+struct wb_iter {
+        int                     start_blkcg_id;
+        struct radix_tree_iter  tree_iter;
+        void                    **slot;
+};
+
+static inline struct bdi_writeback *__wb_iter_next(struct wb_iter *iter,
+                                                   struct backing_dev_info *bdi)
+{
+        struct radix_tree_iter *titer = &iter->tree_iter;
+
+        WARN_ON_ONCE(!rcu_read_lock_held());
+
+        if (iter->start_blkcg_id >= 0) {
+                iter->slot = radix_tree_iter_init(titer, iter->start_blkcg_id);
+                iter->start_blkcg_id = -1;
+        } else {
+                iter->slot = radix_tree_next_slot(iter->slot, titer, 0);
+        }
+
+        if (!iter->slot)
+                iter->slot = radix_tree_next_chunk(&bdi->cgwb_tree, titer, 0);
+        if (iter->slot)
+                return *iter->slot;
+        return NULL;
+}
+
+static inline struct bdi_writeback *__wb_iter_init(struct wb_iter *iter,
+                                                   struct backing_dev_info *bdi,
+                                                   int start_blkcg_id)
+{
+        iter->start_blkcg_id = start_blkcg_id;
+
+        if (start_blkcg_id)
+                return __wb_iter_next(iter, bdi);
+        else
+                return &bdi->wb;
+}
+
+/**
+ * bdi_for_each_wb - walk all wb's of a bdi in ascending blkcg ID order
+ * @wb_cur: cursor struct bdi_writeback pointer
+ * @bdi: bdi to walk wb's of
+ * @iter: pointer to struct wb_iter to be used as iteration buffer
+ * @start_blkcg_id: blkcg ID to start iteration from
+ *
+ * Iterate @wb_cur through the wb's (bdi_writeback's) of @bdi in ascending
+ * blkcg ID order starting from @start_blkcg_id.  @iter is struct wb_iter
+ * to be used as temp storage during iteration.  rcu_read_lock() must be
+ * held throughout iteration.
+ */
+#define bdi_for_each_wb(wb_cur, bdi, iter, start_blkcg_id)              \
+        for ((wb_cur) = __wb_iter_init(iter, bdi, start_blkcg_id);      \
+             (wb_cur); (wb_cur) = __wb_iter_next(iter, bdi))
+
+#else   /* CONFIG_CGROUP_WRITEBACK */
+
+static inline bool inode_cgwb_enabled(struct inode *inode)
+{
+        return false;
+}
+
+static inline struct bdi_writeback_congested *
+wb_congested_get_create(struct backing_dev_info *bdi, int blkcg_id, gfp_t gfp)
+{
+        atomic_inc(&bdi->wb_congested->refcnt);
+        return bdi->wb_congested;
+}
+
+static inline void wb_congested_put(struct bdi_writeback_congested *congested)
+{
+        if (atomic_dec_and_test(&congested->refcnt))
+                kfree(congested);
+}
+
+static inline struct bdi_writeback *wb_find_current(struct backing_dev_info *bdi)
+{
+        return &bdi->wb;
+}
+
+static inline struct bdi_writeback *
+wb_get_create_current(struct backing_dev_info *bdi, gfp_t gfp)
+{
+        return &bdi->wb;
+}
+
+static inline bool inode_to_wb_is_valid(struct inode *inode)
+{
+        return true;
+}
+
+static inline struct bdi_writeback *inode_to_wb(struct inode *inode)
+{
+        return &inode_to_bdi(inode)->wb;
+}
+
+static inline struct bdi_writeback *
+unlocked_inode_to_wb_begin(struct inode *inode, bool *lockedp)
+{
+        return inode_to_wb(inode);
+}
+
+static inline void unlocked_inode_to_wb_end(struct inode *inode, bool locked)
+{
+}
+
+static inline void wb_memcg_offline(struct mem_cgroup *memcg)
+{
+}
+
+static inline void wb_blkcg_offline(struct blkcg *blkcg)
+{
+}
+
+struct wb_iter {
+        int             next_id;
+};
+
+#define bdi_for_each_wb(wb_cur, bdi, iter, start_blkcg_id)              \
+        for ((iter)->next_id = (start_blkcg_id);                        \
+             ({ (wb_cur) = !(iter)->next_id++ ? &(bdi)->wb : NULL; }); )
+
+static inline int inode_congested(struct inode *inode, int cong_bits)
+{
+        return wb_congested(&inode_to_bdi(inode)->wb, cong_bits);
+}
+
+#endif  /* CONFIG_CGROUP_WRITEBACK */
+
+static inline int inode_read_congested(struct inode *inode)
+{
+        return inode_congested(inode, 1 << WB_sync_congested);
+}
+
+static inline int inode_write_congested(struct inode *inode)
+{
+        return inode_congested(inode, 1 << WB_async_congested);
+}
+
+static inline int inode_rw_congested(struct inode *inode)
+{
+        return inode_congested(inode, (1 << WB_sync_congested) |
+                                      (1 << WB_async_congested));
+}
+
+static inline int bdi_congested(struct backing_dev_info *bdi, int cong_bits)
+{
+        return wb_congested(&bdi->wb, cong_bits);
+}
+
+static inline int bdi_read_congested(struct backing_dev_info *bdi)
+{
+        return bdi_congested(bdi, 1 << WB_sync_congested);
+}
+
+static inline int bdi_write_congested(struct backing_dev_info *bdi)
+{
+        return bdi_congested(bdi, 1 << WB_async_congested);
+}
+
+static inline int bdi_rw_congested(struct backing_dev_info *bdi)
+{
+        return bdi_congested(bdi, (1 << WB_sync_congested) |
+                                  (1 << WB_async_congested));
+}
+
+#endif  /* _LINUX_BACKING_DEV_H */
diff --git a/include/linux/backlight.h b/include/linux/backlight.h
index adb14a8616df..1e7a69adbe6f 100644
--- a/include/linux/backlight.h
+++ b/include/linux/backlight.h
@@ -117,12 +117,16 @@ struct backlight_device {
         int use_count;
 };
 
-static inline void backlight_update_status(struct backlight_device *bd)
+static inline int backlight_update_status(struct backlight_device *bd)
 {
+        int ret = -ENOENT;
+
         mutex_lock(&bd->update_lock);
         if (bd->ops && bd->ops->update_status)
-                bd->ops->update_status(bd);
+                ret = bd->ops->update_status(bd);
         mutex_unlock(&bd->update_lock);
+
+        return ret;
 }
 
 extern struct backlight_device *backlight_device_register(const char *name,
diff --git a/include/linux/bcm47xx_nvram.h b/include/linux/bcm47xx_nvram.h
index b12b07e75929..2793652fbf66 100644
--- a/include/linux/bcm47xx_nvram.h
+++ b/include/linux/bcm47xx_nvram.h
@@ -10,11 +10,17 @@
 
 #include <linux/types.h>
 #include <linux/kernel.h>
+#include <linux/vmalloc.h>
 
-#ifdef CONFIG_BCM47XX
+#ifdef CONFIG_BCM47XX_NVRAM
 int bcm47xx_nvram_init_from_mem(u32 base, u32 lim);
 int bcm47xx_nvram_getenv(const char *name, char *val, size_t val_len);
 int bcm47xx_nvram_gpio_pin(const char *name);
+char *bcm47xx_nvram_get_contents(size_t *val_len);
+static inline void bcm47xx_nvram_release_contents(char *nvram)
+{
+        vfree(nvram);
+};
 #else
 static inline int bcm47xx_nvram_init_from_mem(u32 base, u32 lim)
 {
@@ -29,6 +35,15 @@ static inline int bcm47xx_nvram_gpio_pin(const char *name)
 {
         return -ENOTSUPP;
 };
+
+static inline char *bcm47xx_nvram_get_contents(size_t *val_len)
+{
+        return NULL;
+};
+
+static inline void bcm47xx_nvram_release_contents(char *nvram)
+{
+};
 #endif
 
 #endif /* __BCM47XX_NVRAM_H */
diff --git a/include/linux/bcma/bcma.h b/include/linux/bcma/bcma.h
index e34f906647d3..2ff4a9961e1d 100644
--- a/include/linux/bcma/bcma.h
+++ b/include/linux/bcma/bcma.h
@@ -305,6 +305,15 @@ int __bcma_driver_register(struct bcma_driver *drv, struct module *owner);
 
 extern void bcma_driver_unregister(struct bcma_driver *drv);
 
+/* module_bcma_driver() - Helper macro for drivers that don't do
+ * anything special in module init/exit.  This eliminates a lot of
+ * boilerplate.  Each module may only use this macro once, and
+ * calling it replaces module_init() and module_exit()
+ */
+#define module_bcma_driver(__bcma_driver) \
+        module_driver(__bcma_driver, bcma_driver_register, \
+                        bcma_driver_unregister)
+
 /* Set a fallback SPROM.
  * See kdoc at the function definition for complete documentation. */
 extern int bcma_arch_register_fallback_sprom(
diff --git a/include/linux/bcma/bcma_driver_pci.h b/include/linux/bcma/bcma_driver_pci.h
index 5ba6918ca20b..9657f11d48a7 100644
--- a/include/linux/bcma/bcma_driver_pci.h
+++ b/include/linux/bcma/bcma_driver_pci.h
@@ -246,7 +246,18 @@ static inline void bcma_core_pci_power_save(struct bcma_bus *bus, bool up)
 }
 #endif
 
+#ifdef CONFIG_BCMA_DRIVER_PCI_HOSTMODE
 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);
+#else
+static inline int bcma_core_pci_pcibios_map_irq(const struct pci_dev *dev)
+{
+        return -ENOTSUPP;
+}
+static inline int bcma_core_pci_plat_dev_init(struct pci_dev *dev)
+{
+        return -ENOTSUPP;
+}
+#endif
 
 #endif /* LINUX_BCMA_DRIVER_PCI_H_ */
diff --git a/include/linux/bio.h b/include/linux/bio.h
index da3a127c9958..5e963a6d7c14 100644
--- a/include/linux/bio.h
+++ b/include/linux/bio.h
@@ -290,7 +290,21 @@ static inline unsigned bio_segments(struct bio *bio)
  * returns. and then bio would be freed memory when if (bio->bi_flags ...)
  * runs
  */
-#define bio_get(bio)    atomic_inc(&(bio)->bi_cnt)
+static inline void bio_get(struct bio *bio)
+{
+        bio->bi_flags |= (1 << BIO_REFFED);
+        smp_mb__before_atomic();
+        atomic_inc(&bio->__bi_cnt);
+}
+
+static inline void bio_cnt_set(struct bio *bio, unsigned int count)
+{
+        if (count != 1) {
+                bio->bi_flags |= (1 << BIO_REFFED);
+                smp_mb__before_atomic();
+        }
+        atomic_set(&bio->__bi_cnt, count);
+}
 
 enum bip_flags {
         BIP_BLOCK_INTEGRITY     = 1 << 0, /* block layer owns integrity data */
@@ -413,7 +427,6 @@ static inline struct bio *bio_clone_kmalloc(struct bio *bio, gfp_t gfp_mask)
 }
 
 extern void bio_endio(struct bio *, int);
-extern void bio_endio_nodec(struct bio *, int);
 struct request_queue;
 extern int bio_phys_segments(struct request_queue *, struct bio *);
 
@@ -469,9 +482,12 @@ extern void bvec_free(mempool_t *, struct bio_vec *, unsigned int);
 extern unsigned int bvec_nr_vecs(unsigned short idx);
 
 #ifdef CONFIG_BLK_CGROUP
+int bio_associate_blkcg(struct bio *bio, struct cgroup_subsys_state *blkcg_css);
 int bio_associate_current(struct bio *bio);
 void bio_disassociate_task(struct bio *bio);
 #else   /* CONFIG_BLK_CGROUP */
+static inline int bio_associate_blkcg(struct bio *bio,
+                        struct cgroup_subsys_state *blkcg_css) { return 0; }
 static inline int bio_associate_current(struct bio *bio) { return -ENOENT; }
 static inline void bio_disassociate_task(struct bio *bio) { }
 #endif  /* CONFIG_BLK_CGROUP */
diff --git a/include/linux/blk-cgroup.h b/include/linux/blk-cgroup.h
new file mode 100644
index 000000000000..1b62d768c7df
--- /dev/null
+++ b/include/linux/blk-cgroup.h
@@ -0,0 +1,650 @@
+#ifndef _BLK_CGROUP_H
+#define _BLK_CGROUP_H
+/*
+ * Common Block IO controller cgroup interface
+ *
+ * Based on ideas and code from CFQ, CFS and BFQ:
+ * Copyright (C) 2003 Jens Axboe <axboe@kernel.dk>
+ *
+ * Copyright (C) 2008 Fabio Checconi <fabio@gandalf.sssup.it>
+ *                    Paolo Valente <paolo.valente@unimore.it>
+ *
+ * Copyright (C) 2009 Vivek Goyal <vgoyal@redhat.com>
+ *                    Nauman Rafique <nauman@google.com>
+ */
+
+#include <linux/cgroup.h>
+#include <linux/u64_stats_sync.h>
+#include <linux/seq_file.h>
+#include <linux/radix-tree.h>
+#include <linux/blkdev.h>
+#include <linux/atomic.h>
+
+/* Max limits for throttle policy */
+#define THROTL_IOPS_MAX         UINT_MAX
+
+#ifdef CONFIG_BLK_CGROUP
+
+enum blkg_rwstat_type {
+        BLKG_RWSTAT_READ,
+        BLKG_RWSTAT_WRITE,
+        BLKG_RWSTAT_SYNC,
+        BLKG_RWSTAT_ASYNC,
+
+        BLKG_RWSTAT_NR,
+        BLKG_RWSTAT_TOTAL = BLKG_RWSTAT_NR,
+};
+
+struct blkcg_gq;
+
+struct blkcg {
+        struct cgroup_subsys_state      css;
+        spinlock_t                      lock;
+
+        struct radix_tree_root          blkg_tree;
+        struct blkcg_gq                 *blkg_hint;
+        struct hlist_head               blkg_list;
+
+        struct blkcg_policy_data        *pd[BLKCG_MAX_POLS];
+
+        struct list_head                all_blkcgs_node;
+#ifdef CONFIG_CGROUP_WRITEBACK
+        struct list_head                cgwb_list;
+#endif
+};
+
+struct blkg_stat {
+        struct u64_stats_sync           syncp;
+        uint64_t                        cnt;
+};
+
+struct blkg_rwstat {
+        struct u64_stats_sync           syncp;
+        uint64_t                        cnt[BLKG_RWSTAT_NR];
+};
+
+/*
+ * A blkcg_gq (blkg) is association between a block cgroup (blkcg) and a
+ * request_queue (q).  This is used by blkcg policies which need to track
+ * information per blkcg - q pair.
+ *
+ * There can be multiple active blkcg policies and each has its private
+ * data on each blkg, the size of which is determined by
+ * blkcg_policy->pd_size.  blkcg core allocates and frees such areas
+ * together with blkg and invokes pd_init/exit_fn() methods.
+ *
+ * Such private data must embed struct blkg_policy_data (pd) at the
+ * beginning and pd_size can't be smaller than pd.
+ */
+struct blkg_policy_data {
+        /* the blkg and policy id this per-policy data belongs to */
+        struct blkcg_gq                 *blkg;
+        int                             plid;
+
+        /* used during policy activation */
+        struct list_head                alloc_node;
+};
+
+/*
+ * Policies that need to keep per-blkcg data which is independent
+ * from any request_queue associated to it must specify its size
+ * with the cpd_size field of the blkcg_policy structure and
+ * embed a blkcg_policy_data in it.  cpd_init() is invoked to let
+ * each policy handle per-blkcg data.
+ */
+struct blkcg_policy_data {
+        /* the policy id this per-policy data belongs to */
+        int                             plid;
+};
+
+/* association between a blk cgroup and a request queue */
+struct blkcg_gq {
+        /* Pointer to the associated request_queue */
+        struct request_queue            *q;
+        struct list_head                q_node;
+        struct hlist_node               blkcg_node;
+        struct blkcg                    *blkcg;
+
+        /*
+         * Each blkg gets congested separately and the congestion state is
+         * propagated to the matching bdi_writeback_congested.
+         */
+        struct bdi_writeback_congested  *wb_congested;
+
+        /* all non-root blkcg_gq's are guaranteed to have access to parent */
+        struct blkcg_gq                 *parent;
+
+        /* request allocation list for this blkcg-q pair */
+        struct request_list             rl;
+
+        /* reference count */
+        atomic_t                        refcnt;
+
+        /* is this blkg online? protected by both blkcg and q locks */
+        bool                            online;
+
+        struct blkg_policy_data         *pd[BLKCG_MAX_POLS];
+
+        struct rcu_head                 rcu_head;
+};
+
+typedef void (blkcg_pol_init_cpd_fn)(const struct blkcg *blkcg);
+typedef void (blkcg_pol_init_pd_fn)(struct blkcg_gq *blkg);
+typedef void (blkcg_pol_online_pd_fn)(struct blkcg_gq *blkg);
+typedef void (blkcg_pol_offline_pd_fn)(struct blkcg_gq *blkg);
+typedef void (blkcg_pol_exit_pd_fn)(struct blkcg_gq *blkg);
+typedef void (blkcg_pol_reset_pd_stats_fn)(struct blkcg_gq *blkg);
+
+struct blkcg_policy {
+        int                             plid;
+        /* policy specific private data size */
+        size_t                          pd_size;
+        /* policy specific per-blkcg data size */
+        size_t                          cpd_size;
+        /* cgroup files for the policy */
+        struct cftype                   *cftypes;
+
+        /* operations */
+        blkcg_pol_init_cpd_fn           *cpd_init_fn;
+        blkcg_pol_init_pd_fn            *pd_init_fn;
+        blkcg_pol_online_pd_fn          *pd_online_fn;
+        blkcg_pol_offline_pd_fn         *pd_offline_fn;
+        blkcg_pol_exit_pd_fn            *pd_exit_fn;
+        blkcg_pol_reset_pd_stats_fn     *pd_reset_stats_fn;
+};
+
+extern struct blkcg blkcg_root;
+extern struct cgroup_subsys_state * const blkcg_root_css;
+
+struct blkcg_gq *blkg_lookup(struct blkcg *blkcg, struct request_queue *q);
+struct blkcg_gq *blkg_lookup_create(struct blkcg *blkcg,
+                                    struct request_queue *q);
+int blkcg_init_queue(struct request_queue *q);
+void blkcg_drain_queue(struct request_queue *q);
+void blkcg_exit_queue(struct request_queue *q);
+
+/* Blkio controller policy registration */
+int blkcg_policy_register(struct blkcg_policy *pol);
+void blkcg_policy_unregister(struct blkcg_policy *pol);
+int blkcg_activate_policy(struct request_queue *q,
+                          const struct blkcg_policy *pol);
+void blkcg_deactivate_policy(struct request_queue *q,
+                             const struct blkcg_policy *pol);
+
+void blkcg_print_blkgs(struct seq_file *sf, struct blkcg *blkcg,
+                       u64 (*prfill)(struct seq_file *,
+                                     struct blkg_policy_data *, int),
+                       const struct blkcg_policy *pol, int data,
+                       bool show_total);
+u64 __blkg_prfill_u64(struct seq_file *sf, struct blkg_policy_data *pd, u64 v);
+u64 __blkg_prfill_rwstat(struct seq_file *sf, struct blkg_policy_data *pd,
+                         const struct blkg_rwstat *rwstat);
+u64 blkg_prfill_stat(struct seq_file *sf, struct blkg_policy_data *pd, int off);
+u64 blkg_prfill_rwstat(struct seq_file *sf, struct blkg_policy_data *pd,
+                       int off);
+
+u64 blkg_stat_recursive_sum(struct blkg_policy_data *pd, int off);
+struct blkg_rwstat blkg_rwstat_recursive_sum(struct blkg_policy_data *pd,
+                                             int off);
+
+struct blkg_conf_ctx {
+        struct gendisk                  *disk;
+        struct blkcg_gq                 *blkg;
+        u64                             v;
+};
+
+int blkg_conf_prep(struct blkcg *blkcg, const struct blkcg_policy *pol,
+                   const char *input, struct blkg_conf_ctx *ctx);
+void blkg_conf_finish(struct blkg_conf_ctx *ctx);
+
+
+static inline struct blkcg *css_to_blkcg(struct cgroup_subsys_state *css)
+{
+        return css ? container_of(css, struct blkcg, css) : NULL;
+}
+
+static inline struct blkcg *task_blkcg(struct task_struct *tsk)
+{
+        return css_to_blkcg(task_css(tsk, blkio_cgrp_id));
+}
+
+static inline struct blkcg *bio_blkcg(struct bio *bio)
+{
+        if (bio && bio->bi_css)
+                return css_to_blkcg(bio->bi_css);
+        return task_blkcg(current);
+}
+
+static inline struct cgroup_subsys_state *
+task_get_blkcg_css(struct task_struct *task)
+{
+        return task_get_css(task, blkio_cgrp_id);
+}
+
+/**
+ * blkcg_parent - get the parent of a blkcg
+ * @blkcg: blkcg of interest
+ *
+ * Return the parent blkcg of @blkcg.  Can be called anytime.
+ */
+static inline struct blkcg *blkcg_parent(struct blkcg *blkcg)
+{
+        return css_to_blkcg(blkcg->css.parent);
+}
+
+/**
+ * blkg_to_pdata - get policy private data
+ * @blkg: blkg of interest
+ * @pol: policy of interest
+ *
+ * Return pointer to private data associated with the @blkg-@pol pair.
+ */
+static inline struct blkg_policy_data *blkg_to_pd(struct blkcg_gq *blkg,
+                                                  struct blkcg_policy *pol)
+{
+        return blkg ? blkg->pd[pol->plid] : NULL;
+}
+
+static inline struct blkcg_policy_data *blkcg_to_cpd(struct blkcg *blkcg,
+                                                     struct blkcg_policy *pol)
+{
+        return blkcg ? blkcg->pd[pol->plid] : NULL;
+}
+
+/**
+ * pdata_to_blkg - get blkg associated with policy private data
+ * @pd: policy private data of interest
+ *
+ * @pd is policy private data.  Determine the blkg it's associated with.
+ */
+static inline struct blkcg_gq *pd_to_blkg(struct blkg_policy_data *pd)
+{
+        return pd ? pd->blkg : NULL;
+}
+
+/**
+ * blkg_path - format cgroup path of blkg
+ * @blkg: blkg of interest
+ * @buf: target buffer
+ * @buflen: target buffer length
+ *
+ * Format the path of the cgroup of @blkg into @buf.
+ */
+static inline int blkg_path(struct blkcg_gq *blkg, char *buf, int buflen)
+{
+        char *p;
+
+        p = cgroup_path(blkg->blkcg->css.cgroup, buf, buflen);
+        if (!p) {
+                strncpy(buf, "<unavailable>", buflen);
+                return -ENAMETOOLONG;
+        }
+
+        memmove(buf, p, buf + buflen - p);
+        return 0;
+}
+
+/**
+ * blkg_get - get a blkg reference
+ * @blkg: blkg to get
+ *
+ * The caller should be holding an existing reference.
+ */
+static inline void blkg_get(struct blkcg_gq *blkg)
+{
+        WARN_ON_ONCE(atomic_read(&blkg->refcnt) <= 0);
+        atomic_inc(&blkg->refcnt);
+}
+
+void __blkg_release_rcu(struct rcu_head *rcu);
+
+/**
+ * blkg_put - put a blkg reference
+ * @blkg: blkg to put
+ */
+static inline void blkg_put(struct blkcg_gq *blkg)
+{
+        WARN_ON_ONCE(atomic_read(&blkg->refcnt) <= 0);
+        if (atomic_dec_and_test(&blkg->refcnt))
+                call_rcu(&blkg->rcu_head, __blkg_release_rcu);
+}
+
+struct blkcg_gq *__blkg_lookup(struct blkcg *blkcg, struct request_queue *q,
+                               bool update_hint);
+
+/**
+ * blkg_for_each_descendant_pre - pre-order walk of a blkg's descendants
+ * @d_blkg: loop cursor pointing to the current descendant
+ * @pos_css: used for iteration
+ * @p_blkg: target blkg to walk descendants of
+ *
+ * Walk @c_blkg through the descendants of @p_blkg.  Must be used with RCU
+ * read locked.  If called under either blkcg or queue lock, the iteration
+ * is guaranteed to include all and only online blkgs.  The caller may
+ * update @pos_css by calling css_rightmost_descendant() to skip subtree.
+ * @p_blkg is included in the iteration and the first node to be visited.
+ */
+#define blkg_for_each_descendant_pre(d_blkg, pos_css, p_blkg)           \
+        css_for_each_descendant_pre((pos_css), &(p_blkg)->blkcg->css)   \
+                if (((d_blkg) = __blkg_lookup(css_to_blkcg(pos_css),    \
+                                              (p_blkg)->q, false)))
+
+/**
+ * blkg_for_each_descendant_post - post-order walk of a blkg's descendants
+ * @d_blkg: loop cursor pointing to the current descendant
+ * @pos_css: used for iteration
+ * @p_blkg: target blkg to walk descendants of
+ *
+ * Similar to blkg_for_each_descendant_pre() but performs post-order
+ * traversal instead.  Synchronization rules are the same.  @p_blkg is
+ * included in the iteration and the last node to be visited.
+ */
+#define blkg_for_each_descendant_post(d_blkg, pos_css, p_blkg)          \
+        css_for_each_descendant_post((pos_css), &(p_blkg)->blkcg->css)  \
+                if (((d_blkg) = __blkg_lookup(css_to_blkcg(pos_css),    \
+                                              (p_blkg)->q, false)))
+
+/**
+ * blk_get_rl - get request_list to use
+ * @q: request_queue of interest
+ * @bio: bio which will be attached to the allocated request (may be %NULL)
+ *
+ * The caller wants to allocate a request from @q to use for @bio.  Find
+ * the request_list to use and obtain a reference on it.  Should be called
+ * under queue_lock.  This function is guaranteed to return non-%NULL
+ * request_list.
+ */
+static inline struct request_list *blk_get_rl(struct request_queue *q,
+                                              struct bio *bio)
+{
+        struct blkcg *blkcg;
+        struct blkcg_gq *blkg;
+
+        rcu_read_lock();
+
+        blkcg = bio_blkcg(bio);
+
+        /* bypass blkg lookup and use @q->root_rl directly for root */
+        if (blkcg == &blkcg_root)
+                goto root_rl;
+
+        /*
+         * Try to use blkg->rl.  blkg lookup may fail under memory pressure
+         * or if either the blkcg or queue is going away.  Fall back to
+         * root_rl in such cases.
+         */
+        blkg = blkg_lookup_create(blkcg, q);
+        if (unlikely(IS_ERR(blkg)))
+                goto root_rl;
+
+        blkg_get(blkg);
+        rcu_read_unlock();
+        return &blkg->rl;
+root_rl:
+        rcu_read_unlock();
+        return &q->root_rl;
+}
+
+/**
+ * blk_put_rl - put request_list
+ * @rl: request_list to put
+ *
+ * Put the reference acquired by blk_get_rl().  Should be called under
+ * queue_lock.
+ */
+static inline void blk_put_rl(struct request_list *rl)
+{
+        /* root_rl may not have blkg set */
+        if (rl->blkg && rl->blkg->blkcg != &blkcg_root)
+                blkg_put(rl->blkg);
+}
+
+/**
+ * blk_rq_set_rl - associate a request with a request_list
+ * @rq: request of interest
+ * @rl: target request_list
+ *
+ * Associate @rq with @rl so that accounting and freeing can know the
+ * request_list @rq came from.
+ */
+static inline void blk_rq_set_rl(struct request *rq, struct request_list *rl)
+{
+        rq->rl = rl;
+}
+
+/**
+ * blk_rq_rl - return the request_list a request came from
+ * @rq: request of interest
+ *
+ * Return the request_list @rq is allocated from.
+ */
+static inline struct request_list *blk_rq_rl(struct request *rq)
+{
+        return rq->rl;
+}
+
+struct request_list *__blk_queue_next_rl(struct request_list *rl,
+                                         struct request_queue *q);
+/**
+ * blk_queue_for_each_rl - iterate through all request_lists of a request_queue
+ *
+ * Should be used under queue_lock.
+ */
+#define blk_queue_for_each_rl(rl, q)    \
+        for ((rl) = &(q)->root_rl; (rl); (rl) = __blk_queue_next_rl((rl), (q)))
+
+static inline void blkg_stat_init(struct blkg_stat *stat)
+{
+        u64_stats_init(&stat->syncp);
+}
+
+/**
+ * blkg_stat_add - add a value to a blkg_stat
+ * @stat: target blkg_stat
+ * @val: value to add
+ *
+ * Add @val to @stat.  The caller is responsible for synchronizing calls to
+ * this function.
+ */
+static inline void blkg_stat_add(struct blkg_stat *stat, uint64_t val)
+{
+        u64_stats_update_begin(&stat->syncp);
+        stat->cnt += val;
+        u64_stats_update_end(&stat->syncp);
+}
+
+/**
+ * blkg_stat_read - read the current value of a blkg_stat
+ * @stat: blkg_stat to read
+ *
+ * Read the current value of @stat.  This function can be called without
+ * synchroniztion and takes care of u64 atomicity.
+ */
+static inline uint64_t blkg_stat_read(struct blkg_stat *stat)
+{
+        unsigned int start;
+        uint64_t v;
+
+        do {
+                start = u64_stats_fetch_begin_irq(&stat->syncp);
+                v = stat->cnt;
+        } while (u64_stats_fetch_retry_irq(&stat->syncp, start));
+
+        return v;
+}
+
+/**
+ * blkg_stat_reset - reset a blkg_stat
+ * @stat: blkg_stat to reset
+ */
+static inline void blkg_stat_reset(struct blkg_stat *stat)
+{
+        stat->cnt = 0;
+}
+
+/**
+ * blkg_stat_merge - merge a blkg_stat into another
+ * @to: the destination blkg_stat
+ * @from: the source
+ *
+ * Add @from's count to @to.
+ */
+static inline void blkg_stat_merge(struct blkg_stat *to, struct blkg_stat *from)
+{
+        blkg_stat_add(to, blkg_stat_read(from));
+}
+
+static inline void blkg_rwstat_init(struct blkg_rwstat *rwstat)
+{
+        u64_stats_init(&rwstat->syncp);
+}
+
+/**
+ * blkg_rwstat_add - add a value to a blkg_rwstat
+ * @rwstat: target blkg_rwstat
+ * @rw: mask of REQ_{WRITE|SYNC}
+ * @val: value to add
+ *
+ * Add @val to @rwstat.  The counters are chosen according to @rw.  The
+ * caller is responsible for synchronizing calls to this function.
+ */
+static inline void blkg_rwstat_add(struct blkg_rwstat *rwstat,
+                                   int rw, uint64_t val)
+{
+        u64_stats_update_begin(&rwstat->syncp);
+
+        if (rw & REQ_WRITE)
+                rwstat->cnt[BLKG_RWSTAT_WRITE] += val;
+        else
+                rwstat->cnt[BLKG_RWSTAT_READ] += val;
+        if (rw & REQ_SYNC)
+                rwstat->cnt[BLKG_RWSTAT_SYNC] += val;
+        else
+                rwstat->cnt[BLKG_RWSTAT_ASYNC] += val;
+
+        u64_stats_update_end(&rwstat->syncp);
+}
+
+/**
+ * blkg_rwstat_read - read the current values of a blkg_rwstat
+ * @rwstat: blkg_rwstat to read
+ *
+ * Read the current snapshot of @rwstat and return it as the return value.
+ * This function can be called without synchronization and takes care of
+ * u64 atomicity.
+ */
+static inline struct blkg_rwstat blkg_rwstat_read(struct blkg_rwstat *rwstat)
+{
+        unsigned int start;
+        struct blkg_rwstat tmp;
+
+        do {
+                start = u64_stats_fetch_begin_irq(&rwstat->syncp);
+                tmp = *rwstat;
+        } while (u64_stats_fetch_retry_irq(&rwstat->syncp, start));
+
+        return tmp;
+}
+
+/**
+ * blkg_rwstat_total - read the total count of a blkg_rwstat
+ * @rwstat: blkg_rwstat to read
+ *
+ * Return the total count of @rwstat regardless of the IO direction.  This
+ * function can be called without synchronization and takes care of u64
+ * atomicity.
+ */
+static inline uint64_t blkg_rwstat_total(struct blkg_rwstat *rwstat)
+{
+        struct blkg_rwstat tmp = blkg_rwstat_read(rwstat);
+
+        return tmp.cnt[BLKG_RWSTAT_READ] + tmp.cnt[BLKG_RWSTAT_WRITE];
+}
+
+/**
+ * blkg_rwstat_reset - reset a blkg_rwstat
+ * @rwstat: blkg_rwstat to reset
+ */
+static inline void blkg_rwstat_reset(struct blkg_rwstat *rwstat)
+{
+        memset(rwstat->cnt, 0, sizeof(rwstat->cnt));
+}
+
+/**
+ * blkg_rwstat_merge - merge a blkg_rwstat into another
+ * @to: the destination blkg_rwstat
+ * @from: the source
+ *
+ * Add @from's counts to @to.
+ */
+static inline void blkg_rwstat_merge(struct blkg_rwstat *to,
+                                     struct blkg_rwstat *from)
+{
+        struct blkg_rwstat v = blkg_rwstat_read(from);
+        int i;
+
+        u64_stats_update_begin(&to->syncp);
+        for (i = 0; i < BLKG_RWSTAT_NR; i++)
+                to->cnt[i] += v.cnt[i];
+        u64_stats_update_end(&to->syncp);
+}
+
+#else   /* CONFIG_BLK_CGROUP */
+
+struct blkcg {
+};
+
+struct blkg_policy_data {
+};
+
+struct blkcg_policy_data {
+};
+
+struct blkcg_gq {
+};
+
+struct blkcg_policy {
+};
+
+#define blkcg_root_css  ((struct cgroup_subsys_state *)ERR_PTR(-EINVAL))
+
+static inline struct cgroup_subsys_state *
+task_get_blkcg_css(struct task_struct *task)
+{
+        return NULL;
+}
+
+#ifdef CONFIG_BLOCK
+
+static inline struct blkcg_gq *blkg_lookup(struct blkcg *blkcg, void *key) { return NULL; }
+static inline int blkcg_init_queue(struct request_queue *q) { return 0; }
+static inline void blkcg_drain_queue(struct request_queue *q) { }
+static inline void blkcg_exit_queue(struct request_queue *q) { }
+static inline int blkcg_policy_register(struct blkcg_policy *pol) { return 0; }
+static inline void blkcg_policy_unregister(struct blkcg_policy *pol) { }
+static inline int blkcg_activate_policy(struct request_queue *q,
+                                        const struct blkcg_policy *pol) { return 0; }
+static inline void blkcg_deactivate_policy(struct request_queue *q,
+                                           const struct blkcg_policy *pol) { }
+
+static inline struct blkcg *bio_blkcg(struct bio *bio) { return NULL; }
+
+static inline struct blkg_policy_data *blkg_to_pd(struct blkcg_gq *blkg,
+                                                  struct blkcg_policy *pol) { return NULL; }
+static inline struct blkcg_gq *pd_to_blkg(struct blkg_policy_data *pd) { return NULL; }
+static inline char *blkg_path(struct blkcg_gq *blkg) { return NULL; }
+static inline void blkg_get(struct blkcg_gq *blkg) { }
+static inline void blkg_put(struct blkcg_gq *blkg) { }
+
+static inline struct request_list *blk_get_rl(struct request_queue *q,
+                                              struct bio *bio) { return &q->root_rl; }
+static inline void blk_put_rl(struct request_list *rl) { }
+static inline void blk_rq_set_rl(struct request *rq, struct request_list *rl) { }
+static inline struct request_list *blk_rq_rl(struct request *rq) { return &rq->q->root_rl; }
+
+#define blk_queue_for_each_rl(rl, q)    \
+        for ((rl) = &(q)->root_rl; (rl); (rl) = NULL)
+
+#endif  /* CONFIG_BLOCK */
+#endif  /* CONFIG_BLK_CGROUP */
+#endif  /* _BLK_CGROUP_H */
diff --git a/include/linux/blk-mq.h b/include/linux/blk-mq.h
index 2056a99b92f8..37d1602c4f7a 100644
--- a/include/linux/blk-mq.h
+++ b/include/linux/blk-mq.h
@@ -96,6 +96,7 @@ typedef void (exit_request_fn)(void *, struct request *, unsigned int,
 
 typedef void (busy_iter_fn)(struct blk_mq_hw_ctx *, struct request *, void *,
                 bool);
+typedef void (busy_tag_iter_fn)(struct request *, void *, bool);
 
 struct blk_mq_ops {
         /*
@@ -182,6 +183,7 @@ bool blk_mq_can_queue(struct blk_mq_hw_ctx *);
 struct request *blk_mq_alloc_request(struct request_queue *q, int rw,
                 gfp_t gfp, bool reserved);
 struct request *blk_mq_tag_to_rq(struct blk_mq_tags *tags, unsigned int tag);
+struct cpumask *blk_mq_tags_cpumask(struct blk_mq_tags *tags);
 
 enum {
         BLK_MQ_UNIQUE_TAG_BITS = 16,
@@ -224,6 +226,8 @@ void blk_mq_run_hw_queues(struct request_queue *q, bool async);
 void blk_mq_delay_queue(struct blk_mq_hw_ctx *hctx, unsigned long msecs);
 void blk_mq_tag_busy_iter(struct blk_mq_hw_ctx *hctx, busy_iter_fn *fn,
                 void *priv);
+void blk_mq_all_tag_busy_iter(struct blk_mq_tags *tags, busy_tag_iter_fn *fn,
+                void *priv);
 void blk_mq_freeze_queue(struct request_queue *q);
 void blk_mq_unfreeze_queue(struct request_queue *q);
 void blk_mq_freeze_queue_start(struct request_queue *q);
diff --git a/include/linux/blk_types.h b/include/linux/blk_types.h
index b7299febc4b4..7303b3405520 100644
--- a/include/linux/blk_types.h
+++ b/include/linux/blk_types.h
@@ -65,7 +65,7 @@ struct bio {
         unsigned int            bi_seg_front_size;
         unsigned int            bi_seg_back_size;
 
-        atomic_t                bi_remaining;
+        atomic_t                __bi_remaining;
 
         bio_end_io_t            *bi_end_io;
 
@@ -92,7 +92,7 @@ struct bio {
 
         unsigned short          bi_max_vecs;    /* max bvl_vecs we can hold */
 
-        atomic_t                bi_cnt;         /* pin count */
+        atomic_t                __bi_cnt;       /* pin count */
 
         struct bio_vec          *bi_io_vec;     /* the actual vec list */
 
@@ -112,16 +112,15 @@ struct bio {
  * bio flags
  */
 #define BIO_UPTODATE    0       /* ok after I/O completion */
-#define BIO_RW_BLOCK    1       /* RW_AHEAD set, and read/write would block */
-#define BIO_EOF         2       /* out-out-bounds error */
-#define BIO_SEG_VALID   3       /* bi_phys_segments valid */
-#define BIO_CLONED      4       /* doesn't own data */
-#define BIO_BOUNCED     5       /* bio is a bounce bio */
-#define BIO_USER_MAPPED 6       /* contains user pages */
-#define BIO_EOPNOTSUPP  7       /* not supported */
-#define BIO_NULL_MAPPED 8       /* contains invalid user pages */
-#define BIO_QUIET       9       /* Make BIO Quiet */
-#define BIO_SNAP_STABLE 10      /* bio data must be snapshotted during write */
+#define BIO_SEG_VALID   1       /* bi_phys_segments valid */
+#define BIO_CLONED      2       /* doesn't own data */
+#define BIO_BOUNCED     3       /* bio is a bounce bio */
+#define BIO_USER_MAPPED 4       /* contains user pages */
+#define BIO_NULL_MAPPED 5       /* contains invalid user pages */
+#define BIO_QUIET       6       /* Make BIO Quiet */
+#define BIO_SNAP_STABLE 7       /* bio data must be snapshotted during write */
+#define BIO_CHAIN       8       /* chained bio, ->bi_remaining in effect */
+#define BIO_REFFED      9       /* bio has elevated ->bi_cnt */
 
 /*
  * Flags starting here get preserved by bio_reset() - this includes
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 5d93a6645e88..d4068c17d0df 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -12,7 +12,7 @@
 #include <linux/timer.h>
 #include <linux/workqueue.h>
 #include <linux/pagemap.h>
-#include <linux/backing-dev.h>
+#include <linux/backing-dev-defs.h>
 #include <linux/wait.h>
 #include <linux/mempool.h>
 #include <linux/bio.h>
@@ -22,15 +22,13 @@
 #include <linux/smp.h>
 #include <linux/rcupdate.h>
 #include <linux/percpu-refcount.h>
-
-#include <asm/scatterlist.h>
+#include <linux/scatterlist.h>
 
 struct module;
 struct scsi_ioctl_command;
 
 struct request_queue;
 struct elevator_queue;
-struct request_pm_state;
 struct blk_trace;
 struct request;
 struct sg_io_hdr;
@@ -75,18 +73,7 @@ struct request_list {
 enum rq_cmd_type_bits {
         REQ_TYPE_FS             = 1,    /* fs request */
         REQ_TYPE_BLOCK_PC,              /* scsi command */
-        REQ_TYPE_SENSE,                 /* sense request */
-        REQ_TYPE_PM_SUSPEND,            /* suspend request */
-        REQ_TYPE_PM_RESUME,             /* resume request */
-        REQ_TYPE_PM_SHUTDOWN,           /* shutdown request */
-        REQ_TYPE_SPECIAL,               /* driver defined type */
-        /*
-         * for ATA/ATAPI devices. this really doesn't belong here, ide should
-         * use REQ_TYPE_SPECIAL and use rq->cmd[0] with the range of driver
-         * private REQ_LB opcodes to differentiate what type of request this is
-         */
-        REQ_TYPE_ATA_TASKFILE,
-        REQ_TYPE_ATA_PC,
+        REQ_TYPE_DRV_PRIV,              /* driver defined types from here */
 };
 
 #define BLK_MAX_CDB     16
@@ -108,7 +95,7 @@ struct request {
         struct blk_mq_ctx *mq_ctx;
 
         u64 cmd_flags;
-        enum rq_cmd_type_bits cmd_type;
+        unsigned cmd_type;
         unsigned long atomic_flags;
 
         int cpu;
@@ -216,19 +203,6 @@ static inline unsigned short req_get_ioprio(struct request *req)
         return req->ioprio;
 }
 
-/*
- * State information carried for REQ_TYPE_PM_SUSPEND and REQ_TYPE_PM_RESUME
- * requests. Some step values could eventually be made generic.
- */
-struct request_pm_state
-{
-        /* PM state machine step value, currently driver specific */
-        int     pm_step;
-        /* requested PM state value (S1, S2, S3, S4, ...) */
-        u32     pm_state;
-        void*   data;           /* for driver use */
-};
-
 #include <linux/elevator.h>
 
 struct blk_queue_ctx;
@@ -469,7 +443,7 @@ struct request_queue {
         struct mutex            sysfs_lock;
 
         int                     bypass_depth;
-        int                     mq_freeze_depth;
+        atomic_t                mq_freeze_depth;
 
 #if defined(CONFIG_BLK_DEV_BSG)
         bsg_job_fn              *bsg_job_fn;
@@ -610,10 +584,6 @@ static inline void queue_flag_clear(unsigned int flag, struct request_queue *q)
         (((rq)->cmd_flags & REQ_STARTED) && \
          ((rq)->cmd_type == REQ_TYPE_FS))
 
-#define blk_pm_request(rq)      \
-        ((rq)->cmd_type == REQ_TYPE_PM_SUSPEND || \
-         (rq)->cmd_type == REQ_TYPE_PM_RESUME)
-
 #define blk_rq_cpu_valid(rq)    ((rq)->cpu != -1)
 #define blk_bidi_rq(rq)         ((rq)->next_rq != NULL)
 /* rq->queuelist of dequeued request must be list_empty() */
@@ -821,30 +791,12 @@ extern int scsi_cmd_ioctl(struct request_queue *, struct gendisk *, fmode_t,
 extern int sg_scsi_ioctl(struct request_queue *, struct gendisk *, fmode_t,
                          struct scsi_ioctl_command __user *);
 
-/*
- * A queue has just exitted congestion.  Note this in the global counter of
- * congested queues, and wake up anyone who was waiting for requests to be
- * put back.
- */
-static inline void blk_clear_queue_congested(struct request_queue *q, int sync)
-{
-        clear_bdi_congested(&q->backing_dev_info, sync);
-}
-
-/*
- * A queue has just entered congestion.  Flag that in the queue's VM-visible
- * state flags and increment the global gounter of congested queues.
- */
-static inline void blk_set_queue_congested(struct request_queue *q, int sync)
-{
-        set_bdi_congested(&q->backing_dev_info, sync);
-}
-
 extern void blk_start_queue(struct request_queue *q);
 extern void blk_stop_queue(struct request_queue *q);
 extern void blk_sync_queue(struct request_queue *q);
 extern void __blk_stop_queue(struct request_queue *q);
 extern void __blk_run_queue(struct request_queue *q);
+extern void __blk_run_queue_uncond(struct request_queue *q);
 extern void blk_run_queue(struct request_queue *);
 extern void blk_run_queue_async(struct request_queue *q);
 extern int blk_rq_map_user(struct request_queue *, struct request *,
@@ -933,7 +885,7 @@ static inline unsigned int blk_rq_get_max_sectors(struct request *rq)
         if (unlikely(rq->cmd_type == REQ_TYPE_BLOCK_PC))
                 return q->limits.max_hw_sectors;
 
-        if (!q->limits.chunk_sectors)
+        if (!q->limits.chunk_sectors || (rq->cmd_flags & REQ_DISCARD))
                 return blk_queue_get_max_sectors(q, rq->cmd_flags);
 
         return min(blk_max_size_offset(q, blk_rq_pos(rq)),
@@ -1054,6 +1006,7 @@ bool __must_check blk_get_queue(struct request_queue *);
 struct request_queue *blk_alloc_queue(gfp_t);
 struct request_queue *blk_alloc_queue_node(gfp_t, int);
 extern void blk_put_queue(struct request_queue *);
+extern void blk_set_queue_dying(struct request_queue *);
 
 /*
  * block layer runtime pm functions
diff --git a/include/linux/bootmem.h b/include/linux/bootmem.h
index 0995c2de8162..f589222bfa87 100644
--- a/include/linux/bootmem.h
+++ b/include/linux/bootmem.h
@@ -357,12 +357,12 @@ extern void *alloc_large_system_hash(const char *tablename,
 /* Only NUMA needs hash distribution. 64bit NUMA architectures have
  * sufficient vmalloc space.
  */
-#if defined(CONFIG_NUMA) && defined(CONFIG_64BIT)
-#define HASHDIST_DEFAULT 1
+#ifdef CONFIG_NUMA
+#define HASHDIST_DEFAULT IS_ENABLED(CONFIG_64BIT)
+extern int hashdist;            /* Distribute hashes across NUMA nodes? */
 #else
-#define HASHDIST_DEFAULT 0
+#define hashdist (0)
 #endif
-extern int hashdist;            /* Distribute hashes across NUMA nodes? */
 
 
 #endif /* _LINUX_BOOTMEM_H */
diff --git a/include/linux/bpf.h b/include/linux/bpf.h
index d5cda067115a..4383476a0d48 100644
--- a/include/linux/bpf.h
+++ b/include/linux/bpf.h
@@ -105,7 +105,8 @@ struct bpf_verifier_ops {
          */
         bool (*is_valid_access)(int off, int size, enum bpf_access_type type);
 
-        u32 (*convert_ctx_access)(int dst_reg, int src_reg, int ctx_off,
+        u32 (*convert_ctx_access)(enum bpf_access_type type, int dst_reg,
+                                  int src_reg, int ctx_off,
                                   struct bpf_insn *insn);
 };
 
@@ -123,15 +124,41 @@ struct bpf_prog_aux {
         const struct bpf_verifier_ops *ops;
         struct bpf_map **used_maps;
         struct bpf_prog *prog;
-        struct work_struct work;
+        union {
+                struct work_struct work;
+                struct rcu_head rcu;
+        };
 };
 
+struct bpf_array {
+        struct bpf_map map;
+        u32 elem_size;
+        /* 'ownership' of prog_array is claimed by the first program that
+         * is going to use this map or by the first program which FD is stored
+         * in the map to make sure that all callers and callees have the same
+         * prog_type and JITed flag
+         */
+        enum bpf_prog_type owner_prog_type;
+        bool owner_jited;
+        union {
+                char value[0] __aligned(8);
+                struct bpf_prog *prog[0] __aligned(8);
+        };
+};
+#define MAX_TAIL_CALL_CNT 32
+
+u64 bpf_tail_call(u64 ctx, u64 r2, u64 index, u64 r4, u64 r5);
+void bpf_prog_array_map_clear(struct bpf_map *map);
+bool bpf_prog_array_compatible(struct bpf_array *array, const struct bpf_prog *fp);
+const struct bpf_func_proto *bpf_get_trace_printk_proto(void);
+
 #ifdef CONFIG_BPF_SYSCALL
 void bpf_register_prog_type(struct bpf_prog_type_list *tl);
 void bpf_register_map_type(struct bpf_map_type_list *tl);
 
 struct bpf_prog *bpf_prog_get(u32 ufd);
 void bpf_prog_put(struct bpf_prog *prog);
+void bpf_prog_put_rcu(struct bpf_prog *prog);
 
 struct bpf_map *bpf_map_get(struct fd f);
 void bpf_map_put(struct bpf_map *map);
@@ -160,5 +187,10 @@ extern const struct bpf_func_proto bpf_map_delete_elem_proto;
 
 extern const struct bpf_func_proto bpf_get_prandom_u32_proto;
 extern const struct bpf_func_proto bpf_get_smp_processor_id_proto;
+extern const struct bpf_func_proto bpf_tail_call_proto;
+extern const struct bpf_func_proto bpf_ktime_get_ns_proto;
+extern const struct bpf_func_proto bpf_get_current_pid_tgid_proto;
+extern const struct bpf_func_proto bpf_get_current_uid_gid_proto;
+extern const struct bpf_func_proto bpf_get_current_comm_proto;
 
 #endif /* _LINUX_BPF_H */
diff --git a/include/linux/brcmphy.h b/include/linux/brcmphy.h
index 656da2a12ffe..697ca7795bd9 100644
--- a/include/linux/brcmphy.h
+++ b/include/linux/brcmphy.h
@@ -1,6 +1,13 @@
 #ifndef _LINUX_BRCMPHY_H
 #define _LINUX_BRCMPHY_H
 
+#include <linux/phy.h>
+
+/* All Broadcom Ethernet switches have a pseudo-PHY at address 30 which is used
+ * to configure the switch internal registers via MDIO accesses.
+ */
+#define BRCM_PSEUDO_PHY_ADDR           30
+
 #define PHY_ID_BCM50610                 0x0143bd60
 #define PHY_ID_BCM50610M                0x0143bd70
 #define PHY_ID_BCM5241                  0x0143bc30
diff --git a/include/linux/buffer_head.h b/include/linux/buffer_head.h
index 73b45225a7ca..e6797ded700e 100644
--- a/include/linux/buffer_head.h
+++ b/include/linux/buffer_head.h
@@ -317,6 +317,13 @@ sb_getblk(struct super_block *sb, sector_t block)
         return __getblk_gfp(sb->s_bdev, block, sb->s_blocksize, __GFP_MOVABLE);
 }
 
+
+static inline struct buffer_head *
+sb_getblk_gfp(struct super_block *sb, sector_t block, gfp_t gfp)
+{
+        return __getblk_gfp(sb->s_bdev, block, sb->s_blocksize, gfp);
+}
+
 static inline struct buffer_head *
 sb_find_get_block(struct super_block *sb, sector_t block)
 {
diff --git a/include/linux/cacheinfo.h b/include/linux/cacheinfo.h
index 3daf5ed392c9..2189935075b4 100644
--- a/include/linux/cacheinfo.h
+++ b/include/linux/cacheinfo.h
@@ -19,7 +19,7 @@ enum cache_type {
 /**
  * struct cacheinfo - represent a cache leaf node
  * @type: type of the cache - data, inst or unified
- * @level: represents the hierarcy in the multi-level cache
+ * @level: represents the hierarchy in the multi-level cache
  * @coherency_line_size: size of each cache line usually representing
  *      the minimum amount of data that gets transferred from memory
  * @number_of_sets: total number of sets, a set is a collection of cache
diff --git a/include/linux/can/skb.h b/include/linux/can/skb.h
index b6a52a4b457a..51bb6532785c 100644
--- a/include/linux/can/skb.h
+++ b/include/linux/can/skb.h
@@ -27,10 +27,12 @@
 /**
  * struct can_skb_priv - private additional data inside CAN sk_buffs
  * @ifindex:    ifindex of the first interface the CAN frame appeared on
+ * @skbcnt:     atomic counter to have an unique id together with skb pointer
  * @cf:         align to the following CAN frame at skb->data
  */
 struct can_skb_priv {
         int ifindex;
+        int skbcnt;
         struct can_frame cf[0];
 };
 
diff --git a/include/linux/ceph/libceph.h b/include/linux/ceph/libceph.h
index 30f92cefaa72..9ebee53d3bf5 100644
--- a/include/linux/ceph/libceph.h
+++ b/include/linux/ceph/libceph.h
@@ -43,9 +43,9 @@ struct ceph_options {
         int flags;
         struct ceph_fsid fsid;
         struct ceph_entity_addr my_addr;
-        int mount_timeout;
-        int osd_idle_ttl;
-        int osd_keepalive_timeout;
+        unsigned long mount_timeout;            /* jiffies */
+        unsigned long osd_idle_ttl;             /* jiffies */
+        unsigned long osd_keepalive_timeout;    /* jiffies */
 
         /*
          * any type that can't be simply compared or doesn't need need
@@ -63,9 +63,9 @@ struct ceph_options {
 /*
  * defaults
  */
-#define CEPH_MOUNT_TIMEOUT_DEFAULT  60
-#define CEPH_OSD_KEEPALIVE_DEFAULT  5
-#define CEPH_OSD_IDLE_TTL_DEFAULT    60
+#define CEPH_MOUNT_TIMEOUT_DEFAULT      msecs_to_jiffies(60 * 1000)
+#define CEPH_OSD_KEEPALIVE_DEFAULT      msecs_to_jiffies(5 * 1000)
+#define CEPH_OSD_IDLE_TTL_DEFAULT       msecs_to_jiffies(60 * 1000)
 
 #define CEPH_MSG_MAX_FRONT_LEN  (16*1024*1024)
 #define CEPH_MSG_MAX_MIDDLE_LEN (16*1024*1024)
@@ -93,13 +93,9 @@ enum {
         CEPH_MOUNT_SHUTDOWN,
 };
 
-/*
- * subtract jiffies
- */
-static inline unsigned long time_sub(unsigned long a, unsigned long b)
+static inline unsigned long ceph_timeout_jiffies(unsigned long timeout)
 {
-        BUG_ON(time_after(b, a));
-        return (long)a - (long)b;
+        return timeout ?: MAX_SCHEDULE_TIMEOUT;
 }
 
 struct ceph_mds_client;
@@ -178,6 +174,7 @@ static inline int calc_pages_for(u64 off, u64 len)
 
 extern struct kmem_cache *ceph_inode_cachep;
 extern struct kmem_cache *ceph_cap_cachep;
+extern struct kmem_cache *ceph_cap_flush_cachep;
 extern struct kmem_cache *ceph_dentry_cachep;
 extern struct kmem_cache *ceph_file_cachep;
 
diff --git a/include/linux/ceph/messenger.h b/include/linux/ceph/messenger.h
index e15499422fdc..37753278987a 100644
--- a/include/linux/ceph/messenger.h
+++ b/include/linux/ceph/messenger.h
@@ -8,6 +8,7 @@
 #include <linux/radix-tree.h>
 #include <linux/uio.h>
 #include <linux/workqueue.h>
+#include <net/net_namespace.h>
 
 #include <linux/ceph/types.h>
 #include <linux/ceph/buffer.h>
@@ -56,6 +57,7 @@ struct ceph_messenger {
         struct ceph_entity_addr my_enc_addr;
 
         atomic_t stopping;
+        possible_net_t net;
         bool nocrc;
         bool tcp_nodelay;
 
@@ -267,6 +269,7 @@ extern void ceph_messenger_init(struct ceph_messenger *msgr,
                         u64 required_features,
                         bool nocrc,
                         bool tcp_nodelay);
+extern void ceph_messenger_fini(struct ceph_messenger *msgr);
 
 extern void ceph_con_init(struct ceph_connection *con, void *private,
                         const struct ceph_connection_operations *ops,
diff --git a/include/linux/ceph/osd_client.h b/include/linux/ceph/osd_client.h
index 61b19c46bdb3..7506b485bb6d 100644
--- a/include/linux/ceph/osd_client.h
+++ b/include/linux/ceph/osd_client.h
@@ -249,7 +249,7 @@ extern void ceph_osdc_handle_map(struct ceph_osd_client *osdc,
                                  struct ceph_msg *msg);
 
 extern void osd_req_op_init(struct ceph_osd_request *osd_req,
-                                        unsigned int which, u16 opcode);
+                            unsigned int which, u16 opcode, u32 flags);
 
 extern void osd_req_op_raw_data_in_pages(struct ceph_osd_request *,
                                         unsigned int which,
diff --git a/include/linux/cgroup-defs.h b/include/linux/cgroup-defs.h
new file mode 100644
index 000000000000..93755a629299
--- /dev/null
+++ b/include/linux/cgroup-defs.h
@@ -0,0 +1,501 @@
+/*
+ * linux/cgroup-defs.h - basic definitions for cgroup
+ *
+ * This file provides basic type and interface.  Include this file directly
+ * only if necessary to avoid cyclic dependencies.
+ */
+#ifndef _LINUX_CGROUP_DEFS_H
+#define _LINUX_CGROUP_DEFS_H
+
+#include <linux/limits.h>
+#include <linux/list.h>
+#include <linux/idr.h>
+#include <linux/wait.h>
+#include <linux/mutex.h>
+#include <linux/rcupdate.h>
+#include <linux/percpu-refcount.h>
+#include <linux/percpu-rwsem.h>
+#include <linux/workqueue.h>
+
+#ifdef CONFIG_CGROUPS
+
+struct cgroup;
+struct cgroup_root;
+struct cgroup_subsys;
+struct cgroup_taskset;
+struct kernfs_node;
+struct kernfs_ops;
+struct kernfs_open_file;
+struct seq_file;
+
+#define MAX_CGROUP_TYPE_NAMELEN 32
+#define MAX_CGROUP_ROOT_NAMELEN 64
+#define MAX_CFTYPE_NAME         64
+
+/* define the enumeration of all cgroup subsystems */
+#define SUBSYS(_x) _x ## _cgrp_id,
+enum cgroup_subsys_id {
+#include <linux/cgroup_subsys.h>
+        CGROUP_SUBSYS_COUNT,
+};
+#undef SUBSYS
+
+/* bits in struct cgroup_subsys_state flags field */
+enum {
+        CSS_NO_REF      = (1 << 0), /* no reference counting for this css */
+        CSS_ONLINE      = (1 << 1), /* between ->css_online() and ->css_offline() */
+        CSS_RELEASED    = (1 << 2), /* refcnt reached zero, released */
+};
+
+/* bits in struct cgroup flags field */
+enum {
+        /* Control Group requires release notifications to userspace */
+        CGRP_NOTIFY_ON_RELEASE,
+        /*
+         * Clone the parent's configuration when creating a new child
+         * cpuset cgroup.  For historical reasons, this option can be
+         * specified at mount time and thus is implemented here.
+         */
+        CGRP_CPUSET_CLONE_CHILDREN,
+};
+
+/* cgroup_root->flags */
+enum {
+        CGRP_ROOT_SANE_BEHAVIOR = (1 << 0), /* __DEVEL__sane_behavior specified */
+        CGRP_ROOT_NOPREFIX      = (1 << 1), /* mounted subsystems have no named prefix */
+        CGRP_ROOT_XATTR         = (1 << 2), /* supports extended attributes */
+};
+
+/* cftype->flags */
+enum {
+        CFTYPE_ONLY_ON_ROOT     = (1 << 0),     /* only create on root cgrp */
+        CFTYPE_NOT_ON_ROOT      = (1 << 1),     /* don't create on root cgrp */
+        CFTYPE_NO_PREFIX        = (1 << 3),     /* (DON'T USE FOR NEW FILES) no subsys prefix */
+
+        /* internal flags, do not use outside cgroup core proper */
+        __CFTYPE_ONLY_ON_DFL    = (1 << 16),    /* only on default hierarchy */
+        __CFTYPE_NOT_ON_DFL     = (1 << 17),    /* not on default hierarchy */
+};
+
+/*
+ * Per-subsystem/per-cgroup state maintained by the system.  This is the
+ * fundamental structural building block that controllers deal with.
+ *
+ * Fields marked with "PI:" are public and immutable and may be accessed
+ * directly without synchronization.
+ */
+struct cgroup_subsys_state {
+        /* PI: the cgroup that this css is attached to */
+        struct cgroup *cgroup;
+
+        /* PI: the cgroup subsystem that this css is attached to */
+        struct cgroup_subsys *ss;
+
+        /* reference count - access via css_[try]get() and css_put() */
+        struct percpu_ref refcnt;
+
+        /* PI: the parent css */
+        struct cgroup_subsys_state *parent;
+
+        /* siblings list anchored at the parent's ->children */
+        struct list_head sibling;
+        struct list_head children;
+
+        /*
+         * PI: Subsys-unique ID.  0 is unused and root is always 1.  The
+         * matching css can be looked up using css_from_id().
+         */
+        int id;
+
+        unsigned int flags;
+
+        /*
+         * Monotonically increasing unique serial number which defines a
+         * uniform order among all csses.  It's guaranteed that all
+         * ->children lists are in the ascending order of ->serial_nr and
+         * used to allow interrupting and resuming iterations.
+         */
+        u64 serial_nr;
+
+        /* percpu_ref killing and RCU release */
+        struct rcu_head rcu_head;
+        struct work_struct destroy_work;
+};
+
+/*
+ * A css_set is a structure holding pointers to a set of
+ * cgroup_subsys_state objects. This saves space in the task struct
+ * object and speeds up fork()/exit(), since a single inc/dec and a
+ * list_add()/del() can bump the reference count on the entire cgroup
+ * set for a task.
+ */
+struct css_set {
+        /* Reference count */
+        atomic_t refcount;
+
+        /*
+         * List running through all cgroup groups in the same hash
+         * slot. Protected by css_set_lock
+         */
+        struct hlist_node hlist;
+
+        /*
+         * Lists running through all tasks using this cgroup group.
+         * mg_tasks lists tasks which belong to this cset but are in the
+         * process of being migrated out or in.  Protected by
+         * css_set_rwsem, but, during migration, once tasks are moved to
+         * mg_tasks, it can be read safely while holding cgroup_mutex.
+         */
+        struct list_head tasks;
+        struct list_head mg_tasks;
+
+        /*
+         * List of cgrp_cset_links pointing at cgroups referenced from this
+         * css_set.  Protected by css_set_lock.
+         */
+        struct list_head cgrp_links;
+
+        /* the default cgroup associated with this css_set */
+        struct cgroup *dfl_cgrp;
+
+        /*
+         * Set of subsystem states, one for each subsystem. This array is
+         * immutable after creation apart from the init_css_set during
+         * subsystem registration (at boot time).
+         */
+        struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];
+
+        /*
+         * List of csets participating in the on-going migration either as
+         * source or destination.  Protected by cgroup_mutex.
+         */
+        struct list_head mg_preload_node;
+        struct list_head mg_node;
+
+        /*
+         * If this cset is acting as the source of migration the following
+         * two fields are set.  mg_src_cgrp is the source cgroup of the
+         * on-going migration and mg_dst_cset is the destination cset the
+         * target tasks on this cset should be migrated to.  Protected by
+         * cgroup_mutex.
+         */
+        struct cgroup *mg_src_cgrp;
+        struct css_set *mg_dst_cset;
+
+        /*
+         * On the default hierarhcy, ->subsys[ssid] may point to a css
+         * attached to an ancestor instead of the cgroup this css_set is
+         * associated with.  The following node is anchored at
+         * ->subsys[ssid]->cgroup->e_csets[ssid] and provides a way to
+         * iterate through all css's attached to a given cgroup.
+         */
+        struct list_head e_cset_node[CGROUP_SUBSYS_COUNT];
+
+        /* For RCU-protected deletion */
+        struct rcu_head rcu_head;
+};
+
+struct cgroup {
+        /* self css with NULL ->ss, points back to this cgroup */
+        struct cgroup_subsys_state self;
+
+        unsigned long flags;            /* "unsigned long" so bitops work */
+
+        /*
+         * idr allocated in-hierarchy ID.
+         *
+         * ID 0 is not used, the ID of the root cgroup is always 1, and a
+         * new cgroup will be assigned with a smallest available ID.
+         *
+         * Allocating/Removing ID must be protected by cgroup_mutex.
+         */
+        int id;
+
+        /*
+         * If this cgroup contains any tasks, it contributes one to
+         * populated_cnt.  All children with non-zero popuplated_cnt of
+         * their own contribute one.  The count is zero iff there's no task
+         * in this cgroup or its subtree.
+         */
+        int populated_cnt;
+
+        struct kernfs_node *kn;         /* cgroup kernfs entry */
+        struct kernfs_node *procs_kn;   /* kn for "cgroup.procs" */
+        struct kernfs_node *populated_kn; /* kn for "cgroup.subtree_populated" */
+
+        /*
+         * The bitmask of subsystems enabled on the child cgroups.
+         * ->subtree_control is the one configured through
+         * "cgroup.subtree_control" while ->child_subsys_mask is the
+         * effective one which may have more subsystems enabled.
+         * Controller knobs are made available iff it's enabled in
+         * ->subtree_control.
+         */
+        unsigned int subtree_control;
+        unsigned int child_subsys_mask;
+
+        /* Private pointers for each registered subsystem */
+        struct cgroup_subsys_state __rcu *subsys[CGROUP_SUBSYS_COUNT];
+
+        struct cgroup_root *root;
+
+        /*
+         * List of cgrp_cset_links pointing at css_sets with tasks in this
+         * cgroup.  Protected by css_set_lock.
+         */
+        struct list_head cset_links;
+
+        /*
+         * On the default hierarchy, a css_set for a cgroup with some
+         * susbsys disabled will point to css's which are associated with
+         * the closest ancestor which has the subsys enabled.  The
+         * following lists all css_sets which point to this cgroup's css
+         * for the given subsystem.
+         */
+        struct list_head e_csets[CGROUP_SUBSYS_COUNT];
+
+        /*
+         * list of pidlists, up to two for each namespace (one for procs, one
+         * for tasks); created on demand.
+         */
+        struct list_head pidlists;
+        struct mutex pidlist_mutex;
+
+        /* used to wait for offlining of csses */
+        wait_queue_head_t offline_waitq;
+
+        /* used to schedule release agent */
+        struct work_struct release_agent_work;
+};
+
+/*
+ * A cgroup_root represents the root of a cgroup hierarchy, and may be
+ * associated with a kernfs_root to form an active hierarchy.  This is
+ * internal to cgroup core.  Don't access directly from controllers.
+ */
+struct cgroup_root {
+        struct kernfs_root *kf_root;
+
+        /* The bitmask of subsystems attached to this hierarchy */
+        unsigned int subsys_mask;
+
+        /* Unique id for this hierarchy. */
+        int hierarchy_id;
+
+        /* The root cgroup.  Root is destroyed on its release. */
+        struct cgroup cgrp;
+
+        /* Number of cgroups in the hierarchy, used only for /proc/cgroups */
+        atomic_t nr_cgrps;
+
+        /* A list running through the active hierarchies */
+        struct list_head root_list;
+
+        /* Hierarchy-specific flags */
+        unsigned int flags;
+
+        /* IDs for cgroups in this hierarchy */
+        struct idr cgroup_idr;
+
+        /* The path to use for release notifications. */
+        char release_agent_path[PATH_MAX];
+
+        /* The name for this hierarchy - may be empty */
+        char name[MAX_CGROUP_ROOT_NAMELEN];
+};
+
+/*
+ * struct cftype: handler definitions for cgroup control files
+ *
+ * When reading/writing to a file:
+ *      - the cgroup to use is file->f_path.dentry->d_parent->d_fsdata
+ *      - the 'cftype' of the file is file->f_path.dentry->d_fsdata
+ */
+struct cftype {
+        /*
+         * By convention, the name should begin with the name of the
+         * subsystem, followed by a period.  Zero length string indicates
+         * end of cftype array.
+         */
+        char name[MAX_CFTYPE_NAME];
+        int private;
+        /*
+         * If not 0, file mode is set to this value, otherwise it will
+         * be figured out automatically
+         */
+        umode_t mode;
+
+        /*
+         * The maximum length of string, excluding trailing nul, that can
+         * be passed to write.  If < PAGE_SIZE-1, PAGE_SIZE-1 is assumed.
+         */
+        size_t max_write_len;
+
+        /* CFTYPE_* flags */
+        unsigned int flags;
+
+        /*
+         * Fields used for internal bookkeeping.  Initialized automatically
+         * during registration.
+         */
+        struct cgroup_subsys *ss;       /* NULL for cgroup core files */
+        struct list_head node;          /* anchored at ss->cfts */
+        struct kernfs_ops *kf_ops;
+
+        /*
+         * read_u64() is a shortcut for the common case of returning a
+         * single integer. Use it in place of read()
+         */
+        u64 (*read_u64)(struct cgroup_subsys_state *css, struct cftype *cft);
+        /*
+         * read_s64() is a signed version of read_u64()
+         */
+        s64 (*read_s64)(struct cgroup_subsys_state *css, struct cftype *cft);
+
+        /* generic seq_file read interface */
+        int (*seq_show)(struct seq_file *sf, void *v);
+
+        /* optional ops, implement all or none */
+        void *(*seq_start)(struct seq_file *sf, loff_t *ppos);
+        void *(*seq_next)(struct seq_file *sf, void *v, loff_t *ppos);
+        void (*seq_stop)(struct seq_file *sf, void *v);
+
+        /*
+         * write_u64() is a shortcut for the common case of accepting
+         * a single integer (as parsed by simple_strtoull) from
+         * userspace. Use in place of write(); return 0 or error.
+         */
+        int (*write_u64)(struct cgroup_subsys_state *css, struct cftype *cft,
+                         u64 val);
+        /*
+         * write_s64() is a signed version of write_u64()
+         */
+        int (*write_s64)(struct cgroup_subsys_state *css, struct cftype *cft,
+                         s64 val);
+
+        /*
+         * write() is the generic write callback which maps directly to
+         * kernfs write operation and overrides all other operations.
+         * Maximum write size is determined by ->max_write_len.  Use
+         * of_css/cft() to access the associated css and cft.
+         */
+        ssize_t (*write)(struct kernfs_open_file *of,
+                         char *buf, size_t nbytes, loff_t off);
+
+#ifdef CONFIG_DEBUG_LOCK_ALLOC
+        struct lock_class_key   lockdep_key;
+#endif
+};
+
+/*
+ * Control Group subsystem type.
+ * See Documentation/cgroups/cgroups.txt for details
+ */
+struct cgroup_subsys {
+        struct cgroup_subsys_state *(*css_alloc)(struct cgroup_subsys_state *parent_css);
+        int (*css_online)(struct cgroup_subsys_state *css);
+        void (*css_offline)(struct cgroup_subsys_state *css);
+        void (*css_released)(struct cgroup_subsys_state *css);
+        void (*css_free)(struct cgroup_subsys_state *css);
+        void (*css_reset)(struct cgroup_subsys_state *css);
+        void (*css_e_css_changed)(struct cgroup_subsys_state *css);
+
+        int (*can_attach)(struct cgroup_subsys_state *css,
+                          struct cgroup_taskset *tset);
+        void (*cancel_attach)(struct cgroup_subsys_state *css,
+                              struct cgroup_taskset *tset);
+        void (*attach)(struct cgroup_subsys_state *css,
+                       struct cgroup_taskset *tset);
+        void (*fork)(struct task_struct *task);
+        void (*exit)(struct cgroup_subsys_state *css,
+                     struct cgroup_subsys_state *old_css,
+                     struct task_struct *task);
+        void (*bind)(struct cgroup_subsys_state *root_css);
+
+        int disabled;
+        int early_init;
+
+        /*
+         * If %false, this subsystem is properly hierarchical -
+         * configuration, resource accounting and restriction on a parent
+         * cgroup cover those of its children.  If %true, hierarchy support
+         * is broken in some ways - some subsystems ignore hierarchy
+         * completely while others are only implemented half-way.
+         *
+         * It's now disallowed to create nested cgroups if the subsystem is
+         * broken and cgroup core will emit a warning message on such
+         * cases.  Eventually, all subsystems will be made properly
+         * hierarchical and this will go away.
+         */
+        bool broken_hierarchy;
+        bool warned_broken_hierarchy;
+
+        /* the following two fields are initialized automtically during boot */
+        int id;
+        const char *name;
+
+        /* link to parent, protected by cgroup_lock() */
+        struct cgroup_root *root;
+
+        /* idr for css->id */
+        struct idr css_idr;
+
+        /*
+         * List of cftypes.  Each entry is the first entry of an array
+         * terminated by zero length name.
+         */
+        struct list_head cfts;
+
+        /*
+         * Base cftypes which are automatically registered.  The two can
+         * point to the same array.
+         */
+        struct cftype *dfl_cftypes;     /* for the default hierarchy */
+        struct cftype *legacy_cftypes;  /* for the legacy hierarchies */
+
+        /*
+         * A subsystem may depend on other subsystems.  When such subsystem
+         * is enabled on a cgroup, the depended-upon subsystems are enabled
+         * together if available.  Subsystems enabled due to dependency are
+         * not visible to userland until explicitly enabled.  The following
+         * specifies the mask of subsystems that this one depends on.
+         */
+        unsigned int depends_on;
+};
+
+extern struct percpu_rw_semaphore cgroup_threadgroup_rwsem;
+
+/**
+ * cgroup_threadgroup_change_begin - threadgroup exclusion for cgroups
+ * @tsk: target task
+ *
+ * Called from threadgroup_change_begin() and allows cgroup operations to
+ * synchronize against threadgroup changes using a percpu_rw_semaphore.
+ */
+static inline void cgroup_threadgroup_change_begin(struct task_struct *tsk)
+{
+        percpu_down_read(&cgroup_threadgroup_rwsem);
+}
+
+/**
+ * cgroup_threadgroup_change_end - threadgroup exclusion for cgroups
+ * @tsk: target task
+ *
+ * Called from threadgroup_change_end().  Counterpart of
+ * cgroup_threadcgroup_change_begin().
+ */
+static inline void cgroup_threadgroup_change_end(struct task_struct *tsk)
+{
+        percpu_up_read(&cgroup_threadgroup_rwsem);
+}
+
+#else   /* CONFIG_CGROUPS */
+
+#define CGROUP_SUBSYS_COUNT 0
+
+static inline void cgroup_threadgroup_change_begin(struct task_struct *tsk) {}
+static inline void cgroup_threadgroup_change_end(struct task_struct *tsk) {}
+
+#endif  /* CONFIG_CGROUPS */
+
+#endif  /* _LINUX_CGROUP_DEFS_H */
diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h
index b9cb94c3102a..a593e299162e 100644
--- a/include/linux/cgroup.h
+++ b/include/linux/cgroup.h
@@ -11,94 +11,200 @@
 #include <linux/sched.h>
 #include <linux/cpumask.h>
 #include <linux/nodemask.h>
-#include <linux/rcupdate.h>
 #include <linux/rculist.h>
 #include <linux/cgroupstats.h>
 #include <linux/rwsem.h>
-#include <linux/idr.h>
-#include <linux/workqueue.h>
 #include <linux/fs.h>
-#include <linux/percpu-refcount.h>
 #include <linux/seq_file.h>
 #include <linux/kernfs.h>
-#include <linux/wait.h>
+
+#include <linux/cgroup-defs.h>
 
 #ifdef CONFIG_CGROUPS
 
-struct cgroup_root;
-struct cgroup_subsys;
-struct cgroup;
+/* a css_task_iter should be treated as an opaque object */
+struct css_task_iter {
+        struct cgroup_subsys            *ss;
 
-extern int cgroup_init_early(void);
-extern int cgroup_init(void);
-extern void cgroup_fork(struct task_struct *p);
-extern void cgroup_post_fork(struct task_struct *p);
-extern void cgroup_exit(struct task_struct *p);
-extern int cgroupstats_build(struct cgroupstats *stats,
-                                struct dentry *dentry);
+        struct list_head                *cset_pos;
+        struct list_head                *cset_head;
 
-extern int proc_cgroup_show(struct seq_file *m, struct pid_namespace *ns,
-                            struct pid *pid, struct task_struct *tsk);
+        struct list_head                *task_pos;
+        struct list_head                *tasks_head;
+        struct list_head                *mg_tasks_head;
+};
 
-/* define the enumeration of all cgroup subsystems */
-#define SUBSYS(_x) _x ## _cgrp_id,
-enum cgroup_subsys_id {
+extern struct cgroup_root cgrp_dfl_root;
+extern struct css_set init_css_set;
+
+#define SUBSYS(_x) extern struct cgroup_subsys _x ## _cgrp_subsys;
 #include <linux/cgroup_subsys.h>
-        CGROUP_SUBSYS_COUNT,
-};
 #undef SUBSYS
 
+bool css_has_online_children(struct cgroup_subsys_state *css);
+struct cgroup_subsys_state *css_from_id(int id, struct cgroup_subsys *ss);
+struct cgroup_subsys_state *cgroup_get_e_css(struct cgroup *cgroup,
+                                             struct cgroup_subsys *ss);
+struct cgroup_subsys_state *css_tryget_online_from_dir(struct dentry *dentry,
+                                                       struct cgroup_subsys *ss);
+
+bool cgroup_is_descendant(struct cgroup *cgrp, struct cgroup *ancestor);
+int cgroup_attach_task_all(struct task_struct *from, struct task_struct *);
+int cgroup_transfer_tasks(struct cgroup *to, struct cgroup *from);
+
+int cgroup_add_dfl_cftypes(struct cgroup_subsys *ss, struct cftype *cfts);
+int cgroup_add_legacy_cftypes(struct cgroup_subsys *ss, struct cftype *cfts);
+int cgroup_rm_cftypes(struct cftype *cfts);
+
+char *task_cgroup_path(struct task_struct *task, char *buf, size_t buflen);
+int cgroupstats_build(struct cgroupstats *stats, struct dentry *dentry);
+int proc_cgroup_show(struct seq_file *m, struct pid_namespace *ns,
+                     struct pid *pid, struct task_struct *tsk);
+
+void cgroup_fork(struct task_struct *p);
+void cgroup_post_fork(struct task_struct *p);
+void cgroup_exit(struct task_struct *p);
+
+int cgroup_init_early(void);
+int cgroup_init(void);
+
 /*
- * Per-subsystem/per-cgroup state maintained by the system.  This is the
- * fundamental structural building block that controllers deal with.
+ * Iteration helpers and macros.
+ */
+
+struct cgroup_subsys_state *css_next_child(struct cgroup_subsys_state *pos,
+                                           struct cgroup_subsys_state *parent);
+struct cgroup_subsys_state *css_next_descendant_pre(struct cgroup_subsys_state *pos,
+                                                    struct cgroup_subsys_state *css);
+struct cgroup_subsys_state *css_rightmost_descendant(struct cgroup_subsys_state *pos);
+struct cgroup_subsys_state *css_next_descendant_post(struct cgroup_subsys_state *pos,
+                                                     struct cgroup_subsys_state *css);
+
+struct task_struct *cgroup_taskset_first(struct cgroup_taskset *tset);
+struct task_struct *cgroup_taskset_next(struct cgroup_taskset *tset);
+
+void css_task_iter_start(struct cgroup_subsys_state *css,
+                         struct css_task_iter *it);
+struct task_struct *css_task_iter_next(struct css_task_iter *it);
+void css_task_iter_end(struct css_task_iter *it);
+
+/**
+ * css_for_each_child - iterate through children of a css
+ * @pos: the css * to use as the loop cursor
+ * @parent: css whose children to walk
  *
- * Fields marked with "PI:" are public and immutable and may be accessed
- * directly without synchronization.
+ * Walk @parent's children.  Must be called under rcu_read_lock().
+ *
+ * If a subsystem synchronizes ->css_online() and the start of iteration, a
+ * css which finished ->css_online() is guaranteed to be visible in the
+ * future iterations and will stay visible until the last reference is put.
+ * A css which hasn't finished ->css_online() or already finished
+ * ->css_offline() may show up during traversal.  It's each subsystem's
+ * responsibility to synchronize against on/offlining.
+ *
+ * It is allowed to temporarily drop RCU read lock during iteration.  The
+ * caller is responsible for ensuring that @pos remains accessible until
+ * the start of the next iteration by, for example, bumping the css refcnt.
  */
-struct cgroup_subsys_state {
-        /* PI: the cgroup that this css is attached to */
-        struct cgroup *cgroup;
-
-        /* PI: the cgroup subsystem that this css is attached to */
-        struct cgroup_subsys *ss;
-
-        /* reference count - access via css_[try]get() and css_put() */
-        struct percpu_ref refcnt;
-
-        /* PI: the parent css */
-        struct cgroup_subsys_state *parent;
-
-        /* siblings list anchored at the parent's ->children */
-        struct list_head sibling;
-        struct list_head children;
-
-        /*
-         * PI: Subsys-unique ID.  0 is unused and root is always 1.  The
-         * matching css can be looked up using css_from_id().
-         */
-        int id;
-
-        unsigned int flags;
-
-        /*
-         * Monotonically increasing unique serial number which defines a
-         * uniform order among all csses.  It's guaranteed that all
-         * ->children lists are in the ascending order of ->serial_nr and
-         * used to allow interrupting and resuming iterations.
-         */
-        u64 serial_nr;
-
-        /* percpu_ref killing and RCU release */
-        struct rcu_head rcu_head;
-        struct work_struct destroy_work;
-};
+#define css_for_each_child(pos, parent)                                 \
+        for ((pos) = css_next_child(NULL, (parent)); (pos);             \
+             (pos) = css_next_child((pos), (parent)))
 
-/* bits in struct cgroup_subsys_state flags field */
-enum {
-        CSS_NO_REF      = (1 << 0), /* no reference counting for this css */
-        CSS_ONLINE      = (1 << 1), /* between ->css_online() and ->css_offline() */
-        CSS_RELEASED    = (1 << 2), /* refcnt reached zero, released */
-};
+/**
+ * css_for_each_descendant_pre - pre-order walk of a css's descendants
+ * @pos: the css * to use as the loop cursor
+ * @root: css whose descendants to walk
+ *
+ * Walk @root's descendants.  @root is included in the iteration and the
+ * first node to be visited.  Must be called under rcu_read_lock().
+ *
+ * If a subsystem synchronizes ->css_online() and the start of iteration, a
+ * css which finished ->css_online() is guaranteed to be visible in the
+ * future iterations and will stay visible until the last reference is put.
+ * A css which hasn't finished ->css_online() or already finished
+ * ->css_offline() may show up during traversal.  It's each subsystem's
+ * responsibility to synchronize against on/offlining.
+ *
+ * For example, the following guarantees that a descendant can't escape
+ * state updates of its ancestors.
+ *
+ * my_online(@css)
+ * {
+ *      Lock @css's parent and @css;
+ *      Inherit state from the parent;
+ *      Unlock both.
+ * }
+ *
+ * my_update_state(@css)
+ * {
+ *      css_for_each_descendant_pre(@pos, @css) {
+ *              Lock @pos;
+ *              if (@pos == @css)
+ *                      Update @css's state;
+ *              else
+ *                      Verify @pos is alive and inherit state from its parent;
+ *              Unlock @pos;
+ *      }
+ * }
+ *
+ * As long as the inheriting step, including checking the parent state, is
+ * enclosed inside @pos locking, double-locking the parent isn't necessary
+ * while inheriting.  The state update to the parent is guaranteed to be
+ * visible by walking order and, as long as inheriting operations to the
+ * same @pos are atomic to each other, multiple updates racing each other
+ * still result in the correct state.  It's guaranateed that at least one
+ * inheritance happens for any css after the latest update to its parent.
+ *
+ * If checking parent's state requires locking the parent, each inheriting
+ * iteration should lock and unlock both @pos->parent and @pos.
+ *
+ * Alternatively, a subsystem may choose to use a single global lock to
+ * synchronize ->css_online() and ->css_offline() against tree-walking
+ * operations.
+ *
+ * It is allowed to temporarily drop RCU read lock during iteration.  The
+ * caller is responsible for ensuring that @pos remains accessible until
+ * the start of the next iteration by, for example, bumping the css refcnt.
+ */
+#define css_for_each_descendant_pre(pos, css)                           \
+        for ((pos) = css_next_descendant_pre(NULL, (css)); (pos);       \
+             (pos) = css_next_descendant_pre((pos), (css)))
+
+/**
+ * css_for_each_descendant_post - post-order walk of a css's descendants
+ * @pos: the css * to use as the loop cursor
+ * @css: css whose descendants to walk
+ *
+ * Similar to css_for_each_descendant_pre() but performs post-order
+ * traversal instead.  @root is included in the iteration and the last
+ * node to be visited.
+ *
+ * If a subsystem synchronizes ->css_online() and the start of iteration, a
+ * css which finished ->css_online() is guaranteed to be visible in the
+ * future iterations and will stay visible until the last reference is put.
+ * A css which hasn't finished ->css_online() or already finished
+ * ->css_offline() may show up during traversal.  It's each subsystem's
+ * responsibility to synchronize against on/offlining.
+ *
+ * Note that the walk visibility guarantee example described in pre-order
+ * walk doesn't apply the same to post-order walks.
+ */
+#define css_for_each_descendant_post(pos, css)                          \
+        for ((pos) = css_next_descendant_post(NULL, (css)); (pos);      \
+             (pos) = css_next_descendant_post((pos), (css)))
+
+/**
+ * cgroup_taskset_for_each - iterate cgroup_taskset
+ * @task: the loop cursor
+ * @tset: taskset to iterate
+ */
+#define cgroup_taskset_for_each(task, tset)                             \
+        for ((task) = cgroup_taskset_first((tset)); (task);             \
+             (task) = cgroup_taskset_next((tset)))
+
+/*
+ * Inline functions.
+ */
 
 /**
  * css_get - obtain a reference on the specified css
@@ -185,309 +291,112 @@ static inline void css_put_many(struct cgroup_subsys_state *css, unsigned int n)
                 percpu_ref_put_many(&css->refcnt, n);
 }
 
-/* bits in struct cgroup flags field */
-enum {
-        /* Control Group requires release notifications to userspace */
-        CGRP_NOTIFY_ON_RELEASE,
-        /*
-         * Clone the parent's configuration when creating a new child
-         * cpuset cgroup.  For historical reasons, this option can be
-         * specified at mount time and thus is implemented here.
-         */
-        CGRP_CPUSET_CLONE_CHILDREN,
-};
-
-struct cgroup {
-        /* self css with NULL ->ss, points back to this cgroup */
-        struct cgroup_subsys_state self;
-
-        unsigned long flags;            /* "unsigned long" so bitops work */
-
-        /*
-         * idr allocated in-hierarchy ID.
-         *
-         * ID 0 is not used, the ID of the root cgroup is always 1, and a
-         * new cgroup will be assigned with a smallest available ID.
-         *
-         * Allocating/Removing ID must be protected by cgroup_mutex.
-         */
-        int id;
-
-        /*
-         * If this cgroup contains any tasks, it contributes one to
-         * populated_cnt.  All children with non-zero popuplated_cnt of
-         * their own contribute one.  The count is zero iff there's no task
-         * in this cgroup or its subtree.
-         */
-        int populated_cnt;
-
-        struct kernfs_node *kn;         /* cgroup kernfs entry */
-        struct kernfs_node *populated_kn; /* kn for "cgroup.subtree_populated" */
-
-        /*
-         * The bitmask of subsystems enabled on the child cgroups.
-         * ->subtree_control is the one configured through
-         * "cgroup.subtree_control" while ->child_subsys_mask is the
-         * effective one which may have more subsystems enabled.
-         * Controller knobs are made available iff it's enabled in
-         * ->subtree_control.
-         */
-        unsigned int subtree_control;
-        unsigned int child_subsys_mask;
-
-        /* Private pointers for each registered subsystem */
-        struct cgroup_subsys_state __rcu *subsys[CGROUP_SUBSYS_COUNT];
-
-        struct cgroup_root *root;
-
-        /*
-         * List of cgrp_cset_links pointing at css_sets with tasks in this
-         * cgroup.  Protected by css_set_lock.
-         */
-        struct list_head cset_links;
-
-        /*
-         * On the default hierarchy, a css_set for a cgroup with some
-         * susbsys disabled will point to css's which are associated with
-         * the closest ancestor which has the subsys enabled.  The
-         * following lists all css_sets which point to this cgroup's css
-         * for the given subsystem.
-         */
-        struct list_head e_csets[CGROUP_SUBSYS_COUNT];
-
-        /*
-         * list of pidlists, up to two for each namespace (one for procs, one
-         * for tasks); created on demand.
-         */
-        struct list_head pidlists;
-        struct mutex pidlist_mutex;
-
-        /* used to wait for offlining of csses */
-        wait_queue_head_t offline_waitq;
-
-        /* used to schedule release agent */
-        struct work_struct release_agent_work;
-};
-
-#define MAX_CGROUP_ROOT_NAMELEN 64
-
-/* cgroup_root->flags */
-enum {
-        CGRP_ROOT_SANE_BEHAVIOR = (1 << 0), /* __DEVEL__sane_behavior specified */
-        CGRP_ROOT_NOPREFIX      = (1 << 1), /* mounted subsystems have no named prefix */
-        CGRP_ROOT_XATTR         = (1 << 2), /* supports extended attributes */
-};
-
-/*
- * A cgroup_root represents the root of a cgroup hierarchy, and may be
- * associated with a kernfs_root to form an active hierarchy.  This is
- * internal to cgroup core.  Don't access directly from controllers.
+/**
+ * task_css_set_check - obtain a task's css_set with extra access conditions
+ * @task: the task to obtain css_set for
+ * @__c: extra condition expression to be passed to rcu_dereference_check()
+ *
+ * A task's css_set is RCU protected, initialized and exited while holding
+ * task_lock(), and can only be modified while holding both cgroup_mutex
+ * and task_lock() while the task is alive.  This macro verifies that the
+ * caller is inside proper critical section and returns @task's css_set.
+ *
+ * The caller can also specify additional allowed conditions via @__c, such
+ * as locks used during the cgroup_subsys::attach() methods.
  */
-struct cgroup_root {
-        struct kernfs_root *kf_root;
-
-        /* The bitmask of subsystems attached to this hierarchy */
-        unsigned int subsys_mask;
-
-        /* Unique id for this hierarchy. */
-        int hierarchy_id;
-
-        /* The root cgroup.  Root is destroyed on its release. */
-        struct cgroup cgrp;
-
-        /* Number of cgroups in the hierarchy, used only for /proc/cgroups */
-        atomic_t nr_cgrps;
-
-        /* A list running through the active hierarchies */
-        struct list_head root_list;
-
-        /* Hierarchy-specific flags */
-        unsigned int flags;
-
-        /* IDs for cgroups in this hierarchy */
-        struct idr cgroup_idr;
-
-        /* The path to use for release notifications. */
-        char release_agent_path[PATH_MAX];
-
-        /* The name for this hierarchy - may be empty */
-        char name[MAX_CGROUP_ROOT_NAMELEN];
-};
+#ifdef CONFIG_PROVE_RCU
+extern struct mutex cgroup_mutex;
+extern struct rw_semaphore css_set_rwsem;
+#define task_css_set_check(task, __c)                                   \
+        rcu_dereference_check((task)->cgroups,                          \
+                lockdep_is_held(&cgroup_mutex) ||                       \
+                lockdep_is_held(&css_set_rwsem) ||                      \
+                ((task)->flags & PF_EXITING) || (__c))
+#else
+#define task_css_set_check(task, __c)                                   \
+        rcu_dereference((task)->cgroups)
+#endif
 
-/*
- * A css_set is a structure holding pointers to a set of
- * cgroup_subsys_state objects. This saves space in the task struct
- * object and speeds up fork()/exit(), since a single inc/dec and a
- * list_add()/del() can bump the reference count on the entire cgroup
- * set for a task.
+/**
+ * task_css_check - obtain css for (task, subsys) w/ extra access conds
+ * @task: the target task
+ * @subsys_id: the target subsystem ID
+ * @__c: extra condition expression to be passed to rcu_dereference_check()
+ *
+ * Return the cgroup_subsys_state for the (@task, @subsys_id) pair.  The
+ * synchronization rules are the same as task_css_set_check().
  */
+#define task_css_check(task, subsys_id, __c)                            \
+        task_css_set_check((task), (__c))->subsys[(subsys_id)]
 
-struct css_set {
-
-        /* Reference count */
-        atomic_t refcount;
-
-        /*
-         * List running through all cgroup groups in the same hash
-         * slot. Protected by css_set_lock
-         */
-        struct hlist_node hlist;
-
-        /*
-         * Lists running through all tasks using this cgroup group.
-         * mg_tasks lists tasks which belong to this cset but are in the
-         * process of being migrated out or in.  Protected by
-         * css_set_rwsem, but, during migration, once tasks are moved to
-         * mg_tasks, it can be read safely while holding cgroup_mutex.
-         */
-        struct list_head tasks;
-        struct list_head mg_tasks;
-
-        /*
-         * List of cgrp_cset_links pointing at cgroups referenced from this
-         * css_set.  Protected by css_set_lock.
-         */
-        struct list_head cgrp_links;
-
-        /* the default cgroup associated with this css_set */
-        struct cgroup *dfl_cgrp;
-
-        /*
-         * Set of subsystem states, one for each subsystem. This array is
-         * immutable after creation apart from the init_css_set during
-         * subsystem registration (at boot time).
-         */
-        struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];
-
-        /*
-         * List of csets participating in the on-going migration either as
-         * source or destination.  Protected by cgroup_mutex.
-         */
-        struct list_head mg_preload_node;
-        struct list_head mg_node;
-
-        /*
-         * If this cset is acting as the source of migration the following
-         * two fields are set.  mg_src_cgrp is the source cgroup of the
-         * on-going migration and mg_dst_cset is the destination cset the
-         * target tasks on this cset should be migrated to.  Protected by
-         * cgroup_mutex.
-         */
-        struct cgroup *mg_src_cgrp;
-        struct css_set *mg_dst_cset;
-
-        /*
-         * On the default hierarhcy, ->subsys[ssid] may point to a css
-         * attached to an ancestor instead of the cgroup this css_set is
-         * associated with.  The following node is anchored at
-         * ->subsys[ssid]->cgroup->e_csets[ssid] and provides a way to
-         * iterate through all css's attached to a given cgroup.
-         */
-        struct list_head e_cset_node[CGROUP_SUBSYS_COUNT];
-
-        /* For RCU-protected deletion */
-        struct rcu_head rcu_head;
-};
-
-/*
- * struct cftype: handler definitions for cgroup control files
+/**
+ * task_css_set - obtain a task's css_set
+ * @task: the task to obtain css_set for
  *
- * When reading/writing to a file:
- *      - the cgroup to use is file->f_path.dentry->d_parent->d_fsdata
- *      - the 'cftype' of the file is file->f_path.dentry->d_fsdata
+ * See task_css_set_check().
  */
+static inline struct css_set *task_css_set(struct task_struct *task)
+{
+        return task_css_set_check(task, false);
+}
 
-/* cftype->flags */
-enum {
-        CFTYPE_ONLY_ON_ROOT     = (1 << 0),     /* only create on root cgrp */
-        CFTYPE_NOT_ON_ROOT      = (1 << 1),     /* don't create on root cgrp */
-        CFTYPE_NO_PREFIX        = (1 << 3),     /* (DON'T USE FOR NEW FILES) no subsys prefix */
+/**
+ * task_css - obtain css for (task, subsys)
+ * @task: the target task
+ * @subsys_id: the target subsystem ID
+ *
+ * See task_css_check().
+ */
+static inline struct cgroup_subsys_state *task_css(struct task_struct *task,
+                                                   int subsys_id)
+{
+        return task_css_check(task, subsys_id, false);
+}
 
-        /* internal flags, do not use outside cgroup core proper */
-        __CFTYPE_ONLY_ON_DFL    = (1 << 16),    /* only on default hierarchy */
-        __CFTYPE_NOT_ON_DFL     = (1 << 17),    /* not on default hierarchy */
-};
+/**
+ * task_get_css - find and get the css for (task, subsys)
+ * @task: the target task
+ * @subsys_id: the target subsystem ID
+ *
+ * Find the css for the (@task, @subsys_id) combination, increment a
+ * reference on and return it.  This function is guaranteed to return a
+ * valid css.
+ */
+static inline struct cgroup_subsys_state *
+task_get_css(struct task_struct *task, int subsys_id)
+{
+        struct cgroup_subsys_state *css;
+
+        rcu_read_lock();
+        while (true) {
+                css = task_css(task, subsys_id);
+                if (likely(css_tryget_online(css)))
+                        break;
+                cpu_relax();
+        }
+        rcu_read_unlock();
+        return css;
+}
 
-#define MAX_CFTYPE_NAME         64
-
-struct cftype {
-        /*
-         * By convention, the name should begin with the name of the
-         * subsystem, followed by a period.  Zero length string indicates
-         * end of cftype array.
-         */
-        char name[MAX_CFTYPE_NAME];
-        int private;
-        /*
-         * If not 0, file mode is set to this value, otherwise it will
-         * be figured out automatically
-         */
-        umode_t mode;
-
-        /*
-         * The maximum length of string, excluding trailing nul, that can
-         * be passed to write.  If < PAGE_SIZE-1, PAGE_SIZE-1 is assumed.
-         */
-        size_t max_write_len;
-
-        /* CFTYPE_* flags */
-        unsigned int flags;
-
-        /*
-         * Fields used for internal bookkeeping.  Initialized automatically
-         * during registration.
-         */
-        struct cgroup_subsys *ss;       /* NULL for cgroup core files */
-        struct list_head node;          /* anchored at ss->cfts */
-        struct kernfs_ops *kf_ops;
-
-        /*
-         * read_u64() is a shortcut for the common case of returning a
-         * single integer. Use it in place of read()
-         */
-        u64 (*read_u64)(struct cgroup_subsys_state *css, struct cftype *cft);
-        /*
-         * read_s64() is a signed version of read_u64()
-         */
-        s64 (*read_s64)(struct cgroup_subsys_state *css, struct cftype *cft);
-
-        /* generic seq_file read interface */
-        int (*seq_show)(struct seq_file *sf, void *v);
-
-        /* optional ops, implement all or none */
-        void *(*seq_start)(struct seq_file *sf, loff_t *ppos);
-        void *(*seq_next)(struct seq_file *sf, void *v, loff_t *ppos);
-        void (*seq_stop)(struct seq_file *sf, void *v);
-
-        /*
-         * write_u64() is a shortcut for the common case of accepting
-         * a single integer (as parsed by simple_strtoull) from
-         * userspace. Use in place of write(); return 0 or error.
-         */
-        int (*write_u64)(struct cgroup_subsys_state *css, struct cftype *cft,
-                         u64 val);
-        /*
-         * write_s64() is a signed version of write_u64()
-         */
-        int (*write_s64)(struct cgroup_subsys_state *css, struct cftype *cft,
-                         s64 val);
-
-        /*
-         * write() is the generic write callback which maps directly to
-         * kernfs write operation and overrides all other operations.
-         * Maximum write size is determined by ->max_write_len.  Use
-         * of_css/cft() to access the associated css and cft.
-         */
-        ssize_t (*write)(struct kernfs_open_file *of,
-                         char *buf, size_t nbytes, loff_t off);
-
-#ifdef CONFIG_DEBUG_LOCK_ALLOC
-        struct lock_class_key   lockdep_key;
-#endif
-};
+/**
+ * task_css_is_root - test whether a task belongs to the root css
+ * @task: the target task
+ * @subsys_id: the target subsystem ID
+ *
+ * Test whether @task belongs to the root css on the specified subsystem.
+ * May be invoked in any context.
+ */
+static inline bool task_css_is_root(struct task_struct *task, int subsys_id)
+{
+        return task_css_check(task, subsys_id, true) ==
+                init_css_set.subsys[subsys_id];
+}
 
-extern struct cgroup_root cgrp_dfl_root;
-extern struct css_set init_css_set;
+static inline struct cgroup *task_cgroup(struct task_struct *task,
+                                         int subsys_id)
+{
+        return task_css(task, subsys_id)->cgroup;
+}
 
 /**
  * cgroup_on_dfl - test whether a cgroup is on the default hierarchy
@@ -604,367 +513,22 @@ static inline void pr_cont_cgroup_path(struct cgroup *cgrp)
         pr_cont_kernfs_path(cgrp->kn);
 }
 
-char *task_cgroup_path(struct task_struct *task, char *buf, size_t buflen);
-
-int cgroup_add_dfl_cftypes(struct cgroup_subsys *ss, struct cftype *cfts);
-int cgroup_add_legacy_cftypes(struct cgroup_subsys *ss, struct cftype *cfts);
-int cgroup_rm_cftypes(struct cftype *cfts);
-
-bool cgroup_is_descendant(struct cgroup *cgrp, struct cgroup *ancestor);
-
-/*
- * Control Group taskset, used to pass around set of tasks to cgroup_subsys
- * methods.
- */
-struct cgroup_taskset;
-struct task_struct *cgroup_taskset_first(struct cgroup_taskset *tset);
-struct task_struct *cgroup_taskset_next(struct cgroup_taskset *tset);
-
-/**
- * cgroup_taskset_for_each - iterate cgroup_taskset
- * @task: the loop cursor
- * @tset: taskset to iterate
- */
-#define cgroup_taskset_for_each(task, tset)                             \
-        for ((task) = cgroup_taskset_first((tset)); (task);             \
-             (task) = cgroup_taskset_next((tset)))
-
-/*
- * Control Group subsystem type.
- * See Documentation/cgroups/cgroups.txt for details
- */
-
-struct cgroup_subsys {
-        struct cgroup_subsys_state *(*css_alloc)(struct cgroup_subsys_state *parent_css);
-        int (*css_online)(struct cgroup_subsys_state *css);
-        void (*css_offline)(struct cgroup_subsys_state *css);
-        void (*css_released)(struct cgroup_subsys_state *css);
-        void (*css_free)(struct cgroup_subsys_state *css);
-        void (*css_reset)(struct cgroup_subsys_state *css);
-        void (*css_e_css_changed)(struct cgroup_subsys_state *css);
-
-        int (*can_attach)(struct cgroup_subsys_state *css,
-                          struct cgroup_taskset *tset);
-        void (*cancel_attach)(struct cgroup_subsys_state *css,
-                              struct cgroup_taskset *tset);
-        void (*attach)(struct cgroup_subsys_state *css,
-                       struct cgroup_taskset *tset);
-        void (*fork)(struct task_struct *task);
-        void (*exit)(struct cgroup_subsys_state *css,
-                     struct cgroup_subsys_state *old_css,
-                     struct task_struct *task);
-        void (*bind)(struct cgroup_subsys_state *root_css);
-
-        int disabled;
-        int early_init;
-
-        /*
-         * If %false, this subsystem is properly hierarchical -
-         * configuration, resource accounting and restriction on a parent
-         * cgroup cover those of its children.  If %true, hierarchy support
-         * is broken in some ways - some subsystems ignore hierarchy
-         * completely while others are only implemented half-way.
-         *
-         * It's now disallowed to create nested cgroups if the subsystem is
-         * broken and cgroup core will emit a warning message on such
-         * cases.  Eventually, all subsystems will be made properly
-         * hierarchical and this will go away.
-         */
-        bool broken_hierarchy;
-        bool warned_broken_hierarchy;
-
-        /* the following two fields are initialized automtically during boot */
-        int id;
-#define MAX_CGROUP_TYPE_NAMELEN 32
-        const char *name;
-
-        /* link to parent, protected by cgroup_lock() */
-        struct cgroup_root *root;
-
-        /* idr for css->id */
-        struct idr css_idr;
-
-        /*
-         * List of cftypes.  Each entry is the first entry of an array
-         * terminated by zero length name.
-         */
-        struct list_head cfts;
-
-        /*
-         * Base cftypes which are automatically registered.  The two can
-         * point to the same array.
-         */
-        struct cftype *dfl_cftypes;     /* for the default hierarchy */
-        struct cftype *legacy_cftypes;  /* for the legacy hierarchies */
-
-        /*
-         * A subsystem may depend on other subsystems.  When such subsystem
-         * is enabled on a cgroup, the depended-upon subsystems are enabled
-         * together if available.  Subsystems enabled due to dependency are
-         * not visible to userland until explicitly enabled.  The following
-         * specifies the mask of subsystems that this one depends on.
-         */
-        unsigned int depends_on;
-};
-
-#define SUBSYS(_x) extern struct cgroup_subsys _x ## _cgrp_subsys;
-#include <linux/cgroup_subsys.h>
-#undef SUBSYS
-
-/**
- * task_css_set_check - obtain a task's css_set with extra access conditions
- * @task: the task to obtain css_set for
- * @__c: extra condition expression to be passed to rcu_dereference_check()
- *
- * A task's css_set is RCU protected, initialized and exited while holding
- * task_lock(), and can only be modified while holding both cgroup_mutex
- * and task_lock() while the task is alive.  This macro verifies that the
- * caller is inside proper critical section and returns @task's css_set.
- *
- * The caller can also specify additional allowed conditions via @__c, such
- * as locks used during the cgroup_subsys::attach() methods.
- */
-#ifdef CONFIG_PROVE_RCU
-extern struct mutex cgroup_mutex;
-extern struct rw_semaphore css_set_rwsem;
-#define task_css_set_check(task, __c)                                   \
-        rcu_dereference_check((task)->cgroups,                          \
-                lockdep_is_held(&cgroup_mutex) ||                       \
-                lockdep_is_held(&css_set_rwsem) ||                      \
-                ((task)->flags & PF_EXITING) || (__c))
-#else
-#define task_css_set_check(task, __c)                                   \
-        rcu_dereference((task)->cgroups)
-#endif
-
-/**
- * task_css_check - obtain css for (task, subsys) w/ extra access conds
- * @task: the target task
- * @subsys_id: the target subsystem ID
- * @__c: extra condition expression to be passed to rcu_dereference_check()
- *
- * Return the cgroup_subsys_state for the (@task, @subsys_id) pair.  The
- * synchronization rules are the same as task_css_set_check().
- */
-#define task_css_check(task, subsys_id, __c)                            \
-        task_css_set_check((task), (__c))->subsys[(subsys_id)]
-
-/**
- * task_css_set - obtain a task's css_set
- * @task: the task to obtain css_set for
- *
- * See task_css_set_check().
- */
-static inline struct css_set *task_css_set(struct task_struct *task)
-{
-        return task_css_set_check(task, false);
-}
-
-/**
- * task_css - obtain css for (task, subsys)
- * @task: the target task
- * @subsys_id: the target subsystem ID
- *
- * See task_css_check().
- */
-static inline struct cgroup_subsys_state *task_css(struct task_struct *task,
-                                                   int subsys_id)
-{
-        return task_css_check(task, subsys_id, false);
-}
-
-/**
- * task_css_is_root - test whether a task belongs to the root css
- * @task: the target task
- * @subsys_id: the target subsystem ID
- *
- * Test whether @task belongs to the root css on the specified subsystem.
- * May be invoked in any context.
- */
-static inline bool task_css_is_root(struct task_struct *task, int subsys_id)
-{
-        return task_css_check(task, subsys_id, true) ==
-                init_css_set.subsys[subsys_id];
-}
-
-static inline struct cgroup *task_cgroup(struct task_struct *task,
-                                         int subsys_id)
-{
-        return task_css(task, subsys_id)->cgroup;
-}
-
-struct cgroup_subsys_state *css_next_child(struct cgroup_subsys_state *pos,
-                                           struct cgroup_subsys_state *parent);
-
-struct cgroup_subsys_state *css_from_id(int id, struct cgroup_subsys *ss);
-
-/**
- * css_for_each_child - iterate through children of a css
- * @pos: the css * to use as the loop cursor
- * @parent: css whose children to walk
- *
- * Walk @parent's children.  Must be called under rcu_read_lock().
- *
- * If a subsystem synchronizes ->css_online() and the start of iteration, a
- * css which finished ->css_online() is guaranteed to be visible in the
- * future iterations and will stay visible until the last reference is put.
- * A css which hasn't finished ->css_online() or already finished
- * ->css_offline() may show up during traversal.  It's each subsystem's
- * responsibility to synchronize against on/offlining.
- *
- * It is allowed to temporarily drop RCU read lock during iteration.  The
- * caller is responsible for ensuring that @pos remains accessible until
- * the start of the next iteration by, for example, bumping the css refcnt.
- */
-#define css_for_each_child(pos, parent)                                 \
-        for ((pos) = css_next_child(NULL, (parent)); (pos);             \
-             (pos) = css_next_child((pos), (parent)))
-
-struct cgroup_subsys_state *
-css_next_descendant_pre(struct cgroup_subsys_state *pos,
-                        struct cgroup_subsys_state *css);
-
-struct cgroup_subsys_state *
-css_rightmost_descendant(struct cgroup_subsys_state *pos);
-
-/**
- * css_for_each_descendant_pre - pre-order walk of a css's descendants
- * @pos: the css * to use as the loop cursor
- * @root: css whose descendants to walk
- *
- * Walk @root's descendants.  @root is included in the iteration and the
- * first node to be visited.  Must be called under rcu_read_lock().
- *
- * If a subsystem synchronizes ->css_online() and the start of iteration, a
- * css which finished ->css_online() is guaranteed to be visible in the
- * future iterations and will stay visible until the last reference is put.
- * A css which hasn't finished ->css_online() or already finished
- * ->css_offline() may show up during traversal.  It's each subsystem's
- * responsibility to synchronize against on/offlining.
- *
- * For example, the following guarantees that a descendant can't escape
- * state updates of its ancestors.
- *
- * my_online(@css)
- * {
- *      Lock @css's parent and @css;
- *      Inherit state from the parent;
- *      Unlock both.
- * }
- *
- * my_update_state(@css)
- * {
- *      css_for_each_descendant_pre(@pos, @css) {
- *              Lock @pos;
- *              if (@pos == @css)
- *                      Update @css's state;
- *              else
- *                      Verify @pos is alive and inherit state from its parent;
- *              Unlock @pos;
- *      }
- * }
- *
- * As long as the inheriting step, including checking the parent state, is
- * enclosed inside @pos locking, double-locking the parent isn't necessary
- * while inheriting.  The state update to the parent is guaranteed to be
- * visible by walking order and, as long as inheriting operations to the
- * same @pos are atomic to each other, multiple updates racing each other
- * still result in the correct state.  It's guaranateed that at least one
- * inheritance happens for any css after the latest update to its parent.
- *
- * If checking parent's state requires locking the parent, each inheriting
- * iteration should lock and unlock both @pos->parent and @pos.
- *
- * Alternatively, a subsystem may choose to use a single global lock to
- * synchronize ->css_online() and ->css_offline() against tree-walking
- * operations.
- *
- * It is allowed to temporarily drop RCU read lock during iteration.  The
- * caller is responsible for ensuring that @pos remains accessible until
- * the start of the next iteration by, for example, bumping the css refcnt.
- */
-#define css_for_each_descendant_pre(pos, css)                           \
-        for ((pos) = css_next_descendant_pre(NULL, (css)); (pos);       \
-             (pos) = css_next_descendant_pre((pos), (css)))
-
-struct cgroup_subsys_state *
-css_next_descendant_post(struct cgroup_subsys_state *pos,
-                         struct cgroup_subsys_state *css);
-
-/**
- * css_for_each_descendant_post - post-order walk of a css's descendants
- * @pos: the css * to use as the loop cursor
- * @css: css whose descendants to walk
- *
- * Similar to css_for_each_descendant_pre() but performs post-order
- * traversal instead.  @root is included in the iteration and the last
- * node to be visited.
- *
- * If a subsystem synchronizes ->css_online() and the start of iteration, a
- * css which finished ->css_online() is guaranteed to be visible in the
- * future iterations and will stay visible until the last reference is put.
- * A css which hasn't finished ->css_online() or already finished
- * ->css_offline() may show up during traversal.  It's each subsystem's
- * responsibility to synchronize against on/offlining.
- *
- * Note that the walk visibility guarantee example described in pre-order
- * walk doesn't apply the same to post-order walks.
- */
-#define css_for_each_descendant_post(pos, css)                          \
-        for ((pos) = css_next_descendant_post(NULL, (css)); (pos);      \
-             (pos) = css_next_descendant_post((pos), (css)))
-
-bool css_has_online_children(struct cgroup_subsys_state *css);
-
-/* A css_task_iter should be treated as an opaque object */
-struct css_task_iter {
-        struct cgroup_subsys            *ss;
-
-        struct list_head                *cset_pos;
-        struct list_head                *cset_head;
-
-        struct list_head                *task_pos;
-        struct list_head                *tasks_head;
-        struct list_head                *mg_tasks_head;
-};
-
-void css_task_iter_start(struct cgroup_subsys_state *css,
-                         struct css_task_iter *it);
-struct task_struct *css_task_iter_next(struct css_task_iter *it);
-void css_task_iter_end(struct css_task_iter *it);
-
-int cgroup_attach_task_all(struct task_struct *from, struct task_struct *);
-int cgroup_transfer_tasks(struct cgroup *to, struct cgroup *from);
-
-struct cgroup_subsys_state *cgroup_get_e_css(struct cgroup *cgroup,
-                                             struct cgroup_subsys *ss);
-struct cgroup_subsys_state *css_tryget_online_from_dir(struct dentry *dentry,
-                                                       struct cgroup_subsys *ss);
-
 #else /* !CONFIG_CGROUPS */
 
 struct cgroup_subsys_state;
 
-static inline int cgroup_init_early(void) { return 0; }
-static inline int cgroup_init(void) { return 0; }
+static inline void css_put(struct cgroup_subsys_state *css) {}
+static inline int cgroup_attach_task_all(struct task_struct *from,
+                                         struct task_struct *t) { return 0; }
+static inline int cgroupstats_build(struct cgroupstats *stats,
+                                    struct dentry *dentry) { return -EINVAL; }
+
 static inline void cgroup_fork(struct task_struct *p) {}
 static inline void cgroup_post_fork(struct task_struct *p) {}
 static inline void cgroup_exit(struct task_struct *p) {}
 
-static inline int cgroupstats_build(struct cgroupstats *stats,
-                                        struct dentry *dentry)
-{
-        return -EINVAL;
-}
-
-static inline void css_put(struct cgroup_subsys_state *css) {}
-
-/* No cgroups - nothing to do */
-static inline int cgroup_attach_task_all(struct task_struct *from,
-                                         struct task_struct *t)
-{
-        return 0;
-}
+static inline int cgroup_init_early(void) { return 0; }
+static inline int cgroup_init(void) { return 0; }
 
 #endif /* !CONFIG_CGROUPS */
 
diff --git a/include/linux/clk-provider.h b/include/linux/clk-provider.h
index df695313f975..78842f46f152 100644
--- a/include/linux/clk-provider.h
+++ b/include/linux/clk-provider.h
@@ -31,6 +31,7 @@
 #define CLK_GET_RATE_NOCACHE    BIT(6) /* do not use the cached clk rate */
 #define CLK_SET_RATE_NO_REPARENT BIT(7) /* don't re-parent on rate change */
 #define CLK_GET_ACCURACY_NOCACHE BIT(8) /* do not use the cached clk accuracy */
+#define CLK_RECALC_NEW_RATES    BIT(9) /* recalc rates after notifications */
 
 struct clk_hw;
 struct clk_core;
@@ -209,7 +210,7 @@ struct clk_ops {
 struct clk_init_data {
         const char              *name;
         const struct clk_ops    *ops;
-        const char              **parent_names;
+        const char              * const *parent_names;
         u8                      num_parents;
         unsigned long           flags;
 };
@@ -426,12 +427,14 @@ extern const struct clk_ops clk_mux_ops;
 extern const struct clk_ops clk_mux_ro_ops;
 
 struct clk *clk_register_mux(struct device *dev, const char *name,
-                const char **parent_names, u8 num_parents, unsigned long flags,
+                const char * const *parent_names, u8 num_parents,
+                unsigned long flags,
                 void __iomem *reg, u8 shift, u8 width,
                 u8 clk_mux_flags, spinlock_t *lock);
 
 struct clk *clk_register_mux_table(struct device *dev, const char *name,
-                const char **parent_names, u8 num_parents, unsigned long flags,
+                const char * const *parent_names, u8 num_parents,
+                unsigned long flags,
                 void __iomem *reg, u8 shift, u32 mask,
                 u8 clk_mux_flags, u32 *table, spinlock_t *lock);
 
@@ -457,7 +460,7 @@ struct clk_fixed_factor {
         unsigned int    div;
 };
 
-extern struct clk_ops clk_fixed_factor_ops;
+extern const struct clk_ops clk_fixed_factor_ops;
 struct clk *clk_register_fixed_factor(struct device *dev, const char *name,
                 const char *parent_name, unsigned long flags,
                 unsigned int mult, unsigned int div);
@@ -518,7 +521,7 @@ struct clk_composite {
 };
 
 struct clk *clk_register_composite(struct device *dev, const char *name,
-                const char **parent_names, int num_parents,
+                const char * const *parent_names, int num_parents,
                 struct clk_hw *mux_hw, const struct clk_ops *mux_ops,
                 struct clk_hw *rate_hw, const struct clk_ops *rate_ops,
                 struct clk_hw *gate_hw, const struct clk_ops *gate_ops,
@@ -589,6 +592,7 @@ long __clk_mux_determine_rate_closest(struct clk_hw *hw, unsigned long rate,
                               unsigned long max_rate,
                               unsigned long *best_parent_rate,
                               struct clk_hw **best_parent_p);
+void clk_hw_reparent(struct clk_hw *hw, struct clk_hw *new_parent);
 
 static inline void __clk_hw_set_clk(struct clk_hw *dst, struct clk_hw *src)
 {
@@ -624,6 +628,8 @@ struct clk *of_clk_src_simple_get(struct of_phandle_args *clkspec,
                                   void *data);
 struct clk *of_clk_src_onecell_get(struct of_phandle_args *clkspec, void *data);
 int of_clk_get_parent_count(struct device_node *np);
+int of_clk_parent_fill(struct device_node *np, const char **parents,
+                       unsigned int size);
 const char *of_clk_get_parent_name(struct device_node *np, int index);
 
 void of_clk_init(const struct of_device_id *matches);
diff --git a/include/linux/clk.h b/include/linux/clk.h
index 68c16a6bedb3..0df4a51e1a78 100644
--- a/include/linux/clk.h
+++ b/include/linux/clk.h
@@ -306,6 +306,20 @@ void devm_clk_put(struct device *dev, struct clk *clk);
  * @clk: clock source
  * @rate: desired clock rate in Hz
  *
+ * This answers the question "if I were to pass @rate to clk_set_rate(),
+ * what clock rate would I end up with?" without changing the hardware
+ * in any way.  In other words:
+ *
+ *   rate = clk_round_rate(clk, r);
+ *
+ * and:
+ *
+ *   clk_set_rate(clk, r);
+ *   rate = clk_get_rate(clk);
+ *
+ * are equivalent except the former does not modify the clock hardware
+ * in any way.
+ *
  * Returns rounded clock rate in Hz, or negative errno.
  */
 long clk_round_rate(struct clk *clk, unsigned long rate);
@@ -471,19 +485,6 @@ static inline void clk_disable_unprepare(struct clk *clk)
         clk_unprepare(clk);
 }
 
-/**
- * clk_add_alias - add a new clock alias
- * @alias: name for clock alias
- * @alias_dev_name: device name
- * @id: platform specific clock name
- * @dev: device
- *
- * Allows using generic clock names for drivers by adding a new alias.
- * Assumes clkdev, see clkdev.h for more info.
- */
-int clk_add_alias(const char *alias, const char *alias_dev_name, char *id,
-                        struct device *dev);
-
 struct device_node;
 struct of_phandle_args;
 
diff --git a/include/linux/clkdev.h b/include/linux/clkdev.h
index 94bad77eeb4a..08bffcc466de 100644
--- a/include/linux/clkdev.h
+++ b/include/linux/clkdev.h
@@ -22,6 +22,7 @@ struct clk_lookup {
         const char              *dev_id;
         const char              *con_id;
         struct clk              *clk;
+        struct clk_hw           *clk_hw;
 };
 
 #define CLKDEV_INIT(d, n, c)    \
@@ -32,15 +33,19 @@ struct clk_lookup {
         }
 
 struct clk_lookup *clkdev_alloc(struct clk *clk, const char *con_id,
-        const char *dev_fmt, ...);
+        const char *dev_fmt, ...) __printf(3, 4);
 
 void clkdev_add(struct clk_lookup *cl);
 void clkdev_drop(struct clk_lookup *cl);
 
+struct clk_lookup *clkdev_create(struct clk *clk, const char *con_id,
+        const char *dev_fmt, ...) __printf(3, 4);
+
 void clkdev_add_table(struct clk_lookup *, size_t);
-int clk_add_alias(const char *, const char *, char *, struct device *);
+int clk_add_alias(const char *, const char *, const char *, struct device *);
 
-int clk_register_clkdev(struct clk *, const char *, const char *, ...);
+int clk_register_clkdev(struct clk *, const char *, const char *, ...)
+        __printf(3, 4);
 int clk_register_clkdevs(struct clk *, struct clk_lookup *, size_t);
 
 #ifdef CONFIG_COMMON_CLK
diff --git a/include/linux/compat.h b/include/linux/compat.h
index ab25814690bc..a76c9172b2eb 100644
--- a/include/linux/compat.h
+++ b/include/linux/compat.h
@@ -424,7 +424,7 @@ asmlinkage long compat_sys_settimeofday(struct compat_timeval __user *tv,
 
 asmlinkage long compat_sys_adjtimex(struct compat_timex __user *utp);
 
-extern int compat_printk(const char *fmt, ...);
+extern __printf(1, 2) int compat_printk(const char *fmt, ...);
 extern void sigset_from_compat(sigset_t *set, const compat_sigset_t *compat);
 extern void sigset_to_compat(compat_sigset_t *compat, const sigset_t *set);
 
diff --git a/include/linux/compiler-gcc.h b/include/linux/compiler-gcc.h
index 371e560d13cf..dfaa7b3e9ae9 100644
--- a/include/linux/compiler-gcc.h
+++ b/include/linux/compiler-gcc.h
@@ -5,9 +5,9 @@
 /*
  * Common definitions for all gcc versions go here.
  */
-#define GCC_VERSION (__GNUC__ * 10000 \
-                   + __GNUC_MINOR__ * 100 \
-                   + __GNUC_PATCHLEVEL__)
+#define GCC_VERSION (__GNUC__ * 10000           \
+                     + __GNUC_MINOR__ * 100     \
+                     + __GNUC_PATCHLEVEL__)
 
 /* Optimization barrier */
 
@@ -46,55 +46,63 @@
  * the inline assembly constraint from =g to =r, in this particular
  * case either is valid.
  */
-#define RELOC_HIDE(ptr, off)                                    \
-  ({ unsigned long __ptr;                                       \
-    __asm__ ("" : "=r"(__ptr) : "0"(ptr));              \
-    (typeof(ptr)) (__ptr + (off)); })
+#define RELOC_HIDE(ptr, off)                                            \
+({                                                                      \
+        unsigned long __ptr;                                            \
+        __asm__ ("" : "=r"(__ptr) : "0"(ptr));                          \
+        (typeof(ptr)) (__ptr + (off));                                  \
+})
 
 /* Make the optimizer believe the variable can be manipulated arbitrarily. */
-#define OPTIMIZER_HIDE_VAR(var) __asm__ ("" : "=r" (var) : "0" (var))
+#define OPTIMIZER_HIDE_VAR(var)                                         \
+        __asm__ ("" : "=r" (var) : "0" (var))
 
 #ifdef __CHECKER__
-#define __must_be_array(arr) 0
+#define __must_be_array(a)      0
 #else
 /* &a[0] degrades to a pointer: a different type from an array */
-#define __must_be_array(a) BUILD_BUG_ON_ZERO(__same_type((a), &(a)[0]))
+#define __must_be_array(a)      BUILD_BUG_ON_ZERO(__same_type((a), &(a)[0]))
 #endif
 
 /*
  * Force always-inline if the user requests it so via the .config,
  * or if gcc is too old:
  */
-#if !defined(CONFIG_ARCH_SUPPORTS_OPTIMIZED_INLINING) || \
+#if !defined(CONFIG_ARCH_SUPPORTS_OPTIMIZED_INLINING) ||                \
     !defined(CONFIG_OPTIMIZE_INLINING) || (__GNUC__ < 4)
-# define inline         inline          __attribute__((always_inline)) notrace
-# define __inline__     __inline__      __attribute__((always_inline)) notrace
-# define __inline       __inline        __attribute__((always_inline)) notrace
+#define inline          inline          __attribute__((always_inline)) notrace
+#define __inline__      __inline__      __attribute__((always_inline)) notrace
+#define __inline        __inline        __attribute__((always_inline)) notrace
 #else
 /* A lot of inline functions can cause havoc with function tracing */
-# define inline         inline          notrace
-# define __inline__     __inline__      notrace
-# define __inline       __inline        notrace
+#define inline          inline          notrace
+#define __inline__      __inline__      notrace
+#define __inline        __inline        notrace
 #endif
 
-#define __deprecated                    __attribute__((deprecated))
-#define __packed                        __attribute__((packed))
-#define __weak                          __attribute__((weak))
-#define __alias(symbol)         __attribute__((alias(#symbol)))
+#define __always_inline inline __attribute__((always_inline))
+#define  noinline       __attribute__((noinline))
+
+#define __deprecated    __attribute__((deprecated))
+#define __packed        __attribute__((packed))
+#define __weak          __attribute__((weak))
+#define __alias(symbol) __attribute__((alias(#symbol)))
 
 /*
- * it doesn't make sense on ARM (currently the only user of __naked) to trace
- * naked functions because then mcount is called without stack and frame pointer
- * being set up and there is no chance to restore the lr register to the value
- * before mcount was called.
+ * it doesn't make sense on ARM (currently the only user of __naked)
+ * to trace naked functions because then mcount is called without
+ * stack and frame pointer being set up and there is no chance to
+ * restore the lr register to the value before mcount was called.
+ *
+ * The asm() bodies of naked functions often depend on standard calling
+ * conventions, therefore they must be noinline and noclone.
  *
- * The asm() bodies of naked functions often depend on standard calling conventions,
- * therefore they must be noinline and noclone.  GCC 4.[56] currently fail to enforce
- * this, so we must do so ourselves.  See GCC PR44290.
+ * GCC 4.[56] currently fail to enforce this, so we must do so ourselves.
+ * See GCC PR44290.
  */
-#define __naked                         __attribute__((naked)) noinline __noclone notrace
+#define __naked         __attribute__((naked)) noinline __noclone notrace
 
-#define __noreturn                      __attribute__((noreturn))
+#define __noreturn      __attribute__((noreturn))
 
 /*
  * From the GCC manual:
@@ -106,19 +114,130 @@
  * would be.
  * [...]
  */
-#define __pure                          __attribute__((pure))
-#define __aligned(x)                    __attribute__((aligned(x)))
-#define __printf(a, b)                  __attribute__((format(printf, a, b)))
-#define __scanf(a, b)                   __attribute__((format(scanf, a, b)))
-#define  noinline                       __attribute__((noinline))
-#define __attribute_const__             __attribute__((__const__))
-#define __maybe_unused                  __attribute__((unused))
-#define __always_unused                 __attribute__((unused))
-
-#define __gcc_header(x) #x
-#define _gcc_header(x) __gcc_header(linux/compiler-gcc##x.h)
-#define gcc_header(x) _gcc_header(x)
-#include gcc_header(__GNUC__)
+#define __pure                  __attribute__((pure))
+#define __aligned(x)            __attribute__((aligned(x)))
+#define __printf(a, b)          __attribute__((format(printf, a, b)))
+#define __scanf(a, b)           __attribute__((format(scanf, a, b)))
+#define __attribute_const__     __attribute__((__const__))
+#define __maybe_unused          __attribute__((unused))
+#define __always_unused         __attribute__((unused))
+
+/* gcc version specific checks */
+
+#if GCC_VERSION < 30200
+# error Sorry, your compiler is too old - please upgrade it.
+#endif
+
+#if GCC_VERSION < 30300
+# define __used                 __attribute__((__unused__))
+#else
+# define __used                 __attribute__((__used__))
+#endif
+
+#ifdef CONFIG_GCOV_KERNEL
+# if GCC_VERSION < 30400
+#   error "GCOV profiling support for gcc versions below 3.4 not included"
+# endif /* __GNUC_MINOR__ */
+#endif /* CONFIG_GCOV_KERNEL */
+
+#if GCC_VERSION >= 30400
+#define __must_check            __attribute__((warn_unused_result))
+#endif
+
+#if GCC_VERSION >= 40000
+
+/* GCC 4.1.[01] miscompiles __weak */
+#ifdef __KERNEL__
+# if GCC_VERSION >= 40100 &&  GCC_VERSION <= 40101
+#  error Your version of gcc miscompiles the __weak directive
+# endif
+#endif
+
+#define __used                  __attribute__((__used__))
+#define __compiler_offsetof(a, b)                                       \
+        __builtin_offsetof(a, b)
+
+#if GCC_VERSION >= 40100 && GCC_VERSION < 40600
+# define __compiletime_object_size(obj) __builtin_object_size(obj, 0)
+#endif
+
+#if GCC_VERSION >= 40300
+/* Mark functions as cold. gcc will assume any path leading to a call
+ * to them will be unlikely.  This means a lot of manual unlikely()s
+ * are unnecessary now for any paths leading to the usual suspects
+ * like BUG(), printk(), panic() etc. [but let's keep them for now for
+ * older compilers]
+ *
+ * Early snapshots of gcc 4.3 don't support this and we can't detect this
+ * in the preprocessor, but we can live with this because they're unreleased.
+ * Maketime probing would be overkill here.
+ *
+ * gcc also has a __attribute__((__hot__)) to move hot functions into
+ * a special section, but I don't see any sense in this right now in
+ * the kernel context
+ */
+#define __cold                  __attribute__((__cold__))
+
+#define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __COUNTER__)
+
+#ifndef __CHECKER__
+# define __compiletime_warning(message) __attribute__((warning(message)))
+# define __compiletime_error(message) __attribute__((error(message)))
+#endif /* __CHECKER__ */
+#endif /* GCC_VERSION >= 40300 */
+
+#if GCC_VERSION >= 40500
+/*
+ * Mark a position in code as unreachable.  This can be used to
+ * suppress control flow warnings after asm blocks that transfer
+ * control elsewhere.
+ *
+ * Early snapshots of gcc 4.5 don't support this and we can't detect
+ * this in the preprocessor, but we can live with this because they're
+ * unreleased.  Really, we need to have autoconf for the kernel.
+ */
+#define unreachable() __builtin_unreachable()
+
+/* Mark a function definition as prohibited from being cloned. */
+#define __noclone       __attribute__((__noclone__))
+
+#endif /* GCC_VERSION >= 40500 */
+
+#if GCC_VERSION >= 40600
+/*
+ * Tell the optimizer that something else uses this function or variable.
+ */
+#define __visible       __attribute__((externally_visible))
+#endif
+
+/*
+ * GCC 'asm goto' miscompiles certain code sequences:
+ *
+ *   http://gcc.gnu.org/bugzilla/show_bug.cgi?id=58670
+ *
+ * Work it around via a compiler barrier quirk suggested by Jakub Jelinek.
+ *
+ * (asm goto is automatically volatile - the naming reflects this.)
+ */
+#define asm_volatile_goto(x...) do { asm goto(x); asm (""); } while (0)
+
+#ifdef CONFIG_ARCH_USE_BUILTIN_BSWAP
+#if GCC_VERSION >= 40400
+#define __HAVE_BUILTIN_BSWAP32__
+#define __HAVE_BUILTIN_BSWAP64__
+#endif
+#if GCC_VERSION >= 40800 || (defined(__powerpc__) && GCC_VERSION >= 40600)
+#define __HAVE_BUILTIN_BSWAP16__
+#endif
+#endif /* CONFIG_ARCH_USE_BUILTIN_BSWAP */
+
+#if GCC_VERSION >= 50000
+#define KASAN_ABI_VERSION 4
+#elif GCC_VERSION >= 40902
+#define KASAN_ABI_VERSION 3
+#endif
+
+#endif  /* gcc version >= 40000 specific checks */
 
 #if !defined(__noclone)
 #define __noclone       /* not needed */
@@ -129,5 +248,3 @@
  * code
  */
 #define uninitialized_var(x) x = x
-
-#define __always_inline         inline __attribute__((always_inline))
diff --git a/include/linux/compiler-gcc3.h b/include/linux/compiler-gcc3.h
deleted file mode 100644
index 7d89febe4d79..000000000000
--- a/include/linux/compiler-gcc3.h
+++ /dev/null
@@ -1,23 +0,0 @@
-#ifndef __LINUX_COMPILER_H
-#error "Please don't include <linux/compiler-gcc3.h> directly, include <linux/compiler.h> instead."
-#endif
-
-#if GCC_VERSION < 30200
-# error Sorry, your compiler is too old - please upgrade it.
-#endif
-
-#if GCC_VERSION >= 30300
-# define __used                 __attribute__((__used__))
-#else
-# define __used                 __attribute__((__unused__))
-#endif
-
-#if GCC_VERSION >= 30400
-#define __must_check            __attribute__((warn_unused_result))
-#endif
-
-#ifdef CONFIG_GCOV_KERNEL
-# if GCC_VERSION < 30400
-#   error "GCOV profiling support for gcc versions below 3.4 not included"
-# endif /* __GNUC_MINOR__ */
-#endif /* CONFIG_GCOV_KERNEL */
diff --git a/include/linux/compiler-gcc4.h b/include/linux/compiler-gcc4.h
deleted file mode 100644
index 769e19864632..000000000000
--- a/include/linux/compiler-gcc4.h
+++ /dev/null
@@ -1,91 +0,0 @@
-#ifndef __LINUX_COMPILER_H
-#error "Please don't include <linux/compiler-gcc4.h> directly, include <linux/compiler.h> instead."
-#endif
-
-/* GCC 4.1.[01] miscompiles __weak */
-#ifdef __KERNEL__
-# if GCC_VERSION >= 40100 &&  GCC_VERSION <= 40101
-#  error Your version of gcc miscompiles the __weak directive
-# endif
-#endif
-
-#define __used                  __attribute__((__used__))
-#define __must_check            __attribute__((warn_unused_result))
-#define __compiler_offsetof(a,b) __builtin_offsetof(a,b)
-
-#if GCC_VERSION >= 40100 && GCC_VERSION < 40600
-# define __compiletime_object_size(obj) __builtin_object_size(obj, 0)
-#endif
-
-#if GCC_VERSION >= 40300
-/* Mark functions as cold. gcc will assume any path leading to a call
-   to them will be unlikely.  This means a lot of manual unlikely()s
-   are unnecessary now for any paths leading to the usual suspects
-   like BUG(), printk(), panic() etc. [but let's keep them for now for
-   older compilers]
-
-   Early snapshots of gcc 4.3 don't support this and we can't detect this
-   in the preprocessor, but we can live with this because they're unreleased.
-   Maketime probing would be overkill here.
-
-   gcc also has a __attribute__((__hot__)) to move hot functions into
-   a special section, but I don't see any sense in this right now in
-   the kernel context */
-#define __cold                  __attribute__((__cold__))
-
-#define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __COUNTER__)
-
-#ifndef __CHECKER__
-# define __compiletime_warning(message) __attribute__((warning(message)))
-# define __compiletime_error(message) __attribute__((error(message)))
-#endif /* __CHECKER__ */
-#endif /* GCC_VERSION >= 40300 */
-
-#if GCC_VERSION >= 40500
-/*
- * Mark a position in code as unreachable.  This can be used to
- * suppress control flow warnings after asm blocks that transfer
- * control elsewhere.
- *
- * Early snapshots of gcc 4.5 don't support this and we can't detect
- * this in the preprocessor, but we can live with this because they're
- * unreleased.  Really, we need to have autoconf for the kernel.
- */
-#define unreachable() __builtin_unreachable()
-
-/* Mark a function definition as prohibited from being cloned. */
-#define __noclone       __attribute__((__noclone__))
-
-#endif /* GCC_VERSION >= 40500 */
-
-#if GCC_VERSION >= 40600
-/*
- * Tell the optimizer that something else uses this function or variable.
- */
-#define __visible __attribute__((externally_visible))
-#endif
-
-/*
- * GCC 'asm goto' miscompiles certain code sequences:
- *
- *   http://gcc.gnu.org/bugzilla/show_bug.cgi?id=58670
- *
- * Work it around via a compiler barrier quirk suggested by Jakub Jelinek.
- *
- * (asm goto is automatically volatile - the naming reflects this.)
- */
-#define asm_volatile_goto(x...) do { asm goto(x); asm (""); } while (0)
-
-#ifdef CONFIG_ARCH_USE_BUILTIN_BSWAP
-#if GCC_VERSION >= 40400
-#define __HAVE_BUILTIN_BSWAP32__
-#define __HAVE_BUILTIN_BSWAP64__
-#endif
-#if GCC_VERSION >= 40800 || (defined(__powerpc__) && GCC_VERSION >= 40600)
-#define __HAVE_BUILTIN_BSWAP16__
-#endif
-#endif /* CONFIG_ARCH_USE_BUILTIN_BSWAP */
-
-#if GCC_VERSION >= 40902
-#define KASAN_ABI_VERSION 3
-#endif
diff --git a/include/linux/compiler-gcc5.h b/include/linux/compiler-gcc5.h
deleted file mode 100644
index efee493714eb..000000000000
--- a/include/linux/compiler-gcc5.h
+++ /dev/null
@@ -1,67 +0,0 @@
-#ifndef __LINUX_COMPILER_H
-#error "Please don't include <linux/compiler-gcc5.h> directly, include <linux/compiler.h> instead."
-#endif
-
-#define __used                          __attribute__((__used__))
-#define __must_check                    __attribute__((warn_unused_result))
-#define __compiler_offsetof(a, b)       __builtin_offsetof(a, b)
-
-/* Mark functions as cold. gcc will assume any path leading to a call
-   to them will be unlikely.  This means a lot of manual unlikely()s
-   are unnecessary now for any paths leading to the usual suspects
-   like BUG(), printk(), panic() etc. [but let's keep them for now for
-   older compilers]
-
-   Early snapshots of gcc 4.3 don't support this and we can't detect this
-   in the preprocessor, but we can live with this because they're unreleased.
-   Maketime probing would be overkill here.
-
-   gcc also has a __attribute__((__hot__)) to move hot functions into
-   a special section, but I don't see any sense in this right now in
-   the kernel context */
-#define __cold                  __attribute__((__cold__))
-
-#define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __COUNTER__)
-
-#ifndef __CHECKER__
-# define __compiletime_warning(message) __attribute__((warning(message)))
-# define __compiletime_error(message) __attribute__((error(message)))
-#endif /* __CHECKER__ */
-
-/*
- * Mark a position in code as unreachable.  This can be used to
- * suppress control flow warnings after asm blocks that transfer
- * control elsewhere.
- *
- * Early snapshots of gcc 4.5 don't support this and we can't detect
- * this in the preprocessor, but we can live with this because they're
- * unreleased.  Really, we need to have autoconf for the kernel.
- */
-#define unreachable() __builtin_unreachable()
-
-/* Mark a function definition as prohibited from being cloned. */
-#define __noclone       __attribute__((__noclone__))
-
-/*
- * Tell the optimizer that something else uses this function or variable.
- */
-#define __visible __attribute__((externally_visible))
-
-/*
- * GCC 'asm goto' miscompiles certain code sequences:
- *
- *   http://gcc.gnu.org/bugzilla/show_bug.cgi?id=58670
- *
- * Work it around via a compiler barrier quirk suggested by Jakub Jelinek.
- *
- * (asm goto is automatically volatile - the naming reflects this.)
- */
-#define asm_volatile_goto(x...) do { asm goto(x); asm (""); } while (0)
-
-#ifdef CONFIG_ARCH_USE_BUILTIN_BSWAP
-#define __HAVE_BUILTIN_BSWAP32__
-#define __HAVE_BUILTIN_BSWAP64__
-#define __HAVE_BUILTIN_BSWAP16__
-#endif /* CONFIG_ARCH_USE_BUILTIN_BSWAP */
-
-#define KASAN_ABI_VERSION 4
diff --git a/include/linux/compiler-intel.h b/include/linux/compiler-intel.h
index 0c9a2f2c2802..d4c71132d07f 100644
--- a/include/linux/compiler-intel.h
+++ b/include/linux/compiler-intel.h
@@ -13,10 +13,12 @@
 /* Intel ECC compiler doesn't support gcc specific asm stmts.
  * It uses intrinsics to do the equivalent things.
  */
+#undef barrier
 #undef barrier_data
 #undef RELOC_HIDE
 #undef OPTIMIZER_HIDE_VAR
 
+#define barrier() __memory_barrier()
 #define barrier_data(ptr) barrier()
 
 #define RELOC_HIDE(ptr, off)                                    \
diff --git a/include/linux/compiler.h b/include/linux/compiler.h
index 05be2352fef8..e08a6ae7c0a4 100644
--- a/include/linux/compiler.h
+++ b/include/linux/compiler.h
@@ -17,6 +17,7 @@
 # define __release(x)   __context__(x,-1)
 # define __cond_lock(x,c)       ((c) ? ({ __acquire(x); 1; }) : 0)
 # define __percpu       __attribute__((noderef, address_space(3)))
+# define __pmem         __attribute__((noderef, address_space(5)))
 #ifdef CONFIG_SPARSE_RCU_POINTER
 # define __rcu          __attribute__((noderef, address_space(4)))
 #else
@@ -42,6 +43,7 @@ extern void __chk_io_ptr(const volatile void __iomem *);
 # define __cond_lock(x,c) (c)
 # define __percpu
 # define __rcu
+# define __pmem
 #endif
 
 /* Indirect macros required for expanded argument pasting, eg. __LINE__. */
@@ -473,6 +475,21 @@ static __always_inline void __write_once_size(volatile void *p, void *res, int s
         (volatile typeof(x) *)&(x); })
 #define ACCESS_ONCE(x) (*__ACCESS_ONCE(x))
 
+/**
+ * lockless_dereference() - safely load a pointer for later dereference
+ * @p: The pointer to load
+ *
+ * Similar to rcu_dereference(), but for situations where the pointed-to
+ * object's lifetime is managed by something other than RCU.  That
+ * "something other" might be reference counting or simple immortality.
+ */
+#define lockless_dereference(p) \
+({ \
+        typeof(p) _________p1 = READ_ONCE(p); \
+        smp_read_barrier_depends(); /* Dependency order vs. p above. */ \
+        (_________p1); \
+})
+
 /* Ignore/forbid kprobes attach on very low level functions marked by this attribute: */
 #ifdef CONFIG_KPROBES
 # define __kprobes      __attribute__((__section__(".kprobes.text")))
diff --git a/include/linux/configfs.h b/include/linux/configfs.h
index 34025df61829..63a36e89d0eb 100644
--- a/include/linux/configfs.h
+++ b/include/linux/configfs.h
@@ -64,14 +64,14 @@ struct config_item {
         struct dentry           *ci_dentry;
 };
 
-extern int config_item_set_name(struct config_item *, const char *, ...);
+extern __printf(2, 3)
+int config_item_set_name(struct config_item *, const char *, ...);
 
 static inline char *config_item_name(struct config_item * item)
 {
         return item->ci_name;
 }
 
-extern void config_item_init(struct config_item *);
 extern void config_item_init_type_name(struct config_item *item,
                                        const char *name,
                                        struct config_item_type *type);
diff --git a/include/linux/console.h b/include/linux/console.h
index 9f50fb413c11..bd194343c346 100644
--- a/include/linux/console.h
+++ b/include/linux/console.h
@@ -115,6 +115,7 @@ static inline int con_debug_leave(void)
 #define CON_BOOT        (8)
 #define CON_ANYTIME     (16) /* Safe to call when cpu is offline */
 #define CON_BRL         (32) /* Used for a braille device */
+#define CON_EXTENDED    (64) /* Use the extended output format a la /dev/kmsg */
 
 struct console {
         char    name[16];
diff --git a/include/linux/console_struct.h b/include/linux/console_struct.h
index e859c98d1767..e329ee2667e1 100644
--- a/include/linux/console_struct.h
+++ b/include/linux/console_struct.h
@@ -104,6 +104,7 @@ struct vc_data {
         unsigned int    vc_resize_user;         /* resize request from user */
         unsigned int    vc_bell_pitch;          /* Console bell pitch */
         unsigned int    vc_bell_duration;       /* Console bell duration */
+        unsigned short  vc_cur_blink_ms;        /* Cursor blink duration */
         struct vc_data **vc_display_fg;         /* [!] Ptr to var holding fg console for this display */
         struct uni_pagedir *vc_uni_pagedir;
         struct uni_pagedir **vc_uni_pagedir_loc; /* [!] Location of uni_pagedir variable for this console */
diff --git a/include/linux/cper.h b/include/linux/cper.h
index 76abba4b238e..dcacb1a72e26 100644
--- a/include/linux/cper.h
+++ b/include/linux/cper.h
@@ -340,7 +340,27 @@ struct cper_ia_proc_ctx {
         __u64   mm_reg_addr;
 };
 
-/* Memory Error Section */
+/* Old Memory Error Section UEFI 2.1, 2.2 */
+struct cper_sec_mem_err_old {
+        __u64   validation_bits;
+        __u64   error_status;
+        __u64   physical_addr;
+        __u64   physical_addr_mask;
+        __u16   node;
+        __u16   card;
+        __u16   module;
+        __u16   bank;
+        __u16   device;
+        __u16   row;
+        __u16   column;
+        __u16   bit_pos;
+        __u64   requestor_id;
+        __u64   responder_id;
+        __u64   target_id;
+        __u8    error_type;
+};
+
+/* Memory Error Section UEFI >= 2.3 */
 struct cper_sec_mem_err {
         __u64   validation_bits;
         __u64   error_status;
diff --git a/include/linux/cpu.h b/include/linux/cpu.h
index c0fb6b1b4712..23c30bdcca86 100644
--- a/include/linux/cpu.h
+++ b/include/linux/cpu.h
@@ -40,9 +40,10 @@ extern void cpu_remove_dev_attr(struct device_attribute *attr);
 extern int cpu_add_dev_attr_group(struct attribute_group *attrs);
 extern void cpu_remove_dev_attr_group(struct attribute_group *attrs);
 
-extern struct device *cpu_device_create(struct device *parent, void *drvdata,
-                                        const struct attribute_group **groups,
-                                        const char *fmt, ...);
+extern __printf(4, 5)
+struct device *cpu_device_create(struct device *parent, void *drvdata,
+                                 const struct attribute_group **groups,
+                                 const char *fmt, ...);
 #ifdef CONFIG_HOTPLUG_CPU
 extern void unregister_cpu(struct cpu *cpu);
 extern ssize_t arch_cpu_probe(const char *, size_t);
diff --git a/include/linux/cpu_cooling.h b/include/linux/cpu_cooling.h
index bd955270d5aa..c156f5082758 100644
--- a/include/linux/cpu_cooling.h
+++ b/include/linux/cpu_cooling.h
@@ -28,6 +28,9 @@
 #include <linux/thermal.h>
 #include <linux/cpumask.h>
 
+typedef int (*get_static_t)(cpumask_t *cpumask, int interval,
+                            unsigned long voltage, u32 *power);
+
 #ifdef CONFIG_CPU_THERMAL
 /**
  * cpufreq_cooling_register - function to create cpufreq cooling device.
@@ -36,6 +39,10 @@
 struct thermal_cooling_device *
 cpufreq_cooling_register(const struct cpumask *clip_cpus);
 
+struct thermal_cooling_device *
+cpufreq_power_cooling_register(const struct cpumask *clip_cpus,
+                               u32 capacitance, get_static_t plat_static_func);
+
 /**
  * of_cpufreq_cooling_register - create cpufreq cooling device based on DT.
  * @np: a valid struct device_node to the cooling device device tree node.
@@ -45,6 +52,12 @@ cpufreq_cooling_register(const struct cpumask *clip_cpus);
 struct thermal_cooling_device *
 of_cpufreq_cooling_register(struct device_node *np,
                             const struct cpumask *clip_cpus);
+
+struct thermal_cooling_device *
+of_cpufreq_power_cooling_register(struct device_node *np,
+                                  const struct cpumask *clip_cpus,
+                                  u32 capacitance,
+                                  get_static_t plat_static_func);
 #else
 static inline struct thermal_cooling_device *
 of_cpufreq_cooling_register(struct device_node *np,
@@ -52,6 +65,15 @@ of_cpufreq_cooling_register(struct device_node *np,
 {
         return ERR_PTR(-ENOSYS);
 }
+
+static inline struct thermal_cooling_device *
+of_cpufreq_power_cooling_register(struct device_node *np,
+                                  const struct cpumask *clip_cpus,
+                                  u32 capacitance,
+                                  get_static_t plat_static_func)
+{
+        return NULL;
+}
 #endif
 
 /**
@@ -68,11 +90,28 @@ cpufreq_cooling_register(const struct cpumask *clip_cpus)
         return ERR_PTR(-ENOSYS);
 }
 static inline struct thermal_cooling_device *
+cpufreq_power_cooling_register(const struct cpumask *clip_cpus,
+                               u32 capacitance, get_static_t plat_static_func)
+{
+        return NULL;
+}
+
+static inline struct thermal_cooling_device *
 of_cpufreq_cooling_register(struct device_node *np,
                             const struct cpumask *clip_cpus)
 {
         return ERR_PTR(-ENOSYS);
 }
+
+static inline struct thermal_cooling_device *
+of_cpufreq_power_cooling_register(struct device_node *np,
+                                  const struct cpumask *clip_cpus,
+                                  u32 capacitance,
+                                  get_static_t plat_static_func)
+{
+        return NULL;
+}
+
 static inline
 void cpufreq_cooling_unregister(struct thermal_cooling_device *cdev)
 {
diff --git a/include/linux/cpufreq.h b/include/linux/cpufreq.h
index 2ee4888c1f47..bde1e567b3a9 100644
--- a/include/linux/cpufreq.h
+++ b/include/linux/cpufreq.h
@@ -62,10 +62,13 @@ struct cpufreq_policy {
         /* CPUs sharing clock, require sw coordination */
         cpumask_var_t           cpus;   /* Online CPUs only */
         cpumask_var_t           related_cpus; /* Online + Offline CPUs */
+        cpumask_var_t           real_cpus; /* Related and present */
 
         unsigned int            shared_type; /* ACPI: ANY or ALL affected CPUs
                                                 should set cpufreq */
-        unsigned int            cpu;    /* cpu nr of CPU managing this policy */
+        unsigned int            cpu;    /* cpu managing this policy, must be online */
+        unsigned int            kobj_cpu; /* cpu managing sysfs files, can be offline */
+
         struct clk              *clk;
         struct cpufreq_cpuinfo  cpuinfo;/* see above */
 
@@ -80,6 +83,7 @@ struct cpufreq_policy {
         struct cpufreq_governor *governor; /* see below */
         void                    *governor_data;
         bool                    governor_enabled; /* governor start/stop flag */
+        char                    last_governor[CPUFREQ_NAME_LEN]; /* last governor used */
 
         struct work_struct      update; /* if update_policy() needs to be
                                          * called, but you're in IRQ context */
diff --git a/include/linux/cpuidle.h b/include/linux/cpuidle.h
index 9c5e89254796..d075d34279df 100644
--- a/include/linux/cpuidle.h
+++ b/include/linux/cpuidle.h
@@ -151,10 +151,6 @@ extern void cpuidle_resume(void);
 extern int cpuidle_enable_device(struct cpuidle_device *dev);
 extern void cpuidle_disable_device(struct cpuidle_device *dev);
 extern int cpuidle_play_dead(void);
-extern int cpuidle_find_deepest_state(struct cpuidle_driver *drv,
-                                      struct cpuidle_device *dev);
-extern int cpuidle_enter_freeze(struct cpuidle_driver *drv,
-                                struct cpuidle_device *dev);
 
 extern struct cpuidle_driver *cpuidle_get_cpu_driver(struct cpuidle_device *dev);
 #else
@@ -190,16 +186,28 @@ static inline int cpuidle_enable_device(struct cpuidle_device *dev)
 {return -ENODEV; }
 static inline void cpuidle_disable_device(struct cpuidle_device *dev) { }
 static inline int cpuidle_play_dead(void) {return -ENODEV; }
+static inline struct cpuidle_driver *cpuidle_get_cpu_driver(
+        struct cpuidle_device *dev) {return NULL; }
+#endif
+
+#if defined(CONFIG_CPU_IDLE) && defined(CONFIG_SUSPEND)
+extern int cpuidle_find_deepest_state(struct cpuidle_driver *drv,
+                                      struct cpuidle_device *dev);
+extern int cpuidle_enter_freeze(struct cpuidle_driver *drv,
+                                struct cpuidle_device *dev);
+#else
 static inline int cpuidle_find_deepest_state(struct cpuidle_driver *drv,
                                              struct cpuidle_device *dev)
 {return -ENODEV; }
 static inline int cpuidle_enter_freeze(struct cpuidle_driver *drv,
                                        struct cpuidle_device *dev)
 {return -ENODEV; }
-static inline struct cpuidle_driver *cpuidle_get_cpu_driver(
-        struct cpuidle_device *dev) {return NULL; }
 #endif
 
+/* kernel/sched/idle.c */
+extern void sched_idle_set_state(struct cpuidle_state *idle_state);
+extern void default_idle_call(void);
+
 #ifdef CONFIG_ARCH_NEEDS_CPU_IDLE_COUPLED
 void cpuidle_coupled_parallel_barrier(struct cpuidle_device *dev, atomic_t *a);
 #else
diff --git a/include/linux/crc-itu-t.h b/include/linux/crc-itu-t.h
index 84920f3cc83e..a9953c762eee 100644
--- a/include/linux/crc-itu-t.h
+++ b/include/linux/crc-itu-t.h
@@ -3,7 +3,7 @@
  *
  * Implements the standard CRC ITU-T V.41:
  *   Width 16
- *   Poly  0x0x1021 (x^16 + x^12 + x^15 + 1)
+ *   Poly  0x1021 (x^16 + x^12 + x^15 + 1)
  *   Init  0
  *
  * This source code is licensed under the GNU General Public License,
diff --git a/include/linux/crc-t10dif.h b/include/linux/crc-t10dif.h
index cf53d0773ce3..d81961e9e37d 100644
--- a/include/linux/crc-t10dif.h
+++ b/include/linux/crc-t10dif.h
@@ -9,5 +9,6 @@
 extern __u16 crc_t10dif_generic(__u16 crc, const unsigned char *buffer,
                                 size_t len);
 extern __u16 crc_t10dif(unsigned char const *, size_t);
+extern __u16 crc_t10dif_update(__u16 crc, unsigned char const *, size_t);
 
 #endif
diff --git a/include/linux/crush/crush.h b/include/linux/crush/crush.h
index 48a1a7d100f1..48b49305716b 100644
--- a/include/linux/crush/crush.h
+++ b/include/linux/crush/crush.h
@@ -1,7 +1,11 @@
 #ifndef CEPH_CRUSH_CRUSH_H
 #define CEPH_CRUSH_CRUSH_H
 
-#include <linux/types.h>
+#ifdef __KERNEL__
+# include <linux/types.h>
+#else
+# include "crush_compat.h"
+#endif
 
 /*
  * CRUSH is a pseudo-random data distribution algorithm that
@@ -20,7 +24,11 @@
 #define CRUSH_MAGIC 0x00010000ul   /* for detecting algorithm revisions */
 
 #define CRUSH_MAX_DEPTH 10  /* max crush hierarchy depth */
+#define CRUSH_MAX_RULESET (1<<8)  /* max crush ruleset number */
+#define CRUSH_MAX_RULES CRUSH_MAX_RULESET  /* should be the same as max rulesets */
 
+#define CRUSH_MAX_DEVICE_WEIGHT (100u * 0x10000u)
+#define CRUSH_MAX_BUCKET_WEIGHT (65535u * 0x10000u)
 
 #define CRUSH_ITEM_UNDEF  0x7ffffffe  /* undefined result (internal use only) */
 #define CRUSH_ITEM_NONE   0x7fffffff  /* no result */
@@ -108,6 +116,15 @@ enum {
 };
 extern const char *crush_bucket_alg_name(int alg);
 
+/*
+ * although tree was a legacy algorithm, it has been buggy, so
+ * exclude it.
+ */
+#define CRUSH_LEGACY_ALLOWED_BUCKET_ALGS (      \
+                (1 << CRUSH_BUCKET_UNIFORM) |   \
+                (1 << CRUSH_BUCKET_LIST) |      \
+                (1 << CRUSH_BUCKET_STRAW))
+
 struct crush_bucket {
         __s32 id;        /* this'll be negative */
         __u16 type;      /* non-zero; type=0 is reserved for devices */
@@ -174,7 +191,7 @@ struct crush_map {
         /* choose local attempts using a fallback permutation before
          * re-descent */
         __u32 choose_local_fallback_tries;
-        /* choose attempts before giving up */ 
+        /* choose attempts before giving up */
         __u32 choose_total_tries;
         /* attempt chooseleaf inner descent once for firstn mode; on
          * reject retry outer descent.  Note that this does *not*
@@ -187,6 +204,25 @@ struct crush_map {
          * that want to limit reshuffling, a value of 3 or 4 will make the
          * mappings line up a bit better with previous mappings. */
         __u8 chooseleaf_vary_r;
+
+#ifndef __KERNEL__
+        /*
+         * version 0 (original) of straw_calc has various flaws.  version 1
+         * fixes a few of them.
+         */
+        __u8 straw_calc_version;
+
+        /*
+         * allowed bucket algs is a bitmask, here the bit positions
+         * are CRUSH_BUCKET_*.  note that these are *bits* and
+         * CRUSH_BUCKET_* values are not, so we need to or together (1
+         * << CRUSH_BUCKET_WHATEVER).  The 0th bit is not used to
+         * minimize confusion (bucket type values start at 1).
+         */
+        __u32 allowed_bucket_algs;
+
+        __u32 *choose_tries;
+#endif
 };
 
 
diff --git a/include/linux/crush/hash.h b/include/linux/crush/hash.h
index 91e884230d5d..d1d90258242e 100644
--- a/include/linux/crush/hash.h
+++ b/include/linux/crush/hash.h
@@ -1,6 +1,12 @@
 #ifndef CEPH_CRUSH_HASH_H
 #define CEPH_CRUSH_HASH_H
 
+#ifdef __KERNEL__
+# include <linux/types.h>
+#else
+# include "crush_compat.h"
+#endif
+
 #define CRUSH_HASH_RJENKINS1   0
 
 #define CRUSH_HASH_DEFAULT CRUSH_HASH_RJENKINS1
diff --git a/include/linux/crush/mapper.h b/include/linux/crush/mapper.h
index eab367446eea..5dfd5b1125d2 100644
--- a/include/linux/crush/mapper.h
+++ b/include/linux/crush/mapper.h
@@ -8,7 +8,7 @@
  * LGPL2
  */
 
-#include <linux/crush/crush.h>
+#include "crush.h"
 
 extern int crush_find_rule(const struct crush_map *map, int ruleset, int type, int size);
 extern int crush_do_rule(const struct crush_map *map,
diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index df334cbacc6d..d67ae119cf4e 100644
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -160,6 +160,7 @@ struct dentry_operations {
         char *(*d_dname)(struct dentry *, char *, int);
         struct vfsmount *(*d_automount)(struct path *);
         int (*d_manage)(struct dentry *, bool);
+        struct inode *(*d_select_inode)(struct dentry *, unsigned);
 } ____cacheline_aligned;
 
 /*
@@ -225,6 +226,7 @@ struct dentry_operations {
 
 #define DCACHE_MAY_FREE                 0x00800000
 #define DCACHE_FALLTHRU                 0x01000000 /* Fall through to lower layer */
+#define DCACHE_OP_SELECT_INODE          0x02000000 /* Unioned entry: dcache op selects inode */
 
 extern seqlock_t rename_lock;
 
@@ -325,7 +327,8 @@ static inline unsigned d_count(const struct dentry *dentry)
 /*
  * helper function for dentry_operations.d_dname() members
  */
-extern char *dynamic_dname(struct dentry *, char *, int, const char *, ...);
+extern __printf(4, 5)
+char *dynamic_dname(struct dentry *, char *, int, const char *, ...);
 extern char *simple_dname(struct dentry *, char *, int);
 
 extern char *__d_path(const struct path *, const struct path *, char *, int);
@@ -505,6 +508,11 @@ static inline bool d_really_is_positive(const struct dentry *dentry)
         return dentry->d_inode != NULL;
 }
 
+static inline int simple_positive(struct dentry *dentry)
+{
+        return d_really_is_positive(dentry) && !d_unhashed(dentry);
+}
+
 extern void d_set_fallthru(struct dentry *dentry);
 
 static inline bool d_is_fallthru(const struct dentry *dentry)
diff --git a/include/linux/device.h b/include/linux/device.h
index 6558af90c8fe..a2b4ea70a946 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -196,12 +196,41 @@ extern struct kset *bus_get_kset(struct bus_type *bus);
 extern struct klist *bus_get_device_klist(struct bus_type *bus);
 
 /**
+ * enum probe_type - device driver probe type to try
+ *      Device drivers may opt in for special handling of their
+ *      respective probe routines. This tells the core what to
+ *      expect and prefer.
+ *
+ * @PROBE_DEFAULT_STRATEGY: Used by drivers that work equally well
+ *      whether probed synchronously or asynchronously.
+ * @PROBE_PREFER_ASYNCHRONOUS: Drivers for "slow" devices which
+ *      probing order is not essential for booting the system may
+ *      opt into executing their probes asynchronously.
+ * @PROBE_FORCE_SYNCHRONOUS: Use this to annotate drivers that need
+ *      their probe routines to run synchronously with driver and
+ *      device registration (with the exception of -EPROBE_DEFER
+ *      handling - re-probing always ends up being done asynchronously).
+ *
+ * Note that the end goal is to switch the kernel to use asynchronous
+ * probing by default, so annotating drivers with
+ * %PROBE_PREFER_ASYNCHRONOUS is a temporary measure that allows us
+ * to speed up boot process while we are validating the rest of the
+ * drivers.
+ */
+enum probe_type {
+        PROBE_DEFAULT_STRATEGY,
+        PROBE_PREFER_ASYNCHRONOUS,
+        PROBE_FORCE_SYNCHRONOUS,
+};
+
+/**
  * struct device_driver - The basic device driver structure
  * @name:       Name of the device driver.
  * @bus:        The bus which the device of this driver belongs to.
  * @owner:      The module owner.
  * @mod_name:   Used for built-in modules.
  * @suppress_bind_attrs: Disables bind/unbind via sysfs.
+ * @probe_type: Type of the probe (synchronous or asynchronous) to use.
  * @of_match_table: The open firmware table.
  * @acpi_match_table: The ACPI match table.
  * @probe:      Called to query the existence of a specific device,
@@ -235,6 +264,7 @@ struct device_driver {
         const char              *mod_name;      /* used for built-in modules */
 
         bool suppress_bind_attrs;       /* disables bind/unbind via sysfs */
+        enum probe_type probe_type;
 
         const struct of_device_id       *of_match_table;
         const struct acpi_device_id     *acpi_match_table;
@@ -607,8 +637,9 @@ extern int devres_release_group(struct device *dev, void *id);
 
 /* managed devm_k.alloc/kfree for device drivers */
 extern void *devm_kmalloc(struct device *dev, size_t size, gfp_t gfp);
-extern char *devm_kvasprintf(struct device *dev, gfp_t gfp, const char *fmt,
-                             va_list ap);
+extern __printf(3, 0)
+char *devm_kvasprintf(struct device *dev, gfp_t gfp, const char *fmt,
+                      va_list ap);
 extern __printf(3, 4)
 char *devm_kasprintf(struct device *dev, gfp_t gfp, const char *fmt, ...);
 static inline void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp)
@@ -975,17 +1006,16 @@ extern int __must_check device_bind_driver(struct device *dev);
 extern void device_release_driver(struct device *dev);
 extern int  __must_check device_attach(struct device *dev);
 extern int __must_check driver_attach(struct device_driver *drv);
+extern void device_initial_probe(struct device *dev);
 extern int __must_check device_reprobe(struct device *dev);
 
 /*
  * Easy functions for dynamically creating devices on the fly
  */
-extern struct device *device_create_vargs(struct class *cls,
-                                          struct device *parent,
-                                          dev_t devt,
-                                          void *drvdata,
-                                          const char *fmt,
-                                          va_list vargs);
+extern __printf(5, 0)
+struct device *device_create_vargs(struct class *cls, struct device *parent,
+                                   dev_t devt, void *drvdata,
+                                   const char *fmt, va_list vargs);
 extern __printf(5, 6)
 struct device *device_create(struct class *cls, struct device *parent,
                              dev_t devt, void *drvdata,
@@ -1269,4 +1299,26 @@ static void __exit __driver##_exit(void) \
 } \
 module_exit(__driver##_exit);
 
+/**
+ * builtin_driver() - Helper macro for drivers that don't do anything
+ * special in init and have no exit. This eliminates some boilerplate.
+ * Each driver may only use this macro once, and calling it replaces
+ * device_initcall (or in some cases, the legacy __initcall).  This is
+ * meant to be a direct parallel of module_driver() above but without
+ * the __exit stuff that is not used for builtin cases.
+ *
+ * @__driver: driver name
+ * @__register: register function for this driver type
+ * @...: Additional arguments to be passed to __register
+ *
+ * Use this macro to construct bus specific macros for registering
+ * drivers, and do not use it on its own.
+ */
+#define builtin_driver(__driver, __register, ...) \
+static int __init __driver##_init(void) \
+{ \
+        return __register(&(__driver) , ##__VA_ARGS__); \
+} \
+device_initcall(__driver##_init);
+
 #endif /* _DEVICE_H_ */
diff --git a/include/linux/dma-buf.h b/include/linux/dma-buf.h
index 2f0b431b73e0..f98bd7068d55 100644
--- a/include/linux/dma-buf.h
+++ b/include/linux/dma-buf.h
@@ -115,6 +115,8 @@ struct dma_buf_ops {
  * @attachments: list of dma_buf_attachment that denotes all devices attached.
  * @ops: dma_buf_ops associated with this buffer object.
  * @exp_name: name of the exporter; useful for debugging.
+ * @owner: pointer to exporter module; used for refcounting when exporter is a
+ *         kernel module.
  * @list_node: node for dma_buf accounting and debugging.
  * @priv: exporter specific private data for this buffer object.
  * @resv: reservation object linked to this dma-buf
@@ -129,6 +131,7 @@ struct dma_buf {
         unsigned vmapping_counter;
         void *vmap_ptr;
         const char *exp_name;
+        struct module *owner;
         struct list_head list_node;
         void *priv;
         struct reservation_object *resv;
@@ -164,7 +167,8 @@ struct dma_buf_attachment {
 
 /**
  * struct dma_buf_export_info - holds information needed to export a dma_buf
- * @exp_name:   name of the exporting module - useful for debugging.
+ * @exp_name:   name of the exporter - useful for debugging.
+ * @owner:      pointer to exporter module - used for refcounting kernel module
  * @ops:        Attach allocator-defined dma buf ops to the new buffer
  * @size:       Size of the buffer
  * @flags:      mode flags for the file
@@ -176,6 +180,7 @@ struct dma_buf_attachment {
  */
 struct dma_buf_export_info {
         const char *exp_name;
+        struct module *owner;
         const struct dma_buf_ops *ops;
         size_t size;
         int flags;
@@ -187,7 +192,8 @@ struct dma_buf_export_info {
  * helper macro for exporters; zeros and fills in most common values
  */
 #define DEFINE_DMA_BUF_EXPORT_INFO(a)   \
-        struct dma_buf_export_info a = { .exp_name = KBUILD_MODNAME }
+        struct dma_buf_export_info a = { .exp_name = KBUILD_MODNAME, \
+                                         .owner = THIS_MODULE }
 
 /**
  * get_dma_buf - convenience wrapper for get_file.
diff --git a/include/linux/dma/pxa-dma.h b/include/linux/dma/pxa-dma.h
new file mode 100644
index 000000000000..3edc99294bf6
--- /dev/null
+++ b/include/linux/dma/pxa-dma.h
@@ -0,0 +1,27 @@
+#ifndef _PXA_DMA_H_
+#define _PXA_DMA_H_
+
+enum pxad_chan_prio {
+        PXAD_PRIO_HIGHEST = 0,
+        PXAD_PRIO_NORMAL,
+        PXAD_PRIO_LOW,
+        PXAD_PRIO_LOWEST,
+};
+
+struct pxad_param {
+        unsigned int drcmr;
+        enum pxad_chan_prio prio;
+};
+
+struct dma_chan;
+
+#ifdef CONFIG_PXA_DMA
+bool pxad_filter_fn(struct dma_chan *chan, void *param);
+#else
+static inline bool pxad_filter_fn(struct dma_chan *chan, void *param)
+{
+        return false;
+}
+#endif
+
+#endif /* _PXA_DMA_H_ */
diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h
index ad419757241f..e2f5eb419976 100644
--- a/include/linux/dmaengine.h
+++ b/include/linux/dmaengine.h
@@ -65,6 +65,7 @@ enum dma_transaction_type {
         DMA_PQ,
         DMA_XOR_VAL,
         DMA_PQ_VAL,
+        DMA_MEMSET,
         DMA_INTERRUPT,
         DMA_SG,
         DMA_PRIVATE,
@@ -122,10 +123,18 @@ enum dma_transfer_direction {
  *       chunk and before first src/dst address for next chunk.
  *       Ignored for dst(assumed 0), if dst_inc is true and dst_sgl is false.
  *       Ignored for src(assumed 0), if src_inc is true and src_sgl is false.
+ * @dst_icg: Number of bytes to jump after last dst address of this
+ *       chunk and before the first dst address for next chunk.
+ *       Ignored if dst_inc is true and dst_sgl is false.
+ * @src_icg: Number of bytes to jump after last src address of this
+ *       chunk and before the first src address for next chunk.
+ *       Ignored if src_inc is true and src_sgl is false.
  */
 struct data_chunk {
         size_t size;
         size_t icg;
+        size_t dst_icg;
+        size_t src_icg;
 };
 
 /**
@@ -222,6 +231,16 @@ struct dma_chan_percpu {
 };
 
 /**
+ * struct dma_router - DMA router structure
+ * @dev: pointer to the DMA router device
+ * @route_free: function to be called when the route can be disconnected
+ */
+struct dma_router {
+        struct device *dev;
+        void (*route_free)(struct device *dev, void *route_data);
+};
+
+/**
  * struct dma_chan - devices supply DMA channels, clients use them
  * @device: ptr to the dma device who supplies this channel, always !%NULL
  * @cookie: last cookie value returned to client
@@ -232,6 +251,8 @@ struct dma_chan_percpu {
  * @local: per-cpu pointer to a struct dma_chan_percpu
  * @client_count: how many clients are using this channel
  * @table_count: number of appearances in the mem-to-mem allocation table
+ * @router: pointer to the DMA router structure
+ * @route_data: channel specific data for the router
  * @private: private data for certain client-channel associations
  */
 struct dma_chan {
@@ -247,6 +268,11 @@ struct dma_chan {
         struct dma_chan_percpu __percpu *local;
         int client_count;
         int table_count;
+
+        /* DMA router */
+        struct dma_router *router;
+        void *route_data;
+
         void *private;
 };
 
@@ -570,6 +596,7 @@ struct dma_tx_state {
  * @copy_align: alignment shift for memcpy operations
  * @xor_align: alignment shift for xor operations
  * @pq_align: alignment shift for pq operations
+ * @fill_align: alignment shift for memset operations
  * @dev_id: unique device ID
  * @dev: struct device reference for dma mapping api
  * @src_addr_widths: bit mask of src addr widths the device supports
@@ -588,6 +615,7 @@ struct dma_tx_state {
  * @device_prep_dma_xor_val: prepares a xor validation operation
  * @device_prep_dma_pq: prepares a pq operation
  * @device_prep_dma_pq_val: prepares a pqzero_sum operation
+ * @device_prep_dma_memset: prepares a memset operation
  * @device_prep_dma_interrupt: prepares an end of chain interrupt operation
  * @device_prep_slave_sg: prepares a slave dma operation
  * @device_prep_dma_cyclic: prepare a cyclic dma operation suitable for audio.
@@ -620,6 +648,7 @@ struct dma_device {
         u8 copy_align;
         u8 xor_align;
         u8 pq_align;
+        u8 fill_align;
         #define DMA_HAS_PQ_CONTINUE (1 << 15)
 
         int dev_id;
@@ -650,6 +679,9 @@ struct dma_device {
                 struct dma_chan *chan, dma_addr_t *pq, dma_addr_t *src,
                 unsigned int src_cnt, const unsigned char *scf, size_t len,
                 enum sum_check_flags *pqres, unsigned long flags);
+        struct dma_async_tx_descriptor *(*device_prep_dma_memset)(
+                struct dma_chan *chan, dma_addr_t dest, int value, size_t len,
+                unsigned long flags);
         struct dma_async_tx_descriptor *(*device_prep_dma_interrupt)(
                 struct dma_chan *chan, unsigned long flags);
         struct dma_async_tx_descriptor *(*device_prep_dma_sg)(
@@ -745,6 +777,17 @@ static inline struct dma_async_tx_descriptor *dmaengine_prep_interleaved_dma(
         return chan->device->device_prep_interleaved_dma(chan, xt, flags);
 }
 
+static inline struct dma_async_tx_descriptor *dmaengine_prep_dma_memset(
+                struct dma_chan *chan, dma_addr_t dest, int value, size_t len,
+                unsigned long flags)
+{
+        if (!chan || !chan->device)
+                return NULL;
+
+        return chan->device->device_prep_dma_memset(chan, dest, value,
+                                                    len, flags);
+}
+
 static inline struct dma_async_tx_descriptor *dmaengine_prep_dma_sg(
                 struct dma_chan *chan,
                 struct scatterlist *dst_sg, unsigned int dst_nents,
@@ -820,6 +863,12 @@ static inline bool is_dma_pq_aligned(struct dma_device *dev, size_t off1,
         return dmaengine_check_align(dev->pq_align, off1, off2, len);
 }
 
+static inline bool is_dma_fill_aligned(struct dma_device *dev, size_t off1,
+                                       size_t off2, size_t len)
+{
+        return dmaengine_check_align(dev->fill_align, off1, off2, len);
+}
+
 static inline void
 dma_set_maxpq(struct dma_device *dma, int maxpq, int has_pq_continue)
 {
@@ -874,6 +923,33 @@ static inline int dma_maxpq(struct dma_device *dma, enum dma_ctrl_flags flags)
         BUG();
 }
 
+static inline size_t dmaengine_get_icg(bool inc, bool sgl, size_t icg,
+                                      size_t dir_icg)
+{
+        if (inc) {
+                if (dir_icg)
+                        return dir_icg;
+                else if (sgl)
+                        return icg;
+        }
+
+        return 0;
+}
+
+static inline size_t dmaengine_get_dst_icg(struct dma_interleaved_template *xt,
+                                           struct data_chunk *chunk)
+{
+        return dmaengine_get_icg(xt->dst_inc, xt->dst_sgl,
+                                 chunk->icg, chunk->dst_icg);
+}
+
+static inline size_t dmaengine_get_src_icg(struct dma_interleaved_template *xt,
+                                           struct data_chunk *chunk)
+{
+        return dmaengine_get_icg(xt->src_inc, xt->src_sgl,
+                                 chunk->icg, chunk->src_icg);
+}
+
 /* --- public DMA engine API --- */
 
 #ifdef CONFIG_DMA_ENGINE
diff --git a/include/linux/dmapool.h b/include/linux/dmapool.h
index 52456aa566a0..e1043f79122f 100644
--- a/include/linux/dmapool.h
+++ b/include/linux/dmapool.h
@@ -11,8 +11,8 @@
 #ifndef LINUX_DMAPOOL_H
 #define LINUX_DMAPOOL_H
 
+#include <linux/scatterlist.h>
 #include <asm/io.h>
-#include <asm/scatterlist.h>
 
 struct device;
 
diff --git a/include/linux/dmi.h b/include/linux/dmi.h
index f820f0a336c9..5055ac34142d 100644
--- a/include/linux/dmi.h
+++ b/include/linux/dmi.h
@@ -2,6 +2,7 @@
 #define __DMI_H__
 
 #include <linux/list.h>
+#include <linux/kobject.h>
 #include <linux/mod_devicetable.h>
 
 /* enum dmi_field is in mod_devicetable.h */
@@ -74,7 +75,7 @@ struct dmi_header {
         u8 type;
         u8 length;
         u16 handle;
-};
+} __packed;
 
 struct dmi_device {
         struct list_head list;
@@ -93,6 +94,7 @@ struct dmi_dev_onboard {
         int devfn;
 };
 
+extern struct kobject *dmi_kobj;
 extern int dmi_check_system(const struct dmi_system_id *list);
 const struct dmi_system_id *dmi_first_match(const struct dmi_system_id *list);
 extern const char * dmi_get_system_info(int field);
diff --git a/include/linux/efi.h b/include/linux/efi.h
index 2092965afca3..85ef051ac6fb 100644
--- a/include/linux/efi.h
+++ b/include/linux/efi.h
@@ -85,7 +85,8 @@ typedef	struct {
 #define EFI_MEMORY_MAPPED_IO            11
 #define EFI_MEMORY_MAPPED_IO_PORT_SPACE 12
 #define EFI_PAL_CODE                    13
-#define EFI_MAX_MEMORY_TYPE             14
+#define EFI_PERSISTENT_MEMORY           14
+#define EFI_MAX_MEMORY_TYPE             15
 
 /* Attribute values: */
 #define EFI_MEMORY_UC           ((u64)0x0000000000000001ULL)    /* uncached */
@@ -96,6 +97,8 @@ typedef	struct {
 #define EFI_MEMORY_WP           ((u64)0x0000000000001000ULL)    /* write-protect */
 #define EFI_MEMORY_RP           ((u64)0x0000000000002000ULL)    /* read-protect */
 #define EFI_MEMORY_XP           ((u64)0x0000000000004000ULL)    /* execute-protect */
+#define EFI_MEMORY_MORE_RELIABLE \
+                                ((u64)0x0000000000010000ULL)    /* higher reliability */
 #define EFI_MEMORY_RUNTIME      ((u64)0x8000000000000000ULL)    /* range requires runtime mapping */
 #define EFI_MEMORY_DESCRIPTOR_VERSION   1
 
@@ -868,6 +871,7 @@ extern void efi_enter_virtual_mode (void);	/* switch EFI to virtual mode, if pos
 extern void efi_late_init(void);
 extern void efi_free_boot_services(void);
 extern efi_status_t efi_query_variable_store(u32 attributes, unsigned long size);
+extern void efi_find_mirror(void);
 #else
 static inline void efi_late_init(void) {}
 static inline void efi_free_boot_services(void) {}
diff --git a/include/linux/elevator.h b/include/linux/elevator.h
index 45a91474487d..638b324f0291 100644
--- a/include/linux/elevator.h
+++ b/include/linux/elevator.h
@@ -39,6 +39,7 @@ typedef void (elevator_deactivate_req_fn) (struct request_queue *, struct reques
 typedef int (elevator_init_fn) (struct request_queue *,
                                 struct elevator_type *e);
 typedef void (elevator_exit_fn) (struct elevator_queue *);
+typedef void (elevator_registered_fn) (struct request_queue *);
 
 struct elevator_ops
 {
@@ -68,6 +69,7 @@ struct elevator_ops
 
         elevator_init_fn *elevator_init_fn;
         elevator_exit_fn *elevator_exit_fn;
+        elevator_registered_fn *elevator_registered_fn;
 };
 
 #define ELV_NAME_MAX    (16)
diff --git a/include/linux/etherdevice.h b/include/linux/etherdevice.h
index 606563ef8a72..9012f8775208 100644
--- a/include/linux/etherdevice.h
+++ b/include/linux/etherdevice.h
@@ -110,7 +110,29 @@ static inline bool is_zero_ether_addr(const u8 *addr)
  */
 static inline bool is_multicast_ether_addr(const u8 *addr)
 {
-        return 0x01 & addr[0];
+#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)
+        u32 a = *(const u32 *)addr;
+#else
+        u16 a = *(const u16 *)addr;
+#endif
+#ifdef __BIG_ENDIAN
+        return 0x01 & (a >> ((sizeof(a) * 8) - 8));
+#else
+        return 0x01 & a;
+#endif
+}
+
+static inline bool is_multicast_ether_addr_64bits(const u8 addr[6+2])
+{
+#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64
+#ifdef __BIG_ENDIAN
+        return 0x01 & ((*(const u64 *)addr) >> 56);
+#else
+        return 0x01 & (*(const u64 *)addr);
+#endif
+#else
+        return is_multicast_ether_addr(addr);
+#endif
 }
 
 /**
@@ -169,6 +191,24 @@ static inline bool is_valid_ether_addr(const u8 *addr)
 }
 
 /**
+ * eth_proto_is_802_3 - Determine if a given Ethertype/length is a protocol
+ * @proto: Ethertype/length value to be tested
+ *
+ * Check that the value from the Ethertype/length field is a valid Ethertype.
+ *
+ * Return true if the valid is an 802.3 supported Ethertype.
+ */
+static inline bool eth_proto_is_802_3(__be16 proto)
+{
+#ifndef __BIG_ENDIAN
+        /* if CPU is little endian mask off bits representing LSB */
+        proto &= htons(0xFF00);
+#endif
+        /* cast both to u16 and compare since LSB can be ignored */
+        return (__force u16)proto >= (__force u16)htons(ETH_P_802_3_MIN);
+}
+
+/**
  * eth_random_addr - Generate software assigned random Ethernet address
  * @addr: Pointer to a six-byte array containing the Ethernet address
  *
diff --git a/include/linux/extcon.h b/include/linux/extcon.h
index 36f49c405dfb..b16d929fa75f 100644
--- a/include/linux/extcon.h
+++ b/include/linux/extcon.h
@@ -1,6 +1,9 @@
 /*
  *  External connector (extcon) class driver
  *
+ * Copyright (C) 2015 Samsung Electronics
+ * Author: Chanwoo Choi <cw00.choi@samsung.com>
+ *
  * Copyright (C) 2012 Samsung Electronics
  * Author: Donggeun Kim <dg77.kim@samsung.com>
  * Author: MyungJoo Ham <myungjoo.ham@samsung.com>
@@ -27,50 +30,35 @@
 #include <linux/notifier.h>
 #include <linux/sysfs.h>
 
-#define SUPPORTED_CABLE_MAX     32
-#define CABLE_NAME_MAX          30
-
 /*
- * The standard cable name is to help support general notifier
- * and notifiee device drivers to share the common names.
- * Please use standard cable names unless your notifier device has
- * a very unique and abnormal cable or
- * the cable type is supposed to be used with only one unique
- * pair of notifier/notifiee devices.
- *
- * Please add any other "standard" cables used with extcon dev.
- *
- * You may add a dot and number to specify version or specification
- * of the specific cable if it is required. (e.g., "Fast-charger.18"
- * and "Fast-charger.10" for 1.8A and 1.0A chargers)
- * However, the notifiee and notifier should be able to handle such
- * string and if the notifiee can negotiate the protocol or identify,
- * you don't need such convention. This convention is helpful when
- * notifier can distinguish but notifiee cannot.
+ * Define the unique id of supported external connectors
  */
-enum extcon_cable_name {
-        EXTCON_USB = 0,
-        EXTCON_USB_HOST,
-        EXTCON_TA,                      /* Travel Adaptor */
-        EXTCON_FAST_CHARGER,
-        EXTCON_SLOW_CHARGER,
-        EXTCON_CHARGE_DOWNSTREAM,       /* Charging an external device */
-        EXTCON_HDMI,
-        EXTCON_MHL,
-        EXTCON_DVI,
-        EXTCON_VGA,
-        EXTCON_DOCK,
-        EXTCON_LINE_IN,
-        EXTCON_LINE_OUT,
-        EXTCON_MIC_IN,
-        EXTCON_HEADPHONE_OUT,
-        EXTCON_SPDIF_IN,
-        EXTCON_SPDIF_OUT,
-        EXTCON_VIDEO_IN,
-        EXTCON_VIDEO_OUT,
-        EXTCON_MECHANICAL,
-};
-extern const char extcon_cable_name[][CABLE_NAME_MAX + 1];
+#define EXTCON_NONE                     0
+
+#define EXTCON_USB                      1       /* USB connector */
+#define EXTCON_USB_HOST                 2
+
+#define EXTCON_TA                       3       /* Charger connector */
+#define EXTCON_FAST_CHARGER             4
+#define EXTCON_SLOW_CHARGER             5
+#define EXTCON_CHARGE_DOWNSTREAM        6
+
+#define EXTCON_LINE_IN                  7       /* Audio/Video connector */
+#define EXTCON_LINE_OUT                 8
+#define EXTCON_MICROPHONE               9
+#define EXTCON_HEADPHONE                10
+#define EXTCON_HDMI                     11
+#define EXTCON_MHL                      12
+#define EXTCON_DVI                      13
+#define EXTCON_VGA                      14
+#define EXTCON_SPDIF_IN                 15
+#define EXTCON_SPDIF_OUT                16
+#define EXTCON_VIDEO_IN                 17
+#define EXTCON_VIDEO_OUT                18
+
+#define EXTCON_DOCK                     19      /* Misc connector */
+#define EXTCON_JIG                      20
+#define EXTCON_MECHANICAL               21
 
 struct extcon_cable;
 
@@ -78,7 +66,7 @@ struct extcon_cable;
  * struct extcon_dev - An extcon device represents one external connector.
  * @name:               The name of this extcon device. Parent device name is
  *                      used if NULL.
- * @supported_cable:    Array of supported cable names ending with NULL.
+ * @supported_cable:    Array of supported cable names ending with EXTCON_NONE.
  *                      If supported_cable is NULL, cable name related APIs
  *                      are disabled.
  * @mutually_exclusive: Array of mutually exclusive set of cables that cannot
@@ -89,16 +77,14 @@ struct extcon_cable;
  *                      be attached simulataneously. {0x7, 0} is equivalent to
  *                      {0x3, 0x6, 0x5, 0}. If it is {0xFFFFFFFF, 0}, there
  *                      can be no simultaneous connections.
- * @print_name:         An optional callback to override the method to print the
- *                      name of the extcon device.
  * @print_state:        An optional callback to override the method to print the
  *                      status of the extcon device.
  * @dev:                Device of this extcon.
  * @state:              Attach/detach state of this extcon. Do not provide at
  *                      register-time.
  * @nh:                 Notifier for the state change events from this extcon
- * @entry:              To support list of extcon devices so that users can search
- *                      for extcon devices based on the extcon name.
+ * @entry:              To support list of extcon devices so that users can
+ *                      search for extcon devices based on the extcon name.
  * @lock:
  * @max_supported:      Internal value to store the number of cables.
  * @extcon_dev_type:    Device_type struct to provide attribute_groups
@@ -113,16 +99,15 @@ struct extcon_cable;
 struct extcon_dev {
         /* Optional user initializing data */
         const char *name;
-        const char **supported_cable;
+        const unsigned int *supported_cable;
         const u32 *mutually_exclusive;
 
         /* Optional callbacks to override class functions */
-        ssize_t (*print_name)(struct extcon_dev *edev, char *buf);
         ssize_t (*print_state)(struct extcon_dev *edev, char *buf);
 
         /* Internal data. Please do not set. */
         struct device dev;
-        struct raw_notifier_head nh;
+        struct raw_notifier_head *nh;
         struct list_head entry;
         int max_supported;
         spinlock_t lock;        /* could be called by irq handler */
@@ -161,8 +146,6 @@ struct extcon_cable {
 /**
  * struct extcon_specific_cable_nb - An internal data for
  *                                   extcon_register_interest().
- * @internal_nb:        A notifier block bridging extcon notifier
- *                      and cable notifier.
  * @user_nb:            user provided notifier block for events from
  *                      a specific cable.
  * @cable_index:        the target cable.
@@ -170,7 +153,6 @@ struct extcon_cable {
  * @previous_value:     the saved previous event value.
  */
 struct extcon_specific_cable_nb {
-        struct notifier_block internal_nb;
         struct notifier_block *user_nb;
         int cable_index;
         struct extcon_dev *edev;
@@ -194,10 +176,10 @@ extern struct extcon_dev *extcon_get_extcon_dev(const char *extcon_name);
 /*
  * Following APIs control the memory of extcon device.
  */
-extern struct extcon_dev *extcon_dev_allocate(const char **cables);
+extern struct extcon_dev *extcon_dev_allocate(const unsigned int *cable);
 extern void extcon_dev_free(struct extcon_dev *edev);
 extern struct extcon_dev *devm_extcon_dev_allocate(struct device *dev,
-                                                   const char **cables);
+                                                   const unsigned int *cable);
 extern void devm_extcon_dev_free(struct device *dev, struct extcon_dev *edev);
 
 /*
@@ -216,13 +198,10 @@ extern int extcon_update_state(struct extcon_dev *edev, u32 mask, u32 state);
 
 /*
  * get/set_cable_state access each bit of the 32b encoded state value.
- * They are used to access the status of each cable based on the cable_name
- * or cable_index, which is retrieved by extcon_find_cable_index
+ * They are used to access the status of each cable based on the cable_name.
  */
-extern int extcon_find_cable_index(struct extcon_dev *sdev,
-                                   const char *cable_name);
-extern int extcon_get_cable_state_(struct extcon_dev *edev, int cable_index);
-extern int extcon_set_cable_state_(struct extcon_dev *edev, int cable_index,
+extern int extcon_get_cable_state_(struct extcon_dev *edev, unsigned int id);
+extern int extcon_set_cable_state_(struct extcon_dev *edev, unsigned int id,
                                    bool cable_state);
 
 extern int extcon_get_cable_state(struct extcon_dev *edev,
@@ -249,16 +228,21 @@ extern int extcon_unregister_interest(struct extcon_specific_cable_nb *nb);
  * we do not recommend to use this for normal 'notifiee' device drivers who
  * want to be notified by a specific external port of the notifier.
  */
-extern int extcon_register_notifier(struct extcon_dev *edev,
+extern int extcon_register_notifier(struct extcon_dev *edev, unsigned int id,
+                                    struct notifier_block *nb);
+extern int extcon_unregister_notifier(struct extcon_dev *edev, unsigned int id,
                                     struct notifier_block *nb);
-extern int extcon_unregister_notifier(struct extcon_dev *edev,
-                                      struct notifier_block *nb);
 
 /*
  * Following API get the extcon device from devicetree.
  * This function use phandle of devicetree to get extcon device directly.
  */
-extern struct extcon_dev *extcon_get_edev_by_phandle(struct device *dev, int index);
+extern struct extcon_dev *extcon_get_edev_by_phandle(struct device *dev,
+                                                     int index);
+
+/* Following API to get information of extcon device */
+extern const char *extcon_get_edev_name(struct extcon_dev *edev);
+
 #else /* CONFIG_EXTCON */
 static inline int extcon_dev_register(struct extcon_dev *edev)
 {
@@ -276,7 +260,7 @@ static inline int devm_extcon_dev_register(struct device *dev,
 static inline void devm_extcon_dev_unregister(struct device *dev,
                                               struct extcon_dev *edev) { }
 
-static inline struct extcon_dev *extcon_dev_allocate(const char **cables)
+static inline struct extcon_dev *extcon_dev_allocate(const unsigned int *cable)
 {
         return ERR_PTR(-ENOSYS);
 }
@@ -284,7 +268,7 @@ static inline struct extcon_dev *extcon_dev_allocate(const char **cables)
 static inline void extcon_dev_free(struct extcon_dev *edev) { }
 
 static inline struct extcon_dev *devm_extcon_dev_allocate(struct device *dev,
-                                                          const char **cables)
+                                                const unsigned int *cable)
 {
         return ERR_PTR(-ENOSYS);
 }
@@ -307,20 +291,14 @@ static inline int extcon_update_state(struct extcon_dev *edev, u32 mask,
         return 0;
 }
 
-static inline int extcon_find_cable_index(struct extcon_dev *edev,
-                                          const char *cable_name)
-{
-        return 0;
-}
-
 static inline int extcon_get_cable_state_(struct extcon_dev *edev,
-                                          int cable_index)
+                                          unsigned int id)
 {
         return 0;
 }
 
 static inline int extcon_set_cable_state_(struct extcon_dev *edev,
-                                          int cable_index, bool cable_state)
+                                          unsigned int id, bool cable_state)
 {
         return 0;
 }
@@ -343,13 +321,15 @@ static inline struct extcon_dev *extcon_get_extcon_dev(const char *extcon_name)
 }
 
 static inline int extcon_register_notifier(struct extcon_dev *edev,
-                                           struct notifier_block *nb)
+                                        unsigned int id,
+                                        struct notifier_block *nb)
 {
         return 0;
 }
 
 static inline int extcon_unregister_notifier(struct extcon_dev *edev,
-                                             struct notifier_block *nb)
+                                        unsigned int id,
+                                        struct notifier_block *nb)
 {
         return 0;
 }
diff --git a/include/linux/extcon/extcon-adc-jack.h b/include/linux/extcon/extcon-adc-jack.h
index 9ca958c4e94c..53c60806bcfb 100644
--- a/include/linux/extcon/extcon-adc-jack.h
+++ b/include/linux/extcon/extcon-adc-jack.h
@@ -44,7 +44,7 @@ struct adc_jack_cond {
  * @consumer_channel:   Unique name to identify the channel on the consumer
  *                      side. This typically describes the channels used within
  *                      the consumer. E.g. 'battery_voltage'
- * @cable_names:        array of cable names ending with null.
+ * @cable_names:        array of extcon id for supported cables.
  * @adc_contitions:     array of struct adc_jack_cond conditions ending
  *                      with .state = 0 entry. This describes how to decode
  *                      adc values into extcon state.
@@ -58,8 +58,7 @@ struct adc_jack_pdata {
         const char *name;
         const char *consumer_channel;
 
-        /* The last entry should be NULL */
-        const char **cable_names;
+        const enum extcon *cable_names;
 
         /* The last entry's state should be 0 */
         struct adc_jack_cond *adc_conditions;
diff --git a/include/linux/f2fs_fs.h b/include/linux/f2fs_fs.h
index 591f8c3ef410..920408a21ffd 100644
--- a/include/linux/f2fs_fs.h
+++ b/include/linux/f2fs_fs.h
@@ -50,6 +50,8 @@
 #define MAX_ACTIVE_NODE_LOGS    8
 #define MAX_ACTIVE_DATA_LOGS    8
 
+#define VERSION_LEN     256
+
 /*
  * For superblock
  */
@@ -86,6 +88,12 @@ struct f2fs_super_block {
         __le32 extension_count;         /* # of extensions below */
         __u8 extension_list[F2FS_MAX_EXTENSION][8];     /* extension array */
         __le32 cp_payload;
+        __u8 version[VERSION_LEN];      /* the kernel version */
+        __u8 init_version[VERSION_LEN]; /* the initial kernel version */
+        __le32 feature;                 /* defined features */
+        __u8 encryption_level;          /* versioning level for encryption */
+        __u8 encrypt_pw_salt[16];       /* Salt used for string2key algorithm */
+        __u8 reserved[871];             /* valid reserved region */
 } __packed;
 
 /*
diff --git a/include/linux/fdtable.h b/include/linux/fdtable.h
index 230f87bdf5ad..fbb88740634a 100644
--- a/include/linux/fdtable.h
+++ b/include/linux/fdtable.h
@@ -47,6 +47,9 @@ struct files_struct {
    * read mostly part
    */
         atomic_t count;
+        bool resize_in_progress;
+        wait_queue_head_t resize_wait;
+
         struct fdtable __rcu *fdt;
         struct fdtable fdtab;
   /*
diff --git a/include/linux/filter.h b/include/linux/filter.h
index fa11b3a367be..17724f6ea983 100644
--- a/include/linux/filter.h
+++ b/include/linux/filter.h
@@ -207,6 +207,16 @@ struct bpf_prog_aux;
                 .off   = OFF,                                   \
                 .imm   = 0 })
 
+/* Atomic memory add, *(uint *)(dst_reg + off16) += src_reg */
+
+#define BPF_STX_XADD(SIZE, DST, SRC, OFF)                       \
+        ((struct bpf_insn) {                                    \
+                .code  = BPF_STX | BPF_SIZE(SIZE) | BPF_XADD,   \
+                .dst_reg = DST,                                 \
+                .src_reg = SRC,                                 \
+                .off   = OFF,                                   \
+                .imm   = 0 })
+
 /* Memory store, *(uint *) (dst_reg + off16) = imm32 */
 
 #define BPF_ST_MEM(SIZE, DST, OFF, IMM)                         \
@@ -267,6 +277,14 @@ struct bpf_prog_aux;
                 .off   = 0,                                     \
                 .imm   = 0 })
 
+/* Internal classic blocks for direct assignment */
+
+#define __BPF_STMT(CODE, K)                                     \
+        ((struct sock_filter) BPF_STMT(CODE, K))
+
+#define __BPF_JUMP(CODE, K, JT, JF)                             \
+        ((struct sock_filter) BPF_JUMP(CODE, K, JT, JF))
+
 #define bytes_to_bpf_size(bytes)                                \
 ({                                                              \
         int bpf_size = -EINVAL;                                 \
@@ -360,12 +378,9 @@ static inline void bpf_prog_unlock_ro(struct bpf_prog *fp)
 
 int sk_filter(struct sock *sk, struct sk_buff *skb);
 
-void bpf_prog_select_runtime(struct bpf_prog *fp);
+int bpf_prog_select_runtime(struct bpf_prog *fp);
 void bpf_prog_free(struct bpf_prog *fp);
 
-int bpf_convert_filter(struct sock_filter *prog, int len,
-                       struct bpf_insn *new_prog, int *new_len);
-
 struct bpf_prog *bpf_prog_alloc(unsigned int size, gfp_t gfp_extra_flags);
 struct bpf_prog *bpf_prog_realloc(struct bpf_prog *fp_old, unsigned int size,
                                   gfp_t gfp_extra_flags);
@@ -377,14 +392,17 @@ static inline void bpf_prog_unlock_free(struct bpf_prog *fp)
         __bpf_prog_free(fp);
 }
 
+typedef int (*bpf_aux_classic_check_t)(struct sock_filter *filter,
+                                       unsigned int flen);
+
 int bpf_prog_create(struct bpf_prog **pfp, struct sock_fprog_kern *fprog);
+int bpf_prog_create_from_user(struct bpf_prog **pfp, struct sock_fprog *fprog,
+                              bpf_aux_classic_check_t trans);
 void bpf_prog_destroy(struct bpf_prog *fp);
 
 int sk_attach_filter(struct sock_fprog *fprog, struct sock *sk);
 int sk_attach_bpf(u32 ufd, struct sock *sk);
 int sk_detach_filter(struct sock *sk);
-
-int bpf_check_classic(const struct sock_filter *filter, unsigned int flen);
 int sk_get_filter(struct sock *sk, struct sock_filter __user *filter,
                   unsigned int len);
 
diff --git a/include/linux/frontswap.h b/include/linux/frontswap.h
index 8293262401de..e65ef959546c 100644
--- a/include/linux/frontswap.h
+++ b/include/linux/frontswap.h
@@ -6,16 +6,16 @@
 #include <linux/bitops.h>
 
 struct frontswap_ops {
-        void (*init)(unsigned);
-        int (*store)(unsigned, pgoff_t, struct page *);
-        int (*load)(unsigned, pgoff_t, struct page *);
-        void (*invalidate_page)(unsigned, pgoff_t);
-        void (*invalidate_area)(unsigned);
+        void (*init)(unsigned); /* this swap type was just swapon'ed */
+        int (*store)(unsigned, pgoff_t, struct page *); /* store a page */
+        int (*load)(unsigned, pgoff_t, struct page *); /* load a page */
+        void (*invalidate_page)(unsigned, pgoff_t); /* page no longer needed */
+        void (*invalidate_area)(unsigned); /* swap type just swapoff'ed */
+        struct frontswap_ops *next; /* private pointer to next ops */
 };
 
 extern bool frontswap_enabled;
-extern struct frontswap_ops *
-        frontswap_register_ops(struct frontswap_ops *ops);
+extern void frontswap_register_ops(struct frontswap_ops *ops);
 extern void frontswap_shrink(unsigned long);
 extern unsigned long frontswap_curr_pages(void);
 extern void frontswap_writethrough(bool);
diff --git a/include/linux/fs.h b/include/linux/fs.h
index b577e801b4af..84b783f277f7 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -35,6 +35,7 @@
 #include <uapi/linux/fs.h>
 
 struct backing_dev_info;
+struct bdi_writeback;
 struct export_operations;
 struct hd_geometry;
 struct iovec;
@@ -54,7 +55,8 @@ struct vm_fault;
 
 extern void __init inode_init(void);
 extern void __init inode_init_early(void);
-extern void __init files_init(unsigned long);
+extern void __init files_init(void);
+extern void __init files_maxfiles_init(void);
 
 extern struct files_stat_struct files_stat;
 extern unsigned long get_max_files(void);
@@ -69,6 +71,7 @@ typedef int (get_block_t)(struct inode *inode, sector_t iblock,
                         struct buffer_head *bh_result, int create);
 typedef void (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
                         ssize_t bytes, void *private);
+typedef void (dax_iodone_t)(struct buffer_head *bh_map, int uptodate);
 
 #define MAY_EXEC                0x00000001
 #define MAY_WRITE               0x00000002
@@ -634,6 +637,14 @@ struct inode {
 
         struct hlist_node       i_hash;
         struct list_head        i_wb_list;      /* backing dev IO list */
+#ifdef CONFIG_CGROUP_WRITEBACK
+        struct bdi_writeback    *i_wb;          /* the associated cgroup wb */
+
+        /* foreign inode detection, see wbc_detach_inode() */
+        int                     i_wb_frn_winner;
+        u16                     i_wb_frn_avg_time;
+        u16                     i_wb_frn_history;
+#endif
         struct list_head        i_lru;          /* inode LRU list */
         struct list_head        i_sb_list;
         union {
@@ -1036,12 +1047,12 @@ extern void locks_remove_file(struct file *);
 extern void locks_release_private(struct file_lock *);
 extern void posix_test_lock(struct file *, struct file_lock *);
 extern int posix_lock_file(struct file *, struct file_lock *, struct file_lock *);
-extern int posix_lock_file_wait(struct file *, struct file_lock *);
+extern int posix_lock_inode_wait(struct inode *, struct file_lock *);
 extern int posix_unblock_lock(struct file_lock *);
 extern int vfs_test_lock(struct file *, struct file_lock *);
 extern int vfs_lock_file(struct file *, unsigned int, struct file_lock *, struct file_lock *);
 extern int vfs_cancel_lock(struct file *filp, struct file_lock *fl);
-extern int flock_lock_file_wait(struct file *filp, struct file_lock *fl);
+extern int flock_lock_inode_wait(struct inode *inode, struct file_lock *fl);
 extern int __break_lease(struct inode *inode, unsigned int flags, unsigned int type);
 extern void lease_get_mtime(struct inode *, struct timespec *time);
 extern int generic_setlease(struct file *, long, struct file_lock **, void **priv);
@@ -1127,7 +1138,8 @@ static inline int posix_lock_file(struct file *filp, struct file_lock *fl,
         return -ENOLCK;
 }
 
-static inline int posix_lock_file_wait(struct file *filp, struct file_lock *fl)
+static inline int posix_lock_inode_wait(struct inode *inode,
+                                        struct file_lock *fl)
 {
         return -ENOLCK;
 }
@@ -1153,8 +1165,8 @@ static inline int vfs_cancel_lock(struct file *filp, struct file_lock *fl)
         return 0;
 }
 
-static inline int flock_lock_file_wait(struct file *filp,
-                                       struct file_lock *request)
+static inline int flock_lock_inode_wait(struct inode *inode,
+                                        struct file_lock *request)
 {
         return -ENOLCK;
 }
@@ -1192,6 +1204,20 @@ static inline void show_fd_locks(struct seq_file *f,
                         struct file *filp, struct files_struct *files) {}
 #endif /* !CONFIG_FILE_LOCKING */
 
+static inline struct inode *file_inode(const struct file *f)
+{
+        return f->f_inode;
+}
+
+static inline int posix_lock_file_wait(struct file *filp, struct file_lock *fl)
+{
+        return posix_lock_inode_wait(file_inode(filp), fl);
+}
+
+static inline int flock_lock_file_wait(struct file *filp, struct file_lock *fl)
+{
+        return flock_lock_inode_wait(file_inode(filp), fl);
+}
 
 struct fasync_struct {
         spinlock_t              fa_lock;
@@ -1232,6 +1258,8 @@ struct mm_struct;
 #define UMOUNT_NOFOLLOW 0x00000008      /* Don't follow symlink on umount */
 #define UMOUNT_UNUSED   0x80000000      /* Flag guaranteed to be unused */
 
+/* sb->s_iflags */
+#define SB_I_CGROUPWB   0x00000001      /* cgroup-aware writeback enabled */
 
 /* Possible states of 'frozen' field */
 enum {
@@ -1270,6 +1298,7 @@ struct super_block {
         const struct quotactl_ops       *s_qcop;
         const struct export_operations *s_export_op;
         unsigned long           s_flags;
+        unsigned long           s_iflags;       /* internal SB_I_* flags */
         unsigned long           s_magic;
         struct dentry           *s_root;
         struct rw_semaphore     s_umount;
@@ -1641,7 +1670,6 @@ struct inode_operations {
         int (*set_acl)(struct inode *, struct posix_acl *, int);
 
         /* WARNING: probably going away soon, do not use! */
-        int (*dentry_open)(struct dentry *, struct file *, const struct cred *);
 } ____cacheline_aligned;
 
 ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
@@ -1806,6 +1834,11 @@ struct super_operations {
  *
  * I_DIO_WAKEUP         Never set.  Only used as a key for wait_on_bit().
  *
+ * I_WB_SWITCH          Cgroup bdi_writeback switching in progress.  Used to
+ *                      synchronize competing switching instances and to tell
+ *                      wb stat updates to grab mapping->tree_lock.  See
+ *                      inode_switch_wb_work_fn() for details.
+ *
  * Q: What is the difference between I_WILL_FREE and I_FREEING?
  */
 #define I_DIRTY_SYNC            (1 << 0)
@@ -1825,6 +1858,7 @@ struct super_operations {
 #define I_DIRTY_TIME            (1 << 11)
 #define __I_DIRTY_TIME_EXPIRED  12
 #define I_DIRTY_TIME_EXPIRED    (1 << __I_DIRTY_TIME_EXPIRED)
+#define I_WB_SWITCH             (1 << 13)
 
 #define I_DIRTY (I_DIRTY_SYNC | I_DIRTY_DATASYNC | I_DIRTY_PAGES)
 #define I_DIRTY_ALL (I_DIRTY | I_DIRTY_TIME)
@@ -1898,6 +1932,7 @@ struct file_system_type {
 #define FS_HAS_SUBTYPE          4
 #define FS_USERNS_MOUNT         8       /* Can be mounted by userns root */
 #define FS_USERNS_DEV_MOUNT     16 /* A userns mount does not imply MNT_NODEV */
+#define FS_USERNS_VISIBLE       32      /* FS must already be visible */
 #define FS_RENAME_DOES_D_MOVE   32768   /* FS will handle d_move() during rename() internally. */
         struct dentry *(*mount) (struct file_system_type *, int,
                        const char *, void *);
@@ -1985,7 +2020,6 @@ extern int vfs_ustat(dev_t, struct kstatfs *);
 extern int freeze_super(struct super_block *super);
 extern int thaw_super(struct super_block *super);
 extern bool our_mnt(struct vfsmount *mnt);
-extern bool fs_fully_visible(struct file_system_type *);
 
 extern int current_umask(void);
 
@@ -1993,11 +2027,6 @@ extern void ihold(struct inode * inode);
 extern void iput(struct inode *);
 extern int generic_update_time(struct inode *, struct timespec *, int);
 
-static inline struct inode *file_inode(const struct file *f)
-{
-        return f->f_inode;
-}
-
 /* /sys/fs */
 extern struct kobject *fs_kobj;
 
@@ -2194,7 +2223,6 @@ extern struct file *file_open_name(struct filename *, int, umode_t);
 extern struct file *filp_open(const char *, int, umode_t);
 extern struct file *file_open_root(struct dentry *, struct vfsmount *,
                                    const char *, int);
-extern int vfs_open(const struct path *, struct file *, const struct cred *);
 extern struct file * dentry_open(const struct path *, int, const struct cred *);
 extern int filp_close(struct file *, fl_owner_t id);
 
@@ -2218,7 +2246,7 @@ extern int ioctl_preallocate(struct file *filp, void __user *argp);
 
 /* fs/dcache.c */
 extern void __init vfs_caches_init_early(void);
-extern void __init vfs_caches_init(unsigned long);
+extern void __init vfs_caches_init(void);
 
 extern struct kmem_cache *names_cachep;
 
@@ -2241,7 +2269,13 @@ extern struct super_block *freeze_bdev(struct block_device *);
 extern void emergency_thaw_all(void);
 extern int thaw_bdev(struct block_device *bdev, struct super_block *sb);
 extern int fsync_bdev(struct block_device *);
-extern int sb_is_blkdev_sb(struct super_block *sb);
+
+extern struct super_block *blockdev_superblock;
+
+static inline bool sb_is_blkdev_sb(struct super_block *sb)
+{
+        return sb == blockdev_superblock;
+}
 #else
 static inline void bd_forget(struct inode *inode) {}
 static inline int sync_blockdev(struct block_device *bdev) { return 0; }
@@ -2280,6 +2314,9 @@ extern struct block_device *blkdev_get_by_path(const char *path, fmode_t mode,
 extern struct block_device *blkdev_get_by_dev(dev_t dev, fmode_t mode,
                                               void *holder);
 extern void blkdev_put(struct block_device *bdev, fmode_t mode);
+extern int __blkdev_reread_part(struct block_device *bdev);
+extern int blkdev_reread_part(struct block_device *bdev);
+
 #ifdef CONFIG_SYSFS
 extern int bd_link_disk_holder(struct block_device *bdev, struct gendisk *disk);
 extern void bd_unlink_disk_holder(struct block_device *bdev,
@@ -2502,6 +2539,8 @@ extern struct file * open_exec(const char *);
 extern int is_subdir(struct dentry *, struct dentry *);
 extern int path_is_under(struct path *, struct path *);
 
+extern char *file_path(struct file *, char *, int);
+
 #include <linux/err.h>
 
 /* needed for stackable file system support */
@@ -2553,7 +2592,12 @@ extern struct inode *new_inode_pseudo(struct super_block *sb);
 extern struct inode *new_inode(struct super_block *sb);
 extern void free_inode_nonrcu(struct inode *inode);
 extern int should_remove_suid(struct dentry *);
-extern int file_remove_suid(struct file *);
+extern int file_remove_privs(struct file *);
+extern int dentry_needs_remove_privs(struct dentry *dentry);
+static inline int file_needs_remove_privs(struct file *file)
+{
+        return dentry_needs_remove_privs(file->f_path.dentry);
+}
 
 extern void __insert_inode_hash(struct inode *, unsigned long hashval);
 static inline void insert_inode_hash(struct inode *inode)
@@ -2628,9 +2672,13 @@ ssize_t dax_do_io(struct kiocb *, struct inode *, struct iov_iter *, loff_t,
 int dax_clear_blocks(struct inode *, sector_t block, long size);
 int dax_zero_page_range(struct inode *, loff_t from, unsigned len, get_block_t);
 int dax_truncate_page(struct inode *, loff_t from, get_block_t);
-int dax_fault(struct vm_area_struct *, struct vm_fault *, get_block_t);
+int dax_fault(struct vm_area_struct *, struct vm_fault *, get_block_t,
+                dax_iodone_t);
+int __dax_fault(struct vm_area_struct *, struct vm_fault *, get_block_t,
+                dax_iodone_t);
 int dax_pfn_mkwrite(struct vm_area_struct *, struct vm_fault *);
-#define dax_mkwrite(vma, vmf, gb)       dax_fault(vma, vmf, gb)
+#define dax_mkwrite(vma, vmf, gb, iod)          dax_fault(vma, vmf, gb, iod)
+#define __dax_mkwrite(vma, vmf, gb, iod)        __dax_fault(vma, vmf, gb, iod)
 
 #ifdef CONFIG_BLOCK
 typedef void (dio_submit_t)(int rw, struct bio *bio, struct inode *inode,
@@ -2784,6 +2832,8 @@ extern struct dentry *simple_lookup(struct inode *, struct dentry *, unsigned in
 extern ssize_t generic_read_dir(struct file *, char __user *, size_t, loff_t *);
 extern const struct file_operations simple_dir_operations;
 extern const struct inode_operations simple_dir_inode_operations;
+extern void make_empty_dir_inode(struct inode *inode);
+extern bool is_empty_dir_inode(struct inode *inode);
 struct tree_descr { char *name; const struct file_operations *ops; int mode; };
 struct dentry *d_alloc_name(struct dentry *, const char *);
 extern int simple_fill_super(struct super_block *, unsigned long, struct tree_descr *);
diff --git a/include/linux/fscache-cache.h b/include/linux/fscache-cache.h
index 771484993ca7..604e1526cd00 100644
--- a/include/linux/fscache-cache.h
+++ b/include/linux/fscache-cache.h
@@ -74,6 +74,7 @@ extern wait_queue_head_t fscache_cache_cleared_wq;
  */
 typedef void (*fscache_operation_release_t)(struct fscache_operation *op);
 typedef void (*fscache_operation_processor_t)(struct fscache_operation *op);
+typedef void (*fscache_operation_cancel_t)(struct fscache_operation *op);
 
 enum fscache_operation_state {
         FSCACHE_OP_ST_BLANK,            /* Op is not yet submitted */
@@ -109,6 +110,9 @@ struct fscache_operation {
          *   the op in a non-pool thread */
         fscache_operation_processor_t processor;
 
+        /* Operation cancellation cleanup (optional) */
+        fscache_operation_cancel_t cancel;
+
         /* operation releaser */
         fscache_operation_release_t release;
 };
@@ -119,33 +123,17 @@ extern void fscache_op_work_func(struct work_struct *work);
 extern void fscache_enqueue_operation(struct fscache_operation *);
 extern void fscache_op_complete(struct fscache_operation *, bool);
 extern void fscache_put_operation(struct fscache_operation *);
-
-/**
- * fscache_operation_init - Do basic initialisation of an operation
- * @op: The operation to initialise
- * @release: The release function to assign
- *
- * Do basic initialisation of an operation.  The caller must still set flags,
- * object and processor if needed.
- */
-static inline void fscache_operation_init(struct fscache_operation *op,
-                                        fscache_operation_processor_t processor,
-                                        fscache_operation_release_t release)
-{
-        INIT_WORK(&op->work, fscache_op_work_func);
-        atomic_set(&op->usage, 1);
-        op->state = FSCACHE_OP_ST_INITIALISED;
-        op->debug_id = atomic_inc_return(&fscache_op_debug_id);
-        op->processor = processor;
-        op->release = release;
-        INIT_LIST_HEAD(&op->pend_link);
-}
+extern void fscache_operation_init(struct fscache_operation *,
+                                   fscache_operation_processor_t,
+                                   fscache_operation_cancel_t,
+                                   fscache_operation_release_t);
 
 /*
  * data read operation
  */
 struct fscache_retrieval {
         struct fscache_operation op;
+        struct fscache_cookie   *cookie;        /* The netfs cookie */
         struct address_space    *mapping;       /* netfs pages */
         fscache_rw_complete_t   end_io_func;    /* function to call on I/O completion */
         void                    *context;       /* netfs read context (pinned) */
@@ -371,6 +359,7 @@ struct fscache_object {
 #define FSCACHE_OBJECT_IS_LOOKED_UP     4       /* T if object has been looked up */
 #define FSCACHE_OBJECT_IS_AVAILABLE     5       /* T if object has become active */
 #define FSCACHE_OBJECT_RETIRED          6       /* T if object was retired on relinquishment */
+#define FSCACHE_OBJECT_KILLED_BY_CACHE  7       /* T if object was killed by the cache */
 
         struct list_head        cache_link;     /* link in cache->object_list */
         struct hlist_node       cookie_link;    /* link in cookie->backing_objects */
@@ -410,17 +399,16 @@ static inline bool fscache_object_is_available(struct fscache_object *object)
         return test_bit(FSCACHE_OBJECT_IS_AVAILABLE, &object->flags);
 }
 
-static inline bool fscache_object_is_active(struct fscache_object *object)
+static inline bool fscache_cache_is_broken(struct fscache_object *object)
 {
-        return fscache_object_is_available(object) &&
-                fscache_object_is_live(object) &&
-                !test_bit(FSCACHE_IOERROR, &object->cache->flags);
+        return test_bit(FSCACHE_IOERROR, &object->cache->flags);
 }
 
-static inline bool fscache_object_is_dead(struct fscache_object *object)
+static inline bool fscache_object_is_active(struct fscache_object *object)
 {
-        return fscache_object_is_dying(object) &&
-                test_bit(FSCACHE_IOERROR, &object->cache->flags);
+        return fscache_object_is_available(object) &&
+                fscache_object_is_live(object) &&
+                !fscache_cache_is_broken(object);
 }
 
 /**
@@ -551,4 +539,15 @@ extern enum fscache_checkaux fscache_check_aux(struct fscache_object *object,
                                                const void *data,
                                                uint16_t datalen);
 
+extern void fscache_object_retrying_stale(struct fscache_object *object);
+
+enum fscache_why_object_killed {
+        FSCACHE_OBJECT_IS_STALE,
+        FSCACHE_OBJECT_NO_SPACE,
+        FSCACHE_OBJECT_WAS_RETIRED,
+        FSCACHE_OBJECT_WAS_CULLED,
+};
+extern void fscache_object_mark_killed(struct fscache_object *object,
+                                       enum fscache_why_object_killed why);
+
 #endif /* _LINUX_FSCACHE_CACHE_H */
diff --git a/include/linux/fsl_devices.h b/include/linux/fsl_devices.h
index a82296af413f..2a2f56b292c1 100644
--- a/include/linux/fsl_devices.h
+++ b/include/linux/fsl_devices.h
@@ -24,6 +24,7 @@
 #define FSL_USB_VER_1_6         1
 #define FSL_USB_VER_2_2         2
 #define FSL_USB_VER_2_4         3
+#define FSL_USB_VER_2_5         4
 
 #include <linux/types.h>
 
diff --git a/include/linux/fsnotify_backend.h b/include/linux/fsnotify_backend.h
index 0f313f93c586..65a517dd32f7 100644
--- a/include/linux/fsnotify_backend.h
+++ b/include/linux/fsnotify_backend.h
@@ -84,8 +84,6 @@ struct fsnotify_fname;
  * Each group much define these ops.  The fsnotify infrastructure will call
  * these operations for each relevant group.
  *
- * should_send_event - given a group, inode, and mask this function determines
- *              if the group is interested in this event.
  * handle_event - main call for a group to handle an fs event
  * free_group_priv - called when a group refcnt hits 0 to clean up the private union
  * freeing_mark - called when a mark is being destroyed for some reason.  The group
diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h
index 1da602982cf9..6cd8c0ee4b6f 100644
--- a/include/linux/ftrace.h
+++ b/include/linux/ftrace.h
@@ -116,6 +116,7 @@ ftrace_func_t ftrace_ops_get_func(struct ftrace_ops *ops);
  *            SAVE_REGS. If another ops with this flag set is already registered
  *            for any of the functions that this ops will be registered for, then
  *            this ops will fail to register or set_filter_ip.
+ * PID     - Is affected by set_ftrace_pid (allows filtering on those pids)
  */
 enum {
         FTRACE_OPS_FL_ENABLED                   = 1 << 0,
@@ -132,6 +133,7 @@ enum {
         FTRACE_OPS_FL_MODIFYING                 = 1 << 11,
         FTRACE_OPS_FL_ALLOC_TRAMP               = 1 << 12,
         FTRACE_OPS_FL_IPMODIFY                  = 1 << 13,
+        FTRACE_OPS_FL_PID                       = 1 << 14,
 };
 
 #ifdef CONFIG_DYNAMIC_FTRACE
@@ -159,6 +161,7 @@ struct ftrace_ops {
         struct ftrace_ops               *next;
         unsigned long                   flags;
         void                            *private;
+        ftrace_func_t                   saved_func;
         int __percpu                    *disabled;
 #ifdef CONFIG_DYNAMIC_FTRACE
         int                             nr_trampolines;
diff --git a/include/linux/genalloc.h b/include/linux/genalloc.h
index 1ccaab44abcc..5383bb1394a1 100644
--- a/include/linux/genalloc.h
+++ b/include/linux/genalloc.h
@@ -119,16 +119,16 @@ extern unsigned long gen_pool_best_fit(unsigned long *map, unsigned long size,
 
 extern struct gen_pool *devm_gen_pool_create(struct device *dev,
                 int min_alloc_order, int nid);
-extern struct gen_pool *dev_get_gen_pool(struct device *dev);
+extern struct gen_pool *gen_pool_get(struct device *dev);
 
 bool addr_in_gen_pool(struct gen_pool *pool, unsigned long start,
                         size_t size);
 
 #ifdef CONFIG_OF
-extern struct gen_pool *of_get_named_gen_pool(struct device_node *np,
+extern struct gen_pool *of_gen_pool_get(struct device_node *np,
         const char *propname, int index);
 #else
-static inline struct gen_pool *of_get_named_gen_pool(struct device_node *np,
+static inline struct gen_pool *of_gen_pool_get(struct device_node *np,
         const char *propname, int index)
 {
         return NULL;
diff --git a/include/linux/gfp.h b/include/linux/gfp.h
index 15928f0647e4..ad35f300b9a4 100644
--- a/include/linux/gfp.h
+++ b/include/linux/gfp.h
@@ -368,6 +368,11 @@ extern void free_pages(unsigned long addr, unsigned int order);
 extern void free_hot_cold_page(struct page *page, bool cold);
 extern void free_hot_cold_page_list(struct list_head *list, bool cold);
 
+struct page_frag_cache;
+extern void *__alloc_page_frag(struct page_frag_cache *nc,
+                               unsigned int fragsz, gfp_t gfp_mask);
+extern void __free_page_frag(void *addr);
+
 extern void __free_kmem_pages(struct page *page, unsigned int order);
 extern void free_kmem_pages(unsigned long addr, unsigned int order);
 
@@ -379,6 +384,14 @@ void drain_zone_pages(struct zone *zone, struct per_cpu_pages *pcp);
 void drain_all_pages(struct zone *zone);
 void drain_local_pages(struct zone *zone);
 
+#ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT
+void page_alloc_init_late(void);
+#else
+static inline void page_alloc_init_late(void)
+{
+}
+#endif
+
 /*
  * gfp_allowed_mask is set to GFP_BOOT_MASK during early boot to restrict what
  * GFP flags are used before interrupts are enabled. Once interrupts are
diff --git a/include/linux/goldfish.h b/include/linux/goldfish.h
index 569236e6b2bc..93e080b39cf6 100644
--- a/include/linux/goldfish.h
+++ b/include/linux/goldfish.h
@@ -3,13 +3,24 @@
 
 /* Helpers for Goldfish virtual platform */
 
-static inline void gf_write64(unsigned long data,
-                void __iomem *portl, void __iomem *porth)
+static inline void gf_write_ptr(const void *ptr, void __iomem *portl,
+                                void __iomem *porth)
 {
-        writel((u32)data, portl);
+        writel((u32)(unsigned long)ptr, portl);
 #ifdef CONFIG_64BIT
-        writel(data>>32, porth);
+        writel((unsigned long)ptr >> 32, porth);
 #endif
 }
 
+static inline void gf_write_dma_addr(const dma_addr_t addr,
+                                     void __iomem *portl,
+                                     void __iomem *porth)
+{
+        writel((u32)addr, portl);
+#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
+        writel(addr >> 32, porth);
+#endif
+}
+
+
 #endif /* __LINUX_GOLDFISH_H */
diff --git a/include/linux/gpio/consumer.h b/include/linux/gpio/consumer.h
index fd098169fe87..adac255aee86 100644
--- a/include/linux/gpio/consumer.h
+++ b/include/linux/gpio/consumer.h
@@ -407,6 +407,21 @@ static inline int desc_to_gpio(const struct gpio_desc *desc)
         return -EINVAL;
 }
 
+/* Child properties interface */
+struct fwnode_handle;
+
+static inline struct gpio_desc *fwnode_get_named_gpiod(
+        struct fwnode_handle *fwnode, const char *propname)
+{
+        return ERR_PTR(-ENOSYS);
+}
+
+static inline struct gpio_desc *devm_get_gpiod_from_child(
+        struct device *dev, const char *con_id, struct fwnode_handle *child)
+{
+        return ERR_PTR(-ENOSYS);
+}
+
 #endif /* CONFIG_GPIOLIB */
 
 /*
diff --git a/include/linux/gpio/driver.h b/include/linux/gpio/driver.h
index cc7ec129b329..c8393cd4d44f 100644
--- a/include/linux/gpio/driver.h
+++ b/include/linux/gpio/driver.h
@@ -45,7 +45,7 @@ struct seq_file;
  * @base: identifies the first GPIO number handled by this chip;
  *      or, if negative during registration, requests dynamic ID allocation.
  *      DEPRECATION: providing anything non-negative and nailing the base
- *      base offset of GPIO chips is deprecated. Please pass -1 as base to
+ *      offset of GPIO chips is deprecated. Please pass -1 as base to
  *      let gpiolib select the chip base in all possible cases. We want to
  *      get rid of the static GPIO number space in the long run.
  * @ngpio: the number of GPIOs handled by this controller; the last GPIO
diff --git a/include/linux/hid-sensor-hub.h b/include/linux/hid-sensor-hub.h
index 0042bf330b99..c02b5ce6c5cd 100644
--- a/include/linux/hid-sensor-hub.h
+++ b/include/linux/hid-sensor-hub.h
@@ -230,6 +230,7 @@ struct hid_sensor_common {
         struct platform_device *pdev;
         unsigned usage_id;
         atomic_t data_ready;
+        atomic_t user_requested_state;
         struct iio_trigger *trigger;
         struct hid_sensor_hub_attribute_info poll;
         struct hid_sensor_hub_attribute_info report_state;
diff --git a/include/linux/hugetlb.h b/include/linux/hugetlb.h
index 205026175c42..d891f949466a 100644
--- a/include/linux/hugetlb.h
+++ b/include/linux/hugetlb.h
@@ -460,15 +460,14 @@ static inline spinlock_t *huge_pte_lockptr(struct hstate *h,
         return &mm->page_table_lock;
 }
 
-static inline bool hugepages_supported(void)
-{
-        /*
-         * Some platform decide whether they support huge pages at boot
-         * time. On these, such as powerpc, HPAGE_SHIFT is set to 0 when
-         * there is no such support
-         */
-        return HPAGE_SHIFT != 0;
-}
+#ifndef hugepages_supported
+/*
+ * Some platform decide whether they support huge pages at boot
+ * time. Some of them, such as powerpc, set HPAGE_SHIFT to 0
+ * when there is no such support
+ */
+#define hugepages_supported() (HPAGE_SHIFT != 0)
+#endif
 
 #else   /* CONFIG_HUGETLB_PAGE */
 struct hstate {};
diff --git a/include/linux/hwspinlock.h b/include/linux/hwspinlock.h
index 3343298e40e8..859d673d98c8 100644
--- a/include/linux/hwspinlock.h
+++ b/include/linux/hwspinlock.h
@@ -26,6 +26,7 @@
 #define HWLOCK_IRQ      0x02    /* Disable interrupts, don't save state */
 
 struct device;
+struct device_node;
 struct hwspinlock;
 struct hwspinlock_device;
 struct hwspinlock_ops;
@@ -66,6 +67,7 @@ int hwspin_lock_unregister(struct hwspinlock_device *bank);
 struct hwspinlock *hwspin_lock_request(void);
 struct hwspinlock *hwspin_lock_request_specific(unsigned int id);
 int hwspin_lock_free(struct hwspinlock *hwlock);
+int of_hwspin_lock_get_id(struct device_node *np, int index);
 int hwspin_lock_get_id(struct hwspinlock *hwlock);
 int __hwspin_lock_timeout(struct hwspinlock *, unsigned int, int,
                                                         unsigned long *);
@@ -120,6 +122,11 @@ void __hwspin_unlock(struct hwspinlock *hwlock, int mode, unsigned long *flags)
 {
 }
 
+static inline int of_hwspin_lock_get_id(struct device_node *np, int index)
+{
+        return 0;
+}
+
 static inline int hwspin_lock_get_id(struct hwspinlock *hwlock)
 {
         return 0;
diff --git a/include/linux/hyperv.h b/include/linux/hyperv.h
index 902c37aef67e..30d3a1f79450 100644
--- a/include/linux/hyperv.h
+++ b/include/linux/hyperv.h
@@ -160,16 +160,18 @@ hv_get_ringbuffer_availbytes(struct hv_ring_buffer_info *rbi,
  * 1 . 1  (Windows 7)
  * 2 . 4  (Windows 8)
  * 3 . 0  (Windows 8 R2)
+ * 4 . 0  (Windows 10)
  */
 
 #define VERSION_WS2008  ((0 << 16) | (13))
 #define VERSION_WIN7    ((1 << 16) | (1))
 #define VERSION_WIN8    ((2 << 16) | (4))
 #define VERSION_WIN8_1    ((3 << 16) | (0))
+#define VERSION_WIN10   ((4 << 16) | (0))
 
 #define VERSION_INVAL -1
 
-#define VERSION_CURRENT VERSION_WIN8_1
+#define VERSION_CURRENT VERSION_WIN10
 
 /* Make maximum size of pipe payload of 16K */
 #define MAX_PIPE_DATA_PAYLOAD           (sizeof(u8) * 16384)
@@ -389,10 +391,7 @@ enum vmbus_channel_message_type {
         CHANNELMSG_INITIATE_CONTACT             = 14,
         CHANNELMSG_VERSION_RESPONSE             = 15,
         CHANNELMSG_UNLOAD                       = 16,
-#ifdef VMBUS_FEATURE_PARENT_OR_PEER_MEMORY_MAPPED_INTO_A_CHILD
-        CHANNELMSG_VIEWRANGE_ADD                = 17,
-        CHANNELMSG_VIEWRANGE_REMOVE             = 18,
-#endif
+        CHANNELMSG_UNLOAD_RESPONSE              = 17,
         CHANNELMSG_COUNT
 };
 
@@ -549,21 +548,6 @@ struct vmbus_channel_gpadl_torndown {
         u32 gpadl;
 } __packed;
 
-#ifdef VMBUS_FEATURE_PARENT_OR_PEER_MEMORY_MAPPED_INTO_A_CHILD
-struct vmbus_channel_view_range_add {
-        struct vmbus_channel_message_header header;
-        PHYSICAL_ADDRESS viewrange_base;
-        u64 viewrange_length;
-        u32 child_relid;
-} __packed;
-
-struct vmbus_channel_view_range_remove {
-        struct vmbus_channel_message_header header;
-        PHYSICAL_ADDRESS viewrange_base;
-        u32 child_relid;
-} __packed;
-#endif
-
 struct vmbus_channel_relid_released {
         struct vmbus_channel_message_header header;
         u32 child_relid;
@@ -713,6 +697,11 @@ struct vmbus_channel {
         /* The corresponding CPUID in the guest */
         u32 target_cpu;
         /*
+         * State to manage the CPU affiliation of channels.
+         */
+        struct cpumask alloced_cpus_in_node;
+        int numa_node;
+        /*
          * Support for sub-channels. For high performance devices,
          * it will be useful to have multiple sub-channels to support
          * a scalable communication infrastructure with the host.
@@ -745,6 +734,15 @@ struct vmbus_channel {
          */
         struct list_head sc_list;
         /*
+         * Current number of sub-channels.
+         */
+        int num_sc;
+        /*
+         * Number of a sub-channel (position within sc_list) which is supposed
+         * to be used as the next outgoing channel.
+         */
+        int next_oc;
+        /*
          * The primary channel this sub-channel belongs to.
          * This will be NULL for the primary channel.
          */
@@ -758,9 +756,6 @@ struct vmbus_channel {
          * link up channels based on their CPU affinity.
          */
         struct list_head percpu_list;
-
-        int num_sc;
-        int next_oc;
 };
 
 static inline void set_channel_read_state(struct vmbus_channel *c, bool state)
@@ -1236,13 +1231,6 @@ extern bool vmbus_prep_negotiate_resp(struct icmsg_hdr *,
                                         struct icmsg_negotiate *, u8 *, int,
                                         int);
 
-int hv_kvp_init(struct hv_util_service *);
-void hv_kvp_deinit(void);
-void hv_kvp_onchannelcallback(void *);
-
-int hv_vss_init(struct hv_util_service *);
-void hv_vss_deinit(void);
-void hv_vss_onchannelcallback(void *);
 void hv_process_channel_removal(struct vmbus_channel *channel, u32 relid);
 
 extern struct resource hyperv_mmio;
diff --git a/include/linux/i2c/twl.h b/include/linux/i2c/twl.h
index 0bc03f100d04..9ad7828d9d34 100644
--- a/include/linux/i2c/twl.h
+++ b/include/linux/i2c/twl.h
@@ -675,6 +675,7 @@ struct twl4030_power_data {
         struct twl4030_resconfig *board_config;
 #define TWL4030_RESCONFIG_UNDEF ((u8)-1)
         bool use_poweroff;      /* Board is wired for TWL poweroff */
+        bool ac_charger_quirk;  /* Disable AC charger on board */
 };
 
 extern int twl4030_remove_script(u8 flags);
diff --git a/include/linux/ide.h b/include/linux/ide.h
index 93b5ca754b5b..a633898f36ac 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -39,6 +39,19 @@
 
 struct device;
 
+/* IDE-specific values for req->cmd_type */
+enum ata_cmd_type_bits {
+        REQ_TYPE_ATA_TASKFILE = REQ_TYPE_DRV_PRIV + 1,
+        REQ_TYPE_ATA_PC,
+        REQ_TYPE_ATA_SENSE,     /* sense request */
+        REQ_TYPE_ATA_PM_SUSPEND,/* suspend request */
+        REQ_TYPE_ATA_PM_RESUME, /* resume request */
+};
+
+#define ata_pm_request(rq)      \
+        ((rq)->cmd_type == REQ_TYPE_ATA_PM_SUSPEND || \
+         (rq)->cmd_type == REQ_TYPE_ATA_PM_RESUME)
+
 /* Error codes returned in rq->errors to the higher part of the driver. */
 enum {
         IDE_DRV_ERROR_GENERAL   = 101,
@@ -1314,6 +1327,19 @@ struct ide_port_info {
         u8                      udma_mask;
 };
 
+/*
+ * State information carried for REQ_TYPE_ATA_PM_SUSPEND and REQ_TYPE_ATA_PM_RESUME
+ * requests.
+ */
+struct ide_pm_state {
+        /* PM state machine step value, currently driver specific */
+        int     pm_step;
+        /* requested PM state value (S1, S2, S3, S4, ...) */
+        u32     pm_state;
+        void*   data;           /* for driver use */
+};
+
+
 int ide_pci_init_one(struct pci_dev *, const struct ide_port_info *, void *);
 int ide_pci_init_two(struct pci_dev *, struct pci_dev *,
                      const struct ide_port_info *, void *);
@@ -1551,4 +1577,5 @@ static inline void ide_set_drivedata(ide_drive_t *drive, void *data)
 #define ide_host_for_each_port(i, port, host) \
         for ((i) = 0; ((port) = (host)->ports[i]) || (i) < MAX_HOST_PORTS; (i)++)
 
+
 #endif /* _IDE_H */
diff --git a/include/linux/ieee802154.h b/include/linux/ieee802154.h
index 8872ca103d06..1dc1f4ed4001 100644
--- a/include/linux/ieee802154.h
+++ b/include/linux/ieee802154.h
@@ -225,15 +225,13 @@ static inline bool ieee802154_is_valid_psdu_len(const u8 len)
  * ieee802154_is_valid_psdu_len - check if extended addr is valid
  * @addr: extended addr to check
  */
-static inline bool ieee802154_is_valid_extended_addr(const __le64 addr)
+static inline bool ieee802154_is_valid_extended_unicast_addr(const __le64 addr)
 {
-        /* These EUI-64 addresses are reserved by IEEE. 0xffffffffffffffff
-         * is used internally as extended to short address broadcast mapping.
-         * This is currently a workaround because neighbor discovery can't
-         * deal with short addresses types right now.
+        /* Bail out if the address is all zero, or if the group
+         * address bit is set.
          */
         return ((addr != cpu_to_le64(0x0000000000000000ULL)) &&
-                (addr != cpu_to_le64(0xffffffffffffffffULL)));
+                !(addr & cpu_to_le64(0x0100000000000000ULL)));
 }
 
 /**
@@ -244,9 +242,9 @@ static inline void ieee802154_random_extended_addr(__le64 *addr)
 {
         get_random_bytes(addr, IEEE802154_EXTENDED_ADDR_LEN);
 
-        /* toggle some bit if we hit an invalid extended addr */
-        if (!ieee802154_is_valid_extended_addr(*addr))
-                ((u8 *)addr)[IEEE802154_EXTENDED_ADDR_LEN - 1] ^= 0x01;
+        /* clear the group bit, and set the locally administered bit */
+        ((u8 *)addr)[IEEE802154_EXTENDED_ADDR_LEN - 1] &= ~0x01;
+        ((u8 *)addr)[IEEE802154_EXTENDED_ADDR_LEN - 1] |= 0x02;
 }
 
 #endif /* LINUX_IEEE802154_H */
diff --git a/include/linux/if_link.h b/include/linux/if_link.h
index da4929927f69..ae5d0d22955d 100644
--- a/include/linux/if_link.h
+++ b/include/linux/if_link.h
@@ -5,6 +5,15 @@
 
 
 /* We don't want this structure exposed to user space */
+struct ifla_vf_stats {
+        __u64 rx_packets;
+        __u64 tx_packets;
+        __u64 rx_bytes;
+        __u64 tx_bytes;
+        __u64 broadcast;
+        __u64 multicast;
+};
+
 struct ifla_vf_info {
         __u32 vf;
         __u8 mac[32];
diff --git a/include/linux/if_macvlan.h b/include/linux/if_macvlan.h
index 6f6929ea8a0c..a4ccc3122f93 100644
--- a/include/linux/if_macvlan.h
+++ b/include/linux/if_macvlan.h
@@ -29,7 +29,7 @@ struct macvtap_queue;
  * Maximum times a macvtap device can be opened. This can be used to
  * configure the number of receive queue, e.g. for multiqueue virtio.
  */
-#define MAX_MACVTAP_QUEUES      16
+#define MAX_MACVTAP_QUEUES      256
 
 #define MACVLAN_MC_FILTER_BITS  8
 #define MACVLAN_MC_FILTER_SZ    (1 << MACVLAN_MC_FILTER_BITS)
diff --git a/include/linux/if_pppox.h b/include/linux/if_pppox.h
index 66a7d7600f43..b49cf923becc 100644
--- a/include/linux/if_pppox.h
+++ b/include/linux/if_pppox.h
@@ -74,7 +74,7 @@ static inline struct sock *sk_pppox(struct pppox_sock *po)
 struct module;
 
 struct pppox_proto {
-        int             (*create)(struct net *net, struct socket *sock);
+        int             (*create)(struct net *net, struct socket *sock, int kern);
         int             (*ioctl)(struct socket *sock, unsigned int cmd,
                                  unsigned long arg);
         struct module   *owner;
diff --git a/include/linux/if_vlan.h b/include/linux/if_vlan.h
index 920e4457ce6e..67ce5bd3b56a 100644
--- a/include/linux/if_vlan.h
+++ b/include/linux/if_vlan.h
@@ -416,7 +416,7 @@ static inline void __vlan_hwaccel_put_tag(struct sk_buff *skb,
 /**
  * __vlan_get_tag - get the VLAN ID that is part of the payload
  * @skb: skbuff to query
- * @vlan_tci: buffer to store vlaue
+ * @vlan_tci: buffer to store value
  *
  * Returns error if the skb is not of VLAN type
  */
@@ -435,7 +435,7 @@ static inline int __vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci)
 /**
  * __vlan_hwaccel_get_tag - get the VLAN ID that is in @skb->cb[]
  * @skb: skbuff to query
- * @vlan_tci: buffer to store vlaue
+ * @vlan_tci: buffer to store value
  *
  * Returns error if @skb->vlan_tci is not set correctly
  */
@@ -456,7 +456,7 @@ static inline int __vlan_hwaccel_get_tag(const struct sk_buff *skb,
 /**
  * vlan_get_tag - get the VLAN ID from the skb
  * @skb: skbuff to query
- * @vlan_tci: buffer to store vlaue
+ * @vlan_tci: buffer to store value
  *
  * Returns error if the skb is not VLAN tagged
  */
@@ -539,7 +539,7 @@ static inline void vlan_set_encap_proto(struct sk_buff *skb,
          */
 
         proto = vhdr->h_vlan_encapsulated_proto;
-        if (ntohs(proto) >= ETH_P_802_3_MIN) {
+        if (eth_proto_is_802_3(proto)) {
                 skb->protocol = proto;
                 return;
         }
@@ -628,4 +628,24 @@ static inline netdev_features_t vlan_features_check(const struct sk_buff *skb,
         return features;
 }
 
+/**
+ * compare_vlan_header - Compare two vlan headers
+ * @h1: Pointer to vlan header
+ * @h2: Pointer to vlan header
+ *
+ * Compare two vlan headers, returns 0 if equal.
+ *
+ * Please note that alignment of h1 & h2 are only guaranteed to be 16 bits.
+ */
+static inline unsigned long compare_vlan_header(const struct vlan_hdr *h1,
+                                                const struct vlan_hdr *h2)
+{
+#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)
+        return *(u32 *)h1 ^ *(u32 *)h2;
+#else
+        return ((__force u32)h1->h_vlan_TCI ^ (__force u32)h2->h_vlan_TCI) |
+               ((__force u32)h1->h_vlan_encapsulated_proto ^
+                (__force u32)h2->h_vlan_encapsulated_proto);
+#endif
+}
 #endif /* !(_LINUX_IF_VLAN_H_) */
diff --git a/include/linux/igmp.h b/include/linux/igmp.h
index 2c677afeea47..193ad488d3e2 100644
--- a/include/linux/igmp.h
+++ b/include/linux/igmp.h
@@ -130,5 +130,6 @@ extern void ip_mc_unmap(struct in_device *);
 extern void ip_mc_remap(struct in_device *);
 extern void ip_mc_dec_group(struct in_device *in_dev, __be32 addr);
 extern void ip_mc_inc_group(struct in_device *in_dev, __be32 addr);
+int ip_mc_check_igmp(struct sk_buff *skb, struct sk_buff **skb_trimmed);
 
 #endif
diff --git a/include/linux/iio/buffer.h b/include/linux/iio/buffer.h
index eb8622b78ec9..1600c55828e0 100644
--- a/include/linux/iio/buffer.h
+++ b/include/linux/iio/buffer.h
@@ -29,6 +29,7 @@ struct iio_buffer;
  * @set_length:         set number of datums in buffer
  * @release:            called when the last reference to the buffer is dropped,
  *                      should free all resources allocated by the buffer.
+ * @modes:              Supported operating modes by this buffer type
  *
  * The purpose of this structure is to make the buffer element
  * modular as event for a given driver, different usecases may require
@@ -51,6 +52,8 @@ struct iio_buffer_access_funcs {
         int (*set_length)(struct iio_buffer *buffer, int length);
 
         void (*release)(struct iio_buffer *buffer);
+
+        unsigned int modes;
 };
 
 /**
diff --git a/include/linux/iio/iio.h b/include/linux/iio/iio.h
index d86b753e9b30..f79148261d16 100644
--- a/include/linux/iio/iio.h
+++ b/include/linux/iio/iio.h
@@ -32,6 +32,7 @@ enum iio_chan_info_enum {
         IIO_CHAN_INFO_QUADRATURE_CORRECTION_RAW,
         IIO_CHAN_INFO_AVERAGE_RAW,
         IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY,
+        IIO_CHAN_INFO_HIGH_PASS_FILTER_3DB_FREQUENCY,
         IIO_CHAN_INFO_SAMP_FREQ,
         IIO_CHAN_INFO_FREQUENCY,
         IIO_CHAN_INFO_PHASE,
@@ -43,6 +44,8 @@ enum iio_chan_info_enum {
         IIO_CHAN_INFO_CALIBWEIGHT,
         IIO_CHAN_INFO_DEBOUNCE_COUNT,
         IIO_CHAN_INFO_DEBOUNCE_TIME,
+        IIO_CHAN_INFO_CALIBEMISSIVITY,
+        IIO_CHAN_INFO_OVERSAMPLING_RATIO,
 };
 
 enum iio_shared_by {
diff --git a/include/linux/iio/types.h b/include/linux/iio/types.h
index 942b6de68e2f..32b579525004 100644
--- a/include/linux/iio/types.h
+++ b/include/linux/iio/types.h
@@ -17,6 +17,8 @@ enum iio_event_info {
         IIO_EV_INFO_VALUE,
         IIO_EV_INFO_HYSTERESIS,
         IIO_EV_INFO_PERIOD,
+        IIO_EV_INFO_HIGH_PASS_FILTER_3DB,
+        IIO_EV_INFO_LOW_PASS_FILTER_3DB,
 };
 
 #define IIO_VAL_INT 1
diff --git a/include/linux/inet_diag.h b/include/linux/inet_diag.h
index ac48b10c9395..0e707f0c1a3e 100644
--- a/include/linux/inet_diag.h
+++ b/include/linux/inet_diag.h
@@ -24,6 +24,7 @@ struct inet_diag_handler {
                                           struct inet_diag_msg *r,
                                           void *info);
         __u16           idiag_type;
+        __u16           idiag_info_size;
 };
 
 struct inet_connection_sock;
diff --git a/include/linux/inetdevice.h b/include/linux/inetdevice.h
index 0a21fbefdfbe..a4328cea376a 100644
--- a/include/linux/inetdevice.h
+++ b/include/linux/inetdevice.h
@@ -120,6 +120,9 @@ static inline void ipv4_devconf_setall(struct in_device *in_dev)
          || (!IN_DEV_FORWARD(in_dev) && \
           IN_DEV_ORCONF((in_dev), ACCEPT_REDIRECTS)))
 
+#define IN_DEV_IGNORE_ROUTES_WITH_LINKDOWN(in_dev) \
+        IN_DEV_CONF_GET((in_dev), IGNORE_ROUTES_WITH_LINKDOWN)
+
 #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)
diff --git a/include/linux/init.h b/include/linux/init.h
index 21b6d768edd7..b449f378f995 100644
--- a/include/linux/init.h
+++ b/include/linux/init.h
@@ -91,14 +91,6 @@
 
 #define __exit          __section(.exit.text) __exitused __cold notrace
 
-/* temporary, until all users are removed */
-#define __cpuinit
-#define __cpuinitdata
-#define __cpuinitconst
-#define __cpuexit
-#define __cpuexitdata
-#define __cpuexitconst
-
 /* Used for MEMORY_HOTPLUG */
 #define __meminit        __section(.meminit.text) __cold notrace
 #define __meminitdata    __section(.meminit.data)
@@ -116,9 +108,6 @@
 #define __INITRODATA    .section        ".init.rodata","a",%progbits
 #define __FINITDATA     .previous
 
-/* temporary, until all users are removed */
-#define __CPUINIT
-
 #define __MEMINIT        .section       ".meminit.text", "ax"
 #define __MEMINITDATA    .section       ".meminit.data", "aw"
 #define __MEMINITRODATA  .section       ".meminit.rodata", "a"
@@ -293,68 +282,8 @@ void __init parse_early_param(void);
 void __init parse_early_options(char *cmdline);
 #endif /* __ASSEMBLY__ */
 
-/**
- * module_init() - driver initialization entry point
- * @x: function to be run at kernel boot time or module insertion
- * 
- * module_init() will either be called during do_initcalls() (if
- * builtin) or at module insertion time (if a module).  There can only
- * be one per module.
- */
-#define module_init(x)  __initcall(x);
-
-/**
- * module_exit() - driver exit entry point
- * @x: function to be run when driver is removed
- * 
- * module_exit() will wrap the driver clean-up code
- * with cleanup_module() when used with rmmod when
- * the driver is a module.  If the driver is statically
- * compiled into the kernel, module_exit() has no effect.
- * There can only be one per module.
- */
-#define module_exit(x)  __exitcall(x);
-
 #else /* MODULE */
 
-/*
- * In most cases loadable modules do not need custom
- * initcall levels. There are still some valid cases where
- * a driver may be needed early if built in, and does not
- * matter when built as a loadable module. Like bus
- * snooping debug drivers.
- */
-#define early_initcall(fn)              module_init(fn)
-#define core_initcall(fn)               module_init(fn)
-#define core_initcall_sync(fn)          module_init(fn)
-#define postcore_initcall(fn)           module_init(fn)
-#define postcore_initcall_sync(fn)      module_init(fn)
-#define arch_initcall(fn)               module_init(fn)
-#define subsys_initcall(fn)             module_init(fn)
-#define subsys_initcall_sync(fn)        module_init(fn)
-#define fs_initcall(fn)                 module_init(fn)
-#define fs_initcall_sync(fn)            module_init(fn)
-#define rootfs_initcall(fn)             module_init(fn)
-#define device_initcall(fn)             module_init(fn)
-#define device_initcall_sync(fn)        module_init(fn)
-#define late_initcall(fn)               module_init(fn)
-#define late_initcall_sync(fn)          module_init(fn)
-
-#define console_initcall(fn)            module_init(fn)
-#define security_initcall(fn)           module_init(fn)
-
-/* Each module must use one module_init(). */
-#define module_init(initfn)                                     \
-        static inline initcall_t __inittest(void)               \
-        { return initfn; }                                      \
-        int init_module(void) __attribute__((alias(#initfn)));
-
-/* This is only required if you want to be unloadable. */
-#define module_exit(exitfn)                                     \
-        static inline exitcall_t __exittest(void)               \
-        { return exitfn; }                                      \
-        void cleanup_module(void) __attribute__((alias(#exitfn)));
-
 #define __setup_param(str, unique_id, fn)       /* nothing */
 #define __setup(str, func)                      /* nothing */
 #endif
@@ -362,24 +291,6 @@ void __init parse_early_options(char *cmdline);
 /* Data marked not to be saved by software suspend */
 #define __nosavedata __section(.data..nosave)
 
-/* This means "can be init if no module support, otherwise module load
-   may call it." */
-#ifdef CONFIG_MODULES
-#define __init_or_module
-#define __initdata_or_module
-#define __initconst_or_module
-#define __INIT_OR_MODULE        .text
-#define __INITDATA_OR_MODULE    .data
-#define __INITRODATA_OR_MODULE  .section ".rodata","a",%progbits
-#else
-#define __init_or_module __init
-#define __initdata_or_module __initdata
-#define __initconst_or_module __initconst
-#define __INIT_OR_MODULE __INIT
-#define __INITDATA_OR_MODULE __INITDATA
-#define __INITRODATA_OR_MODULE __INITRODATA
-#endif /*CONFIG_MODULES*/
-
 #ifdef MODULE
 #define __exit_p(x) x
 #else
diff --git a/include/linux/init_task.h b/include/linux/init_task.h
index bb9b075f0eb0..e8493fee8160 100644
--- a/include/linux/init_task.h
+++ b/include/linux/init_task.h
@@ -25,13 +25,6 @@
 extern struct files_struct init_files;
 extern struct fs_struct init_fs;
 
-#ifdef CONFIG_CGROUPS
-#define INIT_GROUP_RWSEM(sig)                                           \
-        .group_rwsem = __RWSEM_INITIALIZER(sig.group_rwsem),
-#else
-#define INIT_GROUP_RWSEM(sig)
-#endif
-
 #ifdef CONFIG_CPUSETS
 #define INIT_CPUSET_SEQ(tsk)                                                    \
         .mems_allowed_seq = SEQCNT_ZERO(tsk.mems_allowed_seq),
@@ -55,7 +48,6 @@ extern struct fs_struct init_fs;
         },                                                              \
         .cred_guard_mutex =                                             \
                  __MUTEX_INITIALIZER(sig.cred_guard_mutex),             \
-        INIT_GROUP_RWSEM(sig)                                           \
 }
 
 extern struct nsproxy init_nsproxy;
diff --git a/include/linux/input/touchscreen.h b/include/linux/input/touchscreen.h
index 08a5ef6e8f25..eecc9ea6cd58 100644
--- a/include/linux/input/touchscreen.h
+++ b/include/linux/input/touchscreen.h
@@ -12,9 +12,10 @@
 #include <linux/input.h>
 
 #ifdef CONFIG_OF
-void touchscreen_parse_of_params(struct input_dev *dev);
+void touchscreen_parse_of_params(struct input_dev *dev, bool multitouch);
 #else
-static inline void touchscreen_parse_of_params(struct input_dev *dev)
+static inline void touchscreen_parse_of_params(struct input_dev *dev,
+                                               bool multitouch)
 {
 }
 #endif
diff --git a/include/linux/intel-iommu.h b/include/linux/intel-iommu.h
index 3665cb331ca1..d9a366d24e3b 100644
--- a/include/linux/intel-iommu.h
+++ b/include/linux/intel-iommu.h
@@ -297,6 +297,7 @@ struct q_inval {
 /* 1MB - maximum possible interrupt remapping table size */
 #define INTR_REMAP_PAGE_ORDER   8
 #define INTR_REMAP_TABLE_REG_SIZE       0xf
+#define INTR_REMAP_TABLE_REG_SIZE_MASK  0xf
 
 #define INTR_REMAP_TABLE_ENTRIES        65536
 
@@ -323,6 +324,9 @@ enum {
         MAX_SR_DMAR_REGS
 };
 
+#define VTD_FLAG_TRANS_PRE_ENABLED      (1 << 0)
+#define VTD_FLAG_IRQ_REMAP_PRE_ENABLED  (1 << 1)
+
 struct intel_iommu {
         void __iomem    *reg; /* Pointer to hardware regs, virtual addr */
         u64             reg_phys; /* physical address of hw register set */
@@ -356,6 +360,7 @@ struct intel_iommu {
 #endif
         struct device   *iommu_dev; /* IOMMU-sysfs device */
         int             node;
+        u32             flags;      /* Software defined flags */
 };
 
 static inline void __iommu_flush_cache(
diff --git a/include/linux/iommu.h b/include/linux/iommu.h
index 0546b8710ce3..f9c1b6d0f2e4 100644
--- a/include/linux/iommu.h
+++ b/include/linux/iommu.h
@@ -114,6 +114,20 @@ enum iommu_attr {
         DOMAIN_ATTR_MAX,
 };
 
+/**
+ * struct iommu_dm_region - descriptor for a direct mapped memory region
+ * @list: Linked list pointers
+ * @start: System physical start address of the region
+ * @length: Length of the region in bytes
+ * @prot: IOMMU Protection flags (READ/WRITE/...)
+ */
+struct iommu_dm_region {
+        struct list_head        list;
+        phys_addr_t             start;
+        size_t                  length;
+        int                     prot;
+};
+
 #ifdef CONFIG_IOMMU_API
 
 /**
@@ -159,6 +173,10 @@ struct iommu_ops {
         int (*domain_set_attr)(struct iommu_domain *domain,
                                enum iommu_attr attr, void *data);
 
+        /* Request/Free a list of direct mapping requirements for a device */
+        void (*get_dm_regions)(struct device *dev, struct list_head *list);
+        void (*put_dm_regions)(struct device *dev, struct list_head *list);
+
         /* Window handling functions */
         int (*domain_window_enable)(struct iommu_domain *domain, u32 wnd_nr,
                                     phys_addr_t paddr, u64 size, int prot);
@@ -193,6 +211,7 @@ extern int iommu_attach_device(struct iommu_domain *domain,
                                struct device *dev);
 extern void iommu_detach_device(struct iommu_domain *domain,
                                 struct device *dev);
+extern struct iommu_domain *iommu_get_domain_for_dev(struct device *dev);
 extern int iommu_map(struct iommu_domain *domain, unsigned long iova,
                      phys_addr_t paddr, size_t size, int prot);
 extern size_t iommu_unmap(struct iommu_domain *domain, unsigned long iova,
@@ -204,6 +223,10 @@ extern phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_addr_t io
 extern void iommu_set_fault_handler(struct iommu_domain *domain,
                         iommu_fault_handler_t handler, void *token);
 
+extern void iommu_get_dm_regions(struct device *dev, struct list_head *list);
+extern void iommu_put_dm_regions(struct device *dev, struct list_head *list);
+extern int iommu_request_dm_for_dev(struct device *dev);
+
 extern int iommu_attach_group(struct iommu_domain *domain,
                               struct iommu_group *group);
 extern void iommu_detach_group(struct iommu_domain *domain,
@@ -227,6 +250,7 @@ extern int iommu_group_unregister_notifier(struct iommu_group *group,
                                            struct notifier_block *nb);
 extern int iommu_group_id(struct iommu_group *group);
 extern struct iommu_group *iommu_group_get_for_dev(struct device *dev);
+extern struct iommu_domain *iommu_group_default_domain(struct iommu_group *);
 
 extern int iommu_domain_get_attr(struct iommu_domain *domain, enum iommu_attr,
                                  void *data);
@@ -234,7 +258,7 @@ extern int iommu_domain_set_attr(struct iommu_domain *domain, enum iommu_attr,
                                  void *data);
 struct device *iommu_device_create(struct device *parent, void *drvdata,
                                    const struct attribute_group **groups,
-                                   const char *fmt, ...);
+                                   const char *fmt, ...) __printf(4, 5);
 void iommu_device_destroy(struct device *dev);
 int iommu_device_link(struct device *dev, struct device *link);
 void iommu_device_unlink(struct device *dev, struct device *link);
@@ -332,6 +356,11 @@ static inline void iommu_detach_device(struct iommu_domain *domain,
 {
 }
 
+static inline struct iommu_domain *iommu_get_domain_for_dev(struct device *dev)
+{
+        return NULL;
+}
+
 static inline int iommu_map(struct iommu_domain *domain, unsigned long iova,
                             phys_addr_t paddr, int gfp_order, int prot)
 {
@@ -373,6 +402,21 @@ static inline void iommu_set_fault_handler(struct iommu_domain *domain,
 {
 }
 
+static inline void iommu_get_dm_regions(struct device *dev,
+                                        struct list_head *list)
+{
+}
+
+static inline void iommu_put_dm_regions(struct device *dev,
+                                        struct list_head *list)
+{
+}
+
+static inline int iommu_request_dm_for_dev(struct device *dev)
+{
+        return -ENODEV;
+}
+
 static inline int iommu_attach_group(struct iommu_domain *domain,
                                      struct iommu_group *group)
 {
diff --git a/include/linux/irq.h b/include/linux/irq.h
index 812149160d3b..92188b0225bb 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -407,7 +407,6 @@ enum {
         IRQCHIP_EOI_THREADED            = (1 <<  6),
 };
 
-/* This include will go away once we isolated irq_desc usage to core code */
 #include <linux/irqdesc.h>
 
 /*
diff --git a/include/linux/irqchip.h b/include/linux/irqchip.h
index 14d79131f53d..638887376e58 100644
--- a/include/linux/irqchip.h
+++ b/include/linux/irqchip.h
@@ -11,6 +11,20 @@
 #ifndef _LINUX_IRQCHIP_H
 #define _LINUX_IRQCHIP_H
 
+#include <linux/of.h>
+
+/*
+ * This macro must be used by the different irqchip drivers to declare
+ * the association between their DT compatible string and their
+ * initialization function.
+ *
+ * @name: name that must be unique accross all IRQCHIP_DECLARE of the
+ * same file.
+ * @compstr: compatible string of the irqchip driver
+ * @fn: initialization function
+ */
+#define IRQCHIP_DECLARE(name, compat, fn) OF_DECLARE_2(irqchip, name, compat, fn)
+
 #ifdef CONFIG_IRQCHIP
 void irqchip_init(void);
 #else
diff --git a/include/linux/irqchip/ingenic.h b/include/linux/irqchip/ingenic.h
new file mode 100644
index 000000000000..0ee319a4029d
--- /dev/null
+++ b/include/linux/irqchip/ingenic.h
@@ -0,0 +1,23 @@
+/*
+ *  Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.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.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#ifndef __LINUX_IRQCHIP_INGENIC_H__
+#define __LINUX_IRQCHIP_INGENIC_H__
+
+#include <linux/irq.h>
+
+extern void ingenic_intc_irq_suspend(struct irq_data *data);
+extern void ingenic_intc_irq_resume(struct irq_data *data);
+
+#endif
diff --git a/include/linux/irqchip/irq-sa11x0.h b/include/linux/irqchip/irq-sa11x0.h
new file mode 100644
index 000000000000..15db6829c1e4
--- /dev/null
+++ b/include/linux/irqchip/irq-sa11x0.h
@@ -0,0 +1,17 @@
+/*
+ * Generic IRQ handling for the SA11x0.
+ *
+ * Copyright (C) 2015 Dmitry Eremin-Solenikov
+ * Copyright (C) 1999-2001 Nicolas Pitre
+ *
+ * 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 __INCLUDE_LINUX_IRQCHIP_IRQ_SA11x0_H
+#define __INCLUDE_LINUX_IRQCHIP_IRQ_SA11x0_H
+
+void __init sa11x0_init_irq_nodt(int irq_start, resource_size_t io_start);
+
+#endif
diff --git a/include/linux/irqdesc.h b/include/linux/irqdesc.h
index c52d1480f272..fcea4e48e21f 100644
--- a/include/linux/irqdesc.h
+++ b/include/linux/irqdesc.h
@@ -3,9 +3,6 @@
 
 /*
  * Core internal functions to deal with irq descriptors
- *
- * This include will move to kernel/irq once we cleaned up the tree.
- * For now it's included from <linux/irq.h>
  */
 
 struct irq_affinity_notify;
@@ -90,7 +87,12 @@ struct irq_desc {
         const char              *name;
 } ____cacheline_internodealigned_in_smp;
 
-#ifndef CONFIG_SPARSE_IRQ
+#ifdef CONFIG_SPARSE_IRQ
+extern void irq_lock_sparse(void);
+extern void irq_unlock_sparse(void);
+#else
+static inline void irq_lock_sparse(void) { }
+static inline void irq_unlock_sparse(void) { }
 extern struct irq_desc irq_desc[NR_IRQS];
 #endif
 
@@ -103,6 +105,11 @@ static inline struct irq_desc *irq_data_to_desc(struct irq_data *data)
 #endif
 }
 
+static inline unsigned int irq_desc_get_irq(struct irq_desc *desc)
+{
+        return desc->irq_data.irq;
+}
+
 static inline struct irq_data *irq_desc_get_irq_data(struct irq_desc *desc)
 {
         return &desc->irq_data;
@@ -188,6 +195,47 @@ __irq_set_chip_handler_name_locked(unsigned int irq, struct irq_chip *chip,
         desc->name = name;
 }
 
+/**
+ * irq_set_handler_locked - Set irq handler from a locked region
+ * @data:       Pointer to the irq_data structure which identifies the irq
+ * @handler:    Flow control handler function for this interrupt
+ *
+ * Sets the handler in the irq descriptor associated to @data.
+ *
+ * Must be called with irq_desc locked and valid parameters. Typical
+ * call site is the irq_set_type() callback.
+ */
+static inline void irq_set_handler_locked(struct irq_data *data,
+                                          irq_flow_handler_t handler)
+{
+        struct irq_desc *desc = irq_data_to_desc(data);
+
+        desc->handle_irq = handler;
+}
+
+/**
+ * irq_set_chip_handler_name_locked - Set chip, handler and name from a locked region
+ * @data:       Pointer to the irq_data structure for which the chip is set
+ * @chip:       Pointer to the new irq chip
+ * @handler:    Flow control handler function for this interrupt
+ * @name:       Name of the interrupt
+ *
+ * Replace the irq chip at the proper hierarchy level in @data and
+ * sets the handler and name in the associated irq descriptor.
+ *
+ * Must be called with irq_desc locked and valid parameters.
+ */
+static inline void
+irq_set_chip_handler_name_locked(struct irq_data *data, struct irq_chip *chip,
+                                 irq_flow_handler_t handler, const char *name)
+{
+        struct irq_desc *desc = irq_data_to_desc(data);
+
+        desc->handle_irq = handler;
+        desc->name = name;
+        data->chip = chip;
+}
+
 static inline int irq_balancing_disabled(unsigned int irq)
 {
         struct irq_desc *desc;
diff --git a/include/linux/irqnr.h b/include/linux/irqnr.h
index fdd5cc16c9c4..9669bf9d4f48 100644
--- a/include/linux/irqnr.h
+++ b/include/linux/irqnr.h
@@ -23,12 +23,6 @@ unsigned int irq_get_next_irq(unsigned int offset);
                         ;                                               \
                 else
 
-#ifdef CONFIG_SMP
-#define irq_node(irq)   (irq_get_irq_data(irq)->node)
-#else
-#define irq_node(irq)   0
-#endif
-
 # define for_each_active_irq(irq)                       \
         for (irq = irq_get_next_irq(0); irq < nr_irqs;  \
              irq = irq_get_next_irq(irq + 1))
diff --git a/include/linux/jbd2.h b/include/linux/jbd2.h
index 20e7f78041c8..edb640ae9a94 100644
--- a/include/linux/jbd2.h
+++ b/include/linux/jbd2.h
@@ -1035,7 +1035,7 @@ struct buffer_head *jbd2_journal_get_descriptor_buffer(journal_t *journal);
 int jbd2_journal_next_log_block(journal_t *, unsigned long long *);
 int jbd2_journal_get_log_tail(journal_t *journal, tid_t *tid,
                               unsigned long *block);
-void __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);
+int __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);
 void jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);
 
 /* Commit management */
@@ -1157,7 +1157,7 @@ extern int	   jbd2_journal_recover    (journal_t *journal);
 extern int         jbd2_journal_wipe       (journal_t *, int);
 extern int         jbd2_journal_skip_recovery   (journal_t *);
 extern void        jbd2_journal_update_sb_errno(journal_t *);
-extern void        jbd2_journal_update_sb_log_tail      (journal_t *, tid_t,
+extern int         jbd2_journal_update_sb_log_tail      (journal_t *, tid_t,
                                 unsigned long, int);
 extern void        __jbd2_journal_abort_hard    (journal_t *);
 extern void        jbd2_journal_abort      (journal_t *, int);
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 060dd7b61c6d..5582410727cb 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -411,7 +411,8 @@ extern __printf(3, 0)
 int vscnprintf(char *buf, size_t size, const char *fmt, va_list args);
 extern __printf(2, 3)
 char *kasprintf(gfp_t gfp, const char *fmt, ...);
-extern char *kvasprintf(gfp_t gfp, const char *fmt, va_list args);
+extern __printf(2, 0)
+char *kvasprintf(gfp_t gfp, const char *fmt, va_list args);
 
 extern __scanf(2, 3)
 int sscanf(const char *, const char *, ...);
@@ -439,6 +440,9 @@ extern int panic_on_unrecovered_nmi;
 extern int panic_on_io_nmi;
 extern int panic_on_warn;
 extern int sysctl_panic_on_stackoverflow;
+
+extern bool crash_kexec_post_notifiers;
+
 /*
  * Only to be used by arch init code. If the user over-wrote the default
  * CONFIG_PANIC_TIMEOUT, honor it.
@@ -533,12 +537,6 @@ bool mac_pton(const char *s, u8 *mac);
  *
  * Most likely, you want to use tracing_on/tracing_off.
  */
-#ifdef CONFIG_RING_BUFFER
-/* trace_off_permanent stops recording with no way to bring it back */
-void tracing_off_permanent(void);
-#else
-static inline void tracing_off_permanent(void) { }
-#endif
 
 enum ftrace_dump_mode {
         DUMP_NONE,
@@ -682,10 +680,10 @@ do {									\
                 __ftrace_vprintk(_THIS_IP_, fmt, vargs);                \
 } while (0)
 
-extern int
+extern __printf(2, 0) int
 __ftrace_vbprintk(unsigned long ip, const char *fmt, va_list ap);
 
-extern int
+extern __printf(2, 0) int
 __ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap);
 
 extern void ftrace_dump(enum ftrace_dump_mode oops_dump_mode);
@@ -705,7 +703,7 @@ int trace_printk(const char *fmt, ...)
 {
         return 0;
 }
-static inline int
+static __printf(1, 0) inline int
 ftrace_vprintk(const char *fmt, va_list ap)
 {
         return 0;
@@ -819,13 +817,15 @@ static inline void ftrace_dump(enum ftrace_dump_mode oops_dump_mode) { }
 #endif
 
 /* Permissions on a sysfs file: you didn't miss the 0 prefix did you? */
-#define VERIFY_OCTAL_PERMISSIONS(perms)                                 \
-        (BUILD_BUG_ON_ZERO((perms) < 0) +                               \
-         BUILD_BUG_ON_ZERO((perms) > 0777) +                            \
-         /* User perms >= group perms >= other perms */                 \
-         BUILD_BUG_ON_ZERO(((perms) >> 6) < (((perms) >> 3) & 7)) +     \
-         BUILD_BUG_ON_ZERO((((perms) >> 3) & 7) < ((perms) & 7)) +      \
-         /* Other writable?  Generally considered a bad idea. */        \
-         BUILD_BUG_ON_ZERO((perms) & 2) +                               \
+#define VERIFY_OCTAL_PERMISSIONS(perms)                                         \
+        (BUILD_BUG_ON_ZERO((perms) < 0) +                                       \
+         BUILD_BUG_ON_ZERO((perms) > 0777) +                                    \
+         /* USER_READABLE >= GROUP_READABLE >= OTHER_READABLE */                \
+         BUILD_BUG_ON_ZERO((((perms) >> 6) & 4) < (((perms) >> 3) & 4)) +       \
+         BUILD_BUG_ON_ZERO((((perms) >> 3) & 4) < ((perms) & 4)) +              \
+         /* USER_WRITABLE >= GROUP_WRITABLE */                                  \
+         BUILD_BUG_ON_ZERO((((perms) >> 6) & 2) < (((perms) >> 3) & 2)) +       \
+         /* OTHER_WRITABLE?  Generally considered a bad idea. */                \
+         BUILD_BUG_ON_ZERO((perms) & 2) +                                       \
          (perms))
 #endif
diff --git a/include/linux/kernfs.h b/include/linux/kernfs.h
index 71ecdab1671b..123be25ea15a 100644
--- a/include/linux/kernfs.h
+++ b/include/linux/kernfs.h
@@ -45,6 +45,7 @@ enum kernfs_node_flag {
         KERNFS_LOCKDEP          = 0x0100,
         KERNFS_SUICIDAL         = 0x0400,
         KERNFS_SUICIDED         = 0x0800,
+        KERNFS_EMPTY_DIR        = 0x1000,
 };
 
 /* @flags for kernfs_create_root() */
@@ -277,6 +278,7 @@ void kernfs_put(struct kernfs_node *kn);
 
 struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry);
 struct kernfs_root *kernfs_root_from_sb(struct super_block *sb);
+struct inode *kernfs_get_inode(struct super_block *sb, struct kernfs_node *kn);
 
 struct kernfs_root *kernfs_create_root(struct kernfs_syscall_ops *scops,
                                        unsigned int flags, void *priv);
@@ -285,6 +287,8 @@ void kernfs_destroy_root(struct kernfs_root *root);
 struct kernfs_node *kernfs_create_dir_ns(struct kernfs_node *parent,
                                          const char *name, umode_t mode,
                                          void *priv, const void *ns);
+struct kernfs_node *kernfs_create_empty_dir(struct kernfs_node *parent,
+                                            const char *name);
 struct kernfs_node *__kernfs_create_file(struct kernfs_node *parent,
                                          const char *name,
                                          umode_t mode, loff_t size,
@@ -352,6 +356,10 @@ static inline struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry)
 static inline struct kernfs_root *kernfs_root_from_sb(struct super_block *sb)
 { return NULL; }
 
+static inline struct inode *
+kernfs_get_inode(struct super_block *sb, struct kernfs_node *kn)
+{ return NULL; }
+
 static inline struct kernfs_root *
 kernfs_create_root(struct kernfs_syscall_ops *scops, unsigned int flags,
                    void *priv)
diff --git a/include/linux/kmemleak.h b/include/linux/kmemleak.h
index e705467ddb47..d0a1f99e24e3 100644
--- a/include/linux/kmemleak.h
+++ b/include/linux/kmemleak.h
@@ -28,7 +28,8 @@
 extern void kmemleak_init(void) __ref;
 extern void kmemleak_alloc(const void *ptr, size_t size, int min_count,
                            gfp_t gfp) __ref;
-extern void kmemleak_alloc_percpu(const void __percpu *ptr, size_t size) __ref;
+extern void kmemleak_alloc_percpu(const void __percpu *ptr, size_t size,
+                                  gfp_t gfp) __ref;
 extern void kmemleak_free(const void *ptr) __ref;
 extern void kmemleak_free_part(const void *ptr, size_t size) __ref;
 extern void kmemleak_free_percpu(const void __percpu *ptr) __ref;
@@ -71,7 +72,8 @@ static inline void kmemleak_alloc_recursive(const void *ptr, size_t size,
                                             gfp_t gfp)
 {
 }
-static inline void kmemleak_alloc_percpu(const void __percpu *ptr, size_t size)
+static inline void kmemleak_alloc_percpu(const void __percpu *ptr, size_t size,
+                                         gfp_t gfp)
 {
 }
 static inline void kmemleak_free(const void *ptr)
diff --git a/include/linux/kobject.h b/include/linux/kobject.h
index 2d61b909f414..637f67002c5a 100644
--- a/include/linux/kobject.h
+++ b/include/linux/kobject.h
@@ -80,8 +80,9 @@ struct kobject {
 
 extern __printf(2, 3)
 int kobject_set_name(struct kobject *kobj, const char *name, ...);
-extern int kobject_set_name_vargs(struct kobject *kobj, const char *fmt,
-                                  va_list vargs);
+extern __printf(2, 0)
+int kobject_set_name_vargs(struct kobject *kobj, const char *fmt,
+                           va_list vargs);
 
 static inline const char *kobject_name(const struct kobject *kobj)
 {
diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h
index ad45054309a0..05e99b8ef465 100644
--- a/include/linux/kvm_host.h
+++ b/include/linux/kvm_host.h
@@ -44,6 +44,10 @@
 /* Two fragments for cross MMIO pages. */
 #define KVM_MAX_MMIO_FRAGMENTS  2
 
+#ifndef KVM_ADDRESS_SPACE_NUM
+#define KVM_ADDRESS_SPACE_NUM   1
+#endif
+
 /*
  * For the normal pfn, the highest 12 bits should be zero,
  * so we can mask bit 62 ~ bit 52  to indicate the error pfn,
@@ -134,6 +138,7 @@ static inline bool is_error_page(struct page *page)
 #define KVM_REQ_ENABLE_IBS        23
 #define KVM_REQ_DISABLE_IBS       24
 #define KVM_REQ_APIC_PAGE_RELOAD  25
+#define KVM_REQ_SMI               26
 
 #define KVM_USERSPACE_IRQ_SOURCE_ID             0
 #define KVM_IRQFD_RESAMPLE_IRQ_SOURCE_ID        1
@@ -230,6 +235,7 @@ struct kvm_vcpu {
 
         int fpu_active;
         int guest_fpu_loaded, guest_xcr0_loaded;
+        unsigned char fpu_counter;
         wait_queue_head_t wq;
         struct pid *pid;
         int sigset_active;
@@ -329,6 +335,13 @@ struct kvm_kernel_irq_routing_entry {
 #define KVM_MEM_SLOTS_NUM (KVM_USER_MEM_SLOTS + KVM_PRIVATE_MEM_SLOTS)
 #endif
 
+#ifndef __KVM_VCPU_MULTIPLE_ADDRESS_SPACE
+static inline int kvm_arch_vcpu_memslots_id(struct kvm_vcpu *vcpu)
+{
+        return 0;
+}
+#endif
+
 /*
  * Note:
  * memslots are not sorted by id anymore, please use id_to_memslot()
@@ -347,7 +360,7 @@ struct kvm {
         spinlock_t mmu_lock;
         struct mutex slots_lock;
         struct mm_struct *mm; /* userspace tied to this vm */
-        struct kvm_memslots *memslots;
+        struct kvm_memslots *memslots[KVM_ADDRESS_SPACE_NUM];
         struct srcu_struct srcu;
         struct srcu_struct irq_srcu;
 #ifdef CONFIG_KVM_APIC_ARCHITECTURE
@@ -462,13 +475,25 @@ void kvm_exit(void);
 void kvm_get_kvm(struct kvm *kvm);
 void kvm_put_kvm(struct kvm *kvm);
 
-static inline struct kvm_memslots *kvm_memslots(struct kvm *kvm)
+static inline struct kvm_memslots *__kvm_memslots(struct kvm *kvm, int as_id)
 {
-        return rcu_dereference_check(kvm->memslots,
+        return rcu_dereference_check(kvm->memslots[as_id],
                         srcu_read_lock_held(&kvm->srcu)
                         || lockdep_is_held(&kvm->slots_lock));
 }
 
+static inline struct kvm_memslots *kvm_memslots(struct kvm *kvm)
+{
+        return __kvm_memslots(kvm, 0);
+}
+
+static inline struct kvm_memslots *kvm_vcpu_memslots(struct kvm_vcpu *vcpu)
+{
+        int as_id = kvm_arch_vcpu_memslots_id(vcpu);
+
+        return __kvm_memslots(vcpu->kvm, as_id);
+}
+
 static inline struct kvm_memory_slot *
 id_to_memslot(struct kvm_memslots *slots, int id)
 {
@@ -500,21 +525,22 @@ enum kvm_mr_change {
 };
 
 int kvm_set_memory_region(struct kvm *kvm,
-                          struct kvm_userspace_memory_region *mem);
+                          const struct kvm_userspace_memory_region *mem);
 int __kvm_set_memory_region(struct kvm *kvm,
-                            struct kvm_userspace_memory_region *mem);
+                            const struct kvm_userspace_memory_region *mem);
 void kvm_arch_free_memslot(struct kvm *kvm, struct kvm_memory_slot *free,
                            struct kvm_memory_slot *dont);
 int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot,
                             unsigned long npages);
-void kvm_arch_memslots_updated(struct kvm *kvm);
+void kvm_arch_memslots_updated(struct kvm *kvm, struct kvm_memslots *slots);
 int kvm_arch_prepare_memory_region(struct kvm *kvm,
                                 struct kvm_memory_slot *memslot,
-                                struct kvm_userspace_memory_region *mem,
+                                const struct kvm_userspace_memory_region *mem,
                                 enum kvm_mr_change change);
 void kvm_arch_commit_memory_region(struct kvm *kvm,
-                                struct kvm_userspace_memory_region *mem,
+                                const struct kvm_userspace_memory_region *mem,
                                 const struct kvm_memory_slot *old,
+                                const struct kvm_memory_slot *new,
                                 enum kvm_mr_change change);
 bool kvm_largepages_enabled(void);
 void kvm_disable_largepages(void);
@@ -524,8 +550,8 @@ void kvm_arch_flush_shadow_all(struct kvm *kvm);
 void kvm_arch_flush_shadow_memslot(struct kvm *kvm,
                                    struct kvm_memory_slot *slot);
 
-int gfn_to_page_many_atomic(struct kvm *kvm, gfn_t gfn, struct page **pages,
-                            int nr_pages);
+int gfn_to_page_many_atomic(struct kvm_memory_slot *slot, gfn_t gfn,
+                            struct page **pages, int nr_pages);
 
 struct page *gfn_to_page(struct kvm *kvm, gfn_t gfn);
 unsigned long gfn_to_hva(struct kvm *kvm, gfn_t gfn);
@@ -538,13 +564,13 @@ void kvm_release_page_dirty(struct page *page);
 void kvm_set_page_accessed(struct page *page);
 
 pfn_t gfn_to_pfn_atomic(struct kvm *kvm, gfn_t gfn);
-pfn_t gfn_to_pfn_async(struct kvm *kvm, gfn_t gfn, bool *async,
-                       bool write_fault, bool *writable);
 pfn_t gfn_to_pfn(struct kvm *kvm, gfn_t gfn);
 pfn_t gfn_to_pfn_prot(struct kvm *kvm, gfn_t gfn, bool write_fault,
                       bool *writable);
 pfn_t gfn_to_pfn_memslot(struct kvm_memory_slot *slot, gfn_t gfn);
 pfn_t gfn_to_pfn_memslot_atomic(struct kvm_memory_slot *slot, gfn_t gfn);
+pfn_t __gfn_to_pfn_memslot(struct kvm_memory_slot *slot, gfn_t gfn, bool atomic,
+                           bool *async, bool write_fault, bool *writable);
 
 void kvm_release_pfn_clean(pfn_t pfn);
 void kvm_set_pfn_dirty(pfn_t pfn);
@@ -573,6 +599,25 @@ int kvm_is_visible_gfn(struct kvm *kvm, gfn_t gfn);
 unsigned long kvm_host_page_size(struct kvm *kvm, gfn_t gfn);
 void mark_page_dirty(struct kvm *kvm, gfn_t gfn);
 
+struct kvm_memslots *kvm_vcpu_memslots(struct kvm_vcpu *vcpu);
+struct kvm_memory_slot *kvm_vcpu_gfn_to_memslot(struct kvm_vcpu *vcpu, gfn_t gfn);
+pfn_t kvm_vcpu_gfn_to_pfn_atomic(struct kvm_vcpu *vcpu, gfn_t gfn);
+pfn_t kvm_vcpu_gfn_to_pfn(struct kvm_vcpu *vcpu, gfn_t gfn);
+struct page *kvm_vcpu_gfn_to_page(struct kvm_vcpu *vcpu, gfn_t gfn);
+unsigned long kvm_vcpu_gfn_to_hva(struct kvm_vcpu *vcpu, gfn_t gfn);
+unsigned long kvm_vcpu_gfn_to_hva_prot(struct kvm_vcpu *vcpu, gfn_t gfn, bool *writable);
+int kvm_vcpu_read_guest_page(struct kvm_vcpu *vcpu, gfn_t gfn, void *data, int offset,
+                             int len);
+int kvm_vcpu_read_guest_atomic(struct kvm_vcpu *vcpu, gpa_t gpa, void *data,
+                               unsigned long len);
+int kvm_vcpu_read_guest(struct kvm_vcpu *vcpu, gpa_t gpa, void *data,
+                        unsigned long len);
+int kvm_vcpu_write_guest_page(struct kvm_vcpu *vcpu, gfn_t gfn, const void *data,
+                              int offset, int len);
+int kvm_vcpu_write_guest(struct kvm_vcpu *vcpu, gpa_t gpa, const void *data,
+                         unsigned long len);
+void kvm_vcpu_mark_page_dirty(struct kvm_vcpu *vcpu, gfn_t gfn);
+
 void kvm_vcpu_block(struct kvm_vcpu *vcpu);
 void kvm_vcpu_kick(struct kvm_vcpu *vcpu);
 int kvm_vcpu_yield_to(struct kvm_vcpu *target);
@@ -689,6 +734,24 @@ static inline bool kvm_arch_has_noncoherent_dma(struct kvm *kvm)
         return false;
 }
 #endif
+#ifdef __KVM_HAVE_ARCH_ASSIGNED_DEVICE
+void kvm_arch_start_assignment(struct kvm *kvm);
+void kvm_arch_end_assignment(struct kvm *kvm);
+bool kvm_arch_has_assigned_device(struct kvm *kvm);
+#else
+static inline void kvm_arch_start_assignment(struct kvm *kvm)
+{
+}
+
+static inline void kvm_arch_end_assignment(struct kvm *kvm)
+{
+}
+
+static inline bool kvm_arch_has_assigned_device(struct kvm *kvm)
+{
+        return false;
+}
+#endif
 
 static inline wait_queue_head_t *kvm_arch_vcpu_wq(struct kvm_vcpu *vcpu)
 {
@@ -762,16 +825,10 @@ static inline void kvm_iommu_unmap_pages(struct kvm *kvm,
 }
 #endif
 
-static inline void kvm_guest_enter(void)
+/* must be called with irqs disabled */
+static inline void __kvm_guest_enter(void)
 {
-        unsigned long flags;
-
-        BUG_ON(preemptible());
-
-        local_irq_save(flags);
         guest_enter();
-        local_irq_restore(flags);
-
         /* KVM does not hold any references to rcu protected data when it
          * switches CPU into a guest mode. In fact switching to a guest mode
          * is very similar to exiting to userspace from rcu point of view. In
@@ -783,12 +840,27 @@ static inline void kvm_guest_enter(void)
                 rcu_virt_note_context_switch(smp_processor_id());
 }
 
+/* must be called with irqs disabled */
+static inline void __kvm_guest_exit(void)
+{
+        guest_exit();
+}
+
+static inline void kvm_guest_enter(void)
+{
+        unsigned long flags;
+
+        local_irq_save(flags);
+        __kvm_guest_enter();
+        local_irq_restore(flags);
+}
+
 static inline void kvm_guest_exit(void)
 {
         unsigned long flags;
 
         local_irq_save(flags);
-        guest_exit();
+        __kvm_guest_exit();
         local_irq_restore(flags);
 }
 
diff --git a/include/linux/kvm_types.h b/include/linux/kvm_types.h
index 931da7e917cf..1b47a185c2f0 100644
--- a/include/linux/kvm_types.h
+++ b/include/linux/kvm_types.h
@@ -28,6 +28,7 @@ struct kvm_run;
 struct kvm_userspace_memory_region;
 struct kvm_vcpu;
 struct kvm_vcpu_init;
+struct kvm_memslots;
 
 enum kvm_mr_change;
 
diff --git a/include/linux/leds.h b/include/linux/leds.h
index 9a2b000094cf..b122eeafb5dc 100644
--- a/include/linux/leds.h
+++ b/include/linux/leds.h
@@ -12,6 +12,7 @@
 #ifndef __LINUX_LEDS_H_INCLUDED
 #define __LINUX_LEDS_H_INCLUDED
 
+#include <linux/device.h>
 #include <linux/list.h>
 #include <linux/mutex.h>
 #include <linux/rwsem.h>
@@ -222,6 +223,11 @@ struct led_trigger {
         struct list_head  next_trig;
 };
 
+ssize_t led_trigger_store(struct device *dev, struct device_attribute *attr,
+                        const char *buf, size_t count);
+ssize_t led_trigger_show(struct device *dev, struct device_attribute *attr,
+                        char *buf);
+
 /* Registration functions for complex triggers */
 extern int led_trigger_register(struct led_trigger *trigger);
 extern void led_trigger_unregister(struct led_trigger *trigger);
@@ -238,6 +244,16 @@ extern void led_trigger_blink_oneshot(struct led_trigger *trigger,
                                       unsigned long *delay_on,
                                       unsigned long *delay_off,
                                       int invert);
+extern void led_trigger_set_default(struct led_classdev *led_cdev);
+extern void led_trigger_set(struct led_classdev *led_cdev,
+                        struct led_trigger *trigger);
+extern void led_trigger_remove(struct led_classdev *led_cdev);
+
+static inline void *led_get_trigger_data(struct led_classdev *led_cdev)
+{
+        return led_cdev->trigger_data;
+}
+
 /**
  * led_trigger_rename_static - rename a trigger
  * @name: the new trigger name
@@ -267,6 +283,15 @@ static inline void led_trigger_register_simple(const char *name,
 static inline void led_trigger_unregister_simple(struct led_trigger *trigger) {}
 static inline void led_trigger_event(struct led_trigger *trigger,
                                 enum led_brightness event) {}
+static inline void led_trigger_set_default(struct led_classdev *led_cdev) {}
+static inline void led_trigger_set(struct led_classdev *led_cdev,
+                                struct led_trigger *trigger) {}
+static inline void led_trigger_remove(struct led_classdev *led_cdev) {}
+static inline void *led_get_trigger_data(struct led_classdev *led_cdev)
+{
+        return NULL;
+}
+
 #endif /* CONFIG_LEDS_TRIGGERS */
 
 /* Trigger specific functions */
diff --git a/include/linux/libata.h b/include/linux/libata.h
index 28aeae46f355..c9cfbcdb8d14 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -134,7 +134,6 @@ enum {
         ATA_ALL_DEVICES         = (1 << ATA_MAX_DEVICES) - 1,
 
         ATA_SHT_EMULATED        = 1,
-        ATA_SHT_CMD_PER_LUN     = 1,
         ATA_SHT_THIS_ID         = -1,
         ATA_SHT_USE_CLUSTERING  = 1,
 
@@ -431,6 +430,9 @@ enum {
         ATA_HORKAGE_NOLPM       = (1 << 20),    /* don't use LPM */
         ATA_HORKAGE_WD_BROKEN_LPM = (1 << 21),  /* some WDs have broken LPM */
         ATA_HORKAGE_ZERO_AFTER_TRIM = (1 << 22),/* guarantees zero after trim */
+        ATA_HORKAGE_NO_NCQ_LOG  = (1 << 23),    /* don't use NCQ for log read */
+        ATA_HORKAGE_NOTRIM      = (1 << 24),    /* don't use TRIM */
+        ATA_HORKAGE_MAX_SEC_1024 = (1 << 25),   /* Limit max sects to 1024 */
 
          /* DMA mask for user DMA control: User visible values; DO NOT
             renumber */
@@ -1364,7 +1366,6 @@ extern struct device_attribute *ata_common_sdev_attrs[];
         .can_queue              = ATA_DEF_QUEUE,                \
         .tag_alloc_policy       = BLK_TAG_ALLOC_RR,             \
         .this_id                = ATA_SHT_THIS_ID,              \
-        .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,          \
         .emulated               = ATA_SHT_EMULATED,             \
         .use_clustering         = ATA_SHT_USE_CLUSTERING,       \
         .proc_name              = drv_name,                     \
diff --git a/include/linux/libfdt_env.h b/include/linux/libfdt_env.h
index 01508c7b8c81..2a663c6bb428 100644
--- a/include/linux/libfdt_env.h
+++ b/include/linux/libfdt_env.h
@@ -5,6 +5,10 @@
 
 #include <asm/byteorder.h>
 
+typedef __be16 fdt16_t;
+typedef __be32 fdt32_t;
+typedef __be64 fdt64_t;
+
 #define fdt32_to_cpu(x) be32_to_cpu(x)
 #define cpu_to_fdt32(x) cpu_to_be32(x)
 #define fdt64_to_cpu(x) be64_to_cpu(x)
diff --git a/include/linux/libnvdimm.h b/include/linux/libnvdimm.h
new file mode 100644
index 000000000000..75e3af01ee32
--- /dev/null
+++ b/include/linux/libnvdimm.h
@@ -0,0 +1,151 @@
+/*
+ * libnvdimm - Non-volatile-memory Devices Subsystem
+ *
+ * Copyright(c) 2013-2015 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ */
+#ifndef __LIBNVDIMM_H__
+#define __LIBNVDIMM_H__
+#include <linux/kernel.h>
+#include <linux/sizes.h>
+#include <linux/types.h>
+
+enum {
+        /* when a dimm supports both PMEM and BLK access a label is required */
+        NDD_ALIASING = 1 << 0,
+        /* unarmed memory devices may not persist writes */
+        NDD_UNARMED = 1 << 1,
+
+        /* need to set a limit somewhere, but yes, this is likely overkill */
+        ND_IOCTL_MAX_BUFLEN = SZ_4M,
+        ND_CMD_MAX_ELEM = 4,
+        ND_CMD_MAX_ENVELOPE = 16,
+        ND_CMD_ARS_STATUS_MAX = SZ_4K,
+        ND_MAX_MAPPINGS = 32,
+
+        /* mark newly adjusted resources as requiring a label update */
+        DPA_RESOURCE_ADJUSTED = 1 << 0,
+};
+
+extern struct attribute_group nvdimm_bus_attribute_group;
+extern struct attribute_group nvdimm_attribute_group;
+extern struct attribute_group nd_device_attribute_group;
+extern struct attribute_group nd_numa_attribute_group;
+extern struct attribute_group nd_region_attribute_group;
+extern struct attribute_group nd_mapping_attribute_group;
+
+struct nvdimm;
+struct nvdimm_bus_descriptor;
+typedef int (*ndctl_fn)(struct nvdimm_bus_descriptor *nd_desc,
+                struct nvdimm *nvdimm, unsigned int cmd, void *buf,
+                unsigned int buf_len);
+
+struct nd_namespace_label;
+struct nvdimm_drvdata;
+struct nd_mapping {
+        struct nvdimm *nvdimm;
+        struct nd_namespace_label **labels;
+        u64 start;
+        u64 size;
+        /*
+         * @ndd is for private use at region enable / disable time for
+         * get_ndd() + put_ndd(), all other nd_mapping to ndd
+         * conversions use to_ndd() which respects enabled state of the
+         * nvdimm.
+         */
+        struct nvdimm_drvdata *ndd;
+};
+
+struct nvdimm_bus_descriptor {
+        const struct attribute_group **attr_groups;
+        unsigned long dsm_mask;
+        char *provider_name;
+        ndctl_fn ndctl;
+};
+
+struct nd_cmd_desc {
+        int in_num;
+        int out_num;
+        u32 in_sizes[ND_CMD_MAX_ELEM];
+        int out_sizes[ND_CMD_MAX_ELEM];
+};
+
+struct nd_interleave_set {
+        u64 cookie;
+};
+
+struct nd_region_desc {
+        struct resource *res;
+        struct nd_mapping *nd_mapping;
+        u16 num_mappings;
+        const struct attribute_group **attr_groups;
+        struct nd_interleave_set *nd_set;
+        void *provider_data;
+        int num_lanes;
+        int numa_node;
+};
+
+struct nvdimm_bus;
+struct module;
+struct device;
+struct nd_blk_region;
+struct nd_blk_region_desc {
+        int (*enable)(struct nvdimm_bus *nvdimm_bus, struct device *dev);
+        void (*disable)(struct nvdimm_bus *nvdimm_bus, struct device *dev);
+        int (*do_io)(struct nd_blk_region *ndbr, resource_size_t dpa,
+                        void *iobuf, u64 len, int rw);
+        struct nd_region_desc ndr_desc;
+};
+
+static inline struct nd_blk_region_desc *to_blk_region_desc(
+                struct nd_region_desc *ndr_desc)
+{
+        return container_of(ndr_desc, struct nd_blk_region_desc, ndr_desc);
+
+}
+
+struct nvdimm_bus *__nvdimm_bus_register(struct device *parent,
+                struct nvdimm_bus_descriptor *nfit_desc, struct module *module);
+#define nvdimm_bus_register(parent, desc) \
+        __nvdimm_bus_register(parent, desc, THIS_MODULE)
+void nvdimm_bus_unregister(struct nvdimm_bus *nvdimm_bus);
+struct nvdimm_bus *to_nvdimm_bus(struct device *dev);
+struct nvdimm *to_nvdimm(struct device *dev);
+struct nd_region *to_nd_region(struct device *dev);
+struct nd_blk_region *to_nd_blk_region(struct device *dev);
+struct nvdimm_bus_descriptor *to_nd_desc(struct nvdimm_bus *nvdimm_bus);
+const char *nvdimm_name(struct nvdimm *nvdimm);
+void *nvdimm_provider_data(struct nvdimm *nvdimm);
+struct nvdimm *nvdimm_create(struct nvdimm_bus *nvdimm_bus, void *provider_data,
+                const struct attribute_group **groups, unsigned long flags,
+                unsigned long *dsm_mask);
+const struct nd_cmd_desc *nd_cmd_dimm_desc(int cmd);
+const struct nd_cmd_desc *nd_cmd_bus_desc(int cmd);
+u32 nd_cmd_in_size(struct nvdimm *nvdimm, int cmd,
+                const struct nd_cmd_desc *desc, int idx, void *buf);
+u32 nd_cmd_out_size(struct nvdimm *nvdimm, int cmd,
+                const struct nd_cmd_desc *desc, int idx, const u32 *in_field,
+                const u32 *out_field);
+int nvdimm_bus_check_dimm_count(struct nvdimm_bus *nvdimm_bus, int dimm_count);
+struct nd_region *nvdimm_pmem_region_create(struct nvdimm_bus *nvdimm_bus,
+                struct nd_region_desc *ndr_desc);
+struct nd_region *nvdimm_blk_region_create(struct nvdimm_bus *nvdimm_bus,
+                struct nd_region_desc *ndr_desc);
+struct nd_region *nvdimm_volatile_region_create(struct nvdimm_bus *nvdimm_bus,
+                struct nd_region_desc *ndr_desc);
+void *nd_region_provider_data(struct nd_region *nd_region);
+void *nd_blk_region_provider_data(struct nd_blk_region *ndbr);
+void nd_blk_region_set_provider_data(struct nd_blk_region *ndbr, void *data);
+struct nvdimm *nd_blk_region_to_dimm(struct nd_blk_region *ndbr);
+unsigned int nd_region_acquire_lane(struct nd_region *nd_region);
+void nd_region_release_lane(struct nd_region *nd_region, unsigned int lane);
+u64 nd_fletcher64(void *addr, size_t len, bool le);
+#endif /* __LIBNVDIMM_H__ */
diff --git a/include/linux/livepatch.h b/include/linux/livepatch.h
index ee6dbb39a809..31db7a05dd36 100644
--- a/include/linux/livepatch.h
+++ b/include/linux/livepatch.h
@@ -99,7 +99,7 @@ struct klp_object {
         struct klp_func *funcs;
 
         /* internal */
-        struct kobject *kobj;
+        struct kobject kobj;
         struct module *mod;
         enum klp_state state;
 };
@@ -123,6 +123,12 @@ struct klp_patch {
         enum klp_state state;
 };
 
+#define klp_for_each_object(patch, obj) \
+        for (obj = patch->objs; obj->funcs; obj++)
+
+#define klp_for_each_func(obj, func) \
+        for (func = obj->funcs; func->old_name; func++)
+
 int klp_register_patch(struct klp_patch *);
 int klp_unregister_patch(struct klp_patch *);
 int klp_enable_patch(struct klp_patch *);
diff --git a/include/linux/lockdep.h b/include/linux/lockdep.h
index 2722111591a3..70400dc7660f 100644
--- a/include/linux/lockdep.h
+++ b/include/linux/lockdep.h
@@ -255,6 +255,7 @@ struct held_lock {
         unsigned int check:1;       /* see lock_acquire() comment */
         unsigned int hardirqs_off:1;
         unsigned int references:12;                                     /* 32 bits */
+        unsigned int pin_count;
 };
 
 /*
@@ -354,6 +355,9 @@ extern void lockdep_set_current_reclaim_state(gfp_t gfp_mask);
 extern void lockdep_clear_current_reclaim_state(void);
 extern void lockdep_trace_alloc(gfp_t mask);
 
+extern void lock_pin_lock(struct lockdep_map *lock);
+extern void lock_unpin_lock(struct lockdep_map *lock);
+
 # define INIT_LOCKDEP                           .lockdep_recursion = 0, .lockdep_reclaim_gfp = 0,
 
 #define lockdep_depth(tsk)      (debug_locks ? (tsk)->lockdep_depth : 0)
@@ -368,6 +372,9 @@ extern void lockdep_trace_alloc(gfp_t mask);
 
 #define lockdep_recursing(tsk)  ((tsk)->lockdep_recursion)
 
+#define lockdep_pin_lock(l)             lock_pin_lock(&(l)->dep_map)
+#define lockdep_unpin_lock(l)   lock_unpin_lock(&(l)->dep_map)
+
 #else /* !CONFIG_LOCKDEP */
 
 static inline void lockdep_off(void)
@@ -420,6 +427,9 @@ struct lock_class_key { };
 
 #define lockdep_recursing(tsk)                  (0)
 
+#define lockdep_pin_lock(l)                             do { (void)(l); } while (0)
+#define lockdep_unpin_lock(l)                   do { (void)(l); } while (0)
+
 #endif /* !LOCKDEP */
 
 #ifdef CONFIG_LOCK_STAT
diff --git a/include/linux/lsm_hooks.h b/include/linux/lsm_hooks.h
new file mode 100644
index 000000000000..9429f054c323
--- /dev/null
+++ b/include/linux/lsm_hooks.h
@@ -0,0 +1,1888 @@
+/*
+ * Linux Security Module interfaces
+ *
+ * Copyright (C) 2001 WireX Communications, Inc <chris@wirex.com>
+ * Copyright (C) 2001 Greg Kroah-Hartman <greg@kroah.com>
+ * Copyright (C) 2001 Networks Associates Technology, Inc <ssmalley@nai.com>
+ * Copyright (C) 2001 James Morris <jmorris@intercode.com.au>
+ * Copyright (C) 2001 Silicon Graphics, Inc. (Trust Technology Group)
+ * Copyright (C) 2015 Intel Corporation.
+ * Copyright (C) 2015 Casey Schaufler <casey@schaufler-ca.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.
+ *
+ *      Due to this file being licensed under the GPL there is controversy over
+ *      whether this permits you to write a module that #includes this file
+ *      without placing your module under the GPL.  Please consult a lawyer for
+ *      advice before doing this.
+ *
+ */
+
+#ifndef __LINUX_LSM_HOOKS_H
+#define __LINUX_LSM_HOOKS_H
+
+#include <linux/security.h>
+#include <linux/init.h>
+#include <linux/rculist.h>
+
+/**
+ * Security hooks for program execution operations.
+ *
+ * @bprm_set_creds:
+ *      Save security information in the bprm->security field, typically based
+ *      on information about the bprm->file, for later use by the apply_creds
+ *      hook.  This hook may also optionally check permissions (e.g. for
+ *      transitions between security domains).
+ *      This hook may be called multiple times during a single execve, e.g. for
+ *      interpreters.  The hook can tell whether it has already been called by
+ *      checking to see if @bprm->security is non-NULL.  If so, then the hook
+ *      may decide either to retain the security information saved earlier or
+ *      to replace it.
+ *      @bprm contains the linux_binprm structure.
+ *      Return 0 if the hook is successful and permission is granted.
+ * @bprm_check_security:
+ *      This hook mediates the point when a search for a binary handler will
+ *      begin.  It allows a check the @bprm->security value which is set in the
+ *      preceding set_creds call.  The primary difference from set_creds is
+ *      that the argv list and envp list are reliably available in @bprm.  This
+ *      hook may be called multiple times during a single execve; and in each
+ *      pass set_creds is called first.
+ *      @bprm contains the linux_binprm structure.
+ *      Return 0 if the hook is successful and permission is granted.
+ * @bprm_committing_creds:
+ *      Prepare to install the new security attributes of a process being
+ *      transformed by an execve operation, based on the old credentials
+ *      pointed to by @current->cred and the information set in @bprm->cred by
+ *      the bprm_set_creds hook.  @bprm points to the linux_binprm structure.
+ *      This hook is a good place to perform state changes on the process such
+ *      as closing open file descriptors to which access will no longer be
+ *      granted when the attributes are changed.  This is called immediately
+ *      before commit_creds().
+ * @bprm_committed_creds:
+ *      Tidy up after the installation of the new security attributes of a
+ *      process being transformed by an execve operation.  The new credentials
+ *      have, by this point, been set to @current->cred.  @bprm points to the
+ *      linux_binprm structure.  This hook is a good place to perform state
+ *      changes on the process such as clearing out non-inheritable signal
+ *      state.  This is called immediately after commit_creds().
+ * @bprm_secureexec:
+ *      Return a boolean value (0 or 1) indicating whether a "secure exec"
+ *      is required.  The flag is passed in the auxiliary table
+ *      on the initial stack to the ELF interpreter to indicate whether libc
+ *      should enable secure mode.
+ *      @bprm contains the linux_binprm structure.
+ *
+ * Security hooks for filesystem operations.
+ *
+ * @sb_alloc_security:
+ *      Allocate and attach a security structure to the sb->s_security field.
+ *      The s_security field is initialized to NULL when the structure is
+ *      allocated.
+ *      @sb contains the super_block structure to be modified.
+ *      Return 0 if operation was successful.
+ * @sb_free_security:
+ *      Deallocate and clear the sb->s_security field.
+ *      @sb contains the super_block structure to be modified.
+ * @sb_statfs:
+ *      Check permission before obtaining filesystem statistics for the @mnt
+ *      mountpoint.
+ *      @dentry is a handle on the superblock for the filesystem.
+ *      Return 0 if permission is granted.
+ * @sb_mount:
+ *      Check permission before an object specified by @dev_name is mounted on
+ *      the mount point named by @nd.  For an ordinary mount, @dev_name
+ *      identifies a device if the file system type requires a device.  For a
+ *      remount (@flags & MS_REMOUNT), @dev_name is irrelevant.  For a
+ *      loopback/bind mount (@flags & MS_BIND), @dev_name identifies the
+ *      pathname of the object being mounted.
+ *      @dev_name contains the name for object being mounted.
+ *      @path contains the path for mount point object.
+ *      @type contains the filesystem type.
+ *      @flags contains the mount flags.
+ *      @data contains the filesystem-specific data.
+ *      Return 0 if permission is granted.
+ * @sb_copy_data:
+ *      Allow mount option data to be copied prior to parsing by the filesystem,
+ *      so that the security module can extract security-specific mount
+ *      options cleanly (a filesystem may modify the data e.g. with strsep()).
+ *      This also allows the original mount data to be stripped of security-
+ *      specific options to avoid having to make filesystems aware of them.
+ *      @type the type of filesystem being mounted.
+ *      @orig the original mount data copied from userspace.
+ *      @copy copied data which will be passed to the security module.
+ *      Returns 0 if the copy was successful.
+ * @sb_remount:
+ *      Extracts security system specific mount options and verifies no changes
+ *      are being made to those options.
+ *      @sb superblock being remounted
+ *      @data contains the filesystem-specific data.
+ *      Return 0 if permission is granted.
+ * @sb_umount:
+ *      Check permission before the @mnt file system is unmounted.
+ *      @mnt contains the mounted file system.
+ *      @flags contains the unmount flags, e.g. MNT_FORCE.
+ *      Return 0 if permission is granted.
+ * @sb_pivotroot:
+ *      Check permission before pivoting the root filesystem.
+ *      @old_path contains the path for the new location of the
+ *      current root (put_old).
+ *      @new_path contains the path for the new root (new_root).
+ *      Return 0 if permission is granted.
+ * @sb_set_mnt_opts:
+ *      Set the security relevant mount options used for a superblock
+ *      @sb the superblock to set security mount options for
+ *      @opts binary data structure containing all lsm mount data
+ * @sb_clone_mnt_opts:
+ *      Copy all security options from a given superblock to another
+ *      @oldsb old superblock which contain information to clone
+ *      @newsb new superblock which needs filled in
+ * @sb_parse_opts_str:
+ *      Parse a string of security data filling in the opts structure
+ *      @options string containing all mount options known by the LSM
+ *      @opts binary data structure usable by the LSM
+ * @dentry_init_security:
+ *      Compute a context for a dentry as the inode is not yet available
+ *      since NFSv4 has no label backed by an EA anyway.
+ *      @dentry dentry to use in calculating the context.
+ *      @mode mode used to determine resource type.
+ *      @name name of the last path component used to create file
+ *      @ctx pointer to place the pointer to the resulting context in.
+ *      @ctxlen point to place the length of the resulting context.
+ *
+ *
+ * Security hooks for inode operations.
+ *
+ * @inode_alloc_security:
+ *      Allocate and attach a security structure to @inode->i_security.  The
+ *      i_security field is initialized to NULL when the inode structure is
+ *      allocated.
+ *      @inode contains the inode structure.
+ *      Return 0 if operation was successful.
+ * @inode_free_security:
+ *      @inode contains the inode structure.
+ *      Deallocate the inode security structure and set @inode->i_security to
+ *      NULL.
+ * @inode_init_security:
+ *      Obtain the security attribute name suffix and value to set on a newly
+ *      created inode and set up the incore security field for the new inode.
+ *      This hook is called by the fs code as part of the inode creation
+ *      transaction and provides for atomic labeling of the inode, unlike
+ *      the post_create/mkdir/... hooks called by the VFS.  The hook function
+ *      is expected to allocate the name and value via kmalloc, with the caller
+ *      being responsible for calling kfree after using them.
+ *      If the security module does not use security attributes or does
+ *      not wish to put a security attribute on this particular inode,
+ *      then it should return -EOPNOTSUPP to skip this processing.
+ *      @inode contains the inode structure of the newly created inode.
+ *      @dir contains the inode structure of the parent directory.
+ *      @qstr contains the last path component of the new object
+ *      @name will be set to the allocated name suffix (e.g. selinux).
+ *      @value will be set to the allocated attribute value.
+ *      @len will be set to the length of the value.
+ *      Returns 0 if @name and @value have been successfully set,
+ *              -EOPNOTSUPP if no security attribute is needed, or
+ *              -ENOMEM on memory allocation failure.
+ * @inode_create:
+ *      Check permission to create a regular file.
+ *      @dir contains inode structure of the parent of the new file.
+ *      @dentry contains the dentry structure for the file to be created.
+ *      @mode contains the file mode of the file to be created.
+ *      Return 0 if permission is granted.
+ * @inode_link:
+ *      Check permission before creating a new hard link to a file.
+ *      @old_dentry contains the dentry structure for an existing
+ *      link to the file.
+ *      @dir contains the inode structure of the parent directory
+ *      of the new link.
+ *      @new_dentry contains the dentry structure for the new link.
+ *      Return 0 if permission is granted.
+ * @path_link:
+ *      Check permission before creating a new hard link to a file.
+ *      @old_dentry contains the dentry structure for an existing link
+ *      to the file.
+ *      @new_dir contains the path structure of the parent directory of
+ *      the new link.
+ *      @new_dentry contains the dentry structure for the new link.
+ *      Return 0 if permission is granted.
+ * @inode_unlink:
+ *      Check the permission to remove a hard link to a file.
+ *      @dir contains the inode structure of parent directory of the file.
+ *      @dentry contains the dentry structure for file to be unlinked.
+ *      Return 0 if permission is granted.
+ * @path_unlink:
+ *      Check the permission to remove a hard link to a file.
+ *      @dir contains the path structure of parent directory of the file.
+ *      @dentry contains the dentry structure for file to be unlinked.
+ *      Return 0 if permission is granted.
+ * @inode_symlink:
+ *      Check the permission to create a symbolic link to a file.
+ *      @dir contains the inode structure of parent directory of
+ *      the symbolic link.
+ *      @dentry contains the dentry structure of the symbolic link.
+ *      @old_name contains the pathname of file.
+ *      Return 0 if permission is granted.
+ * @path_symlink:
+ *      Check the permission to create a symbolic link to a file.
+ *      @dir contains the path structure of parent directory of
+ *      the symbolic link.
+ *      @dentry contains the dentry structure of the symbolic link.
+ *      @old_name contains the pathname of file.
+ *      Return 0 if permission is granted.
+ * @inode_mkdir:
+ *      Check permissions to create a new directory in the existing directory
+ *      associated with inode structure @dir.
+ *      @dir contains the inode structure of parent of the directory
+ *      to be created.
+ *      @dentry contains the dentry structure of new directory.
+ *      @mode contains the mode of new directory.
+ *      Return 0 if permission is granted.
+ * @path_mkdir:
+ *      Check permissions to create a new directory in the existing directory
+ *      associated with path structure @path.
+ *      @dir contains the path structure of parent of the directory
+ *      to be created.
+ *      @dentry contains the dentry structure of new directory.
+ *      @mode contains the mode of new directory.
+ *      Return 0 if permission is granted.
+ * @inode_rmdir:
+ *      Check the permission to remove a directory.
+ *      @dir contains the inode structure of parent of the directory
+ *      to be removed.
+ *      @dentry contains the dentry structure of directory to be removed.
+ *      Return 0 if permission is granted.
+ * @path_rmdir:
+ *      Check the permission to remove a directory.
+ *      @dir contains the path structure of parent of the directory to be
+ *      removed.
+ *      @dentry contains the dentry structure of directory to be removed.
+ *      Return 0 if permission is granted.
+ * @inode_mknod:
+ *      Check permissions when creating a special file (or a socket or a fifo
+ *      file created via the mknod system call).  Note that if mknod operation
+ *      is being done for a regular file, then the create hook will be called
+ *      and not this hook.
+ *      @dir contains the inode structure of parent of the new file.
+ *      @dentry contains the dentry structure of the new file.
+ *      @mode contains the mode of the new file.
+ *      @dev contains the device number.
+ *      Return 0 if permission is granted.
+ * @path_mknod:
+ *      Check permissions when creating a file. Note that this hook is called
+ *      even if mknod operation is being done for a regular file.
+ *      @dir contains the path structure of parent of the new file.
+ *      @dentry contains the dentry structure of the new file.
+ *      @mode contains the mode of the new file.
+ *      @dev contains the undecoded device number. Use new_decode_dev() to get
+ *      the decoded device number.
+ *      Return 0 if permission is granted.
+ * @inode_rename:
+ *      Check for permission to rename a file or directory.
+ *      @old_dir contains the inode structure for parent of the old link.
+ *      @old_dentry contains the dentry structure of the old link.
+ *      @new_dir contains the inode structure for parent of the new link.
+ *      @new_dentry contains the dentry structure of the new link.
+ *      Return 0 if permission is granted.
+ * @path_rename:
+ *      Check for permission to rename a file or directory.
+ *      @old_dir contains the path structure for parent of the old link.
+ *      @old_dentry contains the dentry structure of the old link.
+ *      @new_dir contains the path structure for parent of the new link.
+ *      @new_dentry contains the dentry structure of the new link.
+ *      Return 0 if permission is granted.
+ * @path_chmod:
+ *      Check for permission to change DAC's permission of a file or directory.
+ *      @dentry contains the dentry structure.
+ *      @mnt contains the vfsmnt structure.
+ *      @mode contains DAC's mode.
+ *      Return 0 if permission is granted.
+ * @path_chown:
+ *      Check for permission to change owner/group of a file or directory.
+ *      @path contains the path structure.
+ *      @uid contains new owner's ID.
+ *      @gid contains new group's ID.
+ *      Return 0 if permission is granted.
+ * @path_chroot:
+ *      Check for permission to change root directory.
+ *      @path contains the path structure.
+ *      Return 0 if permission is granted.
+ * @inode_readlink:
+ *      Check the permission to read the symbolic link.
+ *      @dentry contains the dentry structure for the file link.
+ *      Return 0 if permission is granted.
+ * @inode_follow_link:
+ *      Check permission to follow a symbolic link when looking up a pathname.
+ *      @dentry contains the dentry structure for the link.
+ *      @inode contains the inode, which itself is not stable in RCU-walk
+ *      @rcu indicates whether we are in RCU-walk mode.
+ *      Return 0 if permission is granted.
+ * @inode_permission:
+ *      Check permission before accessing an inode.  This hook is called by the
+ *      existing Linux permission function, so a security module can use it to
+ *      provide additional checking for existing Linux permission checks.
+ *      Notice that this hook is called when a file is opened (as well as many
+ *      other operations), whereas the file_security_ops permission hook is
+ *      called when the actual read/write operations are performed.
+ *      @inode contains the inode structure to check.
+ *      @mask contains the permission mask.
+ *      Return 0 if permission is granted.
+ * @inode_setattr:
+ *      Check permission before setting file attributes.  Note that the kernel
+ *      call to notify_change is performed from several locations, whenever
+ *      file attributes change (such as when a file is truncated, chown/chmod
+ *      operations, transferring disk quotas, etc).
+ *      @dentry contains the dentry structure for the file.
+ *      @attr is the iattr structure containing the new file attributes.
+ *      Return 0 if permission is granted.
+ * @path_truncate:
+ *      Check permission before truncating a file.
+ *      @path contains the path structure for the file.
+ *      Return 0 if permission is granted.
+ * @inode_getattr:
+ *      Check permission before obtaining file attributes.
+ *      @mnt is the vfsmount where the dentry was looked up
+ *      @dentry contains the dentry structure for the file.
+ *      Return 0 if permission is granted.
+ * @inode_setxattr:
+ *      Check permission before setting the extended attributes
+ *      @value identified by @name for @dentry.
+ *      Return 0 if permission is granted.
+ * @inode_post_setxattr:
+ *      Update inode security field after successful setxattr operation.
+ *      @value identified by @name for @dentry.
+ * @inode_getxattr:
+ *      Check permission before obtaining the extended attributes
+ *      identified by @name for @dentry.
+ *      Return 0 if permission is granted.
+ * @inode_listxattr:
+ *      Check permission before obtaining the list of extended attribute
+ *      names for @dentry.
+ *      Return 0 if permission is granted.
+ * @inode_removexattr:
+ *      Check permission before removing the extended attribute
+ *      identified by @name for @dentry.
+ *      Return 0 if permission is granted.
+ * @inode_getsecurity:
+ *      Retrieve a copy of the extended attribute representation of the
+ *      security label associated with @name for @inode via @buffer.  Note that
+ *      @name is the remainder of the attribute name after the security prefix
+ *      has been removed. @alloc is used to specify of the call should return a
+ *      value via the buffer or just the value length Return size of buffer on
+ *      success.
+ * @inode_setsecurity:
+ *      Set the security label associated with @name for @inode from the
+ *      extended attribute value @value.  @size indicates the size of the
+ *      @value in bytes.  @flags may be XATTR_CREATE, XATTR_REPLACE, or 0.
+ *      Note that @name is the remainder of the attribute name after the
+ *      security. prefix has been removed.
+ *      Return 0 on success.
+ * @inode_listsecurity:
+ *      Copy the extended attribute names for the security labels
+ *      associated with @inode into @buffer.  The maximum size of @buffer
+ *      is specified by @buffer_size.  @buffer may be NULL to request
+ *      the size of the buffer required.
+ *      Returns number of bytes used/required on success.
+ * @inode_need_killpriv:
+ *      Called when an inode has been changed.
+ *      @dentry is the dentry being changed.
+ *      Return <0 on error to abort the inode change operation.
+ *      Return 0 if inode_killpriv does not need to be called.
+ *      Return >0 if inode_killpriv does need to be called.
+ * @inode_killpriv:
+ *      The setuid bit is being removed.  Remove similar security labels.
+ *      Called with the dentry->d_inode->i_mutex held.
+ *      @dentry is the dentry being changed.
+ *      Return 0 on success.  If error is returned, then the operation
+ *      causing setuid bit removal is failed.
+ * @inode_getsecid:
+ *      Get the secid associated with the node.
+ *      @inode contains a pointer to the inode.
+ *      @secid contains a pointer to the location where result will be saved.
+ *      In case of failure, @secid will be set to zero.
+ *
+ * Security hooks for file operations
+ *
+ * @file_permission:
+ *      Check file permissions before accessing an open file.  This hook is
+ *      called by various operations that read or write files.  A security
+ *      module can use this hook to perform additional checking on these
+ *      operations, e.g.  to revalidate permissions on use to support privilege
+ *      bracketing or policy changes.  Notice that this hook is used when the
+ *      actual read/write operations are performed, whereas the
+ *      inode_security_ops hook is called when a file is opened (as well as
+ *      many other operations).
+ *      Caveat:  Although this hook can be used to revalidate permissions for
+ *      various system call operations that read or write files, it does not
+ *      address the revalidation of permissions for memory-mapped files.
+ *      Security modules must handle this separately if they need such
+ *      revalidation.
+ *      @file contains the file structure being accessed.
+ *      @mask contains the requested permissions.
+ *      Return 0 if permission is granted.
+ * @file_alloc_security:
+ *      Allocate and attach a security structure to the file->f_security field.
+ *      The security field is initialized to NULL when the structure is first
+ *      created.
+ *      @file contains the file structure to secure.
+ *      Return 0 if the hook is successful and permission is granted.
+ * @file_free_security:
+ *      Deallocate and free any security structures stored in file->f_security.
+ *      @file contains the file structure being modified.
+ * @file_ioctl:
+ *      @file contains the file structure.
+ *      @cmd contains the operation to perform.
+ *      @arg contains the operational arguments.
+ *      Check permission for an ioctl operation on @file.  Note that @arg
+ *      sometimes represents a user space pointer; in other cases, it may be a
+ *      simple integer value.  When @arg represents a user space pointer, it
+ *      should never be used by the security module.
+ *      Return 0 if permission is granted.
+ * @mmap_addr :
+ *      Check permissions for a mmap operation at @addr.
+ *      @addr contains virtual address that will be used for the operation.
+ *      Return 0 if permission is granted.
+ * @mmap_file :
+ *      Check permissions for a mmap operation.  The @file may be NULL, e.g.
+ *      if mapping anonymous memory.
+ *      @file contains the file structure for file to map (may be NULL).
+ *      @reqprot contains the protection requested by the application.
+ *      @prot contains the protection that will be applied by the kernel.
+ *      @flags contains the operational flags.
+ *      Return 0 if permission is granted.
+ * @file_mprotect:
+ *      Check permissions before changing memory access permissions.
+ *      @vma contains the memory region to modify.
+ *      @reqprot contains the protection requested by the application.
+ *      @prot contains the protection that will be applied by the kernel.
+ *      Return 0 if permission is granted.
+ * @file_lock:
+ *      Check permission before performing file locking operations.
+ *      Note: this hook mediates both flock and fcntl style locks.
+ *      @file contains the file structure.
+ *      @cmd contains the posix-translated lock operation to perform
+ *      (e.g. F_RDLCK, F_WRLCK).
+ *      Return 0 if permission is granted.
+ * @file_fcntl:
+ *      Check permission before allowing the file operation specified by @cmd
+ *      from being performed on the file @file.  Note that @arg sometimes
+ *      represents a user space pointer; in other cases, it may be a simple
+ *      integer value.  When @arg represents a user space pointer, it should
+ *      never be used by the security module.
+ *      @file contains the file structure.
+ *      @cmd contains the operation to be performed.
+ *      @arg contains the operational arguments.
+ *      Return 0 if permission is granted.
+ * @file_set_fowner:
+ *      Save owner security information (typically from current->security) in
+ *      file->f_security for later use by the send_sigiotask hook.
+ *      @file contains the file structure to update.
+ *      Return 0 on success.
+ * @file_send_sigiotask:
+ *      Check permission for the file owner @fown to send SIGIO or SIGURG to the
+ *      process @tsk.  Note that this hook is sometimes called from interrupt.
+ *      Note that the fown_struct, @fown, is never outside the context of a
+ *      struct file, so the file structure (and associated security information)
+ *      can always be obtained:
+ *              container_of(fown, struct file, f_owner)
+ *      @tsk contains the structure of task receiving signal.
+ *      @fown contains the file owner information.
+ *      @sig is the signal that will be sent.  When 0, kernel sends SIGIO.
+ *      Return 0 if permission is granted.
+ * @file_receive:
+ *      This hook allows security modules to control the ability of a process
+ *      to receive an open file descriptor via socket IPC.
+ *      @file contains the file structure being received.
+ *      Return 0 if permission is granted.
+ * @file_open
+ *      Save open-time permission checking state for later use upon
+ *      file_permission, and recheck access if anything has changed
+ *      since inode_permission.
+ *
+ * Security hooks for task operations.
+ *
+ * @task_create:
+ *      Check permission before creating a child process.  See the clone(2)
+ *      manual page for definitions of the @clone_flags.
+ *      @clone_flags contains the flags indicating what should be shared.
+ *      Return 0 if permission is granted.
+ * @task_free:
+ *      @task task being freed
+ *      Handle release of task-related resources. (Note that this can be called
+ *      from interrupt context.)
+ * @cred_alloc_blank:
+ *      @cred points to the credentials.
+ *      @gfp indicates the atomicity of any memory allocations.
+ *      Only allocate sufficient memory and attach to @cred such that
+ *      cred_transfer() will not get ENOMEM.
+ * @cred_free:
+ *      @cred points to the credentials.
+ *      Deallocate and clear the cred->security field in a set of credentials.
+ * @cred_prepare:
+ *      @new points to the new credentials.
+ *      @old points to the original credentials.
+ *      @gfp indicates the atomicity of any memory allocations.
+ *      Prepare a new set of credentials by copying the data from the old set.
+ * @cred_transfer:
+ *      @new points to the new credentials.
+ *      @old points to the original credentials.
+ *      Transfer data from original creds to new creds
+ * @kernel_act_as:
+ *      Set the credentials for a kernel service to act as (subjective context).
+ *      @new points to the credentials to be modified.
+ *      @secid specifies the security ID to be set
+ *      The current task must be the one that nominated @secid.
+ *      Return 0 if successful.
+ * @kernel_create_files_as:
+ *      Set the file creation context in a set of credentials to be the same as
+ *      the objective context of the specified inode.
+ *      @new points to the credentials to be modified.
+ *      @inode points to the inode to use as a reference.
+ *      The current task must be the one that nominated @inode.
+ *      Return 0 if successful.
+ * @kernel_fw_from_file:
+ *      Load firmware from userspace (not called for built-in firmware).
+ *      @file contains the file structure pointing to the file containing
+ *      the firmware to load. This argument will be NULL if the firmware
+ *      was loaded via the uevent-triggered blob-based interface exposed
+ *      by CONFIG_FW_LOADER_USER_HELPER.
+ *      @buf pointer to buffer containing firmware contents.
+ *      @size length of the firmware contents.
+ *      Return 0 if permission is granted.
+ * @kernel_module_request:
+ *      Ability to trigger the kernel to automatically upcall to userspace for
+ *      userspace to load a kernel module with the given name.
+ *      @kmod_name name of the module requested by the kernel
+ *      Return 0 if successful.
+ * @kernel_module_from_file:
+ *      Load a kernel module from userspace.
+ *      @file contains the file structure pointing to the file containing
+ *      the kernel module to load. If the module is being loaded from a blob,
+ *      this argument will be NULL.
+ *      Return 0 if permission is granted.
+ * @task_fix_setuid:
+ *      Update the module's state after setting one or more of the user
+ *      identity attributes of the current process.  The @flags parameter
+ *      indicates which of the set*uid system calls invoked this hook.  If
+ *      @new is the set of credentials that will be installed.  Modifications
+ *      should be made to this rather than to @current->cred.
+ *      @old is the set of credentials that are being replaces
+ *      @flags contains one of the LSM_SETID_* values.
+ *      Return 0 on success.
+ * @task_setpgid:
+ *      Check permission before setting the process group identifier of the
+ *      process @p to @pgid.
+ *      @p contains the task_struct for process being modified.
+ *      @pgid contains the new pgid.
+ *      Return 0 if permission is granted.
+ * @task_getpgid:
+ *      Check permission before getting the process group identifier of the
+ *      process @p.
+ *      @p contains the task_struct for the process.
+ *      Return 0 if permission is granted.
+ * @task_getsid:
+ *      Check permission before getting the session identifier of the process
+ *      @p.
+ *      @p contains the task_struct for the process.
+ *      Return 0 if permission is granted.
+ * @task_getsecid:
+ *      Retrieve the security identifier of the process @p.
+ *      @p contains the task_struct for the process and place is into @secid.
+ *      In case of failure, @secid will be set to zero.
+ *
+ * @task_setnice:
+ *      Check permission before setting the nice value of @p to @nice.
+ *      @p contains the task_struct of process.
+ *      @nice contains the new nice value.
+ *      Return 0 if permission is granted.
+ * @task_setioprio
+ *      Check permission before setting the ioprio value of @p to @ioprio.
+ *      @p contains the task_struct of process.
+ *      @ioprio contains the new ioprio value
+ *      Return 0 if permission is granted.
+ * @task_getioprio
+ *      Check permission before getting the ioprio value of @p.
+ *      @p contains the task_struct of process.
+ *      Return 0 if permission is granted.
+ * @task_setrlimit:
+ *      Check permission before setting the resource limits of the current
+ *      process for @resource to @new_rlim.  The old resource limit values can
+ *      be examined by dereferencing (current->signal->rlim + resource).
+ *      @resource contains the resource whose limit is being set.
+ *      @new_rlim contains the new limits for @resource.
+ *      Return 0 if permission is granted.
+ * @task_setscheduler:
+ *      Check permission before setting scheduling policy and/or parameters of
+ *      process @p based on @policy and @lp.
+ *      @p contains the task_struct for process.
+ *      @policy contains the scheduling policy.
+ *      @lp contains the scheduling parameters.
+ *      Return 0 if permission is granted.
+ * @task_getscheduler:
+ *      Check permission before obtaining scheduling information for process
+ *      @p.
+ *      @p contains the task_struct for process.
+ *      Return 0 if permission is granted.
+ * @task_movememory
+ *      Check permission before moving memory owned by process @p.
+ *      @p contains the task_struct for process.
+ *      Return 0 if permission is granted.
+ * @task_kill:
+ *      Check permission before sending signal @sig to @p.  @info can be NULL,
+ *      the constant 1, or a pointer to a siginfo structure.  If @info is 1 or
+ *      SI_FROMKERNEL(info) is true, then the signal should be viewed as coming
+ *      from the kernel and should typically be permitted.
+ *      SIGIO signals are handled separately by the send_sigiotask hook in
+ *      file_security_ops.
+ *      @p contains the task_struct for process.
+ *      @info contains the signal information.
+ *      @sig contains the signal value.
+ *      @secid contains the sid of the process where the signal originated
+ *      Return 0 if permission is granted.
+ * @task_wait:
+ *      Check permission before allowing a process to reap a child process @p
+ *      and collect its status information.
+ *      @p contains the task_struct for process.
+ *      Return 0 if permission is granted.
+ * @task_prctl:
+ *      Check permission before performing a process control operation on the
+ *      current process.
+ *      @option contains the operation.
+ *      @arg2 contains a argument.
+ *      @arg3 contains a argument.
+ *      @arg4 contains a argument.
+ *      @arg5 contains a argument.
+ *      Return -ENOSYS if no-one wanted to handle this op, any other value to
+ *      cause prctl() to return immediately with that value.
+ * @task_to_inode:
+ *      Set the security attributes for an inode based on an associated task's
+ *      security attributes, e.g. for /proc/pid inodes.
+ *      @p contains the task_struct for the task.
+ *      @inode contains the inode structure for the inode.
+ *
+ * Security hooks for Netlink messaging.
+ *
+ * @netlink_send:
+ *      Save security information for a netlink message so that permission
+ *      checking can be performed when the message is processed.  The security
+ *      information can be saved using the eff_cap field of the
+ *      netlink_skb_parms structure.  Also may be used to provide fine
+ *      grained control over message transmission.
+ *      @sk associated sock of task sending the message.
+ *      @skb contains the sk_buff structure for the netlink message.
+ *      Return 0 if the information was successfully saved and message
+ *      is allowed to be transmitted.
+ *
+ * Security hooks for Unix domain networking.
+ *
+ * @unix_stream_connect:
+ *      Check permissions before establishing a Unix domain stream connection
+ *      between @sock and @other.
+ *      @sock contains the sock structure.
+ *      @other contains the peer sock structure.
+ *      @newsk contains the new sock structure.
+ *      Return 0 if permission is granted.
+ * @unix_may_send:
+ *      Check permissions before connecting or sending datagrams from @sock to
+ *      @other.
+ *      @sock contains the 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
+ * Linux provides an alternative to the conventional file name space for Unix
+ * domain sockets.  Whereas binding and connecting to sockets in the file name
+ * space is mediated by the typical file permissions (and caught by the mknod
+ * and permission hooks in inode_security_ops), binding and connecting to
+ * sockets in the abstract name space is completely unmediated.  Sufficient
+ * control of Unix domain sockets in the abstract name space isn't possible
+ * using only the socket layer hooks, since we need to know the actual target
+ * socket, which is not looked up until we are inside the af_unix code.
+ *
+ * Security hooks for socket operations.
+ *
+ * @socket_create:
+ *      Check permissions prior to creating a new socket.
+ *      @family contains the requested protocol family.
+ *      @type contains the requested communications type.
+ *      @protocol contains the requested protocol.
+ *      @kern set to 1 if a kernel socket.
+ *      Return 0 if permission is granted.
+ * @socket_post_create:
+ *      This hook allows a module to update or allocate a per-socket security
+ *      structure. Note that the security field was not added directly to the
+ *      socket structure, but rather, the socket security information is stored
+ *      in the associated inode.  Typically, the inode alloc_security hook will
+ *      allocate and and attach security information to
+ *      sock->inode->i_security.  This hook may be used to update the
+ *      sock->inode->i_security field with additional information that wasn't
+ *      available when the inode was allocated.
+ *      @sock contains the newly created socket structure.
+ *      @family contains the requested protocol family.
+ *      @type contains the requested communications type.
+ *      @protocol contains the requested protocol.
+ *      @kern set to 1 if a kernel socket.
+ * @socket_bind:
+ *      Check permission before socket protocol layer bind operation is
+ *      performed and the socket @sock is bound to the address specified in the
+ *      @address parameter.
+ *      @sock contains the socket structure.
+ *      @address contains the address to bind to.
+ *      @addrlen contains the length of address.
+ *      Return 0 if permission is granted.
+ * @socket_connect:
+ *      Check permission before socket protocol layer connect operation
+ *      attempts to connect socket @sock to a remote address, @address.
+ *      @sock contains the socket structure.
+ *      @address contains the address of remote endpoint.
+ *      @addrlen contains the length of address.
+ *      Return 0 if permission is granted.
+ * @socket_listen:
+ *      Check permission before socket protocol layer listen operation.
+ *      @sock contains the socket structure.
+ *      @backlog contains the maximum length for the pending connection queue.
+ *      Return 0 if permission is granted.
+ * @socket_accept:
+ *      Check permission before accepting a new connection.  Note that the new
+ *      socket, @newsock, has been created and some information copied to it,
+ *      but the accept operation has not actually been performed.
+ *      @sock contains the listening socket structure.
+ *      @newsock contains the newly created server socket for connection.
+ *      Return 0 if permission is granted.
+ * @socket_sendmsg:
+ *      Check permission before transmitting a message to another socket.
+ *      @sock contains the socket structure.
+ *      @msg contains the message to be transmitted.
+ *      @size contains the size of message.
+ *      Return 0 if permission is granted.
+ * @socket_recvmsg:
+ *      Check permission before receiving a message from a socket.
+ *      @sock contains the socket structure.
+ *      @msg contains the message structure.
+ *      @size contains the size of message structure.
+ *      @flags contains the operational flags.
+ *      Return 0 if permission is granted.
+ * @socket_getsockname:
+ *      Check permission before the local address (name) of the socket object
+ *      @sock is retrieved.
+ *      @sock contains the socket structure.
+ *      Return 0 if permission is granted.
+ * @socket_getpeername:
+ *      Check permission before the remote address (name) of a socket object
+ *      @sock is retrieved.
+ *      @sock contains the socket structure.
+ *      Return 0 if permission is granted.
+ * @socket_getsockopt:
+ *      Check permissions before retrieving the options associated with socket
+ *      @sock.
+ *      @sock contains the socket structure.
+ *      @level contains the protocol level to retrieve option from.
+ *      @optname contains the name of option to retrieve.
+ *      Return 0 if permission is granted.
+ * @socket_setsockopt:
+ *      Check permissions before setting the options associated with socket
+ *      @sock.
+ *      @sock contains the socket structure.
+ *      @level contains the protocol level to set options for.
+ *      @optname contains the name of the option to set.
+ *      Return 0 if permission is granted.
+ * @socket_shutdown:
+ *      Checks permission before all or part of a connection on the socket
+ *      @sock is shut down.
+ *      @sock contains the socket structure.
+ *      @how contains the flag indicating how future sends and receives
+ *      are handled.
+ *      Return 0 if permission is granted.
+ * @socket_sock_rcv_skb:
+ *      Check permissions on incoming network packets.  This hook is distinct
+ *      from Netfilter's IP input hooks since it is the first time that the
+ *      incoming sk_buff @skb has been associated with a particular socket, @sk.
+ *      Must not sleep inside this hook because some callers hold spinlocks.
+ *      @sk contains the sock (not socket) associated with the incoming sk_buff.
+ *      @skb contains the incoming network data.
+ * @socket_getpeersec_stream:
+ *      This hook allows the security module to provide peer socket security
+ *      state for unix or connected tcp sockets to userspace via getsockopt
+ *      SO_GETPEERSEC.  For tcp sockets this can be meaningful if the
+ *      socket is associated with an ipsec SA.
+ *      @sock is the local socket.
+ *      @optval userspace memory where the security state is to be copied.
+ *      @optlen userspace int where the module should copy the actual length
+ *      of the security state.
+ *      @len as input is the maximum length to copy to userspace provided
+ *      by the caller.
+ *      Return 0 if all is well, otherwise, typical getsockopt return
+ *      values.
+ * @socket_getpeersec_dgram:
+ *      This hook allows the security module to provide peer socket security
+ *      state for udp sockets on a per-packet basis to userspace via
+ *      getsockopt SO_GETPEERSEC.  The application must first have indicated
+ *      the IP_PASSSEC option via getsockopt.  It can then retrieve the
+ *      security state returned by this hook for a packet via the SCM_SECURITY
+ *      ancillary message type.
+ *      @skb is the skbuff for the packet being queried
+ *      @secdata is a pointer to a buffer in which to copy the security data
+ *      @seclen is the maximum length for @secdata
+ *      Return 0 on success, error on failure.
+ * @sk_alloc_security:
+ *      Allocate and attach a security structure to the sk->sk_security field,
+ *      which is used to copy security attributes between local stream sockets.
+ * @sk_free_security:
+ *      Deallocate security structure.
+ * @sk_clone_security:
+ *      Clone/copy security structure.
+ * @sk_getsecid:
+ *      Retrieve the LSM-specific secid for the sock to enable caching
+ *      of network authorizations.
+ * @sock_graft:
+ *      Sets the socket's isec sid to the sock's sid.
+ * @inet_conn_request:
+ *      Sets the openreq's sid to socket's sid with MLS portion taken
+ *      from peer sid.
+ * @inet_csk_clone:
+ *      Sets the new child socket's sid to the openreq sid.
+ * @inet_conn_established:
+ *      Sets the connection's peersid to the secmark on skb.
+ * @secmark_relabel_packet:
+ *      check if the process should be allowed to relabel packets to
+ *      the given secid
+ * @security_secmark_refcount_inc
+ *      tells the LSM to increment the number of secmark labeling rules loaded
+ * @security_secmark_refcount_dec
+ *      tells the LSM to decrement the number of secmark labeling rules loaded
+ * @req_classify_flow:
+ *      Sets the flow's sid to the openreq sid.
+ * @tun_dev_alloc_security:
+ *      This hook allows a module to allocate a security structure for a TUN
+ *      device.
+ *      @security pointer to a security structure pointer.
+ *      Returns a zero on success, negative values on failure.
+ * @tun_dev_free_security:
+ *      This hook allows a module to free the security structure for a TUN
+ *      device.
+ *      @security pointer to the TUN device's security structure
+ * @tun_dev_create:
+ *      Check permissions prior to creating a new TUN device.
+ * @tun_dev_attach_queue:
+ *      Check permissions prior to attaching to a TUN device queue.
+ *      @security pointer to the TUN device's security structure.
+ * @tun_dev_attach:
+ *      This hook can be used by the module to update any security state
+ *      associated with the TUN device's sock structure.
+ *      @sk contains the existing sock structure.
+ *      @security pointer to the TUN device's security structure.
+ * @tun_dev_open:
+ *      This hook can be used by the module to update any security state
+ *      associated with the TUN device's security structure.
+ *      @security pointer to the TUN devices's security structure.
+ *
+ * Security hooks for XFRM operations.
+ *
+ * @xfrm_policy_alloc_security:
+ *      @ctxp is a pointer to the xfrm_sec_ctx being added to Security Policy
+ *      Database used by the XFRM system.
+ *      @sec_ctx contains the security context information being provided by
+ *      the user-level policy update program (e.g., setkey).
+ *      Allocate a security structure to the xp->security field; the security
+ *      field is initialized to NULL when the xfrm_policy is allocated.
+ *      Return 0 if operation was successful (memory to allocate, legal context)
+ *      @gfp is to specify the context for the allocation
+ * @xfrm_policy_clone_security:
+ *      @old_ctx contains an existing xfrm_sec_ctx.
+ *      @new_ctxp contains a new xfrm_sec_ctx being cloned from old.
+ *      Allocate a security structure in new_ctxp that contains the
+ *      information from the old_ctx structure.
+ *      Return 0 if operation was successful (memory to allocate).
+ * @xfrm_policy_free_security:
+ *      @ctx contains the xfrm_sec_ctx
+ *      Deallocate xp->security.
+ * @xfrm_policy_delete_security:
+ *      @ctx contains the xfrm_sec_ctx.
+ *      Authorize deletion of xp->security.
+ * @xfrm_state_alloc:
+ *      @x contains the xfrm_state being added to the Security Association
+ *      Database by the XFRM system.
+ *      @sec_ctx contains the security context information being provided by
+ *      the user-level SA generation program (e.g., setkey or racoon).
+ *      Allocate a security structure to the x->security field; the security
+ *      field is initialized to NULL when the xfrm_state is allocated. Set the
+ *      context to correspond to sec_ctx. Return 0 if operation was successful
+ *      (memory to allocate, legal context).
+ * @xfrm_state_alloc_acquire:
+ *      @x contains the xfrm_state being added to the Security Association
+ *      Database by the XFRM system.
+ *      @polsec contains the policy's security context.
+ *      @secid contains the secid from which to take the mls portion of the
+ *      context.
+ *      Allocate a security structure to the x->security field; the security
+ *      field is initialized to NULL when the xfrm_state is allocated. Set the
+ *      context to correspond to secid. Return 0 if operation was successful
+ *      (memory to allocate, legal context).
+ * @xfrm_state_free_security:
+ *      @x contains the xfrm_state.
+ *      Deallocate x->security.
+ * @xfrm_state_delete_security:
+ *      @x contains the xfrm_state.
+ *      Authorize deletion of x->security.
+ * @xfrm_policy_lookup:
+ *      @ctx contains the xfrm_sec_ctx for which the access control is being
+ *      checked.
+ *      @fl_secid contains the flow security label that is used to authorize
+ *      access to the policy xp.
+ *      @dir contains the direction of the flow (input or output).
+ *      Check permission when a flow selects a xfrm_policy for processing
+ *      XFRMs on a packet.  The hook is called when selecting either a
+ *      per-socket policy or a generic xfrm policy.
+ *      Return 0 if permission is granted, -ESRCH otherwise, or -errno
+ *      on other errors.
+ * @xfrm_state_pol_flow_match:
+ *      @x contains the state to match.
+ *      @xp contains the policy to check for a match.
+ *      @fl contains the flow to check for a match.
+ *      Return 1 if there is a match.
+ * @xfrm_decode_session:
+ *      @skb points to skb to decode.
+ *      @secid points to the flow key secid to set.
+ *      @ckall says if all xfrms used should be checked for same secid.
+ *      Return 0 if ckall is zero or all xfrms used have the same secid.
+ *
+ * Security hooks affecting all Key Management operations
+ *
+ * @key_alloc:
+ *      Permit allocation of a key and assign security data. Note that key does
+ *      not have a serial number assigned at this point.
+ *      @key points to the key.
+ *      @flags is the allocation flags
+ *      Return 0 if permission is granted, -ve error otherwise.
+ * @key_free:
+ *      Notification of destruction; free security data.
+ *      @key points to the key.
+ *      No return value.
+ * @key_permission:
+ *      See whether a specific operational right is granted to a process on a
+ *      key.
+ *      @key_ref refers to the key (key pointer + possession attribute bit).
+ *      @cred points to the credentials to provide the context against which to
+ *      evaluate the security data on the key.
+ *      @perm describes the combination of permissions required of this key.
+ *      Return 0 if permission is granted, -ve error otherwise.
+ * @key_getsecurity:
+ *      Get a textual representation of the security context attached to a key
+ *      for the purposes of honouring KEYCTL_GETSECURITY.  This function
+ *      allocates the storage for the NUL-terminated string and the caller
+ *      should free it.
+ *      @key points to the key to be queried.
+ *      @_buffer points to a pointer that should be set to point to the
+ *      resulting string (if no label or an error occurs).
+ *      Return the length of the string (including terminating NUL) or -ve if
+ *      an error.
+ *      May also return 0 (and a NULL buffer pointer) if there is no label.
+ *
+ * Security hooks affecting all System V IPC operations.
+ *
+ * @ipc_permission:
+ *      Check permissions for access to IPC
+ *      @ipcp contains the kernel IPC permission structure
+ *      @flag contains the desired (requested) permission set
+ *      Return 0 if permission is granted.
+ * @ipc_getsecid:
+ *      Get the secid associated with the ipc object.
+ *      @ipcp contains the kernel IPC permission structure.
+ *      @secid contains a pointer to the location where result will be saved.
+ *      In case of failure, @secid will be set to zero.
+ *
+ * Security hooks for individual messages held in System V IPC message queues
+ * @msg_msg_alloc_security:
+ *      Allocate and attach a security structure to the msg->security field.
+ *      The security field is initialized to NULL when the structure is first
+ *      created.
+ *      @msg contains the message structure to be modified.
+ *      Return 0 if operation was successful and permission is granted.
+ * @msg_msg_free_security:
+ *      Deallocate the security structure for this message.
+ *      @msg contains the message structure to be modified.
+ *
+ * Security hooks for System V IPC Message Queues
+ *
+ * @msg_queue_alloc_security:
+ *      Allocate and attach a security structure to the
+ *      msq->q_perm.security field. The security field is initialized to
+ *      NULL when the structure is first created.
+ *      @msq contains the message queue structure to be modified.
+ *      Return 0 if operation was successful and permission is granted.
+ * @msg_queue_free_security:
+ *      Deallocate security structure for this message queue.
+ *      @msq contains the message queue structure to be modified.
+ * @msg_queue_associate:
+ *      Check permission when a message queue is requested through the
+ *      msgget system call.  This hook is only called when returning the
+ *      message queue identifier for an existing message queue, not when a
+ *      new message queue is created.
+ *      @msq contains the message queue to act upon.
+ *      @msqflg contains the operation control flags.
+ *      Return 0 if permission is granted.
+ * @msg_queue_msgctl:
+ *      Check permission when a message control operation specified by @cmd
+ *      is to be performed on the message queue @msq.
+ *      The @msq may be NULL, e.g. for IPC_INFO or MSG_INFO.
+ *      @msq contains the message queue to act upon.  May be NULL.
+ *      @cmd contains the operation to be performed.
+ *      Return 0 if permission is granted.
+ * @msg_queue_msgsnd:
+ *      Check permission before a message, @msg, is enqueued on the message
+ *      queue, @msq.
+ *      @msq contains the message queue to send message to.
+ *      @msg contains the message to be enqueued.
+ *      @msqflg contains operational flags.
+ *      Return 0 if permission is granted.
+ * @msg_queue_msgrcv:
+ *      Check permission before a message, @msg, is removed from the message
+ *      queue, @msq.  The @target task structure contains a pointer to the
+ *      process that will be receiving the message (not equal to the current
+ *      process when inline receives are being performed).
+ *      @msq contains the message queue to retrieve message from.
+ *      @msg contains the message destination.
+ *      @target contains the task structure for recipient process.
+ *      @type contains the type of message requested.
+ *      @mode contains the operational flags.
+ *      Return 0 if permission is granted.
+ *
+ * Security hooks for System V Shared Memory Segments
+ *
+ * @shm_alloc_security:
+ *      Allocate and attach a security structure to the shp->shm_perm.security
+ *      field.  The security field is initialized to NULL when the structure is
+ *      first created.
+ *      @shp contains the shared memory structure to be modified.
+ *      Return 0 if operation was successful and permission is granted.
+ * @shm_free_security:
+ *      Deallocate the security struct for this memory segment.
+ *      @shp contains the shared memory structure to be modified.
+ * @shm_associate:
+ *      Check permission when a shared memory region is requested through the
+ *      shmget system call.  This hook is only called when returning the shared
+ *      memory region identifier for an existing region, not when a new shared
+ *      memory region is created.
+ *      @shp contains the shared memory structure to be modified.
+ *      @shmflg contains the operation control flags.
+ *      Return 0 if permission is granted.
+ * @shm_shmctl:
+ *      Check permission when a shared memory control operation specified by
+ *      @cmd is to be performed on the shared memory region @shp.
+ *      The @shp may be NULL, e.g. for IPC_INFO or SHM_INFO.
+ *      @shp contains shared memory structure to be modified.
+ *      @cmd contains the operation to be performed.
+ *      Return 0 if permission is granted.
+ * @shm_shmat:
+ *      Check permissions prior to allowing the shmat system call to attach the
+ *      shared memory segment @shp to the data segment of the calling process.
+ *      The attaching address is specified by @shmaddr.
+ *      @shp contains the shared memory structure to be modified.
+ *      @shmaddr contains the address to attach memory region to.
+ *      @shmflg contains the operational flags.
+ *      Return 0 if permission is granted.
+ *
+ * Security hooks for System V Semaphores
+ *
+ * @sem_alloc_security:
+ *      Allocate and attach a security structure to the sma->sem_perm.security
+ *      field.  The security field is initialized to NULL when the structure is
+ *      first created.
+ *      @sma contains the semaphore structure
+ *      Return 0 if operation was successful and permission is granted.
+ * @sem_free_security:
+ *      deallocate security struct for this semaphore
+ *      @sma contains the semaphore structure.
+ * @sem_associate:
+ *      Check permission when a semaphore is requested through the semget
+ *      system call.  This hook is only called when returning the semaphore
+ *      identifier for an existing semaphore, not when a new one must be
+ *      created.
+ *      @sma contains the semaphore structure.
+ *      @semflg contains the operation control flags.
+ *      Return 0 if permission is granted.
+ * @sem_semctl:
+ *      Check permission when a semaphore operation specified by @cmd is to be
+ *      performed on the semaphore @sma.  The @sma may be NULL, e.g. for
+ *      IPC_INFO or SEM_INFO.
+ *      @sma contains the semaphore structure.  May be NULL.
+ *      @cmd contains the operation to be performed.
+ *      Return 0 if permission is granted.
+ * @sem_semop
+ *      Check permissions before performing operations on members of the
+ *      semaphore set @sma.  If the @alter flag is nonzero, the semaphore set
+ *      may be modified.
+ *      @sma contains the semaphore structure.
+ *      @sops contains the operations to perform.
+ *      @nsops contains the number of operations to perform.
+ *      @alter contains the flag indicating whether changes are to be made.
+ *      Return 0 if permission is granted.
+ *
+ * @binder_set_context_mgr
+ *      Check whether @mgr is allowed to be the binder context manager.
+ *      @mgr contains the task_struct for the task being registered.
+ *      Return 0 if permission is granted.
+ * @binder_transaction
+ *      Check whether @from is allowed to invoke a binder transaction call
+ *      to @to.
+ *      @from contains the task_struct for the sending task.
+ *      @to contains the task_struct for the receiving task.
+ * @binder_transfer_binder
+ *      Check whether @from is allowed to transfer a binder reference to @to.
+ *      @from contains the task_struct for the sending task.
+ *      @to contains the task_struct for the receiving task.
+ * @binder_transfer_file
+ *      Check whether @from is allowed to transfer @file to @to.
+ *      @from contains the task_struct for the sending task.
+ *      @file contains the struct file being transferred.
+ *      @to contains the task_struct for the receiving task.
+ *
+ * @ptrace_access_check:
+ *      Check permission before allowing the current process to trace the
+ *      @child process.
+ *      Security modules may also want to perform a process tracing check
+ *      during an execve in the set_security or apply_creds hooks of
+ *      tracing check during an execve in the bprm_set_creds hook of
+ *      binprm_security_ops if the process is being traced and its security
+ *      attributes would be changed by the execve.
+ *      @child contains the task_struct structure for the target process.
+ *      @mode contains the PTRACE_MODE flags indicating the form of access.
+ *      Return 0 if permission is granted.
+ * @ptrace_traceme:
+ *      Check that the @parent process has sufficient permission to trace the
+ *      current process before allowing the current process to present itself
+ *      to the @parent process for tracing.
+ *      @parent contains the task_struct structure for debugger process.
+ *      Return 0 if permission is granted.
+ * @capget:
+ *      Get the @effective, @inheritable, and @permitted capability sets for
+ *      the @target process.  The hook may also perform permission checking to
+ *      determine if the current process is allowed to see the capability sets
+ *      of the @target process.
+ *      @target contains the task_struct structure for target process.
+ *      @effective contains the effective capability set.
+ *      @inheritable contains the inheritable capability set.
+ *      @permitted contains the permitted capability set.
+ *      Return 0 if the capability sets were successfully obtained.
+ * @capset:
+ *      Set the @effective, @inheritable, and @permitted capability sets for
+ *      the current process.
+ *      @new contains the new credentials structure for target process.
+ *      @old contains the current credentials structure for target process.
+ *      @effective contains the effective capability set.
+ *      @inheritable contains the inheritable capability set.
+ *      @permitted contains the permitted capability set.
+ *      Return 0 and update @new if permission is granted.
+ * @capable:
+ *      Check whether the @tsk process has the @cap capability in the indicated
+ *      credentials.
+ *      @cred contains the credentials to use.
+ *      @ns contains the user namespace we want the capability in
+ *      @cap contains the capability <include/linux/capability.h>.
+ *      @audit: Whether to write an audit message or not
+ *      Return 0 if the capability is granted for @tsk.
+ * @syslog:
+ *      Check permission before accessing the kernel message ring or changing
+ *      logging to the console.
+ *      See the syslog(2) manual page for an explanation of the @type values.
+ *      @type contains the type of action.
+ *      @from_file indicates the context of action (if it came from /proc).
+ *      Return 0 if permission is granted.
+ * @settime:
+ *      Check permission to change the system time.
+ *      struct timespec and timezone are defined in include/linux/time.h
+ *      @ts contains new time
+ *      @tz contains new timezone
+ *      Return 0 if permission is granted.
+ * @vm_enough_memory:
+ *      Check permissions for allocating a new virtual mapping.
+ *      @mm contains the mm struct it is being added to.
+ *      @pages contains the number of pages.
+ *      Return 0 if permission is granted.
+ *
+ * @ismaclabel:
+ *      Check if the extended attribute specified by @name
+ *      represents a MAC label. Returns 1 if name is a MAC
+ *      attribute otherwise returns 0.
+ *      @name full extended attribute name to check against
+ *      LSM as a MAC label.
+ *
+ * @secid_to_secctx:
+ *      Convert secid to security context.  If secdata is NULL the length of
+ *      the result will be returned in seclen, but no secdata will be returned.
+ *      This does mean that the length could change between calls to check the
+ *      length and the next call which actually allocates and returns the
+ *      secdata.
+ *      @secid contains the security ID.
+ *      @secdata contains the pointer that stores the converted security
+ *      context.
+ *      @seclen pointer which contains the length of the data
+ * @secctx_to_secid:
+ *      Convert security context to secid.
+ *      @secid contains the pointer to the generated security ID.
+ *      @secdata contains the security context.
+ *
+ * @release_secctx:
+ *      Release the security context.
+ *      @secdata contains the security context.
+ *      @seclen contains the length of the security context.
+ *
+ * Security hooks for Audit
+ *
+ * @audit_rule_init:
+ *      Allocate and initialize an LSM audit rule structure.
+ *      @field contains the required Audit action.
+ *      Fields flags are defined in include/linux/audit.h
+ *      @op contains the operator the rule uses.
+ *      @rulestr contains the context where the rule will be applied to.
+ *      @lsmrule contains a pointer to receive the result.
+ *      Return 0 if @lsmrule has been successfully set,
+ *      -EINVAL in case of an invalid rule.
+ *
+ * @audit_rule_known:
+ *      Specifies whether given @rule contains any fields related to
+ *      current LSM.
+ *      @rule contains the audit rule of interest.
+ *      Return 1 in case of relation found, 0 otherwise.
+ *
+ * @audit_rule_match:
+ *      Determine if given @secid matches a rule previously approved
+ *      by @audit_rule_known.
+ *      @secid contains the security id in question.
+ *      @field contains the field which relates to current LSM.
+ *      @op contains the operator that will be used for matching.
+ *      @rule points to the audit rule that will be checked against.
+ *      @actx points to the audit context associated with the check.
+ *      Return 1 if secid matches the rule, 0 if it does not, -ERRNO on failure.
+ *
+ * @audit_rule_free:
+ *      Deallocate the LSM audit rule structure previously allocated by
+ *      audit_rule_init.
+ *      @rule contains the allocated rule
+ *
+ * @inode_notifysecctx:
+ *      Notify the security module of what the security context of an inode
+ *      should be.  Initializes the incore security context managed by the
+ *      security module for this inode.  Example usage:  NFS client invokes
+ *      this hook to initialize the security context in its incore inode to the
+ *      value provided by the server for the file when the server returned the
+ *      file's attributes to the client.
+ *
+ *      Must be called with inode->i_mutex locked.
+ *
+ *      @inode we wish to set the security context of.
+ *      @ctx contains the string which we wish to set in the inode.
+ *      @ctxlen contains the length of @ctx.
+ *
+ * @inode_setsecctx:
+ *      Change the security context of an inode.  Updates the
+ *      incore security context managed by the security module and invokes the
+ *      fs code as needed (via __vfs_setxattr_noperm) to update any backing
+ *      xattrs that represent the context.  Example usage:  NFS server invokes
+ *      this hook to change the security context in its incore inode and on the
+ *      backing filesystem to a value provided by the client on a SETATTR
+ *      operation.
+ *
+ *      Must be called with inode->i_mutex locked.
+ *
+ *      @dentry contains the inode we wish to set the security context of.
+ *      @ctx contains the string which we wish to set in the inode.
+ *      @ctxlen contains the length of @ctx.
+ *
+ * @inode_getsecctx:
+ *      On success, returns 0 and fills out @ctx and @ctxlen with the security
+ *      context for the given @inode.
+ *
+ *      @inode we wish to get the security context of.
+ *      @ctx is a pointer in which to place the allocated security context.
+ *      @ctxlen points to the place to put the length of @ctx.
+ * This is the main security structure.
+ */
+
+union security_list_options {
+        int (*binder_set_context_mgr)(struct task_struct *mgr);
+        int (*binder_transaction)(struct task_struct *from,
+                                        struct task_struct *to);
+        int (*binder_transfer_binder)(struct task_struct *from,
+                                        struct task_struct *to);
+        int (*binder_transfer_file)(struct task_struct *from,
+                                        struct task_struct *to,
+                                        struct file *file);
+
+        int (*ptrace_access_check)(struct task_struct *child,
+                                        unsigned int mode);
+        int (*ptrace_traceme)(struct task_struct *parent);
+        int (*capget)(struct task_struct *target, kernel_cap_t *effective,
+                        kernel_cap_t *inheritable, kernel_cap_t *permitted);
+        int (*capset)(struct cred *new, const struct cred *old,
+                        const kernel_cap_t *effective,
+                        const kernel_cap_t *inheritable,
+                        const kernel_cap_t *permitted);
+        int (*capable)(const struct cred *cred, struct user_namespace *ns,
+                        int cap, int audit);
+        int (*quotactl)(int cmds, int type, int id, struct super_block *sb);
+        int (*quota_on)(struct dentry *dentry);
+        int (*syslog)(int type);
+        int (*settime)(const struct timespec *ts, const struct timezone *tz);
+        int (*vm_enough_memory)(struct mm_struct *mm, long pages);
+
+        int (*bprm_set_creds)(struct linux_binprm *bprm);
+        int (*bprm_check_security)(struct linux_binprm *bprm);
+        int (*bprm_secureexec)(struct linux_binprm *bprm);
+        void (*bprm_committing_creds)(struct linux_binprm *bprm);
+        void (*bprm_committed_creds)(struct linux_binprm *bprm);
+
+        int (*sb_alloc_security)(struct super_block *sb);
+        void (*sb_free_security)(struct super_block *sb);
+        int (*sb_copy_data)(char *orig, char *copy);
+        int (*sb_remount)(struct super_block *sb, void *data);
+        int (*sb_kern_mount)(struct super_block *sb, int flags, void *data);
+        int (*sb_show_options)(struct seq_file *m, struct super_block *sb);
+        int (*sb_statfs)(struct dentry *dentry);
+        int (*sb_mount)(const char *dev_name, struct path *path,
+                        const char *type, unsigned long flags, void *data);
+        int (*sb_umount)(struct vfsmount *mnt, int flags);
+        int (*sb_pivotroot)(struct path *old_path, struct path *new_path);
+        int (*sb_set_mnt_opts)(struct super_block *sb,
+                                struct security_mnt_opts *opts,
+                                unsigned long kern_flags,
+                                unsigned long *set_kern_flags);
+        int (*sb_clone_mnt_opts)(const struct super_block *oldsb,
+                                        struct super_block *newsb);
+        int (*sb_parse_opts_str)(char *options, struct security_mnt_opts *opts);
+        int (*dentry_init_security)(struct dentry *dentry, int mode,
+                                        struct qstr *name, void **ctx,
+                                        u32 *ctxlen);
+
+
+#ifdef CONFIG_SECURITY_PATH
+        int (*path_unlink)(struct path *dir, struct dentry *dentry);
+        int (*path_mkdir)(struct path *dir, struct dentry *dentry,
+                                umode_t mode);
+        int (*path_rmdir)(struct path *dir, struct dentry *dentry);
+        int (*path_mknod)(struct path *dir, struct dentry *dentry,
+                                umode_t mode, unsigned int dev);
+        int (*path_truncate)(struct path *path);
+        int (*path_symlink)(struct path *dir, struct dentry *dentry,
+                                const char *old_name);
+        int (*path_link)(struct dentry *old_dentry, struct path *new_dir,
+                                struct dentry *new_dentry);
+        int (*path_rename)(struct path *old_dir, struct dentry *old_dentry,
+                                struct path *new_dir,
+                                struct dentry *new_dentry);
+        int (*path_chmod)(struct path *path, umode_t mode);
+        int (*path_chown)(struct path *path, kuid_t uid, kgid_t gid);
+        int (*path_chroot)(struct path *path);
+#endif
+
+        int (*inode_alloc_security)(struct inode *inode);
+        void (*inode_free_security)(struct inode *inode);
+        int (*inode_init_security)(struct inode *inode, struct inode *dir,
+                                        const struct qstr *qstr,
+                                        const char **name, void **value,
+                                        size_t *len);
+        int (*inode_create)(struct inode *dir, struct dentry *dentry,
+                                umode_t mode);
+        int (*inode_link)(struct dentry *old_dentry, struct inode *dir,
+                                struct dentry *new_dentry);
+        int (*inode_unlink)(struct inode *dir, struct dentry *dentry);
+        int (*inode_symlink)(struct inode *dir, struct dentry *dentry,
+                                const char *old_name);
+        int (*inode_mkdir)(struct inode *dir, struct dentry *dentry,
+                                umode_t mode);
+        int (*inode_rmdir)(struct inode *dir, struct dentry *dentry);
+        int (*inode_mknod)(struct inode *dir, struct dentry *dentry,
+                                umode_t mode, dev_t dev);
+        int (*inode_rename)(struct inode *old_dir, struct dentry *old_dentry,
+                                struct inode *new_dir,
+                                struct dentry *new_dentry);
+        int (*inode_readlink)(struct dentry *dentry);
+        int (*inode_follow_link)(struct dentry *dentry, struct inode *inode,
+                                 bool rcu);
+        int (*inode_permission)(struct inode *inode, int mask);
+        int (*inode_setattr)(struct dentry *dentry, struct iattr *attr);
+        int (*inode_getattr)(const struct path *path);
+        int (*inode_setxattr)(struct dentry *dentry, const char *name,
+                                const void *value, size_t size, int flags);
+        void (*inode_post_setxattr)(struct dentry *dentry, const char *name,
+                                        const void *value, size_t size,
+                                        int flags);
+        int (*inode_getxattr)(struct dentry *dentry, const char *name);
+        int (*inode_listxattr)(struct dentry *dentry);
+        int (*inode_removexattr)(struct dentry *dentry, const char *name);
+        int (*inode_need_killpriv)(struct dentry *dentry);
+        int (*inode_killpriv)(struct dentry *dentry);
+        int (*inode_getsecurity)(const struct inode *inode, const char *name,
+                                        void **buffer, bool alloc);
+        int (*inode_setsecurity)(struct inode *inode, const char *name,
+                                        const void *value, size_t size,
+                                        int flags);
+        int (*inode_listsecurity)(struct inode *inode, char *buffer,
+                                        size_t buffer_size);
+        void (*inode_getsecid)(const struct inode *inode, u32 *secid);
+
+        int (*file_permission)(struct file *file, int mask);
+        int (*file_alloc_security)(struct file *file);
+        void (*file_free_security)(struct file *file);
+        int (*file_ioctl)(struct file *file, unsigned int cmd,
+                                unsigned long arg);
+        int (*mmap_addr)(unsigned long addr);
+        int (*mmap_file)(struct file *file, unsigned long reqprot,
+                                unsigned long prot, unsigned long flags);
+        int (*file_mprotect)(struct vm_area_struct *vma, unsigned long reqprot,
+                                unsigned long prot);
+        int (*file_lock)(struct file *file, unsigned int cmd);
+        int (*file_fcntl)(struct file *file, unsigned int cmd,
+                                unsigned long arg);
+        void (*file_set_fowner)(struct file *file);
+        int (*file_send_sigiotask)(struct task_struct *tsk,
+                                        struct fown_struct *fown, int sig);
+        int (*file_receive)(struct file *file);
+        int (*file_open)(struct file *file, const struct cred *cred);
+
+        int (*task_create)(unsigned long clone_flags);
+        void (*task_free)(struct task_struct *task);
+        int (*cred_alloc_blank)(struct cred *cred, gfp_t gfp);
+        void (*cred_free)(struct cred *cred);
+        int (*cred_prepare)(struct cred *new, const struct cred *old,
+                                gfp_t gfp);
+        void (*cred_transfer)(struct cred *new, const struct cred *old);
+        int (*kernel_act_as)(struct cred *new, u32 secid);
+        int (*kernel_create_files_as)(struct cred *new, struct inode *inode);
+        int (*kernel_fw_from_file)(struct file *file, char *buf, size_t size);
+        int (*kernel_module_request)(char *kmod_name);
+        int (*kernel_module_from_file)(struct file *file);
+        int (*task_fix_setuid)(struct cred *new, const struct cred *old,
+                                int flags);
+        int (*task_setpgid)(struct task_struct *p, pid_t pgid);
+        int (*task_getpgid)(struct task_struct *p);
+        int (*task_getsid)(struct task_struct *p);
+        void (*task_getsecid)(struct task_struct *p, u32 *secid);
+        int (*task_setnice)(struct task_struct *p, int nice);
+        int (*task_setioprio)(struct task_struct *p, int ioprio);
+        int (*task_getioprio)(struct task_struct *p);
+        int (*task_setrlimit)(struct task_struct *p, unsigned int resource,
+                                struct rlimit *new_rlim);
+        int (*task_setscheduler)(struct task_struct *p);
+        int (*task_getscheduler)(struct task_struct *p);
+        int (*task_movememory)(struct task_struct *p);
+        int (*task_kill)(struct task_struct *p, struct siginfo *info,
+                                int sig, u32 secid);
+        int (*task_wait)(struct task_struct *p);
+        int (*task_prctl)(int option, unsigned long arg2, unsigned long arg3,
+                                unsigned long arg4, unsigned long arg5);
+        void (*task_to_inode)(struct task_struct *p, struct inode *inode);
+
+        int (*ipc_permission)(struct kern_ipc_perm *ipcp, short flag);
+        void (*ipc_getsecid)(struct kern_ipc_perm *ipcp, u32 *secid);
+
+        int (*msg_msg_alloc_security)(struct msg_msg *msg);
+        void (*msg_msg_free_security)(struct msg_msg *msg);
+
+        int (*msg_queue_alloc_security)(struct msg_queue *msq);
+        void (*msg_queue_free_security)(struct msg_queue *msq);
+        int (*msg_queue_associate)(struct msg_queue *msq, int msqflg);
+        int (*msg_queue_msgctl)(struct msg_queue *msq, int cmd);
+        int (*msg_queue_msgsnd)(struct msg_queue *msq, struct msg_msg *msg,
+                                int msqflg);
+        int (*msg_queue_msgrcv)(struct msg_queue *msq, struct msg_msg *msg,
+                                struct task_struct *target, long type,
+                                int mode);
+
+        int (*shm_alloc_security)(struct shmid_kernel *shp);
+        void (*shm_free_security)(struct shmid_kernel *shp);
+        int (*shm_associate)(struct shmid_kernel *shp, int shmflg);
+        int (*shm_shmctl)(struct shmid_kernel *shp, int cmd);
+        int (*shm_shmat)(struct shmid_kernel *shp, char __user *shmaddr,
+                                int shmflg);
+
+        int (*sem_alloc_security)(struct sem_array *sma);
+        void (*sem_free_security)(struct sem_array *sma);
+        int (*sem_associate)(struct sem_array *sma, int semflg);
+        int (*sem_semctl)(struct sem_array *sma, int cmd);
+        int (*sem_semop)(struct sem_array *sma, struct sembuf *sops,
+                                unsigned nsops, int alter);
+
+        int (*netlink_send)(struct sock *sk, struct sk_buff *skb);
+
+        void (*d_instantiate)(struct dentry *dentry, struct inode *inode);
+
+        int (*getprocattr)(struct task_struct *p, char *name, char **value);
+        int (*setprocattr)(struct task_struct *p, char *name, void *value,
+                                size_t size);
+        int (*ismaclabel)(const char *name);
+        int (*secid_to_secctx)(u32 secid, char **secdata, u32 *seclen);
+        int (*secctx_to_secid)(const char *secdata, u32 seclen, u32 *secid);
+        void (*release_secctx)(char *secdata, u32 seclen);
+
+        int (*inode_notifysecctx)(struct inode *inode, void *ctx, u32 ctxlen);
+        int (*inode_setsecctx)(struct dentry *dentry, void *ctx, u32 ctxlen);
+        int (*inode_getsecctx)(struct inode *inode, void **ctx, u32 *ctxlen);
+
+#ifdef CONFIG_SECURITY_NETWORK
+        int (*unix_stream_connect)(struct sock *sock, struct sock *other,
+                                        struct sock *newsk);
+        int (*unix_may_send)(struct socket *sock, struct socket *other);
+
+        int (*socket_create)(int family, int type, int protocol, int kern);
+        int (*socket_post_create)(struct socket *sock, int family, int type,
+                                        int protocol, int kern);
+        int (*socket_bind)(struct socket *sock, struct sockaddr *address,
+                                int addrlen);
+        int (*socket_connect)(struct socket *sock, struct sockaddr *address,
+                                int addrlen);
+        int (*socket_listen)(struct socket *sock, int backlog);
+        int (*socket_accept)(struct socket *sock, struct socket *newsock);
+        int (*socket_sendmsg)(struct socket *sock, struct msghdr *msg,
+                                int size);
+        int (*socket_recvmsg)(struct socket *sock, struct msghdr *msg,
+                                int size, int flags);
+        int (*socket_getsockname)(struct socket *sock);
+        int (*socket_getpeername)(struct socket *sock);
+        int (*socket_getsockopt)(struct socket *sock, int level, int optname);
+        int (*socket_setsockopt)(struct socket *sock, int level, int optname);
+        int (*socket_shutdown)(struct socket *sock, int how);
+        int (*socket_sock_rcv_skb)(struct sock *sk, struct sk_buff *skb);
+        int (*socket_getpeersec_stream)(struct socket *sock,
+                                        char __user *optval,
+                                        int __user *optlen, unsigned len);
+        int (*socket_getpeersec_dgram)(struct socket *sock,
+                                        struct sk_buff *skb, u32 *secid);
+        int (*sk_alloc_security)(struct sock *sk, int family, gfp_t priority);
+        void (*sk_free_security)(struct sock *sk);
+        void (*sk_clone_security)(const struct sock *sk, struct sock *newsk);
+        void (*sk_getsecid)(struct sock *sk, u32 *secid);
+        void (*sock_graft)(struct sock *sk, struct socket *parent);
+        int (*inet_conn_request)(struct sock *sk, struct sk_buff *skb,
+                                        struct request_sock *req);
+        void (*inet_csk_clone)(struct sock *newsk,
+                                const struct request_sock *req);
+        void (*inet_conn_established)(struct sock *sk, struct sk_buff *skb);
+        int (*secmark_relabel_packet)(u32 secid);
+        void (*secmark_refcount_inc)(void);
+        void (*secmark_refcount_dec)(void);
+        void (*req_classify_flow)(const struct request_sock *req,
+                                        struct flowi *fl);
+        int (*tun_dev_alloc_security)(void **security);
+        void (*tun_dev_free_security)(void *security);
+        int (*tun_dev_create)(void);
+        int (*tun_dev_attach_queue)(void *security);
+        int (*tun_dev_attach)(struct sock *sk, void *security);
+        int (*tun_dev_open)(void *security);
+#endif  /* CONFIG_SECURITY_NETWORK */
+
+#ifdef CONFIG_SECURITY_NETWORK_XFRM
+        int (*xfrm_policy_alloc_security)(struct xfrm_sec_ctx **ctxp,
+                                          struct xfrm_user_sec_ctx *sec_ctx,
+                                                gfp_t gfp);
+        int (*xfrm_policy_clone_security)(struct xfrm_sec_ctx *old_ctx,
+                                                struct xfrm_sec_ctx **new_ctx);
+        void (*xfrm_policy_free_security)(struct xfrm_sec_ctx *ctx);
+        int (*xfrm_policy_delete_security)(struct xfrm_sec_ctx *ctx);
+        int (*xfrm_state_alloc)(struct xfrm_state *x,
+                                struct xfrm_user_sec_ctx *sec_ctx);
+        int (*xfrm_state_alloc_acquire)(struct xfrm_state *x,
+                                        struct xfrm_sec_ctx *polsec,
+                                        u32 secid);
+        void (*xfrm_state_free_security)(struct xfrm_state *x);
+        int (*xfrm_state_delete_security)(struct xfrm_state *x);
+        int (*xfrm_policy_lookup)(struct xfrm_sec_ctx *ctx, u32 fl_secid,
+                                        u8 dir);
+        int (*xfrm_state_pol_flow_match)(struct xfrm_state *x,
+                                                struct xfrm_policy *xp,
+                                                const struct flowi *fl);
+        int (*xfrm_decode_session)(struct sk_buff *skb, u32 *secid, int ckall);
+#endif  /* CONFIG_SECURITY_NETWORK_XFRM */
+
+        /* key management security hooks */
+#ifdef CONFIG_KEYS
+        int (*key_alloc)(struct key *key, const struct cred *cred,
+                                unsigned long flags);
+        void (*key_free)(struct key *key);
+        int (*key_permission)(key_ref_t key_ref, const struct cred *cred,
+                                unsigned perm);
+        int (*key_getsecurity)(struct key *key, char **_buffer);
+#endif  /* CONFIG_KEYS */
+
+#ifdef CONFIG_AUDIT
+        int (*audit_rule_init)(u32 field, u32 op, char *rulestr,
+                                void **lsmrule);
+        int (*audit_rule_known)(struct audit_krule *krule);
+        int (*audit_rule_match)(u32 secid, u32 field, u32 op, void *lsmrule,
+                                struct audit_context *actx);
+        void (*audit_rule_free)(void *lsmrule);
+#endif /* CONFIG_AUDIT */
+};
+
+struct security_hook_heads {
+        struct list_head binder_set_context_mgr;
+        struct list_head binder_transaction;
+        struct list_head binder_transfer_binder;
+        struct list_head binder_transfer_file;
+        struct list_head ptrace_access_check;
+        struct list_head ptrace_traceme;
+        struct list_head capget;
+        struct list_head capset;
+        struct list_head capable;
+        struct list_head quotactl;
+        struct list_head quota_on;
+        struct list_head syslog;
+        struct list_head settime;
+        struct list_head vm_enough_memory;
+        struct list_head bprm_set_creds;
+        struct list_head bprm_check_security;
+        struct list_head bprm_secureexec;
+        struct list_head bprm_committing_creds;
+        struct list_head bprm_committed_creds;
+        struct list_head sb_alloc_security;
+        struct list_head sb_free_security;
+        struct list_head sb_copy_data;
+        struct list_head sb_remount;
+        struct list_head sb_kern_mount;
+        struct list_head sb_show_options;
+        struct list_head sb_statfs;
+        struct list_head sb_mount;
+        struct list_head sb_umount;
+        struct list_head sb_pivotroot;
+        struct list_head sb_set_mnt_opts;
+        struct list_head sb_clone_mnt_opts;
+        struct list_head sb_parse_opts_str;
+        struct list_head dentry_init_security;
+#ifdef CONFIG_SECURITY_PATH
+        struct list_head path_unlink;
+        struct list_head path_mkdir;
+        struct list_head path_rmdir;
+        struct list_head path_mknod;
+        struct list_head path_truncate;
+        struct list_head path_symlink;
+        struct list_head path_link;
+        struct list_head path_rename;
+        struct list_head path_chmod;
+        struct list_head path_chown;
+        struct list_head path_chroot;
+#endif
+        struct list_head inode_alloc_security;
+        struct list_head inode_free_security;
+        struct list_head inode_init_security;
+        struct list_head inode_create;
+        struct list_head inode_link;
+        struct list_head inode_unlink;
+        struct list_head inode_symlink;
+        struct list_head inode_mkdir;
+        struct list_head inode_rmdir;
+        struct list_head inode_mknod;
+        struct list_head inode_rename;
+        struct list_head inode_readlink;
+        struct list_head inode_follow_link;
+        struct list_head inode_permission;
+        struct list_head inode_setattr;
+        struct list_head inode_getattr;
+        struct list_head inode_setxattr;
+        struct list_head inode_post_setxattr;
+        struct list_head inode_getxattr;
+        struct list_head inode_listxattr;
+        struct list_head inode_removexattr;
+        struct list_head inode_need_killpriv;
+        struct list_head inode_killpriv;
+        struct list_head inode_getsecurity;
+        struct list_head inode_setsecurity;
+        struct list_head inode_listsecurity;
+        struct list_head inode_getsecid;
+        struct list_head file_permission;
+        struct list_head file_alloc_security;
+        struct list_head file_free_security;
+        struct list_head file_ioctl;
+        struct list_head mmap_addr;
+        struct list_head mmap_file;
+        struct list_head file_mprotect;
+        struct list_head file_lock;
+        struct list_head file_fcntl;
+        struct list_head file_set_fowner;
+        struct list_head file_send_sigiotask;
+        struct list_head file_receive;
+        struct list_head file_open;
+        struct list_head task_create;
+        struct list_head task_free;
+        struct list_head cred_alloc_blank;
+        struct list_head cred_free;
+        struct list_head cred_prepare;
+        struct list_head cred_transfer;
+        struct list_head kernel_act_as;
+        struct list_head kernel_create_files_as;
+        struct list_head kernel_fw_from_file;
+        struct list_head kernel_module_request;
+        struct list_head kernel_module_from_file;
+        struct list_head task_fix_setuid;
+        struct list_head task_setpgid;
+        struct list_head task_getpgid;
+        struct list_head task_getsid;
+        struct list_head task_getsecid;
+        struct list_head task_setnice;
+        struct list_head task_setioprio;
+        struct list_head task_getioprio;
+        struct list_head task_setrlimit;
+        struct list_head task_setscheduler;
+        struct list_head task_getscheduler;
+        struct list_head task_movememory;
+        struct list_head task_kill;
+        struct list_head task_wait;
+        struct list_head task_prctl;
+        struct list_head task_to_inode;
+        struct list_head ipc_permission;
+        struct list_head ipc_getsecid;
+        struct list_head msg_msg_alloc_security;
+        struct list_head msg_msg_free_security;
+        struct list_head msg_queue_alloc_security;
+        struct list_head msg_queue_free_security;
+        struct list_head msg_queue_associate;
+        struct list_head msg_queue_msgctl;
+        struct list_head msg_queue_msgsnd;
+        struct list_head msg_queue_msgrcv;
+        struct list_head shm_alloc_security;
+        struct list_head shm_free_security;
+        struct list_head shm_associate;
+        struct list_head shm_shmctl;
+        struct list_head shm_shmat;
+        struct list_head sem_alloc_security;
+        struct list_head sem_free_security;
+        struct list_head sem_associate;
+        struct list_head sem_semctl;
+        struct list_head sem_semop;
+        struct list_head netlink_send;
+        struct list_head d_instantiate;
+        struct list_head getprocattr;
+        struct list_head setprocattr;
+        struct list_head ismaclabel;
+        struct list_head secid_to_secctx;
+        struct list_head secctx_to_secid;
+        struct list_head release_secctx;
+        struct list_head inode_notifysecctx;
+        struct list_head inode_setsecctx;
+        struct list_head inode_getsecctx;
+#ifdef CONFIG_SECURITY_NETWORK
+        struct list_head unix_stream_connect;
+        struct list_head unix_may_send;
+        struct list_head socket_create;
+        struct list_head socket_post_create;
+        struct list_head socket_bind;
+        struct list_head socket_connect;
+        struct list_head socket_listen;
+        struct list_head socket_accept;
+        struct list_head socket_sendmsg;
+        struct list_head socket_recvmsg;
+        struct list_head socket_getsockname;
+        struct list_head socket_getpeername;
+        struct list_head socket_getsockopt;
+        struct list_head socket_setsockopt;
+        struct list_head socket_shutdown;
+        struct list_head socket_sock_rcv_skb;
+        struct list_head socket_getpeersec_stream;
+        struct list_head socket_getpeersec_dgram;
+        struct list_head sk_alloc_security;
+        struct list_head sk_free_security;
+        struct list_head sk_clone_security;
+        struct list_head sk_getsecid;
+        struct list_head sock_graft;
+        struct list_head inet_conn_request;
+        struct list_head inet_csk_clone;
+        struct list_head inet_conn_established;
+        struct list_head secmark_relabel_packet;
+        struct list_head secmark_refcount_inc;
+        struct list_head secmark_refcount_dec;
+        struct list_head req_classify_flow;
+        struct list_head tun_dev_alloc_security;
+        struct list_head tun_dev_free_security;
+        struct list_head tun_dev_create;
+        struct list_head tun_dev_attach_queue;
+        struct list_head tun_dev_attach;
+        struct list_head tun_dev_open;
+        struct list_head skb_owned_by;
+#endif  /* CONFIG_SECURITY_NETWORK */
+#ifdef CONFIG_SECURITY_NETWORK_XFRM
+        struct list_head xfrm_policy_alloc_security;
+        struct list_head xfrm_policy_clone_security;
+        struct list_head xfrm_policy_free_security;
+        struct list_head xfrm_policy_delete_security;
+        struct list_head xfrm_state_alloc;
+        struct list_head xfrm_state_alloc_acquire;
+        struct list_head xfrm_state_free_security;
+        struct list_head xfrm_state_delete_security;
+        struct list_head xfrm_policy_lookup;
+        struct list_head xfrm_state_pol_flow_match;
+        struct list_head xfrm_decode_session;
+#endif  /* CONFIG_SECURITY_NETWORK_XFRM */
+#ifdef CONFIG_KEYS
+        struct list_head key_alloc;
+        struct list_head key_free;
+        struct list_head key_permission;
+        struct list_head key_getsecurity;
+#endif  /* CONFIG_KEYS */
+#ifdef CONFIG_AUDIT
+        struct list_head audit_rule_init;
+        struct list_head audit_rule_known;
+        struct list_head audit_rule_match;
+        struct list_head audit_rule_free;
+#endif /* CONFIG_AUDIT */
+};
+
+/*
+ * Security module hook list structure.
+ * For use with generic list macros for common operations.
+ */
+struct security_hook_list {
+        struct list_head                list;
+        struct list_head                *head;
+        union security_list_options     hook;
+};
+
+/*
+ * Initializing a security_hook_list structure takes
+ * up a lot of space in a source file. This macro takes
+ * care of the common case and reduces the amount of
+ * text involved.
+ */
+#define LSM_HOOK_INIT(HEAD, HOOK) \
+        { .head = &security_hook_heads.HEAD, .hook = { .HEAD = HOOK } }
+
+extern struct security_hook_heads security_hook_heads;
+
+static inline void security_add_hooks(struct security_hook_list *hooks,
+                                      int count)
+{
+        int i;
+
+        for (i = 0; i < count; i++)
+                list_add_tail_rcu(&hooks[i].list, hooks[i].head);
+}
+
+#ifdef CONFIG_SECURITY_SELINUX_DISABLE
+/*
+ * Assuring the safety of deleting a security module is up to
+ * the security module involved. This may entail ordering the
+ * module's hook list in a particular way, refusing to disable
+ * the module once a policy is loaded or any number of other
+ * actions better imagined than described.
+ *
+ * The name of the configuration option reflects the only module
+ * that currently uses the mechanism. Any developer who thinks
+ * disabling their module is a good idea needs to be at least as
+ * careful as the SELinux team.
+ */
+static inline void security_delete_hooks(struct security_hook_list *hooks,
+                                                int count)
+{
+        int i;
+
+        for (i = 0; i < count; i++)
+                list_del_rcu(&hooks[i].list);
+}
+#endif /* CONFIG_SECURITY_SELINUX_DISABLE */
+
+extern int __init security_module_enable(const char *module);
+extern void __init capability_add_hooks(void);
+#ifdef CONFIG_SECURITY_YAMA_STACKED
+void __init yama_add_hooks(void);
+#endif
+
+#endif /* ! __LINUX_LSM_HOOKS_H */
diff --git a/include/linux/mailbox_client.h b/include/linux/mailbox_client.h
index 1726ccbd8009..44348710953f 100644
--- a/include/linux/mailbox_client.h
+++ b/include/linux/mailbox_client.h
@@ -40,6 +40,8 @@ struct mbox_client {
         void (*tx_done)(struct mbox_client *cl, void *mssg, int r);
 };
 
+struct mbox_chan *mbox_request_channel_byname(struct mbox_client *cl,
+                                              const char *name);
 struct mbox_chan *mbox_request_channel(struct mbox_client *cl, int index);
 int mbox_send_message(struct mbox_chan *chan, void *mssg);
 void mbox_client_txdone(struct mbox_chan *chan, int r); /* atomic */
diff --git a/include/linux/mailbox_controller.h b/include/linux/mailbox_controller.h
index d4cf96f07cfc..68c42454439b 100644
--- a/include/linux/mailbox_controller.h
+++ b/include/linux/mailbox_controller.h
@@ -72,7 +72,7 @@ struct mbox_chan_ops {
  */
 struct mbox_controller {
         struct device *dev;
-        struct mbox_chan_ops *ops;
+        const struct mbox_chan_ops *ops;
         struct mbox_chan *chans;
         int num_chans;
         bool txdone_irq;
diff --git a/include/linux/mdio-gpio.h b/include/linux/mdio-gpio.h
index 66c30a763b10..11f00cdabe3d 100644
--- a/include/linux/mdio-gpio.h
+++ b/include/linux/mdio-gpio.h
@@ -23,7 +23,8 @@ struct mdio_gpio_platform_data {
         bool mdio_active_low;
         bool mdo_active_low;
 
-        unsigned int phy_mask;
+        u32 phy_mask;
+        u32 phy_ignore_ta_mask;
         int irqs[PHY_MAX_ADDR];
         /* reset callback */
         int (*reset)(struct mii_bus *bus);
diff --git a/include/linux/mei_cl_bus.h b/include/linux/mei_cl_bus.h
index 0819d36a3a74..a16b1f9c1aca 100644
--- a/include/linux/mei_cl_bus.h
+++ b/include/linux/mei_cl_bus.h
@@ -7,6 +7,42 @@
 
 struct mei_cl_device;
 
+typedef void (*mei_cl_event_cb_t)(struct mei_cl_device *device,
+                               u32 events, void *context);
+
+/**
+ * struct mei_cl_device - MEI device handle
+ * An mei_cl_device pointer is returned from mei_add_device()
+ * and links MEI bus clients to their actual ME host client pointer.
+ * Drivers for MEI devices will get an mei_cl_device pointer
+ * when being probed and shall use it for doing ME bus I/O.
+ *
+ * @dev: linux driver model device pointer
+ * @me_cl: me client
+ * @cl: mei client
+ * @name: device name
+ * @event_work: async work to execute event callback
+ * @event_cb: Drivers register this callback to get asynchronous ME
+ *      events (e.g. Rx buffer pending) notifications.
+ * @event_context: event callback run context
+ * @events: Events bitmask sent to the driver.
+ * @priv_data: client private data
+ */
+struct mei_cl_device {
+        struct device dev;
+
+        struct mei_me_client *me_cl;
+        struct mei_cl *cl;
+        char name[MEI_CL_NAME_SIZE];
+
+        struct work_struct event_work;
+        mei_cl_event_cb_t event_cb;
+        void *event_context;
+        unsigned long events;
+
+        void *priv_data;
+};
+
 struct mei_cl_driver {
         struct device_driver driver;
         const char *name;
@@ -28,8 +64,6 @@ void mei_cl_driver_unregister(struct mei_cl_driver *driver);
 ssize_t mei_cl_send(struct mei_cl_device *device, u8 *buf, size_t length);
 ssize_t  mei_cl_recv(struct mei_cl_device *device, u8 *buf, size_t length);
 
-typedef void (*mei_cl_event_cb_t)(struct mei_cl_device *device,
-                               u32 events, void *context);
 int mei_cl_register_event_cb(struct mei_cl_device *device,
                           mei_cl_event_cb_t read_cb, void *context);
 
diff --git a/include/linux/memblock.h b/include/linux/memblock.h
index 9497ec7c77ea..cc4b01972060 100644
--- a/include/linux/memblock.h
+++ b/include/linux/memblock.h
@@ -21,7 +21,11 @@
 #define INIT_PHYSMEM_REGIONS    4
 
 /* Definition of memblock flags. */
-#define MEMBLOCK_HOTPLUG        0x1     /* hotpluggable region */
+enum {
+        MEMBLOCK_NONE           = 0x0,  /* No special request */
+        MEMBLOCK_HOTPLUG        = 0x1,  /* hotpluggable region */
+        MEMBLOCK_MIRROR         = 0x2,  /* mirrored region */
+};
 
 struct memblock_region {
         phys_addr_t base;
@@ -61,7 +65,7 @@ extern bool movable_node_enabled;
 
 phys_addr_t memblock_find_in_range_node(phys_addr_t size, phys_addr_t align,
                                             phys_addr_t start, phys_addr_t end,
-                                            int nid);
+                                            int nid, ulong flags);
 phys_addr_t memblock_find_in_range(phys_addr_t start, phys_addr_t end,
                                    phys_addr_t size, phys_addr_t align);
 phys_addr_t get_allocated_memblock_reserved_regions_info(phys_addr_t *addr);
@@ -75,6 +79,8 @@ int memblock_reserve(phys_addr_t base, phys_addr_t size);
 void memblock_trim_memory(phys_addr_t align);
 int memblock_mark_hotplug(phys_addr_t base, phys_addr_t size);
 int memblock_clear_hotplug(phys_addr_t base, phys_addr_t size);
+int memblock_mark_mirror(phys_addr_t base, phys_addr_t size);
+ulong choose_memblock_flags(void);
 
 /* Low level functions */
 int memblock_add_range(struct memblock_type *type,
@@ -85,14 +91,19 @@ int memblock_remove_range(struct memblock_type *type,
                           phys_addr_t base,
                           phys_addr_t size);
 
-void __next_mem_range(u64 *idx, int nid, struct memblock_type *type_a,
+void __next_mem_range(u64 *idx, int nid, ulong flags,
+                      struct memblock_type *type_a,
                       struct memblock_type *type_b, phys_addr_t *out_start,
                       phys_addr_t *out_end, int *out_nid);
 
-void __next_mem_range_rev(u64 *idx, int nid, struct memblock_type *type_a,
+void __next_mem_range_rev(u64 *idx, int nid, ulong flags,
+                          struct memblock_type *type_a,
                           struct memblock_type *type_b, phys_addr_t *out_start,
                           phys_addr_t *out_end, int *out_nid);
 
+void __next_reserved_mem_region(u64 *idx, phys_addr_t *out_start,
+                               phys_addr_t *out_end);
+
 /**
  * for_each_mem_range - iterate through memblock areas from type_a and not
  * included in type_b. Or just type_a if type_b is NULL.
@@ -100,16 +111,17 @@ void __next_mem_range_rev(u64 *idx, int nid, struct memblock_type *type_a,
  * @type_a: ptr to memblock_type to iterate
  * @type_b: ptr to memblock_type which excludes from the iteration
  * @nid: node selector, %NUMA_NO_NODE for all nodes
+ * @flags: pick from blocks based on memory attributes
  * @p_start: ptr to phys_addr_t for start address of the range, can be %NULL
  * @p_end: ptr to phys_addr_t for end address of the range, can be %NULL
  * @p_nid: ptr to int for nid of the range, can be %NULL
  */
-#define for_each_mem_range(i, type_a, type_b, nid,                      \
+#define for_each_mem_range(i, type_a, type_b, nid, flags,               \
                            p_start, p_end, p_nid)                       \
-        for (i = 0, __next_mem_range(&i, nid, type_a, type_b,           \
+        for (i = 0, __next_mem_range(&i, nid, flags, type_a, type_b,    \
                                      p_start, p_end, p_nid);            \
              i != (u64)ULLONG_MAX;                                      \
-             __next_mem_range(&i, nid, type_a, type_b,                  \
+             __next_mem_range(&i, nid, flags, type_a, type_b,           \
                               p_start, p_end, p_nid))
 
 /**
@@ -119,19 +131,35 @@ void __next_mem_range_rev(u64 *idx, int nid, struct memblock_type *type_a,
  * @type_a: ptr to memblock_type to iterate
  * @type_b: ptr to memblock_type which excludes from the iteration
  * @nid: node selector, %NUMA_NO_NODE for all nodes
+ * @flags: pick from blocks based on memory attributes
  * @p_start: ptr to phys_addr_t for start address of the range, can be %NULL
  * @p_end: ptr to phys_addr_t for end address of the range, can be %NULL
  * @p_nid: ptr to int for nid of the range, can be %NULL
  */
-#define for_each_mem_range_rev(i, type_a, type_b, nid,                  \
+#define for_each_mem_range_rev(i, type_a, type_b, nid, flags,           \
                                p_start, p_end, p_nid)                   \
         for (i = (u64)ULLONG_MAX,                                       \
-                     __next_mem_range_rev(&i, nid, type_a, type_b,      \
+                     __next_mem_range_rev(&i, nid, flags, type_a, type_b,\
                                          p_start, p_end, p_nid);        \
              i != (u64)ULLONG_MAX;                                      \
-             __next_mem_range_rev(&i, nid, type_a, type_b,              \
+             __next_mem_range_rev(&i, nid, flags, type_a, type_b,       \
                                   p_start, p_end, p_nid))
 
+/**
+ * for_each_reserved_mem_region - iterate over all reserved memblock areas
+ * @i: u64 used as loop variable
+ * @p_start: ptr to phys_addr_t for start address of the range, can be %NULL
+ * @p_end: ptr to phys_addr_t for end address of the range, can be %NULL
+ *
+ * Walks over reserved areas of memblock. Available as soon as memblock
+ * is initialized.
+ */
+#define for_each_reserved_mem_region(i, p_start, p_end)                 \
+        for (i = 0UL,                                                   \
+             __next_reserved_mem_region(&i, p_start, p_end);            \
+             i != (u64)ULLONG_MAX;                                      \
+             __next_reserved_mem_region(&i, p_start, p_end))
+
 #ifdef CONFIG_MOVABLE_NODE
 static inline bool memblock_is_hotpluggable(struct memblock_region *m)
 {
@@ -153,6 +181,11 @@ static inline bool movable_node_is_enabled(void)
 }
 #endif
 
+static inline bool memblock_is_mirror(struct memblock_region *m)
+{
+        return m->flags & MEMBLOCK_MIRROR;
+}
+
 #ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP
 int memblock_search_pfn_nid(unsigned long pfn, unsigned long *start_pfn,
                             unsigned long  *end_pfn);
@@ -181,13 +214,14 @@ void __next_mem_pfn_range(int *idx, int nid, unsigned long *out_start_pfn,
  * @p_start: ptr to phys_addr_t for start address of the range, can be %NULL
  * @p_end: ptr to phys_addr_t for end address of the range, can be %NULL
  * @p_nid: ptr to int for nid of the range, can be %NULL
+ * @flags: pick from blocks based on memory attributes
  *
  * Walks over free (memory && !reserved) areas of memblock.  Available as
  * soon as memblock is initialized.
  */
-#define for_each_free_mem_range(i, nid, p_start, p_end, p_nid)          \
+#define for_each_free_mem_range(i, nid, flags, p_start, p_end, p_nid)   \
         for_each_mem_range(i, &memblock.memory, &memblock.reserved,     \
-                           nid, p_start, p_end, p_nid)
+                           nid, flags, p_start, p_end, p_nid)
 
 /**
  * for_each_free_mem_range_reverse - rev-iterate through free memblock areas
@@ -196,13 +230,15 @@ void __next_mem_pfn_range(int *idx, int nid, unsigned long *out_start_pfn,
  * @p_start: ptr to phys_addr_t for start address of the range, can be %NULL
  * @p_end: ptr to phys_addr_t for end address of the range, can be %NULL
  * @p_nid: ptr to int for nid of the range, can be %NULL
+ * @flags: pick from blocks based on memory attributes
  *
  * Walks over free (memory && !reserved) areas of memblock in reverse
  * order.  Available as soon as memblock is initialized.
  */
-#define for_each_free_mem_range_reverse(i, nid, p_start, p_end, p_nid)  \
+#define for_each_free_mem_range_reverse(i, nid, flags, p_start, p_end,  \
+                                        p_nid)                          \
         for_each_mem_range_rev(i, &memblock.memory, &memblock.reserved, \
-                               nid, p_start, p_end, p_nid)
+                               nid, flags, p_start, p_end, p_nid)
 
 static inline void memblock_set_region_flags(struct memblock_region *r,
                                              unsigned long flags)
@@ -273,7 +309,8 @@ static inline bool memblock_bottom_up(void) { return false; }
 #define MEMBLOCK_ALLOC_ACCESSIBLE       0
 
 phys_addr_t __init memblock_alloc_range(phys_addr_t size, phys_addr_t align,
-                                        phys_addr_t start, phys_addr_t end);
+                                        phys_addr_t start, phys_addr_t end,
+                                        ulong flags);
 phys_addr_t memblock_alloc_base(phys_addr_t size, phys_addr_t align,
                                 phys_addr_t max_addr);
 phys_addr_t __memblock_alloc_base(phys_addr_t size, phys_addr_t align,
diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h
index 6c8918114804..73b02b0a8f60 100644
--- a/include/linux/memcontrol.h
+++ b/include/linux/memcontrol.h
@@ -41,6 +41,7 @@ enum mem_cgroup_stat_index {
         MEM_CGROUP_STAT_RSS,            /* # of pages charged as anon rss */
         MEM_CGROUP_STAT_RSS_HUGE,       /* # of pages charged as anon huge */
         MEM_CGROUP_STAT_FILE_MAPPED,    /* # of pages charged as file rss */
+        MEM_CGROUP_STAT_DIRTY,          /* # of dirty pages in page cache */
         MEM_CGROUP_STAT_WRITEBACK,      /* # of pages under writeback */
         MEM_CGROUP_STAT_SWAP,           /* # of pages, swapped out */
         MEM_CGROUP_STAT_NSTATS,
@@ -67,6 +68,8 @@ enum mem_cgroup_events_index {
 };
 
 #ifdef CONFIG_MEMCG
+extern struct cgroup_subsys_state *mem_cgroup_root_css;
+
 void mem_cgroup_events(struct mem_cgroup *memcg,
                        enum mem_cgroup_events_index idx,
                        unsigned int nr);
@@ -112,6 +115,7 @@ static inline bool mm_match_cgroup(struct mm_struct *mm,
 }
 
 extern struct cgroup_subsys_state *mem_cgroup_css(struct mem_cgroup *memcg);
+extern struct cgroup_subsys_state *mem_cgroup_css_from_page(struct page *page);
 
 struct mem_cgroup *mem_cgroup_iter(struct mem_cgroup *,
                                    struct mem_cgroup *,
@@ -195,6 +199,8 @@ void mem_cgroup_split_huge_fixup(struct page *head);
 #else /* CONFIG_MEMCG */
 struct mem_cgroup;
 
+#define mem_cgroup_root_css ((struct cgroup_subsys_state *)ERR_PTR(-EINVAL))
+
 static inline void mem_cgroup_events(struct mem_cgroup *memcg,
                                      enum mem_cgroup_events_index idx,
                                      unsigned int nr)
@@ -382,6 +388,29 @@ enum {
         OVER_LIMIT,
 };
 
+#ifdef CONFIG_CGROUP_WRITEBACK
+
+struct list_head *mem_cgroup_cgwb_list(struct mem_cgroup *memcg);
+struct wb_domain *mem_cgroup_wb_domain(struct bdi_writeback *wb);
+void mem_cgroup_wb_stats(struct bdi_writeback *wb, unsigned long *pavail,
+                         unsigned long *pdirty, unsigned long *pwriteback);
+
+#else   /* CONFIG_CGROUP_WRITEBACK */
+
+static inline struct wb_domain *mem_cgroup_wb_domain(struct bdi_writeback *wb)
+{
+        return NULL;
+}
+
+static inline void mem_cgroup_wb_stats(struct bdi_writeback *wb,
+                                       unsigned long *pavail,
+                                       unsigned long *pdirty,
+                                       unsigned long *pwriteback)
+{
+}
+
+#endif  /* CONFIG_CGROUP_WRITEBACK */
+
 struct sock;
 #if defined(CONFIG_INET) && defined(CONFIG_MEMCG_KMEM)
 void sock_update_memcg(struct sock *sk);
diff --git a/include/linux/mfd/arizona/core.h b/include/linux/mfd/arizona/core.h
index 16a498f48169..2f434f4f79a1 100644
--- a/include/linux/mfd/arizona/core.h
+++ b/include/linux/mfd/arizona/core.h
@@ -117,6 +117,7 @@ struct arizona {
         int num_core_supplies;
         struct regulator_bulk_data core_supplies[ARIZONA_MAX_CORE_SUPPLIES];
         struct regulator *dcvdd;
+        bool has_fully_powered_off;
 
         struct arizona_pdata pdata;
 
@@ -153,7 +154,15 @@ int arizona_request_irq(struct arizona *arizona, int irq, char *name,
 void arizona_free_irq(struct arizona *arizona, int irq, void *data);
 int arizona_set_irq_wake(struct arizona *arizona, int irq, int on);
 
+#ifdef CONFIG_MFD_WM5102
 int wm5102_patch(struct arizona *arizona);
+#else
+static inline int wm5102_patch(struct arizona *arizona)
+{
+        return 0;
+}
+#endif
+
 int wm5110_patch(struct arizona *arizona);
 int wm8997_patch(struct arizona *arizona);
 
diff --git a/include/linux/mfd/arizona/pdata.h b/include/linux/mfd/arizona/pdata.h
index 1789cb0f4f17..43db4faad143 100644
--- a/include/linux/mfd/arizona/pdata.h
+++ b/include/linux/mfd/arizona/pdata.h
@@ -121,6 +121,9 @@ struct arizona_pdata {
         /** GPIO used for mic isolation with HPDET */
         int hpdet_id_gpio;
 
+        /** Channel to use for headphone detection */
+        unsigned int hpdet_channel;
+
         /** Extra debounce timeout used during initial mic detection (ms) */
         int micd_detect_debounce;
 
@@ -156,7 +159,10 @@ struct arizona_pdata {
         /** MICBIAS configurations */
         struct arizona_micbias micbias[ARIZONA_MAX_MICBIAS];
 
-        /** Mode of input structures */
+        /**
+         * Mode of input structures
+         * One of the ARIZONA_INMODE_xxx values
+         */
         int inmode[ARIZONA_MAX_INPUT];
 
         /** Mode for outputs */
diff --git a/include/linux/mfd/arizona/registers.h b/include/linux/mfd/arizona/registers.h
index aacc10d7789c..3499d36e6067 100644
--- a/include/linux/mfd/arizona/registers.h
+++ b/include/linux/mfd/arizona/registers.h
@@ -2515,9 +2515,12 @@
 #define ARIZONA_IN1_DMIC_SUP_MASK                0x1800  /* IN1_DMIC_SUP - [12:11] */
 #define ARIZONA_IN1_DMIC_SUP_SHIFT                   11  /* IN1_DMIC_SUP - [12:11] */
 #define ARIZONA_IN1_DMIC_SUP_WIDTH                    2  /* IN1_DMIC_SUP - [12:11] */
-#define ARIZONA_IN1_MODE_MASK                    0x0600  /* IN1_MODE - [10:9] */
-#define ARIZONA_IN1_MODE_SHIFT                        9  /* IN1_MODE - [10:9] */
-#define ARIZONA_IN1_MODE_WIDTH                        2  /* IN1_MODE - [10:9] */
+#define ARIZONA_IN1_MODE_MASK                    0x0400  /* IN1_MODE - [10] */
+#define ARIZONA_IN1_MODE_SHIFT                       10  /* IN1_MODE - [10] */
+#define ARIZONA_IN1_MODE_WIDTH                        1  /* IN1_MODE - [10] */
+#define ARIZONA_IN1_SINGLE_ENDED_MASK            0x0200  /* IN1_MODE - [9] */
+#define ARIZONA_IN1_SINGLE_ENDED_SHIFT                9  /* IN1_MODE - [9] */
+#define ARIZONA_IN1_SINGLE_ENDED_WIDTH                1  /* IN1_MODE - [9] */
 #define ARIZONA_IN1L_PGA_VOL_MASK                0x00FE  /* IN1L_PGA_VOL - [7:1] */
 #define ARIZONA_IN1L_PGA_VOL_SHIFT                    1  /* IN1L_PGA_VOL - [7:1] */
 #define ARIZONA_IN1L_PGA_VOL_WIDTH                    7  /* IN1L_PGA_VOL - [7:1] */
@@ -2588,9 +2591,12 @@
 #define ARIZONA_IN2_DMIC_SUP_MASK                0x1800  /* IN2_DMIC_SUP - [12:11] */
 #define ARIZONA_IN2_DMIC_SUP_SHIFT                   11  /* IN2_DMIC_SUP - [12:11] */
 #define ARIZONA_IN2_DMIC_SUP_WIDTH                    2  /* IN2_DMIC_SUP - [12:11] */
-#define ARIZONA_IN2_MODE_MASK                    0x0600  /* IN2_MODE - [10:9] */
-#define ARIZONA_IN2_MODE_SHIFT                        9  /* IN2_MODE - [10:9] */
-#define ARIZONA_IN2_MODE_WIDTH                        2  /* IN2_MODE - [10:9] */
+#define ARIZONA_IN2_MODE_MASK                    0x0400  /* IN2_MODE - [10] */
+#define ARIZONA_IN2_MODE_SHIFT                       10  /* IN2_MODE - [10] */
+#define ARIZONA_IN2_MODE_WIDTH                        1  /* IN2_MODE - [10] */
+#define ARIZONA_IN2_SINGLE_ENDED_MASK            0x0200  /* IN2_MODE - [9] */
+#define ARIZONA_IN2_SINGLE_ENDED_SHIFT                9  /* IN2_MODE - [9] */
+#define ARIZONA_IN2_SINGLE_ENDED_WIDTH                1  /* IN2_MODE - [9] */
 #define ARIZONA_IN2L_PGA_VOL_MASK                0x00FE  /* IN2L_PGA_VOL - [7:1] */
 #define ARIZONA_IN2L_PGA_VOL_SHIFT                    1  /* IN2L_PGA_VOL - [7:1] */
 #define ARIZONA_IN2L_PGA_VOL_WIDTH                    7  /* IN2L_PGA_VOL - [7:1] */
@@ -2661,9 +2667,12 @@
 #define ARIZONA_IN3_DMIC_SUP_MASK                0x1800  /* IN3_DMIC_SUP - [12:11] */
 #define ARIZONA_IN3_DMIC_SUP_SHIFT                   11  /* IN3_DMIC_SUP - [12:11] */
 #define ARIZONA_IN3_DMIC_SUP_WIDTH                    2  /* IN3_DMIC_SUP - [12:11] */
-#define ARIZONA_IN3_MODE_MASK                    0x0600  /* IN3_MODE - [10:9] */
-#define ARIZONA_IN3_MODE_SHIFT                        9  /* IN3_MODE - [10:9] */
-#define ARIZONA_IN3_MODE_WIDTH                        2  /* IN3_MODE - [10:9] */
+#define ARIZONA_IN3_MODE_MASK                    0x0400  /* IN3_MODE - [10] */
+#define ARIZONA_IN3_MODE_SHIFT                       10  /* IN3_MODE - [10] */
+#define ARIZONA_IN3_MODE_WIDTH                        1  /* IN3_MODE - [10] */
+#define ARIZONA_IN3_SINGLE_ENDED_MASK            0x0200  /* IN3_MODE - [9] */
+#define ARIZONA_IN3_SINGLE_ENDED_SHIFT                9  /* IN3_MODE - [9] */
+#define ARIZONA_IN3_SINGLE_ENDED_WIDTH                1  /* IN3_MODE - [9] */
 #define ARIZONA_IN3L_PGA_VOL_MASK                0x00FE  /* IN3L_PGA_VOL - [7:1] */
 #define ARIZONA_IN3L_PGA_VOL_SHIFT                    1  /* IN3L_PGA_VOL - [7:1] */
 #define ARIZONA_IN3L_PGA_VOL_WIDTH                    7  /* IN3L_PGA_VOL - [7:1] */
diff --git a/include/linux/mfd/axp20x.h b/include/linux/mfd/axp20x.h
index dfabd6db7ddf..c2aa853fb412 100644
--- a/include/linux/mfd/axp20x.h
+++ b/include/linux/mfd/axp20x.h
@@ -14,6 +14,7 @@
 enum {
         AXP202_ID = 0,
         AXP209_ID,
+        AXP221_ID,
         AXP288_ID,
         NR_AXP20X_VARIANTS,
 };
@@ -45,6 +46,28 @@ enum {
 #define AXP20X_V_LTF_DISCHRG            0x3c
 #define AXP20X_V_HTF_DISCHRG            0x3d
 
+#define AXP22X_PWR_OUT_CTRL1            0x10
+#define AXP22X_PWR_OUT_CTRL2            0x12
+#define AXP22X_PWR_OUT_CTRL3            0x13
+#define AXP22X_DLDO1_V_OUT              0x15
+#define AXP22X_DLDO2_V_OUT              0x16
+#define AXP22X_DLDO3_V_OUT              0x17
+#define AXP22X_DLDO4_V_OUT              0x18
+#define AXP22X_ELDO1_V_OUT              0x19
+#define AXP22X_ELDO2_V_OUT              0x1a
+#define AXP22X_ELDO3_V_OUT              0x1b
+#define AXP22X_DC5LDO_V_OUT             0x1c
+#define AXP22X_DCDC1_V_OUT              0x21
+#define AXP22X_DCDC2_V_OUT              0x22
+#define AXP22X_DCDC3_V_OUT              0x23
+#define AXP22X_DCDC4_V_OUT              0x24
+#define AXP22X_DCDC5_V_OUT              0x25
+#define AXP22X_DCDC23_V_RAMP_CTRL       0x27
+#define AXP22X_ALDO1_V_OUT              0x28
+#define AXP22X_ALDO2_V_OUT              0x29
+#define AXP22X_ALDO3_V_OUT              0x2a
+#define AXP22X_CHRG_CTRL3               0x35
+
 /* Interrupt */
 #define AXP20X_IRQ1_EN                  0x40
 #define AXP20X_IRQ2_EN                  0x41
@@ -100,6 +123,9 @@ enum {
 #define AXP20X_VBUS_MON                 0x8b
 #define AXP20X_OVER_TMP                 0x8f
 
+#define AXP22X_PWREN_CTRL1              0x8c
+#define AXP22X_PWREN_CTRL2              0x8d
+
 /* GPIO */
 #define AXP20X_GPIO0_CTRL               0x90
 #define AXP20X_LDO5_V_OUT               0x91
@@ -108,6 +134,11 @@ enum {
 #define AXP20X_GPIO20_SS                0x94
 #define AXP20X_GPIO3_CTRL               0x95
 
+#define AXP22X_LDO_IO0_V_OUT            0x91
+#define AXP22X_LDO_IO1_V_OUT            0x93
+#define AXP22X_GPIO_STATE               0x94
+#define AXP22X_GPIO_PULL_DOWN           0x95
+
 /* Battery */
 #define AXP20X_CHRG_CC_31_24            0xb0
 #define AXP20X_CHRG_CC_23_16            0xb1
@@ -120,6 +151,9 @@ enum {
 #define AXP20X_CC_CTRL                  0xb8
 #define AXP20X_FG_RES                   0xb9
 
+/* AXP22X specific registers */
+#define AXP22X_BATLOW_THRES1            0xe6
+
 /* AXP288 specific registers */
 #define AXP288_PMIC_ADC_H               0x56
 #define AXP288_PMIC_ADC_L               0x57
@@ -158,6 +192,30 @@ enum {
         AXP20X_REG_ID_MAX,
 };
 
+enum {
+        AXP22X_DCDC1 = 0,
+        AXP22X_DCDC2,
+        AXP22X_DCDC3,
+        AXP22X_DCDC4,
+        AXP22X_DCDC5,
+        AXP22X_DC1SW,
+        AXP22X_DC5LDO,
+        AXP22X_ALDO1,
+        AXP22X_ALDO2,
+        AXP22X_ALDO3,
+        AXP22X_ELDO1,
+        AXP22X_ELDO2,
+        AXP22X_ELDO3,
+        AXP22X_DLDO1,
+        AXP22X_DLDO2,
+        AXP22X_DLDO3,
+        AXP22X_DLDO4,
+        AXP22X_RTC_LDO,
+        AXP22X_LDO_IO0,
+        AXP22X_LDO_IO1,
+        AXP22X_REG_ID_MAX,
+};
+
 /* IRQs */
 enum {
         AXP20X_IRQ_ACIN_OVER_V = 1,
@@ -199,6 +257,34 @@ enum {
         AXP20X_IRQ_GPIO0_INPUT,
 };
 
+enum axp22x_irqs {
+        AXP22X_IRQ_ACIN_OVER_V = 1,
+        AXP22X_IRQ_ACIN_PLUGIN,
+        AXP22X_IRQ_ACIN_REMOVAL,
+        AXP22X_IRQ_VBUS_OVER_V,
+        AXP22X_IRQ_VBUS_PLUGIN,
+        AXP22X_IRQ_VBUS_REMOVAL,
+        AXP22X_IRQ_VBUS_V_LOW,
+        AXP22X_IRQ_BATT_PLUGIN,
+        AXP22X_IRQ_BATT_REMOVAL,
+        AXP22X_IRQ_BATT_ENT_ACT_MODE,
+        AXP22X_IRQ_BATT_EXIT_ACT_MODE,
+        AXP22X_IRQ_CHARG,
+        AXP22X_IRQ_CHARG_DONE,
+        AXP22X_IRQ_BATT_TEMP_HIGH,
+        AXP22X_IRQ_BATT_TEMP_LOW,
+        AXP22X_IRQ_DIE_TEMP_HIGH,
+        AXP22X_IRQ_PEK_SHORT,
+        AXP22X_IRQ_PEK_LONG,
+        AXP22X_IRQ_LOW_PWR_LVL1,
+        AXP22X_IRQ_LOW_PWR_LVL2,
+        AXP22X_IRQ_TIMER,
+        AXP22X_IRQ_PEK_RIS_EDGE,
+        AXP22X_IRQ_PEK_FAL_EDGE,
+        AXP22X_IRQ_GPIO1_INPUT,
+        AXP22X_IRQ_GPIO0_INPUT,
+};
+
 enum axp288_irqs {
         AXP288_IRQ_VBUS_FALL     = 2,
         AXP288_IRQ_VBUS_RISE,
@@ -275,4 +361,16 @@ struct axp20x_fg_pdata {
         int thermistor_curve[MAX_THERM_CURVE_SIZE][2];
 };
 
+struct axp20x_chrg_pdata {
+        int max_cc;
+        int max_cv;
+        int def_cc;
+        int def_cv;
+};
+
+struct axp288_extcon_pdata {
+        /* GPIO pin control to switch D+/D- lines b/w PMIC and SOC */
+        struct gpio_desc *gpio_mux_cntl;
+};
+
 #endif /* __LINUX_MFD_AXP20X_H */
diff --git a/include/linux/mfd/cros_ec.h b/include/linux/mfd/cros_ec.h
index 324a34683971..da72671a42fa 100644
--- a/include/linux/mfd/cros_ec.h
+++ b/include/linux/mfd/cros_ec.h
@@ -17,10 +17,29 @@
 #define __LINUX_MFD_CROS_EC_H
 
 #include <linux/cdev.h>
+#include <linux/device.h>
 #include <linux/notifier.h>
 #include <linux/mfd/cros_ec_commands.h>
 #include <linux/mutex.h>
 
+#define CROS_EC_DEV_NAME "cros_ec"
+#define CROS_EC_DEV_PD_NAME "cros_pd"
+
+/*
+ * The EC is unresponsive for a time after a reboot command.  Add a
+ * simple delay to make sure that the bus stays locked.
+ */
+#define EC_REBOOT_DELAY_MS             50
+
+/*
+ * Max bus-specific overhead incurred by request/responses.
+ * I2C requires 1 additional byte for requests.
+ * I2C requires 2 additional bytes for responses.
+ * */
+#define EC_PROTO_VERSION_UNKNOWN        0
+#define EC_MAX_REQUEST_OVERHEAD         1
+#define EC_MAX_RESPONSE_OVERHEAD        2
+
 /*
  * Command interface between EC and AP, for LPC, I2C and SPI interfaces.
  */
@@ -42,8 +61,7 @@ enum {
  * @outsize: Outgoing length in bytes
  * @insize: Max number of bytes to accept from EC
  * @result: EC's response to the command (separate from communication failure)
- * @outdata: Outgoing data to EC
- * @indata: Where to put the incoming data from EC
+ * @data: Where to put the incoming data from EC and outgoing data to EC
  */
 struct cros_ec_command {
         uint32_t version;
@@ -51,18 +69,14 @@ struct cros_ec_command {
         uint32_t outsize;
         uint32_t insize;
         uint32_t result;
-        uint8_t outdata[EC_PROTO2_MAX_PARAM_SIZE];
-        uint8_t indata[EC_PROTO2_MAX_PARAM_SIZE];
+        uint8_t data[0];
 };
 
 /**
  * struct cros_ec_device - Information about a ChromeOS EC device
  *
- * @ec_name: name of EC device (e.g. 'chromeos-ec')
  * @phys_name: name of physical comms layer (e.g. 'i2c-4')
  * @dev: Device pointer for physical comms device
- * @vdev: Device pointer for virtual comms device
- * @cdev: Character device structure for virtual comms device
  * @was_wake_device: true if this device was set to wake the system from
  * sleep at the last suspend
  * @cmd_readmem: direct read of the EC memory-mapped region, if supported
@@ -74,6 +88,7 @@ struct cros_ec_command {
  *
  * @priv: Private data
  * @irq: Interrupt to use
+ * @id: Device id
  * @din: input buffer (for data from EC)
  * @dout: output buffer (for data to EC)
  * \note
@@ -85,41 +100,72 @@ struct cros_ec_command {
  * to using dword.
  * @din_size: size of din buffer to allocate (zero to use static din)
  * @dout_size: size of dout buffer to allocate (zero to use static dout)
- * @parent: pointer to parent device (e.g. i2c or spi device)
  * @wake_enabled: true if this device can wake the system from sleep
  * @cmd_xfer: send command to EC and get response
  *     Returns the number of bytes received if the communication succeeded, but
  *     that doesn't mean the EC was happy with the command. The caller
  *     should check msg.result for the EC's result code.
+ * @pkt_xfer: send packet to EC and get response
  * @lock: one transaction at a time
  */
 struct cros_ec_device {
 
         /* These are used by other drivers that want to talk to the EC */
-        const char *ec_name;
         const char *phys_name;
         struct device *dev;
-        struct device *vdev;
-        struct cdev cdev;
         bool was_wake_device;
         struct class *cros_class;
         int (*cmd_readmem)(struct cros_ec_device *ec, unsigned int offset,
                            unsigned int bytes, void *dest);
 
         /* These are used to implement the platform-specific interface */
+        u16 max_request;
+        u16 max_response;
+        u16 max_passthru;
+        u16 proto_version;
         void *priv;
         int irq;
-        uint8_t *din;
-        uint8_t *dout;
+        u8 *din;
+        u8 *dout;
         int din_size;
         int dout_size;
-        struct device *parent;
         bool wake_enabled;
         int (*cmd_xfer)(struct cros_ec_device *ec,
                         struct cros_ec_command *msg);
+        int (*pkt_xfer)(struct cros_ec_device *ec,
+                        struct cros_ec_command *msg);
         struct mutex lock;
 };
 
+/* struct cros_ec_platform - ChromeOS EC platform information
+ *
+ * @ec_name: name of EC device (e.g. 'cros-ec', 'cros-pd', ...)
+ * used in /dev/ and sysfs.
+ * @cmd_offset: offset to apply for each command. Set when
+ * registering a devicde behind another one.
+ */
+struct cros_ec_platform {
+        const char *ec_name;
+        u16 cmd_offset;
+};
+
+/*
+ * struct cros_ec_dev - ChromeOS EC device entry point
+ *
+ * @class_dev: Device structure used in sysfs
+ * @cdev: Character device structure in /dev
+ * @ec_dev: cros_ec_device structure to talk to the physical device
+ * @dev: pointer to the platform device
+ * @cmd_offset: offset to apply for each command.
+ */
+struct cros_ec_dev {
+        struct device class_dev;
+        struct cdev cdev;
+        struct cros_ec_device *ec_dev;
+        struct device *dev;
+        u16 cmd_offset;
+};
+
 /**
  * cros_ec_suspend - Handle a suspend operation for the ChromeOS EC device
  *
@@ -198,4 +244,16 @@ int cros_ec_remove(struct cros_ec_device *ec_dev);
  */
 int cros_ec_register(struct cros_ec_device *ec_dev);
 
+/**
+ * cros_ec_register -  Query the protocol version supported by the ChromeOS EC
+ *
+ * @ec_dev: Device to register
+ * @return 0 if ok, -ve on error
+ */
+int cros_ec_query_all(struct cros_ec_device *ec_dev);
+
+/* sysfs stuff */
+extern struct attribute_group cros_ec_attr_group;
+extern struct attribute_group cros_ec_lightbar_attr_group;
+
 #endif /* __LINUX_MFD_CROS_EC_H */
diff --git a/include/linux/mfd/cros_ec_commands.h b/include/linux/mfd/cros_ec_commands.h
index a49cd41feea7..13b630c10d4c 100644
--- a/include/linux/mfd/cros_ec_commands.h
+++ b/include/linux/mfd/cros_ec_commands.h
@@ -515,7 +515,7 @@ struct ec_host_response {
 /*
  * Notes on commands:
  *
- * Each command is an 8-byte command value.  Commands which take params or
+ * Each command is an 16-bit command value.  Commands which take params or
  * return response data specify structs for that data.  If no struct is
  * specified, the command does not input or output data, respectively.
  * Parameter/response length is implicit in the structs.  Some underlying
@@ -966,7 +966,7 @@ struct rgb_s {
 /* List of tweakable parameters. NOTE: It's __packed so it can be sent in a
  * host command, but the alignment is the same regardless. Keep it that way.
  */
-struct lightbar_params {
+struct lightbar_params_v0 {
         /* Timing */
         int32_t google_ramp_up;
         int32_t google_ramp_down;
@@ -1000,32 +1000,81 @@ struct lightbar_params {
         struct rgb_s color[8];                  /* 0-3 are Google colors */
 } __packed;
 
+struct lightbar_params_v1 {
+        /* Timing */
+        int32_t google_ramp_up;
+        int32_t google_ramp_down;
+        int32_t s3s0_ramp_up;
+        int32_t s0_tick_delay[2];               /* AC=0/1 */
+        int32_t s0a_tick_delay[2];              /* AC=0/1 */
+        int32_t s0s3_ramp_down;
+        int32_t s3_sleep_for;
+        int32_t s3_ramp_up;
+        int32_t s3_ramp_down;
+        int32_t tap_tick_delay;
+        int32_t tap_display_time;
+
+        /* Tap-for-battery params */
+        uint8_t tap_pct_red;
+        uint8_t tap_pct_green;
+        uint8_t tap_seg_min_on;
+        uint8_t tap_seg_max_on;
+        uint8_t tap_seg_osc;
+        uint8_t tap_idx[3];
+
+        /* Oscillation */
+        uint8_t osc_min[2];                     /* AC=0/1 */
+        uint8_t osc_max[2];                     /* AC=0/1 */
+        uint8_t w_ofs[2];                       /* AC=0/1 */
+
+        /* Brightness limits based on the backlight and AC. */
+        uint8_t bright_bl_off_fixed[2];         /* AC=0/1 */
+        uint8_t bright_bl_on_min[2];            /* AC=0/1 */
+        uint8_t bright_bl_on_max[2];            /* AC=0/1 */
+
+        /* Battery level thresholds */
+        uint8_t battery_threshold[LB_BATTERY_LEVELS - 1];
+
+        /* Map [AC][battery_level] to color index */
+        uint8_t s0_idx[2][LB_BATTERY_LEVELS];   /* AP is running */
+        uint8_t s3_idx[2][LB_BATTERY_LEVELS];   /* AP is sleeping */
+
+        /* Color palette */
+        struct rgb_s color[8];                  /* 0-3 are Google colors */
+} __packed;
+
 struct ec_params_lightbar {
         uint8_t cmd;                  /* Command (see enum lightbar_command) */
         union {
                 struct {
                         /* no args */
-                } dump, off, on, init, get_seq, get_params, version;
+                } dump, off, on, init, get_seq, get_params_v0, get_params_v1,
+                        version, get_brightness, get_demo;
 
-                struct num {
+                struct {
                         uint8_t num;
-                } brightness, seq, demo;
+                } set_brightness, seq, demo;
 
-                struct reg {
+                struct {
                         uint8_t ctrl, reg, value;
                 } reg;
 
-                struct rgb {
+                struct {
                         uint8_t led, red, green, blue;
-                } rgb;
+                } set_rgb;
+
+                struct {
+                        uint8_t led;
+                } get_rgb;
 
-                struct lightbar_params set_params;
+                struct lightbar_params_v0 set_params_v0;
+                struct lightbar_params_v1 set_params_v1;
         };
 } __packed;
 
 struct ec_response_lightbar {
         union {
-                struct dump {
+                struct {
                         struct {
                                 uint8_t reg;
                                 uint8_t ic0;
@@ -1033,20 +1082,26 @@ struct ec_response_lightbar {
                         } vals[23];
                 } dump;
 
-                struct get_seq {
+                struct  {
                         uint8_t num;
-                } get_seq;
+                } get_seq, get_brightness, get_demo;
 
-                struct lightbar_params get_params;
+                struct lightbar_params_v0 get_params_v0;
+                struct lightbar_params_v1 get_params_v1;
 
-                struct version {
+                struct {
                         uint32_t num;
                         uint32_t flags;
                 } version;
 
                 struct {
+                        uint8_t red, green, blue;
+                } get_rgb;
+
+                struct {
                         /* no return params */
-                } off, on, init, brightness, seq, reg, rgb, demo, set_params;
+                } off, on, init, set_brightness, seq, reg, set_rgb,
+                        demo, set_params_v0, set_params_v1;
         };
 } __packed;
 
@@ -1056,15 +1111,20 @@ enum lightbar_command {
         LIGHTBAR_CMD_OFF = 1,
         LIGHTBAR_CMD_ON = 2,
         LIGHTBAR_CMD_INIT = 3,
-        LIGHTBAR_CMD_BRIGHTNESS = 4,
+        LIGHTBAR_CMD_SET_BRIGHTNESS = 4,
         LIGHTBAR_CMD_SEQ = 5,
         LIGHTBAR_CMD_REG = 6,
-        LIGHTBAR_CMD_RGB = 7,
+        LIGHTBAR_CMD_SET_RGB = 7,
         LIGHTBAR_CMD_GET_SEQ = 8,
         LIGHTBAR_CMD_DEMO = 9,
-        LIGHTBAR_CMD_GET_PARAMS = 10,
-        LIGHTBAR_CMD_SET_PARAMS = 11,
+        LIGHTBAR_CMD_GET_PARAMS_V0 = 10,
+        LIGHTBAR_CMD_SET_PARAMS_V0 = 11,
         LIGHTBAR_CMD_VERSION = 12,
+        LIGHTBAR_CMD_GET_BRIGHTNESS = 13,
+        LIGHTBAR_CMD_GET_RGB = 14,
+        LIGHTBAR_CMD_GET_DEMO = 15,
+        LIGHTBAR_CMD_GET_PARAMS_V1 = 16,
+        LIGHTBAR_CMD_SET_PARAMS_V1 = 17,
         LIGHTBAR_NUM_CMDS
 };
 
@@ -1421,8 +1481,40 @@ struct ec_response_rtc {
 /*****************************************************************************/
 /* Port80 log access */
 
+/* Maximum entries that can be read/written in a single command */
+#define EC_PORT80_SIZE_MAX 32
+
 /* Get last port80 code from previous boot */
 #define EC_CMD_PORT80_LAST_BOOT 0x48
+#define EC_CMD_PORT80_READ 0x48
+
+enum ec_port80_subcmd {
+        EC_PORT80_GET_INFO = 0,
+        EC_PORT80_READ_BUFFER,
+};
+
+struct ec_params_port80_read {
+        uint16_t subcmd;
+        union {
+                struct {
+                        uint32_t offset;
+                        uint32_t num_entries;
+                } read_buffer;
+        };
+} __packed;
+
+struct ec_response_port80_read {
+        union {
+                struct {
+                        uint32_t writes;
+                        uint32_t history_size;
+                        uint32_t last_boot;
+                } get_info;
+                struct {
+                        uint16_t codes[EC_PORT80_SIZE_MAX];
+                } data;
+        };
+} __packed;
 
 struct ec_response_port80_last_boot {
         uint16_t code;
@@ -1782,6 +1874,7 @@ struct ec_params_gpio_set {
 /* Get GPIO value */
 #define EC_CMD_GPIO_GET 0x93
 
+/* Version 0 of input params and response */
 struct ec_params_gpio_get {
         char name[32];
 } __packed;
@@ -1789,6 +1882,38 @@ struct ec_response_gpio_get {
         uint8_t val;
 } __packed;
 
+/* Version 1 of input params and response */
+struct ec_params_gpio_get_v1 {
+        uint8_t subcmd;
+        union {
+                struct {
+                        char name[32];
+                } get_value_by_name;
+                struct {
+                        uint8_t index;
+                } get_info;
+        };
+} __packed;
+
+struct ec_response_gpio_get_v1 {
+        union {
+                struct {
+                        uint8_t val;
+                } get_value_by_name, get_count;
+                struct {
+                        uint8_t val;
+                        char name[32];
+                        uint32_t flags;
+                } get_info;
+        };
+} __packed;
+
+enum gpio_get_subcmd {
+        EC_GPIO_GET_BY_NAME = 0,
+        EC_GPIO_GET_COUNT = 1,
+        EC_GPIO_GET_INFO = 2,
+};
+
 /*****************************************************************************/
 /* I2C commands. Only available when flash write protect is unlocked. */
 
@@ -1857,13 +1982,21 @@ struct ec_params_charge_control {
 /*****************************************************************************/
 
 /*
- * Cut off battery power output if the battery supports.
+ * Cut off battery power immediately or after the host has shut down.
  *
- * For unsupported battery, just don't implement this command and lets EC
- * return EC_RES_INVALID_COMMAND.
+ * return EC_RES_INVALID_COMMAND if unsupported by a board/battery.
+ *        EC_RES_SUCCESS if the command was successful.
+ *        EC_RES_ERROR if the cut off command failed.
  */
+
 #define EC_CMD_BATTERY_CUT_OFF 0x99
 
+#define EC_BATTERY_CUTOFF_FLAG_AT_SHUTDOWN      (1 << 0)
+
+struct ec_params_battery_cutoff {
+        uint8_t flags;
+} __packed;
+
 /*****************************************************************************/
 /* USB port mux control. */
 
@@ -2142,6 +2275,32 @@ struct ec_params_sb_wr_block {
 } __packed;
 
 /*****************************************************************************/
+/* Battery vendor parameters
+ *
+ * Get or set vendor-specific parameters in the battery. Implementations may
+ * differ between boards or batteries. On a set operation, the response
+ * contains the actual value set, which may be rounded or clipped from the
+ * requested value.
+ */
+
+#define EC_CMD_BATTERY_VENDOR_PARAM 0xb4
+
+enum ec_battery_vendor_param_mode {
+        BATTERY_VENDOR_PARAM_MODE_GET = 0,
+        BATTERY_VENDOR_PARAM_MODE_SET,
+};
+
+struct ec_params_battery_vendor_param {
+        uint32_t param;
+        uint32_t value;
+        uint8_t mode;
+} __packed;
+
+struct ec_response_battery_vendor_param {
+        uint32_t value;
+} __packed;
+
+/*****************************************************************************/
 /* System commands */
 
 /*
@@ -2338,6 +2497,80 @@ struct ec_params_reboot_ec {
 
 /*****************************************************************************/
 /*
+ * PD commands
+ *
+ * These commands are for PD MCU communication.
+ */
+
+/* EC to PD MCU exchange status command */
+#define EC_CMD_PD_EXCHANGE_STATUS 0x100
+
+/* Status of EC being sent to PD */
+struct ec_params_pd_status {
+        int8_t batt_soc; /* battery state of charge */
+} __packed;
+
+/* Status of PD being sent back to EC */
+struct ec_response_pd_status {
+        int8_t status;        /* PD MCU status */
+        uint32_t curr_lim_ma; /* input current limit */
+} __packed;
+
+/* Set USB type-C port role and muxes */
+#define EC_CMD_USB_PD_CONTROL 0x101
+
+enum usb_pd_control_role {
+        USB_PD_CTRL_ROLE_NO_CHANGE = 0,
+        USB_PD_CTRL_ROLE_TOGGLE_ON = 1, /* == AUTO */
+        USB_PD_CTRL_ROLE_TOGGLE_OFF = 2,
+        USB_PD_CTRL_ROLE_FORCE_SINK = 3,
+        USB_PD_CTRL_ROLE_FORCE_SOURCE = 4,
+};
+
+enum usb_pd_control_mux {
+        USB_PD_CTRL_MUX_NO_CHANGE = 0,
+        USB_PD_CTRL_MUX_NONE = 1,
+        USB_PD_CTRL_MUX_USB = 2,
+        USB_PD_CTRL_MUX_DP = 3,
+        USB_PD_CTRL_MUX_DOCK = 4,
+        USB_PD_CTRL_MUX_AUTO = 5,
+};
+
+struct ec_params_usb_pd_control {
+        uint8_t port;
+        uint8_t role;
+        uint8_t mux;
+} __packed;
+
+/*****************************************************************************/
+/*
+ * Passthru commands
+ *
+ * Some platforms have sub-processors chained to each other.  For example.
+ *
+ *     AP <--> EC <--> PD MCU
+ *
+ * The top 2 bits of the command number are used to indicate which device the
+ * command is intended for.  Device 0 is always the device receiving the
+ * command; other device mapping is board-specific.
+ *
+ * When a device receives a command to be passed to a sub-processor, it passes
+ * it on with the device number set back to 0.  This allows the sub-processor
+ * to remain blissfully unaware of whether the command originated on the next
+ * device up the chain, or was passed through from the AP.
+ *
+ * In the above example, if the AP wants to send command 0x0002 to the PD MCU,
+ *     AP sends command 0x4002 to the EC
+ *     EC sends command 0x0002 to the PD MCU
+ *     EC forwards PD MCU response back to the AP
+ */
+
+/* Offset and max command number for sub-device n */
+#define EC_CMD_PASSTHRU_OFFSET(n) (0x4000 * (n))
+#define EC_CMD_PASSTHRU_MAX(n) (EC_CMD_PASSTHRU_OFFSET(n) + 0x3fff)
+
+/*****************************************************************************/
+/*
  * Deprecated constants. These constants have been renamed for clarity. The
  * meaning and size has not changed. Programs that use the old names should
  * switch to the new names soon, as the old names may not be carried forward
diff --git a/include/linux/mfd/da9055/core.h b/include/linux/mfd/da9055/core.h
index 956afa445998..5dc743fd63a6 100644
--- a/include/linux/mfd/da9055/core.h
+++ b/include/linux/mfd/da9055/core.h
@@ -89,6 +89,6 @@ static inline int da9055_reg_update(struct da9055 *da9055, unsigned char reg,
 int da9055_device_init(struct da9055 *da9055);
 void da9055_device_exit(struct da9055 *da9055);
 
-extern struct regmap_config da9055_regmap_config;
+extern const struct regmap_config da9055_regmap_config;
 
 #endif /* __DA9055_CORE_H */
diff --git a/include/linux/mfd/da9063/pdata.h b/include/linux/mfd/da9063/pdata.h
index 95c8742215a7..612383bd80ae 100644
--- a/include/linux/mfd/da9063/pdata.h
+++ b/include/linux/mfd/da9063/pdata.h
@@ -103,6 +103,7 @@ struct da9063;
 struct da9063_pdata {
         int                             (*init)(struct da9063 *da9063);
         int                             irq_base;
+        bool                            key_power;
         unsigned                        flags;
         struct da9063_regulators_pdata  *regulators_pdata;
         struct led_platform_data        *leds_pdata;
diff --git a/include/linux/mfd/max77686.h b/include/linux/mfd/max77686.h
index bb995ab9a575..d4b72d519115 100644
--- a/include/linux/mfd/max77686.h
+++ b/include/linux/mfd/max77686.h
@@ -125,9 +125,4 @@ enum max77686_opmode {
         MAX77686_OPMODE_STANDBY,
 };
 
-struct max77686_opmode_data {
-        int id;
-        int mode;
-};
-
 #endif /* __LINUX_MFD_MAX77686_H */
diff --git a/include/linux/mfd/stmpe.h b/include/linux/mfd/stmpe.h
index c9d869027300..cb83883918a7 100644
--- a/include/linux/mfd/stmpe.h
+++ b/include/linux/mfd/stmpe.h
@@ -118,47 +118,6 @@ extern int stmpe_disable(struct stmpe *stmpe, unsigned int blocks);
 #define STMPE_GPIO_NOREQ_811_TOUCH      (0xf0)
 
 /**
- * struct stmpe_ts_platform_data - stmpe811 touch screen controller platform
- * data
- * @sample_time: ADC converstion time in number of clock.
- * (0 -> 36 clocks, 1 -> 44 clocks, 2 -> 56 clocks, 3 -> 64 clocks,
- * 4 -> 80 clocks, 5 -> 96 clocks, 6 -> 144 clocks),
- * recommended is 4.
- * @mod_12b: ADC Bit mode (0 -> 10bit ADC, 1 -> 12bit ADC)
- * @ref_sel: ADC reference source
- * (0 -> internal reference, 1 -> external reference)
- * @adc_freq: ADC Clock speed
- * (0 -> 1.625 MHz, 1 -> 3.25 MHz, 2 || 3 -> 6.5 MHz)
- * @ave_ctrl: Sample average control
- * (0 -> 1 sample, 1 -> 2 samples, 2 -> 4 samples, 3 -> 8 samples)
- * @touch_det_delay: Touch detect interrupt delay
- * (0 -> 10 us, 1 -> 50 us, 2 -> 100 us, 3 -> 500 us,
- * 4-> 1 ms, 5 -> 5 ms, 6 -> 10 ms, 7 -> 50 ms)
- * recommended is 3
- * @settling: Panel driver settling time
- * (0 -> 10 us, 1 -> 100 us, 2 -> 500 us, 3 -> 1 ms,
- * 4 -> 5 ms, 5 -> 10 ms, 6 for 50 ms, 7 -> 100 ms)
- * recommended is 2
- * @fraction_z: Length of the fractional part in z
- * (fraction_z ([0..7]) = Count of the fractional part)
- * recommended is 7
- * @i_drive: current limit value of the touchscreen drivers
- * (0 -> 20 mA typical 35 mA max, 1 -> 50 mA typical 80 mA max)
- *
- * */
-struct stmpe_ts_platform_data {
-       u8 sample_time;
-       u8 mod_12b;
-       u8 ref_sel;
-       u8 adc_freq;
-       u8 ave_ctrl;
-       u8 touch_det_delay;
-       u8 settling;
-       u8 fraction_z;
-       u8 i_drive;
-};
-
-/**
  * struct stmpe_platform_data - STMPE platform data
  * @id: device id to distinguish between multiple STMPEs on the same board
  * @blocks: bitmask of blocks to enable (use STMPE_BLOCK_*)
@@ -168,7 +127,6 @@ struct stmpe_ts_platform_data {
  * @irq_over_gpio: true if gpio is used to get irq
  * @irq_gpio: gpio number over which irq will be requested (significant only if
  *            irq_over_gpio is true)
- * @ts: touchscreen-specific platform data
  */
 struct stmpe_platform_data {
         int id;
@@ -178,8 +136,6 @@ struct stmpe_platform_data {
         bool irq_over_gpio;
         int irq_gpio;
         int autosleep_timeout;
-
-        struct stmpe_ts_platform_data *ts;
 };
 
 #endif
diff --git a/include/linux/mfd/syscon/atmel-mc.h b/include/linux/mfd/syscon/atmel-mc.h
new file mode 100644
index 000000000000..afd9b8f1e363
--- /dev/null
+++ b/include/linux/mfd/syscon/atmel-mc.h
@@ -0,0 +1,144 @@
+/*
+ * Copyright (C) 2005 Ivan Kokshaysky
+ * Copyright (C) SAN People
+ *
+ * Memory Controllers (MC, EBI, SMC, SDRAMC, BFC) - System peripherals
+ * registers.
+ * Based on AT91RM9200 datasheet revision E.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#ifndef _LINUX_MFD_SYSCON_ATMEL_MC_H_
+#define _LINUX_MFD_SYSCON_ATMEL_MC_H_
+
+/* Memory Controller */
+#define AT91_MC_RCR                     0x00
+#define AT91_MC_RCB                     BIT(0)
+
+#define AT91_MC_ASR                     0x04
+#define AT91_MC_UNADD                   BIT(0)
+#define AT91_MC_MISADD                  BIT(1)
+#define AT91_MC_ABTSZ                   GENMASK(9, 8)
+#define AT91_MC_ABTSZ_BYTE              (0 << 8)
+#define AT91_MC_ABTSZ_HALFWORD          (1 << 8)
+#define AT91_MC_ABTSZ_WORD              (2 << 8)
+#define AT91_MC_ABTTYP                  GENMASK(11, 10)
+#define AT91_MC_ABTTYP_DATAREAD         (0 << 10)
+#define AT91_MC_ABTTYP_DATAWRITE        (1 << 10)
+#define AT91_MC_ABTTYP_FETCH            (2 << 10)
+#define AT91_MC_MST(n)                  BIT(16 + (n))
+#define AT91_MC_SVMST(n)                BIT(24 + (n))
+
+#define AT91_MC_AASR                    0x08
+
+#define AT91_MC_MPR                     0x0c
+#define AT91_MPR_MSTP(n)                GENMASK(2 + ((x) * 4), ((x) * 4))
+
+/* External Bus Interface (EBI) registers */
+#define AT91_MC_EBI_CSA                 0x60
+#define AT91_MC_EBI_CS(n)               BIT(x)
+#define AT91_MC_EBI_NUM_CS              8
+
+#define AT91_MC_EBI_CFGR                0x64
+#define AT91_MC_EBI_DBPUC               BIT(0)
+
+/* Static Memory Controller (SMC) registers */
+#define AT91_MC_SMC_CSR(n)              (0x70 + ((n) * 4))
+#define AT91_MC_SMC_NWS                 GENMASK(6, 0)
+#define AT91_MC_SMC_NWS_(x)             ((x) << 0)
+#define AT91_MC_SMC_WSEN                BIT(7)
+#define AT91_MC_SMC_TDF                 GENMASK(11, 8)
+#define AT91_MC_SMC_TDF_(x)             ((x) << 8)
+#define AT91_MC_SMC_TDF_MAX             0xf
+#define AT91_MC_SMC_BAT                 BIT(12)
+#define AT91_MC_SMC_DBW                 GENMASK(14, 13)
+#define AT91_MC_SMC_DBW_16              (1 << 13)
+#define AT91_MC_SMC_DBW_8               (2 << 13)
+#define AT91_MC_SMC_DPR                 BIT(15)
+#define AT91_MC_SMC_ACSS                GENMASK(17, 16)
+#define AT91_MC_SMC_ACSS_(x)            ((x) << 16)
+#define AT91_MC_SMC_ACSS_MAX            3
+#define AT91_MC_SMC_RWSETUP             GENMASK(26, 24)
+#define AT91_MC_SMC_RWSETUP_(x)         ((x) << 24)
+#define AT91_MC_SMC_RWHOLD              GENMASK(30, 28)
+#define AT91_MC_SMC_RWHOLD_(x)          ((x) << 28)
+#define AT91_MC_SMC_RWHOLDSETUP_MAX     7
+
+/* SDRAM Controller registers */
+#define AT91_MC_SDRAMC_MR               0x90
+#define AT91_MC_SDRAMC_MODE             GENMASK(3, 0)
+#define AT91_MC_SDRAMC_MODE_NORMAL      (0 << 0)
+#define AT91_MC_SDRAMC_MODE_NOP         (1 << 0)
+#define AT91_MC_SDRAMC_MODE_PRECHARGE   (2 << 0)
+#define AT91_MC_SDRAMC_MODE_LMR         (3 << 0)
+#define AT91_MC_SDRAMC_MODE_REFRESH     (4 << 0)
+#define AT91_MC_SDRAMC_DBW_16           BIT(4)
+
+#define AT91_MC_SDRAMC_TR               0x94
+#define AT91_MC_SDRAMC_COUNT            GENMASK(11, 0)
+
+#define AT91_MC_SDRAMC_CR               0x98
+#define AT91_MC_SDRAMC_NC               GENMASK(1, 0)
+#define AT91_MC_SDRAMC_NC_8             (0 << 0)
+#define AT91_MC_SDRAMC_NC_9             (1 << 0)
+#define AT91_MC_SDRAMC_NC_10            (2 << 0)
+#define AT91_MC_SDRAMC_NC_11            (3 << 0)
+#define AT91_MC_SDRAMC_NR               GENMASK(3, 2)
+#define AT91_MC_SDRAMC_NR_11            (0 << 2)
+#define AT91_MC_SDRAMC_NR_12            (1 << 2)
+#define AT91_MC_SDRAMC_NR_13            (2 << 2)
+#define AT91_MC_SDRAMC_NB               BIT(4)
+#define AT91_MC_SDRAMC_NB_2             (0 << 4)
+#define AT91_MC_SDRAMC_NB_4             (1 << 4)
+#define AT91_MC_SDRAMC_CAS              GENMASK(6, 5)
+#define AT91_MC_SDRAMC_CAS_2            (2 << 5)
+#define AT91_MC_SDRAMC_TWR              GENMASK(10,  7)
+#define AT91_MC_SDRAMC_TRC              GENMASK(14, 11)
+#define AT91_MC_SDRAMC_TRP              GENMASK(18, 15)
+#define AT91_MC_SDRAMC_TRCD             GENMASK(22, 19)
+#define AT91_MC_SDRAMC_TRAS             GENMASK(26, 23)
+#define AT91_MC_SDRAMC_TXSR             GENMASK(30, 27)
+
+#define AT91_MC_SDRAMC_SRR              0x9c
+#define AT91_MC_SDRAMC_SRCB             BIT(0)
+
+#define AT91_MC_SDRAMC_LPR              0xa0
+#define AT91_MC_SDRAMC_LPCB             BIT(0)
+
+#define AT91_MC_SDRAMC_IER              0xa4
+#define AT91_MC_SDRAMC_IDR              0xa8
+#define AT91_MC_SDRAMC_IMR              0xac
+#define AT91_MC_SDRAMC_ISR              0xb0
+#define AT91_MC_SDRAMC_RES              BIT(0)
+
+/* Burst Flash Controller register */
+#define AT91_MC_BFC_MR                  0xc0
+#define AT91_MC_BFC_BFCOM               GENMASK(1, 0)
+#define AT91_MC_BFC_BFCOM_DISABLED      (0 << 0)
+#define AT91_MC_BFC_BFCOM_ASYNC         (1 << 0)
+#define AT91_MC_BFC_BFCOM_BURST         (2 << 0)
+#define AT91_MC_BFC_BFCC                GENMASK(3, 2)
+#define AT91_MC_BFC_BFCC_MCK            (1 << 2)
+#define AT91_MC_BFC_BFCC_DIV2           (2 << 2)
+#define AT91_MC_BFC_BFCC_DIV4           (3 << 2)
+#define AT91_MC_BFC_AVL                 GENMASK(7,  4)
+#define AT91_MC_BFC_PAGES               GENMASK(10, 8)
+#define AT91_MC_BFC_PAGES_NO_PAGE       (0 << 8)
+#define AT91_MC_BFC_PAGES_16            (1 << 8)
+#define AT91_MC_BFC_PAGES_32            (2 << 8)
+#define AT91_MC_BFC_PAGES_64            (3 << 8)
+#define AT91_MC_BFC_PAGES_128           (4 << 8)
+#define AT91_MC_BFC_PAGES_256           (5 << 8)
+#define AT91_MC_BFC_PAGES_512           (6 << 8)
+#define AT91_MC_BFC_PAGES_1024          (7 << 8)
+#define AT91_MC_BFC_OEL                 GENMASK(13, 12)
+#define AT91_MC_BFC_BAAEN               BIT(16)
+#define AT91_MC_BFC_BFOEH               BIT(17)
+#define AT91_MC_BFC_MUXEN               BIT(18)
+#define AT91_MC_BFC_RDYEN               BIT(19)
+
+#endif /* _LINUX_MFD_SYSCON_ATMEL_MC_H_ */
diff --git a/include/linux/mlx4/cmd.h b/include/linux/mlx4/cmd.h
index f62e7cf227c6..58391f2e0414 100644
--- a/include/linux/mlx4/cmd.h
+++ b/include/linux/mlx4/cmd.h
@@ -35,6 +35,8 @@
 
 #include <linux/dma-mapping.h>
 #include <linux/if_link.h>
+#include <linux/mlx4/device.h>
+#include <linux/netdevice.h>
 
 enum {
         /* initialization and general commands */
@@ -300,6 +302,10 @@ static inline int mlx4_cmd_imm(struct mlx4_dev *dev, u64 in_param, u64 *out_para
 struct mlx4_cmd_mailbox *mlx4_alloc_cmd_mailbox(struct mlx4_dev *dev);
 void mlx4_free_cmd_mailbox(struct mlx4_dev *dev, struct mlx4_cmd_mailbox *mailbox);
 
+int mlx4_get_counter_stats(struct mlx4_dev *dev, int counter_index,
+                           struct mlx4_counter *counter_stats, int reset);
+int mlx4_get_vf_stats(struct mlx4_dev *dev, int port, int vf_idx,
+                      struct ifla_vf_stats *vf_stats);
 u32 mlx4_comm_get_version(void);
 int mlx4_set_vf_mac(struct mlx4_dev *dev, int port, int vf, u64 mac);
 int mlx4_set_vf_vlan(struct mlx4_dev *dev, int port, int vf, u16 vlan, u8 qos);
diff --git a/include/linux/mlx4/device.h b/include/linux/mlx4/device.h
index 83e80ab94500..fd13c1ce3b4a 100644
--- a/include/linux/mlx4/device.h
+++ b/include/linux/mlx4/device.h
@@ -46,8 +46,9 @@
 
 #define MAX_MSIX_P_PORT         17
 #define MAX_MSIX                64
-#define MSIX_LEGACY_SZ          4
 #define MIN_MSIX_P_PORT         5
+#define MLX4_IS_LEGACY_EQ_MODE(dev_cap) ((dev_cap).num_comp_vectors < \
+                                         (dev_cap).num_ports * MIN_MSIX_P_PORT)
 
 #define MLX4_MAX_100M_UNITS_VAL         255     /*
                                                  * work around: can't set values
@@ -528,7 +529,6 @@ struct mlx4_caps {
         int                     num_eqs;
         int                     reserved_eqs;
         int                     num_comp_vectors;
-        int                     comp_pool;
         int                     num_mpts;
         int                     max_fmr_maps;
         int                     num_mtts;
@@ -771,6 +771,14 @@ union mlx4_ext_av {
         struct mlx4_eth_av      eth;
 };
 
+/* Counters should be saturate once they reach their maximum value */
+#define ASSIGN_32BIT_COUNTER(counter, value) do {       \
+        if ((value) > U32_MAX)                          \
+                counter = cpu_to_be32(U32_MAX);         \
+        else                                            \
+                counter = cpu_to_be32(value);           \
+} while (0)
+
 struct mlx4_counter {
         u8      reserved1[3];
         u8      counter_mode;
@@ -829,6 +837,12 @@ struct mlx4_dev {
         struct mlx4_vf_dev     *dev_vfs;
 };
 
+struct mlx4_clock_params {
+        u64 offset;
+        u8 bar;
+        u8 size;
+};
+
 struct mlx4_eqe {
         u8                      reserved1;
         u8                      type;
@@ -957,6 +971,7 @@ struct mlx4_mad_ifc {
                         ((dev)->caps.flags & MLX4_DEV_CAP_FLAG_IBOE))
 
 #define MLX4_INVALID_SLAVE_ID   0xFF
+#define MLX4_SINK_COUNTER_INDEX(dev)    (dev->caps.max_counters - 1)
 
 void handle_port_mgmt_change_event(struct work_struct *work);
 
@@ -1332,10 +1347,13 @@ void mlx4_fmr_unmap(struct mlx4_dev *dev, struct mlx4_fmr *fmr,
 int mlx4_fmr_free(struct mlx4_dev *dev, struct mlx4_fmr *fmr);
 int mlx4_SYNC_TPT(struct mlx4_dev *dev);
 int mlx4_test_interrupts(struct mlx4_dev *dev);
-int mlx4_assign_eq(struct mlx4_dev *dev, char *name, struct cpu_rmap *rmap,
-                   int *vector);
+u32 mlx4_get_eqs_per_port(struct mlx4_dev *dev, u8 port);
+bool mlx4_is_eq_vector_valid(struct mlx4_dev *dev, u8 port, int vector);
+struct cpu_rmap *mlx4_get_cpu_rmap(struct mlx4_dev *dev, int port);
+int mlx4_assign_eq(struct mlx4_dev *dev, u8 port, int *vector);
 void mlx4_release_eq(struct mlx4_dev *dev, int vec);
 
+int mlx4_is_eq_shared(struct mlx4_dev *dev, int vector);
 int mlx4_eq_get_irq(struct mlx4_dev *dev, int vec);
 
 int mlx4_get_phys_port_id(struct mlx4_dev *dev);
@@ -1344,6 +1362,7 @@ int mlx4_wol_write(struct mlx4_dev *dev, u64 config, int port);
 
 int mlx4_counter_alloc(struct mlx4_dev *dev, u32 *idx);
 void mlx4_counter_free(struct mlx4_dev *dev, u32 idx);
+int mlx4_get_default_counter_index(struct mlx4_dev *dev, int port);
 
 void mlx4_set_admin_guid(struct mlx4_dev *dev, __be64 guid, int entry,
                          int port);
@@ -1485,4 +1504,7 @@ int mlx4_ACCESS_PTYS_REG(struct mlx4_dev *dev,
                          enum mlx4_access_reg_method method,
                          struct mlx4_ptys_reg *ptys_reg);
 
+int mlx4_get_internal_clock_params(struct mlx4_dev *dev,
+                                   struct mlx4_clock_params *params);
+
 #endif /* MLX4_DEVICE_H */
diff --git a/include/linux/mlx5/cq.h b/include/linux/mlx5/cq.h
index 2695ced222df..abc4767695e4 100644
--- a/include/linux/mlx5/cq.h
+++ b/include/linux/mlx5/cq.h
@@ -169,6 +169,9 @@ int mlx5_core_query_cq(struct mlx5_core_dev *dev, struct mlx5_core_cq *cq,
                        struct mlx5_query_cq_mbox_out *out);
 int mlx5_core_modify_cq(struct mlx5_core_dev *dev, struct mlx5_core_cq *cq,
                         struct mlx5_modify_cq_mbox_in *in, int in_sz);
+int mlx5_core_modify_cq_moderation(struct mlx5_core_dev *dev,
+                                   struct mlx5_core_cq *cq, u16 cq_period,
+                                   u16 cq_max_count);
 int mlx5_debug_cq_add(struct mlx5_core_dev *dev, struct mlx5_core_cq *cq);
 void mlx5_debug_cq_remove(struct mlx5_core_dev *dev, struct mlx5_core_cq *cq);
 
diff --git a/include/linux/mlx5/device.h b/include/linux/mlx5/device.h
index abf65c790421..b943cd9e2097 100644
--- a/include/linux/mlx5/device.h
+++ b/include/linux/mlx5/device.h
@@ -35,6 +35,7 @@
 
 #include <linux/types.h>
 #include <rdma/ib_verbs.h>
+#include <linux/mlx5/mlx5_ifc.h>
 
 #if defined(__LITTLE_ENDIAN)
 #define MLX5_SET_HOST_ENDIANNESS        0
@@ -58,6 +59,8 @@
 #define MLX5_FLD_SZ_BYTES(typ, fld) (__mlx5_bit_sz(typ, fld) / 8)
 #define MLX5_ST_SZ_BYTES(typ) (sizeof(struct mlx5_ifc_##typ##_bits) / 8)
 #define MLX5_ST_SZ_DW(typ) (sizeof(struct mlx5_ifc_##typ##_bits) / 32)
+#define MLX5_UN_SZ_BYTES(typ) (sizeof(union mlx5_ifc_##typ##_bits) / 8)
+#define MLX5_UN_SZ_DW(typ) (sizeof(union mlx5_ifc_##typ##_bits) / 32)
 #define MLX5_BYTE_OFF(typ, fld) (__mlx5_bit_off(typ, fld) / 8)
 #define MLX5_ADDR_OF(typ, p, fld) ((char *)(p) + MLX5_BYTE_OFF(typ, fld))
 
@@ -70,6 +73,14 @@
                      << __mlx5_dw_bit_off(typ, fld))); \
 } while (0)
 
+#define MLX5_SET_TO_ONES(typ, p, fld) do { \
+        BUILD_BUG_ON(__mlx5_st_sz_bits(typ) % 32);             \
+        *((__be32 *)(p) + __mlx5_dw_off(typ, fld)) = \
+        cpu_to_be32((be32_to_cpu(*((__be32 *)(p) + __mlx5_dw_off(typ, fld))) & \
+                     (~__mlx5_dw_mask(typ, fld))) | ((__mlx5_mask(typ, fld)) \
+                     << __mlx5_dw_bit_off(typ, fld))); \
+} while (0)
+
 #define MLX5_GET(typ, p, fld) ((be32_to_cpu(*((__be32 *)(p) +\
 __mlx5_dw_off(typ, fld))) >> __mlx5_dw_bit_off(typ, fld)) & \
 __mlx5_mask(typ, fld))
@@ -88,6 +99,12 @@ __mlx5_mask(typ, fld))
 
 #define MLX5_GET64(typ, p, fld) be64_to_cpu(*((__be64 *)(p) + __mlx5_64_off(typ, fld)))
 
+#define MLX5_GET64_PR(typ, p, fld) ({ \
+        u64 ___t = MLX5_GET64(typ, p, fld); \
+        pr_debug(#fld " = 0x%llx\n", ___t); \
+        ___t; \
+})
+
 enum {
         MLX5_MAX_COMMANDS               = 32,
         MLX5_CMD_DATA_BLOCK_SIZE        = 512,
@@ -115,6 +132,10 @@ enum {
 };
 
 enum {
+        MLX5_HW_START_PADDING = MLX5_INLINE_SEG,
+};
+
+enum {
         MLX5_MIN_PKEY_TABLE_SIZE = 128,
         MLX5_MAX_LOG_PKEY_TABLE  = 5,
 };
@@ -264,6 +285,7 @@ enum {
         MLX5_OPCODE_RDMA_WRITE_IMM      = 0x09,
         MLX5_OPCODE_SEND                = 0x0a,
         MLX5_OPCODE_SEND_IMM            = 0x0b,
+        MLX5_OPCODE_LSO                 = 0x0e,
         MLX5_OPCODE_RDMA_READ           = 0x10,
         MLX5_OPCODE_ATOMIC_CS           = 0x11,
         MLX5_OPCODE_ATOMIC_FA           = 0x12,
@@ -312,13 +334,6 @@ enum {
         MLX5_CAP_OFF_CMDIF_CSUM         = 46,
 };
 
-enum {
-        HCA_CAP_OPMOD_GET_MAX   = 0,
-        HCA_CAP_OPMOD_GET_CUR   = 1,
-        HCA_CAP_OPMOD_GET_ODP_MAX = 4,
-        HCA_CAP_OPMOD_GET_ODP_CUR = 5
-};
-
 struct mlx5_inbox_hdr {
         __be16          opcode;
         u8              rsvd[4];
@@ -541,6 +556,10 @@ struct mlx5_cmd_prot_block {
         u8              sig;
 };
 
+enum {
+        MLX5_CQE_SYND_FLUSHED_IN_ERROR = 5,
+};
+
 struct mlx5_err_cqe {
         u8      rsvd0[32];
         __be32  srqn;
@@ -554,13 +573,22 @@ struct mlx5_err_cqe {
 };
 
 struct mlx5_cqe64 {
-        u8              rsvd0[17];
+        u8              rsvd0[4];
+        u8              lro_tcppsh_abort_dupack;
+        u8              lro_min_ttl;
+        __be16          lro_tcp_win;
+        __be32          lro_ack_seq_num;
+        __be32          rss_hash_result;
+        u8              rss_hash_type;
         u8              ml_path;
-        u8              rsvd20[4];
+        u8              rsvd20[2];
+        __be16          check_sum;
         __be16          slid;
         __be32          flags_rqpn;
-        u8              rsvd28[4];
-        __be32          srqn;
+        u8              hds_ip_ext;
+        u8              l4_hdr_type_etc;
+        __be16          vlan_info;
+        __be32          srqn; /* [31:24]: lro_num_seg, [23:0]: srqn */
         __be32          imm_inval_pkey;
         u8              rsvd40[4];
         __be32          byte_cnt;
@@ -571,6 +599,40 @@ struct mlx5_cqe64 {
         u8              op_own;
 };
 
+static inline int get_cqe_lro_tcppsh(struct mlx5_cqe64 *cqe)
+{
+        return (cqe->lro_tcppsh_abort_dupack >> 6) & 1;
+}
+
+static inline u8 get_cqe_l4_hdr_type(struct mlx5_cqe64 *cqe)
+{
+        return (cqe->l4_hdr_type_etc >> 4) & 0x7;
+}
+
+static inline int cqe_has_vlan(struct mlx5_cqe64 *cqe)
+{
+        return !!(cqe->l4_hdr_type_etc & 0x1);
+}
+
+enum {
+        CQE_L4_HDR_TYPE_NONE                    = 0x0,
+        CQE_L4_HDR_TYPE_TCP_NO_ACK              = 0x1,
+        CQE_L4_HDR_TYPE_UDP                     = 0x2,
+        CQE_L4_HDR_TYPE_TCP_ACK_NO_DATA         = 0x3,
+        CQE_L4_HDR_TYPE_TCP_ACK_AND_DATA        = 0x4,
+};
+
+enum {
+        CQE_RSS_HTYPE_IP        = 0x3 << 6,
+        CQE_RSS_HTYPE_L4        = 0x3 << 2,
+};
+
+enum {
+        CQE_L2_OK       = 1 << 0,
+        CQE_L3_OK       = 1 << 1,
+        CQE_L4_OK       = 1 << 2,
+};
+
 struct mlx5_sig_err_cqe {
         u8              rsvd0[16];
         __be32          expected_trans_sig;
@@ -996,4 +1058,135 @@ struct mlx5_destroy_psv_out {
         u8                      rsvd[8];
 };
 
+#define MLX5_CMD_OP_MAX 0x920
+
+enum {
+        VPORT_STATE_DOWN                = 0x0,
+        VPORT_STATE_UP                  = 0x1,
+};
+
+enum {
+        MLX5_L3_PROT_TYPE_IPV4          = 0,
+        MLX5_L3_PROT_TYPE_IPV6          = 1,
+};
+
+enum {
+        MLX5_L4_PROT_TYPE_TCP           = 0,
+        MLX5_L4_PROT_TYPE_UDP           = 1,
+};
+
+enum {
+        MLX5_HASH_FIELD_SEL_SRC_IP      = 1 << 0,
+        MLX5_HASH_FIELD_SEL_DST_IP      = 1 << 1,
+        MLX5_HASH_FIELD_SEL_L4_SPORT    = 1 << 2,
+        MLX5_HASH_FIELD_SEL_L4_DPORT    = 1 << 3,
+        MLX5_HASH_FIELD_SEL_IPSEC_SPI   = 1 << 4,
+};
+
+enum {
+        MLX5_MATCH_OUTER_HEADERS        = 1 << 0,
+        MLX5_MATCH_MISC_PARAMETERS      = 1 << 1,
+        MLX5_MATCH_INNER_HEADERS        = 1 << 2,
+
+};
+
+enum {
+        MLX5_FLOW_TABLE_TYPE_NIC_RCV    = 0,
+        MLX5_FLOW_TABLE_TYPE_ESWITCH    = 4,
+};
+
+enum {
+        MLX5_FLOW_CONTEXT_DEST_TYPE_VPORT       = 0,
+        MLX5_FLOW_CONTEXT_DEST_TYPE_FLOW_TABLE  = 1,
+        MLX5_FLOW_CONTEXT_DEST_TYPE_TIR         = 2,
+};
+
+enum {
+        MLX5_RQC_RQ_TYPE_MEMORY_RQ_INLINE = 0x0,
+        MLX5_RQC_RQ_TYPE_MEMORY_RQ_RPM    = 0x1,
+};
+
+/* MLX5 DEV CAPs */
+
+/* TODO: EAT.ME */
+enum mlx5_cap_mode {
+        HCA_CAP_OPMOD_GET_MAX   = 0,
+        HCA_CAP_OPMOD_GET_CUR   = 1,
+};
+
+enum mlx5_cap_type {
+        MLX5_CAP_GENERAL = 0,
+        MLX5_CAP_ETHERNET_OFFLOADS,
+        MLX5_CAP_ODP,
+        MLX5_CAP_ATOMIC,
+        MLX5_CAP_ROCE,
+        MLX5_CAP_IPOIB_OFFLOADS,
+        MLX5_CAP_EOIB_OFFLOADS,
+        MLX5_CAP_FLOW_TABLE,
+        /* NUM OF CAP Types */
+        MLX5_CAP_NUM
+};
+
+/* GET Dev Caps macros */
+#define MLX5_CAP_GEN(mdev, cap) \
+        MLX5_GET(cmd_hca_cap, mdev->hca_caps_cur[MLX5_CAP_GENERAL], cap)
+
+#define MLX5_CAP_GEN_MAX(mdev, cap) \
+        MLX5_GET(cmd_hca_cap, mdev->hca_caps_max[MLX5_CAP_GENERAL], cap)
+
+#define MLX5_CAP_ETH(mdev, cap) \
+        MLX5_GET(per_protocol_networking_offload_caps,\
+                 mdev->hca_caps_cur[MLX5_CAP_ETHERNET_OFFLOADS], cap)
+
+#define MLX5_CAP_ETH_MAX(mdev, cap) \
+        MLX5_GET(per_protocol_networking_offload_caps,\
+                 mdev->hca_caps_max[MLX5_CAP_ETHERNET_OFFLOADS], cap)
+
+#define MLX5_CAP_ROCE(mdev, cap) \
+        MLX5_GET(roce_cap, mdev->hca_caps_cur[MLX5_CAP_ROCE], cap)
+
+#define MLX5_CAP_ROCE_MAX(mdev, cap) \
+        MLX5_GET(roce_cap, mdev->hca_caps_max[MLX5_CAP_ROCE], cap)
+
+#define MLX5_CAP_ATOMIC(mdev, cap) \
+        MLX5_GET(atomic_caps, mdev->hca_caps_cur[MLX5_CAP_ATOMIC], cap)
+
+#define MLX5_CAP_ATOMIC_MAX(mdev, cap) \
+        MLX5_GET(atomic_caps, mdev->hca_caps_max[MLX5_CAP_ATOMIC], cap)
+
+#define MLX5_CAP_FLOWTABLE(mdev, cap) \
+        MLX5_GET(flow_table_nic_cap, mdev->hca_caps_cur[MLX5_CAP_FLOW_TABLE], cap)
+
+#define MLX5_CAP_FLOWTABLE_MAX(mdev, cap) \
+        MLX5_GET(flow_table_nic_cap, mdev->hca_caps_max[MLX5_CAP_FLOW_TABLE], cap)
+
+#define MLX5_CAP_ODP(mdev, cap)\
+        MLX5_GET(odp_cap, mdev->hca_caps_cur[MLX5_CAP_ODP], cap)
+
+enum {
+        MLX5_CMD_STAT_OK                        = 0x0,
+        MLX5_CMD_STAT_INT_ERR                   = 0x1,
+        MLX5_CMD_STAT_BAD_OP_ERR                = 0x2,
+        MLX5_CMD_STAT_BAD_PARAM_ERR             = 0x3,
+        MLX5_CMD_STAT_BAD_SYS_STATE_ERR         = 0x4,
+        MLX5_CMD_STAT_BAD_RES_ERR               = 0x5,
+        MLX5_CMD_STAT_RES_BUSY                  = 0x6,
+        MLX5_CMD_STAT_LIM_ERR                   = 0x8,
+        MLX5_CMD_STAT_BAD_RES_STATE_ERR         = 0x9,
+        MLX5_CMD_STAT_IX_ERR                    = 0xa,
+        MLX5_CMD_STAT_NO_RES_ERR                = 0xf,
+        MLX5_CMD_STAT_BAD_INP_LEN_ERR           = 0x50,
+        MLX5_CMD_STAT_BAD_OUTP_LEN_ERR          = 0x51,
+        MLX5_CMD_STAT_BAD_QP_STATE_ERR          = 0x10,
+        MLX5_CMD_STAT_BAD_PKT_ERR               = 0x30,
+        MLX5_CMD_STAT_BAD_SIZE_OUTS_CQES_ERR    = 0x40,
+};
+
+static inline u16 mlx5_to_sw_pkey_sz(int pkey_sz)
+{
+        if (pkey_sz > MLX5_MAX_LOG_PKEY_TABLE)
+                return 0;
+        return MLX5_MIN_PKEY_TABLE_SIZE << pkey_sz;
+}
+
 #endif /* MLX5_DEVICE_H */
diff --git a/include/linux/mlx5/driver.h b/include/linux/mlx5/driver.h
index 9a90e7523dc2..5722d88c2429 100644
--- a/include/linux/mlx5/driver.h
+++ b/include/linux/mlx5/driver.h
@@ -44,7 +44,6 @@
 
 #include <linux/mlx5/device.h>
 #include <linux/mlx5/doorbell.h>
-#include <linux/mlx5/mlx5_ifc.h>
 
 enum {
         MLX5_BOARD_ID_LEN = 64,
@@ -85,7 +84,7 @@ enum {
 };
 
 enum {
-        MLX5_MAX_EQ_NAME        = 32
+        MLX5_MAX_IRQ_NAME       = 32
 };
 
 enum {
@@ -108,6 +107,7 @@ enum {
         MLX5_REG_PUDE            = 0x5009,
         MLX5_REG_PMPE            = 0x5010,
         MLX5_REG_PELC            = 0x500e,
+        MLX5_REG_PVLC            = 0x500f,
         MLX5_REG_PMLP            = 0, /* TBD */
         MLX5_REG_NODE_DESC       = 0x6001,
         MLX5_REG_HOST_ENDIANNESS = 0x7004,
@@ -150,6 +150,11 @@ enum mlx5_dev_event {
         MLX5_DEV_EVENT_CLIENT_REREG,
 };
 
+enum mlx5_port_status {
+        MLX5_PORT_UP        = 1 << 1,
+        MLX5_PORT_DOWN      = 1 << 2,
+};
+
 struct mlx5_uuar_info {
         struct mlx5_uar        *uars;
         int                     num_uars;
@@ -269,56 +274,7 @@ struct mlx5_cmd {
 struct mlx5_port_caps {
         int     gid_table_len;
         int     pkey_table_len;
-};
-
-struct mlx5_general_caps {
-        u8      log_max_eq;
-        u8      log_max_cq;
-        u8      log_max_qp;
-        u8      log_max_mkey;
-        u8      log_max_pd;
-        u8      log_max_srq;
-        u8      log_max_strq;
-        u8      log_max_mrw_sz;
-        u8      log_max_bsf_list_size;
-        u8      log_max_klm_list_size;
-        u32     max_cqes;
-        int     max_wqes;
-        u32     max_eqes;
-        u32     max_indirection;
-        int     max_sq_desc_sz;
-        int     max_rq_desc_sz;
-        int     max_dc_sq_desc_sz;
-        u64     flags;
-        u16     stat_rate_support;
-        int     log_max_msg;
-        int     num_ports;
-        u8      log_max_ra_res_qp;
-        u8      log_max_ra_req_qp;
-        int     max_srq_wqes;
-        int     bf_reg_size;
-        int     bf_regs_per_page;
-        struct mlx5_port_caps   port[MLX5_MAX_PORTS];
-        u8                      ext_port_cap[MLX5_MAX_PORTS];
-        int     max_vf;
-        u32     reserved_lkey;
-        u8      local_ca_ack_delay;
-        u8      log_max_mcg;
-        u32     max_qp_mcg;
-        int     min_page_sz;
-        int     pd_cap;
-        u32     max_qp_counters;
-        u32     pkey_table_size;
-        u8      log_max_ra_req_dc;
-        u8      log_max_ra_res_dc;
-        u32     uar_sz;
-        u8      min_log_pg_sz;
-        u8      log_max_xrcd;
-        u16     log_uar_page_sz;
-};
-
-struct mlx5_caps {
-        struct mlx5_general_caps gen;
+        u8      ext_port_cap;
 };
 
 struct mlx5_cmd_mailbox {
@@ -334,8 +290,6 @@ struct mlx5_buf_list {
 
 struct mlx5_buf {
         struct mlx5_buf_list    direct;
-        struct mlx5_buf_list   *page_list;
-        int                     nbufs;
         int                     npages;
         int                     size;
         u8                      page_shift;
@@ -351,7 +305,6 @@ struct mlx5_eq {
         u8                      eqn;
         int                     nent;
         u64                     mask;
-        char                    name[MLX5_MAX_EQ_NAME];
         struct list_head        list;
         int                     index;
         struct mlx5_rsc_debug   *dbg;
@@ -387,6 +340,8 @@ struct mlx5_core_mr {
 
 enum mlx5_res_type {
         MLX5_RES_QP,
+        MLX5_RES_SRQ,
+        MLX5_RES_XSRQ,
 };
 
 struct mlx5_core_rsc_common {
@@ -396,6 +351,7 @@ struct mlx5_core_rsc_common {
 };
 
 struct mlx5_core_srq {
+        struct mlx5_core_rsc_common     common; /* must be first */
         u32             srqn;
         int             max;
         int             max_gs;
@@ -414,7 +370,6 @@ struct mlx5_eq_table {
         struct mlx5_eq          pages_eq;
         struct mlx5_eq          async_eq;
         struct mlx5_eq          cmd_eq;
-        struct msix_entry       *msix_arr;
         int                     num_comp_vectors;
         /* protect EQs list
          */
@@ -467,9 +422,16 @@ struct mlx5_mr_table {
         struct radix_tree_root  tree;
 };
 
+struct mlx5_irq_info {
+        cpumask_var_t mask;
+        char name[MLX5_MAX_IRQ_NAME];
+};
+
 struct mlx5_priv {
         char                    name[MLX5_MAX_NAME_LEN];
         struct mlx5_eq_table    eq_table;
+        struct msix_entry       *msix_arr;
+        struct mlx5_irq_info    *irq_info;
         struct mlx5_uuar_info   uuari;
         MLX5_DECLARE_DOORBELL_LOCK(cq_uar_lock);
 
@@ -520,7 +482,9 @@ struct mlx5_core_dev {
         u8                      rev_id;
         char                    board_id[MLX5_BOARD_ID_LEN];
         struct mlx5_cmd         cmd;
-        struct mlx5_caps        caps;
+        struct mlx5_port_caps   port_caps[MLX5_MAX_PORTS];
+        u32 hca_caps_cur[MLX5_CAP_NUM][MLX5_UN_SZ_DW(hca_cap_union)];
+        u32 hca_caps_max[MLX5_CAP_NUM][MLX5_UN_SZ_DW(hca_cap_union)];
         phys_addr_t             iseg_base;
         struct mlx5_init_seg __iomem *iseg;
         void                    (*event) (struct mlx5_core_dev *dev,
@@ -529,6 +493,7 @@ struct mlx5_core_dev {
         struct mlx5_priv        priv;
         struct mlx5_profile     *profile;
         atomic_t                num_qps;
+        u32                     issi;
 };
 
 struct mlx5_db {
@@ -549,6 +514,11 @@ enum {
         MLX5_COMP_EQ_SIZE = 1024,
 };
 
+enum {
+        MLX5_PTYS_IB = 1 << 0,
+        MLX5_PTYS_EN = 1 << 2,
+};
+
 struct mlx5_db_pgdir {
         struct list_head        list;
         DECLARE_BITMAP(bitmap, MLX5_DB_PER_PAGE);
@@ -584,13 +554,44 @@ struct mlx5_pas {
         u8      log_sz;
 };
 
+enum port_state_policy {
+        MLX5_AAA_000
+};
+
+enum phy_port_state {
+        MLX5_AAA_111
+};
+
+struct mlx5_hca_vport_context {
+        u32                     field_select;
+        bool                    sm_virt_aware;
+        bool                    has_smi;
+        bool                    has_raw;
+        enum port_state_policy  policy;
+        enum phy_port_state     phys_state;
+        enum ib_port_state      vport_state;
+        u8                      port_physical_state;
+        u64                     sys_image_guid;
+        u64                     port_guid;
+        u64                     node_guid;
+        u32                     cap_mask1;
+        u32                     cap_mask1_perm;
+        u32                     cap_mask2;
+        u32                     cap_mask2_perm;
+        u16                     lid;
+        u8                      init_type_reply; /* bitmask: see ib spec 14.2.5.6 InitTypeReply */
+        u8                      lmc;
+        u8                      subnet_timeout;
+        u16                     sm_lid;
+        u8                      sm_sl;
+        u16                     qkey_violation_counter;
+        u16                     pkey_violation_counter;
+        bool                    grh_required;
+};
+
 static inline void *mlx5_buf_offset(struct mlx5_buf *buf, int offset)
 {
-        if (likely(BITS_PER_LONG == 64 || buf->nbufs == 1))
                 return buf->direct.buf + offset;
-        else
-                return buf->page_list[offset >> PAGE_SHIFT].buf +
-                        (offset & (PAGE_SIZE - 1));
 }
 
 extern struct workqueue_struct *mlx5_core_wq;
@@ -654,8 +655,8 @@ void mlx5_cmd_use_events(struct mlx5_core_dev *dev);
 void mlx5_cmd_use_polling(struct mlx5_core_dev *dev);
 int mlx5_cmd_status_to_err(struct mlx5_outbox_hdr *hdr);
 int mlx5_cmd_status_to_err_v2(void *ptr);
-int mlx5_core_get_caps(struct mlx5_core_dev *dev, struct mlx5_caps *caps,
-                       u16 opmod);
+int mlx5_core_get_caps(struct mlx5_core_dev *dev, enum mlx5_cap_type cap_type,
+                       enum mlx5_cap_mode cap_mode);
 int mlx5_cmd_exec(struct mlx5_core_dev *dev, void *in, int in_size, void *out,
                   int out_size);
 int mlx5_cmd_exec_cb(struct mlx5_core_dev *dev, void *in, int in_size,
@@ -665,19 +666,21 @@ int mlx5_cmd_alloc_uar(struct mlx5_core_dev *dev, u32 *uarn);
 int mlx5_cmd_free_uar(struct mlx5_core_dev *dev, u32 uarn);
 int mlx5_alloc_uuars(struct mlx5_core_dev *dev, struct mlx5_uuar_info *uuari);
 int mlx5_free_uuars(struct mlx5_core_dev *dev, struct mlx5_uuar_info *uuari);
+int mlx5_alloc_map_uar(struct mlx5_core_dev *mdev, struct mlx5_uar *uar);
+void mlx5_unmap_free_uar(struct mlx5_core_dev *mdev, struct mlx5_uar *uar);
 void mlx5_health_cleanup(void);
 void  __init mlx5_health_init(void);
 void mlx5_start_health_poll(struct mlx5_core_dev *dev);
 void mlx5_stop_health_poll(struct mlx5_core_dev *dev);
-int mlx5_buf_alloc(struct mlx5_core_dev *dev, int size, int max_direct,
-                   struct mlx5_buf *buf);
+int mlx5_buf_alloc(struct mlx5_core_dev *dev, int size, struct mlx5_buf *buf);
 void mlx5_buf_free(struct mlx5_core_dev *dev, struct mlx5_buf *buf);
 struct mlx5_cmd_mailbox *mlx5_alloc_cmd_mailbox_chain(struct mlx5_core_dev *dev,
                                                       gfp_t flags, int npages);
 void mlx5_free_cmd_mailbox_chain(struct mlx5_core_dev *dev,
                                  struct mlx5_cmd_mailbox *head);
 int mlx5_core_create_srq(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq,
-                         struct mlx5_create_srq_mbox_in *in, int inlen);
+                         struct mlx5_create_srq_mbox_in *in, int inlen,
+                         int is_xrc);
 int mlx5_core_destroy_srq(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq);
 int mlx5_core_query_srq(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq,
                         struct mlx5_query_srq_mbox_out *out);
@@ -696,7 +699,7 @@ int mlx5_core_dump_fill_mkey(struct mlx5_core_dev *dev, struct mlx5_core_mr *mr,
                              u32 *mkey);
 int mlx5_core_alloc_pd(struct mlx5_core_dev *dev, u32 *pdn);
 int mlx5_core_dealloc_pd(struct mlx5_core_dev *dev, u32 pdn);
-int mlx5_core_mad_ifc(struct mlx5_core_dev *dev, void *inb, void *outb,
+int mlx5_core_mad_ifc(struct mlx5_core_dev *dev, const void *inb, void *outb,
                       u16 opmod, u8 port);
 void mlx5_pagealloc_init(struct mlx5_core_dev *dev);
 void mlx5_pagealloc_cleanup(struct mlx5_core_dev *dev);
@@ -734,7 +737,32 @@ void mlx5_qp_debugfs_cleanup(struct mlx5_core_dev *dev);
 int mlx5_core_access_reg(struct mlx5_core_dev *dev, void *data_in,
                          int size_in, void *data_out, int size_out,
                          u16 reg_num, int arg, int write);
+
 int mlx5_set_port_caps(struct mlx5_core_dev *dev, u8 port_num, u32 caps);
+int mlx5_query_port_ptys(struct mlx5_core_dev *dev, u32 *ptys,
+                         int ptys_size, int proto_mask, u8 local_port);
+int mlx5_query_port_proto_cap(struct mlx5_core_dev *dev,
+                              u32 *proto_cap, int proto_mask);
+int mlx5_query_port_proto_admin(struct mlx5_core_dev *dev,
+                                u32 *proto_admin, int proto_mask);
+int mlx5_query_port_link_width_oper(struct mlx5_core_dev *dev,
+                                    u8 *link_width_oper, u8 local_port);
+int mlx5_query_port_proto_oper(struct mlx5_core_dev *dev,
+                               u8 *proto_oper, int proto_mask,
+                               u8 local_port);
+int mlx5_set_port_proto(struct mlx5_core_dev *dev, u32 proto_admin,
+                        int proto_mask);
+int mlx5_set_port_status(struct mlx5_core_dev *dev,
+                         enum mlx5_port_status status);
+int mlx5_query_port_status(struct mlx5_core_dev *dev, u8 *status);
+
+int mlx5_set_port_mtu(struct mlx5_core_dev *dev, int mtu, u8 port);
+void mlx5_query_port_max_mtu(struct mlx5_core_dev *dev, int *max_mtu, u8 port);
+void mlx5_query_port_oper_mtu(struct mlx5_core_dev *dev, int *oper_mtu,
+                              u8 port);
+
+int mlx5_query_port_vl_hw_cap(struct mlx5_core_dev *dev,
+                              u8 *vl_hw_cap, u8 local_port);
 
 int mlx5_debug_eq_add(struct mlx5_core_dev *dev, struct mlx5_eq *eq);
 void mlx5_debug_eq_remove(struct mlx5_core_dev *dev, struct mlx5_eq *eq);
@@ -799,6 +827,7 @@ struct mlx5_interface {
 void *mlx5_get_protocol_dev(struct mlx5_core_dev *mdev, int protocol);
 int mlx5_register_interface(struct mlx5_interface *intf);
 void mlx5_unregister_interface(struct mlx5_interface *intf);
+int mlx5_core_query_vendor_id(struct mlx5_core_dev *mdev, u32 *vendor_id);
 
 struct mlx5_profile {
         u64     mask;
@@ -809,4 +838,14 @@ struct mlx5_profile {
         } mr_cache[MAX_MR_CACHE_ENTRIES];
 };
 
+static inline int mlx5_get_gid_table_len(u16 param)
+{
+        if (param > 4) {
+                pr_warn("gid table length is zero\n");
+                return 0;
+        }
+
+        return 8 * (1 << param);
+}
+
 #endif /* MLX5_DRIVER_H */
diff --git a/include/linux/mlx5/flow_table.h b/include/linux/mlx5/flow_table.h
new file mode 100644
index 000000000000..5f922c6d4fc2
--- /dev/null
+++ b/include/linux/mlx5/flow_table.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2013-2015, Mellanox Technologies, Ltd.  All rights reserved.
+ *
+ * This software is available to you under a choice of one of two
+ * licenses.  You may choose to be licensed under the terms of the GNU
+ * General Public License (GPL) Version 2, available from the file
+ * COPYING in the main directory of this source tree, or the
+ * OpenIB.org BSD license below:
+ *
+ *     Redistribution and use in source and binary forms, with or
+ *     without modification, are permitted provided that the following
+ *     conditions are met:
+ *
+ *      - Redistributions of source code must retain the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer.
+ *
+ *      - Redistributions in binary form must reproduce the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ * 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. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef MLX5_FLOW_TABLE_H
+#define MLX5_FLOW_TABLE_H
+
+#include <linux/mlx5/driver.h>
+
+struct mlx5_flow_table_group {
+        u8      log_sz;
+        u8      match_criteria_enable;
+        u32     match_criteria[MLX5_ST_SZ_DW(fte_match_param)];
+};
+
+void *mlx5_create_flow_table(struct mlx5_core_dev *dev, u8 level, u8 table_type,
+                             u16 num_groups,
+                             struct mlx5_flow_table_group *group);
+void mlx5_destroy_flow_table(void *flow_table);
+int mlx5_add_flow_table_entry(void *flow_table, u8 match_criteria_enable,
+                              void *match_criteria, void *flow_context,
+                              u32 *flow_index);
+void mlx5_del_flow_table_entry(void *flow_table, u32 flow_index);
+u32 mlx5_get_flow_table_id(void *flow_table);
+
+#endif /* MLX5_FLOW_TABLE_H */
diff --git a/include/linux/mlx5/mlx5_ifc.h b/include/linux/mlx5/mlx5_ifc.h
index cb3ad17edd1f..6d2f6fee041c 100644
--- a/include/linux/mlx5/mlx5_ifc.h
+++ b/include/linux/mlx5/mlx5_ifc.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013-2015, Mellanox Technologies. All rights reserved.
+ * Copyright (c) 2013-2015, Mellanox Technologies, Ltd.  All rights reserved.
  *
  * This software is available to you under a choice of one of two
  * licenses.  You may choose to be licensed under the terms of the GNU
@@ -28,12 +28,45 @@
  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
- */
-
+*/
 #ifndef MLX5_IFC_H
 #define MLX5_IFC_H
 
 enum {
+        MLX5_EVENT_TYPE_CODING_COMPLETION_EVENTS                   = 0x0,
+        MLX5_EVENT_TYPE_CODING_PATH_MIGRATED_SUCCEEDED             = 0x1,
+        MLX5_EVENT_TYPE_CODING_COMMUNICATION_ESTABLISHED           = 0x2,
+        MLX5_EVENT_TYPE_CODING_SEND_QUEUE_DRAINED                  = 0x3,
+        MLX5_EVENT_TYPE_CODING_LAST_WQE_REACHED                    = 0x13,
+        MLX5_EVENT_TYPE_CODING_SRQ_LIMIT                           = 0x14,
+        MLX5_EVENT_TYPE_CODING_DCT_ALL_CONNECTIONS_CLOSED          = 0x1c,
+        MLX5_EVENT_TYPE_CODING_DCT_ACCESS_KEY_VIOLATION            = 0x1d,
+        MLX5_EVENT_TYPE_CODING_CQ_ERROR                            = 0x4,
+        MLX5_EVENT_TYPE_CODING_LOCAL_WQ_CATASTROPHIC_ERROR         = 0x5,
+        MLX5_EVENT_TYPE_CODING_PATH_MIGRATION_FAILED               = 0x7,
+        MLX5_EVENT_TYPE_CODING_PAGE_FAULT_EVENT                    = 0xc,
+        MLX5_EVENT_TYPE_CODING_INVALID_REQUEST_LOCAL_WQ_ERROR      = 0x10,
+        MLX5_EVENT_TYPE_CODING_LOCAL_ACCESS_VIOLATION_WQ_ERROR     = 0x11,
+        MLX5_EVENT_TYPE_CODING_LOCAL_SRQ_CATASTROPHIC_ERROR        = 0x12,
+        MLX5_EVENT_TYPE_CODING_INTERNAL_ERROR                      = 0x8,
+        MLX5_EVENT_TYPE_CODING_PORT_STATE_CHANGE                   = 0x9,
+        MLX5_EVENT_TYPE_CODING_GPIO_EVENT                          = 0x15,
+        MLX5_EVENT_TYPE_CODING_REMOTE_CONFIGURATION_PROTOCOL_EVENT = 0x19,
+        MLX5_EVENT_TYPE_CODING_DOORBELL_BLUEFLAME_CONGESTION_EVENT = 0x1a,
+        MLX5_EVENT_TYPE_CODING_STALL_VL_EVENT                      = 0x1b,
+        MLX5_EVENT_TYPE_CODING_DROPPED_PACKET_LOGGED_EVENT         = 0x1f,
+        MLX5_EVENT_TYPE_CODING_COMMAND_INTERFACE_COMPLETION        = 0xa,
+        MLX5_EVENT_TYPE_CODING_PAGE_REQUEST                        = 0xb
+};
+
+enum {
+        MLX5_MODIFY_TIR_BITMASK_LRO                   = 0x0,
+        MLX5_MODIFY_TIR_BITMASK_INDIRECT_TABLE        = 0x1,
+        MLX5_MODIFY_TIR_BITMASK_HASH                  = 0x2,
+        MLX5_MODIFY_TIR_BITMASK_TUNNELED_OFFLOAD_EN   = 0x3
+};
+
+enum {
         MLX5_CMD_OP_QUERY_HCA_CAP                 = 0x100,
         MLX5_CMD_OP_QUERY_ADAPTER                 = 0x101,
         MLX5_CMD_OP_INIT_HCA                      = 0x102,
@@ -43,6 +76,8 @@ enum {
         MLX5_CMD_OP_QUERY_PAGES                   = 0x107,
         MLX5_CMD_OP_MANAGE_PAGES                  = 0x108,
         MLX5_CMD_OP_SET_HCA_CAP                   = 0x109,
+        MLX5_CMD_OP_QUERY_ISSI                    = 0x10a,
+        MLX5_CMD_OP_SET_ISSI                      = 0x10b,
         MLX5_CMD_OP_CREATE_MKEY                   = 0x200,
         MLX5_CMD_OP_QUERY_MKEY                    = 0x201,
         MLX5_CMD_OP_DESTROY_MKEY                  = 0x202,
@@ -66,6 +101,7 @@ enum {
         MLX5_CMD_OP_2ERR_QP                       = 0x507,
         MLX5_CMD_OP_2RST_QP                       = 0x50a,
         MLX5_CMD_OP_QUERY_QP                      = 0x50b,
+        MLX5_CMD_OP_SQD_RTS_QP                    = 0x50c,
         MLX5_CMD_OP_INIT2INIT_QP                  = 0x50e,
         MLX5_CMD_OP_CREATE_PSV                    = 0x600,
         MLX5_CMD_OP_DESTROY_PSV                   = 0x601,
@@ -73,7 +109,10 @@ enum {
         MLX5_CMD_OP_DESTROY_SRQ                   = 0x701,
         MLX5_CMD_OP_QUERY_SRQ                     = 0x702,
         MLX5_CMD_OP_ARM_RQ                        = 0x703,
-        MLX5_CMD_OP_RESIZE_SRQ                    = 0x704,
+        MLX5_CMD_OP_CREATE_XRC_SRQ                = 0x705,
+        MLX5_CMD_OP_DESTROY_XRC_SRQ               = 0x706,
+        MLX5_CMD_OP_QUERY_XRC_SRQ                 = 0x707,
+        MLX5_CMD_OP_ARM_XRC_SRQ                   = 0x708,
         MLX5_CMD_OP_CREATE_DCT                    = 0x710,
         MLX5_CMD_OP_DESTROY_DCT                   = 0x711,
         MLX5_CMD_OP_DRAIN_DCT                     = 0x712,
@@ -85,8 +124,12 @@ enum {
         MLX5_CMD_OP_MODIFY_ESW_VPORT_CONTEXT      = 0x753,
         MLX5_CMD_OP_QUERY_NIC_VPORT_CONTEXT       = 0x754,
         MLX5_CMD_OP_MODIFY_NIC_VPORT_CONTEXT      = 0x755,
-        MLX5_CMD_OP_QUERY_RCOE_ADDRESS            = 0x760,
+        MLX5_CMD_OP_QUERY_ROCE_ADDRESS            = 0x760,
         MLX5_CMD_OP_SET_ROCE_ADDRESS              = 0x761,
+        MLX5_CMD_OP_QUERY_HCA_VPORT_CONTEXT       = 0x762,
+        MLX5_CMD_OP_MODIFY_HCA_VPORT_CONTEXT      = 0x763,
+        MLX5_CMD_OP_QUERY_HCA_VPORT_GID           = 0x764,
+        MLX5_CMD_OP_QUERY_HCA_VPORT_PKEY          = 0x765,
         MLX5_CMD_OP_QUERY_VPORT_COUNTER           = 0x770,
         MLX5_CMD_OP_ALLOC_Q_COUNTER               = 0x771,
         MLX5_CMD_OP_DEALLOC_Q_COUNTER             = 0x772,
@@ -98,7 +141,7 @@ enum {
         MLX5_CMD_OP_CONFIG_INT_MODERATION         = 0x804,
         MLX5_CMD_OP_ACCESS_REG                    = 0x805,
         MLX5_CMD_OP_ATTACH_TO_MCG                 = 0x806,
-        MLX5_CMD_OP_DETACH_FROM_MCG               = 0x807,
+        MLX5_CMD_OP_DETTACH_FROM_MCG              = 0x807,
         MLX5_CMD_OP_GET_DROPPED_PACKET_LOG        = 0x80a,
         MLX5_CMD_OP_MAD_IFC                       = 0x50d,
         MLX5_CMD_OP_QUERY_MAD_DEMUX               = 0x80b,
@@ -106,23 +149,22 @@ enum {
         MLX5_CMD_OP_NOP                           = 0x80d,
         MLX5_CMD_OP_ALLOC_XRCD                    = 0x80e,
         MLX5_CMD_OP_DEALLOC_XRCD                  = 0x80f,
-        MLX5_CMD_OP_SET_BURST_SIZE                = 0x812,
-        MLX5_CMD_OP_QUERY_BURST_SZIE              = 0x813,
-        MLX5_CMD_OP_ACTIVATE_TRACER               = 0x814,
-        MLX5_CMD_OP_DEACTIVATE_TRACER             = 0x815,
-        MLX5_CMD_OP_CREATE_SNIFFER_RULE           = 0x820,
-        MLX5_CMD_OP_DESTROY_SNIFFER_RULE          = 0x821,
-        MLX5_CMD_OP_QUERY_CONG_PARAMS             = 0x822,
-        MLX5_CMD_OP_MODIFY_CONG_PARAMS            = 0x823,
-        MLX5_CMD_OP_QUERY_CONG_STATISTICS         = 0x824,
+        MLX5_CMD_OP_ALLOC_TRANSPORT_DOMAIN        = 0x816,
+        MLX5_CMD_OP_DEALLOC_TRANSPORT_DOMAIN      = 0x817,
+        MLX5_CMD_OP_QUERY_CONG_STATUS             = 0x822,
+        MLX5_CMD_OP_MODIFY_CONG_STATUS            = 0x823,
+        MLX5_CMD_OP_QUERY_CONG_PARAMS             = 0x824,
+        MLX5_CMD_OP_MODIFY_CONG_PARAMS            = 0x825,
+        MLX5_CMD_OP_QUERY_CONG_STATISTICS         = 0x826,
+        MLX5_CMD_OP_ADD_VXLAN_UDP_DPORT           = 0x827,
+        MLX5_CMD_OP_DELETE_VXLAN_UDP_DPORT        = 0x828,
+        MLX5_CMD_OP_SET_L2_TABLE_ENTRY            = 0x829,
+        MLX5_CMD_OP_QUERY_L2_TABLE_ENTRY          = 0x82a,
+        MLX5_CMD_OP_DELETE_L2_TABLE_ENTRY         = 0x82b,
         MLX5_CMD_OP_CREATE_TIR                    = 0x900,
         MLX5_CMD_OP_MODIFY_TIR                    = 0x901,
         MLX5_CMD_OP_DESTROY_TIR                   = 0x902,
         MLX5_CMD_OP_QUERY_TIR                     = 0x903,
-        MLX5_CMD_OP_CREATE_TIS                    = 0x912,
-        MLX5_CMD_OP_MODIFY_TIS                    = 0x913,
-        MLX5_CMD_OP_DESTROY_TIS                   = 0x914,
-        MLX5_CMD_OP_QUERY_TIS                     = 0x915,
         MLX5_CMD_OP_CREATE_SQ                     = 0x904,
         MLX5_CMD_OP_MODIFY_SQ                     = 0x905,
         MLX5_CMD_OP_DESTROY_SQ                    = 0x906,
@@ -135,9 +177,430 @@ enum {
         MLX5_CMD_OP_MODIFY_RMP                    = 0x90d,
         MLX5_CMD_OP_DESTROY_RMP                   = 0x90e,
         MLX5_CMD_OP_QUERY_RMP                     = 0x90f,
-        MLX5_CMD_OP_SET_FLOW_TABLE_ENTRY          = 0x910,
-        MLX5_CMD_OP_QUERY_FLOW_TABLE_ENTRY        = 0x911,
-        MLX5_CMD_OP_MAX                           = 0x911
+        MLX5_CMD_OP_CREATE_TIS                    = 0x912,
+        MLX5_CMD_OP_MODIFY_TIS                    = 0x913,
+        MLX5_CMD_OP_DESTROY_TIS                   = 0x914,
+        MLX5_CMD_OP_QUERY_TIS                     = 0x915,
+        MLX5_CMD_OP_CREATE_RQT                    = 0x916,
+        MLX5_CMD_OP_MODIFY_RQT                    = 0x917,
+        MLX5_CMD_OP_DESTROY_RQT                   = 0x918,
+        MLX5_CMD_OP_QUERY_RQT                     = 0x919,
+        MLX5_CMD_OP_CREATE_FLOW_TABLE             = 0x930,
+        MLX5_CMD_OP_DESTROY_FLOW_TABLE            = 0x931,
+        MLX5_CMD_OP_QUERY_FLOW_TABLE              = 0x932,
+        MLX5_CMD_OP_CREATE_FLOW_GROUP             = 0x933,
+        MLX5_CMD_OP_DESTROY_FLOW_GROUP            = 0x934,
+        MLX5_CMD_OP_QUERY_FLOW_GROUP              = 0x935,
+        MLX5_CMD_OP_SET_FLOW_TABLE_ENTRY          = 0x936,
+        MLX5_CMD_OP_QUERY_FLOW_TABLE_ENTRY        = 0x937,
+        MLX5_CMD_OP_DELETE_FLOW_TABLE_ENTRY       = 0x938
+};
+
+struct mlx5_ifc_flow_table_fields_supported_bits {
+        u8         outer_dmac[0x1];
+        u8         outer_smac[0x1];
+        u8         outer_ether_type[0x1];
+        u8         reserved_0[0x1];
+        u8         outer_first_prio[0x1];
+        u8         outer_first_cfi[0x1];
+        u8         outer_first_vid[0x1];
+        u8         reserved_1[0x1];
+        u8         outer_second_prio[0x1];
+        u8         outer_second_cfi[0x1];
+        u8         outer_second_vid[0x1];
+        u8         reserved_2[0x1];
+        u8         outer_sip[0x1];
+        u8         outer_dip[0x1];
+        u8         outer_frag[0x1];
+        u8         outer_ip_protocol[0x1];
+        u8         outer_ip_ecn[0x1];
+        u8         outer_ip_dscp[0x1];
+        u8         outer_udp_sport[0x1];
+        u8         outer_udp_dport[0x1];
+        u8         outer_tcp_sport[0x1];
+        u8         outer_tcp_dport[0x1];
+        u8         outer_tcp_flags[0x1];
+        u8         outer_gre_protocol[0x1];
+        u8         outer_gre_key[0x1];
+        u8         outer_vxlan_vni[0x1];
+        u8         reserved_3[0x5];
+        u8         source_eswitch_port[0x1];
+
+        u8         inner_dmac[0x1];
+        u8         inner_smac[0x1];
+        u8         inner_ether_type[0x1];
+        u8         reserved_4[0x1];
+        u8         inner_first_prio[0x1];
+        u8         inner_first_cfi[0x1];
+        u8         inner_first_vid[0x1];
+        u8         reserved_5[0x1];
+        u8         inner_second_prio[0x1];
+        u8         inner_second_cfi[0x1];
+        u8         inner_second_vid[0x1];
+        u8         reserved_6[0x1];
+        u8         inner_sip[0x1];
+        u8         inner_dip[0x1];
+        u8         inner_frag[0x1];
+        u8         inner_ip_protocol[0x1];
+        u8         inner_ip_ecn[0x1];
+        u8         inner_ip_dscp[0x1];
+        u8         inner_udp_sport[0x1];
+        u8         inner_udp_dport[0x1];
+        u8         inner_tcp_sport[0x1];
+        u8         inner_tcp_dport[0x1];
+        u8         inner_tcp_flags[0x1];
+        u8         reserved_7[0x9];
+
+        u8         reserved_8[0x40];
+};
+
+struct mlx5_ifc_flow_table_prop_layout_bits {
+        u8         ft_support[0x1];
+        u8         reserved_0[0x1f];
+
+        u8         reserved_1[0x2];
+        u8         log_max_ft_size[0x6];
+        u8         reserved_2[0x10];
+        u8         max_ft_level[0x8];
+
+        u8         reserved_3[0x20];
+
+        u8         reserved_4[0x18];
+        u8         log_max_ft_num[0x8];
+
+        u8         reserved_5[0x18];
+        u8         log_max_destination[0x8];
+
+        u8         reserved_6[0x18];
+        u8         log_max_flow[0x8];
+
+        u8         reserved_7[0x40];
+
+        struct mlx5_ifc_flow_table_fields_supported_bits ft_field_support;
+
+        struct mlx5_ifc_flow_table_fields_supported_bits ft_field_bitmask_support;
+};
+
+struct mlx5_ifc_odp_per_transport_service_cap_bits {
+        u8         send[0x1];
+        u8         receive[0x1];
+        u8         write[0x1];
+        u8         read[0x1];
+        u8         reserved_0[0x1];
+        u8         srq_receive[0x1];
+        u8         reserved_1[0x1a];
+};
+
+struct mlx5_ifc_fte_match_set_lyr_2_4_bits {
+        u8         smac_47_16[0x20];
+
+        u8         smac_15_0[0x10];
+        u8         ethertype[0x10];
+
+        u8         dmac_47_16[0x20];
+
+        u8         dmac_15_0[0x10];
+        u8         first_prio[0x3];
+        u8         first_cfi[0x1];
+        u8         first_vid[0xc];
+
+        u8         ip_protocol[0x8];
+        u8         ip_dscp[0x6];
+        u8         ip_ecn[0x2];
+        u8         vlan_tag[0x1];
+        u8         reserved_0[0x1];
+        u8         frag[0x1];
+        u8         reserved_1[0x4];
+        u8         tcp_flags[0x9];
+
+        u8         tcp_sport[0x10];
+        u8         tcp_dport[0x10];
+
+        u8         reserved_2[0x20];
+
+        u8         udp_sport[0x10];
+        u8         udp_dport[0x10];
+
+        u8         src_ip[4][0x20];
+
+        u8         dst_ip[4][0x20];
+};
+
+struct mlx5_ifc_fte_match_set_misc_bits {
+        u8         reserved_0[0x20];
+
+        u8         reserved_1[0x10];
+        u8         source_port[0x10];
+
+        u8         outer_second_prio[0x3];
+        u8         outer_second_cfi[0x1];
+        u8         outer_second_vid[0xc];
+        u8         inner_second_prio[0x3];
+        u8         inner_second_cfi[0x1];
+        u8         inner_second_vid[0xc];
+
+        u8         outer_second_vlan_tag[0x1];
+        u8         inner_second_vlan_tag[0x1];
+        u8         reserved_2[0xe];
+        u8         gre_protocol[0x10];
+
+        u8         gre_key_h[0x18];
+        u8         gre_key_l[0x8];
+
+        u8         vxlan_vni[0x18];
+        u8         reserved_3[0x8];
+
+        u8         reserved_4[0x20];
+
+        u8         reserved_5[0xc];
+        u8         outer_ipv6_flow_label[0x14];
+
+        u8         reserved_6[0xc];
+        u8         inner_ipv6_flow_label[0x14];
+
+        u8         reserved_7[0xe0];
+};
+
+struct mlx5_ifc_cmd_pas_bits {
+        u8         pa_h[0x20];
+
+        u8         pa_l[0x14];
+        u8         reserved_0[0xc];
+};
+
+struct mlx5_ifc_uint64_bits {
+        u8         hi[0x20];
+
+        u8         lo[0x20];
+};
+
+enum {
+        MLX5_ADS_STAT_RATE_NO_LIMIT  = 0x0,
+        MLX5_ADS_STAT_RATE_2_5GBPS   = 0x7,
+        MLX5_ADS_STAT_RATE_10GBPS    = 0x8,
+        MLX5_ADS_STAT_RATE_30GBPS    = 0x9,
+        MLX5_ADS_STAT_RATE_5GBPS     = 0xa,
+        MLX5_ADS_STAT_RATE_20GBPS    = 0xb,
+        MLX5_ADS_STAT_RATE_40GBPS    = 0xc,
+        MLX5_ADS_STAT_RATE_60GBPS    = 0xd,
+        MLX5_ADS_STAT_RATE_80GBPS    = 0xe,
+        MLX5_ADS_STAT_RATE_120GBPS   = 0xf,
+};
+
+struct mlx5_ifc_ads_bits {
+        u8         fl[0x1];
+        u8         free_ar[0x1];
+        u8         reserved_0[0xe];
+        u8         pkey_index[0x10];
+
+        u8         reserved_1[0x8];
+        u8         grh[0x1];
+        u8         mlid[0x7];
+        u8         rlid[0x10];
+
+        u8         ack_timeout[0x5];
+        u8         reserved_2[0x3];
+        u8         src_addr_index[0x8];
+        u8         reserved_3[0x4];
+        u8         stat_rate[0x4];
+        u8         hop_limit[0x8];
+
+        u8         reserved_4[0x4];
+        u8         tclass[0x8];
+        u8         flow_label[0x14];
+
+        u8         rgid_rip[16][0x8];
+
+        u8         reserved_5[0x4];
+        u8         f_dscp[0x1];
+        u8         f_ecn[0x1];
+        u8         reserved_6[0x1];
+        u8         f_eth_prio[0x1];
+        u8         ecn[0x2];
+        u8         dscp[0x6];
+        u8         udp_sport[0x10];
+
+        u8         dei_cfi[0x1];
+        u8         eth_prio[0x3];
+        u8         sl[0x4];
+        u8         port[0x8];
+        u8         rmac_47_32[0x10];
+
+        u8         rmac_31_0[0x20];
+};
+
+struct mlx5_ifc_flow_table_nic_cap_bits {
+        u8         reserved_0[0x200];
+
+        struct mlx5_ifc_flow_table_prop_layout_bits flow_table_properties_nic_receive;
+
+        u8         reserved_1[0x200];
+
+        struct mlx5_ifc_flow_table_prop_layout_bits flow_table_properties_nic_receive_sniffer;
+
+        struct mlx5_ifc_flow_table_prop_layout_bits flow_table_properties_nic_transmit;
+
+        u8         reserved_2[0x200];
+
+        struct mlx5_ifc_flow_table_prop_layout_bits flow_table_properties_nic_transmit_sniffer;
+
+        u8         reserved_3[0x7200];
+};
+
+struct mlx5_ifc_per_protocol_networking_offload_caps_bits {
+        u8         csum_cap[0x1];
+        u8         vlan_cap[0x1];
+        u8         lro_cap[0x1];
+        u8         lro_psh_flag[0x1];
+        u8         lro_time_stamp[0x1];
+        u8         reserved_0[0x6];
+        u8         max_lso_cap[0x5];
+        u8         reserved_1[0x4];
+        u8         rss_ind_tbl_cap[0x4];
+        u8         reserved_2[0x3];
+        u8         tunnel_lso_const_out_ip_id[0x1];
+        u8         reserved_3[0x2];
+        u8         tunnel_statless_gre[0x1];
+        u8         tunnel_stateless_vxlan[0x1];
+
+        u8         reserved_4[0x20];
+
+        u8         reserved_5[0x10];
+        u8         lro_min_mss_size[0x10];
+
+        u8         reserved_6[0x120];
+
+        u8         lro_timer_supported_periods[4][0x20];
+
+        u8         reserved_7[0x600];
+};
+
+struct mlx5_ifc_roce_cap_bits {
+        u8         roce_apm[0x1];
+        u8         reserved_0[0x1f];
+
+        u8         reserved_1[0x60];
+
+        u8         reserved_2[0xc];
+        u8         l3_type[0x4];
+        u8         reserved_3[0x8];
+        u8         roce_version[0x8];
+
+        u8         reserved_4[0x10];
+        u8         r_roce_dest_udp_port[0x10];
+
+        u8         r_roce_max_src_udp_port[0x10];
+        u8         r_roce_min_src_udp_port[0x10];
+
+        u8         reserved_5[0x10];
+        u8         roce_address_table_size[0x10];
+
+        u8         reserved_6[0x700];
+};
+
+enum {
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_QP_1_BYTE     = 0x0,
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_QP_2_BYTES    = 0x2,
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_QP_4_BYTES    = 0x4,
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_QP_8_BYTES    = 0x8,
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_QP_16_BYTES   = 0x10,
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_QP_32_BYTES   = 0x20,
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_QP_64_BYTES   = 0x40,
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_QP_128_BYTES  = 0x80,
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_QP_256_BYTES  = 0x100,
+};
+
+enum {
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_DC_1_BYTE     = 0x1,
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_DC_2_BYTES    = 0x2,
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_DC_4_BYTES    = 0x4,
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_DC_8_BYTES    = 0x8,
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_DC_16_BYTES   = 0x10,
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_DC_32_BYTES   = 0x20,
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_DC_64_BYTES   = 0x40,
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_DC_128_BYTES  = 0x80,
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_DC_256_BYTES  = 0x100,
+};
+
+struct mlx5_ifc_atomic_caps_bits {
+        u8         reserved_0[0x40];
+
+        u8         atomic_req_endianness[0x1];
+        u8         reserved_1[0x1f];
+
+        u8         reserved_2[0x20];
+
+        u8         reserved_3[0x10];
+        u8         atomic_operations[0x10];
+
+        u8         reserved_4[0x10];
+        u8         atomic_size_qp[0x10];
+
+        u8         reserved_5[0x10];
+        u8         atomic_size_dc[0x10];
+
+        u8         reserved_6[0x720];
+};
+
+struct mlx5_ifc_odp_cap_bits {
+        u8         reserved_0[0x40];
+
+        u8         sig[0x1];
+        u8         reserved_1[0x1f];
+
+        u8         reserved_2[0x20];
+
+        struct mlx5_ifc_odp_per_transport_service_cap_bits rc_odp_caps;
+
+        struct mlx5_ifc_odp_per_transport_service_cap_bits uc_odp_caps;
+
+        struct mlx5_ifc_odp_per_transport_service_cap_bits ud_odp_caps;
+
+        u8         reserved_3[0x720];
+};
+
+enum {
+        MLX5_WQ_TYPE_LINKED_LIST  = 0x0,
+        MLX5_WQ_TYPE_CYCLIC       = 0x1,
+        MLX5_WQ_TYPE_STRQ         = 0x2,
+};
+
+enum {
+        MLX5_WQ_END_PAD_MODE_NONE   = 0x0,
+        MLX5_WQ_END_PAD_MODE_ALIGN  = 0x1,
+};
+
+enum {
+        MLX5_CMD_HCA_CAP_GID_TABLE_SIZE_8_GID_ENTRIES    = 0x0,
+        MLX5_CMD_HCA_CAP_GID_TABLE_SIZE_16_GID_ENTRIES   = 0x1,
+        MLX5_CMD_HCA_CAP_GID_TABLE_SIZE_32_GID_ENTRIES   = 0x2,
+        MLX5_CMD_HCA_CAP_GID_TABLE_SIZE_64_GID_ENTRIES   = 0x3,
+        MLX5_CMD_HCA_CAP_GID_TABLE_SIZE_128_GID_ENTRIES  = 0x4,
+};
+
+enum {
+        MLX5_CMD_HCA_CAP_PKEY_TABLE_SIZE_128_ENTRIES  = 0x0,
+        MLX5_CMD_HCA_CAP_PKEY_TABLE_SIZE_256_ENTRIES  = 0x1,
+        MLX5_CMD_HCA_CAP_PKEY_TABLE_SIZE_512_ENTRIES  = 0x2,
+        MLX5_CMD_HCA_CAP_PKEY_TABLE_SIZE_1K_ENTRIES   = 0x3,
+        MLX5_CMD_HCA_CAP_PKEY_TABLE_SIZE_2K_ENTRIES   = 0x4,
+        MLX5_CMD_HCA_CAP_PKEY_TABLE_SIZE_4K_ENTRIES   = 0x5,
+};
+
+enum {
+        MLX5_CMD_HCA_CAP_PORT_TYPE_IB        = 0x0,
+        MLX5_CMD_HCA_CAP_PORT_TYPE_ETHERNET  = 0x1,
+};
+
+enum {
+        MLX5_CMD_HCA_CAP_CMDIF_CHECKSUM_DISABLED       = 0x0,
+        MLX5_CMD_HCA_CAP_CMDIF_CHECKSUM_INITIAL_STATE  = 0x1,
+        MLX5_CMD_HCA_CAP_CMDIF_CHECKSUM_ENABLED        = 0x3,
+};
+
+enum {
+        MLX5_CAP_PORT_TYPE_IB  = 0x0,
+        MLX5_CAP_PORT_TYPE_ETH = 0x1,
 };
 
 struct mlx5_ifc_cmd_hca_cap_bits {
@@ -148,9 +611,8 @@ struct mlx5_ifc_cmd_hca_cap_bits {
         u8         reserved_1[0xb];
         u8         log_max_qp[0x5];
 
-        u8         log_max_strq_sz[0x8];
-        u8         reserved_2[0x3];
-        u8         log_max_srqs[0x5];
+        u8         reserved_2[0xb];
+        u8         log_max_srq[0x5];
         u8         reserved_3[0x10];
 
         u8         reserved_4[0x8];
@@ -185,123 +647,2112 @@ struct mlx5_ifc_cmd_hca_cap_bits {
         u8         pad_cap[0x1];
         u8         cc_query_allowed[0x1];
         u8         cc_modify_allowed[0x1];
-        u8         reserved_15[0x1d];
+        u8         reserved_15[0xd];
+        u8         gid_table_size[0x10];
 
-        u8         reserved_16[0x6];
+        u8         out_of_seq_cnt[0x1];
+        u8         vport_counters[0x1];
+        u8         reserved_16[0x4];
         u8         max_qp_cnt[0xa];
         u8         pkey_table_size[0x10];
 
-        u8         eswitch_owner[0x1];
-        u8         reserved_17[0xa];
+        u8         vport_group_manager[0x1];
+        u8         vhca_group_manager[0x1];
+        u8         ib_virt[0x1];
+        u8         eth_virt[0x1];
+        u8         reserved_17[0x1];
+        u8         ets[0x1];
+        u8         nic_flow_table[0x1];
+        u8         reserved_18[0x4];
         u8         local_ca_ack_delay[0x5];
-        u8         reserved_18[0x8];
+        u8         reserved_19[0x6];
+        u8         port_type[0x2];
         u8         num_ports[0x8];
 
-        u8         reserved_19[0x3];
+        u8         reserved_20[0x3];
         u8         log_max_msg[0x5];
-        u8         reserved_20[0x18];
+        u8         reserved_21[0x18];
 
         u8         stat_rate_support[0x10];
-        u8         reserved_21[0x10];
+        u8         reserved_22[0xc];
+        u8         cqe_version[0x4];
 
-        u8         reserved_22[0x10];
+        u8         compact_address_vector[0x1];
+        u8         reserved_23[0xe];
+        u8         drain_sigerr[0x1];
         u8         cmdif_checksum[0x2];
         u8         sigerr_cqe[0x1];
-        u8         reserved_23[0x1];
+        u8         reserved_24[0x1];
         u8         wq_signature[0x1];
         u8         sctr_data_cqe[0x1];
-        u8         reserved_24[0x1];
+        u8         reserved_25[0x1];
         u8         sho[0x1];
         u8         tph[0x1];
         u8         rf[0x1];
-        u8         dc[0x1];
-        u8         reserved_25[0x2];
+        u8         dct[0x1];
+        u8         reserved_26[0x1];
+        u8         eth_net_offloads[0x1];
         u8         roce[0x1];
         u8         atomic[0x1];
-        u8         rsz_srq[0x1];
+        u8         reserved_27[0x1];
 
         u8         cq_oi[0x1];
         u8         cq_resize[0x1];
         u8         cq_moderation[0x1];
-        u8         sniffer_rule_flow[0x1];
-        u8         sniffer_rule_vport[0x1];
-        u8         sniffer_rule_phy[0x1];
-        u8         reserved_26[0x1];
+        u8         reserved_28[0x3];
+        u8         cq_eq_remap[0x1];
         u8         pg[0x1];
         u8         block_lb_mc[0x1];
-        u8         reserved_27[0x3];
+        u8         reserved_29[0x1];
+        u8         scqe_break_moderation[0x1];
+        u8         reserved_30[0x1];
         u8         cd[0x1];
-        u8         reserved_28[0x1];
+        u8         reserved_31[0x1];
         u8         apm[0x1];
-        u8         reserved_29[0x7];
+        u8         reserved_32[0x7];
         u8         qkv[0x1];
         u8         pkv[0x1];
-        u8         reserved_30[0x4];
+        u8         reserved_33[0x4];
         u8         xrc[0x1];
         u8         ud[0x1];
         u8         uc[0x1];
         u8         rc[0x1];
 
-        u8         reserved_31[0xa];
+        u8         reserved_34[0xa];
         u8         uar_sz[0x6];
-        u8         reserved_32[0x8];
+        u8         reserved_35[0x8];
         u8         log_pg_sz[0x8];
 
         u8         bf[0x1];
-        u8         reserved_33[0xa];
+        u8         reserved_36[0x1];
+        u8         pad_tx_eth_packet[0x1];
+        u8         reserved_37[0x8];
         u8         log_bf_reg_size[0x5];
-        u8         reserved_34[0x10];
+        u8         reserved_38[0x10];
 
-        u8         reserved_35[0x10];
+        u8         reserved_39[0x10];
         u8         max_wqe_sz_sq[0x10];
 
-        u8         reserved_36[0x10];
+        u8         reserved_40[0x10];
         u8         max_wqe_sz_rq[0x10];
 
-        u8         reserved_37[0x10];
+        u8         reserved_41[0x10];
         u8         max_wqe_sz_sq_dc[0x10];
 
-        u8         reserved_38[0x7];
+        u8         reserved_42[0x7];
         u8         max_qp_mcg[0x19];
 
-        u8         reserved_39[0x18];
+        u8         reserved_43[0x18];
         u8         log_max_mcg[0x8];
 
-        u8         reserved_40[0xb];
+        u8         reserved_44[0x3];
+        u8         log_max_transport_domain[0x5];
+        u8         reserved_45[0x3];
         u8         log_max_pd[0x5];
-        u8         reserved_41[0xb];
+        u8         reserved_46[0xb];
         u8         log_max_xrcd[0x5];
 
-        u8         reserved_42[0x20];
+        u8         reserved_47[0x20];
 
-        u8         reserved_43[0x3];
+        u8         reserved_48[0x3];
         u8         log_max_rq[0x5];
-        u8         reserved_44[0x3];
+        u8         reserved_49[0x3];
         u8         log_max_sq[0x5];
-        u8         reserved_45[0x3];
+        u8         reserved_50[0x3];
         u8         log_max_tir[0x5];
-        u8         reserved_46[0x3];
+        u8         reserved_51[0x3];
         u8         log_max_tis[0x5];
 
-        u8         reserved_47[0x13];
-        u8         log_max_rq_per_tir[0x5];
-        u8         reserved_48[0x3];
+        u8         basic_cyclic_rcv_wqe[0x1];
+        u8         reserved_52[0x2];
+        u8         log_max_rmp[0x5];
+        u8         reserved_53[0x3];
+        u8         log_max_rqt[0x5];
+        u8         reserved_54[0x3];
+        u8         log_max_rqt_size[0x5];
+        u8         reserved_55[0x3];
         u8         log_max_tis_per_sq[0x5];
 
-        u8         reserved_49[0xe0];
+        u8         reserved_56[0x3];
+        u8         log_max_stride_sz_rq[0x5];
+        u8         reserved_57[0x3];
+        u8         log_min_stride_sz_rq[0x5];
+        u8         reserved_58[0x3];
+        u8         log_max_stride_sz_sq[0x5];
+        u8         reserved_59[0x3];
+        u8         log_min_stride_sz_sq[0x5];
 
-        u8         reserved_50[0x10];
+        u8         reserved_60[0x1b];
+        u8         log_max_wq_sz[0x5];
+
+        u8         reserved_61[0xa0];
+
+        u8         reserved_62[0x3];
+        u8         log_max_l2_table[0x5];
+        u8         reserved_63[0x8];
         u8         log_uar_page_sz[0x10];
 
-        u8         reserved_51[0x100];
+        u8         reserved_64[0x100];
 
-        u8         reserved_52[0x1f];
+        u8         reserved_65[0x1f];
         u8         cqe_zip[0x1];
 
         u8         cqe_zip_timeout[0x10];
         u8         cqe_zip_max_num[0x10];
 
-        u8         reserved_53[0x220];
+        u8         reserved_66[0x220];
+};
+
+enum {
+        MLX5_DEST_FORMAT_STRUCT_DESTINATION_TYPE_FLOW_TABLE_  = 0x1,
+        MLX5_DEST_FORMAT_STRUCT_DESTINATION_TYPE_TIR          = 0x2,
+};
+
+struct mlx5_ifc_dest_format_struct_bits {
+        u8         destination_type[0x8];
+        u8         destination_id[0x18];
+
+        u8         reserved_0[0x20];
+};
+
+struct mlx5_ifc_fte_match_param_bits {
+        struct mlx5_ifc_fte_match_set_lyr_2_4_bits outer_headers;
+
+        struct mlx5_ifc_fte_match_set_misc_bits misc_parameters;
+
+        struct mlx5_ifc_fte_match_set_lyr_2_4_bits inner_headers;
+
+        u8         reserved_0[0xa00];
+};
+
+enum {
+        MLX5_RX_HASH_FIELD_SELECT_SELECTED_FIELDS_SRC_IP     = 0x0,
+        MLX5_RX_HASH_FIELD_SELECT_SELECTED_FIELDS_DST_IP     = 0x1,
+        MLX5_RX_HASH_FIELD_SELECT_SELECTED_FIELDS_L4_SPORT   = 0x2,
+        MLX5_RX_HASH_FIELD_SELECT_SELECTED_FIELDS_L4_DPORT   = 0x3,
+        MLX5_RX_HASH_FIELD_SELECT_SELECTED_FIELDS_IPSEC_SPI  = 0x4,
+};
+
+struct mlx5_ifc_rx_hash_field_select_bits {
+        u8         l3_prot_type[0x1];
+        u8         l4_prot_type[0x1];
+        u8         selected_fields[0x1e];
+};
+
+enum {
+        MLX5_WQ_WQ_TYPE_WQ_LINKED_LIST  = 0x0,
+        MLX5_WQ_WQ_TYPE_WQ_CYCLIC       = 0x1,
+};
+
+enum {
+        MLX5_WQ_END_PADDING_MODE_END_PAD_NONE   = 0x0,
+        MLX5_WQ_END_PADDING_MODE_END_PAD_ALIGN  = 0x1,
+};
+
+struct mlx5_ifc_wq_bits {
+        u8         wq_type[0x4];
+        u8         wq_signature[0x1];
+        u8         end_padding_mode[0x2];
+        u8         cd_slave[0x1];
+        u8         reserved_0[0x18];
+
+        u8         hds_skip_first_sge[0x1];
+        u8         log2_hds_buf_size[0x3];
+        u8         reserved_1[0x7];
+        u8         page_offset[0x5];
+        u8         lwm[0x10];
+
+        u8         reserved_2[0x8];
+        u8         pd[0x18];
+
+        u8         reserved_3[0x8];
+        u8         uar_page[0x18];
+
+        u8         dbr_addr[0x40];
+
+        u8         hw_counter[0x20];
+
+        u8         sw_counter[0x20];
+
+        u8         reserved_4[0xc];
+        u8         log_wq_stride[0x4];
+        u8         reserved_5[0x3];
+        u8         log_wq_pg_sz[0x5];
+        u8         reserved_6[0x3];
+        u8         log_wq_sz[0x5];
+
+        u8         reserved_7[0x4e0];
+
+        struct mlx5_ifc_cmd_pas_bits pas[0];
+};
+
+struct mlx5_ifc_rq_num_bits {
+        u8         reserved_0[0x8];
+        u8         rq_num[0x18];
+};
+
+struct mlx5_ifc_mac_address_layout_bits {
+        u8         reserved_0[0x10];
+        u8         mac_addr_47_32[0x10];
+
+        u8         mac_addr_31_0[0x20];
+};
+
+struct mlx5_ifc_cong_control_r_roce_ecn_np_bits {
+        u8         reserved_0[0xa0];
+
+        u8         min_time_between_cnps[0x20];
+
+        u8         reserved_1[0x12];
+        u8         cnp_dscp[0x6];
+        u8         reserved_2[0x5];
+        u8         cnp_802p_prio[0x3];
+
+        u8         reserved_3[0x720];
+};
+
+struct mlx5_ifc_cong_control_r_roce_ecn_rp_bits {
+        u8         reserved_0[0x60];
+
+        u8         reserved_1[0x4];
+        u8         clamp_tgt_rate[0x1];
+        u8         reserved_2[0x3];
+        u8         clamp_tgt_rate_after_time_inc[0x1];
+        u8         reserved_3[0x17];
+
+        u8         reserved_4[0x20];
+
+        u8         rpg_time_reset[0x20];
+
+        u8         rpg_byte_reset[0x20];
+
+        u8         rpg_threshold[0x20];
+
+        u8         rpg_max_rate[0x20];
+
+        u8         rpg_ai_rate[0x20];
+
+        u8         rpg_hai_rate[0x20];
+
+        u8         rpg_gd[0x20];
+
+        u8         rpg_min_dec_fac[0x20];
+
+        u8         rpg_min_rate[0x20];
+
+        u8         reserved_5[0xe0];
+
+        u8         rate_to_set_on_first_cnp[0x20];
+
+        u8         dce_tcp_g[0x20];
+
+        u8         dce_tcp_rtt[0x20];
+
+        u8         rate_reduce_monitor_period[0x20];
+
+        u8         reserved_6[0x20];
+
+        u8         initial_alpha_value[0x20];
+
+        u8         reserved_7[0x4a0];
+};
+
+struct mlx5_ifc_cong_control_802_1qau_rp_bits {
+        u8         reserved_0[0x80];
+
+        u8         rppp_max_rps[0x20];
+
+        u8         rpg_time_reset[0x20];
+
+        u8         rpg_byte_reset[0x20];
+
+        u8         rpg_threshold[0x20];
+
+        u8         rpg_max_rate[0x20];
+
+        u8         rpg_ai_rate[0x20];
+
+        u8         rpg_hai_rate[0x20];
+
+        u8         rpg_gd[0x20];
+
+        u8         rpg_min_dec_fac[0x20];
+
+        u8         rpg_min_rate[0x20];
+
+        u8         reserved_1[0x640];
+};
+
+enum {
+        MLX5_RESIZE_FIELD_SELECT_RESIZE_FIELD_SELECT_LOG_CQ_SIZE    = 0x1,
+        MLX5_RESIZE_FIELD_SELECT_RESIZE_FIELD_SELECT_PAGE_OFFSET    = 0x2,
+        MLX5_RESIZE_FIELD_SELECT_RESIZE_FIELD_SELECT_LOG_PAGE_SIZE  = 0x4,
+};
+
+struct mlx5_ifc_resize_field_select_bits {
+        u8         resize_field_select[0x20];
+};
+
+enum {
+        MLX5_MODIFY_FIELD_SELECT_MODIFY_FIELD_SELECT_CQ_PERIOD     = 0x1,
+        MLX5_MODIFY_FIELD_SELECT_MODIFY_FIELD_SELECT_CQ_MAX_COUNT  = 0x2,
+        MLX5_MODIFY_FIELD_SELECT_MODIFY_FIELD_SELECT_OI            = 0x4,
+        MLX5_MODIFY_FIELD_SELECT_MODIFY_FIELD_SELECT_C_EQN         = 0x8,
+};
+
+struct mlx5_ifc_modify_field_select_bits {
+        u8         modify_field_select[0x20];
+};
+
+struct mlx5_ifc_field_select_r_roce_np_bits {
+        u8         field_select_r_roce_np[0x20];
+};
+
+struct mlx5_ifc_field_select_r_roce_rp_bits {
+        u8         field_select_r_roce_rp[0x20];
+};
+
+enum {
+        MLX5_FIELD_SELECT_802_1QAU_RP_FIELD_SELECT_8021QAURP_RPPP_MAX_RPS     = 0x4,
+        MLX5_FIELD_SELECT_802_1QAU_RP_FIELD_SELECT_8021QAURP_RPG_TIME_RESET   = 0x8,
+        MLX5_FIELD_SELECT_802_1QAU_RP_FIELD_SELECT_8021QAURP_RPG_BYTE_RESET   = 0x10,
+        MLX5_FIELD_SELECT_802_1QAU_RP_FIELD_SELECT_8021QAURP_RPG_THRESHOLD    = 0x20,
+        MLX5_FIELD_SELECT_802_1QAU_RP_FIELD_SELECT_8021QAURP_RPG_MAX_RATE     = 0x40,
+        MLX5_FIELD_SELECT_802_1QAU_RP_FIELD_SELECT_8021QAURP_RPG_AI_RATE      = 0x80,
+        MLX5_FIELD_SELECT_802_1QAU_RP_FIELD_SELECT_8021QAURP_RPG_HAI_RATE     = 0x100,
+        MLX5_FIELD_SELECT_802_1QAU_RP_FIELD_SELECT_8021QAURP_RPG_GD           = 0x200,
+        MLX5_FIELD_SELECT_802_1QAU_RP_FIELD_SELECT_8021QAURP_RPG_MIN_DEC_FAC  = 0x400,
+        MLX5_FIELD_SELECT_802_1QAU_RP_FIELD_SELECT_8021QAURP_RPG_MIN_RATE     = 0x800,
+};
+
+struct mlx5_ifc_field_select_802_1qau_rp_bits {
+        u8         field_select_8021qaurp[0x20];
+};
+
+struct mlx5_ifc_phys_layer_cntrs_bits {
+        u8         time_since_last_clear_high[0x20];
+
+        u8         time_since_last_clear_low[0x20];
+
+        u8         symbol_errors_high[0x20];
+
+        u8         symbol_errors_low[0x20];
+
+        u8         sync_headers_errors_high[0x20];
+
+        u8         sync_headers_errors_low[0x20];
+
+        u8         edpl_bip_errors_lane0_high[0x20];
+
+        u8         edpl_bip_errors_lane0_low[0x20];
+
+        u8         edpl_bip_errors_lane1_high[0x20];
+
+        u8         edpl_bip_errors_lane1_low[0x20];
+
+        u8         edpl_bip_errors_lane2_high[0x20];
+
+        u8         edpl_bip_errors_lane2_low[0x20];
+
+        u8         edpl_bip_errors_lane3_high[0x20];
+
+        u8         edpl_bip_errors_lane3_low[0x20];
+
+        u8         fc_fec_corrected_blocks_lane0_high[0x20];
+
+        u8         fc_fec_corrected_blocks_lane0_low[0x20];
+
+        u8         fc_fec_corrected_blocks_lane1_high[0x20];
+
+        u8         fc_fec_corrected_blocks_lane1_low[0x20];
+
+        u8         fc_fec_corrected_blocks_lane2_high[0x20];
+
+        u8         fc_fec_corrected_blocks_lane2_low[0x20];
+
+        u8         fc_fec_corrected_blocks_lane3_high[0x20];
+
+        u8         fc_fec_corrected_blocks_lane3_low[0x20];
+
+        u8         fc_fec_uncorrectable_blocks_lane0_high[0x20];
+
+        u8         fc_fec_uncorrectable_blocks_lane0_low[0x20];
+
+        u8         fc_fec_uncorrectable_blocks_lane1_high[0x20];
+
+        u8         fc_fec_uncorrectable_blocks_lane1_low[0x20];
+
+        u8         fc_fec_uncorrectable_blocks_lane2_high[0x20];
+
+        u8         fc_fec_uncorrectable_blocks_lane2_low[0x20];
+
+        u8         fc_fec_uncorrectable_blocks_lane3_high[0x20];
+
+        u8         fc_fec_uncorrectable_blocks_lane3_low[0x20];
+
+        u8         rs_fec_corrected_blocks_high[0x20];
+
+        u8         rs_fec_corrected_blocks_low[0x20];
+
+        u8         rs_fec_uncorrectable_blocks_high[0x20];
+
+        u8         rs_fec_uncorrectable_blocks_low[0x20];
+
+        u8         rs_fec_no_errors_blocks_high[0x20];
+
+        u8         rs_fec_no_errors_blocks_low[0x20];
+
+        u8         rs_fec_single_error_blocks_high[0x20];
+
+        u8         rs_fec_single_error_blocks_low[0x20];
+
+        u8         rs_fec_corrected_symbols_total_high[0x20];
+
+        u8         rs_fec_corrected_symbols_total_low[0x20];
+
+        u8         rs_fec_corrected_symbols_lane0_high[0x20];
+
+        u8         rs_fec_corrected_symbols_lane0_low[0x20];
+
+        u8         rs_fec_corrected_symbols_lane1_high[0x20];
+
+        u8         rs_fec_corrected_symbols_lane1_low[0x20];
+
+        u8         rs_fec_corrected_symbols_lane2_high[0x20];
+
+        u8         rs_fec_corrected_symbols_lane2_low[0x20];
+
+        u8         rs_fec_corrected_symbols_lane3_high[0x20];
+
+        u8         rs_fec_corrected_symbols_lane3_low[0x20];
+
+        u8         link_down_events[0x20];
+
+        u8         successful_recovery_events[0x20];
+
+        u8         reserved_0[0x180];
+};
+
+struct mlx5_ifc_eth_per_traffic_grp_data_layout_bits {
+        u8         transmit_queue_high[0x20];
+
+        u8         transmit_queue_low[0x20];
+
+        u8         reserved_0[0x780];
+};
+
+struct mlx5_ifc_eth_per_prio_grp_data_layout_bits {
+        u8         rx_octets_high[0x20];
+
+        u8         rx_octets_low[0x20];
+
+        u8         reserved_0[0xc0];
+
+        u8         rx_frames_high[0x20];
+
+        u8         rx_frames_low[0x20];
+
+        u8         tx_octets_high[0x20];
+
+        u8         tx_octets_low[0x20];
+
+        u8         reserved_1[0xc0];
+
+        u8         tx_frames_high[0x20];
+
+        u8         tx_frames_low[0x20];
+
+        u8         rx_pause_high[0x20];
+
+        u8         rx_pause_low[0x20];
+
+        u8         rx_pause_duration_high[0x20];
+
+        u8         rx_pause_duration_low[0x20];
+
+        u8         tx_pause_high[0x20];
+
+        u8         tx_pause_low[0x20];
+
+        u8         tx_pause_duration_high[0x20];
+
+        u8         tx_pause_duration_low[0x20];
+
+        u8         rx_pause_transition_high[0x20];
+
+        u8         rx_pause_transition_low[0x20];
+
+        u8         reserved_2[0x400];
+};
+
+struct mlx5_ifc_eth_extended_cntrs_grp_data_layout_bits {
+        u8         port_transmit_wait_high[0x20];
+
+        u8         port_transmit_wait_low[0x20];
+
+        u8         reserved_0[0x780];
+};
+
+struct mlx5_ifc_eth_3635_cntrs_grp_data_layout_bits {
+        u8         dot3stats_alignment_errors_high[0x20];
+
+        u8         dot3stats_alignment_errors_low[0x20];
+
+        u8         dot3stats_fcs_errors_high[0x20];
+
+        u8         dot3stats_fcs_errors_low[0x20];
+
+        u8         dot3stats_single_collision_frames_high[0x20];
+
+        u8         dot3stats_single_collision_frames_low[0x20];
+
+        u8         dot3stats_multiple_collision_frames_high[0x20];
+
+        u8         dot3stats_multiple_collision_frames_low[0x20];
+
+        u8         dot3stats_sqe_test_errors_high[0x20];
+
+        u8         dot3stats_sqe_test_errors_low[0x20];
+
+        u8         dot3stats_deferred_transmissions_high[0x20];
+
+        u8         dot3stats_deferred_transmissions_low[0x20];
+
+        u8         dot3stats_late_collisions_high[0x20];
+
+        u8         dot3stats_late_collisions_low[0x20];
+
+        u8         dot3stats_excessive_collisions_high[0x20];
+
+        u8         dot3stats_excessive_collisions_low[0x20];
+
+        u8         dot3stats_internal_mac_transmit_errors_high[0x20];
+
+        u8         dot3stats_internal_mac_transmit_errors_low[0x20];
+
+        u8         dot3stats_carrier_sense_errors_high[0x20];
+
+        u8         dot3stats_carrier_sense_errors_low[0x20];
+
+        u8         dot3stats_frame_too_longs_high[0x20];
+
+        u8         dot3stats_frame_too_longs_low[0x20];
+
+        u8         dot3stats_internal_mac_receive_errors_high[0x20];
+
+        u8         dot3stats_internal_mac_receive_errors_low[0x20];
+
+        u8         dot3stats_symbol_errors_high[0x20];
+
+        u8         dot3stats_symbol_errors_low[0x20];
+
+        u8         dot3control_in_unknown_opcodes_high[0x20];
+
+        u8         dot3control_in_unknown_opcodes_low[0x20];
+
+        u8         dot3in_pause_frames_high[0x20];
+
+        u8         dot3in_pause_frames_low[0x20];
+
+        u8         dot3out_pause_frames_high[0x20];
+
+        u8         dot3out_pause_frames_low[0x20];
+
+        u8         reserved_0[0x3c0];
+};
+
+struct mlx5_ifc_eth_2819_cntrs_grp_data_layout_bits {
+        u8         ether_stats_drop_events_high[0x20];
+
+        u8         ether_stats_drop_events_low[0x20];
+
+        u8         ether_stats_octets_high[0x20];
+
+        u8         ether_stats_octets_low[0x20];
+
+        u8         ether_stats_pkts_high[0x20];
+
+        u8         ether_stats_pkts_low[0x20];
+
+        u8         ether_stats_broadcast_pkts_high[0x20];
+
+        u8         ether_stats_broadcast_pkts_low[0x20];
+
+        u8         ether_stats_multicast_pkts_high[0x20];
+
+        u8         ether_stats_multicast_pkts_low[0x20];
+
+        u8         ether_stats_crc_align_errors_high[0x20];
+
+        u8         ether_stats_crc_align_errors_low[0x20];
+
+        u8         ether_stats_undersize_pkts_high[0x20];
+
+        u8         ether_stats_undersize_pkts_low[0x20];
+
+        u8         ether_stats_oversize_pkts_high[0x20];
+
+        u8         ether_stats_oversize_pkts_low[0x20];
+
+        u8         ether_stats_fragments_high[0x20];
+
+        u8         ether_stats_fragments_low[0x20];
+
+        u8         ether_stats_jabbers_high[0x20];
+
+        u8         ether_stats_jabbers_low[0x20];
+
+        u8         ether_stats_collisions_high[0x20];
+
+        u8         ether_stats_collisions_low[0x20];
+
+        u8         ether_stats_pkts64octets_high[0x20];
+
+        u8         ether_stats_pkts64octets_low[0x20];
+
+        u8         ether_stats_pkts65to127octets_high[0x20];
+
+        u8         ether_stats_pkts65to127octets_low[0x20];
+
+        u8         ether_stats_pkts128to255octets_high[0x20];
+
+        u8         ether_stats_pkts128to255octets_low[0x20];
+
+        u8         ether_stats_pkts256to511octets_high[0x20];
+
+        u8         ether_stats_pkts256to511octets_low[0x20];
+
+        u8         ether_stats_pkts512to1023octets_high[0x20];
+
+        u8         ether_stats_pkts512to1023octets_low[0x20];
+
+        u8         ether_stats_pkts1024to1518octets_high[0x20];
+
+        u8         ether_stats_pkts1024to1518octets_low[0x20];
+
+        u8         ether_stats_pkts1519to2047octets_high[0x20];
+
+        u8         ether_stats_pkts1519to2047octets_low[0x20];
+
+        u8         ether_stats_pkts2048to4095octets_high[0x20];
+
+        u8         ether_stats_pkts2048to4095octets_low[0x20];
+
+        u8         ether_stats_pkts4096to8191octets_high[0x20];
+
+        u8         ether_stats_pkts4096to8191octets_low[0x20];
+
+        u8         ether_stats_pkts8192to10239octets_high[0x20];
+
+        u8         ether_stats_pkts8192to10239octets_low[0x20];
+
+        u8         reserved_0[0x280];
+};
+
+struct mlx5_ifc_eth_2863_cntrs_grp_data_layout_bits {
+        u8         if_in_octets_high[0x20];
+
+        u8         if_in_octets_low[0x20];
+
+        u8         if_in_ucast_pkts_high[0x20];
+
+        u8         if_in_ucast_pkts_low[0x20];
+
+        u8         if_in_discards_high[0x20];
+
+        u8         if_in_discards_low[0x20];
+
+        u8         if_in_errors_high[0x20];
+
+        u8         if_in_errors_low[0x20];
+
+        u8         if_in_unknown_protos_high[0x20];
+
+        u8         if_in_unknown_protos_low[0x20];
+
+        u8         if_out_octets_high[0x20];
+
+        u8         if_out_octets_low[0x20];
+
+        u8         if_out_ucast_pkts_high[0x20];
+
+        u8         if_out_ucast_pkts_low[0x20];
+
+        u8         if_out_discards_high[0x20];
+
+        u8         if_out_discards_low[0x20];
+
+        u8         if_out_errors_high[0x20];
+
+        u8         if_out_errors_low[0x20];
+
+        u8         if_in_multicast_pkts_high[0x20];
+
+        u8         if_in_multicast_pkts_low[0x20];
+
+        u8         if_in_broadcast_pkts_high[0x20];
+
+        u8         if_in_broadcast_pkts_low[0x20];
+
+        u8         if_out_multicast_pkts_high[0x20];
+
+        u8         if_out_multicast_pkts_low[0x20];
+
+        u8         if_out_broadcast_pkts_high[0x20];
+
+        u8         if_out_broadcast_pkts_low[0x20];
+
+        u8         reserved_0[0x480];
+};
+
+struct mlx5_ifc_eth_802_3_cntrs_grp_data_layout_bits {
+        u8         a_frames_transmitted_ok_high[0x20];
+
+        u8         a_frames_transmitted_ok_low[0x20];
+
+        u8         a_frames_received_ok_high[0x20];
+
+        u8         a_frames_received_ok_low[0x20];
+
+        u8         a_frame_check_sequence_errors_high[0x20];
+
+        u8         a_frame_check_sequence_errors_low[0x20];
+
+        u8         a_alignment_errors_high[0x20];
+
+        u8         a_alignment_errors_low[0x20];
+
+        u8         a_octets_transmitted_ok_high[0x20];
+
+        u8         a_octets_transmitted_ok_low[0x20];
+
+        u8         a_octets_received_ok_high[0x20];
+
+        u8         a_octets_received_ok_low[0x20];
+
+        u8         a_multicast_frames_xmitted_ok_high[0x20];
+
+        u8         a_multicast_frames_xmitted_ok_low[0x20];
+
+        u8         a_broadcast_frames_xmitted_ok_high[0x20];
+
+        u8         a_broadcast_frames_xmitted_ok_low[0x20];
+
+        u8         a_multicast_frames_received_ok_high[0x20];
+
+        u8         a_multicast_frames_received_ok_low[0x20];
+
+        u8         a_broadcast_frames_received_ok_high[0x20];
+
+        u8         a_broadcast_frames_received_ok_low[0x20];
+
+        u8         a_in_range_length_errors_high[0x20];
+
+        u8         a_in_range_length_errors_low[0x20];
+
+        u8         a_out_of_range_length_field_high[0x20];
+
+        u8         a_out_of_range_length_field_low[0x20];
+
+        u8         a_frame_too_long_errors_high[0x20];
+
+        u8         a_frame_too_long_errors_low[0x20];
+
+        u8         a_symbol_error_during_carrier_high[0x20];
+
+        u8         a_symbol_error_during_carrier_low[0x20];
+
+        u8         a_mac_control_frames_transmitted_high[0x20];
+
+        u8         a_mac_control_frames_transmitted_low[0x20];
+
+        u8         a_mac_control_frames_received_high[0x20];
+
+        u8         a_mac_control_frames_received_low[0x20];
+
+        u8         a_unsupported_opcodes_received_high[0x20];
+
+        u8         a_unsupported_opcodes_received_low[0x20];
+
+        u8         a_pause_mac_ctrl_frames_received_high[0x20];
+
+        u8         a_pause_mac_ctrl_frames_received_low[0x20];
+
+        u8         a_pause_mac_ctrl_frames_transmitted_high[0x20];
+
+        u8         a_pause_mac_ctrl_frames_transmitted_low[0x20];
+
+        u8         reserved_0[0x300];
+};
+
+struct mlx5_ifc_cmd_inter_comp_event_bits {
+        u8         command_completion_vector[0x20];
+
+        u8         reserved_0[0xc0];
+};
+
+struct mlx5_ifc_stall_vl_event_bits {
+        u8         reserved_0[0x18];
+        u8         port_num[0x1];
+        u8         reserved_1[0x3];
+        u8         vl[0x4];
+
+        u8         reserved_2[0xa0];
+};
+
+struct mlx5_ifc_db_bf_congestion_event_bits {
+        u8         event_subtype[0x8];
+        u8         reserved_0[0x8];
+        u8         congestion_level[0x8];
+        u8         reserved_1[0x8];
+
+        u8         reserved_2[0xa0];
+};
+
+struct mlx5_ifc_gpio_event_bits {
+        u8         reserved_0[0x60];
+
+        u8         gpio_event_hi[0x20];
+
+        u8         gpio_event_lo[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_port_state_change_event_bits {
+        u8         reserved_0[0x40];
+
+        u8         port_num[0x4];
+        u8         reserved_1[0x1c];
+
+        u8         reserved_2[0x80];
+};
+
+struct mlx5_ifc_dropped_packet_logged_bits {
+        u8         reserved_0[0xe0];
+};
+
+enum {
+        MLX5_CQ_ERROR_SYNDROME_CQ_OVERRUN                 = 0x1,
+        MLX5_CQ_ERROR_SYNDROME_CQ_ACCESS_VIOLATION_ERROR  = 0x2,
+};
+
+struct mlx5_ifc_cq_error_bits {
+        u8         reserved_0[0x8];
+        u8         cqn[0x18];
+
+        u8         reserved_1[0x20];
+
+        u8         reserved_2[0x18];
+        u8         syndrome[0x8];
+
+        u8         reserved_3[0x80];
+};
+
+struct mlx5_ifc_rdma_page_fault_event_bits {
+        u8         bytes_committed[0x20];
+
+        u8         r_key[0x20];
+
+        u8         reserved_0[0x10];
+        u8         packet_len[0x10];
+
+        u8         rdma_op_len[0x20];
+
+        u8         rdma_va[0x40];
+
+        u8         reserved_1[0x5];
+        u8         rdma[0x1];
+        u8         write[0x1];
+        u8         requestor[0x1];
+        u8         qp_number[0x18];
+};
+
+struct mlx5_ifc_wqe_associated_page_fault_event_bits {
+        u8         bytes_committed[0x20];
+
+        u8         reserved_0[0x10];
+        u8         wqe_index[0x10];
+
+        u8         reserved_1[0x10];
+        u8         len[0x10];
+
+        u8         reserved_2[0x60];
+
+        u8         reserved_3[0x5];
+        u8         rdma[0x1];
+        u8         write_read[0x1];
+        u8         requestor[0x1];
+        u8         qpn[0x18];
+};
+
+struct mlx5_ifc_qp_events_bits {
+        u8         reserved_0[0xa0];
+
+        u8         type[0x8];
+        u8         reserved_1[0x18];
+
+        u8         reserved_2[0x8];
+        u8         qpn_rqn_sqn[0x18];
+};
+
+struct mlx5_ifc_dct_events_bits {
+        u8         reserved_0[0xc0];
+
+        u8         reserved_1[0x8];
+        u8         dct_number[0x18];
+};
+
+struct mlx5_ifc_comp_event_bits {
+        u8         reserved_0[0xc0];
+
+        u8         reserved_1[0x8];
+        u8         cq_number[0x18];
+};
+
+enum {
+        MLX5_QPC_STATE_RST        = 0x0,
+        MLX5_QPC_STATE_INIT       = 0x1,
+        MLX5_QPC_STATE_RTR        = 0x2,
+        MLX5_QPC_STATE_RTS        = 0x3,
+        MLX5_QPC_STATE_SQER       = 0x4,
+        MLX5_QPC_STATE_ERR        = 0x6,
+        MLX5_QPC_STATE_SQD        = 0x7,
+        MLX5_QPC_STATE_SUSPENDED  = 0x9,
+};
+
+enum {
+        MLX5_QPC_ST_RC            = 0x0,
+        MLX5_QPC_ST_UC            = 0x1,
+        MLX5_QPC_ST_UD            = 0x2,
+        MLX5_QPC_ST_XRC           = 0x3,
+        MLX5_QPC_ST_DCI           = 0x5,
+        MLX5_QPC_ST_QP0           = 0x7,
+        MLX5_QPC_ST_QP1           = 0x8,
+        MLX5_QPC_ST_RAW_DATAGRAM  = 0x9,
+        MLX5_QPC_ST_REG_UMR       = 0xc,
+};
+
+enum {
+        MLX5_QPC_PM_STATE_ARMED     = 0x0,
+        MLX5_QPC_PM_STATE_REARM     = 0x1,
+        MLX5_QPC_PM_STATE_RESERVED  = 0x2,
+        MLX5_QPC_PM_STATE_MIGRATED  = 0x3,
+};
+
+enum {
+        MLX5_QPC_END_PADDING_MODE_SCATTER_AS_IS                = 0x0,
+        MLX5_QPC_END_PADDING_MODE_PAD_TO_CACHE_LINE_ALIGNMENT  = 0x1,
+};
+
+enum {
+        MLX5_QPC_MTU_256_BYTES        = 0x1,
+        MLX5_QPC_MTU_512_BYTES        = 0x2,
+        MLX5_QPC_MTU_1K_BYTES         = 0x3,
+        MLX5_QPC_MTU_2K_BYTES         = 0x4,
+        MLX5_QPC_MTU_4K_BYTES         = 0x5,
+        MLX5_QPC_MTU_RAW_ETHERNET_QP  = 0x7,
+};
+
+enum {
+        MLX5_QPC_ATOMIC_MODE_IB_SPEC     = 0x1,
+        MLX5_QPC_ATOMIC_MODE_ONLY_8B     = 0x2,
+        MLX5_QPC_ATOMIC_MODE_UP_TO_8B    = 0x3,
+        MLX5_QPC_ATOMIC_MODE_UP_TO_16B   = 0x4,
+        MLX5_QPC_ATOMIC_MODE_UP_TO_32B   = 0x5,
+        MLX5_QPC_ATOMIC_MODE_UP_TO_64B   = 0x6,
+        MLX5_QPC_ATOMIC_MODE_UP_TO_128B  = 0x7,
+        MLX5_QPC_ATOMIC_MODE_UP_TO_256B  = 0x8,
+};
+
+enum {
+        MLX5_QPC_CS_REQ_DISABLE    = 0x0,
+        MLX5_QPC_CS_REQ_UP_TO_32B  = 0x11,
+        MLX5_QPC_CS_REQ_UP_TO_64B  = 0x22,
+};
+
+enum {
+        MLX5_QPC_CS_RES_DISABLE    = 0x0,
+        MLX5_QPC_CS_RES_UP_TO_32B  = 0x1,
+        MLX5_QPC_CS_RES_UP_TO_64B  = 0x2,
+};
+
+struct mlx5_ifc_qpc_bits {
+        u8         state[0x4];
+        u8         reserved_0[0x4];
+        u8         st[0x8];
+        u8         reserved_1[0x3];
+        u8         pm_state[0x2];
+        u8         reserved_2[0x7];
+        u8         end_padding_mode[0x2];
+        u8         reserved_3[0x2];
+
+        u8         wq_signature[0x1];
+        u8         block_lb_mc[0x1];
+        u8         atomic_like_write_en[0x1];
+        u8         latency_sensitive[0x1];
+        u8         reserved_4[0x1];
+        u8         drain_sigerr[0x1];
+        u8         reserved_5[0x2];
+        u8         pd[0x18];
+
+        u8         mtu[0x3];
+        u8         log_msg_max[0x5];
+        u8         reserved_6[0x1];
+        u8         log_rq_size[0x4];
+        u8         log_rq_stride[0x3];
+        u8         no_sq[0x1];
+        u8         log_sq_size[0x4];
+        u8         reserved_7[0x6];
+        u8         rlky[0x1];
+        u8         reserved_8[0x4];
+
+        u8         counter_set_id[0x8];
+        u8         uar_page[0x18];
+
+        u8         reserved_9[0x8];
+        u8         user_index[0x18];
+
+        u8         reserved_10[0x3];
+        u8         log_page_size[0x5];
+        u8         remote_qpn[0x18];
+
+        struct mlx5_ifc_ads_bits primary_address_path;
+
+        struct mlx5_ifc_ads_bits secondary_address_path;
+
+        u8         log_ack_req_freq[0x4];
+        u8         reserved_11[0x4];
+        u8         log_sra_max[0x3];
+        u8         reserved_12[0x2];
+        u8         retry_count[0x3];
+        u8         rnr_retry[0x3];
+        u8         reserved_13[0x1];
+        u8         fre[0x1];
+        u8         cur_rnr_retry[0x3];
+        u8         cur_retry_count[0x3];
+        u8         reserved_14[0x5];
+
+        u8         reserved_15[0x20];
+
+        u8         reserved_16[0x8];
+        u8         next_send_psn[0x18];
+
+        u8         reserved_17[0x8];
+        u8         cqn_snd[0x18];
+
+        u8         reserved_18[0x40];
+
+        u8         reserved_19[0x8];
+        u8         last_acked_psn[0x18];
+
+        u8         reserved_20[0x8];
+        u8         ssn[0x18];
+
+        u8         reserved_21[0x8];
+        u8         log_rra_max[0x3];
+        u8         reserved_22[0x1];
+        u8         atomic_mode[0x4];
+        u8         rre[0x1];
+        u8         rwe[0x1];
+        u8         rae[0x1];
+        u8         reserved_23[0x1];
+        u8         page_offset[0x6];
+        u8         reserved_24[0x3];
+        u8         cd_slave_receive[0x1];
+        u8         cd_slave_send[0x1];
+        u8         cd_master[0x1];
+
+        u8         reserved_25[0x3];
+        u8         min_rnr_nak[0x5];
+        u8         next_rcv_psn[0x18];
+
+        u8         reserved_26[0x8];
+        u8         xrcd[0x18];
+
+        u8         reserved_27[0x8];
+        u8         cqn_rcv[0x18];
+
+        u8         dbr_addr[0x40];
+
+        u8         q_key[0x20];
+
+        u8         reserved_28[0x5];
+        u8         rq_type[0x3];
+        u8         srqn_rmpn[0x18];
+
+        u8         reserved_29[0x8];
+        u8         rmsn[0x18];
+
+        u8         hw_sq_wqebb_counter[0x10];
+        u8         sw_sq_wqebb_counter[0x10];
+
+        u8         hw_rq_counter[0x20];
+
+        u8         sw_rq_counter[0x20];
+
+        u8         reserved_30[0x20];
+
+        u8         reserved_31[0xf];
+        u8         cgs[0x1];
+        u8         cs_req[0x8];
+        u8         cs_res[0x8];
+
+        u8         dc_access_key[0x40];
+
+        u8         reserved_32[0xc0];
+};
+
+struct mlx5_ifc_roce_addr_layout_bits {
+        u8         source_l3_address[16][0x8];
+
+        u8         reserved_0[0x3];
+        u8         vlan_valid[0x1];
+        u8         vlan_id[0xc];
+        u8         source_mac_47_32[0x10];
+
+        u8         source_mac_31_0[0x20];
+
+        u8         reserved_1[0x14];
+        u8         roce_l3_type[0x4];
+        u8         roce_version[0x8];
+
+        u8         reserved_2[0x20];
+};
+
+union mlx5_ifc_hca_cap_union_bits {
+        struct mlx5_ifc_cmd_hca_cap_bits cmd_hca_cap;
+        struct mlx5_ifc_odp_cap_bits odp_cap;
+        struct mlx5_ifc_atomic_caps_bits atomic_caps;
+        struct mlx5_ifc_roce_cap_bits roce_cap;
+        struct mlx5_ifc_per_protocol_networking_offload_caps_bits per_protocol_networking_offload_caps;
+        struct mlx5_ifc_flow_table_nic_cap_bits flow_table_nic_cap;
+        u8         reserved_0[0x8000];
+};
+
+enum {
+        MLX5_FLOW_CONTEXT_ACTION_ALLOW     = 0x1,
+        MLX5_FLOW_CONTEXT_ACTION_DROP      = 0x2,
+        MLX5_FLOW_CONTEXT_ACTION_FWD_DEST  = 0x4,
+};
+
+struct mlx5_ifc_flow_context_bits {
+        u8         reserved_0[0x20];
+
+        u8         group_id[0x20];
+
+        u8         reserved_1[0x8];
+        u8         flow_tag[0x18];
+
+        u8         reserved_2[0x10];
+        u8         action[0x10];
+
+        u8         reserved_3[0x8];
+        u8         destination_list_size[0x18];
+
+        u8         reserved_4[0x160];
+
+        struct mlx5_ifc_fte_match_param_bits match_value;
+
+        u8         reserved_5[0x600];
+
+        struct mlx5_ifc_dest_format_struct_bits destination[0];
+};
+
+enum {
+        MLX5_XRC_SRQC_STATE_GOOD   = 0x0,
+        MLX5_XRC_SRQC_STATE_ERROR  = 0x1,
+};
+
+struct mlx5_ifc_xrc_srqc_bits {
+        u8         state[0x4];
+        u8         log_xrc_srq_size[0x4];
+        u8         reserved_0[0x18];
+
+        u8         wq_signature[0x1];
+        u8         cont_srq[0x1];
+        u8         reserved_1[0x1];
+        u8         rlky[0x1];
+        u8         basic_cyclic_rcv_wqe[0x1];
+        u8         log_rq_stride[0x3];
+        u8         xrcd[0x18];
+
+        u8         page_offset[0x6];
+        u8         reserved_2[0x2];
+        u8         cqn[0x18];
+
+        u8         reserved_3[0x20];
+
+        u8         user_index_equal_xrc_srqn[0x1];
+        u8         reserved_4[0x1];
+        u8         log_page_size[0x6];
+        u8         user_index[0x18];
+
+        u8         reserved_5[0x20];
+
+        u8         reserved_6[0x8];
+        u8         pd[0x18];
+
+        u8         lwm[0x10];
+        u8         wqe_cnt[0x10];
+
+        u8         reserved_7[0x40];
+
+        u8         db_record_addr_h[0x20];
+
+        u8         db_record_addr_l[0x1e];
+        u8         reserved_8[0x2];
+
+        u8         reserved_9[0x80];
+};
+
+struct mlx5_ifc_traffic_counter_bits {
+        u8         packets[0x40];
+
+        u8         octets[0x40];
+};
+
+struct mlx5_ifc_tisc_bits {
+        u8         reserved_0[0xc];
+        u8         prio[0x4];
+        u8         reserved_1[0x10];
+
+        u8         reserved_2[0x100];
+
+        u8         reserved_3[0x8];
+        u8         transport_domain[0x18];
+
+        u8         reserved_4[0x3c0];
+};
+
+enum {
+        MLX5_TIRC_DISP_TYPE_DIRECT    = 0x0,
+        MLX5_TIRC_DISP_TYPE_INDIRECT  = 0x1,
+};
+
+enum {
+        MLX5_TIRC_LRO_ENABLE_MASK_IPV4_LRO  = 0x1,
+        MLX5_TIRC_LRO_ENABLE_MASK_IPV6_LRO  = 0x2,
+};
+
+enum {
+        MLX5_TIRC_RX_HASH_FN_HASH_NONE           = 0x0,
+        MLX5_TIRC_RX_HASH_FN_HASH_INVERTED_XOR8  = 0x1,
+        MLX5_TIRC_RX_HASH_FN_HASH_TOEPLITZ       = 0x2,
+};
+
+enum {
+        MLX5_TIRC_SELF_LB_BLOCK_BLOCK_UNICAST_    = 0x1,
+        MLX5_TIRC_SELF_LB_BLOCK_BLOCK_MULTICAST_  = 0x2,
+};
+
+struct mlx5_ifc_tirc_bits {
+        u8         reserved_0[0x20];
+
+        u8         disp_type[0x4];
+        u8         reserved_1[0x1c];
+
+        u8         reserved_2[0x40];
+
+        u8         reserved_3[0x4];
+        u8         lro_timeout_period_usecs[0x10];
+        u8         lro_enable_mask[0x4];
+        u8         lro_max_ip_payload_size[0x8];
+
+        u8         reserved_4[0x40];
+
+        u8         reserved_5[0x8];
+        u8         inline_rqn[0x18];
+
+        u8         rx_hash_symmetric[0x1];
+        u8         reserved_6[0x1];
+        u8         tunneled_offload_en[0x1];
+        u8         reserved_7[0x5];
+        u8         indirect_table[0x18];
+
+        u8         rx_hash_fn[0x4];
+        u8         reserved_8[0x2];
+        u8         self_lb_block[0x2];
+        u8         transport_domain[0x18];
+
+        u8         rx_hash_toeplitz_key[10][0x20];
+
+        struct mlx5_ifc_rx_hash_field_select_bits rx_hash_field_selector_outer;
+
+        struct mlx5_ifc_rx_hash_field_select_bits rx_hash_field_selector_inner;
+
+        u8         reserved_9[0x4c0];
+};
+
+enum {
+        MLX5_SRQC_STATE_GOOD   = 0x0,
+        MLX5_SRQC_STATE_ERROR  = 0x1,
+};
+
+struct mlx5_ifc_srqc_bits {
+        u8         state[0x4];
+        u8         log_srq_size[0x4];
+        u8         reserved_0[0x18];
+
+        u8         wq_signature[0x1];
+        u8         cont_srq[0x1];
+        u8         reserved_1[0x1];
+        u8         rlky[0x1];
+        u8         reserved_2[0x1];
+        u8         log_rq_stride[0x3];
+        u8         xrcd[0x18];
+
+        u8         page_offset[0x6];
+        u8         reserved_3[0x2];
+        u8         cqn[0x18];
+
+        u8         reserved_4[0x20];
+
+        u8         reserved_5[0x2];
+        u8         log_page_size[0x6];
+        u8         reserved_6[0x18];
+
+        u8         reserved_7[0x20];
+
+        u8         reserved_8[0x8];
+        u8         pd[0x18];
+
+        u8         lwm[0x10];
+        u8         wqe_cnt[0x10];
+
+        u8         reserved_9[0x40];
+
+        u8         dbr_addr[0x40];
+
+        u8         reserved_10[0x80];
+};
+
+enum {
+        MLX5_SQC_STATE_RST  = 0x0,
+        MLX5_SQC_STATE_RDY  = 0x1,
+        MLX5_SQC_STATE_ERR  = 0x3,
+};
+
+struct mlx5_ifc_sqc_bits {
+        u8         rlky[0x1];
+        u8         cd_master[0x1];
+        u8         fre[0x1];
+        u8         flush_in_error_en[0x1];
+        u8         reserved_0[0x4];
+        u8         state[0x4];
+        u8         reserved_1[0x14];
+
+        u8         reserved_2[0x8];
+        u8         user_index[0x18];
+
+        u8         reserved_3[0x8];
+        u8         cqn[0x18];
+
+        u8         reserved_4[0xa0];
+
+        u8         tis_lst_sz[0x10];
+        u8         reserved_5[0x10];
+
+        u8         reserved_6[0x40];
+
+        u8         reserved_7[0x8];
+        u8         tis_num_0[0x18];
+
+        struct mlx5_ifc_wq_bits wq;
+};
+
+struct mlx5_ifc_rqtc_bits {
+        u8         reserved_0[0xa0];
+
+        u8         reserved_1[0x10];
+        u8         rqt_max_size[0x10];
+
+        u8         reserved_2[0x10];
+        u8         rqt_actual_size[0x10];
+
+        u8         reserved_3[0x6a0];
+
+        struct mlx5_ifc_rq_num_bits rq_num[0];
+};
+
+enum {
+        MLX5_RQC_MEM_RQ_TYPE_MEMORY_RQ_INLINE  = 0x0,
+        MLX5_RQC_MEM_RQ_TYPE_MEMORY_RQ_RMP     = 0x1,
+};
+
+enum {
+        MLX5_RQC_STATE_RST  = 0x0,
+        MLX5_RQC_STATE_RDY  = 0x1,
+        MLX5_RQC_STATE_ERR  = 0x3,
+};
+
+struct mlx5_ifc_rqc_bits {
+        u8         rlky[0x1];
+        u8         reserved_0[0x2];
+        u8         vsd[0x1];
+        u8         mem_rq_type[0x4];
+        u8         state[0x4];
+        u8         reserved_1[0x1];
+        u8         flush_in_error_en[0x1];
+        u8         reserved_2[0x12];
+
+        u8         reserved_3[0x8];
+        u8         user_index[0x18];
+
+        u8         reserved_4[0x8];
+        u8         cqn[0x18];
+
+        u8         counter_set_id[0x8];
+        u8         reserved_5[0x18];
+
+        u8         reserved_6[0x8];
+        u8         rmpn[0x18];
+
+        u8         reserved_7[0xe0];
+
+        struct mlx5_ifc_wq_bits wq;
+};
+
+enum {
+        MLX5_RMPC_STATE_RDY  = 0x1,
+        MLX5_RMPC_STATE_ERR  = 0x3,
+};
+
+struct mlx5_ifc_rmpc_bits {
+        u8         reserved_0[0x8];
+        u8         state[0x4];
+        u8         reserved_1[0x14];
+
+        u8         basic_cyclic_rcv_wqe[0x1];
+        u8         reserved_2[0x1f];
+
+        u8         reserved_3[0x140];
+
+        struct mlx5_ifc_wq_bits wq;
+};
+
+enum {
+        MLX5_NIC_VPORT_CONTEXT_ALLOWED_LIST_TYPE_CURRENT_UC_MAC_ADDRESS  = 0x0,
+};
+
+struct mlx5_ifc_nic_vport_context_bits {
+        u8         reserved_0[0x1f];
+        u8         roce_en[0x1];
+
+        u8         reserved_1[0x760];
+
+        u8         reserved_2[0x5];
+        u8         allowed_list_type[0x3];
+        u8         reserved_3[0xc];
+        u8         allowed_list_size[0xc];
+
+        struct mlx5_ifc_mac_address_layout_bits permanent_address;
+
+        u8         reserved_4[0x20];
+
+        u8         current_uc_mac_address[0][0x40];
+};
+
+enum {
+        MLX5_MKC_ACCESS_MODE_PA    = 0x0,
+        MLX5_MKC_ACCESS_MODE_MTT   = 0x1,
+        MLX5_MKC_ACCESS_MODE_KLMS  = 0x2,
+};
+
+struct mlx5_ifc_mkc_bits {
+        u8         reserved_0[0x1];
+        u8         free[0x1];
+        u8         reserved_1[0xd];
+        u8         small_fence_on_rdma_read_response[0x1];
+        u8         umr_en[0x1];
+        u8         a[0x1];
+        u8         rw[0x1];
+        u8         rr[0x1];
+        u8         lw[0x1];
+        u8         lr[0x1];
+        u8         access_mode[0x2];
+        u8         reserved_2[0x8];
+
+        u8         qpn[0x18];
+        u8         mkey_7_0[0x8];
+
+        u8         reserved_3[0x20];
+
+        u8         length64[0x1];
+        u8         bsf_en[0x1];
+        u8         sync_umr[0x1];
+        u8         reserved_4[0x2];
+        u8         expected_sigerr_count[0x1];
+        u8         reserved_5[0x1];
+        u8         en_rinval[0x1];
+        u8         pd[0x18];
+
+        u8         start_addr[0x40];
+
+        u8         len[0x40];
+
+        u8         bsf_octword_size[0x20];
+
+        u8         reserved_6[0x80];
+
+        u8         translations_octword_size[0x20];
+
+        u8         reserved_7[0x1b];
+        u8         log_page_size[0x5];
+
+        u8         reserved_8[0x20];
+};
+
+struct mlx5_ifc_pkey_bits {
+        u8         reserved_0[0x10];
+        u8         pkey[0x10];
+};
+
+struct mlx5_ifc_array128_auto_bits {
+        u8         array128_auto[16][0x8];
+};
+
+struct mlx5_ifc_hca_vport_context_bits {
+        u8         field_select[0x20];
+
+        u8         reserved_0[0xe0];
+
+        u8         sm_virt_aware[0x1];
+        u8         has_smi[0x1];
+        u8         has_raw[0x1];
+        u8         grh_required[0x1];
+        u8         reserved_1[0xc];
+        u8         port_physical_state[0x4];
+        u8         vport_state_policy[0x4];
+        u8         port_state[0x4];
+        u8         vport_state[0x4];
+
+        u8         reserved_2[0x20];
+
+        u8         system_image_guid[0x40];
+
+        u8         port_guid[0x40];
+
+        u8         node_guid[0x40];
+
+        u8         cap_mask1[0x20];
+
+        u8         cap_mask1_field_select[0x20];
+
+        u8         cap_mask2[0x20];
+
+        u8         cap_mask2_field_select[0x20];
+
+        u8         reserved_3[0x80];
+
+        u8         lid[0x10];
+        u8         reserved_4[0x4];
+        u8         init_type_reply[0x4];
+        u8         lmc[0x3];
+        u8         subnet_timeout[0x5];
+
+        u8         sm_lid[0x10];
+        u8         sm_sl[0x4];
+        u8         reserved_5[0xc];
+
+        u8         qkey_violation_counter[0x10];
+        u8         pkey_violation_counter[0x10];
+
+        u8         reserved_6[0xca0];
+};
+
+enum {
+        MLX5_EQC_STATUS_OK                = 0x0,
+        MLX5_EQC_STATUS_EQ_WRITE_FAILURE  = 0xa,
+};
+
+enum {
+        MLX5_EQC_ST_ARMED  = 0x9,
+        MLX5_EQC_ST_FIRED  = 0xa,
+};
+
+struct mlx5_ifc_eqc_bits {
+        u8         status[0x4];
+        u8         reserved_0[0x9];
+        u8         ec[0x1];
+        u8         oi[0x1];
+        u8         reserved_1[0x5];
+        u8         st[0x4];
+        u8         reserved_2[0x8];
+
+        u8         reserved_3[0x20];
+
+        u8         reserved_4[0x14];
+        u8         page_offset[0x6];
+        u8         reserved_5[0x6];
+
+        u8         reserved_6[0x3];
+        u8         log_eq_size[0x5];
+        u8         uar_page[0x18];
+
+        u8         reserved_7[0x20];
+
+        u8         reserved_8[0x18];
+        u8         intr[0x8];
+
+        u8         reserved_9[0x3];
+        u8         log_page_size[0x5];
+        u8         reserved_10[0x18];
+
+        u8         reserved_11[0x60];
+
+        u8         reserved_12[0x8];
+        u8         consumer_counter[0x18];
+
+        u8         reserved_13[0x8];
+        u8         producer_counter[0x18];
+
+        u8         reserved_14[0x80];
+};
+
+enum {
+        MLX5_DCTC_STATE_ACTIVE    = 0x0,
+        MLX5_DCTC_STATE_DRAINING  = 0x1,
+        MLX5_DCTC_STATE_DRAINED   = 0x2,
+};
+
+enum {
+        MLX5_DCTC_CS_RES_DISABLE    = 0x0,
+        MLX5_DCTC_CS_RES_NA         = 0x1,
+        MLX5_DCTC_CS_RES_UP_TO_64B  = 0x2,
+};
+
+enum {
+        MLX5_DCTC_MTU_256_BYTES  = 0x1,
+        MLX5_DCTC_MTU_512_BYTES  = 0x2,
+        MLX5_DCTC_MTU_1K_BYTES   = 0x3,
+        MLX5_DCTC_MTU_2K_BYTES   = 0x4,
+        MLX5_DCTC_MTU_4K_BYTES   = 0x5,
+};
+
+struct mlx5_ifc_dctc_bits {
+        u8         reserved_0[0x4];
+        u8         state[0x4];
+        u8         reserved_1[0x18];
+
+        u8         reserved_2[0x8];
+        u8         user_index[0x18];
+
+        u8         reserved_3[0x8];
+        u8         cqn[0x18];
+
+        u8         counter_set_id[0x8];
+        u8         atomic_mode[0x4];
+        u8         rre[0x1];
+        u8         rwe[0x1];
+        u8         rae[0x1];
+        u8         atomic_like_write_en[0x1];
+        u8         latency_sensitive[0x1];
+        u8         rlky[0x1];
+        u8         free_ar[0x1];
+        u8         reserved_4[0xd];
+
+        u8         reserved_5[0x8];
+        u8         cs_res[0x8];
+        u8         reserved_6[0x3];
+        u8         min_rnr_nak[0x5];
+        u8         reserved_7[0x8];
+
+        u8         reserved_8[0x8];
+        u8         srqn[0x18];
+
+        u8         reserved_9[0x8];
+        u8         pd[0x18];
+
+        u8         tclass[0x8];
+        u8         reserved_10[0x4];
+        u8         flow_label[0x14];
+
+        u8         dc_access_key[0x40];
+
+        u8         reserved_11[0x5];
+        u8         mtu[0x3];
+        u8         port[0x8];
+        u8         pkey_index[0x10];
+
+        u8         reserved_12[0x8];
+        u8         my_addr_index[0x8];
+        u8         reserved_13[0x8];
+        u8         hop_limit[0x8];
+
+        u8         dc_access_key_violation_count[0x20];
+
+        u8         reserved_14[0x14];
+        u8         dei_cfi[0x1];
+        u8         eth_prio[0x3];
+        u8         ecn[0x2];
+        u8         dscp[0x6];
+
+        u8         reserved_15[0x40];
+};
+
+enum {
+        MLX5_CQC_STATUS_OK             = 0x0,
+        MLX5_CQC_STATUS_CQ_OVERFLOW    = 0x9,
+        MLX5_CQC_STATUS_CQ_WRITE_FAIL  = 0xa,
+};
+
+enum {
+        MLX5_CQC_CQE_SZ_64_BYTES   = 0x0,
+        MLX5_CQC_CQE_SZ_128_BYTES  = 0x1,
+};
+
+enum {
+        MLX5_CQC_ST_SOLICITED_NOTIFICATION_REQUEST_ARMED  = 0x6,
+        MLX5_CQC_ST_NOTIFICATION_REQUEST_ARMED            = 0x9,
+        MLX5_CQC_ST_FIRED                                 = 0xa,
+};
+
+struct mlx5_ifc_cqc_bits {
+        u8         status[0x4];
+        u8         reserved_0[0x4];
+        u8         cqe_sz[0x3];
+        u8         cc[0x1];
+        u8         reserved_1[0x1];
+        u8         scqe_break_moderation_en[0x1];
+        u8         oi[0x1];
+        u8         reserved_2[0x2];
+        u8         cqe_zip_en[0x1];
+        u8         mini_cqe_res_format[0x2];
+        u8         st[0x4];
+        u8         reserved_3[0x8];
+
+        u8         reserved_4[0x20];
+
+        u8         reserved_5[0x14];
+        u8         page_offset[0x6];
+        u8         reserved_6[0x6];
+
+        u8         reserved_7[0x3];
+        u8         log_cq_size[0x5];
+        u8         uar_page[0x18];
+
+        u8         reserved_8[0x4];
+        u8         cq_period[0xc];
+        u8         cq_max_count[0x10];
+
+        u8         reserved_9[0x18];
+        u8         c_eqn[0x8];
+
+        u8         reserved_10[0x3];
+        u8         log_page_size[0x5];
+        u8         reserved_11[0x18];
+
+        u8         reserved_12[0x20];
+
+        u8         reserved_13[0x8];
+        u8         last_notified_index[0x18];
+
+        u8         reserved_14[0x8];
+        u8         last_solicit_index[0x18];
+
+        u8         reserved_15[0x8];
+        u8         consumer_counter[0x18];
+
+        u8         reserved_16[0x8];
+        u8         producer_counter[0x18];
+
+        u8         reserved_17[0x40];
+
+        u8         dbr_addr[0x40];
+};
+
+union mlx5_ifc_cong_control_roce_ecn_auto_bits {
+        struct mlx5_ifc_cong_control_802_1qau_rp_bits cong_control_802_1qau_rp;
+        struct mlx5_ifc_cong_control_r_roce_ecn_rp_bits cong_control_r_roce_ecn_rp;
+        struct mlx5_ifc_cong_control_r_roce_ecn_np_bits cong_control_r_roce_ecn_np;
+        u8         reserved_0[0x800];
+};
+
+struct mlx5_ifc_query_adapter_param_block_bits {
+        u8         reserved_0[0xc0];
+
+        u8         reserved_1[0x8];
+        u8         ieee_vendor_id[0x18];
+
+        u8         reserved_2[0x10];
+        u8         vsd_vendor_id[0x10];
+
+        u8         vsd[208][0x8];
+
+        u8         vsd_contd_psid[16][0x8];
+};
+
+union mlx5_ifc_modify_field_select_resize_field_select_auto_bits {
+        struct mlx5_ifc_modify_field_select_bits modify_field_select;
+        struct mlx5_ifc_resize_field_select_bits resize_field_select;
+        u8         reserved_0[0x20];
+};
+
+union mlx5_ifc_field_select_802_1_r_roce_auto_bits {
+        struct mlx5_ifc_field_select_802_1qau_rp_bits field_select_802_1qau_rp;
+        struct mlx5_ifc_field_select_r_roce_rp_bits field_select_r_roce_rp;
+        struct mlx5_ifc_field_select_r_roce_np_bits field_select_r_roce_np;
+        u8         reserved_0[0x20];
+};
+
+union mlx5_ifc_eth_cntrs_grp_data_layout_auto_bits {
+        struct mlx5_ifc_eth_802_3_cntrs_grp_data_layout_bits eth_802_3_cntrs_grp_data_layout;
+        struct mlx5_ifc_eth_2863_cntrs_grp_data_layout_bits eth_2863_cntrs_grp_data_layout;
+        struct mlx5_ifc_eth_2819_cntrs_grp_data_layout_bits eth_2819_cntrs_grp_data_layout;
+        struct mlx5_ifc_eth_3635_cntrs_grp_data_layout_bits eth_3635_cntrs_grp_data_layout;
+        struct mlx5_ifc_eth_extended_cntrs_grp_data_layout_bits eth_extended_cntrs_grp_data_layout;
+        struct mlx5_ifc_eth_per_prio_grp_data_layout_bits eth_per_prio_grp_data_layout;
+        struct mlx5_ifc_eth_per_traffic_grp_data_layout_bits eth_per_traffic_grp_data_layout;
+        struct mlx5_ifc_phys_layer_cntrs_bits phys_layer_cntrs;
+        u8         reserved_0[0x7c0];
+};
+
+union mlx5_ifc_event_auto_bits {
+        struct mlx5_ifc_comp_event_bits comp_event;
+        struct mlx5_ifc_dct_events_bits dct_events;
+        struct mlx5_ifc_qp_events_bits qp_events;
+        struct mlx5_ifc_wqe_associated_page_fault_event_bits wqe_associated_page_fault_event;
+        struct mlx5_ifc_rdma_page_fault_event_bits rdma_page_fault_event;
+        struct mlx5_ifc_cq_error_bits cq_error;
+        struct mlx5_ifc_dropped_packet_logged_bits dropped_packet_logged;
+        struct mlx5_ifc_port_state_change_event_bits port_state_change_event;
+        struct mlx5_ifc_gpio_event_bits gpio_event;
+        struct mlx5_ifc_db_bf_congestion_event_bits db_bf_congestion_event;
+        struct mlx5_ifc_stall_vl_event_bits stall_vl_event;
+        struct mlx5_ifc_cmd_inter_comp_event_bits cmd_inter_comp_event;
+        u8         reserved_0[0xe0];
+};
+
+struct mlx5_ifc_health_buffer_bits {
+        u8         reserved_0[0x100];
+
+        u8         assert_existptr[0x20];
+
+        u8         assert_callra[0x20];
+
+        u8         reserved_1[0x40];
+
+        u8         fw_version[0x20];
+
+        u8         hw_id[0x20];
+
+        u8         reserved_2[0x20];
+
+        u8         irisc_index[0x8];
+        u8         synd[0x8];
+        u8         ext_synd[0x10];
+};
+
+struct mlx5_ifc_register_loopback_control_bits {
+        u8         no_lb[0x1];
+        u8         reserved_0[0x7];
+        u8         port[0x8];
+        u8         reserved_1[0x10];
+
+        u8         reserved_2[0x60];
+};
+
+struct mlx5_ifc_teardown_hca_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+enum {
+        MLX5_TEARDOWN_HCA_IN_PROFILE_GRACEFUL_CLOSE  = 0x0,
+        MLX5_TEARDOWN_HCA_IN_PROFILE_PANIC_CLOSE     = 0x1,
+};
+
+struct mlx5_ifc_teardown_hca_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x10];
+        u8         profile[0x10];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_sqerr2rts_qp_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_sqerr2rts_qp_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         qpn[0x18];
+
+        u8         reserved_3[0x20];
+
+        u8         opt_param_mask[0x20];
+
+        u8         reserved_4[0x20];
+
+        struct mlx5_ifc_qpc_bits qpc;
+
+        u8         reserved_5[0x80];
+};
+
+struct mlx5_ifc_sqd2rts_qp_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_sqd2rts_qp_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         qpn[0x18];
+
+        u8         reserved_3[0x20];
+
+        u8         opt_param_mask[0x20];
+
+        u8         reserved_4[0x20];
+
+        struct mlx5_ifc_qpc_bits qpc;
+
+        u8         reserved_5[0x80];
+};
+
+struct mlx5_ifc_set_roce_address_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_set_roce_address_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         roce_address_index[0x10];
+        u8         reserved_2[0x10];
+
+        u8         reserved_3[0x20];
+
+        struct mlx5_ifc_roce_addr_layout_bits roce_address;
+};
+
+struct mlx5_ifc_set_mad_demux_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+enum {
+        MLX5_SET_MAD_DEMUX_IN_DEMUX_MODE_PASS_ALL   = 0x0,
+        MLX5_SET_MAD_DEMUX_IN_DEMUX_MODE_SELECTIVE  = 0x2,
+};
+
+struct mlx5_ifc_set_mad_demux_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x20];
+
+        u8         reserved_3[0x6];
+        u8         demux_mode[0x2];
+        u8         reserved_4[0x18];
+};
+
+struct mlx5_ifc_set_l2_table_entry_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_set_l2_table_entry_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x60];
+
+        u8         reserved_3[0x8];
+        u8         table_index[0x18];
+
+        u8         reserved_4[0x20];
+
+        u8         reserved_5[0x13];
+        u8         vlan_valid[0x1];
+        u8         vlan[0xc];
+
+        struct mlx5_ifc_mac_address_layout_bits mac_address;
+
+        u8         reserved_6[0xc0];
+};
+
+struct mlx5_ifc_set_issi_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_set_issi_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x10];
+        u8         current_issi[0x10];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_set_hca_cap_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
 };
 
 struct mlx5_ifc_set_hca_cap_in_bits {
@@ -313,10 +2764,653 @@ struct mlx5_ifc_set_hca_cap_in_bits {
 
         u8         reserved_2[0x40];
 
-        struct mlx5_ifc_cmd_hca_cap_bits hca_capability_struct;
+        union mlx5_ifc_hca_cap_union_bits capability;
 };
 
-struct mlx5_ifc_query_hca_cap_in_bits {
+struct mlx5_ifc_set_fte_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_set_fte_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+
+        u8         table_type[0x8];
+        u8         reserved_3[0x18];
+
+        u8         reserved_4[0x8];
+        u8         table_id[0x18];
+
+        u8         reserved_5[0x40];
+
+        u8         flow_index[0x20];
+
+        u8         reserved_6[0xe0];
+
+        struct mlx5_ifc_flow_context_bits flow_context;
+};
+
+struct mlx5_ifc_rts2rts_qp_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_rts2rts_qp_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         qpn[0x18];
+
+        u8         reserved_3[0x20];
+
+        u8         opt_param_mask[0x20];
+
+        u8         reserved_4[0x20];
+
+        struct mlx5_ifc_qpc_bits qpc;
+
+        u8         reserved_5[0x80];
+};
+
+struct mlx5_ifc_rtr2rts_qp_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_rtr2rts_qp_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         qpn[0x18];
+
+        u8         reserved_3[0x20];
+
+        u8         opt_param_mask[0x20];
+
+        u8         reserved_4[0x20];
+
+        struct mlx5_ifc_qpc_bits qpc;
+
+        u8         reserved_5[0x80];
+};
+
+struct mlx5_ifc_rst2init_qp_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_rst2init_qp_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         qpn[0x18];
+
+        u8         reserved_3[0x20];
+
+        u8         opt_param_mask[0x20];
+
+        u8         reserved_4[0x20];
+
+        struct mlx5_ifc_qpc_bits qpc;
+
+        u8         reserved_5[0x80];
+};
+
+struct mlx5_ifc_query_xrc_srq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        struct mlx5_ifc_xrc_srqc_bits xrc_srq_context_entry;
+
+        u8         reserved_2[0x600];
+
+        u8         pas[0][0x40];
+};
+
+struct mlx5_ifc_query_xrc_srq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         xrc_srqn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+enum {
+        MLX5_QUERY_VPORT_STATE_OUT_STATE_DOWN  = 0x0,
+        MLX5_QUERY_VPORT_STATE_OUT_STATE_UP    = 0x1,
+};
+
+struct mlx5_ifc_query_vport_state_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x20];
+
+        u8         reserved_2[0x18];
+        u8         admin_state[0x4];
+        u8         state[0x4];
+};
+
+enum {
+        MLX5_QUERY_VPORT_STATE_IN_OP_MOD_VNIC_VPORT  = 0x0,
+};
+
+struct mlx5_ifc_query_vport_state_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         other_vport[0x1];
+        u8         reserved_2[0xf];
+        u8         vport_number[0x10];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_vport_counter_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        struct mlx5_ifc_traffic_counter_bits received_errors;
+
+        struct mlx5_ifc_traffic_counter_bits transmit_errors;
+
+        struct mlx5_ifc_traffic_counter_bits received_ib_unicast;
+
+        struct mlx5_ifc_traffic_counter_bits transmitted_ib_unicast;
+
+        struct mlx5_ifc_traffic_counter_bits received_ib_multicast;
+
+        struct mlx5_ifc_traffic_counter_bits transmitted_ib_multicast;
+
+        struct mlx5_ifc_traffic_counter_bits received_eth_broadcast;
+
+        struct mlx5_ifc_traffic_counter_bits transmitted_eth_broadcast;
+
+        struct mlx5_ifc_traffic_counter_bits received_eth_unicast;
+
+        struct mlx5_ifc_traffic_counter_bits transmitted_eth_unicast;
+
+        struct mlx5_ifc_traffic_counter_bits received_eth_multicast;
+
+        struct mlx5_ifc_traffic_counter_bits transmitted_eth_multicast;
+
+        u8         reserved_2[0xa00];
+};
+
+enum {
+        MLX5_QUERY_VPORT_COUNTER_IN_OP_MOD_VPORT_COUNTERS  = 0x0,
+};
+
+struct mlx5_ifc_query_vport_counter_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         other_vport[0x1];
+        u8         reserved_2[0xf];
+        u8         vport_number[0x10];
+
+        u8         reserved_3[0x60];
+
+        u8         clear[0x1];
+        u8         reserved_4[0x1f];
+
+        u8         reserved_5[0x20];
+};
+
+struct mlx5_ifc_query_tis_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        struct mlx5_ifc_tisc_bits tis_context;
+};
+
+struct mlx5_ifc_query_tis_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         tisn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_tir_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0xc0];
+
+        struct mlx5_ifc_tirc_bits tir_context;
+};
+
+struct mlx5_ifc_query_tir_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         tirn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_srq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        struct mlx5_ifc_srqc_bits srq_context_entry;
+
+        u8         reserved_2[0x600];
+
+        u8         pas[0][0x40];
+};
+
+struct mlx5_ifc_query_srq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         srqn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_sq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0xc0];
+
+        struct mlx5_ifc_sqc_bits sq_context;
+};
+
+struct mlx5_ifc_query_sq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         sqn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_special_contexts_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x20];
+
+        u8         resd_lkey[0x20];
+};
+
+struct mlx5_ifc_query_special_contexts_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+};
+
+struct mlx5_ifc_query_rqt_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0xc0];
+
+        struct mlx5_ifc_rqtc_bits rqt_context;
+};
+
+struct mlx5_ifc_query_rqt_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         rqtn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_rq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0xc0];
+
+        struct mlx5_ifc_rqc_bits rq_context;
+};
+
+struct mlx5_ifc_query_rq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         rqn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_roce_address_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        struct mlx5_ifc_roce_addr_layout_bits roce_address;
+};
+
+struct mlx5_ifc_query_roce_address_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         roce_address_index[0x10];
+        u8         reserved_2[0x10];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_rmp_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0xc0];
+
+        struct mlx5_ifc_rmpc_bits rmp_context;
+};
+
+struct mlx5_ifc_query_rmp_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         rmpn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_qp_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        u8         opt_param_mask[0x20];
+
+        u8         reserved_2[0x20];
+
+        struct mlx5_ifc_qpc_bits qpc;
+
+        u8         reserved_3[0x80];
+
+        u8         pas[0][0x40];
+};
+
+struct mlx5_ifc_query_qp_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         qpn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_q_counter_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        u8         rx_write_requests[0x20];
+
+        u8         reserved_2[0x20];
+
+        u8         rx_read_requests[0x20];
+
+        u8         reserved_3[0x20];
+
+        u8         rx_atomic_requests[0x20];
+
+        u8         reserved_4[0x20];
+
+        u8         rx_dct_connect[0x20];
+
+        u8         reserved_5[0x20];
+
+        u8         out_of_buffer[0x20];
+
+        u8         reserved_6[0x20];
+
+        u8         out_of_sequence[0x20];
+
+        u8         reserved_7[0x620];
+};
+
+struct mlx5_ifc_query_q_counter_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x80];
+
+        u8         clear[0x1];
+        u8         reserved_3[0x1f];
+
+        u8         reserved_4[0x18];
+        u8         counter_set_id[0x8];
+};
+
+struct mlx5_ifc_query_pages_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x10];
+        u8         function_id[0x10];
+
+        u8         num_pages[0x20];
+};
+
+enum {
+        MLX5_QUERY_PAGES_IN_OP_MOD_BOOT_PAGES     = 0x1,
+        MLX5_QUERY_PAGES_IN_OP_MOD_INIT_PAGES     = 0x2,
+        MLX5_QUERY_PAGES_IN_OP_MOD_REGULAR_PAGES  = 0x3,
+};
+
+struct mlx5_ifc_query_pages_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x10];
+        u8         function_id[0x10];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_nic_vport_context_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        struct mlx5_ifc_nic_vport_context_bits nic_vport_context;
+};
+
+struct mlx5_ifc_query_nic_vport_context_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         other_vport[0x1];
+        u8         reserved_2[0xf];
+        u8         vport_number[0x10];
+
+        u8         reserved_3[0x5];
+        u8         allowed_list_type[0x3];
+        u8         reserved_4[0x18];
+};
+
+struct mlx5_ifc_query_mkey_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        struct mlx5_ifc_mkc_bits memory_key_mkey_entry;
+
+        u8         reserved_2[0x600];
+
+        u8         bsf0_klm0_pas_mtt0_1[16][0x8];
+
+        u8         bsf1_klm1_pas_mtt2_3[16][0x8];
+};
+
+struct mlx5_ifc_query_mkey_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         mkey_index[0x18];
+
+        u8         pg_access[0x1];
+        u8         reserved_3[0x1f];
+};
+
+struct mlx5_ifc_query_mad_demux_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        u8         mad_dumux_parameters_block[0x20];
+};
+
+struct mlx5_ifc_query_mad_demux_in_bits {
         u8         opcode[0x10];
         u8         reserved_0[0x10];
 
@@ -326,6 +3420,146 @@ struct mlx5_ifc_query_hca_cap_in_bits {
         u8         reserved_2[0x40];
 };
 
+struct mlx5_ifc_query_l2_table_entry_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0xa0];
+
+        u8         reserved_2[0x13];
+        u8         vlan_valid[0x1];
+        u8         vlan[0xc];
+
+        struct mlx5_ifc_mac_address_layout_bits mac_address;
+
+        u8         reserved_3[0xc0];
+};
+
+struct mlx5_ifc_query_l2_table_entry_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x60];
+
+        u8         reserved_3[0x8];
+        u8         table_index[0x18];
+
+        u8         reserved_4[0x140];
+};
+
+struct mlx5_ifc_query_issi_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x10];
+        u8         current_issi[0x10];
+
+        u8         reserved_2[0xa0];
+
+        u8         supported_issi_reserved[76][0x8];
+        u8         supported_issi_dw0[0x20];
+};
+
+struct mlx5_ifc_query_issi_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+};
+
+struct mlx5_ifc_query_hca_vport_pkey_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        struct mlx5_ifc_pkey_bits pkey[0];
+};
+
+struct mlx5_ifc_query_hca_vport_pkey_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         other_vport[0x1];
+        u8         reserved_2[0xb];
+        u8         port_num[0x4];
+        u8         vport_number[0x10];
+
+        u8         reserved_3[0x10];
+        u8         pkey_index[0x10];
+};
+
+struct mlx5_ifc_query_hca_vport_gid_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x20];
+
+        u8         gids_num[0x10];
+        u8         reserved_2[0x10];
+
+        struct mlx5_ifc_array128_auto_bits gid[0];
+};
+
+struct mlx5_ifc_query_hca_vport_gid_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         other_vport[0x1];
+        u8         reserved_2[0xb];
+        u8         port_num[0x4];
+        u8         vport_number[0x10];
+
+        u8         reserved_3[0x10];
+        u8         gid_index[0x10];
+};
+
+struct mlx5_ifc_query_hca_vport_context_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        struct mlx5_ifc_hca_vport_context_bits hca_vport_context;
+};
+
+struct mlx5_ifc_query_hca_vport_context_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         other_vport[0x1];
+        u8         reserved_2[0xb];
+        u8         port_num[0x4];
+        u8         vport_number[0x10];
+
+        u8         reserved_3[0x20];
+};
+
 struct mlx5_ifc_query_hca_cap_out_bits {
         u8         status[0x8];
         u8         reserved_0[0x18];
@@ -334,16 +3568,3216 @@ struct mlx5_ifc_query_hca_cap_out_bits {
 
         u8         reserved_1[0x40];
 
-        u8         capability_struct[256][0x8];
+        union mlx5_ifc_hca_cap_union_bits capability;
 };
 
-struct mlx5_ifc_set_hca_cap_out_bits {
+struct mlx5_ifc_query_hca_cap_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+};
+
+struct mlx5_ifc_query_flow_table_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x80];
+
+        u8         reserved_2[0x8];
+        u8         level[0x8];
+        u8         reserved_3[0x8];
+        u8         log_size[0x8];
+
+        u8         reserved_4[0x120];
+};
+
+struct mlx5_ifc_query_flow_table_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+
+        u8         table_type[0x8];
+        u8         reserved_3[0x18];
+
+        u8         reserved_4[0x8];
+        u8         table_id[0x18];
+
+        u8         reserved_5[0x140];
+};
+
+struct mlx5_ifc_query_fte_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x1c0];
+
+        struct mlx5_ifc_flow_context_bits flow_context;
+};
+
+struct mlx5_ifc_query_fte_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+
+        u8         table_type[0x8];
+        u8         reserved_3[0x18];
+
+        u8         reserved_4[0x8];
+        u8         table_id[0x18];
+
+        u8         reserved_5[0x40];
+
+        u8         flow_index[0x20];
+
+        u8         reserved_6[0xe0];
+};
+
+enum {
+        MLX5_QUERY_FLOW_GROUP_OUT_MATCH_CRITERIA_ENABLE_OUTER_HEADERS    = 0x0,
+        MLX5_QUERY_FLOW_GROUP_OUT_MATCH_CRITERIA_ENABLE_MISC_PARAMETERS  = 0x1,
+        MLX5_QUERY_FLOW_GROUP_OUT_MATCH_CRITERIA_ENABLE_INNER_HEADERS    = 0x2,
+};
+
+struct mlx5_ifc_query_flow_group_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0xa0];
+
+        u8         start_flow_index[0x20];
+
+        u8         reserved_2[0x20];
+
+        u8         end_flow_index[0x20];
+
+        u8         reserved_3[0xa0];
+
+        u8         reserved_4[0x18];
+        u8         match_criteria_enable[0x8];
+
+        struct mlx5_ifc_fte_match_param_bits match_criteria;
+
+        u8         reserved_5[0xe00];
+};
+
+struct mlx5_ifc_query_flow_group_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+
+        u8         table_type[0x8];
+        u8         reserved_3[0x18];
+
+        u8         reserved_4[0x8];
+        u8         table_id[0x18];
+
+        u8         group_id[0x20];
+
+        u8         reserved_5[0x120];
+};
+
+struct mlx5_ifc_query_eq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        struct mlx5_ifc_eqc_bits eq_context_entry;
+
+        u8         reserved_2[0x40];
+
+        u8         event_bitmask[0x40];
+
+        u8         reserved_3[0x580];
+
+        u8         pas[0][0x40];
+};
+
+struct mlx5_ifc_query_eq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x18];
+        u8         eq_number[0x8];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_dct_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        struct mlx5_ifc_dctc_bits dct_context_entry;
+
+        u8         reserved_2[0x180];
+};
+
+struct mlx5_ifc_query_dct_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         dctn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_cq_out_bits {
         u8         status[0x8];
         u8         reserved_0[0x18];
 
         u8         syndrome[0x20];
 
         u8         reserved_1[0x40];
+
+        struct mlx5_ifc_cqc_bits cq_context;
+
+        u8         reserved_2[0x600];
+
+        u8         pas[0][0x40];
+};
+
+struct mlx5_ifc_query_cq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         cqn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_cong_status_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x20];
+
+        u8         enable[0x1];
+        u8         tag_enable[0x1];
+        u8         reserved_2[0x1e];
+};
+
+struct mlx5_ifc_query_cong_status_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x18];
+        u8         priority[0x4];
+        u8         cong_protocol[0x4];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_cong_statistics_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        u8         cur_flows[0x20];
+
+        u8         sum_flows[0x20];
+
+        u8         cnp_ignored_high[0x20];
+
+        u8         cnp_ignored_low[0x20];
+
+        u8         cnp_handled_high[0x20];
+
+        u8         cnp_handled_low[0x20];
+
+        u8         reserved_2[0x100];
+
+        u8         time_stamp_high[0x20];
+
+        u8         time_stamp_low[0x20];
+
+        u8         accumulators_period[0x20];
+
+        u8         ecn_marked_roce_packets_high[0x20];
+
+        u8         ecn_marked_roce_packets_low[0x20];
+
+        u8         cnps_sent_high[0x20];
+
+        u8         cnps_sent_low[0x20];
+
+        u8         reserved_3[0x560];
+};
+
+struct mlx5_ifc_query_cong_statistics_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         clear[0x1];
+        u8         reserved_2[0x1f];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_cong_params_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        union mlx5_ifc_cong_control_roce_ecn_auto_bits congestion_parameters;
+};
+
+struct mlx5_ifc_query_cong_params_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x1c];
+        u8         cong_protocol[0x4];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_adapter_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        struct mlx5_ifc_query_adapter_param_block_bits query_adapter_struct;
+};
+
+struct mlx5_ifc_query_adapter_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+};
+
+struct mlx5_ifc_qp_2rst_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_qp_2rst_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         qpn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_qp_2err_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_qp_2err_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         qpn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_page_fault_resume_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_page_fault_resume_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         error[0x1];
+        u8         reserved_2[0x4];
+        u8         rdma[0x1];
+        u8         read_write[0x1];
+        u8         req_res[0x1];
+        u8         qpn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_nop_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_nop_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+};
+
+struct mlx5_ifc_modify_vport_state_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_modify_vport_state_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         other_vport[0x1];
+        u8         reserved_2[0xf];
+        u8         vport_number[0x10];
+
+        u8         reserved_3[0x18];
+        u8         admin_state[0x4];
+        u8         reserved_4[0x4];
+};
+
+struct mlx5_ifc_modify_tis_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_modify_tis_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         tisn[0x18];
+
+        u8         reserved_3[0x20];
+
+        u8         modify_bitmask[0x40];
+
+        u8         reserved_4[0x40];
+
+        struct mlx5_ifc_tisc_bits ctx;
+};
+
+struct mlx5_ifc_modify_tir_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_modify_tir_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         tirn[0x18];
+
+        u8         reserved_3[0x20];
+
+        u8         modify_bitmask[0x40];
+
+        u8         reserved_4[0x40];
+
+        struct mlx5_ifc_tirc_bits ctx;
+};
+
+struct mlx5_ifc_modify_sq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_modify_sq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         sq_state[0x4];
+        u8         reserved_2[0x4];
+        u8         sqn[0x18];
+
+        u8         reserved_3[0x20];
+
+        u8         modify_bitmask[0x40];
+
+        u8         reserved_4[0x40];
+
+        struct mlx5_ifc_sqc_bits ctx;
+};
+
+struct mlx5_ifc_modify_rqt_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_modify_rqt_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         rqtn[0x18];
+
+        u8         reserved_3[0x20];
+
+        u8         modify_bitmask[0x40];
+
+        u8         reserved_4[0x40];
+
+        struct mlx5_ifc_rqtc_bits ctx;
+};
+
+struct mlx5_ifc_modify_rq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_modify_rq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         rq_state[0x4];
+        u8         reserved_2[0x4];
+        u8         rqn[0x18];
+
+        u8         reserved_3[0x20];
+
+        u8         modify_bitmask[0x40];
+
+        u8         reserved_4[0x40];
+
+        struct mlx5_ifc_rqc_bits ctx;
+};
+
+struct mlx5_ifc_modify_rmp_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_rmp_bitmask_bits {
+        u8         reserved[0x20];
+
+        u8         reserved1[0x1f];
+        u8         lwm[0x1];
+};
+
+struct mlx5_ifc_modify_rmp_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         rmp_state[0x4];
+        u8         reserved_2[0x4];
+        u8         rmpn[0x18];
+
+        u8         reserved_3[0x20];
+
+        struct mlx5_ifc_rmp_bitmask_bits bitmask;
+
+        u8         reserved_4[0x40];
+
+        struct mlx5_ifc_rmpc_bits ctx;
+};
+
+struct mlx5_ifc_modify_nic_vport_context_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_modify_nic_vport_field_select_bits {
+        u8         reserved_0[0x1c];
+        u8         permanent_address[0x1];
+        u8         addresses_list[0x1];
+        u8         roce_en[0x1];
+        u8         reserved_1[0x1];
+};
+
+struct mlx5_ifc_modify_nic_vport_context_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         other_vport[0x1];
+        u8         reserved_2[0xf];
+        u8         vport_number[0x10];
+
+        struct mlx5_ifc_modify_nic_vport_field_select_bits field_select;
+
+        u8         reserved_3[0x780];
+
+        struct mlx5_ifc_nic_vport_context_bits nic_vport_context;
+};
+
+struct mlx5_ifc_modify_hca_vport_context_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_modify_hca_vport_context_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         other_vport[0x1];
+        u8         reserved_2[0xb];
+        u8         port_num[0x4];
+        u8         vport_number[0x10];
+
+        u8         reserved_3[0x20];
+
+        struct mlx5_ifc_hca_vport_context_bits hca_vport_context;
+};
+
+struct mlx5_ifc_modify_cq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+enum {
+        MLX5_MODIFY_CQ_IN_OP_MOD_MODIFY_CQ  = 0x0,
+        MLX5_MODIFY_CQ_IN_OP_MOD_RESIZE_CQ  = 0x1,
+};
+
+struct mlx5_ifc_modify_cq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         cqn[0x18];
+
+        union mlx5_ifc_modify_field_select_resize_field_select_auto_bits modify_field_select_resize_field_select;
+
+        struct mlx5_ifc_cqc_bits cq_context;
+
+        u8         reserved_3[0x600];
+
+        u8         pas[0][0x40];
+};
+
+struct mlx5_ifc_modify_cong_status_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_modify_cong_status_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x18];
+        u8         priority[0x4];
+        u8         cong_protocol[0x4];
+
+        u8         enable[0x1];
+        u8         tag_enable[0x1];
+        u8         reserved_3[0x1e];
+};
+
+struct mlx5_ifc_modify_cong_params_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_modify_cong_params_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x1c];
+        u8         cong_protocol[0x4];
+
+        union mlx5_ifc_field_select_802_1_r_roce_auto_bits field_select;
+
+        u8         reserved_3[0x80];
+
+        union mlx5_ifc_cong_control_roce_ecn_auto_bits congestion_parameters;
+};
+
+struct mlx5_ifc_manage_pages_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         output_num_entries[0x20];
+
+        u8         reserved_1[0x20];
+
+        u8         pas[0][0x40];
+};
+
+enum {
+        MLX5_MANAGE_PAGES_IN_OP_MOD_ALLOCATION_FAIL     = 0x0,
+        MLX5_MANAGE_PAGES_IN_OP_MOD_ALLOCATION_SUCCESS  = 0x1,
+        MLX5_MANAGE_PAGES_IN_OP_MOD_HCA_RETURN_PAGES    = 0x2,
+};
+
+struct mlx5_ifc_manage_pages_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x10];
+        u8         function_id[0x10];
+
+        u8         input_num_entries[0x20];
+
+        u8         pas[0][0x40];
+};
+
+struct mlx5_ifc_mad_ifc_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        u8         response_mad_packet[256][0x8];
+};
+
+struct mlx5_ifc_mad_ifc_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         remote_lid[0x10];
+        u8         reserved_2[0x8];
+        u8         port[0x8];
+
+        u8         reserved_3[0x20];
+
+        u8         mad[256][0x8];
+};
+
+struct mlx5_ifc_init_hca_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_init_hca_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+};
+
+struct mlx5_ifc_init2rtr_qp_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_init2rtr_qp_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         qpn[0x18];
+
+        u8         reserved_3[0x20];
+
+        u8         opt_param_mask[0x20];
+
+        u8         reserved_4[0x20];
+
+        struct mlx5_ifc_qpc_bits qpc;
+
+        u8         reserved_5[0x80];
+};
+
+struct mlx5_ifc_init2init_qp_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_init2init_qp_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         qpn[0x18];
+
+        u8         reserved_3[0x20];
+
+        u8         opt_param_mask[0x20];
+
+        u8         reserved_4[0x20];
+
+        struct mlx5_ifc_qpc_bits qpc;
+
+        u8         reserved_5[0x80];
+};
+
+struct mlx5_ifc_get_dropped_packet_log_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        u8         packet_headers_log[128][0x8];
+
+        u8         packet_syndrome[64][0x8];
+};
+
+struct mlx5_ifc_get_dropped_packet_log_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+};
+
+struct mlx5_ifc_gen_eqe_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x18];
+        u8         eq_number[0x8];
+
+        u8         reserved_3[0x20];
+
+        u8         eqe[64][0x8];
+};
+
+struct mlx5_ifc_gen_eq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_enable_hca_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x20];
+};
+
+struct mlx5_ifc_enable_hca_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x10];
+        u8         function_id[0x10];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_drain_dct_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_drain_dct_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         dctn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_disable_hca_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x20];
+};
+
+struct mlx5_ifc_disable_hca_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x10];
+        u8         function_id[0x10];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_detach_from_mcg_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_detach_from_mcg_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         qpn[0x18];
+
+        u8         reserved_3[0x20];
+
+        u8         multicast_gid[16][0x8];
+};
+
+struct mlx5_ifc_destroy_xrc_srq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_destroy_xrc_srq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         xrc_srqn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_destroy_tis_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_destroy_tis_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         tisn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_destroy_tir_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_destroy_tir_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         tirn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_destroy_srq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_destroy_srq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         srqn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_destroy_sq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_destroy_sq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         sqn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_destroy_rqt_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_destroy_rqt_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         rqtn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_destroy_rq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_destroy_rq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         rqn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_destroy_rmp_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_destroy_rmp_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         rmpn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_destroy_qp_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_destroy_qp_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         qpn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_destroy_psv_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_destroy_psv_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         psvn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_destroy_mkey_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_destroy_mkey_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         mkey_index[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_destroy_flow_table_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_destroy_flow_table_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+
+        u8         table_type[0x8];
+        u8         reserved_3[0x18];
+
+        u8         reserved_4[0x8];
+        u8         table_id[0x18];
+
+        u8         reserved_5[0x140];
+};
+
+struct mlx5_ifc_destroy_flow_group_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_destroy_flow_group_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+
+        u8         table_type[0x8];
+        u8         reserved_3[0x18];
+
+        u8         reserved_4[0x8];
+        u8         table_id[0x18];
+
+        u8         group_id[0x20];
+
+        u8         reserved_5[0x120];
+};
+
+struct mlx5_ifc_destroy_eq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_destroy_eq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x18];
+        u8         eq_number[0x8];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_destroy_dct_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_destroy_dct_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         dctn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_destroy_cq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_destroy_cq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         cqn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_delete_vxlan_udp_dport_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_delete_vxlan_udp_dport_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x20];
+
+        u8         reserved_3[0x10];
+        u8         vxlan_udp_port[0x10];
+};
+
+struct mlx5_ifc_delete_l2_table_entry_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_delete_l2_table_entry_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x60];
+
+        u8         reserved_3[0x8];
+        u8         table_index[0x18];
+
+        u8         reserved_4[0x140];
+};
+
+struct mlx5_ifc_delete_fte_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_delete_fte_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+
+        u8         table_type[0x8];
+        u8         reserved_3[0x18];
+
+        u8         reserved_4[0x8];
+        u8         table_id[0x18];
+
+        u8         reserved_5[0x40];
+
+        u8         flow_index[0x20];
+
+        u8         reserved_6[0xe0];
+};
+
+struct mlx5_ifc_dealloc_xrcd_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_dealloc_xrcd_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         xrcd[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_dealloc_uar_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_dealloc_uar_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         uar[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_dealloc_transport_domain_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_dealloc_transport_domain_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         transport_domain[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_dealloc_q_counter_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_dealloc_q_counter_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x18];
+        u8         counter_set_id[0x8];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_dealloc_pd_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_dealloc_pd_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         pd[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_create_xrc_srq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         xrc_srqn[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_create_xrc_srq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+
+        struct mlx5_ifc_xrc_srqc_bits xrc_srq_context_entry;
+
+        u8         reserved_3[0x600];
+
+        u8         pas[0][0x40];
+};
+
+struct mlx5_ifc_create_tis_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         tisn[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_create_tis_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0xc0];
+
+        struct mlx5_ifc_tisc_bits ctx;
+};
+
+struct mlx5_ifc_create_tir_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         tirn[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_create_tir_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0xc0];
+
+        struct mlx5_ifc_tirc_bits ctx;
+};
+
+struct mlx5_ifc_create_srq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         srqn[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_create_srq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+
+        struct mlx5_ifc_srqc_bits srq_context_entry;
+
+        u8         reserved_3[0x600];
+
+        u8         pas[0][0x40];
+};
+
+struct mlx5_ifc_create_sq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         sqn[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_create_sq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0xc0];
+
+        struct mlx5_ifc_sqc_bits ctx;
+};
+
+struct mlx5_ifc_create_rqt_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         rqtn[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_create_rqt_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0xc0];
+
+        struct mlx5_ifc_rqtc_bits rqt_context;
+};
+
+struct mlx5_ifc_create_rq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         rqn[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_create_rq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0xc0];
+
+        struct mlx5_ifc_rqc_bits ctx;
+};
+
+struct mlx5_ifc_create_rmp_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         rmpn[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_create_rmp_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0xc0];
+
+        struct mlx5_ifc_rmpc_bits ctx;
+};
+
+struct mlx5_ifc_create_qp_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         qpn[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_create_qp_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+
+        u8         opt_param_mask[0x20];
+
+        u8         reserved_3[0x20];
+
+        struct mlx5_ifc_qpc_bits qpc;
+
+        u8         reserved_4[0x80];
+
+        u8         pas[0][0x40];
+};
+
+struct mlx5_ifc_create_psv_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        u8         reserved_2[0x8];
+        u8         psv0_index[0x18];
+
+        u8         reserved_3[0x8];
+        u8         psv1_index[0x18];
+
+        u8         reserved_4[0x8];
+        u8         psv2_index[0x18];
+
+        u8         reserved_5[0x8];
+        u8         psv3_index[0x18];
+};
+
+struct mlx5_ifc_create_psv_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         num_psv[0x4];
+        u8         reserved_2[0x4];
+        u8         pd[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_create_mkey_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         mkey_index[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_create_mkey_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x20];
+
+        u8         pg_access[0x1];
+        u8         reserved_3[0x1f];
+
+        struct mlx5_ifc_mkc_bits memory_key_mkey_entry;
+
+        u8         reserved_4[0x80];
+
+        u8         translations_octword_actual_size[0x20];
+
+        u8         reserved_5[0x560];
+
+        u8         klm_pas_mtt[0][0x20];
+};
+
+struct mlx5_ifc_create_flow_table_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         table_id[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_create_flow_table_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+
+        u8         table_type[0x8];
+        u8         reserved_3[0x18];
+
+        u8         reserved_4[0x20];
+
+        u8         reserved_5[0x8];
+        u8         level[0x8];
+        u8         reserved_6[0x8];
+        u8         log_size[0x8];
+
+        u8         reserved_7[0x120];
+};
+
+struct mlx5_ifc_create_flow_group_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         group_id[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+enum {
+        MLX5_CREATE_FLOW_GROUP_IN_MATCH_CRITERIA_ENABLE_OUTER_HEADERS    = 0x0,
+        MLX5_CREATE_FLOW_GROUP_IN_MATCH_CRITERIA_ENABLE_MISC_PARAMETERS  = 0x1,
+        MLX5_CREATE_FLOW_GROUP_IN_MATCH_CRITERIA_ENABLE_INNER_HEADERS    = 0x2,
+};
+
+struct mlx5_ifc_create_flow_group_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+
+        u8         table_type[0x8];
+        u8         reserved_3[0x18];
+
+        u8         reserved_4[0x8];
+        u8         table_id[0x18];
+
+        u8         reserved_5[0x20];
+
+        u8         start_flow_index[0x20];
+
+        u8         reserved_6[0x20];
+
+        u8         end_flow_index[0x20];
+
+        u8         reserved_7[0xa0];
+
+        u8         reserved_8[0x18];
+        u8         match_criteria_enable[0x8];
+
+        struct mlx5_ifc_fte_match_param_bits match_criteria;
+
+        u8         reserved_9[0xe00];
+};
+
+struct mlx5_ifc_create_eq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x18];
+        u8         eq_number[0x8];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_create_eq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+
+        struct mlx5_ifc_eqc_bits eq_context_entry;
+
+        u8         reserved_3[0x40];
+
+        u8         event_bitmask[0x40];
+
+        u8         reserved_4[0x580];
+
+        u8         pas[0][0x40];
+};
+
+struct mlx5_ifc_create_dct_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         dctn[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_create_dct_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+
+        struct mlx5_ifc_dctc_bits dct_context_entry;
+
+        u8         reserved_3[0x180];
+};
+
+struct mlx5_ifc_create_cq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         cqn[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_create_cq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+
+        struct mlx5_ifc_cqc_bits cq_context;
+
+        u8         reserved_3[0x600];
+
+        u8         pas[0][0x40];
+};
+
+struct mlx5_ifc_config_int_moderation_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x4];
+        u8         min_delay[0xc];
+        u8         int_vector[0x10];
+
+        u8         reserved_2[0x20];
+};
+
+enum {
+        MLX5_CONFIG_INT_MODERATION_IN_OP_MOD_WRITE  = 0x0,
+        MLX5_CONFIG_INT_MODERATION_IN_OP_MOD_READ   = 0x1,
+};
+
+struct mlx5_ifc_config_int_moderation_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x4];
+        u8         min_delay[0xc];
+        u8         int_vector[0x10];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_attach_to_mcg_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_attach_to_mcg_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         qpn[0x18];
+
+        u8         reserved_3[0x20];
+
+        u8         multicast_gid[16][0x8];
+};
+
+struct mlx5_ifc_arm_xrc_srq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+enum {
+        MLX5_ARM_XRC_SRQ_IN_OP_MOD_XRC_SRQ  = 0x1,
+};
+
+struct mlx5_ifc_arm_xrc_srq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         xrc_srqn[0x18];
+
+        u8         reserved_3[0x10];
+        u8         lwm[0x10];
+};
+
+struct mlx5_ifc_arm_rq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+enum {
+        MLX5_ARM_RQ_IN_OP_MOD_SRQ_  = 0x1,
+};
+
+struct mlx5_ifc_arm_rq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         srq_number[0x18];
+
+        u8         reserved_3[0x10];
+        u8         lwm[0x10];
+};
+
+struct mlx5_ifc_arm_dct_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_arm_dct_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         dct_number[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_alloc_xrcd_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         xrcd[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_alloc_xrcd_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+};
+
+struct mlx5_ifc_alloc_uar_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         uar[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_alloc_uar_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+};
+
+struct mlx5_ifc_alloc_transport_domain_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         transport_domain[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_alloc_transport_domain_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+};
+
+struct mlx5_ifc_alloc_q_counter_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x18];
+        u8         counter_set_id[0x8];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_alloc_q_counter_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+};
+
+struct mlx5_ifc_alloc_pd_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         pd[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_alloc_pd_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+};
+
+struct mlx5_ifc_add_vxlan_udp_dport_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_add_vxlan_udp_dport_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x20];
+
+        u8         reserved_3[0x10];
+        u8         vxlan_udp_port[0x10];
+};
+
+struct mlx5_ifc_access_register_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        u8         register_data[0][0x20];
+};
+
+enum {
+        MLX5_ACCESS_REGISTER_IN_OP_MOD_WRITE  = 0x0,
+        MLX5_ACCESS_REGISTER_IN_OP_MOD_READ   = 0x1,
+};
+
+struct mlx5_ifc_access_register_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x10];
+        u8         register_id[0x10];
+
+        u8         argument[0x20];
+
+        u8         register_data[0][0x20];
+};
+
+struct mlx5_ifc_sltp_reg_bits {
+        u8         status[0x4];
+        u8         version[0x4];
+        u8         local_port[0x8];
+        u8         pnat[0x2];
+        u8         reserved_0[0x2];
+        u8         lane[0x4];
+        u8         reserved_1[0x8];
+
+        u8         reserved_2[0x20];
+
+        u8         reserved_3[0x7];
+        u8         polarity[0x1];
+        u8         ob_tap0[0x8];
+        u8         ob_tap1[0x8];
+        u8         ob_tap2[0x8];
+
+        u8         reserved_4[0xc];
+        u8         ob_preemp_mode[0x4];
+        u8         ob_reg[0x8];
+        u8         ob_bias[0x8];
+
+        u8         reserved_5[0x20];
+};
+
+struct mlx5_ifc_slrg_reg_bits {
+        u8         status[0x4];
+        u8         version[0x4];
+        u8         local_port[0x8];
+        u8         pnat[0x2];
+        u8         reserved_0[0x2];
+        u8         lane[0x4];
+        u8         reserved_1[0x8];
+
+        u8         time_to_link_up[0x10];
+        u8         reserved_2[0xc];
+        u8         grade_lane_speed[0x4];
+
+        u8         grade_version[0x8];
+        u8         grade[0x18];
+
+        u8         reserved_3[0x4];
+        u8         height_grade_type[0x4];
+        u8         height_grade[0x18];
+
+        u8         height_dz[0x10];
+        u8         height_dv[0x10];
+
+        u8         reserved_4[0x10];
+        u8         height_sigma[0x10];
+
+        u8         reserved_5[0x20];
+
+        u8         reserved_6[0x4];
+        u8         phase_grade_type[0x4];
+        u8         phase_grade[0x18];
+
+        u8         reserved_7[0x8];
+        u8         phase_eo_pos[0x8];
+        u8         reserved_8[0x8];
+        u8         phase_eo_neg[0x8];
+
+        u8         ffe_set_tested[0x10];
+        u8         test_errors_per_lane[0x10];
+};
+
+struct mlx5_ifc_pvlc_reg_bits {
+        u8         reserved_0[0x8];
+        u8         local_port[0x8];
+        u8         reserved_1[0x10];
+
+        u8         reserved_2[0x1c];
+        u8         vl_hw_cap[0x4];
+
+        u8         reserved_3[0x1c];
+        u8         vl_admin[0x4];
+
+        u8         reserved_4[0x1c];
+        u8         vl_operational[0x4];
+};
+
+struct mlx5_ifc_pude_reg_bits {
+        u8         swid[0x8];
+        u8         local_port[0x8];
+        u8         reserved_0[0x4];
+        u8         admin_status[0x4];
+        u8         reserved_1[0x4];
+        u8         oper_status[0x4];
+
+        u8         reserved_2[0x60];
+};
+
+struct mlx5_ifc_ptys_reg_bits {
+        u8         reserved_0[0x8];
+        u8         local_port[0x8];
+        u8         reserved_1[0xd];
+        u8         proto_mask[0x3];
+
+        u8         reserved_2[0x40];
+
+        u8         eth_proto_capability[0x20];
+
+        u8         ib_link_width_capability[0x10];
+        u8         ib_proto_capability[0x10];
+
+        u8         reserved_3[0x20];
+
+        u8         eth_proto_admin[0x20];
+
+        u8         ib_link_width_admin[0x10];
+        u8         ib_proto_admin[0x10];
+
+        u8         reserved_4[0x20];
+
+        u8         eth_proto_oper[0x20];
+
+        u8         ib_link_width_oper[0x10];
+        u8         ib_proto_oper[0x10];
+
+        u8         reserved_5[0x20];
+
+        u8         eth_proto_lp_advertise[0x20];
+
+        u8         reserved_6[0x60];
+};
+
+struct mlx5_ifc_ptas_reg_bits {
+        u8         reserved_0[0x20];
+
+        u8         algorithm_options[0x10];
+        u8         reserved_1[0x4];
+        u8         repetitions_mode[0x4];
+        u8         num_of_repetitions[0x8];
+
+        u8         grade_version[0x8];
+        u8         height_grade_type[0x4];
+        u8         phase_grade_type[0x4];
+        u8         height_grade_weight[0x8];
+        u8         phase_grade_weight[0x8];
+
+        u8         gisim_measure_bits[0x10];
+        u8         adaptive_tap_measure_bits[0x10];
+
+        u8         ber_bath_high_error_threshold[0x10];
+        u8         ber_bath_mid_error_threshold[0x10];
+
+        u8         ber_bath_low_error_threshold[0x10];
+        u8         one_ratio_high_threshold[0x10];
+
+        u8         one_ratio_high_mid_threshold[0x10];
+        u8         one_ratio_low_mid_threshold[0x10];
+
+        u8         one_ratio_low_threshold[0x10];
+        u8         ndeo_error_threshold[0x10];
+
+        u8         mixer_offset_step_size[0x10];
+        u8         reserved_2[0x8];
+        u8         mix90_phase_for_voltage_bath[0x8];
+
+        u8         mixer_offset_start[0x10];
+        u8         mixer_offset_end[0x10];
+
+        u8         reserved_3[0x15];
+        u8         ber_test_time[0xb];
+};
+
+struct mlx5_ifc_pspa_reg_bits {
+        u8         swid[0x8];
+        u8         local_port[0x8];
+        u8         sub_port[0x8];
+        u8         reserved_0[0x8];
+
+        u8         reserved_1[0x20];
+};
+
+struct mlx5_ifc_pqdr_reg_bits {
+        u8         reserved_0[0x8];
+        u8         local_port[0x8];
+        u8         reserved_1[0x5];
+        u8         prio[0x3];
+        u8         reserved_2[0x6];
+        u8         mode[0x2];
+
+        u8         reserved_3[0x20];
+
+        u8         reserved_4[0x10];
+        u8         min_threshold[0x10];
+
+        u8         reserved_5[0x10];
+        u8         max_threshold[0x10];
+
+        u8         reserved_6[0x10];
+        u8         mark_probability_denominator[0x10];
+
+        u8         reserved_7[0x60];
+};
+
+struct mlx5_ifc_ppsc_reg_bits {
+        u8         reserved_0[0x8];
+        u8         local_port[0x8];
+        u8         reserved_1[0x10];
+
+        u8         reserved_2[0x60];
+
+        u8         reserved_3[0x1c];
+        u8         wrps_admin[0x4];
+
+        u8         reserved_4[0x1c];
+        u8         wrps_status[0x4];
+
+        u8         reserved_5[0x8];
+        u8         up_threshold[0x8];
+        u8         reserved_6[0x8];
+        u8         down_threshold[0x8];
+
+        u8         reserved_7[0x20];
+
+        u8         reserved_8[0x1c];
+        u8         srps_admin[0x4];
+
+        u8         reserved_9[0x1c];
+        u8         srps_status[0x4];
+
+        u8         reserved_10[0x40];
+};
+
+struct mlx5_ifc_pplr_reg_bits {
+        u8         reserved_0[0x8];
+        u8         local_port[0x8];
+        u8         reserved_1[0x10];
+
+        u8         reserved_2[0x8];
+        u8         lb_cap[0x8];
+        u8         reserved_3[0x8];
+        u8         lb_en[0x8];
+};
+
+struct mlx5_ifc_pplm_reg_bits {
+        u8         reserved_0[0x8];
+        u8         local_port[0x8];
+        u8         reserved_1[0x10];
+
+        u8         reserved_2[0x20];
+
+        u8         port_profile_mode[0x8];
+        u8         static_port_profile[0x8];
+        u8         active_port_profile[0x8];
+        u8         reserved_3[0x8];
+
+        u8         retransmission_active[0x8];
+        u8         fec_mode_active[0x18];
+
+        u8         reserved_4[0x20];
+};
+
+struct mlx5_ifc_ppcnt_reg_bits {
+        u8         swid[0x8];
+        u8         local_port[0x8];
+        u8         pnat[0x2];
+        u8         reserved_0[0x8];
+        u8         grp[0x6];
+
+        u8         clr[0x1];
+        u8         reserved_1[0x1c];
+        u8         prio_tc[0x3];
+
+        union mlx5_ifc_eth_cntrs_grp_data_layout_auto_bits counter_set;
+};
+
+struct mlx5_ifc_ppad_reg_bits {
+        u8         reserved_0[0x3];
+        u8         single_mac[0x1];
+        u8         reserved_1[0x4];
+        u8         local_port[0x8];
+        u8         mac_47_32[0x10];
+
+        u8         mac_31_0[0x20];
+
+        u8         reserved_2[0x40];
+};
+
+struct mlx5_ifc_pmtu_reg_bits {
+        u8         reserved_0[0x8];
+        u8         local_port[0x8];
+        u8         reserved_1[0x10];
+
+        u8         max_mtu[0x10];
+        u8         reserved_2[0x10];
+
+        u8         admin_mtu[0x10];
+        u8         reserved_3[0x10];
+
+        u8         oper_mtu[0x10];
+        u8         reserved_4[0x10];
+};
+
+struct mlx5_ifc_pmpr_reg_bits {
+        u8         reserved_0[0x8];
+        u8         module[0x8];
+        u8         reserved_1[0x10];
+
+        u8         reserved_2[0x18];
+        u8         attenuation_5g[0x8];
+
+        u8         reserved_3[0x18];
+        u8         attenuation_7g[0x8];
+
+        u8         reserved_4[0x18];
+        u8         attenuation_12g[0x8];
+};
+
+struct mlx5_ifc_pmpe_reg_bits {
+        u8         reserved_0[0x8];
+        u8         module[0x8];
+        u8         reserved_1[0xc];
+        u8         module_status[0x4];
+
+        u8         reserved_2[0x60];
+};
+
+struct mlx5_ifc_pmpc_reg_bits {
+        u8         module_state_updated[32][0x8];
+};
+
+struct mlx5_ifc_pmlpn_reg_bits {
+        u8         reserved_0[0x4];
+        u8         mlpn_status[0x4];
+        u8         local_port[0x8];
+        u8         reserved_1[0x10];
+
+        u8         e[0x1];
+        u8         reserved_2[0x1f];
+};
+
+struct mlx5_ifc_pmlp_reg_bits {
+        u8         rxtx[0x1];
+        u8         reserved_0[0x7];
+        u8         local_port[0x8];
+        u8         reserved_1[0x8];
+        u8         width[0x8];
+
+        u8         lane0_module_mapping[0x20];
+
+        u8         lane1_module_mapping[0x20];
+
+        u8         lane2_module_mapping[0x20];
+
+        u8         lane3_module_mapping[0x20];
+
+        u8         reserved_2[0x160];
+};
+
+struct mlx5_ifc_pmaos_reg_bits {
+        u8         reserved_0[0x8];
+        u8         module[0x8];
+        u8         reserved_1[0x4];
+        u8         admin_status[0x4];
+        u8         reserved_2[0x4];
+        u8         oper_status[0x4];
+
+        u8         ase[0x1];
+        u8         ee[0x1];
+        u8         reserved_3[0x1c];
+        u8         e[0x2];
+
+        u8         reserved_4[0x40];
+};
+
+struct mlx5_ifc_plpc_reg_bits {
+        u8         reserved_0[0x4];
+        u8         profile_id[0xc];
+        u8         reserved_1[0x4];
+        u8         proto_mask[0x4];
+        u8         reserved_2[0x8];
+
+        u8         reserved_3[0x10];
+        u8         lane_speed[0x10];
+
+        u8         reserved_4[0x17];
+        u8         lpbf[0x1];
+        u8         fec_mode_policy[0x8];
+
+        u8         retransmission_capability[0x8];
+        u8         fec_mode_capability[0x18];
+
+        u8         retransmission_support_admin[0x8];
+        u8         fec_mode_support_admin[0x18];
+
+        u8         retransmission_request_admin[0x8];
+        u8         fec_mode_request_admin[0x18];
+
+        u8         reserved_5[0x80];
+};
+
+struct mlx5_ifc_plib_reg_bits {
+        u8         reserved_0[0x8];
+        u8         local_port[0x8];
+        u8         reserved_1[0x8];
+        u8         ib_port[0x8];
+
+        u8         reserved_2[0x60];
+};
+
+struct mlx5_ifc_plbf_reg_bits {
+        u8         reserved_0[0x8];
+        u8         local_port[0x8];
+        u8         reserved_1[0xd];
+        u8         lbf_mode[0x3];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_pipg_reg_bits {
+        u8         reserved_0[0x8];
+        u8         local_port[0x8];
+        u8         reserved_1[0x10];
+
+        u8         dic[0x1];
+        u8         reserved_2[0x19];
+        u8         ipg[0x4];
+        u8         reserved_3[0x2];
+};
+
+struct mlx5_ifc_pifr_reg_bits {
+        u8         reserved_0[0x8];
+        u8         local_port[0x8];
+        u8         reserved_1[0x10];
+
+        u8         reserved_2[0xe0];
+
+        u8         port_filter[8][0x20];
+
+        u8         port_filter_update_en[8][0x20];
+};
+
+struct mlx5_ifc_pfcc_reg_bits {
+        u8         reserved_0[0x8];
+        u8         local_port[0x8];
+        u8         reserved_1[0x10];
+
+        u8         ppan[0x4];
+        u8         reserved_2[0x4];
+        u8         prio_mask_tx[0x8];
+        u8         reserved_3[0x8];
+        u8         prio_mask_rx[0x8];
+
+        u8         pptx[0x1];
+        u8         aptx[0x1];
+        u8         reserved_4[0x6];
+        u8         pfctx[0x8];
+        u8         reserved_5[0x10];
+
+        u8         pprx[0x1];
+        u8         aprx[0x1];
+        u8         reserved_6[0x6];
+        u8         pfcrx[0x8];
+        u8         reserved_7[0x10];
+
+        u8         reserved_8[0x80];
+};
+
+struct mlx5_ifc_pelc_reg_bits {
+        u8         op[0x4];
+        u8         reserved_0[0x4];
+        u8         local_port[0x8];
+        u8         reserved_1[0x10];
+
+        u8         op_admin[0x8];
+        u8         op_capability[0x8];
+        u8         op_request[0x8];
+        u8         op_active[0x8];
+
+        u8         admin[0x40];
+
+        u8         capability[0x40];
+
+        u8         request[0x40];
+
+        u8         active[0x40];
+
+        u8         reserved_2[0x80];
+};
+
+struct mlx5_ifc_peir_reg_bits {
+        u8         reserved_0[0x8];
+        u8         local_port[0x8];
+        u8         reserved_1[0x10];
+
+        u8         reserved_2[0xc];
+        u8         error_count[0x4];
+        u8         reserved_3[0x10];
+
+        u8         reserved_4[0xc];
+        u8         lane[0x4];
+        u8         reserved_5[0x8];
+        u8         error_type[0x8];
+};
+
+struct mlx5_ifc_pcap_reg_bits {
+        u8         reserved_0[0x8];
+        u8         local_port[0x8];
+        u8         reserved_1[0x10];
+
+        u8         port_capability_mask[4][0x20];
+};
+
+struct mlx5_ifc_paos_reg_bits {
+        u8         swid[0x8];
+        u8         local_port[0x8];
+        u8         reserved_0[0x4];
+        u8         admin_status[0x4];
+        u8         reserved_1[0x4];
+        u8         oper_status[0x4];
+
+        u8         ase[0x1];
+        u8         ee[0x1];
+        u8         reserved_2[0x1c];
+        u8         e[0x2];
+
+        u8         reserved_3[0x40];
+};
+
+struct mlx5_ifc_pamp_reg_bits {
+        u8         reserved_0[0x8];
+        u8         opamp_group[0x8];
+        u8         reserved_1[0xc];
+        u8         opamp_group_type[0x4];
+
+        u8         start_index[0x10];
+        u8         reserved_2[0x4];
+        u8         num_of_indices[0xc];
+
+        u8         index_data[18][0x10];
+};
+
+struct mlx5_ifc_lane_2_module_mapping_bits {
+        u8         reserved_0[0x6];
+        u8         rx_lane[0x2];
+        u8         reserved_1[0x6];
+        u8         tx_lane[0x2];
+        u8         reserved_2[0x8];
+        u8         module[0x8];
+};
+
+struct mlx5_ifc_bufferx_reg_bits {
+        u8         reserved_0[0x6];
+        u8         lossy[0x1];
+        u8         epsb[0x1];
+        u8         reserved_1[0xc];
+        u8         size[0xc];
+
+        u8         xoff_threshold[0x10];
+        u8         xon_threshold[0x10];
+};
+
+struct mlx5_ifc_set_node_in_bits {
+        u8         node_description[64][0x8];
+};
+
+struct mlx5_ifc_register_power_settings_bits {
+        u8         reserved_0[0x18];
+        u8         power_settings_level[0x8];
+
+        u8         reserved_1[0x60];
+};
+
+struct mlx5_ifc_register_host_endianness_bits {
+        u8         he[0x1];
+        u8         reserved_0[0x1f];
+
+        u8         reserved_1[0x60];
+};
+
+struct mlx5_ifc_umr_pointer_desc_argument_bits {
+        u8         reserved_0[0x20];
+
+        u8         mkey[0x20];
+
+        u8         addressh_63_32[0x20];
+
+        u8         addressl_31_0[0x20];
+};
+
+struct mlx5_ifc_ud_adrs_vector_bits {
+        u8         dc_key[0x40];
+
+        u8         ext[0x1];
+        u8         reserved_0[0x7];
+        u8         destination_qp_dct[0x18];
+
+        u8         static_rate[0x4];
+        u8         sl_eth_prio[0x4];
+        u8         fl[0x1];
+        u8         mlid[0x7];
+        u8         rlid_udp_sport[0x10];
+
+        u8         reserved_1[0x20];
+
+        u8         rmac_47_16[0x20];
+
+        u8         rmac_15_0[0x10];
+        u8         tclass[0x8];
+        u8         hop_limit[0x8];
+
+        u8         reserved_2[0x1];
+        u8         grh[0x1];
+        u8         reserved_3[0x2];
+        u8         src_addr_index[0x8];
+        u8         flow_label[0x14];
+
+        u8         rgid_rip[16][0x8];
+};
+
+struct mlx5_ifc_pages_req_event_bits {
+        u8         reserved_0[0x10];
+        u8         function_id[0x10];
+
+        u8         num_pages[0x20];
+
+        u8         reserved_1[0xa0];
+};
+
+struct mlx5_ifc_eqe_bits {
+        u8         reserved_0[0x8];
+        u8         event_type[0x8];
+        u8         reserved_1[0x8];
+        u8         event_sub_type[0x8];
+
+        u8         reserved_2[0xe0];
+
+        union mlx5_ifc_event_auto_bits event_data;
+
+        u8         reserved_3[0x10];
+        u8         signature[0x8];
+        u8         reserved_4[0x7];
+        u8         owner[0x1];
+};
+
+enum {
+        MLX5_CMD_QUEUE_ENTRY_TYPE_PCIE_CMD_IF_TRANSPORT  = 0x7,
+};
+
+struct mlx5_ifc_cmd_queue_entry_bits {
+        u8         type[0x8];
+        u8         reserved_0[0x18];
+
+        u8         input_length[0x20];
+
+        u8         input_mailbox_pointer_63_32[0x20];
+
+        u8         input_mailbox_pointer_31_9[0x17];
+        u8         reserved_1[0x9];
+
+        u8         command_input_inline_data[16][0x8];
+
+        u8         command_output_inline_data[16][0x8];
+
+        u8         output_mailbox_pointer_63_32[0x20];
+
+        u8         output_mailbox_pointer_31_9[0x17];
+        u8         reserved_2[0x9];
+
+        u8         output_length[0x20];
+
+        u8         token[0x8];
+        u8         signature[0x8];
+        u8         reserved_3[0x8];
+        u8         status[0x7];
+        u8         ownership[0x1];
+};
+
+struct mlx5_ifc_cmd_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         command_output[0x20];
+};
+
+struct mlx5_ifc_cmd_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         command[0][0x20];
+};
+
+struct mlx5_ifc_cmd_if_box_bits {
+        u8         mailbox_data[512][0x8];
+
+        u8         reserved_0[0x180];
+
+        u8         next_pointer_63_32[0x20];
+
+        u8         next_pointer_31_10[0x16];
+        u8         reserved_1[0xa];
+
+        u8         block_number[0x20];
+
+        u8         reserved_2[0x8];
+        u8         token[0x8];
+        u8         ctrl_signature[0x8];
+        u8         signature[0x8];
+};
+
+struct mlx5_ifc_mtt_bits {
+        u8         ptag_63_32[0x20];
+
+        u8         ptag_31_8[0x18];
+        u8         reserved_0[0x6];
+        u8         wr_en[0x1];
+        u8         rd_en[0x1];
+};
+
+enum {
+        MLX5_INITIAL_SEG_NIC_INTERFACE_FULL_DRIVER  = 0x0,
+        MLX5_INITIAL_SEG_NIC_INTERFACE_DISABLED     = 0x1,
+        MLX5_INITIAL_SEG_NIC_INTERFACE_NO_DRAM_NIC  = 0x2,
+};
+
+enum {
+        MLX5_INITIAL_SEG_NIC_INTERFACE_SUPPORTED_FULL_DRIVER  = 0x0,
+        MLX5_INITIAL_SEG_NIC_INTERFACE_SUPPORTED_DISABLED     = 0x1,
+        MLX5_INITIAL_SEG_NIC_INTERFACE_SUPPORTED_NO_DRAM_NIC  = 0x2,
+};
+
+enum {
+        MLX5_INITIAL_SEG_HEALTH_SYNDROME_FW_INTERNAL_ERR              = 0x1,
+        MLX5_INITIAL_SEG_HEALTH_SYNDROME_DEAD_IRISC                   = 0x7,
+        MLX5_INITIAL_SEG_HEALTH_SYNDROME_HW_FATAL_ERR                 = 0x8,
+        MLX5_INITIAL_SEG_HEALTH_SYNDROME_FW_CRC_ERR                   = 0x9,
+        MLX5_INITIAL_SEG_HEALTH_SYNDROME_ICM_FETCH_PCI_ERR            = 0xa,
+        MLX5_INITIAL_SEG_HEALTH_SYNDROME_ICM_PAGE_ERR                 = 0xb,
+        MLX5_INITIAL_SEG_HEALTH_SYNDROME_ASYNCHRONOUS_EQ_BUF_OVERRUN  = 0xc,
+        MLX5_INITIAL_SEG_HEALTH_SYNDROME_EQ_IN_ERR                    = 0xd,
+        MLX5_INITIAL_SEG_HEALTH_SYNDROME_EQ_INV                       = 0xe,
+        MLX5_INITIAL_SEG_HEALTH_SYNDROME_FFSER_ERR                    = 0xf,
+        MLX5_INITIAL_SEG_HEALTH_SYNDROME_HIGH_TEMP_ERR                = 0x10,
+};
+
+struct mlx5_ifc_initial_seg_bits {
+        u8         fw_rev_minor[0x10];
+        u8         fw_rev_major[0x10];
+
+        u8         cmd_interface_rev[0x10];
+        u8         fw_rev_subminor[0x10];
+
+        u8         reserved_0[0x40];
+
+        u8         cmdq_phy_addr_63_32[0x20];
+
+        u8         cmdq_phy_addr_31_12[0x14];
+        u8         reserved_1[0x2];
+        u8         nic_interface[0x2];
+        u8         log_cmdq_size[0x4];
+        u8         log_cmdq_stride[0x4];
+
+        u8         command_doorbell_vector[0x20];
+
+        u8         reserved_2[0xf00];
+
+        u8         initializing[0x1];
+        u8         reserved_3[0x4];
+        u8         nic_interface_supported[0x3];
+        u8         reserved_4[0x18];
+
+        struct mlx5_ifc_health_buffer_bits health_buffer;
+
+        u8         no_dram_nic_offset[0x20];
+
+        u8         reserved_5[0x6e40];
+
+        u8         reserved_6[0x1f];
+        u8         clear_int[0x1];
+
+        u8         health_syndrome[0x8];
+        u8         health_counter[0x18];
+
+        u8         reserved_7[0x17fc0];
+};
+
+union mlx5_ifc_ports_control_registers_document_bits {
+        struct mlx5_ifc_bufferx_reg_bits bufferx_reg;
+        struct mlx5_ifc_eth_2819_cntrs_grp_data_layout_bits eth_2819_cntrs_grp_data_layout;
+        struct mlx5_ifc_eth_2863_cntrs_grp_data_layout_bits eth_2863_cntrs_grp_data_layout;
+        struct mlx5_ifc_eth_3635_cntrs_grp_data_layout_bits eth_3635_cntrs_grp_data_layout;
+        struct mlx5_ifc_eth_802_3_cntrs_grp_data_layout_bits eth_802_3_cntrs_grp_data_layout;
+        struct mlx5_ifc_eth_extended_cntrs_grp_data_layout_bits eth_extended_cntrs_grp_data_layout;
+        struct mlx5_ifc_eth_per_prio_grp_data_layout_bits eth_per_prio_grp_data_layout;
+        struct mlx5_ifc_eth_per_traffic_grp_data_layout_bits eth_per_traffic_grp_data_layout;
+        struct mlx5_ifc_lane_2_module_mapping_bits lane_2_module_mapping;
+        struct mlx5_ifc_pamp_reg_bits pamp_reg;
+        struct mlx5_ifc_paos_reg_bits paos_reg;
+        struct mlx5_ifc_pcap_reg_bits pcap_reg;
+        struct mlx5_ifc_peir_reg_bits peir_reg;
+        struct mlx5_ifc_pelc_reg_bits pelc_reg;
+        struct mlx5_ifc_pfcc_reg_bits pfcc_reg;
+        struct mlx5_ifc_phys_layer_cntrs_bits phys_layer_cntrs;
+        struct mlx5_ifc_pifr_reg_bits pifr_reg;
+        struct mlx5_ifc_pipg_reg_bits pipg_reg;
+        struct mlx5_ifc_plbf_reg_bits plbf_reg;
+        struct mlx5_ifc_plib_reg_bits plib_reg;
+        struct mlx5_ifc_plpc_reg_bits plpc_reg;
+        struct mlx5_ifc_pmaos_reg_bits pmaos_reg;
+        struct mlx5_ifc_pmlp_reg_bits pmlp_reg;
+        struct mlx5_ifc_pmlpn_reg_bits pmlpn_reg;
+        struct mlx5_ifc_pmpc_reg_bits pmpc_reg;
+        struct mlx5_ifc_pmpe_reg_bits pmpe_reg;
+        struct mlx5_ifc_pmpr_reg_bits pmpr_reg;
+        struct mlx5_ifc_pmtu_reg_bits pmtu_reg;
+        struct mlx5_ifc_ppad_reg_bits ppad_reg;
+        struct mlx5_ifc_ppcnt_reg_bits ppcnt_reg;
+        struct mlx5_ifc_pplm_reg_bits pplm_reg;
+        struct mlx5_ifc_pplr_reg_bits pplr_reg;
+        struct mlx5_ifc_ppsc_reg_bits ppsc_reg;
+        struct mlx5_ifc_pqdr_reg_bits pqdr_reg;
+        struct mlx5_ifc_pspa_reg_bits pspa_reg;
+        struct mlx5_ifc_ptas_reg_bits ptas_reg;
+        struct mlx5_ifc_ptys_reg_bits ptys_reg;
+        struct mlx5_ifc_pude_reg_bits pude_reg;
+        struct mlx5_ifc_pvlc_reg_bits pvlc_reg;
+        struct mlx5_ifc_slrg_reg_bits slrg_reg;
+        struct mlx5_ifc_sltp_reg_bits sltp_reg;
+        u8         reserved_0[0x60e0];
+};
+
+union mlx5_ifc_debug_enhancements_document_bits {
+        struct mlx5_ifc_health_buffer_bits health_buffer;
+        u8         reserved_0[0x200];
+};
+
+union mlx5_ifc_uplink_pci_interface_document_bits {
+        struct mlx5_ifc_initial_seg_bits initial_seg;
+        u8         reserved_0[0x20060];
 };
 
 #endif /* MLX5_IFC_H */
diff --git a/include/linux/mlx5/qp.h b/include/linux/mlx5/qp.h
index 310b5f7fd6ae..f079fb1a31f7 100644
--- a/include/linux/mlx5/qp.h
+++ b/include/linux/mlx5/qp.h
@@ -134,13 +134,21 @@ enum {
 
 enum {
         MLX5_WQE_CTRL_CQ_UPDATE         = 2 << 2,
+        MLX5_WQE_CTRL_CQ_UPDATE_AND_EQE = 3 << 2,
         MLX5_WQE_CTRL_SOLICITED         = 1 << 1,
 };
 
 enum {
+        MLX5_SEND_WQE_DS        = 16,
         MLX5_SEND_WQE_BB        = 64,
 };
 
+#define MLX5_SEND_WQEBB_NUM_DS  (MLX5_SEND_WQE_BB / MLX5_SEND_WQE_DS)
+
+enum {
+        MLX5_SEND_WQE_MAX_WQEBBS        = 16,
+};
+
 enum {
         MLX5_WQE_FMR_PERM_LOCAL_READ    = 1 << 27,
         MLX5_WQE_FMR_PERM_LOCAL_WRITE   = 1 << 28,
@@ -200,6 +208,23 @@ struct mlx5_wqe_ctrl_seg {
 #define MLX5_WQE_CTRL_WQE_INDEX_MASK 0x00ffff00
 #define MLX5_WQE_CTRL_WQE_INDEX_SHIFT 8
 
+enum {
+        MLX5_ETH_WQE_L3_INNER_CSUM      = 1 << 4,
+        MLX5_ETH_WQE_L4_INNER_CSUM      = 1 << 5,
+        MLX5_ETH_WQE_L3_CSUM            = 1 << 6,
+        MLX5_ETH_WQE_L4_CSUM            = 1 << 7,
+};
+
+struct mlx5_wqe_eth_seg {
+        u8              rsvd0[4];
+        u8              cs_flags;
+        u8              rsvd1;
+        __be16          mss;
+        __be32          rsvd2;
+        __be16          inline_hdr_sz;
+        u8              inline_hdr_start[2];
+};
+
 struct mlx5_wqe_xrc_seg {
         __be32                  xrc_srqn;
         u8                      rsvd[12];
diff --git a/include/linux/mlx5/vport.h b/include/linux/mlx5/vport.h
new file mode 100644
index 000000000000..967e0fd06e89
--- /dev/null
+++ b/include/linux/mlx5/vport.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2013-2015, Mellanox Technologies, Ltd.  All rights reserved.
+ *
+ * This software is available to you under a choice of one of two
+ * licenses.  You may choose to be licensed under the terms of the GNU
+ * General Public License (GPL) Version 2, available from the file
+ * COPYING in the main directory of this source tree, or the
+ * OpenIB.org BSD license below:
+ *
+ *     Redistribution and use in source and binary forms, with or
+ *     without modification, are permitted provided that the following
+ *     conditions are met:
+ *
+ *      - Redistributions of source code must retain the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer.
+ *
+ *      - Redistributions in binary form must reproduce the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ * 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. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef __MLX5_VPORT_H__
+#define __MLX5_VPORT_H__
+
+#include <linux/mlx5/driver.h>
+
+u8 mlx5_query_vport_state(struct mlx5_core_dev *mdev, u8 opmod);
+void mlx5_query_nic_vport_mac_address(struct mlx5_core_dev *mdev, u8 *addr);
+int mlx5_query_hca_vport_gid(struct mlx5_core_dev *dev, u8 other_vport,
+                             u8 port_num, u16  vf_num, u16 gid_index,
+                             union ib_gid *gid);
+int mlx5_query_hca_vport_pkey(struct mlx5_core_dev *dev, u8 other_vport,
+                              u8 port_num, u16 vf_num, u16 pkey_index,
+                              u16 *pkey);
+int mlx5_query_hca_vport_context(struct mlx5_core_dev *dev,
+                                 u8 other_vport, u8 port_num,
+                                 u16 vf_num,
+                                 struct mlx5_hca_vport_context *rep);
+int mlx5_query_hca_vport_system_image_guid(struct mlx5_core_dev *dev,
+                                           u64 *sys_image_guid);
+int mlx5_query_hca_vport_node_guid(struct mlx5_core_dev *dev,
+                                   u64 *node_guid);
+
+#endif /* __MLX5_VPORT_H__ */
diff --git a/include/linux/mm-arch-hooks.h b/include/linux/mm-arch-hooks.h
new file mode 100644
index 000000000000..4efc3f56e6df
--- /dev/null
+++ b/include/linux/mm-arch-hooks.h
@@ -0,0 +1,25 @@
+/*
+ * Generic mm no-op hooks.
+ *
+ * Copyright (C) 2015, IBM Corporation
+ * Author: Laurent Dufour <ldufour@linux.vnet.ibm.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#ifndef _LINUX_MM_ARCH_HOOKS_H
+#define _LINUX_MM_ARCH_HOOKS_H
+
+#include <asm/mm-arch-hooks.h>
+
+#ifndef arch_remap
+static inline void arch_remap(struct mm_struct *mm,
+                              unsigned long old_start, unsigned long old_end,
+                              unsigned long new_start, unsigned long new_end)
+{
+}
+#define arch_remap arch_remap
+#endif
+
+#endif /* _LINUX_MM_ARCH_HOOKS_H */
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 0755b9fd03a7..2e872f92dbac 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -27,6 +27,7 @@ struct anon_vma_chain;
 struct file_ra_state;
 struct user_struct;
 struct writeback_control;
+struct bdi_writeback;
 
 #ifndef CONFIG_NEED_MULTIPLE_NODES      /* Don't use mapnrs, do it properly */
 extern unsigned long max_mapnr;
@@ -499,7 +500,7 @@ static inline int page_count(struct page *page)
 
 static inline bool __compound_tail_refcounted(struct page *page)
 {
-        return !PageSlab(page) && !PageHeadHuge(page);
+        return PageAnon(page) && !PageSlab(page) && !PageHeadHuge(page);
 }
 
 /*
@@ -1211,10 +1212,13 @@ int __set_page_dirty_nobuffers(struct page *page);
 int __set_page_dirty_no_writeback(struct page *page);
 int redirty_page_for_writepage(struct writeback_control *wbc,
                                 struct page *page);
-void account_page_dirtied(struct page *page, struct address_space *mapping);
-void account_page_cleaned(struct page *page, struct address_space *mapping);
+void account_page_dirtied(struct page *page, struct address_space *mapping,
+                          struct mem_cgroup *memcg);
+void account_page_cleaned(struct page *page, struct address_space *mapping,
+                          struct mem_cgroup *memcg, struct bdi_writeback *wb);
 int set_page_dirty(struct page *page);
 int set_page_dirty_lock(struct page *page);
+void cancel_dirty_page(struct page *page);
 int clear_page_dirty_for_io(struct page *page);
 
 int get_cmdline(struct task_struct *task, char *buffer, int buflen);
@@ -1631,6 +1635,8 @@ extern void free_highmem_page(struct page *page);
 extern void adjust_managed_page_count(struct page *page, long count);
 extern void mem_init_print_info(const char *str);
 
+extern void reserve_bootmem_region(unsigned long start, unsigned long end);
+
 /* Free the reserved page into the buddy system, so it gets managed. */
 static inline void __free_reserved_page(struct page *page)
 {
@@ -1720,7 +1726,8 @@ extern void sparse_memory_present_with_active_regions(int nid);
 
 #if !defined(CONFIG_HAVE_MEMBLOCK_NODE_MAP) && \
     !defined(CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID)
-static inline int __early_pfn_to_nid(unsigned long pfn)
+static inline int __early_pfn_to_nid(unsigned long pfn,
+                                        struct mminit_pfnnid_cache *state)
 {
         return 0;
 }
@@ -1728,7 +1735,8 @@ static inline int __early_pfn_to_nid(unsigned long pfn)
 /* please see mm/page_alloc.c */
 extern int __meminit early_pfn_to_nid(unsigned long pfn);
 /* there is a per-arch backend function. */
-extern int __meminit __early_pfn_to_nid(unsigned long pfn);
+extern int __meminit __early_pfn_to_nid(unsigned long pfn,
+                                        struct mminit_pfnnid_cache *state);
 #endif
 
 extern void set_dma_reserve(unsigned long new_dma_reserve);
@@ -2146,12 +2154,47 @@ enum mf_flags {
 extern int memory_failure(unsigned long pfn, int trapno, int flags);
 extern void memory_failure_queue(unsigned long pfn, int trapno, int flags);
 extern int unpoison_memory(unsigned long pfn);
+extern int get_hwpoison_page(struct page *page);
 extern int sysctl_memory_failure_early_kill;
 extern int sysctl_memory_failure_recovery;
 extern void shake_page(struct page *p, int access);
 extern atomic_long_t num_poisoned_pages;
 extern int soft_offline_page(struct page *page, int flags);
 
+
+/*
+ * Error handlers for various types of pages.
+ */
+enum mf_result {
+        MF_IGNORED,     /* Error: cannot be handled */
+        MF_FAILED,      /* Error: handling failed */
+        MF_DELAYED,     /* Will be handled later */
+        MF_RECOVERED,   /* Successfully recovered */
+};
+
+enum mf_action_page_type {
+        MF_MSG_KERNEL,
+        MF_MSG_KERNEL_HIGH_ORDER,
+        MF_MSG_SLAB,
+        MF_MSG_DIFFERENT_COMPOUND,
+        MF_MSG_POISONED_HUGE,
+        MF_MSG_HUGE,
+        MF_MSG_FREE_HUGE,
+        MF_MSG_UNMAP_FAILED,
+        MF_MSG_DIRTY_SWAPCACHE,
+        MF_MSG_CLEAN_SWAPCACHE,
+        MF_MSG_DIRTY_MLOCKED_LRU,
+        MF_MSG_CLEAN_MLOCKED_LRU,
+        MF_MSG_DIRTY_UNEVICTABLE_LRU,
+        MF_MSG_CLEAN_UNEVICTABLE_LRU,
+        MF_MSG_DIRTY_LRU,
+        MF_MSG_CLEAN_LRU,
+        MF_MSG_TRUNCATED_LRU,
+        MF_MSG_BUDDY,
+        MF_MSG_BUDDY_2ND,
+        MF_MSG_UNKNOWN,
+};
+
 #if defined(CONFIG_TRANSPARENT_HUGEPAGE) || defined(CONFIG_HUGETLBFS)
 extern void clear_huge_page(struct page *page,
                             unsigned long addr,
diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
index 8d37e26a1007..0038ac7466fd 100644
--- a/include/linux/mm_types.h
+++ b/include/linux/mm_types.h
@@ -226,6 +226,24 @@ struct page_frag {
 #endif
 };
 
+#define PAGE_FRAG_CACHE_MAX_SIZE        __ALIGN_MASK(32768, ~PAGE_MASK)
+#define PAGE_FRAG_CACHE_MAX_ORDER       get_order(PAGE_FRAG_CACHE_MAX_SIZE)
+
+struct page_frag_cache {
+        void * va;
+#if (PAGE_SIZE < PAGE_FRAG_CACHE_MAX_SIZE)
+        __u16 offset;
+        __u16 size;
+#else
+        __u32 offset;
+#endif
+        /* we maintain a pagecount bias, so that we dont dirty cache line
+         * containing page->_count every time we allocate a fragment.
+         */
+        unsigned int            pagecnt_bias;
+        bool pfmemalloc;
+};
+
 typedef unsigned long __nocast vm_flags_t;
 
 /*
diff --git a/include/linux/mmiotrace.h b/include/linux/mmiotrace.h
index c5d52780d6a0..3ba327af055c 100644
--- a/include/linux/mmiotrace.h
+++ b/include/linux/mmiotrace.h
@@ -106,6 +106,6 @@ extern void enable_mmiotrace(void);
 extern void disable_mmiotrace(void);
 extern void mmio_trace_rw(struct mmiotrace_rw *rw);
 extern void mmio_trace_mapping(struct mmiotrace_map *map);
-extern int mmio_trace_printk(const char *fmt, va_list args);
+extern __printf(1, 0) int mmio_trace_printk(const char *fmt, va_list args);
 
 #endif /* _LINUX_MMIOTRACE_H */
diff --git a/include/linux/mmu_notifier.h b/include/linux/mmu_notifier.h
index 95243d28a0ee..61cd67f4d788 100644
--- a/include/linux/mmu_notifier.h
+++ b/include/linux/mmu_notifier.h
@@ -324,25 +324,25 @@ static inline void mmu_notifier_mm_destroy(struct mm_struct *mm)
         ___pte;                                                         \
 })
 
-#define pmdp_clear_flush_notify(__vma, __haddr, __pmd)                  \
+#define pmdp_huge_clear_flush_notify(__vma, __haddr, __pmd)             \
 ({                                                                      \
         unsigned long ___haddr = __haddr & HPAGE_PMD_MASK;              \
         struct mm_struct *___mm = (__vma)->vm_mm;                       \
         pmd_t ___pmd;                                                   \
                                                                         \
-        ___pmd = pmdp_clear_flush(__vma, __haddr, __pmd);               \
+        ___pmd = pmdp_huge_clear_flush(__vma, __haddr, __pmd);          \
         mmu_notifier_invalidate_range(___mm, ___haddr,                  \
                                       ___haddr + HPAGE_PMD_SIZE);       \
                                                                         \
         ___pmd;                                                         \
 })
 
-#define pmdp_get_and_clear_notify(__mm, __haddr, __pmd)                 \
+#define pmdp_huge_get_and_clear_notify(__mm, __haddr, __pmd)            \
 ({                                                                      \
         unsigned long ___haddr = __haddr & HPAGE_PMD_MASK;              \
         pmd_t ___pmd;                                                   \
                                                                         \
-        ___pmd = pmdp_get_and_clear(__mm, __haddr, __pmd);              \
+        ___pmd = pmdp_huge_get_and_clear(__mm, __haddr, __pmd);         \
         mmu_notifier_invalidate_range(__mm, ___haddr,                   \
                                       ___haddr + HPAGE_PMD_SIZE);       \
                                                                         \
@@ -428,8 +428,8 @@ static inline void mmu_notifier_mm_destroy(struct mm_struct *mm)
 #define ptep_clear_flush_young_notify ptep_clear_flush_young
 #define pmdp_clear_flush_young_notify pmdp_clear_flush_young
 #define ptep_clear_flush_notify ptep_clear_flush
-#define pmdp_clear_flush_notify pmdp_clear_flush
-#define pmdp_get_and_clear_notify pmdp_get_and_clear
+#define pmdp_huge_clear_flush_notify pmdp_huge_clear_flush
+#define pmdp_huge_get_and_clear_notify pmdp_huge_get_and_clear
 #define set_pte_at_notify set_pte_at
 
 #endif /* CONFIG_MMU_NOTIFIER */
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index 54d74f6eb233..754c25966a0a 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -762,6 +762,14 @@ typedef struct pglist_data {
         /* Number of pages migrated during the rate limiting time interval */
         unsigned long numabalancing_migrate_nr_pages;
 #endif
+
+#ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT
+        /*
+         * If memory initialisation on large machines is deferred then this
+         * is the first PFN that needs to be initialised.
+         */
+        unsigned long first_deferred_pfn;
+#endif /* CONFIG_DEFERRED_STRUCT_PAGE_INIT */
 } pg_data_t;
 
 #define node_present_pages(nid) (NODE_DATA(nid)->node_present_pages)
@@ -1216,11 +1224,16 @@ void sparse_init(void);
 #define sparse_index_init(_sec, _nid)  do {} while (0)
 #endif /* CONFIG_SPARSEMEM */
 
-#ifdef CONFIG_NODES_SPAN_OTHER_NODES
-bool early_pfn_in_nid(unsigned long pfn, int nid);
-#else
-#define early_pfn_in_nid(pfn, nid)      (1)
-#endif
+/*
+ * During memory init memblocks map pfns to nids. The search is expensive and
+ * this caches recent lookups. The implementation of __early_pfn_to_nid
+ * may treat start/end as pfns or sections.
+ */
+struct mminit_pfnnid_cache {
+        unsigned long last_start;
+        unsigned long last_end;
+        int last_nid;
+};
 
 #ifndef early_pfn_valid
 #define early_pfn_valid(pfn)    (1)
diff --git a/include/linux/mod_devicetable.h b/include/linux/mod_devicetable.h
index 3bfd56778c29..34f25b7bf642 100644
--- a/include/linux/mod_devicetable.h
+++ b/include/linux/mod_devicetable.h
@@ -189,6 +189,8 @@ struct css_device_id {
 struct acpi_device_id {
         __u8 id[ACPI_ID_LEN];
         kernel_ulong_t driver_data;
+        __u32 cls;
+        __u32 cls_msk;
 };
 
 #define PNP_ID_LEN      8
@@ -599,9 +601,22 @@ struct ipack_device_id {
 
 #define MEI_CL_MODULE_PREFIX "mei:"
 #define MEI_CL_NAME_SIZE 32
+#define MEI_CL_UUID_FMT "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x"
+#define MEI_CL_UUID_ARGS(_u) \
+        _u[0], _u[1], _u[2], _u[3], _u[4], _u[5], _u[6], _u[7], \
+        _u[8], _u[9], _u[10], _u[11], _u[12], _u[13], _u[14], _u[15]
 
+/**
+ * struct mei_cl_device_id - MEI client device identifier
+ * @name: helper name
+ * @uuid: client uuid
+ * @driver_info: information used by the driver.
+ *
+ * identifies mei client device by uuid and name
+ */
 struct mei_cl_device_id {
         char name[MEI_CL_NAME_SIZE];
+        uuid_le uuid;
         kernel_ulong_t driver_info;
 };
 
@@ -629,4 +644,10 @@ struct mcb_device_id {
         kernel_ulong_t driver_data;
 };
 
+struct ulpi_device_id {
+        __u16 vendor;
+        __u16 product;
+        kernel_ulong_t driver_data;
+};
+
 #endif /* LINUX_MOD_DEVICETABLE_H */
diff --git a/include/linux/module.h b/include/linux/module.h
index 1e5436042eb0..3a19c79918e0 100644
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -11,12 +11,14 @@
 #include <linux/compiler.h>
 #include <linux/cache.h>
 #include <linux/kmod.h>
+#include <linux/init.h>
 #include <linux/elf.h>
 #include <linux/stringify.h>
 #include <linux/kobject.h>
 #include <linux/moduleparam.h>
 #include <linux/jump_label.h>
 #include <linux/export.h>
+#include <linux/rbtree_latch.h>
 
 #include <linux/percpu.h>
 #include <asm/module.h>
@@ -70,6 +72,89 @@ extern struct module_attribute module_uevent;
 extern int init_module(void);
 extern void cleanup_module(void);
 
+#ifndef MODULE
+/**
+ * module_init() - driver initialization entry point
+ * @x: function to be run at kernel boot time or module insertion
+ *
+ * module_init() will either be called during do_initcalls() (if
+ * builtin) or at module insertion time (if a module).  There can only
+ * be one per module.
+ */
+#define module_init(x)  __initcall(x);
+
+/**
+ * module_exit() - driver exit entry point
+ * @x: function to be run when driver is removed
+ *
+ * module_exit() will wrap the driver clean-up code
+ * with cleanup_module() when used with rmmod when
+ * the driver is a module.  If the driver is statically
+ * compiled into the kernel, module_exit() has no effect.
+ * There can only be one per module.
+ */
+#define module_exit(x)  __exitcall(x);
+
+#else /* MODULE */
+
+/*
+ * In most cases loadable modules do not need custom
+ * initcall levels. There are still some valid cases where
+ * a driver may be needed early if built in, and does not
+ * matter when built as a loadable module. Like bus
+ * snooping debug drivers.
+ */
+#define early_initcall(fn)              module_init(fn)
+#define core_initcall(fn)               module_init(fn)
+#define core_initcall_sync(fn)          module_init(fn)
+#define postcore_initcall(fn)           module_init(fn)
+#define postcore_initcall_sync(fn)      module_init(fn)
+#define arch_initcall(fn)               module_init(fn)
+#define subsys_initcall(fn)             module_init(fn)
+#define subsys_initcall_sync(fn)        module_init(fn)
+#define fs_initcall(fn)                 module_init(fn)
+#define fs_initcall_sync(fn)            module_init(fn)
+#define rootfs_initcall(fn)             module_init(fn)
+#define device_initcall(fn)             module_init(fn)
+#define device_initcall_sync(fn)        module_init(fn)
+#define late_initcall(fn)               module_init(fn)
+#define late_initcall_sync(fn)          module_init(fn)
+
+#define console_initcall(fn)            module_init(fn)
+#define security_initcall(fn)           module_init(fn)
+
+/* Each module must use one module_init(). */
+#define module_init(initfn)                                     \
+        static inline initcall_t __inittest(void)               \
+        { return initfn; }                                      \
+        int init_module(void) __attribute__((alias(#initfn)));
+
+/* This is only required if you want to be unloadable. */
+#define module_exit(exitfn)                                     \
+        static inline exitcall_t __exittest(void)               \
+        { return exitfn; }                                      \
+        void cleanup_module(void) __attribute__((alias(#exitfn)));
+
+#endif
+
+/* This means "can be init if no module support, otherwise module load
+   may call it." */
+#ifdef CONFIG_MODULES
+#define __init_or_module
+#define __initdata_or_module
+#define __initconst_or_module
+#define __INIT_OR_MODULE        .text
+#define __INITDATA_OR_MODULE    .data
+#define __INITRODATA_OR_MODULE  .section ".rodata","a",%progbits
+#else
+#define __init_or_module __init
+#define __initdata_or_module __initdata
+#define __initconst_or_module __initconst
+#define __INIT_OR_MODULE __INIT
+#define __INITDATA_OR_MODULE __INITDATA
+#define __INITRODATA_OR_MODULE __INITRODATA
+#endif /*CONFIG_MODULES*/
+
 /* Archs provide a method of finding the correct exception table. */
 struct exception_table_entry;
 
@@ -210,6 +295,13 @@ enum module_state {
         MODULE_STATE_UNFORMED,  /* Still setting it up. */
 };
 
+struct module;
+
+struct mod_tree_node {
+        struct module *mod;
+        struct latch_tree_node node;
+};
+
 struct module {
         enum module_state state;
 
@@ -232,6 +324,9 @@ struct module {
         unsigned int num_syms;
 
         /* Kernel parameters. */
+#ifdef CONFIG_SYSFS
+        struct mutex param_lock;
+#endif
         struct kernel_param *kp;
         unsigned int num_kp;
 
@@ -257,6 +352,8 @@ struct module {
         bool sig_ok;
 #endif
 
+        bool async_probe_requested;
+
         /* symbols that will be GPL-only in the near future. */
         const struct kernel_symbol *gpl_future_syms;
         const unsigned long *gpl_future_crcs;
@@ -269,8 +366,15 @@ struct module {
         /* Startup function. */
         int (*init)(void);
 
-        /* If this is non-NULL, vfree after init() returns */
-        void *module_init;
+        /*
+         * If this is non-NULL, vfree() after init() returns.
+         *
+         * Cacheline align here, such that:
+         *   module_init, module_core, init_size, core_size,
+         *   init_text_size, core_text_size and mtn_core::{mod,node[0]}
+         * are on the same cacheline.
+         */
+        void *module_init       ____cacheline_aligned;
 
         /* Here is the actual code + data, vfree'd on unload. */
         void *module_core;
@@ -281,6 +385,16 @@ struct module {
         /* The size of the executable code in each section.  */
         unsigned int init_text_size, core_text_size;
 
+#ifdef CONFIG_MODULES_TREE_LOOKUP
+        /*
+         * We want mtn_core::{mod,node[0]} to be in the same cacheline as the
+         * above entries such that a regular lookup will only touch one
+         * cacheline.
+         */
+        struct mod_tree_node    mtn_core;
+        struct mod_tree_node    mtn_init;
+#endif
+
         /* Size of RO sections of the module (text+rodata) */
         unsigned int init_ro_size, core_ro_size;
 
@@ -336,7 +450,7 @@ struct module {
         const char **trace_bprintk_fmt_start;
 #endif
 #ifdef CONFIG_EVENT_TRACING
-        struct ftrace_event_call **trace_events;
+        struct trace_event_call **trace_events;
         unsigned int num_trace_events;
         struct trace_enum_map **trace_enums;
         unsigned int num_trace_enums;
@@ -367,7 +481,7 @@ struct module {
         ctor_fn_t *ctors;
         unsigned int num_ctors;
 #endif
-};
+} ____cacheline_aligned;
 #ifndef MODULE_ARCH_INIT
 #define MODULE_ARCH_INIT {}
 #endif
@@ -421,14 +535,22 @@ struct symsearch {
         bool unused;
 };
 
-/* Search for an exported symbol by name. */
+/*
+ * Search for an exported symbol by name.
+ *
+ * Must be called with module_mutex held or preemption disabled.
+ */
 const struct kernel_symbol *find_symbol(const char *name,
                                         struct module **owner,
                                         const unsigned long **crc,
                                         bool gplok,
                                         bool warn);
 
-/* Walk the exported symbol table */
+/*
+ * Walk the exported symbol table
+ *
+ * Must be called with module_mutex held or preemption disabled.
+ */
 bool each_symbol_section(bool (*fn)(const struct symsearch *arr,
                                     struct module *owner,
                                     void *data), void *data);
@@ -508,6 +630,11 @@ int unregister_module_notifier(struct notifier_block *nb);
 
 extern void print_modules(void);
 
+static inline bool module_requested_async_probing(struct module *module)
+{
+        return module && module->async_probe_requested;
+}
+
 #else /* !CONFIG_MODULES... */
 
 /* Given an address, look for it in the exception tables. */
@@ -618,6 +745,12 @@ static inline int unregister_module_notifier(struct notifier_block *nb)
 static inline void print_modules(void)
 {
 }
+
+static inline bool module_requested_async_probing(struct module *module)
+{
+        return false;
+}
+
 #endif /* CONFIG_MODULES */
 
 #ifdef CONFIG_SYSFS
diff --git a/include/linux/moduleparam.h b/include/linux/moduleparam.h
index 1c9effa25e26..c12f2147c350 100644
--- a/include/linux/moduleparam.h
+++ b/include/linux/moduleparam.h
@@ -67,8 +67,9 @@ enum {
 
 struct kernel_param {
         const char *name;
+        struct module *mod;
         const struct kernel_param_ops *ops;
-        u16 perm;
+        const u16 perm;
         s8 level;
         u8 flags;
         union {
@@ -108,7 +109,7 @@ struct kparam_array
  *
  * @perm is 0 if the the variable is not to appear in sysfs, or 0444
  * for world-readable, 0644 for root-writable, etc.  Note that if it
- * is writable, you may need to use kparam_block_sysfs_write() around
+ * is writable, you may need to use kernel_param_lock() around
  * accesses (esp. charp, which can be kfreed when it changes).
  *
  * The @type is simply pasted to refer to a param_ops_##type and a
@@ -216,16 +217,16 @@ struct kparam_array
    parameters. */
 #define __module_param_call(prefix, name, ops, arg, perm, level, flags) \
         /* Default value instead of permissions? */                     \
-        static const char __param_str_##name[] = prefix #name; \
+        static const char __param_str_##name[] = prefix #name;          \
         static struct kernel_param __moduleparam_const __param_##name   \
         __used                                                          \
     __attribute__ ((unused,__section__ ("__param"),aligned(sizeof(void *)))) \
-        = { __param_str_##name, ops, VERIFY_OCTAL_PERMISSIONS(perm),    \
-            level, flags, { arg } }
+        = { __param_str_##name, THIS_MODULE, ops,                       \
+            VERIFY_OCTAL_PERMISSIONS(perm), level, flags, { arg } }
 
 /* Obsolete - use module_param_cb() */
 #define module_param_call(name, set, get, arg, perm)                    \
-        static struct kernel_param_ops __param_ops_##name =             \
+        static const struct kernel_param_ops __param_ops_##name =               \
                 { .flags = 0, (void *)set, (void *)get };               \
         __module_param_call(MODULE_PARAM_PREFIX,                        \
                             name, &__param_ops_##name, arg,             \
@@ -238,58 +239,14 @@ __check_old_set_param(int (*oldset)(const char *, struct kernel_param *))
         return 0;
 }
 
-/**
- * kparam_block_sysfs_write - make sure a parameter isn't written via sysfs.
- * @name: the name of the parameter
- *
- * There's no point blocking write on a paramter that isn't writable via sysfs!
- */
-#define kparam_block_sysfs_write(name)                  \
-        do {                                            \
-                BUG_ON(!(__param_##name.perm & 0222));  \
-                __kernel_param_lock();                  \
-        } while (0)
-
-/**
- * kparam_unblock_sysfs_write - allows sysfs to write to a parameter again.
- * @name: the name of the parameter
- */
-#define kparam_unblock_sysfs_write(name)                \
-        do {                                            \
-                BUG_ON(!(__param_##name.perm & 0222));  \
-                __kernel_param_unlock();                \
-        } while (0)
-
-/**
- * kparam_block_sysfs_read - make sure a parameter isn't read via sysfs.
- * @name: the name of the parameter
- *
- * This also blocks sysfs writes.
- */
-#define kparam_block_sysfs_read(name)                   \
-        do {                                            \
-                BUG_ON(!(__param_##name.perm & 0444));  \
-                __kernel_param_lock();                  \
-        } while (0)
-
-/**
- * kparam_unblock_sysfs_read - allows sysfs to read a parameter again.
- * @name: the name of the parameter
- */
-#define kparam_unblock_sysfs_read(name)                 \
-        do {                                            \
-                BUG_ON(!(__param_##name.perm & 0444));  \
-                __kernel_param_unlock();                \
-        } while (0)
-
 #ifdef CONFIG_SYSFS
-extern void __kernel_param_lock(void);
-extern void __kernel_param_unlock(void);
+extern void kernel_param_lock(struct module *mod);
+extern void kernel_param_unlock(struct module *mod);
 #else
-static inline void __kernel_param_lock(void)
+static inline void kernel_param_lock(struct module *mod)
 {
 }
-static inline void __kernel_param_unlock(void)
+static inline void kernel_param_unlock(struct module *mod)
 {
 }
 #endif
@@ -310,6 +267,15 @@ static inline void __kernel_param_unlock(void)
 #define core_param(name, var, type, perm)                               \
         param_check_##type(name, &(var));                               \
         __module_param_call("", name, &param_ops_##type, &var, perm, -1, 0)
+
+/**
+ * core_param_unsafe - same as core_param but taints kernel
+ */
+#define core_param_unsafe(name, var, type, perm)                \
+        param_check_##type(name, &(var));                               \
+        __module_param_call("", name, &param_ops_##type, &var, perm,    \
+                            -1, KERNEL_PARAM_FL_UNSAFE)
+
 #endif /* !MODULE */
 
 /**
@@ -357,8 +323,9 @@ extern char *parse_args(const char *name,
                       unsigned num,
                       s16 level_min,
                       s16 level_max,
+                      void *arg,
                       int (*unknown)(char *param, char *val,
-                              const char *doing));
+                                     const char *doing, void *arg));
 
 /* Called by module remove. */
 #ifdef CONFIG_SYSFS
@@ -376,64 +343,70 @@ static inline void destroy_params(const struct kernel_param *params,
 #define __param_check(name, p, type) \
         static inline type __always_unused *__check_##name(void) { return(p); }
 
-extern struct kernel_param_ops param_ops_byte;
+extern const struct kernel_param_ops param_ops_byte;
 extern int param_set_byte(const char *val, const struct kernel_param *kp);
 extern int param_get_byte(char *buffer, const struct kernel_param *kp);
 #define param_check_byte(name, p) __param_check(name, p, unsigned char)
 
-extern struct kernel_param_ops param_ops_short;
+extern const struct kernel_param_ops param_ops_short;
 extern int param_set_short(const char *val, const struct kernel_param *kp);
 extern int param_get_short(char *buffer, const struct kernel_param *kp);
 #define param_check_short(name, p) __param_check(name, p, short)
 
-extern struct kernel_param_ops param_ops_ushort;
+extern const struct kernel_param_ops param_ops_ushort;
 extern int param_set_ushort(const char *val, const struct kernel_param *kp);
 extern int param_get_ushort(char *buffer, const struct kernel_param *kp);
 #define param_check_ushort(name, p) __param_check(name, p, unsigned short)
 
-extern struct kernel_param_ops param_ops_int;
+extern const struct kernel_param_ops param_ops_int;
 extern int param_set_int(const char *val, const struct kernel_param *kp);
 extern int param_get_int(char *buffer, const struct kernel_param *kp);
 #define param_check_int(name, p) __param_check(name, p, int)
 
-extern struct kernel_param_ops param_ops_uint;
+extern const struct kernel_param_ops param_ops_uint;
 extern int param_set_uint(const char *val, const struct kernel_param *kp);
 extern int param_get_uint(char *buffer, const struct kernel_param *kp);
 #define param_check_uint(name, p) __param_check(name, p, unsigned int)
 
-extern struct kernel_param_ops param_ops_long;
+extern const struct kernel_param_ops param_ops_long;
 extern int param_set_long(const char *val, const struct kernel_param *kp);
 extern int param_get_long(char *buffer, const struct kernel_param *kp);
 #define param_check_long(name, p) __param_check(name, p, long)
 
-extern struct kernel_param_ops param_ops_ulong;
+extern const struct kernel_param_ops param_ops_ulong;
 extern int param_set_ulong(const char *val, const struct kernel_param *kp);
 extern int param_get_ulong(char *buffer, const struct kernel_param *kp);
 #define param_check_ulong(name, p) __param_check(name, p, unsigned long)
 
-extern struct kernel_param_ops param_ops_ullong;
+extern const struct kernel_param_ops param_ops_ullong;
 extern int param_set_ullong(const char *val, const struct kernel_param *kp);
 extern int param_get_ullong(char *buffer, const struct kernel_param *kp);
 #define param_check_ullong(name, p) __param_check(name, p, unsigned long long)
 
-extern struct kernel_param_ops param_ops_charp;
+extern const struct kernel_param_ops param_ops_charp;
 extern int param_set_charp(const char *val, const struct kernel_param *kp);
 extern int param_get_charp(char *buffer, const struct kernel_param *kp);
 #define param_check_charp(name, p) __param_check(name, p, char *)
 
 /* We used to allow int as well as bool.  We're taking that away! */
-extern struct kernel_param_ops param_ops_bool;
+extern const struct kernel_param_ops param_ops_bool;
 extern int param_set_bool(const char *val, const struct kernel_param *kp);
 extern int param_get_bool(char *buffer, const struct kernel_param *kp);
 #define param_check_bool(name, p) __param_check(name, p, bool)
 
-extern struct kernel_param_ops param_ops_invbool;
+extern const struct kernel_param_ops param_ops_bool_enable_only;
+extern int param_set_bool_enable_only(const char *val,
+                                      const struct kernel_param *kp);
+/* getter is the same as for the regular bool */
+#define param_check_bool_enable_only param_check_bool
+
+extern const struct kernel_param_ops param_ops_invbool;
 extern int param_set_invbool(const char *val, const struct kernel_param *kp);
 extern int param_get_invbool(char *buffer, const struct kernel_param *kp);
 #define param_check_invbool(name, p) __param_check(name, p, bool)
 
 /* An int, which can only be set like a bool (though it shows as an int). */
-extern struct kernel_param_ops param_ops_bint;
+extern const struct kernel_param_ops param_ops_bint;
 extern int param_set_bint(const char *val, const struct kernel_param *kp);
 #define param_get_bint param_get_int
 #define param_check_bint param_check_int
@@ -477,9 +450,9 @@ extern int param_set_bint(const char *val, const struct kernel_param *kp);
                             perm, -1, 0);                               \
         __MODULE_PARM_TYPE(name, "array of " #type)
 
-extern struct kernel_param_ops param_array_ops;
+extern const struct kernel_param_ops param_array_ops;
 
-extern struct kernel_param_ops param_ops_string;
+extern const struct kernel_param_ops param_ops_string;
 extern int param_set_copystring(const char *val, const struct kernel_param *);
 extern int param_get_string(char *buffer, const struct kernel_param *kp);
 
diff --git a/include/linux/mtd/cfi.h b/include/linux/mtd/cfi.h
index 299d7d31fe53..9b57a9b1b081 100644
--- a/include/linux/mtd/cfi.h
+++ b/include/linux/mtd/cfi.h
@@ -296,183 +296,19 @@ struct cfi_private {
         struct flchip chips[0];  /* per-chip data structure for each chip */
 };
 
-/*
- * Returns the command address according to the given geometry.
- */
-static inline uint32_t cfi_build_cmd_addr(uint32_t cmd_ofs,
-                                struct map_info *map, struct cfi_private *cfi)
-{
-        unsigned bankwidth = map_bankwidth(map);
-        unsigned interleave = cfi_interleave(cfi);
-        unsigned type = cfi->device_type;
-        uint32_t addr;
-        
-        addr = (cmd_ofs * type) * interleave;
-
-        /* Modify the unlock address if we are in compatibility mode.
-         * For 16bit devices on 8 bit busses
-         * and 32bit devices on 16 bit busses
-         * set the low bit of the alternating bit sequence of the address.
-         */
-        if (((type * interleave) > bankwidth) && ((cmd_ofs & 0xff) == 0xaa))
-                addr |= (type >> 1)*interleave;
-
-        return  addr;
-}
-
-/*
- * Transforms the CFI command for the given geometry (bus width & interleave).
- * It looks too long to be inline, but in the common case it should almost all
- * get optimised away.
- */
-static inline map_word cfi_build_cmd(u_long cmd, struct map_info *map, struct cfi_private *cfi)
-{
-        map_word val = { {0} };
-        int wordwidth, words_per_bus, chip_mode, chips_per_word;
-        unsigned long onecmd;
-        int i;
-
-        /* We do it this way to give the compiler a fighting chance
-           of optimising away all the crap for 'bankwidth' larger than
-           an unsigned long, in the common case where that support is
-           disabled */
-        if (map_bankwidth_is_large(map)) {
-                wordwidth = sizeof(unsigned long);
-                words_per_bus = (map_bankwidth(map)) / wordwidth; // i.e. normally 1
-        } else {
-                wordwidth = map_bankwidth(map);
-                words_per_bus = 1;
-        }
-
-        chip_mode = map_bankwidth(map) / cfi_interleave(cfi);
-        chips_per_word = wordwidth * cfi_interleave(cfi) / map_bankwidth(map);
-
-        /* First, determine what the bit-pattern should be for a single
-           device, according to chip mode and endianness... */
-        switch (chip_mode) {
-        default: BUG();
-        case 1:
-                onecmd = cmd;
-                break;
-        case 2:
-                onecmd = cpu_to_cfi16(map, cmd);
-                break;
-        case 4:
-                onecmd = cpu_to_cfi32(map, cmd);
-                break;
-        }
-
-        /* Now replicate it across the size of an unsigned long, or
-           just to the bus width as appropriate */
-        switch (chips_per_word) {
-        default: BUG();
-#if BITS_PER_LONG >= 64
-        case 8:
-                onecmd |= (onecmd << (chip_mode * 32));
-#endif
-        case 4:
-                onecmd |= (onecmd << (chip_mode * 16));
-        case 2:
-                onecmd |= (onecmd << (chip_mode * 8));
-        case 1:
-                ;
-        }
+uint32_t cfi_build_cmd_addr(uint32_t cmd_ofs,
+                                struct map_info *map, struct cfi_private *cfi);
 
-        /* And finally, for the multi-word case, replicate it
-           in all words in the structure */
-        for (i=0; i < words_per_bus; i++) {
-                val.x[i] = onecmd;
-        }
-
-        return val;
-}
+map_word cfi_build_cmd(u_long cmd, struct map_info *map, struct cfi_private *cfi);
 #define CMD(x)  cfi_build_cmd((x), map, cfi)
 
-
-static inline unsigned long cfi_merge_status(map_word val, struct map_info *map,
-                                           struct cfi_private *cfi)
-{
-        int wordwidth, words_per_bus, chip_mode, chips_per_word;
-        unsigned long onestat, res = 0;
-        int i;
-
-        /* We do it this way to give the compiler a fighting chance
-           of optimising away all the crap for 'bankwidth' larger than
-           an unsigned long, in the common case where that support is
-           disabled */
-        if (map_bankwidth_is_large(map)) {
-                wordwidth = sizeof(unsigned long);
-                words_per_bus = (map_bankwidth(map)) / wordwidth; // i.e. normally 1
-        } else {
-                wordwidth = map_bankwidth(map);
-                words_per_bus = 1;
-        }
-
-        chip_mode = map_bankwidth(map) / cfi_interleave(cfi);
-        chips_per_word = wordwidth * cfi_interleave(cfi) / map_bankwidth(map);
-
-        onestat = val.x[0];
-        /* Or all status words together */
-        for (i=1; i < words_per_bus; i++) {
-                onestat |= val.x[i];
-        }
-
-        res = onestat;
-        switch(chips_per_word) {
-        default: BUG();
-#if BITS_PER_LONG >= 64
-        case 8:
-                res |= (onestat >> (chip_mode * 32));
-#endif
-        case 4:
-                res |= (onestat >> (chip_mode * 16));
-        case 2:
-                res |= (onestat >> (chip_mode * 8));
-        case 1:
-                ;
-        }
-
-        /* Last, determine what the bit-pattern should be for a single
-           device, according to chip mode and endianness... */
-        switch (chip_mode) {
-        case 1:
-                break;
-        case 2:
-                res = cfi16_to_cpu(map, res);
-                break;
-        case 4:
-                res = cfi32_to_cpu(map, res);
-                break;
-        default: BUG();
-        }
-        return res;
-}
-
+unsigned long cfi_merge_status(map_word val, struct map_info *map,
+                                           struct cfi_private *cfi);
 #define MERGESTATUS(x) cfi_merge_status((x), map, cfi)
 
-
-/*
- * Sends a CFI command to a bank of flash for the given geometry.
- *
- * Returns the offset in flash where the command was written.
- * If prev_val is non-null, it will be set to the value at the command address,
- * before the command was written.
- */
-static inline uint32_t cfi_send_gen_cmd(u_char cmd, uint32_t cmd_addr, uint32_t base,
+uint32_t cfi_send_gen_cmd(u_char cmd, uint32_t cmd_addr, uint32_t base,
                                 struct map_info *map, struct cfi_private *cfi,
-                                int type, map_word *prev_val)
-{
-        map_word val;
-        uint32_t addr = base + cfi_build_cmd_addr(cmd_addr, map, cfi);
-        val = cfi_build_cmd(cmd, map, cfi);
-
-        if (prev_val)
-                *prev_val = map_read(map, addr);
-
-        map_write(map, val, addr);
-
-        return addr - base;
-}
+                                int type, map_word *prev_val);
 
 static inline uint8_t cfi_read_query(struct map_info *map, uint32_t addr)
 {
@@ -506,15 +342,7 @@ static inline uint16_t cfi_read_query16(struct map_info *map, uint32_t addr)
         }
 }
 
-static inline void cfi_udelay(int us)
-{
-        if (us >= 1000) {
-                msleep((us+999)/1000);
-        } else {
-                udelay(us);
-                cond_resched();
-        }
-}
+void cfi_udelay(int us);
 
 int __xipram cfi_qry_present(struct map_info *map, __u32 base,
                              struct cfi_private *cfi);
diff --git a/include/linux/mtd/nand.h b/include/linux/mtd/nand.h
index 3d4ea7eb2b68..272f42952f34 100644
--- a/include/linux/mtd/nand.h
+++ b/include/linux/mtd/nand.h
@@ -26,6 +26,8 @@
 
 struct mtd_info;
 struct nand_flash_dev;
+struct device_node;
+
 /* Scan and identify a NAND device */
 extern int nand_scan(struct mtd_info *mtd, int max_chips);
 /*
@@ -176,17 +178,17 @@ typedef enum {
 /* Chip may not exist, so silence any errors in scan */
 #define NAND_SCAN_SILENT_NODEV  0x00040000
 /*
- * This option could be defined by controller drivers to protect against
- * kmap'ed, vmalloc'ed highmem buffers being passed from upper layers
- */
-#define NAND_USE_BOUNCE_BUFFER  0x00080000
-/*
  * Autodetect nand buswidth with readid/onfi.
  * This suppose the driver will configure the hardware in 8 bits mode
  * when calling nand_scan_ident, and update its configuration
  * before calling nand_scan_tail.
  */
 #define NAND_BUSWIDTH_AUTO      0x00080000
+/*
+ * This option could be defined by controller drivers to protect against
+ * kmap'ed, vmalloc'ed highmem buffers being passed from upper layers
+ */
+#define NAND_USE_BOUNCE_BUFFER  0x00100000
 
 /* Options set by nand scan */
 /* Nand scan has allocated controller struct */
@@ -542,6 +544,7 @@ struct nand_buffers {
  *                      flash device
  * @IO_ADDR_W:          [BOARDSPECIFIC] address to write the 8 I/O lines of the
  *                      flash device.
+ * @dn:                 [BOARDSPECIFIC] device node describing this instance
  * @read_byte:          [REPLACEABLE] read one byte from the chip
  * @read_word:          [REPLACEABLE] read one word from the chip
  * @write_byte:         [REPLACEABLE] write a single byte to the chip on the
@@ -644,6 +647,8 @@ struct nand_chip {
         void __iomem *IO_ADDR_R;
         void __iomem *IO_ADDR_W;
 
+        struct device_node *dn;
+
         uint8_t (*read_byte)(struct mtd_info *mtd);
         u16 (*read_word)(struct mtd_info *mtd);
         void (*write_byte)(struct mtd_info *mtd, uint8_t byte);
@@ -833,7 +838,6 @@ struct nand_manufacturers {
 extern struct nand_flash_dev nand_flash_ids[];
 extern struct nand_manufacturers nand_manuf_ids[];
 
-extern int nand_scan_bbt(struct mtd_info *mtd, struct nand_bbt_descr *bd);
 extern int nand_default_bbt(struct mtd_info *mtd);
 extern int nand_markbad_bbt(struct mtd_info *mtd, loff_t offs);
 extern int nand_isreserved_bbt(struct mtd_info *mtd, loff_t offs);
diff --git a/include/linux/nd.h b/include/linux/nd.h
new file mode 100644
index 000000000000..507e47c86737
--- /dev/null
+++ b/include/linux/nd.h
@@ -0,0 +1,151 @@
+/*
+ * Copyright(c) 2013-2015 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ */
+#ifndef __LINUX_ND_H__
+#define __LINUX_ND_H__
+#include <linux/fs.h>
+#include <linux/ndctl.h>
+#include <linux/device.h>
+
+struct nd_device_driver {
+        struct device_driver drv;
+        unsigned long type;
+        int (*probe)(struct device *dev);
+        int (*remove)(struct device *dev);
+};
+
+static inline struct nd_device_driver *to_nd_device_driver(
+                struct device_driver *drv)
+{
+        return container_of(drv, struct nd_device_driver, drv);
+};
+
+/**
+ * struct nd_namespace_common - core infrastructure of a namespace
+ * @force_raw: ignore other personalities for the namespace (e.g. btt)
+ * @dev: device model node
+ * @claim: when set a another personality has taken ownership of the namespace
+ * @rw_bytes: access the raw namespace capacity with byte-aligned transfers
+ */
+struct nd_namespace_common {
+        int force_raw;
+        struct device dev;
+        struct device *claim;
+        int (*rw_bytes)(struct nd_namespace_common *, resource_size_t offset,
+                        void *buf, size_t size, int rw);
+};
+
+static inline struct nd_namespace_common *to_ndns(struct device *dev)
+{
+        return container_of(dev, struct nd_namespace_common, dev);
+}
+
+/**
+ * struct nd_namespace_io - infrastructure for loading an nd_pmem instance
+ * @dev: namespace device created by the nd region driver
+ * @res: struct resource conversion of a NFIT SPA table
+ */
+struct nd_namespace_io {
+        struct nd_namespace_common common;
+        struct resource res;
+};
+
+/**
+ * struct nd_namespace_pmem - namespace device for dimm-backed interleaved memory
+ * @nsio: device and system physical address range to drive
+ * @alt_name: namespace name supplied in the dimm label
+ * @uuid: namespace name supplied in the dimm label
+ */
+struct nd_namespace_pmem {
+        struct nd_namespace_io nsio;
+        char *alt_name;
+        u8 *uuid;
+};
+
+/**
+ * struct nd_namespace_blk - namespace for dimm-bounded persistent memory
+ * @alt_name: namespace name supplied in the dimm label
+ * @uuid: namespace name supplied in the dimm label
+ * @id: ida allocated id
+ * @lbasize: blk namespaces have a native sector size when btt not present
+ * @num_resources: number of dpa extents to claim
+ * @res: discontiguous dpa extents for given dimm
+ */
+struct nd_namespace_blk {
+        struct nd_namespace_common common;
+        char *alt_name;
+        u8 *uuid;
+        int id;
+        unsigned long lbasize;
+        int num_resources;
+        struct resource **res;
+};
+
+static inline struct nd_namespace_io *to_nd_namespace_io(struct device *dev)
+{
+        return container_of(dev, struct nd_namespace_io, common.dev);
+}
+
+static inline struct nd_namespace_pmem *to_nd_namespace_pmem(struct device *dev)
+{
+        struct nd_namespace_io *nsio = to_nd_namespace_io(dev);
+
+        return container_of(nsio, struct nd_namespace_pmem, nsio);
+}
+
+static inline struct nd_namespace_blk *to_nd_namespace_blk(struct device *dev)
+{
+        return container_of(dev, struct nd_namespace_blk, common.dev);
+}
+
+/**
+ * nvdimm_read_bytes() - synchronously read bytes from an nvdimm namespace
+ * @ndns: device to read
+ * @offset: namespace-relative starting offset
+ * @buf: buffer to fill
+ * @size: transfer length
+ *
+ * @buf is up-to-date upon return from this routine.
+ */
+static inline int nvdimm_read_bytes(struct nd_namespace_common *ndns,
+                resource_size_t offset, void *buf, size_t size)
+{
+        return ndns->rw_bytes(ndns, offset, buf, size, READ);
+}
+
+/**
+ * nvdimm_write_bytes() - synchronously write bytes to an nvdimm namespace
+ * @ndns: device to read
+ * @offset: namespace-relative starting offset
+ * @buf: buffer to drain
+ * @size: transfer length
+ *
+ * NVDIMM Namepaces disks do not implement sectors internally.  Depending on
+ * the @ndns, the contents of @buf may be in cpu cache, platform buffers,
+ * or on backing memory media upon return from this routine.  Flushing
+ * to media is handled internal to the @ndns driver, if at all.
+ */
+static inline int nvdimm_write_bytes(struct nd_namespace_common *ndns,
+                resource_size_t offset, void *buf, size_t size)
+{
+        return ndns->rw_bytes(ndns, offset, buf, size, WRITE);
+}
+
+#define MODULE_ALIAS_ND_DEVICE(type) \
+        MODULE_ALIAS("nd:t" __stringify(type) "*")
+#define ND_DEVICE_MODALIAS_FMT "nd:t%d"
+
+int __must_check __nd_driver_register(struct nd_device_driver *nd_drv,
+                struct module *module, const char *mod_name);
+#define nd_driver_register(driver) \
+        __nd_driver_register(driver, THIS_MODULE, KBUILD_MODNAME)
+#endif /* __LINUX_ND_H__ */
diff --git a/include/linux/net.h b/include/linux/net.h
index 738ea48be889..04aa06852771 100644
--- a/include/linux/net.h
+++ b/include/linux/net.h
@@ -38,7 +38,6 @@ struct net;
 #define SOCK_NOSPACE            2
 #define SOCK_PASSCRED           3
 #define SOCK_PASSSEC            4
-#define SOCK_EXTERNALLY_ALLOCATED 5
 
 #ifndef ARCH_HAS_SOCKET_TYPES
 /**
@@ -208,7 +207,7 @@ void sock_unregister(int family);
 int __sock_create(struct net *net, int family, int type, int proto,
                   struct socket **res, int kern);
 int sock_create(int family, int type, int proto, struct socket **res);
-int sock_create_kern(int family, int type, int proto, struct socket **res);
+int sock_create_kern(struct net *net, int family, int type, int proto, struct socket **res);
 int sock_create_lite(int family, int type, int proto, struct socket **res);
 void sock_release(struct socket *sock);
 int sock_sendmsg(struct socket *sock, struct msghdr *msg);
diff --git a/include/linux/netdev_features.h b/include/linux/netdev_features.h
index 7d59dc6ab789..9672781c593d 100644
--- a/include/linux/netdev_features.h
+++ b/include/linux/netdev_features.h
@@ -66,7 +66,6 @@ enum {
         NETIF_F_HW_VLAN_STAG_FILTER_BIT,/* Receive filtering on VLAN STAGs */
         NETIF_F_HW_L2FW_DOFFLOAD_BIT,   /* Allow L2 Forwarding in Hardware */
         NETIF_F_BUSY_POLL_BIT,          /* Busy poll */
-        NETIF_F_HW_SWITCH_OFFLOAD_BIT,  /* HW switch offload */
 
         /*
          * Add your fresh new feature above and remember to update
@@ -125,7 +124,6 @@ enum {
 #define NETIF_F_HW_VLAN_STAG_TX __NETIF_F(HW_VLAN_STAG_TX)
 #define NETIF_F_HW_L2FW_DOFFLOAD        __NETIF_F(HW_L2FW_DOFFLOAD)
 #define NETIF_F_BUSY_POLL       __NETIF_F(BUSY_POLL)
-#define NETIF_F_HW_SWITCH_OFFLOAD       __NETIF_F(HW_SWITCH_OFFLOAD)
 
 /* Features valid for ethtool to change */
 /* = all defined minus driver/device-class-related */
@@ -161,8 +159,7 @@ enum {
  */
 #define NETIF_F_ONE_FOR_ALL     (NETIF_F_GSO_SOFTWARE | NETIF_F_GSO_ROBUST | \
                                  NETIF_F_SG | NETIF_F_HIGHDMA |         \
-                                 NETIF_F_FRAGLIST | NETIF_F_VLAN_CHALLENGED | \
-                                 NETIF_F_HW_SWITCH_OFFLOAD)
+                                 NETIF_F_FRAGLIST | NETIF_F_VLAN_CHALLENGED)
 
 /*
  * If one device doesn't support one of these features, then disable it
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index 05b9a694e213..e20979dfd6a9 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -1100,6 +1100,10 @@ struct net_device_ops {
                                                      struct ifla_vf_info *ivf);
         int                     (*ndo_set_vf_link_state)(struct net_device *dev,
                                                          int vf, int link_state);
+        int                     (*ndo_get_vf_stats)(struct net_device *dev,
+                                                    int vf,
+                                                    struct ifla_vf_stats
+                                                    *vf_stats);
         int                     (*ndo_set_vf_port)(struct net_device *dev,
                                                    int vf,
                                                    struct nlattr *port[]);
@@ -1564,7 +1568,7 @@ struct net_device {
         const struct net_device_ops *netdev_ops;
         const struct ethtool_ops *ethtool_ops;
 #ifdef CONFIG_NET_SWITCHDEV
-        const struct swdev_ops *swdev_ops;
+        const struct switchdev_ops *switchdev_ops;
 #endif
 
         const struct header_ops *header_ops;
@@ -1652,7 +1656,14 @@ struct net_device {
         rx_handler_func_t __rcu *rx_handler;
         void __rcu              *rx_handler_data;
 
+#ifdef CONFIG_NET_CLS_ACT
+        struct tcf_proto __rcu  *ingress_cl_list;
+#endif
         struct netdev_queue __rcu *ingress_queue;
+#ifdef CONFIG_NETFILTER_INGRESS
+        struct list_head        nf_hooks_ingress;
+#endif
+
         unsigned char           broadcast[MAX_ADDR_LEN];
 #ifdef CONFIG_RFS_ACCEL
         struct cpu_rmap         *rx_cpu_rmap;
@@ -1990,6 +2001,7 @@ struct offload_callbacks {
 
 struct packet_offload {
         __be16                   type;  /* This is really htons(ether_type). */
+        u16                      priority;
         struct offload_callbacks callbacks;
         struct list_head         list;
 };
@@ -2552,10 +2564,6 @@ static inline void netif_tx_wake_all_queues(struct net_device *dev)
 
 static inline void netif_tx_stop_queue(struct netdev_queue *dev_queue)
 {
-        if (WARN_ON(!dev_queue)) {
-                pr_info("netif_stop_queue() cannot be called before register_netdev()\n");
-                return;
-        }
         set_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state);
 }
 
@@ -2571,15 +2579,7 @@ static inline void netif_stop_queue(struct net_device *dev)
         netif_tx_stop_queue(netdev_get_tx_queue(dev, 0));
 }
 
-static inline void netif_tx_stop_all_queues(struct net_device *dev)
-{
-        unsigned int i;
-
-        for (i = 0; i < dev->num_tx_queues; i++) {
-                struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
-                netif_tx_stop_queue(txq);
-        }
-}
+void netif_tx_stop_all_queues(struct net_device *dev);
 
 static inline bool netif_tx_queue_stopped(const struct netdev_queue *dev_queue)
 {
@@ -2840,6 +2840,9 @@ static inline int netif_set_xps_queue(struct net_device *dev,
 }
 #endif
 
+u16 __skb_tx_hash(const struct net_device *dev, struct sk_buff *skb,
+                  unsigned int num_tx_queues);
+
 /*
  * Returns a Tx hash for the given packet when dev->real_num_tx_queues is used
  * as a distribution range limit for the returned value.
diff --git a/include/linux/netfilter.h b/include/linux/netfilter.h
index 63560d0a8dfe..00050dfd9f23 100644
--- a/include/linux/netfilter.h
+++ b/include/linux/netfilter.h
@@ -10,7 +10,8 @@
 #include <linux/wait.h>
 #include <linux/list.h>
 #include <linux/static_key.h>
-#include <uapi/linux/netfilter.h>
+#include <linux/netfilter_defs.h>
+
 #ifdef CONFIG_NETFILTER
 static inline int NF_DROP_GETERR(int verdict)
 {
@@ -38,9 +39,6 @@ static inline void nf_inet_addr_mask(const union nf_inet_addr *a1,
 
 int netfilter_init(void);
 
-/* Largest hook number + 1 */
-#define NF_MAX_HOOKS 8
-
 struct sk_buff;
 
 struct nf_hook_ops;
@@ -54,10 +52,12 @@ struct nf_hook_state {
         struct net_device *in;
         struct net_device *out;
         struct sock *sk;
+        struct list_head *hook_list;
         int (*okfn)(struct sock *, struct sk_buff *);
 };
 
 static inline void nf_hook_state_init(struct nf_hook_state *p,
+                                      struct list_head *hook_list,
                                       unsigned int hook,
                                       int thresh, u_int8_t pf,
                                       struct net_device *indev,
@@ -71,6 +71,7 @@ static inline void nf_hook_state_init(struct nf_hook_state *p,
         p->in = indev;
         p->out = outdev;
         p->sk = sk;
+        p->hook_list = hook_list;
         p->okfn = okfn;
 }
 
@@ -79,16 +80,17 @@ typedef unsigned int nf_hookfn(const struct nf_hook_ops *ops,
                                const struct nf_hook_state *state);
 
 struct nf_hook_ops {
-        struct list_head list;
+        struct list_head        list;
 
         /* User fills in from here down. */
-        nf_hookfn       *hook;
-        struct module   *owner;
-        void            *priv;
-        u_int8_t        pf;
-        unsigned int    hooknum;
+        nf_hookfn               *hook;
+        struct net_device       *dev;
+        struct module           *owner;
+        void                    *priv;
+        u_int8_t                pf;
+        unsigned int            hooknum;
         /* Hooks are ordered in ascending priority. */
-        int             priority;
+        int                     priority;
 };
 
 struct nf_sockopt_ops {
@@ -131,26 +133,33 @@ extern struct list_head nf_hooks[NFPROTO_NUMPROTO][NF_MAX_HOOKS];
 #ifdef HAVE_JUMP_LABEL
 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)
+static inline bool nf_hook_list_active(struct list_head *nf_hook_list,
+                                       u_int8_t pf, unsigned int hook)
 {
         if (__builtin_constant_p(pf) &&
             __builtin_constant_p(hook))
                 return static_key_false(&nf_hooks_needed[pf][hook]);
 
-        return !list_empty(&nf_hooks[pf][hook]);
+        return !list_empty(nf_hook_list);
 }
 #else
-static inline bool nf_hooks_active(u_int8_t pf, unsigned int hook)
+static inline bool nf_hook_list_active(struct list_head *nf_hook_list,
+                                       u_int8_t pf, unsigned int hook)
 {
-        return !list_empty(&nf_hooks[pf][hook]);
+        return !list_empty(nf_hook_list);
 }
 #endif
 
+static inline bool nf_hooks_active(u_int8_t pf, unsigned int hook)
+{
+        return nf_hook_list_active(&nf_hooks[pf][hook], pf, hook);
+}
+
 int nf_hook_slow(struct sk_buff *skb, struct nf_hook_state *state);
 
 /**
  *      nf_hook_thresh - call a netfilter hook
- *      
+ *
  *      Returns 1 if the hook has allowed the packet to pass.  The function
  *      okfn must be invoked by the caller in this case.  Any other return
  *      value indicates the packet has been consumed by the hook.
@@ -166,8 +175,8 @@ static inline int nf_hook_thresh(u_int8_t pf, unsigned int hook,
         if (nf_hooks_active(pf, hook)) {
                 struct nf_hook_state state;
 
-                nf_hook_state_init(&state, hook, thresh, pf,
-                                   indev, outdev, sk, okfn);
+                nf_hook_state_init(&state, &nf_hooks[pf][hook], hook, thresh,
+                                   pf, indev, outdev, sk, okfn);
                 return nf_hook_slow(skb, &state);
         }
         return 1;
diff --git a/include/linux/netfilter/ipset/ip_set.h b/include/linux/netfilter/ipset/ip_set.h
index 34b172301558..48bb01edcf30 100644
--- a/include/linux/netfilter/ipset/ip_set.h
+++ b/include/linux/netfilter/ipset/ip_set.h
@@ -108,8 +108,13 @@ struct ip_set_counter {
         atomic64_t packets;
 };
 
+struct ip_set_comment_rcu {
+        struct rcu_head rcu;
+        char str[0];
+};
+
 struct ip_set_comment {
-        char *str;
+        struct ip_set_comment_rcu __rcu *c;
 };
 
 struct ip_set_skbinfo {
@@ -122,13 +127,13 @@ struct ip_set_skbinfo {
 struct ip_set;
 
 #define ext_timeout(e, s)       \
-(unsigned long *)(((void *)(e)) + (s)->offset[IPSET_EXT_ID_TIMEOUT])
+((unsigned long *)(((void *)(e)) + (s)->offset[IPSET_EXT_ID_TIMEOUT]))
 #define ext_counter(e, s)       \
-(struct ip_set_counter *)(((void *)(e)) + (s)->offset[IPSET_EXT_ID_COUNTER])
+((struct ip_set_counter *)(((void *)(e)) + (s)->offset[IPSET_EXT_ID_COUNTER]))
 #define ext_comment(e, s)       \
-(struct ip_set_comment *)(((void *)(e)) + (s)->offset[IPSET_EXT_ID_COMMENT])
+((struct ip_set_comment *)(((void *)(e)) + (s)->offset[IPSET_EXT_ID_COMMENT]))
 #define ext_skbinfo(e, s)       \
-(struct ip_set_skbinfo *)(((void *)(e)) + (s)->offset[IPSET_EXT_ID_SKBINFO])
+((struct ip_set_skbinfo *)(((void *)(e)) + (s)->offset[IPSET_EXT_ID_SKBINFO]))
 
 typedef int (*ipset_adtfn)(struct ip_set *set, void *value,
                            const struct ip_set_ext *ext,
@@ -176,6 +181,9 @@ struct ip_set_type_variant {
         /* List elements */
         int (*list)(const struct ip_set *set, struct sk_buff *skb,
                     struct netlink_callback *cb);
+        /* Keep listing private when resizing runs parallel */
+        void (*uref)(struct ip_set *set, struct netlink_callback *cb,
+                     bool start);
 
         /* Return true if "b" set is the same as "a"
          * according to the create set parameters */
@@ -223,7 +231,7 @@ struct ip_set {
         /* The name of the set */
         char name[IPSET_MAXNAMELEN];
         /* Lock protecting the set data */
-        rwlock_t lock;
+        spinlock_t lock;
         /* References to the set */
         u32 ref;
         /* The core set type */
@@ -341,12 +349,11 @@ ip_set_put_skbinfo(struct sk_buff *skb, struct ip_set_skbinfo *skbinfo)
                               cpu_to_be64((u64)skbinfo->skbmark << 32 |
                                           skbinfo->skbmarkmask))) ||
                (skbinfo->skbprio &&
-                nla_put_net32(skb, IPSET_ATTR_SKBPRIO,
+                nla_put_net32(skb, IPSET_ATTR_SKBPRIO,
                               cpu_to_be32(skbinfo->skbprio))) ||
                (skbinfo->skbqueue &&
-                nla_put_net16(skb, IPSET_ATTR_SKBQUEUE,
+                nla_put_net16(skb, IPSET_ATTR_SKBQUEUE,
                              cpu_to_be16(skbinfo->skbqueue)));
-
 }
 
 static inline void
@@ -380,12 +387,12 @@ ip_set_init_counter(struct ip_set_counter *counter,
 
 /* Netlink CB args */
 enum {
-        IPSET_CB_NET = 0,
-        IPSET_CB_DUMP,
-        IPSET_CB_INDEX,
-        IPSET_CB_ARG0,
+        IPSET_CB_NET = 0,       /* net namespace */
+        IPSET_CB_DUMP,          /* dump single set/all sets */
+        IPSET_CB_INDEX,         /* set index */
+        IPSET_CB_PRIVATE,       /* set private data */
+        IPSET_CB_ARG0,          /* type specific */
         IPSET_CB_ARG1,
-        IPSET_CB_ARG2,
 };
 
 /* register and unregister set references */
@@ -533,29 +540,9 @@ bitmap_bytes(u32 a, u32 b)
 #include <linux/netfilter/ipset/ip_set_timeout.h>
 #include <linux/netfilter/ipset/ip_set_comment.h>
 
-static inline int
+int
 ip_set_put_extensions(struct sk_buff *skb, const struct ip_set *set,
-                      const void *e, bool active)
-{
-        if (SET_WITH_TIMEOUT(set)) {
-                unsigned long *timeout = ext_timeout(e, set);
-
-                if (nla_put_net32(skb, IPSET_ATTR_TIMEOUT,
-                        htonl(active ? ip_set_timeout_get(timeout)
-                                : *timeout)))
-                        return -EMSGSIZE;
-        }
-        if (SET_WITH_COUNTER(set) &&
-            ip_set_put_counter(skb, ext_counter(e, set)))
-                return -EMSGSIZE;
-        if (SET_WITH_COMMENT(set) &&
-            ip_set_put_comment(skb, ext_comment(e, set)))
-                return -EMSGSIZE;
-        if (SET_WITH_SKBINFO(set) &&
-            ip_set_put_skbinfo(skb, ext_skbinfo(e, set)))
-                return -EMSGSIZE;
-        return 0;
-}
+                      const void *e, bool active);
 
 #define IP_SET_INIT_KEXT(skb, opt, set)                 \
         { .bytes = (skb)->len, .packets = 1,            \
@@ -565,8 +552,6 @@ ip_set_put_extensions(struct sk_buff *skb, const struct ip_set *set,
         { .bytes = ULLONG_MAX, .packets = ULLONG_MAX,   \
           .timeout = (set)->timeout }
 
-#define IP_SET_INIT_CIDR(a, b) ((a) ? (a) : (b))
-
 #define IPSET_CONCAT(a, b)              a##b
 #define IPSET_TOKEN(a, b)               IPSET_CONCAT(a, b)
 
diff --git a/include/linux/netfilter/ipset/ip_set_comment.h b/include/linux/netfilter/ipset/ip_set_comment.h
index 21217ea008d7..8d0248525957 100644
--- a/include/linux/netfilter/ipset/ip_set_comment.h
+++ b/include/linux/netfilter/ipset/ip_set_comment.h
@@ -16,41 +16,57 @@ ip_set_comment_uget(struct nlattr *tb)
         return nla_data(tb);
 }
 
+/* Called from uadd only, protected by the set spinlock.
+ * The kadt functions don't use the comment extensions in any way.
+ */
 static inline void
 ip_set_init_comment(struct ip_set_comment *comment,
                     const struct ip_set_ext *ext)
 {
+        struct ip_set_comment_rcu *c = rcu_dereference_protected(comment->c, 1);
         size_t len = ext->comment ? strlen(ext->comment) : 0;
 
-        if (unlikely(comment->str)) {
-                kfree(comment->str);
-                comment->str = NULL;
+        if (unlikely(c)) {
+                kfree_rcu(c, rcu);
+                rcu_assign_pointer(comment->c, NULL);
         }
         if (!len)
                 return;
         if (unlikely(len > IPSET_MAX_COMMENT_SIZE))
                 len = IPSET_MAX_COMMENT_SIZE;
-        comment->str = kzalloc(len + 1, GFP_ATOMIC);
-        if (unlikely(!comment->str))
+        c = kzalloc(sizeof(*c) + len + 1, GFP_ATOMIC);
+        if (unlikely(!c))
                 return;
-        strlcpy(comment->str, ext->comment, len + 1);
+        strlcpy(c->str, ext->comment, len + 1);
+        rcu_assign_pointer(comment->c, c);
 }
 
+/* Used only when dumping a set, protected by rcu_read_lock_bh() */
 static inline int
 ip_set_put_comment(struct sk_buff *skb, struct ip_set_comment *comment)
 {
-        if (!comment->str)
+        struct ip_set_comment_rcu *c = rcu_dereference_bh(comment->c);
+
+        if (!c)
                 return 0;
-        return nla_put_string(skb, IPSET_ATTR_COMMENT, comment->str);
+        return nla_put_string(skb, IPSET_ATTR_COMMENT, c->str);
 }
 
+/* Called from uadd/udel, flush or the garbage collectors protected
+ * by the set spinlock.
+ * Called when the set is destroyed and when there can't be any user
+ * of the set data anymore.
+ */
 static inline void
 ip_set_comment_free(struct ip_set_comment *comment)
 {
-        if (unlikely(!comment->str))
+        struct ip_set_comment_rcu *c;
+
+        c = rcu_dereference_protected(comment->c, 1);
+        if (unlikely(!c))
                 return;
-        kfree(comment->str);
-        comment->str = NULL;
+        kfree_rcu(c, rcu);
+        rcu_assign_pointer(comment->c, NULL);
 }
 
 #endif
diff --git a/include/linux/netfilter/ipset/ip_set_timeout.h b/include/linux/netfilter/ipset/ip_set_timeout.h
index 83c2f9e0886c..1d6a935c1ac5 100644
--- a/include/linux/netfilter/ipset/ip_set_timeout.h
+++ b/include/linux/netfilter/ipset/ip_set_timeout.h
@@ -40,38 +40,33 @@ ip_set_timeout_uget(struct nlattr *tb)
 }
 
 static inline bool
-ip_set_timeout_test(unsigned long timeout)
+ip_set_timeout_expired(unsigned long *t)
 {
-        return timeout == IPSET_ELEM_PERMANENT ||
-               time_is_after_jiffies(timeout);
-}
-
-static inline bool
-ip_set_timeout_expired(unsigned long *timeout)
-{
-        return *timeout != IPSET_ELEM_PERMANENT &&
-               time_is_before_jiffies(*timeout);
+        return *t != IPSET_ELEM_PERMANENT && time_is_before_jiffies(*t);
 }
 
 static inline void
-ip_set_timeout_set(unsigned long *timeout, u32 t)
+ip_set_timeout_set(unsigned long *timeout, u32 value)
 {
-        if (!t) {
+        unsigned long t;
+
+        if (!value) {
                 *timeout = IPSET_ELEM_PERMANENT;
                 return;
         }
 
-        *timeout = msecs_to_jiffies(t * 1000) + jiffies;
-        if (*timeout == IPSET_ELEM_PERMANENT)
+        t = msecs_to_jiffies(value * MSEC_PER_SEC) + jiffies;
+        if (t == IPSET_ELEM_PERMANENT)
                 /* Bingo! :-) */
-                (*timeout)--;
+                t--;
+        *timeout = t;
 }
 
 static inline u32
 ip_set_timeout_get(unsigned long *timeout)
 {
         return *timeout == IPSET_ELEM_PERMANENT ? 0 :
-                jiffies_to_msecs(*timeout - jiffies)/1000;
+                jiffies_to_msecs(*timeout - jiffies)/MSEC_PER_SEC;
 }
 
 #endif  /* __KERNEL__ */
diff --git a/include/linux/netfilter/x_tables.h b/include/linux/netfilter/x_tables.h
index a3e215bb0241..286098a5667f 100644
--- a/include/linux/netfilter/x_tables.h
+++ b/include/linux/netfilter/x_tables.h
@@ -62,6 +62,7 @@ struct xt_mtchk_param {
         void *matchinfo;
         unsigned int hook_mask;
         u_int8_t family;
+        bool nft_compat;
 };
 
 /**
@@ -92,6 +93,7 @@ struct xt_tgchk_param {
         void *targinfo;
         unsigned int hook_mask;
         u_int8_t family;
+        bool nft_compat;
 };
 
 /* Target destructor parameters */
@@ -222,13 +224,10 @@ struct xt_table_info {
         unsigned int stacksize;
         unsigned int __percpu *stackptr;
         void ***jumpstack;
-        /* ipt_entry tables: one per CPU */
-        /* Note : this field MUST be the last one, see XT_TABLE_INFO_SZ */
-        void *entries[1];
+
+        unsigned char entries[0] __aligned(8);
 };
 
-#define XT_TABLE_INFO_SZ (offsetof(struct xt_table_info, entries) \
-                          + nr_cpu_ids * sizeof(char *))
 int xt_register_target(struct xt_target *target);
 void xt_unregister_target(struct xt_target *target);
 int xt_register_targets(struct xt_target *target, unsigned int n);
@@ -351,6 +350,57 @@ static inline unsigned long ifname_compare_aligned(const char *_a,
         return ret;
 }
 
+
+/* On SMP, ip(6)t_entry->counters.pcnt holds address of the
+ * real (percpu) counter.  On !SMP, its just the packet count,
+ * so nothing needs to be done there.
+ *
+ * xt_percpu_counter_alloc returns the address of the percpu
+ * counter, or 0 on !SMP. We force an alignment of 16 bytes
+ * so that bytes/packets share a common cache line.
+ *
+ * Hence caller must use IS_ERR_VALUE to check for error, this
+ * allows us to return 0 for single core systems without forcing
+ * callers to deal with SMP vs. NONSMP issues.
+ */
+static inline u64 xt_percpu_counter_alloc(void)
+{
+        if (nr_cpu_ids > 1) {
+                void __percpu *res = __alloc_percpu(sizeof(struct xt_counters),
+                                                    sizeof(struct xt_counters));
+
+                if (res == NULL)
+                        return (u64) -ENOMEM;
+
+                return (u64) (__force unsigned long) res;
+        }
+
+        return 0;
+}
+static inline void xt_percpu_counter_free(u64 pcnt)
+{
+        if (nr_cpu_ids > 1)
+                free_percpu((void __percpu *) (unsigned long) pcnt);
+}
+
+static inline struct xt_counters *
+xt_get_this_cpu_counter(struct xt_counters *cnt)
+{
+        if (nr_cpu_ids > 1)
+                return this_cpu_ptr((void __percpu *) (unsigned long) cnt->pcnt);
+
+        return cnt;
+}
+
+static inline struct xt_counters *
+xt_get_per_cpu_counter(struct xt_counters *cnt, unsigned int cpu)
+{
+        if (nr_cpu_ids > 1)
+                return per_cpu_ptr((void __percpu *) (unsigned long) cnt->pcnt, cpu);
+
+        return cnt;
+}
+
 struct nf_hook_ops *xt_hook_link(const struct xt_table *, nf_hookfn *);
 void xt_hook_unlink(const struct xt_table *, struct nf_hook_ops *);
 
diff --git a/include/linux/netfilter_bridge.h b/include/linux/netfilter_bridge.h
index f2fdb5a52070..6d80fc686323 100644
--- a/include/linux/netfilter_bridge.h
+++ b/include/linux/netfilter_bridge.h
@@ -20,13 +20,6 @@ enum nf_br_hook_priorities {
 #define BRNF_BRIDGED_DNAT               0x02
 #define BRNF_NF_BRIDGE_PREROUTING       0x08
 
-static inline unsigned int nf_bridge_mtu_reduction(const struct sk_buff *skb)
-{
-        if (skb->nf_bridge->orig_proto == BRNF_PROTO_PPPOE)
-                return PPPOE_SES_HLEN;
-        return 0;
-}
-
 int br_handle_frame_finish(struct sock *sk, struct sk_buff *skb);
 
 static inline void br_drop_fake_rtable(struct sk_buff *skb)
diff --git a/include/linux/netfilter_bridge/ebtables.h b/include/linux/netfilter_bridge/ebtables.h
index f1bd3962e6b6..8ca6d6464ea3 100644
--- a/include/linux/netfilter_bridge/ebtables.h
+++ b/include/linux/netfilter_bridge/ebtables.h
@@ -6,7 +6,7 @@
  *
  *  ebtables.c,v 2.0, April, 2002
  *
- *  This code is stongly inspired on the iptables code which is
+ *  This code is strongly inspired by the iptables code which is
  *  Copyright (C) 1999 Paul `Rusty' Russell & Michael J. Neuling
  */
 #ifndef __LINUX_BRIDGE_EFF_H
diff --git a/include/linux/netfilter_defs.h b/include/linux/netfilter_defs.h
new file mode 100644
index 000000000000..d3a7f8597e82
--- /dev/null
+++ b/include/linux/netfilter_defs.h
@@ -0,0 +1,9 @@
+#ifndef __LINUX_NETFILTER_CORE_H_
+#define __LINUX_NETFILTER_CORE_H_
+
+#include <uapi/linux/netfilter.h>
+
+/* Largest hook number + 1, see uapi/linux/netfilter_decnet.h */
+#define NF_MAX_HOOKS 8
+
+#endif
diff --git a/include/linux/netfilter_ingress.h b/include/linux/netfilter_ingress.h
new file mode 100644
index 000000000000..cb0727fe2b3d
--- /dev/null
+++ b/include/linux/netfilter_ingress.h
@@ -0,0 +1,41 @@
+#ifndef _NETFILTER_INGRESS_H_
+#define _NETFILTER_INGRESS_H_
+
+#include <linux/netfilter.h>
+#include <linux/netdevice.h>
+
+#ifdef CONFIG_NETFILTER_INGRESS
+static inline int nf_hook_ingress_active(struct sk_buff *skb)
+{
+        return nf_hook_list_active(&skb->dev->nf_hooks_ingress,
+                                   NFPROTO_NETDEV, NF_NETDEV_INGRESS);
+}
+
+static inline int nf_hook_ingress(struct sk_buff *skb)
+{
+        struct nf_hook_state state;
+
+        nf_hook_state_init(&state, &skb->dev->nf_hooks_ingress,
+                           NF_NETDEV_INGRESS, INT_MIN, NFPROTO_NETDEV, NULL,
+                           skb->dev, NULL, NULL);
+        return nf_hook_slow(skb, &state);
+}
+
+static inline void nf_hook_ingress_init(struct net_device *dev)
+{
+        INIT_LIST_HEAD(&dev->nf_hooks_ingress);
+}
+#else /* CONFIG_NETFILTER_INGRESS */
+static inline int nf_hook_ingress_active(struct sk_buff *skb)
+{
+        return 0;
+}
+
+static inline int nf_hook_ingress(struct sk_buff *skb)
+{
+        return 0;
+}
+
+static inline void nf_hook_ingress_init(struct net_device *dev) {}
+#endif /* CONFIG_NETFILTER_INGRESS */
+#endif /* _NETFILTER_INGRESS_H_ */
diff --git a/include/linux/netfilter_ipv6.h b/include/linux/netfilter_ipv6.h
index 64dad1cc1a4b..8b7d28f3aada 100644
--- a/include/linux/netfilter_ipv6.h
+++ b/include/linux/netfilter_ipv6.h
@@ -25,6 +25,9 @@ void ipv6_netfilter_fini(void);
 struct nf_ipv6_ops {
         int (*chk_addr)(struct net *net, const struct in6_addr *addr,
                         const struct net_device *dev, int strict);
+        void (*route_input)(struct sk_buff *skb);
+        int (*fragment)(struct sock *sk, struct sk_buff *skb,
+                        int (*output)(struct sock *, struct sk_buff *));
 };
 
 extern const struct nf_ipv6_ops __rcu *nf_ipv6_ops;
diff --git a/include/linux/netlink.h b/include/linux/netlink.h
index 6835c1279df7..9120edb650a0 100644
--- a/include/linux/netlink.h
+++ b/include/linux/netlink.h
@@ -28,6 +28,8 @@ struct netlink_skb_parms {
         __u32                   dst_group;
         __u32                   flags;
         struct sock             *sk;
+        bool                    nsid_is_set;
+        int                     nsid;
 };
 
 #define NETLINK_CB(skb)         (*(struct netlink_skb_parms*)&((skb)->cb))
diff --git a/include/linux/nfs4.h b/include/linux/nfs4.h
index 32201c269890..b8e72aad919c 100644
--- a/include/linux/nfs4.h
+++ b/include/linux/nfs4.h
@@ -500,6 +500,7 @@ enum {
         NFSPROC4_CLNT_SEEK,
         NFSPROC4_CLNT_ALLOCATE,
         NFSPROC4_CLNT_DEALLOCATE,
+        NFSPROC4_CLNT_LAYOUTSTATS,
 };
 
 /* nfs41 types */
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index b95f914ce083..874b77228fb9 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -219,6 +219,7 @@ struct nfs_inode {
 #define NFS_INO_COMMIT          (7)             /* inode is committing unstable writes */
 #define NFS_INO_LAYOUTCOMMIT    (9)             /* layoutcommit required */
 #define NFS_INO_LAYOUTCOMMITTING (10)           /* layoutcommit inflight */
+#define NFS_INO_LAYOUTSTATS     (11)            /* layoutstats inflight */
 
 static inline struct nfs_inode *NFS_I(const struct inode *inode)
 {
@@ -291,9 +292,12 @@ static inline void nfs_mark_for_revalidate(struct inode *inode)
         struct nfs_inode *nfsi = NFS_I(inode);
 
         spin_lock(&inode->i_lock);
-        nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS;
+        nfsi->cache_validity |= NFS_INO_INVALID_ATTR |
+                                NFS_INO_REVAL_PAGECACHE |
+                                NFS_INO_INVALID_ACCESS |
+                                NFS_INO_INVALID_ACL;
         if (S_ISDIR(inode->i_mode))
-                nfsi->cache_validity |= NFS_INO_REVAL_PAGECACHE|NFS_INO_INVALID_DATA;
+                nfsi->cache_validity |= NFS_INO_INVALID_DATA;
         spin_unlock(&inode->i_lock);
 }
 
diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h
index 5e1273d4de14..20bc8e51b161 100644
--- a/include/linux/nfs_fs_sb.h
+++ b/include/linux/nfs_fs_sb.h
@@ -220,7 +220,7 @@ struct nfs_server {
 #define NFS_CAP_SYMLINKS        (1U << 2)
 #define NFS_CAP_ACLS            (1U << 3)
 #define NFS_CAP_ATOMIC_OPEN     (1U << 4)
-#define NFS_CAP_CHANGE_ATTR     (1U << 5)
+/* #define NFS_CAP_CHANGE_ATTR  (1U << 5) */
 #define NFS_CAP_FILEID          (1U << 6)
 #define NFS_CAP_MODE            (1U << 7)
 #define NFS_CAP_NLINK           (1U << 8)
@@ -237,5 +237,6 @@ struct nfs_server {
 #define NFS_CAP_SEEK            (1U << 19)
 #define NFS_CAP_ALLOCATE        (1U << 20)
 #define NFS_CAP_DEALLOCATE      (1U << 21)
+#define NFS_CAP_LAYOUTSTATS     (1U << 22)
 
 #endif
diff --git a/include/linux/nfs_page.h b/include/linux/nfs_page.h
index 3eb072dbce83..f2f650f136ee 100644
--- a/include/linux/nfs_page.h
+++ b/include/linux/nfs_page.h
@@ -67,7 +67,6 @@ struct nfs_rw_ops {
         const fmode_t rw_mode;
         struct nfs_pgio_header *(*rw_alloc_header)(void);
         void (*rw_free_header)(struct nfs_pgio_header *);
-        void (*rw_release)(struct nfs_pgio_header *);
         int  (*rw_done)(struct rpc_task *, struct nfs_pgio_header *,
                         struct inode *);
         void (*rw_result)(struct rpc_task *, struct nfs_pgio_header *);
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index 93ab6071bbe9..7bbe50504211 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -316,6 +316,49 @@ struct nfs4_layoutreturn {
         int rpc_status;
 };
 
+#define PNFS_LAYOUTSTATS_MAXSIZE 256
+
+struct nfs42_layoutstat_args;
+struct nfs42_layoutstat_devinfo;
+typedef void (*layoutstats_encode_t)(struct xdr_stream *,
+                struct nfs42_layoutstat_args *,
+                struct nfs42_layoutstat_devinfo *);
+
+/* Per file per deviceid layoutstats */
+struct nfs42_layoutstat_devinfo {
+        struct nfs4_deviceid dev_id;
+        __u64 offset;
+        __u64 length;
+        __u64 read_count;
+        __u64 read_bytes;
+        __u64 write_count;
+        __u64 write_bytes;
+        __u32 layout_type;
+        layoutstats_encode_t layoutstats_encode;
+        void *layout_private;
+};
+
+struct nfs42_layoutstat_args {
+        struct nfs4_sequence_args seq_args;
+        struct nfs_fh *fh;
+        struct inode *inode;
+        nfs4_stateid stateid;
+        int num_dev;
+        struct nfs42_layoutstat_devinfo *devinfo;
+};
+
+struct nfs42_layoutstat_res {
+        struct nfs4_sequence_res seq_res;
+        int num_dev;
+        int rpc_status;
+};
+
+struct nfs42_layoutstat_data {
+        struct inode *inode;
+        struct nfs42_layoutstat_args args;
+        struct nfs42_layoutstat_res res;
+};
+
 struct stateowner_id {
         __u64   create_time;
         __u32   uniquifier;
@@ -984,17 +1027,14 @@ struct nfs4_readlink_res {
         struct nfs4_sequence_res        seq_res;
 };
 
-#define NFS4_SETCLIENTID_NAMELEN        (127)
 struct nfs4_setclientid {
         const nfs4_verifier *           sc_verifier;
-        unsigned int                    sc_name_len;
-        char                            sc_name[NFS4_SETCLIENTID_NAMELEN + 1];
         u32                             sc_prog;
         unsigned int                    sc_netid_len;
         char                            sc_netid[RPCBIND_MAXNETIDLEN + 1];
         unsigned int                    sc_uaddr_len;
         char                            sc_uaddr[RPCBIND_MAXUADDRLEN + 1];
-        u32                             sc_cb_ident;
+        struct nfs_client               *sc_clnt;
         struct rpc_cred                 *sc_cred;
 };
 
@@ -1142,12 +1182,9 @@ struct nfs41_state_protection {
         struct nfs4_op_map allow;
 };
 
-#define NFS4_EXCHANGE_ID_LEN    (48)
 struct nfs41_exchange_id_args {
         struct nfs_client               *client;
         nfs4_verifier                   *verifier;
-        unsigned int                    id_len;
-        char                            id[NFS4_EXCHANGE_ID_LEN];
         u32                             flags;
         struct nfs41_state_protection   state_protect;
 };
diff --git a/include/linux/nmi.h b/include/linux/nmi.h
index 3d46fb4708e0..f94da0e65dea 100644
--- a/include/linux/nmi.h
+++ b/include/linux/nmi.h
@@ -67,6 +67,7 @@ extern int nmi_watchdog_enabled;
 extern int soft_watchdog_enabled;
 extern int watchdog_user_enabled;
 extern int watchdog_thresh;
+extern unsigned long *watchdog_cpumask_bits;
 extern int sysctl_softlockup_all_cpu_backtrace;
 struct ctl_table;
 extern int proc_watchdog(struct ctl_table *, int ,
@@ -77,6 +78,8 @@ extern int proc_soft_watchdog(struct ctl_table *, int ,
                               void __user *, size_t *, loff_t *);
 extern int proc_watchdog_thresh(struct ctl_table *, int ,
                                 void __user *, size_t *, loff_t *);
+extern int proc_watchdog_cpumask(struct ctl_table *, int,
+                                 void __user *, size_t *, loff_t *);
 #endif
 
 #ifdef CONFIG_HAVE_ACPI_APEI_NMI
diff --git a/include/linux/ntb.h b/include/linux/ntb.h
index 9ac1a62fc6f5..b02f72bb8e32 100644
--- a/include/linux/ntb.h
+++ b/include/linux/ntb.h
@@ -4,15 +4,20 @@
  *
  *   GPL LICENSE SUMMARY
  *
- *   Copyright(c) 2012 Intel Corporation. All rights reserved.
+ *   Copyright (C) 2015 EMC Corporation. All Rights Reserved.
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of version 2 of the GNU General Public License as
  *   published by the Free Software Foundation.
  *
+ *   This program is distributed in the hope that it will be useful, but
+ *   WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *   General Public License for more details.
+ *
  *   BSD LICENSE
  *
- *   Copyright(c) 2012 Intel Corporation. All rights reserved.
+ *   Copyright (C) 2015 EMC Corporation. All Rights Reserved.
  *
  *   Redistribution and use in source and binary forms, with or without
  *   modification, are permitted provided that the following conditions
@@ -40,49 +45,940 @@
  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
- * Intel PCIe NTB Linux driver
+ * PCIe NTB Linux driver
  *
  * Contact Information:
- * Jon Mason <jon.mason@intel.com>
+ * Allen Hubbe <Allen.Hubbe@emc.com>
  */
 
-struct ntb_transport_qp;
+#ifndef _NTB_H_
+#define _NTB_H_
 
-struct ntb_client {
-        struct device_driver driver;
-        int (*probe)(struct pci_dev *pdev);
-        void (*remove)(struct pci_dev *pdev);
+#include <linux/completion.h>
+#include <linux/device.h>
+
+struct ntb_client;
+struct ntb_dev;
+struct pci_dev;
+
+/**
+ * enum ntb_topo - NTB connection topology
+ * @NTB_TOPO_NONE:      Topology is unknown or invalid.
+ * @NTB_TOPO_PRI:       On primary side of local ntb.
+ * @NTB_TOPO_SEC:       On secondary side of remote ntb.
+ * @NTB_TOPO_B2B_USD:   On primary side of local ntb upstream of remote ntb.
+ * @NTB_TOPO_B2B_DSD:   On primary side of local ntb downstream of remote ntb.
+ */
+enum ntb_topo {
+        NTB_TOPO_NONE = -1,
+        NTB_TOPO_PRI,
+        NTB_TOPO_SEC,
+        NTB_TOPO_B2B_USD,
+        NTB_TOPO_B2B_DSD,
+};
+
+static inline int ntb_topo_is_b2b(enum ntb_topo topo)
+{
+        switch ((int)topo) {
+        case NTB_TOPO_B2B_USD:
+        case NTB_TOPO_B2B_DSD:
+                return 1;
+        }
+        return 0;
+}
+
+static inline char *ntb_topo_string(enum ntb_topo topo)
+{
+        switch (topo) {
+        case NTB_TOPO_NONE:     return "NTB_TOPO_NONE";
+        case NTB_TOPO_PRI:      return "NTB_TOPO_PRI";
+        case NTB_TOPO_SEC:      return "NTB_TOPO_SEC";
+        case NTB_TOPO_B2B_USD:  return "NTB_TOPO_B2B_USD";
+        case NTB_TOPO_B2B_DSD:  return "NTB_TOPO_B2B_DSD";
+        }
+        return "NTB_TOPO_INVALID";
+}
+
+/**
+ * enum ntb_speed - NTB link training speed
+ * @NTB_SPEED_AUTO:     Request the max supported speed.
+ * @NTB_SPEED_NONE:     Link is not trained to any speed.
+ * @NTB_SPEED_GEN1:     Link is trained to gen1 speed.
+ * @NTB_SPEED_GEN2:     Link is trained to gen2 speed.
+ * @NTB_SPEED_GEN3:     Link is trained to gen3 speed.
+ */
+enum ntb_speed {
+        NTB_SPEED_AUTO = -1,
+        NTB_SPEED_NONE = 0,
+        NTB_SPEED_GEN1 = 1,
+        NTB_SPEED_GEN2 = 2,
+        NTB_SPEED_GEN3 = 3,
+};
+
+/**
+ * enum ntb_width - NTB link training width
+ * @NTB_WIDTH_AUTO:     Request the max supported width.
+ * @NTB_WIDTH_NONE:     Link is not trained to any width.
+ * @NTB_WIDTH_1:        Link is trained to 1 lane width.
+ * @NTB_WIDTH_2:        Link is trained to 2 lane width.
+ * @NTB_WIDTH_4:        Link is trained to 4 lane width.
+ * @NTB_WIDTH_8:        Link is trained to 8 lane width.
+ * @NTB_WIDTH_12:       Link is trained to 12 lane width.
+ * @NTB_WIDTH_16:       Link is trained to 16 lane width.
+ * @NTB_WIDTH_32:       Link is trained to 32 lane width.
+ */
+enum ntb_width {
+        NTB_WIDTH_AUTO = -1,
+        NTB_WIDTH_NONE = 0,
+        NTB_WIDTH_1 = 1,
+        NTB_WIDTH_2 = 2,
+        NTB_WIDTH_4 = 4,
+        NTB_WIDTH_8 = 8,
+        NTB_WIDTH_12 = 12,
+        NTB_WIDTH_16 = 16,
+        NTB_WIDTH_32 = 32,
+};
+
+/**
+ * struct ntb_client_ops - ntb client operations
+ * @probe:              Notify client of a new device.
+ * @remove:             Notify client to remove a device.
+ */
+struct ntb_client_ops {
+        int (*probe)(struct ntb_client *client, struct ntb_dev *ntb);
+        void (*remove)(struct ntb_client *client, struct ntb_dev *ntb);
+};
+
+static inline int ntb_client_ops_is_valid(const struct ntb_client_ops *ops)
+{
+        /* commented callbacks are not required: */
+        return
+                ops->probe                      &&
+                ops->remove                     &&
+                1;
+}
+
+/**
+ * struct ntb_ctx_ops - ntb driver context operations
+ * @link_event:         See ntb_link_event().
+ * @db_event:           See ntb_db_event().
+ */
+struct ntb_ctx_ops {
+        void (*link_event)(void *ctx);
+        void (*db_event)(void *ctx, int db_vector);
+};
+
+static inline int ntb_ctx_ops_is_valid(const struct ntb_ctx_ops *ops)
+{
+        /* commented callbacks are not required: */
+        return
+                /* ops->link_event              && */
+                /* ops->db_event                && */
+                1;
+}
+
+/**
+ * struct ntb_ctx_ops - ntb device operations
+ * @mw_count:           See ntb_mw_count().
+ * @mw_get_range:       See ntb_mw_get_range().
+ * @mw_set_trans:       See ntb_mw_set_trans().
+ * @mw_clear_trans:     See ntb_mw_clear_trans().
+ * @link_is_up:         See ntb_link_is_up().
+ * @link_enable:        See ntb_link_enable().
+ * @link_disable:       See ntb_link_disable().
+ * @db_is_unsafe:       See ntb_db_is_unsafe().
+ * @db_valid_mask:      See ntb_db_valid_mask().
+ * @db_vector_count:    See ntb_db_vector_count().
+ * @db_vector_mask:     See ntb_db_vector_mask().
+ * @db_read:            See ntb_db_read().
+ * @db_set:             See ntb_db_set().
+ * @db_clear:           See ntb_db_clear().
+ * @db_read_mask:       See ntb_db_read_mask().
+ * @db_set_mask:        See ntb_db_set_mask().
+ * @db_clear_mask:      See ntb_db_clear_mask().
+ * @peer_db_addr:       See ntb_peer_db_addr().
+ * @peer_db_read:       See ntb_peer_db_read().
+ * @peer_db_set:        See ntb_peer_db_set().
+ * @peer_db_clear:      See ntb_peer_db_clear().
+ * @peer_db_read_mask:  See ntb_peer_db_read_mask().
+ * @peer_db_set_mask:   See ntb_peer_db_set_mask().
+ * @peer_db_clear_mask: See ntb_peer_db_clear_mask().
+ * @spad_is_unsafe:     See ntb_spad_is_unsafe().
+ * @spad_count:         See ntb_spad_count().
+ * @spad_read:          See ntb_spad_read().
+ * @spad_write:         See ntb_spad_write().
+ * @peer_spad_addr:     See ntb_peer_spad_addr().
+ * @peer_spad_read:     See ntb_peer_spad_read().
+ * @peer_spad_write:    See ntb_peer_spad_write().
+ */
+struct ntb_dev_ops {
+        int (*mw_count)(struct ntb_dev *ntb);
+        int (*mw_get_range)(struct ntb_dev *ntb, int idx,
+                            phys_addr_t *base, resource_size_t *size,
+                        resource_size_t *align, resource_size_t *align_size);
+        int (*mw_set_trans)(struct ntb_dev *ntb, int idx,
+                            dma_addr_t addr, resource_size_t size);
+        int (*mw_clear_trans)(struct ntb_dev *ntb, int idx);
+
+        int (*link_is_up)(struct ntb_dev *ntb,
+                          enum ntb_speed *speed, enum ntb_width *width);
+        int (*link_enable)(struct ntb_dev *ntb,
+                           enum ntb_speed max_speed, enum ntb_width max_width);
+        int (*link_disable)(struct ntb_dev *ntb);
+
+        int (*db_is_unsafe)(struct ntb_dev *ntb);
+        u64 (*db_valid_mask)(struct ntb_dev *ntb);
+        int (*db_vector_count)(struct ntb_dev *ntb);
+        u64 (*db_vector_mask)(struct ntb_dev *ntb, int db_vector);
+
+        u64 (*db_read)(struct ntb_dev *ntb);
+        int (*db_set)(struct ntb_dev *ntb, u64 db_bits);
+        int (*db_clear)(struct ntb_dev *ntb, u64 db_bits);
+
+        u64 (*db_read_mask)(struct ntb_dev *ntb);
+        int (*db_set_mask)(struct ntb_dev *ntb, u64 db_bits);
+        int (*db_clear_mask)(struct ntb_dev *ntb, u64 db_bits);
+
+        int (*peer_db_addr)(struct ntb_dev *ntb,
+                            phys_addr_t *db_addr, resource_size_t *db_size);
+        u64 (*peer_db_read)(struct ntb_dev *ntb);
+        int (*peer_db_set)(struct ntb_dev *ntb, u64 db_bits);
+        int (*peer_db_clear)(struct ntb_dev *ntb, u64 db_bits);
+
+        u64 (*peer_db_read_mask)(struct ntb_dev *ntb);
+        int (*peer_db_set_mask)(struct ntb_dev *ntb, u64 db_bits);
+        int (*peer_db_clear_mask)(struct ntb_dev *ntb, u64 db_bits);
+
+        int (*spad_is_unsafe)(struct ntb_dev *ntb);
+        int (*spad_count)(struct ntb_dev *ntb);
+
+        u32 (*spad_read)(struct ntb_dev *ntb, int idx);
+        int (*spad_write)(struct ntb_dev *ntb, int idx, u32 val);
+
+        int (*peer_spad_addr)(struct ntb_dev *ntb, int idx,
+                              phys_addr_t *spad_addr);
+        u32 (*peer_spad_read)(struct ntb_dev *ntb, int idx);
+        int (*peer_spad_write)(struct ntb_dev *ntb, int idx, u32 val);
 };
 
-enum {
-        NTB_LINK_DOWN = 0,
-        NTB_LINK_UP,
+static inline int ntb_dev_ops_is_valid(const struct ntb_dev_ops *ops)
+{
+        /* commented callbacks are not required: */
+        return
+                ops->mw_count                           &&
+                ops->mw_get_range                       &&
+                ops->mw_set_trans                       &&
+                /* ops->mw_clear_trans                  && */
+                ops->link_is_up                         &&
+                ops->link_enable                        &&
+                ops->link_disable                       &&
+                /* ops->db_is_unsafe                    && */
+                ops->db_valid_mask                      &&
+
+                /* both set, or both unset */
+                (!ops->db_vector_count == !ops->db_vector_mask) &&
+
+                ops->db_read                            &&
+                /* ops->db_set                          && */
+                ops->db_clear                           &&
+                /* ops->db_read_mask                    && */
+                ops->db_set_mask                        &&
+                ops->db_clear_mask                      &&
+                ops->peer_db_addr                       &&
+                /* ops->peer_db_read                    && */
+                ops->peer_db_set                        &&
+                /* ops->peer_db_clear                   && */
+                /* ops->peer_db_read_mask               && */
+                /* ops->peer_db_set_mask                && */
+                /* ops->peer_db_clear_mask              && */
+                /* ops->spad_is_unsafe                  && */
+                ops->spad_count                         &&
+                ops->spad_read                          &&
+                ops->spad_write                         &&
+                ops->peer_spad_addr                     &&
+                /* ops->peer_spad_read                  && */
+                ops->peer_spad_write                    &&
+                1;
+}
+
+/**
+ * struct ntb_client - client interested in ntb devices
+ * @drv:                Linux driver object.
+ * @ops:                See &ntb_client_ops.
+ */
+struct ntb_client {
+        struct device_driver            drv;
+        const struct ntb_client_ops     ops;
 };
 
-int ntb_register_client(struct ntb_client *drvr);
-void ntb_unregister_client(struct ntb_client *drvr);
-int ntb_register_client_dev(char *device_name);
-void ntb_unregister_client_dev(char *device_name);
-
-struct ntb_queue_handlers {
-        void (*rx_handler)(struct ntb_transport_qp *qp, void *qp_data,
-                           void *data, int len);
-        void (*tx_handler)(struct ntb_transport_qp *qp, void *qp_data,
-                           void *data, int len);
-        void (*event_handler)(void *data, int status);
+#define drv_ntb_client(__drv) container_of((__drv), struct ntb_client, drv)
+
+/**
+ * struct ntb_device - ntb device
+ * @dev:                Linux device object.
+ * @pdev:               Pci device entry of the ntb.
+ * @topo:               Detected topology of the ntb.
+ * @ops:                See &ntb_dev_ops.
+ * @ctx:                See &ntb_ctx_ops.
+ * @ctx_ops:            See &ntb_ctx_ops.
+ */
+struct ntb_dev {
+        struct device                   dev;
+        struct pci_dev                  *pdev;
+        enum ntb_topo                   topo;
+        const struct ntb_dev_ops        *ops;
+        void                            *ctx;
+        const struct ntb_ctx_ops        *ctx_ops;
+
+        /* private: */
+
+        /* synchronize setting, clearing, and calling ctx_ops */
+        spinlock_t                      ctx_lock;
+        /* block unregister until device is fully released */
+        struct completion               released;
 };
 
-unsigned char ntb_transport_qp_num(struct ntb_transport_qp *qp);
-unsigned int ntb_transport_max_size(struct ntb_transport_qp *qp);
-struct ntb_transport_qp *
-ntb_transport_create_queue(void *data, struct pci_dev *pdev,
-                           const struct ntb_queue_handlers *handlers);
-void ntb_transport_free_queue(struct ntb_transport_qp *qp);
-int ntb_transport_rx_enqueue(struct ntb_transport_qp *qp, void *cb, void *data,
-                             unsigned int len);
-int ntb_transport_tx_enqueue(struct ntb_transport_qp *qp, void *cb, void *data,
-                             unsigned int len);
-void *ntb_transport_rx_remove(struct ntb_transport_qp *qp, unsigned int *len);
-void ntb_transport_link_up(struct ntb_transport_qp *qp);
-void ntb_transport_link_down(struct ntb_transport_qp *qp);
-bool ntb_transport_link_query(struct ntb_transport_qp *qp);
+#define dev_ntb(__dev) container_of((__dev), struct ntb_dev, dev)
+
+/**
+ * ntb_register_client() - register a client for interest in ntb devices
+ * @client:     Client context.
+ *
+ * The client will be added to the list of clients interested in ntb devices.
+ * The client will be notified of any ntb devices that are not already
+ * associated with a client, or if ntb devices are registered later.
+ *
+ * Return: Zero if the client is registered, otherwise an error number.
+ */
+#define ntb_register_client(client) \
+        __ntb_register_client((client), THIS_MODULE, KBUILD_MODNAME)
+
+int __ntb_register_client(struct ntb_client *client, struct module *mod,
+                          const char *mod_name);
+
+/**
+ * ntb_unregister_client() - unregister a client for interest in ntb devices
+ * @client:     Client context.
+ *
+ * The client will be removed from the list of clients interested in ntb
+ * devices.  If any ntb devices are associated with the client, the client will
+ * be notified to remove those devices.
+ */
+void ntb_unregister_client(struct ntb_client *client);
+
+#define module_ntb_client(__ntb_client) \
+        module_driver(__ntb_client, ntb_register_client, \
+                        ntb_unregister_client)
+
+/**
+ * ntb_register_device() - register a ntb device
+ * @ntb:        NTB device context.
+ *
+ * The device will be added to the list of ntb devices.  If any clients are
+ * interested in ntb devices, each client will be notified of the ntb device,
+ * until at most one client accepts the device.
+ *
+ * Return: Zero if the device is registered, otherwise an error number.
+ */
+int ntb_register_device(struct ntb_dev *ntb);
+
+/**
+ * ntb_register_device() - unregister a ntb device
+ * @ntb:        NTB device context.
+ *
+ * The device will be removed from the list of ntb devices.  If the ntb device
+ * is associated with a client, the client will be notified to remove the
+ * device.
+ */
+void ntb_unregister_device(struct ntb_dev *ntb);
+
+/**
+ * ntb_set_ctx() - associate a driver context with an ntb device
+ * @ntb:        NTB device context.
+ * @ctx:        Driver context.
+ * @ctx_ops:    Driver context operations.
+ *
+ * Associate a driver context and operations with a ntb device.  The context is
+ * provided by the client driver, and the driver may associate a different
+ * context with each ntb device.
+ *
+ * Return: Zero if the context is associated, otherwise an error number.
+ */
+int ntb_set_ctx(struct ntb_dev *ntb, void *ctx,
+                const struct ntb_ctx_ops *ctx_ops);
+
+/**
+ * ntb_clear_ctx() - disassociate any driver context from an ntb device
+ * @ntb:        NTB device context.
+ *
+ * Clear any association that may exist between a driver context and the ntb
+ * device.
+ */
+void ntb_clear_ctx(struct ntb_dev *ntb);
+
+/**
+ * ntb_link_event() - notify driver context of a change in link status
+ * @ntb:        NTB device context.
+ *
+ * Notify the driver context that the link status may have changed.  The driver
+ * should call ntb_link_is_up() to get the current status.
+ */
+void ntb_link_event(struct ntb_dev *ntb);
+
+/**
+ * ntb_db_event() - notify driver context of a doorbell event
+ * @ntb:        NTB device context.
+ * @vector:     Interrupt vector number.
+ *
+ * Notify the driver context of a doorbell event.  If hardware supports
+ * multiple interrupt vectors for doorbells, the vector number indicates which
+ * vector received the interrupt.  The vector number is relative to the first
+ * vector used for doorbells, starting at zero, and must be less than
+ ** ntb_db_vector_count().  The driver may call ntb_db_read() to check which
+ * doorbell bits need service, and ntb_db_vector_mask() to determine which of
+ * those bits are associated with the vector number.
+ */
+void ntb_db_event(struct ntb_dev *ntb, int vector);
+
+/**
+ * ntb_mw_count() - get the number of memory windows
+ * @ntb:        NTB device context.
+ *
+ * Hardware and topology may support a different number of memory windows.
+ *
+ * Return: the number of memory windows.
+ */
+static inline int ntb_mw_count(struct ntb_dev *ntb)
+{
+        return ntb->ops->mw_count(ntb);
+}
+
+/**
+ * ntb_mw_get_range() - get the range of a memory window
+ * @ntb:        NTB device context.
+ * @idx:        Memory window number.
+ * @base:       OUT - the base address for mapping the memory window
+ * @size:       OUT - the size for mapping the memory window
+ * @align:      OUT - the base alignment for translating the memory window
+ * @align_size: OUT - the size alignment for translating the memory window
+ *
+ * Get the range of a memory window.  NULL may be given for any output
+ * parameter if the value is not needed.  The base and size may be used for
+ * mapping the memory window, to access the peer memory.  The alignment and
+ * size may be used for translating the memory window, for the peer to access
+ * memory on the local system.
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_mw_get_range(struct ntb_dev *ntb, int idx,
+                                   phys_addr_t *base, resource_size_t *size,
+                resource_size_t *align, resource_size_t *align_size)
+{
+        return ntb->ops->mw_get_range(ntb, idx, base, size,
+                        align, align_size);
+}
+
+/**
+ * ntb_mw_set_trans() - set the translation of a memory window
+ * @ntb:        NTB device context.
+ * @idx:        Memory window number.
+ * @addr:       The dma address local memory to expose to the peer.
+ * @size:       The size of the local memory to expose to the peer.
+ *
+ * Set the translation of a memory window.  The peer may access local memory
+ * through the window starting at the address, up to the size.  The address
+ * must be aligned to the alignment specified by ntb_mw_get_range().  The size
+ * must be aligned to the size alignment specified by ntb_mw_get_range().
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_mw_set_trans(struct ntb_dev *ntb, int idx,
+                                   dma_addr_t addr, resource_size_t size)
+{
+        return ntb->ops->mw_set_trans(ntb, idx, addr, size);
+}
+
+/**
+ * ntb_mw_clear_trans() - clear the translation of a memory window
+ * @ntb:        NTB device context.
+ * @idx:        Memory window number.
+ *
+ * Clear the translation of a memory window.  The peer may no longer access
+ * local memory through the window.
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_mw_clear_trans(struct ntb_dev *ntb, int idx)
+{
+        if (!ntb->ops->mw_clear_trans)
+                return ntb->ops->mw_set_trans(ntb, idx, 0, 0);
+
+        return ntb->ops->mw_clear_trans(ntb, idx);
+}
+
+/**
+ * ntb_link_is_up() - get the current ntb link state
+ * @ntb:        NTB device context.
+ * @speed:      OUT - The link speed expressed as PCIe generation number.
+ * @width:      OUT - The link width expressed as the number of PCIe lanes.
+ *
+ * Set the translation of a memory window.  The peer may access local memory
+ * through the window starting at the address, up to the size.  The address
+ * must be aligned to the alignment specified by ntb_mw_get_range().  The size
+ * must be aligned to the size alignment specified by ntb_mw_get_range().
+ *
+ * Return: One if the link is up, zero if the link is down, otherwise a
+ *              negative value indicating the error number.
+ */
+static inline int ntb_link_is_up(struct ntb_dev *ntb,
+                                 enum ntb_speed *speed, enum ntb_width *width)
+{
+        return ntb->ops->link_is_up(ntb, speed, width);
+}
+
+/**
+ * ntb_link_enable() - enable the link on the secondary side of the ntb
+ * @ntb:        NTB device context.
+ * @max_speed:  The maximum link speed expressed as PCIe generation number.
+ * @max_width:  The maximum link width expressed as the number of PCIe lanes.
+ *
+ * Enable the link on the secondary side of the ntb.  This can only be done
+ * from the primary side of the ntb in primary or b2b topology.  The ntb device
+ * should train the link to its maximum speed and width, or the requested speed
+ * and width, whichever is smaller, if supported.
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_link_enable(struct ntb_dev *ntb,
+                                  enum ntb_speed max_speed,
+                                  enum ntb_width max_width)
+{
+        return ntb->ops->link_enable(ntb, max_speed, max_width);
+}
+
+/**
+ * ntb_link_disable() - disable the link on the secondary side of the ntb
+ * @ntb:        NTB device context.
+ *
+ * Disable the link on the secondary side of the ntb.  This can only be
+ * done from the primary side of the ntb in primary or b2b topology.  The ntb
+ * device should disable the link.  Returning from this call must indicate that
+ * a barrier has passed, though with no more writes may pass in either
+ * direction across the link, except if this call returns an error number.
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_link_disable(struct ntb_dev *ntb)
+{
+        return ntb->ops->link_disable(ntb);
+}
+
+/**
+ * ntb_db_is_unsafe() - check if it is safe to use hardware doorbell
+ * @ntb:        NTB device context.
+ *
+ * It is possible for some ntb hardware to be affected by errata.  Hardware
+ * drivers can advise clients to avoid using doorbells.  Clients may ignore
+ * this advice, though caution is recommended.
+ *
+ * Return: Zero if it is safe to use doorbells, or One if it is not safe.
+ */
+static inline int ntb_db_is_unsafe(struct ntb_dev *ntb)
+{
+        if (!ntb->ops->db_is_unsafe)
+                return 0;
+
+        return ntb->ops->db_is_unsafe(ntb);
+}
+
+/**
+ * ntb_db_valid_mask() - get a mask of doorbell bits supported by the ntb
+ * @ntb:        NTB device context.
+ *
+ * Hardware may support different number or arrangement of doorbell bits.
+ *
+ * Return: A mask of doorbell bits supported by the ntb.
+ */
+static inline u64 ntb_db_valid_mask(struct ntb_dev *ntb)
+{
+        return ntb->ops->db_valid_mask(ntb);
+}
+
+/**
+ * ntb_db_vector_count() - get the number of doorbell interrupt vectors
+ * @ntb:        NTB device context.
+ *
+ * Hardware may support different number of interrupt vectors.
+ *
+ * Return: The number of doorbell interrupt vectors.
+ */
+static inline int ntb_db_vector_count(struct ntb_dev *ntb)
+{
+        if (!ntb->ops->db_vector_count)
+                return 1;
+
+        return ntb->ops->db_vector_count(ntb);
+}
+
+/**
+ * ntb_db_vector_mask() - get a mask of doorbell bits serviced by a vector
+ * @ntb:        NTB device context.
+ * @vector:     Doorbell vector number.
+ *
+ * Each interrupt vector may have a different number or arrangement of bits.
+ *
+ * Return: A mask of doorbell bits serviced by a vector.
+ */
+static inline u64 ntb_db_vector_mask(struct ntb_dev *ntb, int vector)
+{
+        if (!ntb->ops->db_vector_mask)
+                return ntb_db_valid_mask(ntb);
+
+        return ntb->ops->db_vector_mask(ntb, vector);
+}
+
+/**
+ * ntb_db_read() - read the local doorbell register
+ * @ntb:        NTB device context.
+ *
+ * Read the local doorbell register, and return the bits that are set.
+ *
+ * Return: The bits currently set in the local doorbell register.
+ */
+static inline u64 ntb_db_read(struct ntb_dev *ntb)
+{
+        return ntb->ops->db_read(ntb);
+}
+
+/**
+ * ntb_db_set() - set bits in the local doorbell register
+ * @ntb:        NTB device context.
+ * @db_bits:    Doorbell bits to set.
+ *
+ * Set bits in the local doorbell register, which may generate a local doorbell
+ * interrupt.  Bits that were already set must remain set.
+ *
+ * This is unusual, and hardware may not support it.
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_db_set(struct ntb_dev *ntb, u64 db_bits)
+{
+        if (!ntb->ops->db_set)
+                return -EINVAL;
+
+        return ntb->ops->db_set(ntb, db_bits);
+}
+
+/**
+ * ntb_db_clear() - clear bits in the local doorbell register
+ * @ntb:        NTB device context.
+ * @db_bits:    Doorbell bits to clear.
+ *
+ * Clear bits in the local doorbell register, arming the bits for the next
+ * doorbell.
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_db_clear(struct ntb_dev *ntb, u64 db_bits)
+{
+        return ntb->ops->db_clear(ntb, db_bits);
+}
+
+/**
+ * ntb_db_read_mask() - read the local doorbell mask
+ * @ntb:        NTB device context.
+ *
+ * Read the local doorbell mask register, and return the bits that are set.
+ *
+ * This is unusual, though hardware is likely to support it.
+ *
+ * Return: The bits currently set in the local doorbell mask register.
+ */
+static inline u64 ntb_db_read_mask(struct ntb_dev *ntb)
+{
+        if (!ntb->ops->db_read_mask)
+                return 0;
+
+        return ntb->ops->db_read_mask(ntb);
+}
+
+/**
+ * ntb_db_set_mask() - set bits in the local doorbell mask
+ * @ntb:        NTB device context.
+ * @db_bits:    Doorbell mask bits to set.
+ *
+ * Set bits in the local doorbell mask register, preventing doorbell interrupts
+ * from being generated for those doorbell bits.  Bits that were already set
+ * must remain set.
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_db_set_mask(struct ntb_dev *ntb, u64 db_bits)
+{
+        return ntb->ops->db_set_mask(ntb, db_bits);
+}
+
+/**
+ * ntb_db_clear_mask() - clear bits in the local doorbell mask
+ * @ntb:        NTB device context.
+ * @db_bits:    Doorbell bits to clear.
+ *
+ * Clear bits in the local doorbell mask register, allowing doorbell interrupts
+ * from being generated for those doorbell bits.  If a doorbell bit is already
+ * set at the time the mask is cleared, and the corresponding mask bit is
+ * changed from set to clear, then the ntb driver must ensure that
+ * ntb_db_event() is called.  If the hardware does not generate the interrupt
+ * on clearing the mask bit, then the driver must call ntb_db_event() anyway.
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_db_clear_mask(struct ntb_dev *ntb, u64 db_bits)
+{
+        return ntb->ops->db_clear_mask(ntb, db_bits);
+}
+
+/**
+ * ntb_peer_db_addr() - address and size of the peer doorbell register
+ * @ntb:        NTB device context.
+ * @db_addr:    OUT - The address of the peer doorbell register.
+ * @db_size:    OUT - The number of bytes to write the peer doorbell register.
+ *
+ * Return the address of the peer doorbell register.  This may be used, for
+ * example, by drivers that offload memory copy operations to a dma engine.
+ * The drivers may wish to ring the peer doorbell at the completion of memory
+ * copy operations.  For efficiency, and to simplify ordering of operations
+ * between the dma memory copies and the ringing doorbell, the driver may
+ * append one additional dma memory copy with the doorbell register as the
+ * destination, after the memory copy operations.
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_peer_db_addr(struct ntb_dev *ntb,
+                                   phys_addr_t *db_addr,
+                                   resource_size_t *db_size)
+{
+        return ntb->ops->peer_db_addr(ntb, db_addr, db_size);
+}
+
+/**
+ * ntb_peer_db_read() - read the peer doorbell register
+ * @ntb:        NTB device context.
+ *
+ * Read the peer doorbell register, and return the bits that are set.
+ *
+ * This is unusual, and hardware may not support it.
+ *
+ * Return: The bits currently set in the peer doorbell register.
+ */
+static inline u64 ntb_peer_db_read(struct ntb_dev *ntb)
+{
+        if (!ntb->ops->peer_db_read)
+                return 0;
+
+        return ntb->ops->peer_db_read(ntb);
+}
+
+/**
+ * ntb_peer_db_set() - set bits in the peer doorbell register
+ * @ntb:        NTB device context.
+ * @db_bits:    Doorbell bits to set.
+ *
+ * Set bits in the peer doorbell register, which may generate a peer doorbell
+ * interrupt.  Bits that were already set must remain set.
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_peer_db_set(struct ntb_dev *ntb, u64 db_bits)
+{
+        return ntb->ops->peer_db_set(ntb, db_bits);
+}
+
+/**
+ * ntb_peer_db_clear() - clear bits in the local doorbell register
+ * @ntb:        NTB device context.
+ * @db_bits:    Doorbell bits to clear.
+ *
+ * Clear bits in the peer doorbell register, arming the bits for the next
+ * doorbell.
+ *
+ * This is unusual, and hardware may not support it.
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_peer_db_clear(struct ntb_dev *ntb, u64 db_bits)
+{
+        if (!ntb->ops->db_clear)
+                return -EINVAL;
+
+        return ntb->ops->peer_db_clear(ntb, db_bits);
+}
+
+/**
+ * ntb_peer_db_read_mask() - read the peer doorbell mask
+ * @ntb:        NTB device context.
+ *
+ * Read the peer doorbell mask register, and return the bits that are set.
+ *
+ * This is unusual, and hardware may not support it.
+ *
+ * Return: The bits currently set in the peer doorbell mask register.
+ */
+static inline u64 ntb_peer_db_read_mask(struct ntb_dev *ntb)
+{
+        if (!ntb->ops->db_read_mask)
+                return 0;
+
+        return ntb->ops->peer_db_read_mask(ntb);
+}
+
+/**
+ * ntb_peer_db_set_mask() - set bits in the peer doorbell mask
+ * @ntb:        NTB device context.
+ * @db_bits:    Doorbell mask bits to set.
+ *
+ * Set bits in the peer doorbell mask register, preventing doorbell interrupts
+ * from being generated for those doorbell bits.  Bits that were already set
+ * must remain set.
+ *
+ * This is unusual, and hardware may not support it.
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_peer_db_set_mask(struct ntb_dev *ntb, u64 db_bits)
+{
+        if (!ntb->ops->db_set_mask)
+                return -EINVAL;
+
+        return ntb->ops->peer_db_set_mask(ntb, db_bits);
+}
+
+/**
+ * ntb_peer_db_clear_mask() - clear bits in the peer doorbell mask
+ * @ntb:        NTB device context.
+ * @db_bits:    Doorbell bits to clear.
+ *
+ * Clear bits in the peer doorbell mask register, allowing doorbell interrupts
+ * from being generated for those doorbell bits.  If the hardware does not
+ * generate the interrupt on clearing the mask bit, then the driver should not
+ * implement this function!
+ *
+ * This is unusual, and hardware may not support it.
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_peer_db_clear_mask(struct ntb_dev *ntb, u64 db_bits)
+{
+        if (!ntb->ops->db_clear_mask)
+                return -EINVAL;
+
+        return ntb->ops->peer_db_clear_mask(ntb, db_bits);
+}
+
+/**
+ * ntb_spad_is_unsafe() - check if it is safe to use the hardware scratchpads
+ * @ntb:        NTB device context.
+ *
+ * It is possible for some ntb hardware to be affected by errata.  Hardware
+ * drivers can advise clients to avoid using scratchpads.  Clients may ignore
+ * this advice, though caution is recommended.
+ *
+ * Return: Zero if it is safe to use scratchpads, or One if it is not safe.
+ */
+static inline int ntb_spad_is_unsafe(struct ntb_dev *ntb)
+{
+        if (!ntb->ops->spad_is_unsafe)
+                return 0;
+
+        return ntb->ops->spad_is_unsafe(ntb);
+}
+
+/**
+ * ntb_mw_count() - get the number of scratchpads
+ * @ntb:        NTB device context.
+ *
+ * Hardware and topology may support a different number of scratchpads.
+ *
+ * Return: the number of scratchpads.
+ */
+static inline int ntb_spad_count(struct ntb_dev *ntb)
+{
+        return ntb->ops->spad_count(ntb);
+}
+
+/**
+ * ntb_spad_read() - read the local scratchpad register
+ * @ntb:        NTB device context.
+ * @idx:        Scratchpad index.
+ *
+ * Read the local scratchpad register, and return the value.
+ *
+ * Return: The value of the local scratchpad register.
+ */
+static inline u32 ntb_spad_read(struct ntb_dev *ntb, int idx)
+{
+        return ntb->ops->spad_read(ntb, idx);
+}
+
+/**
+ * ntb_spad_write() - write the local scratchpad register
+ * @ntb:        NTB device context.
+ * @idx:        Scratchpad index.
+ * @val:        Scratchpad value.
+ *
+ * Write the value to the local scratchpad register.
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_spad_write(struct ntb_dev *ntb, int idx, u32 val)
+{
+        return ntb->ops->spad_write(ntb, idx, val);
+}
+
+/**
+ * ntb_peer_spad_addr() - address of the peer scratchpad register
+ * @ntb:        NTB device context.
+ * @idx:        Scratchpad index.
+ * @spad_addr:  OUT - The address of the peer scratchpad register.
+ *
+ * Return the address of the peer doorbell register.  This may be used, for
+ * example, by drivers that offload memory copy operations to a dma engine.
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_peer_spad_addr(struct ntb_dev *ntb, int idx,
+                                     phys_addr_t *spad_addr)
+{
+        return ntb->ops->peer_spad_addr(ntb, idx, spad_addr);
+}
+
+/**
+ * ntb_peer_spad_read() - read the peer scratchpad register
+ * @ntb:        NTB device context.
+ * @idx:        Scratchpad index.
+ *
+ * Read the peer scratchpad register, and return the value.
+ *
+ * Return: The value of the local scratchpad register.
+ */
+static inline u32 ntb_peer_spad_read(struct ntb_dev *ntb, int idx)
+{
+        return ntb->ops->peer_spad_read(ntb, idx);
+}
+
+/**
+ * ntb_peer_spad_write() - write the peer scratchpad register
+ * @ntb:        NTB device context.
+ * @idx:        Scratchpad index.
+ * @val:        Scratchpad value.
+ *
+ * Write the value to the peer scratchpad register.
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_peer_spad_write(struct ntb_dev *ntb, int idx, u32 val)
+{
+        return ntb->ops->peer_spad_write(ntb, idx, val);
+}
+
+#endif
diff --git a/include/linux/ntb_transport.h b/include/linux/ntb_transport.h
new file mode 100644
index 000000000000..2862861366a5
--- /dev/null
+++ b/include/linux/ntb_transport.h
@@ -0,0 +1,85 @@
+/*
+ * This file is provided under a dual BSD/GPLv2 license.  When using or
+ *   redistributing this file, you may do so under either license.
+ *
+ *   GPL LICENSE SUMMARY
+ *
+ *   Copyright(c) 2012 Intel Corporation. All rights reserved.
+ *   Copyright (C) 2015 EMC Corporation. All Rights Reserved.
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of version 2 of the GNU General Public License as
+ *   published by the Free Software Foundation.
+ *
+ *   BSD LICENSE
+ *
+ *   Copyright(c) 2012 Intel Corporation. All rights reserved.
+ *   Copyright (C) 2015 EMC Corporation. All Rights Reserved.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following conditions
+ *   are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copy
+ *       notice, this list of conditions and the following disclaimer in
+ *       the documentation and/or other materials provided with the
+ *       distribution.
+ *     * Neither the name of Intel Corporation nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * PCIe NTB Transport Linux driver
+ *
+ * Contact Information:
+ * Jon Mason <jon.mason@intel.com>
+ */
+
+struct ntb_transport_qp;
+
+struct ntb_transport_client {
+        struct device_driver driver;
+        int (*probe)(struct device *client_dev);
+        void (*remove)(struct device *client_dev);
+};
+
+int ntb_transport_register_client(struct ntb_transport_client *drvr);
+void ntb_transport_unregister_client(struct ntb_transport_client *drvr);
+int ntb_transport_register_client_dev(char *device_name);
+void ntb_transport_unregister_client_dev(char *device_name);
+
+struct ntb_queue_handlers {
+        void (*rx_handler)(struct ntb_transport_qp *qp, void *qp_data,
+                           void *data, int len);
+        void (*tx_handler)(struct ntb_transport_qp *qp, void *qp_data,
+                           void *data, int len);
+        void (*event_handler)(void *data, int status);
+};
+
+unsigned char ntb_transport_qp_num(struct ntb_transport_qp *qp);
+unsigned int ntb_transport_max_size(struct ntb_transport_qp *qp);
+struct ntb_transport_qp *
+ntb_transport_create_queue(void *data, struct device *client_dev,
+                           const struct ntb_queue_handlers *handlers);
+void ntb_transport_free_queue(struct ntb_transport_qp *qp);
+int ntb_transport_rx_enqueue(struct ntb_transport_qp *qp, void *cb, void *data,
+                             unsigned int len);
+int ntb_transport_tx_enqueue(struct ntb_transport_qp *qp, void *cb, void *data,
+                             unsigned int len);
+void *ntb_transport_rx_remove(struct ntb_transport_qp *qp, unsigned int *len);
+void ntb_transport_link_up(struct ntb_transport_qp *qp);
+void ntb_transport_link_down(struct ntb_transport_qp *qp);
+bool ntb_transport_link_query(struct ntb_transport_qp *qp);
diff --git a/include/linux/nvme.h b/include/linux/nvme.h
index 8dbd05e70f09..c0d94ed8ce9a 100644
--- a/include/linux/nvme.h
+++ b/include/linux/nvme.h
@@ -74,7 +74,7 @@ struct nvme_dev {
         struct blk_mq_tag_set tagset;
         struct blk_mq_tag_set admin_tagset;
         u32 __iomem *dbs;
-        struct pci_dev *pci_dev;
+        struct device *dev;
         struct dma_pool *prp_page_pool;
         struct dma_pool *prp_small_pool;
         int instance;
@@ -92,6 +92,7 @@ struct nvme_dev {
         work_func_t reset_workfn;
         struct work_struct reset_work;
         struct work_struct probe_work;
+        struct work_struct scan_work;
         char name[12];
         char serial[20];
         char model[40];
@@ -146,25 +147,15 @@ static inline u64 nvme_block_nr(struct nvme_ns *ns, sector_t sector)
         return (sector >> (ns->lba_shift - 9));
 }
 
-/**
- * nvme_free_iod - frees an nvme_iod
- * @dev: The device that the I/O was submitted to
- * @iod: The memory to free
- */
-void nvme_free_iod(struct nvme_dev *dev, struct nvme_iod *iod);
-
-int nvme_setup_prps(struct nvme_dev *, struct nvme_iod *, int, gfp_t);
-struct nvme_iod *nvme_map_user_pages(struct nvme_dev *dev, int write,
-                                unsigned long addr, unsigned length);
-void nvme_unmap_user_pages(struct nvme_dev *dev, int write,
-                        struct nvme_iod *iod);
-int nvme_submit_io_cmd(struct nvme_dev *, struct nvme_ns *,
-                                                struct nvme_command *, u32 *);
-int nvme_submit_flush_data(struct nvme_queue *nvmeq, struct nvme_ns *ns);
-int nvme_submit_admin_cmd(struct nvme_dev *, struct nvme_command *,
-                                                        u32 *result);
-int nvme_identify(struct nvme_dev *, unsigned nsid, unsigned cns,
-                                                        dma_addr_t dma_addr);
+int nvme_submit_sync_cmd(struct request_queue *q, struct nvme_command *cmd,
+                void *buf, unsigned bufflen);
+int __nvme_submit_sync_cmd(struct request_queue *q, struct nvme_command *cmd,
+                void *buffer, void __user *ubuffer, unsigned bufflen,
+                u32 *result, unsigned timeout);
+int nvme_identify_ctrl(struct nvme_dev *dev, struct nvme_id_ctrl **id);
+int nvme_identify_ns(struct nvme_dev *dev, unsigned nsid,
+                struct nvme_id_ns **id);
+int nvme_get_log_page(struct nvme_dev *dev, struct nvme_smart_log **log);
 int nvme_get_features(struct nvme_dev *dev, unsigned fid, unsigned nsid,
                         dma_addr_t dma_addr, u32 *result);
 int nvme_set_features(struct nvme_dev *dev, unsigned fid, unsigned dword11,
diff --git a/include/linux/of.h b/include/linux/of.h
index b871ff9d81d7..edc068d19c79 100644
--- a/include/linux/of.h
+++ b/include/linux/of.h
@@ -120,6 +120,12 @@ extern struct device_node *of_aliases;
 extern struct device_node *of_stdout;
 extern raw_spinlock_t devtree_lock;
 
+/* flag descriptions (need to be visible even when !CONFIG_OF) */
+#define OF_DYNAMIC      1 /* node and properties were allocated via kmalloc */
+#define OF_DETACHED     2 /* node has been detached from the device tree */
+#define OF_POPULATED    3 /* device already created for the node */
+#define OF_POPULATED_BUS        4 /* of_platform_populate recursed to children of this node */
+
 #ifdef CONFIG_OF
 void of_core_init(void);
 
@@ -128,7 +134,7 @@ static inline bool is_of_node(struct fwnode_handle *fwnode)
         return fwnode && fwnode->type == FWNODE_OF;
 }
 
-static inline struct device_node *of_node(struct fwnode_handle *fwnode)
+static inline struct device_node *to_of_node(struct fwnode_handle *fwnode)
 {
         return fwnode ? container_of(fwnode, struct device_node, fwnode) : NULL;
 }
@@ -219,12 +225,6 @@ static inline unsigned long of_read_ulong(const __be32 *cell, int size)
 #define of_node_cmp(s1, s2)             strcasecmp((s1), (s2))
 #endif
 
-/* flag descriptions */
-#define OF_DYNAMIC      1 /* node and properties were allocated via kmalloc */
-#define OF_DETACHED     2 /* node has been detached from the device tree */
-#define OF_POPULATED    3 /* device already created for the node */
-#define OF_POPULATED_BUS        4 /* of_platform_populate recursed to children of this node */
-
 #define OF_IS_DYNAMIC(x) test_bit(OF_DYNAMIC, &x->_flags)
 #define OF_MARK_DYNAMIC(x) set_bit(OF_DYNAMIC, &x->_flags)
 
@@ -387,7 +387,7 @@ static inline bool is_of_node(struct fwnode_handle *fwnode)
         return false;
 }
 
-static inline struct device_node *of_node(struct fwnode_handle *fwnode)
+static inline struct device_node *to_of_node(struct fwnode_handle *fwnode)
 {
         return NULL;
 }
@@ -428,6 +428,11 @@ static inline struct device_node *of_find_node_opts_by_path(const char *path,
         return NULL;
 }
 
+static inline struct device_node *of_find_node_by_phandle(phandle handle)
+{
+        return NULL;
+}
+
 static inline struct device_node *of_get_parent(const struct device_node *node)
 {
         return NULL;
@@ -673,7 +678,10 @@ static inline void of_property_clear_flag(struct property *p, unsigned long flag
 #if defined(CONFIG_OF) && defined(CONFIG_NUMA)
 extern int of_node_to_nid(struct device_node *np);
 #else
-static inline int of_node_to_nid(struct device_node *device) { return 0; }
+static inline int of_node_to_nid(struct device_node *device)
+{
+        return NUMA_NO_NODE;
+}
 #endif
 
 static inline struct device_node *of_find_matching_node(
@@ -821,7 +829,7 @@ static inline int of_property_read_string_index(struct device_node *np,
  * @propname:   name of the property to be searched.
  *
  * Search for a property in a device node.
- * Returns true if the property exist false otherwise.
+ * Returns true if the property exists false otherwise.
  */
 static inline bool of_property_read_bool(const struct device_node *np,
                                          const char *propname)
diff --git a/include/linux/of_device.h b/include/linux/of_device.h
index 22801b10cef5..cc7dd687a89d 100644
--- a/include/linux/of_device.h
+++ b/include/linux/of_device.h
@@ -33,6 +33,8 @@ extern int of_device_add(struct platform_device *pdev);
 extern int of_device_register(struct platform_device *ofdev);
 extern void of_device_unregister(struct platform_device *ofdev);
 
+extern const void *of_device_get_match_data(const struct device *dev);
+
 extern ssize_t of_device_get_modalias(struct device *dev,
                                         char *str, ssize_t len);
 
@@ -57,7 +59,7 @@ void of_dma_configure(struct device *dev, struct device_node *np);
 #else /* CONFIG_OF */
 
 static inline int of_driver_match_device(struct device *dev,
-                                         struct device_driver *drv)
+                                         const struct device_driver *drv)
 {
         return 0;
 }
@@ -65,6 +67,11 @@ static inline int of_driver_match_device(struct device *dev,
 static inline void of_device_uevent(struct device *dev,
                         struct kobj_uevent_env *env) { }
 
+static inline const void *of_device_get_match_data(const struct device *dev)
+{
+        return NULL;
+}
+
 static inline int of_device_get_modalias(struct device *dev,
                                    char *str, ssize_t len)
 {
diff --git a/include/linux/of_dma.h b/include/linux/of_dma.h
index 56bc026c143f..98ba7525929e 100644
--- a/include/linux/of_dma.h
+++ b/include/linux/of_dma.h
@@ -23,6 +23,9 @@ struct of_dma {
         struct device_node      *of_node;
         struct dma_chan         *(*of_dma_xlate)
                                 (struct of_phandle_args *, struct of_dma *);
+        void                    *(*of_dma_route_allocate)
+                                (struct of_phandle_args *, struct of_dma *);
+        struct dma_router       *dma_router;
         void                    *of_dma_data;
 };
 
@@ -37,12 +40,20 @@ extern int of_dma_controller_register(struct device_node *np,
                 (struct of_phandle_args *, struct of_dma *),
                 void *data);
 extern void of_dma_controller_free(struct device_node *np);
+
+extern int of_dma_router_register(struct device_node *np,
+                void *(*of_dma_route_allocate)
+                (struct of_phandle_args *, struct of_dma *),
+                struct dma_router *dma_router);
+#define of_dma_router_free of_dma_controller_free
+
 extern struct dma_chan *of_dma_request_slave_channel(struct device_node *np,
                                                      const char *name);
 extern struct dma_chan *of_dma_simple_xlate(struct of_phandle_args *dma_spec,
                 struct of_dma *ofdma);
 extern struct dma_chan *of_dma_xlate_by_chan_id(struct of_phandle_args *dma_spec,
                 struct of_dma *ofdma);
+
 #else
 static inline int of_dma_controller_register(struct device_node *np,
                 struct dma_chan *(*of_dma_xlate)
@@ -56,6 +67,16 @@ static inline void of_dma_controller_free(struct device_node *np)
 {
 }
 
+static inline int of_dma_router_register(struct device_node *np,
+                void *(*of_dma_route_allocate)
+                (struct of_phandle_args *, struct of_dma *),
+                struct dma_router *dma_router)
+{
+        return -ENODEV;
+}
+
+#define of_dma_router_free of_dma_controller_free
+
 static inline struct dma_chan *of_dma_request_slave_channel(struct device_node *np,
                                                      const char *name)
 {
diff --git a/include/linux/of_fdt.h b/include/linux/of_fdt.h
index 587ee507965d..df9ef3801812 100644
--- a/include/linux/of_fdt.h
+++ b/include/linux/of_fdt.h
@@ -37,7 +37,7 @@ extern bool of_fdt_is_big_endian(const void *blob,
                                  unsigned long node);
 extern int of_fdt_match(const void *blob, unsigned long node,
                         const char *const *compat);
-extern void of_fdt_unflatten_tree(unsigned long *blob,
+extern void of_fdt_unflatten_tree(const unsigned long *blob,
                                struct device_node **mynodes);
 
 /* TBD: Temporary export of fdt globals - remove when code fully merged */
@@ -64,6 +64,7 @@ extern int early_init_dt_scan_chosen(unsigned long node, const char *uname,
 extern int early_init_dt_scan_memory(unsigned long node, const char *uname,
                                      int depth, void *data);
 extern void early_init_fdt_scan_reserved_mem(void);
+extern void early_init_fdt_reserve_self(void);
 extern void early_init_dt_add_memory_arch(u64 base, u64 size);
 extern int early_init_dt_reserve_memory_arch(phys_addr_t base, phys_addr_t size,
                                              bool no_map);
@@ -91,6 +92,7 @@ extern u64 fdt_translate_address(const void *blob, int node_offset);
 extern void of_fdt_limit_memory(int limit);
 #else /* CONFIG_OF_FLATTREE */
 static inline void early_init_fdt_scan_reserved_mem(void) {}
+static inline void early_init_fdt_reserve_self(void) {}
 static inline const char *of_flat_dt_get_machine_name(void) { return NULL; }
 static inline void unflatten_device_tree(void) {}
 static inline void unflatten_and_copy_device_tree(void) {}
diff --git a/include/linux/of_graph.h b/include/linux/of_graph.h
index 7bc92e050608..f8bcd0e21a26 100644
--- a/include/linux/of_graph.h
+++ b/include/linux/of_graph.h
@@ -45,6 +45,8 @@ int of_graph_parse_endpoint(const struct device_node *node,
 struct device_node *of_graph_get_port_by_id(struct device_node *node, u32 id);
 struct device_node *of_graph_get_next_endpoint(const struct device_node *parent,
                                         struct device_node *previous);
+struct device_node *of_graph_get_endpoint_by_regs(
+                const struct device_node *parent, int port_reg, int reg);
 struct device_node *of_graph_get_remote_port_parent(
                                         const struct device_node *node);
 struct device_node *of_graph_get_remote_port(const struct device_node *node);
@@ -69,6 +71,12 @@ static inline struct device_node *of_graph_get_next_endpoint(
         return NULL;
 }
 
+static inline struct device_node *of_graph_get_endpoint_by_regs(
+                const struct device_node *parent, int port_reg, int reg)
+{
+        return NULL;
+}
+
 static inline struct device_node *of_graph_get_remote_port_parent(
                                         const struct device_node *node)
 {
diff --git a/include/linux/oom.h b/include/linux/oom.h
index 44b2f6f7bbd8..7deecb7bca5e 100644
--- a/include/linux/oom.h
+++ b/include/linux/oom.h
@@ -32,6 +32,8 @@ enum oom_scan_t {
 /* Thread is the potential origin of an oom condition; kill first on oom */
 #define OOM_FLAG_ORIGIN         ((__force oom_flags_t)0x1)
 
+extern struct mutex oom_lock;
+
 static inline void set_current_oom_origin(void)
 {
         current->signal->oom_flags |= OOM_FLAG_ORIGIN;
@@ -47,9 +49,7 @@ static inline bool oom_task_origin(const struct task_struct *p)
         return !!(p->signal->oom_flags & OOM_FLAG_ORIGIN);
 }
 
-extern void mark_tsk_oom_victim(struct task_struct *tsk);
-
-extern void unmark_oom_victim(void);
+extern void mark_oom_victim(struct task_struct *tsk);
 
 extern unsigned long oom_badness(struct task_struct *p,
                 struct mem_cgroup *memcg, const nodemask_t *nodemask,
@@ -62,9 +62,6 @@ extern void oom_kill_process(struct task_struct *p, gfp_t gfp_mask, int order,
                              struct mem_cgroup *memcg, nodemask_t *nodemask,
                              const char *message);
 
-extern bool oom_zonelist_trylock(struct zonelist *zonelist, gfp_t gfp_flags);
-extern void oom_zonelist_unlock(struct zonelist *zonelist, gfp_t gfp_flags);
-
 extern void check_panic_on_oom(enum oom_constraint constraint, gfp_t gfp_mask,
                                int order, const nodemask_t *nodemask,
                                struct mem_cgroup *memcg);
@@ -75,6 +72,9 @@ extern enum oom_scan_t oom_scan_process_thread(struct task_struct *task,
 
 extern bool out_of_memory(struct zonelist *zonelist, gfp_t gfp_mask,
                 int order, nodemask_t *mask, bool force_kill);
+
+extern void exit_oom_victim(void);
+
 extern int register_oom_notifier(struct notifier_block *nb);
 extern int unregister_oom_notifier(struct notifier_block *nb);
 
diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h
index f34e040b34e9..41c93844fb1d 100644
--- a/include/linux/page-flags.h
+++ b/include/linux/page-flags.h
@@ -631,15 +631,19 @@ static inline void ClearPageSlabPfmemalloc(struct page *page)
          1 << PG_private | 1 << PG_private_2 | \
          1 << PG_writeback | 1 << PG_reserved | \
          1 << PG_slab    | 1 << PG_swapcache | 1 << PG_active | \
-         1 << PG_unevictable | __PG_MLOCKED | __PG_HWPOISON | \
+         1 << PG_unevictable | __PG_MLOCKED | \
          __PG_COMPOUND_LOCK)
 
 /*
  * Flags checked when a page is prepped for return by the page allocator.
- * Pages being prepped should not have any flags set.  It they are set,
+ * Pages being prepped should not have these flags set.  It they are set,
  * there has been a kernel bug or struct page corruption.
+ *
+ * __PG_HWPOISON is exceptional because it needs to be kept beyond page's
+ * alloc-free cycle to prevent from reusing the page.
  */
-#define PAGE_FLAGS_CHECK_AT_PREP        ((1 << NR_PAGEFLAGS) - 1)
+#define PAGE_FLAGS_CHECK_AT_PREP        \
+        (((1 << NR_PAGEFLAGS) - 1) & ~__PG_HWPOISON)
 
 #define PAGE_FLAGS_PRIVATE                              \
         (1 << PG_private | 1 << PG_private_2)
diff --git a/include/linux/page_owner.h b/include/linux/page_owner.h
index b48c3471c254..cacaabea8a09 100644
--- a/include/linux/page_owner.h
+++ b/include/linux/page_owner.h
@@ -8,6 +8,7 @@ extern struct page_ext_operations page_owner_ops;
 extern void __reset_page_owner(struct page *page, unsigned int order);
 extern void __set_page_owner(struct page *page,
                         unsigned int order, gfp_t gfp_mask);
+extern gfp_t __get_page_owner_gfp(struct page *page);
 
 static inline void reset_page_owner(struct page *page, unsigned int order)
 {
@@ -25,6 +26,14 @@ static inline void set_page_owner(struct page *page,
 
         __set_page_owner(page, order, gfp_mask);
 }
+
+static inline gfp_t get_page_owner_gfp(struct page *page)
+{
+        if (likely(!page_owner_inited))
+                return 0;
+
+        return __get_page_owner_gfp(page);
+}
 #else
 static inline void reset_page_owner(struct page *page, unsigned int order)
 {
@@ -33,6 +42,10 @@ static inline void set_page_owner(struct page *page,
                         unsigned int order, gfp_t gfp_mask)
 {
 }
+static inline gfp_t get_page_owner_gfp(struct page *page)
+{
+        return 0;
+}
 
 #endif /* CONFIG_PAGE_OWNER */
 #endif /* __LINUX_PAGE_OWNER_H */
diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
index 4b3736f7065c..a6c78e00ea96 100644
--- a/include/linux/pagemap.h
+++ b/include/linux/pagemap.h
@@ -651,7 +651,8 @@ int add_to_page_cache_locked(struct page *page, struct address_space *mapping,
 int add_to_page_cache_lru(struct page *page, struct address_space *mapping,
                                 pgoff_t index, gfp_t gfp_mask);
 extern void delete_from_page_cache(struct page *page);
-extern void __delete_from_page_cache(struct page *page, void *shadow);
+extern void __delete_from_page_cache(struct page *page, void *shadow,
+                                     struct mem_cgroup *memcg);
 int replace_page_cache_page(struct page *old, struct page *new, gfp_t gfp_mask);
 
 /*
@@ -670,4 +671,10 @@ static inline int add_to_page_cache(struct page *page,
         return error;
 }
 
+static inline unsigned long dir_pages(struct inode *inode)
+{
+        return (unsigned long)(inode->i_size + PAGE_CACHE_SIZE - 1) >>
+                               PAGE_CACHE_SHIFT;
+}
+
 #endif /* _LINUX_PAGEMAP_H */
diff --git a/include/linux/parport.h b/include/linux/parport.h
index c22f12547324..58e3c64c6b49 100644
--- a/include/linux/parport.h
+++ b/include/linux/parport.h
@@ -13,6 +13,7 @@
 #include <linux/wait.h>
 #include <linux/irqreturn.h>
 #include <linux/semaphore.h>
+#include <linux/device.h>
 #include <asm/ptrace.h>
 #include <uapi/linux/parport.h>
 
@@ -145,6 +146,8 @@ struct pardevice {
         unsigned int flags;
         struct pardevice *next;
         struct pardevice *prev;
+        struct device dev;
+        bool devmodel;
         struct parport_state *state;     /* saved status over preemption */
         wait_queue_head_t wait_q;
         unsigned long int time;
@@ -156,6 +159,8 @@ struct pardevice {
         void * sysctl_table;
 };
 
+#define to_pardevice(n) container_of(n, struct pardevice, dev)
+
 /* IEEE1284 information */
 
 /* IEEE1284 phases. These are exposed to userland through ppdev IOCTL
@@ -195,7 +200,7 @@ struct parport {
                                  * This may unfortulately be null if the
                                  * port has a legacy driver.
                                  */
-
+        struct device bus_dev;  /* to link with the bus */
         struct parport *physport;
                                 /* If this is a non-default mux
                                    parport, i.e. we're a clone of a real
@@ -245,15 +250,26 @@ struct parport {
         struct parport *slaves[3];
 };
 
+#define to_parport_dev(n) container_of(n, struct parport, bus_dev)
+
 #define DEFAULT_SPIN_TIME 500 /* us */
 
 struct parport_driver {
         const char *name;
         void (*attach) (struct parport *);
         void (*detach) (struct parport *);
+        void (*match_port)(struct parport *);
+        int (*probe)(struct pardevice *);
+        struct device_driver driver;
+        bool devmodel;
         struct list_head list;
 };
 
+#define to_parport_driver(n) container_of(n, struct parport_driver, driver)
+
+int parport_bus_init(void);
+void parport_bus_exit(void);
+
 /* parport_register_port registers a new parallel port at the given
    address (if one does not already exist) and returns a pointer to it.
    This entails claiming the I/O region, IRQ and DMA.  NULL is returned
@@ -272,10 +288,20 @@ void parport_announce_port (struct parport *port);
 extern void parport_remove_port(struct parport *port);
 
 /* Register a new high-level driver. */
-extern int parport_register_driver (struct parport_driver *);
+
+int __must_check __parport_register_driver(struct parport_driver *,
+                                           struct module *,
+                                           const char *mod_name);
+/*
+ * parport_register_driver must be a macro so that KBUILD_MODNAME can
+ * be expanded
+ */
+#define parport_register_driver(driver)             \
+        __parport_register_driver(driver, THIS_MODULE, KBUILD_MODNAME)
 
 /* Unregister a high-level driver. */
 extern void parport_unregister_driver (struct parport_driver *);
+void parport_unregister_driver(struct parport_driver *);
 
 /* If parport_register_driver doesn't fit your needs, perhaps
  * parport_find_xxx does. */
@@ -288,6 +314,15 @@ extern irqreturn_t parport_irq_handler(int irq, void *dev_id);
 /* Reference counting for ports. */
 extern struct parport *parport_get_port (struct parport *);
 extern void parport_put_port (struct parport *);
+void parport_del_port(struct parport *);
+
+struct pardev_cb {
+        int (*preempt)(void *);
+        void (*wakeup)(void *);
+        void *private;
+        void (*irq_func)(void *);
+        unsigned int flags;
+};
 
 /* parport_register_device declares that a device is connected to a
    port, and tells the kernel all it needs to know.
@@ -301,6 +336,10 @@ struct pardevice *parport_register_device(struct parport *port,
                           void (*irq_func)(void *), 
                           int flags, void *handle);
 
+struct pardevice *
+parport_register_dev_model(struct parport *port, const char *name,
+                           const struct pardev_cb *par_dev_cb, int cnt);
+
 /* parport_unregister unlinks a device from the chain. */
 extern void parport_unregister_device(struct pardevice *dev);
 
diff --git a/include/linux/pata_arasan_cf_data.h b/include/linux/pata_arasan_cf_data.h
index 3cc21c9cc1e8..9fade5dd2e86 100644
--- a/include/linux/pata_arasan_cf_data.h
+++ b/include/linux/pata_arasan_cf_data.h
@@ -4,7 +4,7 @@
  * Arasan Compact Flash host controller platform data header file
  *
  * Copyright (C) 2011 ST Microelectronics
- * Viresh Kumar <viresh.linux@gmail.com>
+ * Viresh Kumar <vireshk@kernel.org>
  *
  * This file is licensed under the terms of the GNU General Public
  * License version 2. This program is licensed "as is" without any
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index cb63a7b522ef..fcff8f865341 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -2330,6 +2330,8 @@
 #define PCI_DEVICE_ID_ALTIMA_AC9100     0x03ea
 #define PCI_DEVICE_ID_ALTIMA_AC1003     0x03eb
 
+#define PCI_VENDOR_ID_CAVIUM            0x177d
+
 #define PCI_VENDOR_ID_BELKIN            0x1799
 #define PCI_DEVICE_ID_BELKIN_F5D7010V7  0x701f
 
diff --git a/include/linux/perf_event.h b/include/linux/perf_event.h
index 1b82d44b0a02..2027809433b3 100644
--- a/include/linux/perf_event.h
+++ b/include/linux/perf_event.h
@@ -300,6 +300,11 @@ struct pmu {
          * Free pmu-private AUX data structures
          */
         void (*free_aux)                (void *aux); /* optional */
+
+        /*
+         * Filter events for PMU-specific reasons.
+         */
+        int (*filter_match)             (struct perf_event *event); /* optional */
 };
 
 /**
@@ -479,7 +484,7 @@ struct perf_event {
         void                            *overflow_handler_context;
 
 #ifdef CONFIG_EVENT_TRACING
-        struct ftrace_event_call        *tp_event;
+        struct trace_event_call         *tp_event;
         struct event_filter             *filter;
 #ifdef CONFIG_FUNCTION_TRACER
         struct ftrace_ops               ftrace_ops;
diff --git a/include/linux/phy.h b/include/linux/phy.h
index 685809835b5c..a26c3f84b8dd 100644
--- a/include/linux/phy.h
+++ b/include/linux/phy.h
@@ -181,6 +181,9 @@ struct mii_bus {
         /* PHY addresses to be ignored when probing */
         u32 phy_mask;
 
+        /* PHY addresses to ignore the TA/read failure */
+        u32 phy_ignore_ta_mask;
+
         /*
          * Pointer to an array of interrupts, each PHY's
          * interrupt at the index matching its address
@@ -675,6 +678,17 @@ static inline bool phy_is_internal(struct phy_device *phydev)
 }
 
 /**
+ * phy_interface_is_rgmii - Convenience function for testing if a PHY interface
+ * is RGMII (all variants)
+ * @phydev: the phy_device struct
+ */
+static inline bool phy_interface_is_rgmii(struct phy_device *phydev)
+{
+        return phydev->interface >= PHY_INTERFACE_MODE_RGMII &&
+                phydev->interface <= PHY_INTERFACE_MODE_RGMII_TXID;
+}
+
+/**
  * phy_write_mmd - Convenience function for writing a register
  * on an MMD on a given PHY.
  * @phydev: The phy_device struct
diff --git a/include/linux/phy/phy-sun4i-usb.h b/include/linux/phy/phy-sun4i-usb.h
new file mode 100644
index 000000000000..50aed92ea89c
--- /dev/null
+++ b/include/linux/phy/phy-sun4i-usb.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2015 Hans de Goede <hdegoede@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef PHY_SUN4I_USB_H_
+#define PHY_SUN4I_USB_H_
+
+#include "phy.h"
+
+/**
+ * sun4i_usb_phy_set_squelch_detect() - Enable/disable squelch detect
+ * @phy: reference to a sun4i usb phy
+ * @enabled: wether to enable or disable squelch detect
+ */
+void sun4i_usb_phy_set_squelch_detect(struct phy *phy, bool enabled);
+
+#endif
diff --git a/include/linux/phy/phy.h b/include/linux/phy/phy.h
index a0197fa1b116..8cf05e341cff 100644
--- a/include/linux/phy/phy.h
+++ b/include/linux/phy/phy.h
@@ -133,6 +133,8 @@ struct phy *devm_phy_get(struct device *dev, const char *string);
 struct phy *devm_phy_optional_get(struct device *dev, const char *string);
 struct phy *devm_of_phy_get(struct device *dev, struct device_node *np,
                             const char *con_id);
+struct phy *devm_of_phy_get_by_index(struct device *dev, struct device_node *np,
+                                     int index);
 void phy_put(struct phy *phy);
 void devm_phy_put(struct device *dev, struct phy *phy);
 struct phy *of_phy_get(struct device_node *np, const char *con_id);
@@ -261,6 +263,13 @@ static inline struct phy *devm_of_phy_get(struct device *dev,
         return ERR_PTR(-ENOSYS);
 }
 
+static inline struct phy *devm_of_phy_get_by_index(struct device *dev,
+                                                   struct device_node *np,
+                                                   int index)
+{
+        return ERR_PTR(-ENOSYS);
+}
+
 static inline void phy_put(struct phy *phy)
 {
 }
diff --git a/include/linux/pinctrl/consumer.h b/include/linux/pinctrl/consumer.h
index 18eccefea06e..d7e5d608faa7 100644
--- a/include/linux/pinctrl/consumer.h
+++ b/include/linux/pinctrl/consumer.h
@@ -142,7 +142,7 @@ static inline struct pinctrl * __must_check pinctrl_get_select(
         s = pinctrl_lookup_state(p, name);
         if (IS_ERR(s)) {
                 pinctrl_put(p);
-                return ERR_PTR(PTR_ERR(s));
+                return ERR_CAST(s);
         }
 
         ret = pinctrl_select_state(p, s);
diff --git a/include/linux/pinctrl/pinctrl.h b/include/linux/pinctrl/pinctrl.h
index 66e4697516de..9ba59fcba549 100644
--- a/include/linux/pinctrl/pinctrl.h
+++ b/include/linux/pinctrl/pinctrl.h
@@ -127,7 +127,7 @@ struct pinctrl_ops {
  */
 struct pinctrl_desc {
         const char *name;
-        struct pinctrl_pin_desc const *pins;
+        const struct pinctrl_pin_desc *pins;
         unsigned int npins;
         const struct pinctrl_ops *pctlops;
         const struct pinmux_ops *pmxops;
diff --git a/include/linux/pinctrl/pinmux.h b/include/linux/pinctrl/pinmux.h
index 511bda9ed4bf..ace60d775b20 100644
--- a/include/linux/pinctrl/pinmux.h
+++ b/include/linux/pinctrl/pinmux.h
@@ -56,6 +56,9 @@ struct pinctrl_dev;
  *      depending on whether the GPIO is configured as input or output,
  *      a direction selector function may be implemented as a backing
  *      to the GPIO controllers that need pin muxing.
+ * @strict: do not allow simultaneous use of the same pin for GPIO and another
+ *      function. Check both gpio_owner and mux_owner strictly before approving
+ *      the pin request.
  */
 struct pinmux_ops {
         int (*request) (struct pinctrl_dev *pctldev, unsigned offset);
@@ -66,7 +69,7 @@ struct pinmux_ops {
         int (*get_function_groups) (struct pinctrl_dev *pctldev,
                                   unsigned selector,
                                   const char * const **groups,
-                                  unsigned * const num_groups);
+                                  unsigned *num_groups);
         int (*set_mux) (struct pinctrl_dev *pctldev, unsigned func_selector,
                         unsigned group_selector);
         int (*gpio_request_enable) (struct pinctrl_dev *pctldev,
@@ -79,6 +82,7 @@ struct pinmux_ops {
                                    struct pinctrl_gpio_range *range,
                                    unsigned offset,
                                    bool input);
+        bool strict;
 };
 
 #endif /* CONFIG_PINMUX */
diff --git a/include/linux/platform_data/dma-rcar-audmapp.h b/include/linux/platform_data/dma-rcar-audmapp.h
deleted file mode 100644
index 471fffebbeb4..000000000000
--- a/include/linux/platform_data/dma-rcar-audmapp.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * This is for Renesas R-Car Audio-DMAC-peri-peri.
- *
- * Copyright (C) 2014 Renesas Electronics Corporation
- * Copyright (C) 2014 Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
- *
- * This file is based on the include/linux/sh_dma.h
- *
- * Header for the new SH dmaengine driver
- *
- * Copyright (C) 2010 Guennadi Liakhovetski <g.liakhovetski@gmx.de>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-#ifndef SH_AUDMAPP_H
-#define SH_AUDMAPP_H
-
-#include <linux/dmaengine.h>
-
-struct audmapp_slave_config {
-        int             slave_id;
-        dma_addr_t      src;
-        dma_addr_t      dst;
-        u32             chcr;
-};
-
-struct audmapp_pdata {
-        struct audmapp_slave_config *slave;
-        int slave_num;
-};
-
-#endif /* SH_AUDMAPP_H */
diff --git a/include/linux/platform_data/gpio-ath79.h b/include/linux/platform_data/gpio-ath79.h
new file mode 100644
index 000000000000..88b0db7bee74
--- /dev/null
+++ b/include/linux/platform_data/gpio-ath79.h
@@ -0,0 +1,19 @@
+/*
+ *  Atheros AR7XXX/AR9XXX GPIO controller platform data
+ *
+ * Copyright (C) 2015 Alban Bedel <albeu@free.fr>
+ *
+ * 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_PLATFORM_DATA_GPIO_ATH79_H
+#define __LINUX_PLATFORM_DATA_GPIO_ATH79_H
+
+struct ath79_gpio_platform_data {
+        unsigned ngpios;
+        bool oe_inverted;
+};
+
+#endif
diff --git a/include/linux/platform_data/keyboard-spear.h b/include/linux/platform_data/keyboard-spear.h
index 9248e3a7e333..5e3ff653900c 100644
--- a/include/linux/platform_data/keyboard-spear.h
+++ b/include/linux/platform_data/keyboard-spear.h
@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2010 ST Microelectronics
- * Rajeev Kumar<rajeev-dlh.kumar@st.com>
+ * Rajeev Kumar <rajeevkumar.linux@gmail.com>
  *
  * This file is licensed under the terms of the GNU General Public
  * License version 2. This program is licensed "as is" without any
diff --git a/include/linux/platform_data/macb.h b/include/linux/platform_data/macb.h
index 044a124bfbbc..21b15f6fee25 100644
--- a/include/linux/platform_data/macb.h
+++ b/include/linux/platform_data/macb.h
@@ -8,11 +8,19 @@
 #ifndef __MACB_PDATA_H__
 #define __MACB_PDATA_H__
 
+/**
+ * struct macb_platform_data - platform data for MACB Ethernet
+ * @phy_mask:           phy mask passed when register the MDIO bus
+ *                      within the driver
+ * @phy_irq_pin:        PHY IRQ
+ * @is_rmii:            using RMII interface?
+ * @rev_eth_addr:       reverse Ethernet address byte order
+ */
 struct macb_platform_data {
         u32             phy_mask;
-        int             phy_irq_pin;    /* PHY IRQ */
-        u8              is_rmii;        /* using RMII interface? */
-        u8              rev_eth_addr;   /* reverse Ethernet address byte order */
+        int             phy_irq_pin;
+        u8              is_rmii;
+        u8              rev_eth_addr;
 };
 
 #endif /* __MACB_PDATA_H__ */
diff --git a/include/linux/platform_data/mmc-esdhc-imx.h b/include/linux/platform_data/mmc-esdhc-imx.h
index 75f70f6ac137..e1571efa3f2b 100644
--- a/include/linux/platform_data/mmc-esdhc-imx.h
+++ b/include/linux/platform_data/mmc-esdhc-imx.h
@@ -43,7 +43,6 @@ struct esdhc_platform_data {
         enum wp_types wp_type;
         enum cd_types cd_type;
         int max_bus_width;
-        unsigned int f_max;
         bool support_vsel;
         unsigned int delay_line;
 };
diff --git a/include/linux/platform_data/nfcmrvl.h b/include/linux/platform_data/nfcmrvl.h
new file mode 100644
index 000000000000..ac91707dabcb
--- /dev/null
+++ b/include/linux/platform_data/nfcmrvl.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2015, Marvell International Ltd.
+ *
+ * This software file (the "File") is distributed by Marvell International
+ * Ltd. under the terms of the GNU General Public License Version 2, June 1991
+ * (the "License").  You may use, redistribute and/or modify this File in
+ * accordance with the terms and conditions of the License, a copy of which
+ * is available on the worldwide web at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
+ *
+ * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
+ * ARE EXPRESSLY DISCLAIMED.  The License provides additional details about
+ * this warranty disclaimer.
+ */
+
+#ifndef _NFCMRVL_PTF_H_
+#define _NFCMRVL_PTF_H_
+
+struct nfcmrvl_platform_data {
+        /*
+         * Generic
+         */
+
+        /* GPIO that is wired to RESET_N signal */
+        unsigned int reset_n_io;
+        /* Tell if transport is muxed in HCI one */
+        unsigned int hci_muxed;
+
+        /*
+         * UART specific
+         */
+
+        /* Tell if UART needs flow control at init */
+        unsigned int flow_control;
+        /* Tell if firmware supports break control for power management */
+        unsigned int break_control;
+};
+
+#endif /* _NFCMRVL_PTF_H_ */
diff --git a/include/linux/platform_data/st21nfcb.h b/include/linux/platform_data/st-nci.h
index b023373d9874..d9d400a297bd 100644
--- a/include/linux/platform_data/st21nfcb.h
+++ b/include/linux/platform_data/st-nci.h
@@ -1,7 +1,7 @@
 /*
- * Driver include for the ST21NFCB NFC chip.
+ * Driver include for ST NCI NFC chip family.
  *
- * Copyright (C) 2014  STMicroelectronics SAS. All rights reserved.
+ * Copyright (C) 2014-2015  STMicroelectronics SAS. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
@@ -16,14 +16,14 @@
  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef _ST21NFCB_NCI_H_
-#define _ST21NFCB_NCI_H_
+#ifndef _ST_NCI_H_
+#define _ST_NCI_H_
 
-#define ST21NFCB_NCI_DRIVER_NAME "st21nfcb_nci"
+#define ST_NCI_DRIVER_NAME "st_nci"
 
-struct st21nfcb_nfc_platform_data {
+struct st_nci_nfc_platform_data {
         unsigned int gpio_reset;
         unsigned int irq_polarity;
 };
 
-#endif /* _ST21NFCB_NCI_H_ */
+#endif /* _ST_NCI_H_ */
diff --git a/include/linux/platform_data/st_nci.h b/include/linux/platform_data/st_nci.h
new file mode 100644
index 000000000000..d9d400a297bd
--- /dev/null
+++ b/include/linux/platform_data/st_nci.h
@@ -0,0 +1,29 @@
+/*
+ * Driver include for ST NCI NFC chip family.
+ *
+ * Copyright (C) 2014-2015  STMicroelectronics SAS. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _ST_NCI_H_
+#define _ST_NCI_H_
+
+#define ST_NCI_DRIVER_NAME "st_nci"
+
+struct st_nci_nfc_platform_data {
+        unsigned int gpio_reset;
+        unsigned int irq_polarity;
+};
+
+#endif /* _ST_NCI_H_ */
diff --git a/include/linux/platform_data/usb-rcar-gen2-phy.h b/include/linux/platform_data/usb-rcar-gen2-phy.h
deleted file mode 100644
index dd3ba46c0d90..000000000000
--- a/include/linux/platform_data/usb-rcar-gen2-phy.h
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * Copyright (C) 2013 Renesas Solutions Corp.
- * Copyright (C) 2013 Cogent Embedded, Inc.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#ifndef __USB_RCAR_GEN2_PHY_H
-#define __USB_RCAR_GEN2_PHY_H
-
-#include <linux/types.h>
-
-struct rcar_gen2_phy_platform_data {
-        /* USB channel 0 configuration */
-        bool chan0_pci:1;       /* true: PCI USB host 0, false: USBHS */
-        /* USB channel 2 configuration */
-        bool chan2_pci:1;       /* true: PCI USB host 2, false: USBSS */
-};
-
-#endif
diff --git a/include/linux/platform_data/video-msm_fb.h b/include/linux/platform_data/video-msm_fb.h
deleted file mode 100644
index 31449be3eadb..000000000000
--- a/include/linux/platform_data/video-msm_fb.h
+++ /dev/null
@@ -1,146 +0,0 @@
-/*
- * Internal shared definitions for various MSM framebuffer parts.
- *
- * Copyright (C) 2007 Google Incorporated
- *
- * This software is licensed under the terms of the GNU General Public
- * License version 2, as published by the Free Software Foundation, and
- * may be copied, distributed, and modified under those terms.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- */
-
-#ifndef _MSM_FB_H_
-#define _MSM_FB_H_
-
-#include <linux/device.h>
-
-struct mddi_info;
-
-struct msm_fb_data {
-        int xres;       /* x resolution in pixels */
-        int yres;       /* y resolution in pixels */
-        int width;      /* disply width in mm */
-        int height;     /* display height in mm */
-        unsigned output_format;
-};
-
-struct msmfb_callback {
-        void (*func)(struct msmfb_callback *);
-};
-
-enum {
-        MSM_MDDI_PMDH_INTERFACE,
-        MSM_MDDI_EMDH_INTERFACE,
-        MSM_EBI2_INTERFACE,
-};
-
-#define MSMFB_CAP_PARTIAL_UPDATES       (1 << 0)
-
-struct msm_panel_data {
-        /* turns off the fb memory */
-        int (*suspend)(struct msm_panel_data *);
-        /* turns on the fb memory */
-        int (*resume)(struct msm_panel_data *);
-        /* turns off the panel */
-        int (*blank)(struct msm_panel_data *);
-        /* turns on the panel */
-        int (*unblank)(struct msm_panel_data *);
-        void (*wait_vsync)(struct msm_panel_data *);
-        void (*request_vsync)(struct msm_panel_data *, struct msmfb_callback *);
-        void (*clear_vsync)(struct msm_panel_data *);
-        /* from the enum above */
-        unsigned interface_type;
-        /* data to be passed to the fb driver */
-        struct msm_fb_data *fb_data;
-
-        /* capabilities supported by the panel */
-        uint32_t caps;
-};
-
-struct msm_mddi_client_data {
-        void (*suspend)(struct msm_mddi_client_data *);
-        void (*resume)(struct msm_mddi_client_data *);
-        void (*activate_link)(struct msm_mddi_client_data *);
-        void (*remote_write)(struct msm_mddi_client_data *, uint32_t val,
-                             uint32_t reg);
-        uint32_t (*remote_read)(struct msm_mddi_client_data *, uint32_t reg);
-        void (*auto_hibernate)(struct msm_mddi_client_data *, int);
-        /* custom data that needs to be passed from the board file to a 
-         * particular client */
-        void *private_client_data;
-        struct resource *fb_resource;
-        /* from the list above */
-        unsigned interface_type;
-};
-
-struct msm_mddi_platform_data {
-        unsigned int clk_rate;
-        void (*power_client)(struct msm_mddi_client_data *, int on);
-
-        /* fixup the mfr name, product id */
-        void (*fixup)(uint16_t *mfr_name, uint16_t *product_id);
-
-        struct resource *fb_resource; /*optional*/
-        /* number of clients in the list that follows */
-        int num_clients;
-        /* array of client information of clients */
-        struct {
-                unsigned product_id; /* mfr id in top 16 bits, product id
-                                      * in lower 16 bits
-                                      */
-                char *name;     /* the device name will be the platform
-                                 * device name registered for the client,
-                                 * it should match the name of the associated
-                                 * driver
-                                 */
-                unsigned id;    /* id for mddi client device node, will also
-                                 * be used as device id of panel devices, if
-                                 * the client device will have multiple panels
-                                 * space must be left here for them
-                                 */
-                void *client_data;      /* required private client data */
-                unsigned int clk_rate;  /* optional: if the client requires a
-                                        * different mddi clk rate
-                                        */
-        } client_platform_data[];
-};
-
-struct mdp_blit_req;
-struct fb_info;
-struct mdp_device {
-        struct device dev;
-        void (*dma)(struct mdp_device *mpd, uint32_t addr,
-                    uint32_t stride, uint32_t w, uint32_t h, uint32_t x,
-                    uint32_t y, struct msmfb_callback *callback, int interface);
-        void (*dma_wait)(struct mdp_device *mdp);
-        int (*blit)(struct mdp_device *mdp, struct fb_info *fb,
-                    struct mdp_blit_req *req);
-        void (*set_grp_disp)(struct mdp_device *mdp, uint32_t disp_id);
-};
-
-struct class_interface;
-int register_mdp_client(struct class_interface *class_intf);
-
-/**** private client data structs go below this line ***/
-
-struct msm_mddi_bridge_platform_data {
-        /* from board file */
-        int (*init)(struct msm_mddi_bridge_platform_data *,
-                    struct msm_mddi_client_data *);
-        int (*uninit)(struct msm_mddi_bridge_platform_data *,
-                      struct msm_mddi_client_data *);
-        /* passed to panel for use by the fb driver */
-        int (*blank)(struct msm_mddi_bridge_platform_data *,
-                     struct msm_mddi_client_data *);
-        int (*unblank)(struct msm_mddi_bridge_platform_data *,
-                       struct msm_mddi_client_data *);
-        struct msm_fb_data fb_data;
-};
-
-
-
-#endif
diff --git a/include/linux/platform_data/wkup_m3.h b/include/linux/platform_data/wkup_m3.h
new file mode 100644
index 000000000000..3f1d77effd71
--- /dev/null
+++ b/include/linux/platform_data/wkup_m3.h
@@ -0,0 +1,30 @@
+/*
+ * TI Wakeup M3 remote processor platform data
+ *
+ * Copyright (C) 2014-2015 Texas Instruments, Inc.
+ *
+ * Dave Gerlach <d-gerlach@ti.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef _LINUX_PLATFORM_DATA_WKUP_M3_H
+#define _LINUX_PLATFORM_DATA_WKUP_M3_H
+
+struct platform_device;
+
+struct wkup_m3_platform_data {
+        const char *reset_name;
+
+        int (*assert_reset)(struct platform_device *pdev, const char *name);
+        int (*deassert_reset)(struct platform_device *pdev, const char *name);
+};
+
+#endif /* _LINUX_PLATFORM_DATA_WKUP_M3_H */
diff --git a/include/linux/platform_device.h b/include/linux/platform_device.h
index 58f1e75ba105..bba08f44cc97 100644
--- a/include/linux/platform_device.h
+++ b/include/linux/platform_device.h
@@ -222,6 +222,15 @@ static inline void platform_set_drvdata(struct platform_device *pdev,
         module_driver(__platform_driver, platform_driver_register, \
                         platform_driver_unregister)
 
+/* builtin_platform_driver() - Helper macro for builtin drivers that
+ * don't do anything special in driver init.  This eliminates some
+ * boilerplate.  Each driver may only use this macro once, and
+ * calling it replaces device_initcall().  Note this is meant to be
+ * a parallel of module_platform_driver() above, but w/o _exit stuff.
+ */
+#define builtin_platform_driver(__platform_driver) \
+        builtin_driver(__platform_driver, platform_driver_register)
+
 /* module_platform_driver_probe() - Helper macro for drivers that don't do
  * anything special in module init/exit.  This eliminates a lot of
  * boilerplate.  Each module may only use this macro once, and
@@ -240,6 +249,20 @@ static void __exit __platform_driver##_exit(void) \
 } \
 module_exit(__platform_driver##_exit);
 
+/* builtin_platform_driver_probe() - Helper macro for drivers that don't do
+ * anything special in device init.  This eliminates some boilerplate.  Each
+ * driver may only use this macro once, and using it replaces device_initcall.
+ * This is meant to be a parallel of module_platform_driver_probe above, but
+ * without the __exit parts.
+ */
+#define builtin_platform_driver_probe(__platform_driver, __platform_probe) \
+static int __init __platform_driver##_init(void) \
+{ \
+        return platform_driver_probe(&(__platform_driver), \
+                                     __platform_probe);    \
+} \
+device_initcall(__platform_driver##_init); \
+
 #define platform_create_bundle(driver, probe, res, n_res, data, size) \
         __platform_create_bundle(driver, probe, res, n_res, data, size, THIS_MODULE)
 extern struct platform_device *__platform_create_bundle(
diff --git a/include/linux/pm.h b/include/linux/pm.h
index 2d29c64f8fb1..35d599e7250d 100644
--- a/include/linux/pm.h
+++ b/include/linux/pm.h
@@ -342,6 +342,18 @@ struct dev_pm_ops {
 #define SET_LATE_SYSTEM_SLEEP_PM_OPS(suspend_fn, resume_fn)
 #endif
 
+#ifdef CONFIG_PM_SLEEP
+#define SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(suspend_fn, resume_fn) \
+        .suspend_noirq = suspend_fn, \
+        .resume_noirq = resume_fn, \
+        .freeze_noirq = suspend_fn, \
+        .thaw_noirq = resume_fn, \
+        .poweroff_noirq = suspend_fn, \
+        .restore_noirq = resume_fn,
+#else
+#define SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(suspend_fn, resume_fn)
+#endif
+
 #ifdef CONFIG_PM
 #define SET_RUNTIME_PM_OPS(suspend_fn, resume_fn, idle_fn) \
         .runtime_suspend = suspend_fn, \
@@ -529,6 +541,7 @@ enum rpm_request {
 };
 
 struct wakeup_source;
+struct wake_irq;
 struct pm_domain_data;
 
 struct pm_subsys_data {
@@ -568,6 +581,7 @@ struct dev_pm_info {
         unsigned long           timer_expires;
         struct work_struct      work;
         wait_queue_head_t       wait_queue;
+        struct wake_irq         *wakeirq;
         atomic_t                usage_count;
         atomic_t                child_count;
         unsigned int            disable_depth:3;
diff --git a/include/linux/pm_clock.h b/include/linux/pm_clock.h
index 0b0039634410..25266c600021 100644
--- a/include/linux/pm_clock.h
+++ b/include/linux/pm_clock.h
@@ -20,6 +20,16 @@ struct pm_clk_notifier_block {
 
 struct clk;
 
+#ifdef CONFIG_PM
+extern int pm_clk_runtime_suspend(struct device *dev);
+extern int pm_clk_runtime_resume(struct device *dev);
+#define USE_PM_CLK_RUNTIME_OPS \
+        .runtime_suspend = pm_clk_runtime_suspend, \
+        .runtime_resume = pm_clk_runtime_resume,
+#else
+#define USE_PM_CLK_RUNTIME_OPS
+#endif
+
 #ifdef CONFIG_PM_CLK
 static inline bool pm_clk_no_clocks(struct device *dev)
 {
diff --git a/include/linux/pm_wakeirq.h b/include/linux/pm_wakeirq.h
new file mode 100644
index 000000000000..cd5b62db9084
--- /dev/null
+++ b/include/linux/pm_wakeirq.h
@@ -0,0 +1,51 @@
+/*
+ * pm_wakeirq.h - Device wakeirq helper functions
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef _LINUX_PM_WAKEIRQ_H
+#define _LINUX_PM_WAKEIRQ_H
+
+#ifdef CONFIG_PM
+
+extern int dev_pm_set_wake_irq(struct device *dev, int irq);
+extern int dev_pm_set_dedicated_wake_irq(struct device *dev,
+                                         int irq);
+extern void dev_pm_clear_wake_irq(struct device *dev);
+extern void dev_pm_enable_wake_irq(struct device *dev);
+extern void dev_pm_disable_wake_irq(struct device *dev);
+
+#else   /* !CONFIG_PM */
+
+static inline int dev_pm_set_wake_irq(struct device *dev, int irq)
+{
+        return 0;
+}
+
+static inline int dev_pm_set_dedicated_wake_irq(struct device *dev, int irq)
+{
+        return 0;
+}
+
+static inline void dev_pm_clear_wake_irq(struct device *dev)
+{
+}
+
+static inline void dev_pm_enable_wake_irq(struct device *dev)
+{
+}
+
+static inline void dev_pm_disable_wake_irq(struct device *dev)
+{
+}
+
+#endif  /* CONFIG_PM */
+#endif  /* _LINUX_PM_WAKEIRQ_H */
diff --git a/include/linux/pm_wakeup.h b/include/linux/pm_wakeup.h
index a0f70808d7f4..a3447932df1f 100644
--- a/include/linux/pm_wakeup.h
+++ b/include/linux/pm_wakeup.h
@@ -28,9 +28,17 @@
 
 #include <linux/types.h>
 
+struct wake_irq;
+
 /**
  * struct wakeup_source - Representation of wakeup sources
  *
+ * @name: Name of the wakeup source
+ * @entry: Wakeup source list entry
+ * @lock: Wakeup source lock
+ * @wakeirq: Optional device specific wakeirq
+ * @timer: Wakeup timer list
+ * @timer_expires: Wakeup timer expiration
  * @total_time: Total time this wakeup source has been active.
  * @max_time: Maximum time this wakeup source has been continuously active.
  * @last_time: Monotonic clock when the wakeup source's was touched last time.
@@ -47,6 +55,7 @@ struct wakeup_source {
         const char              *name;
         struct list_head        entry;
         spinlock_t              lock;
+        struct wake_irq         *wakeirq;
         struct timer_list       timer;
         unsigned long           timer_expires;
         ktime_t total_time;
diff --git a/include/linux/pmem.h b/include/linux/pmem.h
new file mode 100644
index 000000000000..d2114045a6c4
--- /dev/null
+++ b/include/linux/pmem.h
@@ -0,0 +1,152 @@
+/*
+ * Copyright(c) 2015 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ */
+#ifndef __PMEM_H__
+#define __PMEM_H__
+
+#include <linux/io.h>
+
+#ifdef CONFIG_ARCH_HAS_PMEM_API
+#include <asm/cacheflush.h>
+#else
+static inline void arch_wmb_pmem(void)
+{
+        BUG();
+}
+
+static inline bool __arch_has_wmb_pmem(void)
+{
+        return false;
+}
+
+static inline void __pmem *arch_memremap_pmem(resource_size_t offset,
+                unsigned long size)
+{
+        return NULL;
+}
+
+static inline void arch_memcpy_to_pmem(void __pmem *dst, const void *src,
+                size_t n)
+{
+        BUG();
+}
+#endif
+
+/*
+ * Architectures that define ARCH_HAS_PMEM_API must provide
+ * implementations for arch_memremap_pmem(), arch_memcpy_to_pmem(),
+ * arch_wmb_pmem(), and __arch_has_wmb_pmem().
+ */
+
+static inline void memcpy_from_pmem(void *dst, void __pmem const *src, size_t size)
+{
+        memcpy(dst, (void __force const *) src, size);
+}
+
+static inline void memunmap_pmem(void __pmem *addr)
+{
+        iounmap((void __force __iomem *) addr);
+}
+
+/**
+ * arch_has_wmb_pmem - true if wmb_pmem() ensures durability
+ *
+ * For a given cpu implementation within an architecture it is possible
+ * that wmb_pmem() resolves to a nop.  In the case this returns
+ * false, pmem api users are unable to ensure durability and may want to
+ * fall back to a different data consistency model, or otherwise notify
+ * the user.
+ */
+static inline bool arch_has_wmb_pmem(void)
+{
+        if (IS_ENABLED(CONFIG_ARCH_HAS_PMEM_API))
+                return __arch_has_wmb_pmem();
+        return false;
+}
+
+static inline bool arch_has_pmem_api(void)
+{
+        return IS_ENABLED(CONFIG_ARCH_HAS_PMEM_API) && arch_has_wmb_pmem();
+}
+
+/*
+ * These defaults seek to offer decent performance and minimize the
+ * window between i/o completion and writes being durable on media.
+ * However, it is undefined / architecture specific whether
+ * default_memremap_pmem + default_memcpy_to_pmem is sufficient for
+ * making data durable relative to i/o completion.
+ */
+static void default_memcpy_to_pmem(void __pmem *dst, const void *src,
+                size_t size)
+{
+        memcpy((void __force *) dst, src, size);
+}
+
+static void __pmem *default_memremap_pmem(resource_size_t offset,
+                unsigned long size)
+{
+        return (void __pmem __force *)ioremap_wt(offset, size);
+}
+
+/**
+ * memremap_pmem - map physical persistent memory for pmem api
+ * @offset: physical address of persistent memory
+ * @size: size of the mapping
+ *
+ * Establish a mapping of the architecture specific memory type expected
+ * by memcpy_to_pmem() and wmb_pmem().  For example, it may be
+ * the case that an uncacheable or writethrough mapping is sufficient,
+ * or a writeback mapping provided memcpy_to_pmem() and
+ * wmb_pmem() arrange for the data to be written through the
+ * cache to persistent media.
+ */
+static inline void __pmem *memremap_pmem(resource_size_t offset,
+                unsigned long size)
+{
+        if (arch_has_pmem_api())
+                return arch_memremap_pmem(offset, size);
+        return default_memremap_pmem(offset, size);
+}
+
+/**
+ * memcpy_to_pmem - copy data to persistent memory
+ * @dst: destination buffer for the copy
+ * @src: source buffer for the copy
+ * @n: length of the copy in bytes
+ *
+ * Perform a memory copy that results in the destination of the copy
+ * being effectively evicted from, or never written to, the processor
+ * cache hierarchy after the copy completes.  After memcpy_to_pmem()
+ * data may still reside in cpu or platform buffers, so this operation
+ * must be followed by a wmb_pmem().
+ */
+static inline void memcpy_to_pmem(void __pmem *dst, const void *src, size_t n)
+{
+        if (arch_has_pmem_api())
+                arch_memcpy_to_pmem(dst, src, n);
+        else
+                default_memcpy_to_pmem(dst, src, n);
+}
+
+/**
+ * wmb_pmem - synchronize writes to persistent memory
+ *
+ * After a series of memcpy_to_pmem() operations this drains data from
+ * cpu write buffers and any platform (memory controller) buffers to
+ * ensure that written data is durable on persistent memory media.
+ */
+static inline void wmb_pmem(void)
+{
+        if (arch_has_pmem_api())
+                arch_wmb_pmem();
+}
+#endif /* __PMEM_H__ */
diff --git a/include/linux/power/max17042_battery.h b/include/linux/power/max17042_battery.h
index cf112b4075c8..522757ac9cd4 100644
--- a/include/linux/power/max17042_battery.h
+++ b/include/linux/power/max17042_battery.h
@@ -215,6 +215,10 @@ struct max17042_platform_data {
          * the datasheet although it can be changed by board designers.
          */
         unsigned int r_sns;
+        int         vmin;       /* in millivolts */
+        int         vmax;       /* in millivolts */
+        int         temp_min;   /* in tenths of degree Celsius */
+        int         temp_max;   /* in tenths of degree Celsius */
 };
 
 #endif /* __MAX17042_BATTERY_H_ */
diff --git a/include/linux/power_supply.h b/include/linux/power_supply.h
index 75a1dd8dc56e..ef9f1592185d 100644
--- a/include/linux/power_supply.h
+++ b/include/linux/power_supply.h
@@ -206,6 +206,11 @@ struct power_supply_desc {
         int (*set_property)(struct power_supply *psy,
                             enum power_supply_property psp,
                             const union power_supply_propval *val);
+        /*
+         * property_is_writeable() will be called during registration
+         * of power supply. If this happens during device probe then it must
+         * not access internal data of device (because probe did not end).
+         */
         int (*property_is_writeable)(struct power_supply *psy,
                                      enum power_supply_property psp);
         void (*external_power_changed)(struct power_supply *psy);
@@ -237,6 +242,7 @@ struct power_supply {
         /* private */
         struct device dev;
         struct work_struct changed_work;
+        struct delayed_work deferred_register_work;
         spinlock_t changed_lock;
         bool changed;
         atomic_t use_cnt;
@@ -286,10 +292,15 @@ extern void power_supply_put(struct power_supply *psy);
 #ifdef CONFIG_OF
 extern struct power_supply *power_supply_get_by_phandle(struct device_node *np,
                                                         const char *property);
+extern struct power_supply *devm_power_supply_get_by_phandle(
+                                    struct device *dev, const char *property);
 #else /* !CONFIG_OF */
 static inline struct power_supply *
 power_supply_get_by_phandle(struct device_node *np, const char *property)
 { return NULL; }
+static inline struct power_supply *
+devm_power_supply_get_by_phandle(struct device *dev, const char *property)
+{ return NULL; }
 #endif /* CONFIG_OF */
 extern void power_supply_changed(struct power_supply *psy);
 extern int power_supply_am_i_supplied(struct power_supply *psy);
diff --git a/include/linux/preempt.h b/include/linux/preempt.h
index 0f1534acaf60..84991f185173 100644
--- a/include/linux/preempt.h
+++ b/include/linux/preempt.h
@@ -293,6 +293,8 @@ struct preempt_notifier {
         struct preempt_ops *ops;
 };
 
+void preempt_notifier_inc(void);
+void preempt_notifier_dec(void);
 void preempt_notifier_register(struct preempt_notifier *notifier);
 void preempt_notifier_unregister(struct preempt_notifier *notifier);
 
diff --git a/include/linux/printk.h b/include/linux/printk.h
index 9b30871c9149..a6298b27ac99 100644
--- a/include/linux/printk.h
+++ b/include/linux/printk.h
@@ -30,6 +30,8 @@ static inline const char *printk_skip_level(const char *buffer)
         return buffer;
 }
 
+#define CONSOLE_EXT_LOG_MAX     8192
+
 /* printk's without a loglevel use this.. */
 #define MESSAGE_LOGLEVEL_DEFAULT CONFIG_MESSAGE_LOGLEVEL_DEFAULT
 
@@ -120,7 +122,7 @@ static inline __printf(1, 2) __cold
 void early_printk(const char *s, ...) { }
 #endif
 
-typedef int(*printk_func_t)(const char *fmt, va_list args);
+typedef __printf(1, 0) int (*printk_func_t)(const char *fmt, va_list args);
 
 #ifdef CONFIG_PRINTK
 asmlinkage __printf(5, 0)
@@ -164,7 +166,7 @@ char *log_buf_addr_get(void);
 u32 log_buf_len_get(void);
 void log_buf_kexec_setup(void);
 void __init setup_log_buf(int early);
-void dump_stack_set_arch_desc(const char *fmt, ...);
+__printf(1, 2) void dump_stack_set_arch_desc(const char *fmt, ...);
 void dump_stack_print_info(const char *log_lvl);
 void show_regs_print_info(const char *log_lvl);
 #else
@@ -215,7 +217,7 @@ static inline void setup_log_buf(int early)
 {
 }
 
-static inline void dump_stack_set_arch_desc(const char *fmt, ...)
+static inline __printf(1, 2) void dump_stack_set_arch_desc(const char *fmt, ...)
 {
 }
 
diff --git a/include/linux/property.h b/include/linux/property.h
index de8bdf417a35..76ebde9c11d4 100644
--- a/include/linux/property.h
+++ b/include/linux/property.h
@@ -164,4 +164,6 @@ struct property_set {
 
 void device_add_property_set(struct device *dev, struct property_set *pset);
 
+bool device_dma_is_coherent(struct device *dev);
+
 #endif /* _LINUX_PROPERTY_H_ */
diff --git a/include/linux/pxa2xx_ssp.h b/include/linux/pxa2xx_ssp.h
index dab545bb66b3..0485bab061fd 100644
--- a/include/linux/pxa2xx_ssp.h
+++ b/include/linux/pxa2xx_ssp.h
@@ -194,8 +194,9 @@ enum pxa_ssp_type {
         PXA168_SSP,
         PXA910_SSP,
         CE4100_SSP,
-        LPSS_SSP,
         QUARK_X1000_SSP,
+        LPSS_LPT_SSP, /* Keep LPSS types sorted with lpss_platforms[] */
+        LPSS_BYT_SSP,
 };
 
 struct ssp_device {
diff --git a/include/linux/qcom_scm.h b/include/linux/qcom_scm.h
index d7a974d5f57c..6e7d5ec65838 100644
--- a/include/linux/qcom_scm.h
+++ b/include/linux/qcom_scm.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2010-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2010-2015, The Linux Foundation. All rights reserved.
  * Copyright (C) 2015 Linaro Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
@@ -16,6 +16,17 @@
 extern int qcom_scm_set_cold_boot_addr(void *entry, const cpumask_t *cpus);
 extern int qcom_scm_set_warm_boot_addr(void *entry, const cpumask_t *cpus);
 
+#define QCOM_SCM_HDCP_MAX_REQ_CNT       5
+
+struct qcom_scm_hdcp_req {
+        u32 addr;
+        u32 val;
+};
+
+extern bool qcom_scm_hdcp_available(void);
+extern int qcom_scm_hdcp_req(struct qcom_scm_hdcp_req *req, u32 req_cnt,
+                u32 *resp);
+
 #define QCOM_SCM_CPU_PWR_DOWN_L2_ON     0x0
 #define QCOM_SCM_CPU_PWR_DOWN_L2_OFF    0x1
 
diff --git a/include/linux/rbtree.h b/include/linux/rbtree.h
index fb31765e935a..830c4992088d 100644
--- a/include/linux/rbtree.h
+++ b/include/linux/rbtree.h
@@ -31,6 +31,7 @@
 
 #include <linux/kernel.h>
 #include <linux/stddef.h>
+#include <linux/rcupdate.h>
 
 struct rb_node {
         unsigned long  __rb_parent_color;
@@ -73,11 +74,11 @@ extern struct rb_node *rb_first_postorder(const struct rb_root *);
 extern struct rb_node *rb_next_postorder(const struct rb_node *);
 
 /* Fast replacement of a single node without remove/rebalance/add/rebalance */
-extern void rb_replace_node(struct rb_node *victim, struct rb_node *new, 
+extern void rb_replace_node(struct rb_node *victim, struct rb_node *new,
                             struct rb_root *root);
 
-static inline void rb_link_node(struct rb_node * node, struct rb_node * parent,
-                                struct rb_node ** rb_link)
+static inline void rb_link_node(struct rb_node *node, struct rb_node *parent,
+                                struct rb_node **rb_link)
 {
         node->__rb_parent_color = (unsigned long)parent;
         node->rb_left = node->rb_right = NULL;
@@ -85,6 +86,15 @@ static inline void rb_link_node(struct rb_node * node, struct rb_node * parent,
         *rb_link = node;
 }
 
+static inline void rb_link_node_rcu(struct rb_node *node, struct rb_node *parent,
+                                    struct rb_node **rb_link)
+{
+        node->__rb_parent_color = (unsigned long)parent;
+        node->rb_left = node->rb_right = NULL;
+
+        rcu_assign_pointer(*rb_link, node);
+}
+
 #define rb_entry_safe(ptr, type, member) \
         ({ typeof(ptr) ____ptr = (ptr); \
            ____ptr ? rb_entry(____ptr, type, member) : NULL; \
diff --git a/include/linux/rbtree_augmented.h b/include/linux/rbtree_augmented.h
index 378c5ee75f78..14d7b831b63a 100644
--- a/include/linux/rbtree_augmented.h
+++ b/include/linux/rbtree_augmented.h
@@ -123,11 +123,11 @@ __rb_change_child(struct rb_node *old, struct rb_node *new,
 {
         if (parent) {
                 if (parent->rb_left == old)
-                        parent->rb_left = new;
+                        WRITE_ONCE(parent->rb_left, new);
                 else
-                        parent->rb_right = new;
+                        WRITE_ONCE(parent->rb_right, new);
         } else
-                root->rb_node = new;
+                WRITE_ONCE(root->rb_node, new);
 }
 
 extern void __rb_erase_color(struct rb_node *parent, struct rb_root *root,
@@ -137,7 +137,8 @@ static __always_inline struct rb_node *
 __rb_erase_augmented(struct rb_node *node, struct rb_root *root,
                      const struct rb_augment_callbacks *augment)
 {
-        struct rb_node *child = node->rb_right, *tmp = node->rb_left;
+        struct rb_node *child = node->rb_right;
+        struct rb_node *tmp = node->rb_left;
         struct rb_node *parent, *rebalance;
         unsigned long pc;
 
@@ -167,6 +168,7 @@ __rb_erase_augmented(struct rb_node *node, struct rb_root *root,
                 tmp = parent;
         } else {
                 struct rb_node *successor = child, *child2;
+
                 tmp = child->rb_left;
                 if (!tmp) {
                         /*
@@ -180,6 +182,7 @@ __rb_erase_augmented(struct rb_node *node, struct rb_root *root,
                          */
                         parent = successor;
                         child2 = successor->rb_right;
+
                         augment->copy(node, successor);
                 } else {
                         /*
@@ -201,19 +204,23 @@ __rb_erase_augmented(struct rb_node *node, struct rb_root *root,
                                 successor = tmp;
                                 tmp = tmp->rb_left;
                         } while (tmp);
-                        parent->rb_left = child2 = successor->rb_right;
-                        successor->rb_right = child;
+                        child2 = successor->rb_right;
+                        WRITE_ONCE(parent->rb_left, child2);
+                        WRITE_ONCE(successor->rb_right, child);
                         rb_set_parent(child, successor);
+
                         augment->copy(node, successor);
                         augment->propagate(parent, successor);
                 }
 
-                successor->rb_left = tmp = node->rb_left;
+                tmp = node->rb_left;
+                WRITE_ONCE(successor->rb_left, tmp);
                 rb_set_parent(tmp, successor);
 
                 pc = node->__rb_parent_color;
                 tmp = __rb_parent(pc);
                 __rb_change_child(node, successor, tmp, root);
+
                 if (child2) {
                         successor->__rb_parent_color = pc;
                         rb_set_parent_color(child2, parent, RB_BLACK);
diff --git a/include/linux/rbtree_latch.h b/include/linux/rbtree_latch.h
new file mode 100644
index 000000000000..4f3432c61d12
--- /dev/null
+++ b/include/linux/rbtree_latch.h
@@ -0,0 +1,212 @@
+/*
+ * Latched RB-trees
+ *
+ * Copyright (C) 2015 Intel Corp., Peter Zijlstra <peterz@infradead.org>
+ *
+ * Since RB-trees have non-atomic modifications they're not immediately suited
+ * for RCU/lockless queries. Even though we made RB-tree lookups non-fatal for
+ * lockless lookups; we cannot guarantee they return a correct result.
+ *
+ * The simplest solution is a seqlock + RB-tree, this will allow lockless
+ * lookups; but has the constraint (inherent to the seqlock) that read sides
+ * cannot nest in write sides.
+ *
+ * If we need to allow unconditional lookups (say as required for NMI context
+ * usage) we need a more complex setup; this data structure provides this by
+ * employing the latch technique -- see @raw_write_seqcount_latch -- to
+ * implement a latched RB-tree which does allow for unconditional lookups by
+ * virtue of always having (at least) one stable copy of the tree.
+ *
+ * However, while we have the guarantee that there is at all times one stable
+ * copy, this does not guarantee an iteration will not observe modifications.
+ * What might have been a stable copy at the start of the iteration, need not
+ * remain so for the duration of the iteration.
+ *
+ * Therefore, this does require a lockless RB-tree iteration to be non-fatal;
+ * see the comment in lib/rbtree.c. Note however that we only require the first
+ * condition -- not seeing partial stores -- because the latch thing isolates
+ * us from loops. If we were to interrupt a modification the lookup would be
+ * pointed at the stable tree and complete while the modification was halted.
+ */
+
+#ifndef RB_TREE_LATCH_H
+#define RB_TREE_LATCH_H
+
+#include <linux/rbtree.h>
+#include <linux/seqlock.h>
+
+struct latch_tree_node {
+        struct rb_node node[2];
+};
+
+struct latch_tree_root {
+        seqcount_t      seq;
+        struct rb_root  tree[2];
+};
+
+/**
+ * latch_tree_ops - operators to define the tree order
+ * @less: used for insertion; provides the (partial) order between two elements.
+ * @comp: used for lookups; provides the order between the search key and an element.
+ *
+ * The operators are related like:
+ *
+ *      comp(a->key,b) < 0  := less(a,b)
+ *      comp(a->key,b) > 0  := less(b,a)
+ *      comp(a->key,b) == 0 := !less(a,b) && !less(b,a)
+ *
+ * If these operators define a partial order on the elements we make no
+ * guarantee on which of the elements matching the key is found. See
+ * latch_tree_find().
+ */
+struct latch_tree_ops {
+        bool (*less)(struct latch_tree_node *a, struct latch_tree_node *b);
+        int  (*comp)(void *key,                 struct latch_tree_node *b);
+};
+
+static __always_inline struct latch_tree_node *
+__lt_from_rb(struct rb_node *node, int idx)
+{
+        return container_of(node, struct latch_tree_node, node[idx]);
+}
+
+static __always_inline void
+__lt_insert(struct latch_tree_node *ltn, struct latch_tree_root *ltr, int idx,
+            bool (*less)(struct latch_tree_node *a, struct latch_tree_node *b))
+{
+        struct rb_root *root = &ltr->tree[idx];
+        struct rb_node **link = &root->rb_node;
+        struct rb_node *node = &ltn->node[idx];
+        struct rb_node *parent = NULL;
+        struct latch_tree_node *ltp;
+
+        while (*link) {
+                parent = *link;
+                ltp = __lt_from_rb(parent, idx);
+
+                if (less(ltn, ltp))
+                        link = &parent->rb_left;
+                else
+                        link = &parent->rb_right;
+        }
+
+        rb_link_node_rcu(node, parent, link);
+        rb_insert_color(node, root);
+}
+
+static __always_inline void
+__lt_erase(struct latch_tree_node *ltn, struct latch_tree_root *ltr, int idx)
+{
+        rb_erase(&ltn->node[idx], &ltr->tree[idx]);
+}
+
+static __always_inline struct latch_tree_node *
+__lt_find(void *key, struct latch_tree_root *ltr, int idx,
+          int (*comp)(void *key, struct latch_tree_node *node))
+{
+        struct rb_node *node = rcu_dereference_raw(ltr->tree[idx].rb_node);
+        struct latch_tree_node *ltn;
+        int c;
+
+        while (node) {
+                ltn = __lt_from_rb(node, idx);
+                c = comp(key, ltn);
+
+                if (c < 0)
+                        node = rcu_dereference_raw(node->rb_left);
+                else if (c > 0)
+                        node = rcu_dereference_raw(node->rb_right);
+                else
+                        return ltn;
+        }
+
+        return NULL;
+}
+
+/**
+ * latch_tree_insert() - insert @node into the trees @root
+ * @node: nodes to insert
+ * @root: trees to insert @node into
+ * @ops: operators defining the node order
+ *
+ * It inserts @node into @root in an ordered fashion such that we can always
+ * observe one complete tree. See the comment for raw_write_seqcount_latch().
+ *
+ * The inserts use rcu_assign_pointer() to publish the element such that the
+ * tree structure is stored before we can observe the new @node.
+ *
+ * All modifications (latch_tree_insert, latch_tree_remove) are assumed to be
+ * serialized.
+ */
+static __always_inline void
+latch_tree_insert(struct latch_tree_node *node,
+                  struct latch_tree_root *root,
+                  const struct latch_tree_ops *ops)
+{
+        raw_write_seqcount_latch(&root->seq);
+        __lt_insert(node, root, 0, ops->less);
+        raw_write_seqcount_latch(&root->seq);
+        __lt_insert(node, root, 1, ops->less);
+}
+
+/**
+ * latch_tree_erase() - removes @node from the trees @root
+ * @node: nodes to remote
+ * @root: trees to remove @node from
+ * @ops: operators defining the node order
+ *
+ * Removes @node from the trees @root in an ordered fashion such that we can
+ * always observe one complete tree. See the comment for
+ * raw_write_seqcount_latch().
+ *
+ * It is assumed that @node will observe one RCU quiescent state before being
+ * reused of freed.
+ *
+ * All modifications (latch_tree_insert, latch_tree_remove) are assumed to be
+ * serialized.
+ */
+static __always_inline void
+latch_tree_erase(struct latch_tree_node *node,
+                 struct latch_tree_root *root,
+                 const struct latch_tree_ops *ops)
+{
+        raw_write_seqcount_latch(&root->seq);
+        __lt_erase(node, root, 0);
+        raw_write_seqcount_latch(&root->seq);
+        __lt_erase(node, root, 1);
+}
+
+/**
+ * latch_tree_find() - find the node matching @key in the trees @root
+ * @key: search key
+ * @root: trees to search for @key
+ * @ops: operators defining the node order
+ *
+ * Does a lockless lookup in the trees @root for the node matching @key.
+ *
+ * It is assumed that this is called while holding the appropriate RCU read
+ * side lock.
+ *
+ * If the operators define a partial order on the elements (there are multiple
+ * elements which have the same key value) it is undefined which of these
+ * elements will be found. Nor is it possible to iterate the tree to find
+ * further elements with the same key value.
+ *
+ * Returns: a pointer to the node matching @key or NULL.
+ */
+static __always_inline struct latch_tree_node *
+latch_tree_find(void *key, struct latch_tree_root *root,
+                const struct latch_tree_ops *ops)
+{
+        struct latch_tree_node *node;
+        unsigned int seq;
+
+        do {
+                seq = raw_read_seqcount_latch(&root->seq);
+                node = __lt_find(key, root, seq & 1, ops->comp);
+        } while (read_seqcount_retry(&root->seq, seq));
+
+        return node;
+}
+
+#endif /* RB_TREE_LATCH_H */
diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h
index 33a056bb886f..4cf5f51b4c9c 100644
--- a/include/linux/rcupdate.h
+++ b/include/linux/rcupdate.h
@@ -633,21 +633,6 @@ static inline void rcu_preempt_sleep_check(void)
 #define RCU_INITIALIZER(v) (typeof(*(v)) __force __rcu *)(v)
 
 /**
- * lockless_dereference() - safely load a pointer for later dereference
- * @p: The pointer to load
- *
- * Similar to rcu_dereference(), but for situations where the pointed-to
- * object's lifetime is managed by something other than RCU.  That
- * "something other" might be reference counting or simple immortality.
- */
-#define lockless_dereference(p) \
-({ \
-        typeof(p) _________p1 = READ_ONCE(p); \
-        smp_read_barrier_depends(); /* Dependency order vs. p above. */ \
-        (_________p1); \
-})
-
-/**
  * rcu_assign_pointer() - assign to RCU-protected pointer
  * @p: pointer to assign to
  * @v: value to assign (publish)
diff --git a/include/linux/regmap.h b/include/linux/regmap.h
index 116655d92269..59c55ea0f0b5 100644
--- a/include/linux/regmap.h
+++ b/include/linux/regmap.h
@@ -433,6 +433,8 @@ int regmap_update_bits_check_async(struct regmap *map, unsigned int reg,
                                    unsigned int mask, unsigned int val,
                                    bool *change);
 int regmap_get_val_bytes(struct regmap *map);
+int regmap_get_max_register(struct regmap *map);
+int regmap_get_reg_stride(struct regmap *map);
 int regmap_async_complete(struct regmap *map);
 bool regmap_can_raw_write(struct regmap *map);
 
@@ -676,6 +678,18 @@ static inline int regmap_get_val_bytes(struct regmap *map)
         return -EINVAL;
 }
 
+static inline int regmap_get_max_register(struct regmap *map)
+{
+        WARN_ONCE(1, "regmap API is disabled");
+        return -EINVAL;
+}
+
+static inline int regmap_get_reg_stride(struct regmap *map)
+{
+        WARN_ONCE(1, "regmap API is disabled");
+        return -EINVAL;
+}
+
 static inline int regcache_sync(struct regmap *map)
 {
         WARN_ONCE(1, "regmap API is disabled");
diff --git a/include/linux/regulator/driver.h b/include/linux/regulator/driver.h
index fffa688ac3a7..4db9fbe4889d 100644
--- a/include/linux/regulator/driver.h
+++ b/include/linux/regulator/driver.h
@@ -91,6 +91,7 @@ struct regulator_linear_range {
  * @set_current_limit: Configure a limit for a current-limited regulator.
  *                     The driver should select the current closest to max_uA.
  * @get_current_limit: Get the configured limit for a current-limited regulator.
+ * @set_input_current_limit: Configure an input limit.
  *
  * @set_mode: Set the configured operating mode for the regulator.
  * @get_mode: Get the configured operating mode for the regulator.
@@ -111,6 +112,7 @@ struct regulator_linear_range {
  *               to stabilise after being set to a new value, in microseconds.
  *               The function provides the from and to voltage selector, the
  *               function should return the worst case.
+ * @set_soft_start: Enable soft start for the regulator.
  *
  * @set_suspend_voltage: Set the voltage for the regulator when the system
  *                       is suspended.
@@ -121,6 +123,9 @@ struct regulator_linear_range {
  * @set_suspend_mode: Set the operating mode for the regulator when the
  *                    system is suspended.
  *
+ * @set_pull_down: Configure the regulator to pull down when the regulator
+ *                 is disabled.
+ *
  * This struct describes regulator operations which can be implemented by
  * regulator chip drivers.
  */
@@ -142,6 +147,8 @@ struct regulator_ops {
                                  int min_uA, int max_uA);
         int (*get_current_limit) (struct regulator_dev *);
 
+        int (*set_input_current_limit) (struct regulator_dev *, int lim_uA);
+
         /* enable/disable regulator */
         int (*enable) (struct regulator_dev *);
         int (*disable) (struct regulator_dev *);
@@ -158,6 +165,8 @@ struct regulator_ops {
                                      unsigned int old_selector,
                                      unsigned int new_selector);
 
+        int (*set_soft_start) (struct regulator_dev *);
+
         /* report regulator status ... most other accessors report
          * control inputs, this reports results of combining inputs
          * from Linux (and other sources) with the actual load.
@@ -187,6 +196,8 @@ struct regulator_ops {
 
         /* set regulator suspend operating mode (defined in consumer.h) */
         int (*set_suspend_mode) (struct regulator_dev *, unsigned int mode);
+
+        int (*set_pull_down) (struct regulator_dev *);
 };
 
 /*
diff --git a/include/linux/regulator/machine.h b/include/linux/regulator/machine.h
index b07562e082c4..b11be1260129 100644
--- a/include/linux/regulator/machine.h
+++ b/include/linux/regulator/machine.h
@@ -75,6 +75,8 @@ struct regulator_state {
  *
  * @min_uA: Smallest current consumers may set.
  * @max_uA: Largest current consumers may set.
+ * @ilim_uA: Maximum input current.
+ * @system_load: Load that isn't captured by any consumer requests.
  *
  * @valid_modes_mask: Mask of modes which may be configured by consumers.
  * @valid_ops_mask: Operations which may be performed by consumers.
@@ -86,6 +88,8 @@ struct regulator_state {
  *           applied.
  * @apply_uV: Apply the voltage constraint when initialising.
  * @ramp_disable: Disable ramp delay when initialising or when setting voltage.
+ * @soft_start: Enable soft start so that voltage ramps slowly.
+ * @pull_down: Enable pull down when regulator is disabled.
  *
  * @input_uV: Input voltage for regulator when supplied by another regulator.
  *
@@ -111,6 +115,9 @@ struct regulation_constraints {
         /* current output range (inclusive) - for current control */
         int min_uA;
         int max_uA;
+        int ilim_uA;
+
+        int system_load;
 
         /* valid regulator operating modes for this machine */
         unsigned int valid_modes_mask;
@@ -138,6 +145,8 @@ struct regulation_constraints {
         unsigned boot_on:1;     /* bootloader/firmware enabled regulator */
         unsigned apply_uV:1;    /* apply uV constraint if min == max */
         unsigned ramp_disable:1; /* disable ramp delay */
+        unsigned soft_start:1;  /* ramp voltage slowly */
+        unsigned pull_down:1;   /* pull down resistor when regulator off */
 };
 
 /**
diff --git a/include/linux/regulator/max8973-regulator.h b/include/linux/regulator/max8973-regulator.h
index f8acc052e353..f6a8a16a0d4d 100644
--- a/include/linux/regulator/max8973-regulator.h
+++ b/include/linux/regulator/max8973-regulator.h
@@ -58,6 +58,9 @@
  *              control signal from EN input pin. If it is false then
  *              voltage output will be enabled/disabled through EN bit of
  *              device register.
+ * @enable_gpio: Enable GPIO. If EN pin is controlled through GPIO from host
+ *              then GPIO number can be provided. If no GPIO controlled then
+ *              it should be -1.
  * @dvs_gpio: GPIO for dvs. It should be -1 if this is tied with fixed logic.
  * @dvs_def_state: Default state of dvs. 1 if it is high else 0.
  */
@@ -65,6 +68,7 @@ struct max8973_regulator_platform_data {
         struct regulator_init_data *reg_init_data;
         unsigned long control_flags;
         bool enable_ext_control;
+        int enable_gpio;
         int dvs_gpio;
         unsigned dvs_def_state:1;
 };
diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
index 78b8a9b9d40a..9c4e1384f636 100644
--- a/include/linux/remoteproc.h
+++ b/include/linux/remoteproc.h
@@ -36,11 +36,11 @@
 #define REMOTEPROC_H
 
 #include <linux/types.h>
-#include <linux/klist.h>
 #include <linux/mutex.h>
 #include <linux/virtio.h>
 #include <linux/completion.h>
 #include <linux/idr.h>
+#include <linux/of.h>
 
 /**
  * struct resource_table - firmware resource table header
@@ -330,11 +330,13 @@ struct rproc;
  * @start:      power on the device and boot it
  * @stop:       power off the device
  * @kick:       kick a virtqueue (virtqueue id given as a parameter)
+ * @da_to_va:   optional platform hook to perform address translations
  */
 struct rproc_ops {
         int (*start)(struct rproc *rproc);
         int (*stop)(struct rproc *rproc);
         void (*kick)(struct rproc *rproc, int vqid);
+        void * (*da_to_va)(struct rproc *rproc, u64 da, int len);
 };
 
 /**
@@ -375,7 +377,7 @@ enum rproc_crash_type {
 
 /**
  * struct rproc - represents a physical remote processor device
- * @node: klist node of this rproc object
+ * @node: list node of this rproc object
  * @domain: iommu domain
  * @name: human readable name of the rproc
  * @firmware: name of firmware file to be loaded
@@ -407,7 +409,7 @@ enum rproc_crash_type {
  * @has_iommu: flag to indicate if remote processor is behind an MMU
  */
 struct rproc {
-        struct klist_node node;
+        struct list_head node;
         struct iommu_domain *domain;
         const char *name;
         const char *firmware;
@@ -481,6 +483,7 @@ struct rproc_vdev {
         u32 rsc_offset;
 };
 
+struct rproc *rproc_get_by_phandle(phandle phandle);
 struct rproc *rproc_alloc(struct device *dev, const char *name,
                                 const struct rproc_ops *ops,
                                 const char *firmware, int len);
diff --git a/include/linux/reset/bcm63xx_pmb.h b/include/linux/reset/bcm63xx_pmb.h
new file mode 100644
index 000000000000..bb4af7b5eb36
--- /dev/null
+++ b/include/linux/reset/bcm63xx_pmb.h
@@ -0,0 +1,88 @@
+/*
+ * Broadcom BCM63xx Processor Monitor Bus shared routines (SMP and reset)
+ *
+ * Copyright (C) 2015, Broadcom Corporation
+ * Author: Florian Fainelli <f.fainelli@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation version 2.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#ifndef __BCM63XX_PMB_H
+#define __BCM63XX_PMB_H
+
+#include <linux/io.h>
+#include <linux/types.h>
+#include <linux/delay.h>
+#include <linux/err.h>
+
+/* PMB Master controller register */
+#define PMB_CTRL                0x00
+#define  PMC_PMBM_START         (1 << 31)
+#define  PMC_PMBM_TIMEOUT       (1 << 30)
+#define  PMC_PMBM_SLAVE_ERR     (1 << 29)
+#define  PMC_PMBM_BUSY          (1 << 28)
+#define  PMC_PMBM_READ          (0 << 20)
+#define  PMC_PMBM_WRITE         (1 << 20)
+#define PMB_WR_DATA             0x04
+#define PMB_TIMEOUT             0x08
+#define PMB_RD_DATA             0x0C
+
+#define PMB_BUS_ID_SHIFT        8
+
+/* Perform the low-level PMB master operation, shared between reads and
+ * writes.
+ */
+static inline int __bpcm_do_op(void __iomem *master, unsigned int addr,
+                               u32 off, u32 op)
+{
+        unsigned int timeout = 1000;
+        u32 cmd;
+
+        cmd = (PMC_PMBM_START | op | (addr & 0xff) << 12 | off);
+        writel(cmd, master + PMB_CTRL);
+        do {
+                cmd = readl(master + PMB_CTRL);
+                if (!(cmd & PMC_PMBM_START))
+                        return 0;
+
+                if (cmd & PMC_PMBM_SLAVE_ERR)
+                        return -EIO;
+
+                if (cmd & PMC_PMBM_TIMEOUT)
+                        return -ETIMEDOUT;
+
+                udelay(1);
+        } while (timeout-- > 0);
+
+        return -ETIMEDOUT;
+}
+
+static inline int bpcm_rd(void __iomem *master, unsigned int addr,
+                          u32 off, u32 *val)
+{
+        int ret = 0;
+
+        ret = __bpcm_do_op(master, addr, off >> 2, PMC_PMBM_READ);
+        *val = readl(master + PMB_RD_DATA);
+
+        return ret;
+}
+
+static inline int bpcm_wr(void __iomem *master, unsigned int addr,
+                          u32 off, u32 val)
+{
+        int ret = 0;
+
+        writel(val, master + PMB_WR_DATA);
+        ret = __bpcm_do_op(master, addr, off >> 2, PMC_PMBM_WRITE);
+
+        return ret;
+}
+
+#endif /* __BCM63XX_PMB_H */
diff --git a/include/linux/rio.h b/include/linux/rio.h
index 6bda06f21930..cde976e86b48 100644
--- a/include/linux/rio.h
+++ b/include/linux/rio.h
@@ -298,7 +298,7 @@ struct rio_id_table {
  * struct rio_net - RIO network info
  * @node: Node in global list of RIO networks
  * @devices: List of devices in this network
- * @switches: List of switches in this netowrk
+ * @switches: List of switches in this network
  * @mports: List of master ports accessing this network
  * @hport: Default port for accessing this network
  * @id: RIO network ID
diff --git a/include/linux/rtc.h b/include/linux/rtc.h
index 8dcf6825fa88..3359f0422c6b 100644
--- a/include/linux/rtc.h
+++ b/include/linux/rtc.h
@@ -24,6 +24,14 @@ extern void rtc_time64_to_tm(time64_t time, struct rtc_time *tm);
 ktime_t rtc_tm_to_ktime(struct rtc_time tm);
 struct rtc_time rtc_ktime_to_tm(ktime_t kt);
 
+/*
+ * rtc_tm_sub - Return the difference in seconds.
+ */
+static inline time64_t rtc_tm_sub(struct rtc_time *lhs, struct rtc_time *rhs)
+{
+        return rtc_tm_to_time64(lhs) - rtc_tm_to_time64(rhs);
+}
+
 /**
  * Deprecated. Use rtc_time64_to_tm().
  */
@@ -101,8 +109,7 @@ struct rtc_timer {
 /* flags */
 #define RTC_DEV_BUSY 0
 
-struct rtc_device
-{
+struct rtc_device {
         struct device dev;
         struct module *owner;
 
@@ -161,7 +168,6 @@ extern void devm_rtc_device_unregister(struct device *dev,
 
 extern int rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm);
 extern int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm);
-extern int rtc_set_mmss(struct rtc_device *rtc, unsigned long secs);
 extern int rtc_set_ntp_time(struct timespec64 now);
 int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm);
 extern int rtc_read_alarm(struct rtc_device *rtc,
@@ -198,10 +204,10 @@ int rtc_register(rtc_task_t *task);
 int rtc_unregister(rtc_task_t *task);
 int rtc_control(rtc_task_t *t, unsigned int cmd, unsigned long arg);
 
-void rtc_timer_init(struct rtc_timer *timer, void (*f)(void* p), void* data);
-int rtc_timer_start(struct rtc_device *rtc, struct rtc_timer* timer,
-                        ktime_t expires, ktime_t period);
-int rtc_timer_cancel(struct rtc_device *rtc, struct rtc_timer* timer);
+void rtc_timer_init(struct rtc_timer *timer, void (*f)(void *p), void *data);
+int rtc_timer_start(struct rtc_device *rtc, struct rtc_timer *timer,
+                    ktime_t expires, ktime_t period);
+void rtc_timer_cancel(struct rtc_device *rtc, struct rtc_timer *timer);
 void rtc_timer_do_work(struct work_struct *work);
 
 static inline bool is_leap_year(unsigned int year)
diff --git a/include/linux/rtc/sirfsoc_rtciobrg.h b/include/linux/rtc/sirfsoc_rtciobrg.h
index 2c92e1c8e055..aefd997262e4 100644
--- a/include/linux/rtc/sirfsoc_rtciobrg.h
+++ b/include/linux/rtc/sirfsoc_rtciobrg.h
@@ -9,10 +9,14 @@
 #ifndef _SIRFSOC_RTC_IOBRG_H_
 #define _SIRFSOC_RTC_IOBRG_H_
 
+struct regmap_config;
+
 extern void sirfsoc_rtc_iobrg_besyncing(void);
 
 extern u32 sirfsoc_rtc_iobrg_readl(u32 addr);
 
 extern void sirfsoc_rtc_iobrg_writel(u32 val, u32 addr);
+struct regmap *devm_regmap_init_iobg(struct device *dev,
+                                    const struct regmap_config *config);
 
 #endif
diff --git a/include/linux/rtnetlink.h b/include/linux/rtnetlink.h
index 7b8e260c4a27..39adaa9529eb 100644
--- a/include/linux/rtnetlink.h
+++ b/include/linux/rtnetlink.h
@@ -79,17 +79,9 @@ static inline struct netdev_queue *dev_ingress_queue(struct net_device *dev)
 
 struct netdev_queue *dev_ingress_queue_create(struct net_device *dev);
 
-#ifdef CONFIG_NET_CLS_ACT
+#ifdef CONFIG_NET_INGRESS
 void net_inc_ingress_queue(void);
 void net_dec_ingress_queue(void);
-#else
-static inline void net_inc_ingress_queue(void)
-{
-}
-
-static inline void net_dec_ingress_queue(void)
-{
-}
 #endif
 
 extern void rtnetlink_init(void);
@@ -122,5 +114,9 @@ extern int ndo_dflt_fdb_del(struct ndmsg *ndm,
 
 extern int ndo_dflt_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq,
                                    struct net_device *dev, u16 mode,
-                                   u32 flags, u32 mask, int nlflags);
+                                   u32 flags, u32 mask, int nlflags,
+                                   u32 filter_mask,
+                                   int (*vlan_fill)(struct sk_buff *skb,
+                                                    struct net_device *dev,
+                                                    u32 filter_mask));
 #endif  /* __LINUX_RTNETLINK_H */
diff --git a/include/linux/scatterlist.h b/include/linux/scatterlist.h
index a0edb992c9c3..9b1ef0c820a7 100644
--- a/include/linux/scatterlist.h
+++ b/include/linux/scatterlist.h
@@ -2,13 +2,39 @@
 #define _LINUX_SCATTERLIST_H
 
 #include <linux/string.h>
+#include <linux/types.h>
 #include <linux/bug.h>
 #include <linux/mm.h>
-
-#include <asm/types.h>
-#include <asm/scatterlist.h>
 #include <asm/io.h>
 
+struct scatterlist {
+#ifdef CONFIG_DEBUG_SG
+        unsigned long   sg_magic;
+#endif
+        unsigned long   page_link;
+        unsigned int    offset;
+        unsigned int    length;
+        dma_addr_t      dma_address;
+#ifdef CONFIG_NEED_SG_DMA_LENGTH
+        unsigned int    dma_length;
+#endif
+};
+
+/*
+ * These macros should be used after a dma_map_sg call has been done
+ * to get bus addresses of each of the SG entries and their lengths.
+ * You should only work with the number of sg entries dma_map_sg
+ * returns, or alternatively stop on the first sg_dma_len(sg) which
+ * is 0.
+ */
+#define sg_dma_address(sg)      ((sg)->dma_address)
+
+#ifdef CONFIG_NEED_SG_DMA_LENGTH
+#define sg_dma_len(sg)          ((sg)->dma_length)
+#else
+#define sg_dma_len(sg)          ((sg)->length)
+#endif
+
 struct sg_table {
         struct scatterlist *sgl;        /* the list */
         unsigned int nents;             /* number of mapped entries */
@@ -18,10 +44,9 @@ struct sg_table {
 /*
  * Notes on SG table design.
  *
- * Architectures must provide an unsigned long page_link field in the
- * scatterlist struct. We use that to place the page pointer AND encode
- * information about the sg table as well. The two lower bits are reserved
- * for this information.
+ * We use the unsigned long page_link field in the scatterlist struct to place
+ * the page pointer AND encode information about the sg table as well. The two
+ * lower bits are reserved for this information.
  *
  * If bit 0 is set, then the page_link contains a pointer to the next sg
  * table list. Otherwise the next entry is at sg + 1.
@@ -240,13 +265,16 @@ int sg_alloc_table_from_pages(struct sg_table *sgt,
         unsigned long offset, unsigned long size,
         gfp_t gfp_mask);
 
+size_t sg_copy_buffer(struct scatterlist *sgl, unsigned int nents, void *buf,
+                      size_t buflen, off_t skip, bool to_buffer);
+
 size_t sg_copy_from_buffer(struct scatterlist *sgl, unsigned int nents,
-                           void *buf, size_t buflen);
+                           const void *buf, size_t buflen);
 size_t sg_copy_to_buffer(struct scatterlist *sgl, unsigned int nents,
                          void *buf, size_t buflen);
 
 size_t sg_pcopy_from_buffer(struct scatterlist *sgl, unsigned int nents,
-                            void *buf, size_t buflen, off_t skip);
+                            const void *buf, size_t buflen, off_t skip);
 size_t sg_pcopy_to_buffer(struct scatterlist *sgl, unsigned int nents,
                           void *buf, size_t buflen, off_t skip);
 
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 6633e83e608a..04b5ada460b4 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -58,6 +58,7 @@ struct sched_param {
 #include <linux/uidgid.h>
 #include <linux/gfp.h>
 #include <linux/magic.h>
+#include <linux/cgroup-defs.h>
 
 #include <asm/processor.h>
 
@@ -191,8 +192,6 @@ struct task_group;
 #ifdef CONFIG_SCHED_DEBUG
 extern void proc_sched_show_task(struct task_struct *p, struct seq_file *m);
 extern void proc_sched_set_task(struct task_struct *p);
-extern void
-print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq);
 #endif
 
 /*
@@ -755,18 +754,6 @@ struct signal_struct {
         unsigned audit_tty_log_passwd;
         struct tty_audit_buf *tty_audit_buf;
 #endif
-#ifdef CONFIG_CGROUPS
-        /*
-         * group_rwsem prevents new tasks from entering the threadgroup and
-         * member tasks from exiting,a more specifically, setting of
-         * PF_EXITING.  fork and exit paths are protected with this rwsem
-         * using threadgroup_change_begin/end().  Users which require
-         * threadgroup to remain stable should use threadgroup_[un]lock()
-         * which also takes care of exec path.  Currently, cgroup is the
-         * only user.
-         */
-        struct rw_semaphore group_rwsem;
-#endif
 
         oom_flags_t oom_flags;
         short oom_score_adj;            /* OOM kill score adjustment */
@@ -849,7 +836,7 @@ extern struct user_struct root_user;
 struct backing_dev_info;
 struct reclaim_state;
 
-#if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
+#ifdef CONFIG_SCHED_INFO
 struct sched_info {
         /* cumulative counters */
         unsigned long pcount;         /* # of times run on this cpu */
@@ -859,7 +846,7 @@ struct sched_info {
         unsigned long long last_arrival,/* when we last ran on a cpu */
                            last_queued; /* when we were last queued to run */
 };
-#endif /* defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT) */
+#endif /* CONFIG_SCHED_INFO */
 
 #ifdef CONFIG_TASK_DELAY_ACCT
 struct task_delay_info {
@@ -1408,7 +1395,7 @@ struct task_struct {
         int rcu_tasks_idle_cpu;
 #endif /* #ifdef CONFIG_TASKS_RCU */
 
-#if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
+#ifdef CONFIG_SCHED_INFO
         struct sched_info sched_info;
 #endif
 
@@ -1535,8 +1522,6 @@ struct task_struct {
 /* hung task detection */
         unsigned long last_switch_count;
 #endif
-/* CPU-specific state of this task */
-        struct thread_struct thread;
 /* filesystem information */
         struct fs_struct *fs;
 /* open file information */
@@ -1791,8 +1776,22 @@ struct task_struct {
         unsigned long   task_state_change;
 #endif
         int pagefault_disabled;
+/* CPU-specific state of this task */
+        struct thread_struct thread;
+/*
+ * WARNING: on x86, 'thread_struct' contains a variable-sized
+ * structure.  It *MUST* be at the end of 'task_struct'.
+ *
+ * Do not put anything below here!
+ */
 };
 
+#ifdef CONFIG_ARCH_WANTS_DYNAMIC_TASK_STRUCT
+extern int arch_task_struct_size __read_mostly;
+#else
+# define arch_task_struct_size (sizeof(struct task_struct))
+#endif
+
 /* Future-safe accessor for struct task_struct's cpus_allowed. */
 #define tsk_cpus_allowed(tsk) (&(tsk)->cpus_allowed)
 
@@ -2432,7 +2431,6 @@ extern void sched_dead(struct task_struct *p);
 
 extern void proc_caches_init(void);
 extern void flush_signals(struct task_struct *);
-extern void __flush_signals(struct task_struct *);
 extern void ignore_signals(struct task_struct *);
 extern void flush_signal_handlers(struct task_struct *, int force_default);
 extern int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info);
@@ -2556,8 +2554,22 @@ 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 *);
 
+#ifdef CONFIG_HAVE_COPY_THREAD_TLS
+extern int copy_thread_tls(unsigned long, unsigned long, unsigned long,
+                        struct task_struct *, unsigned long);
+#else
 extern int copy_thread(unsigned long, unsigned long, unsigned long,
                         struct task_struct *);
+
+/* Architectures that haven't opted into copy_thread_tls get the tls argument
+ * via pt_regs, so ignore the tls argument passed via C. */
+static inline int copy_thread_tls(
+                unsigned long clone_flags, unsigned long sp, unsigned long arg,
+                struct task_struct *p, unsigned long tls)
+{
+        return copy_thread(clone_flags, sp, arg, p);
+}
+#endif
 extern void flush_thread(void);
 extern void exit_thread(void);
 
@@ -2576,6 +2588,7 @@ extern int do_execveat(int, struct filename *,
                        const char __user * const __user *,
                        const char __user * const __user *,
                        int);
+extern long _do_fork(unsigned long, unsigned long, unsigned long, int __user *, int __user *, unsigned long);
 extern long do_fork(unsigned long, unsigned long, unsigned long, int __user *, int __user *);
 struct task_struct *fork_idle(int);
 extern pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);
@@ -2710,53 +2723,33 @@ static inline void unlock_task_sighand(struct task_struct *tsk,
         spin_unlock_irqrestore(&tsk->sighand->siglock, *flags);
 }
 
-#ifdef CONFIG_CGROUPS
-static inline void threadgroup_change_begin(struct task_struct *tsk)
-{
-        down_read(&tsk->signal->group_rwsem);
-}
-static inline void threadgroup_change_end(struct task_struct *tsk)
-{
-        up_read(&tsk->signal->group_rwsem);
-}
-
 /**
- * threadgroup_lock - lock threadgroup
- * @tsk: member task of the threadgroup to lock
- *
- * Lock the threadgroup @tsk belongs to.  No new task is allowed to enter
- * and member tasks aren't allowed to exit (as indicated by PF_EXITING) or
- * change ->group_leader/pid.  This is useful for cases where the threadgroup
- * needs to stay stable across blockable operations.
- *
- * fork and exit paths explicitly call threadgroup_change_{begin|end}() for
- * synchronization.  While held, no new task will be added to threadgroup
- * and no existing live task will have its PF_EXITING set.
+ * threadgroup_change_begin - mark the beginning of changes to a threadgroup
+ * @tsk: task causing the changes
  *
- * de_thread() does threadgroup_change_{begin|end}() when a non-leader
- * sub-thread becomes a new leader.
+ * All operations which modify a threadgroup - a new thread joining the
+ * group, death of a member thread (the assertion of PF_EXITING) and
+ * exec(2) dethreading the process and replacing the leader - are wrapped
+ * by threadgroup_change_{begin|end}().  This is to provide a place which
+ * subsystems needing threadgroup stability can hook into for
+ * synchronization.
  */
-static inline void threadgroup_lock(struct task_struct *tsk)
+static inline void threadgroup_change_begin(struct task_struct *tsk)
 {
-        down_write(&tsk->signal->group_rwsem);
+        might_sleep();
+        cgroup_threadgroup_change_begin(tsk);
 }
 
 /**
- * threadgroup_unlock - unlock threadgroup
- * @tsk: member task of the threadgroup to unlock
+ * threadgroup_change_end - mark the end of changes to a threadgroup
+ * @tsk: task causing the changes
  *
- * Reverse threadgroup_lock().
+ * See threadgroup_change_begin().
  */
-static inline void threadgroup_unlock(struct task_struct *tsk)
+static inline void threadgroup_change_end(struct task_struct *tsk)
 {
-        up_write(&tsk->signal->group_rwsem);
+        cgroup_threadgroup_change_end(tsk);
 }
-#else
-static inline void threadgroup_change_begin(struct task_struct *tsk) {}
-static inline void threadgroup_change_end(struct task_struct *tsk) {}
-static inline void threadgroup_lock(struct task_struct *tsk) {}
-static inline void threadgroup_unlock(struct task_struct *tsk) {}
-#endif
 
 #ifndef __HAVE_THREAD_FUNCTIONS
 
diff --git a/include/linux/scif.h b/include/linux/scif.h
new file mode 100644
index 000000000000..44f4f3898bbe
--- /dev/null
+++ b/include/linux/scif.h
@@ -0,0 +1,993 @@
+/*
+ * Intel MIC Platform Software Stack (MPSS)
+ *
+ * This file is provided under a dual BSD/GPLv2 license.  When using or
+ * redistributing this file, you may do so under either license.
+ *
+ * GPL LICENSE SUMMARY
+ *
+ * Copyright(c) 2014 Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * BSD LICENSE
+ *
+ * Copyright(c) 2014 Intel Corporation.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in
+ *   the documentation and/or other materials provided with the
+ *   distribution.
+ * * Neither the name of Intel Corporation nor the names of its
+ *   contributors may be used to endorse or promote products derived
+ *   from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Intel SCIF driver.
+ *
+ */
+#ifndef __SCIF_H__
+#define __SCIF_H__
+
+#include <linux/types.h>
+#include <linux/poll.h>
+#include <linux/scif_ioctl.h>
+
+#define SCIF_ACCEPT_SYNC        1
+#define SCIF_SEND_BLOCK         1
+#define SCIF_RECV_BLOCK         1
+
+enum {
+        SCIF_PROT_READ = (1 << 0),
+        SCIF_PROT_WRITE = (1 << 1)
+};
+
+enum {
+        SCIF_MAP_FIXED = 0x10,
+        SCIF_MAP_KERNEL = 0x20,
+};
+
+enum {
+        SCIF_FENCE_INIT_SELF = (1 << 0),
+        SCIF_FENCE_INIT_PEER = (1 << 1),
+        SCIF_SIGNAL_LOCAL = (1 << 4),
+        SCIF_SIGNAL_REMOTE = (1 << 5)
+};
+
+enum {
+        SCIF_RMA_USECPU = (1 << 0),
+        SCIF_RMA_USECACHE = (1 << 1),
+        SCIF_RMA_SYNC = (1 << 2),
+        SCIF_RMA_ORDERED = (1 << 3)
+};
+
+/* End of SCIF Admin Reserved Ports */
+#define SCIF_ADMIN_PORT_END     1024
+
+/* End of SCIF Reserved Ports */
+#define SCIF_PORT_RSVD          1088
+
+typedef struct scif_endpt *scif_epd_t;
+
+#define SCIF_OPEN_FAILED ((scif_epd_t)-1)
+#define SCIF_REGISTER_FAILED ((off_t)-1)
+#define SCIF_MMAP_FAILED ((void *)-1)
+
+/**
+ * scif_open() - Create an endpoint
+ *
+ * Return:
+ * Upon successful completion, scif_open() returns an endpoint descriptor to
+ * be used in subsequent SCIF functions calls to refer to that endpoint;
+ * otherwise in user mode SCIF_OPEN_FAILED (that is ((scif_epd_t)-1)) is
+ * returned and errno is set to indicate the error; in kernel mode a NULL
+ * scif_epd_t is returned.
+ *
+ * Errors:
+ * ENOMEM - Insufficient kernel memory was available
+ */
+scif_epd_t scif_open(void);
+
+/**
+ * scif_bind() - Bind an endpoint to a port
+ * @epd:        endpoint descriptor
+ * @pn:         port number
+ *
+ * scif_bind() binds endpoint epd to port pn, where pn is a port number on the
+ * local node. If pn is zero, a port number greater than or equal to
+ * SCIF_PORT_RSVD is assigned and returned. Each endpoint may be bound to
+ * exactly one local port. Ports less than 1024 when requested can only be bound
+ * by system (or root) processes or by processes executed by privileged users.
+ *
+ * Return:
+ * Upon successful completion, scif_bind() returns the port number to which epd
+ * is bound; otherwise in user mode -1 is returned and errno is set to
+ * indicate the error; in kernel mode the negative of one of the following
+ * errors is returned.
+ *
+ * Errors:
+ * EBADF, ENOTTY - epd is not a valid endpoint descriptor
+ * EINVAL - the endpoint or the port is already bound
+ * EISCONN - The endpoint is already connected
+ * ENOSPC - No port number available for assignment
+ * EACCES - The port requested is protected and the user is not the superuser
+ */
+int scif_bind(scif_epd_t epd, u16 pn);
+
+/**
+ * scif_listen() - Listen for connections on an endpoint
+ * @epd:        endpoint descriptor
+ * @backlog:    maximum pending connection requests
+ *
+ * scif_listen() marks the endpoint epd as a listening endpoint - that is, as
+ * an endpoint that will be used to accept incoming connection requests. Once
+ * so marked, the endpoint is said to be in the listening state and may not be
+ * used as the endpoint of a connection.
+ *
+ * The endpoint, epd, must have been bound to a port.
+ *
+ * The backlog argument defines the maximum length to which the queue of
+ * pending connections for epd may grow. If a connection request arrives when
+ * the queue is full, the client may receive an error with an indication that
+ * the connection was refused.
+ *
+ * Return:
+ * Upon successful completion, scif_listen() returns 0; otherwise in user mode
+ * -1 is returned and errno is set to indicate the error; in kernel mode the
+ * negative of one of the following errors is returned.
+ *
+ * Errors:
+ * EBADF, ENOTTY - epd is not a valid endpoint descriptor
+ * EINVAL - the endpoint is not bound to a port
+ * EISCONN - The endpoint is already connected or listening
+ */
+int scif_listen(scif_epd_t epd, int backlog);
+
+/**
+ * scif_connect() - Initiate a connection on a port
+ * @epd:        endpoint descriptor
+ * @dst:        global id of port to which to connect
+ *
+ * The scif_connect() function requests the connection of endpoint epd to remote
+ * port dst. If the connection is successful, a peer endpoint, bound to dst, is
+ * created on node dst.node. On successful return, the connection is complete.
+ *
+ * If the endpoint epd has not already been bound to a port, scif_connect()
+ * will bind it to an unused local port.
+ *
+ * A connection is terminated when an endpoint of the connection is closed,
+ * either explicitly by scif_close(), or when a process that owns one of the
+ * endpoints of the connection is terminated.
+ *
+ * In user space, scif_connect() supports an asynchronous connection mode
+ * if the application has set the O_NONBLOCK flag on the endpoint via the
+ * fcntl() system call. Setting this flag will result in the calling process
+ * not to wait during scif_connect().
+ *
+ * Return:
+ * Upon successful completion, scif_connect() returns the port ID to which the
+ * endpoint, epd, is bound; otherwise in user mode -1 is returned and errno is
+ * set to indicate the error; in kernel mode the negative of one of the
+ * following errors is returned.
+ *
+ * Errors:
+ * EBADF, ENOTTY - epd is not a valid endpoint descriptor
+ * ECONNREFUSED - The destination was not listening for connections or refused
+ * the connection request
+ * EINVAL - dst.port is not a valid port ID
+ * EISCONN - The endpoint is already connected
+ * ENOMEM - No buffer space is available
+ * ENODEV - The destination node does not exist, or the node is lost or existed,
+ * but is not currently in the network since it may have crashed
+ * ENOSPC - No port number available for assignment
+ * EOPNOTSUPP - The endpoint is listening and cannot be connected
+ */
+int scif_connect(scif_epd_t epd, struct scif_port_id *dst);
+
+/**
+ * scif_accept() - Accept a connection on an endpoint
+ * @epd:        endpoint descriptor
+ * @peer:       global id of port to which connected
+ * @newepd:     new connected endpoint descriptor
+ * @flags:      flags
+ *
+ * The scif_accept() call extracts the first connection request from the queue
+ * of pending connections for the port on which epd is listening. scif_accept()
+ * creates a new endpoint, bound to the same port as epd, and allocates a new
+ * SCIF endpoint descriptor, returned in newepd, for the endpoint. The new
+ * endpoint is connected to the endpoint through which the connection was
+ * requested. epd is unaffected by this call, and remains in the listening
+ * state.
+ *
+ * On successful return, peer holds the global port identifier (node id and
+ * local port number) of the port which requested the connection.
+ *
+ * A connection is terminated when an endpoint of the connection is closed,
+ * either explicitly by scif_close(), or when a process that owns one of the
+ * endpoints of the connection is terminated.
+ *
+ * The number of connections that can (subsequently) be accepted on epd is only
+ * limited by system resources (memory).
+ *
+ * The flags argument is formed by OR'ing together zero or more of the
+ * following values.
+ * SCIF_ACCEPT_SYNC - block until a connection request is presented. If
+ *                      SCIF_ACCEPT_SYNC is not in flags, and no pending
+ *                      connections are present on the queue, scif_accept()
+ *                      fails with an EAGAIN error
+ *
+ * In user mode, the select() and poll() functions can be used to determine
+ * when there is a connection request. In kernel mode, the scif_poll()
+ * function may be used for this purpose. A readable event will be delivered
+ * when a connection is requested.
+ *
+ * Return:
+ * Upon successful completion, scif_accept() returns 0; otherwise in user mode
+ * -1 is returned and errno is set to indicate the error; in kernel mode the
+ *      negative of one of the following errors is returned.
+ *
+ * Errors:
+ * EAGAIN - SCIF_ACCEPT_SYNC is not set and no connections are present to be
+ * accepted or SCIF_ACCEPT_SYNC is not set and remote node failed to complete
+ * its connection request
+ * EBADF, ENOTTY - epd is not a valid endpoint descriptor
+ * EINTR - Interrupted function
+ * EINVAL - epd is not a listening endpoint, or flags is invalid, or peer is
+ * NULL, or newepd is NULL
+ * ENODEV - The requesting node is lost or existed, but is not currently in the
+ * network since it may have crashed
+ * ENOMEM - Not enough space
+ * ENOENT - Secondary part of epd registration failed
+ */
+int scif_accept(scif_epd_t epd, struct scif_port_id *peer, scif_epd_t
+                *newepd, int flags);
+
+/**
+ * scif_close() - Close an endpoint
+ * @epd:        endpoint descriptor
+ *
+ * scif_close() closes an endpoint and performs necessary teardown of
+ * facilities associated with that endpoint.
+ *
+ * If epd is a listening endpoint then it will no longer accept connection
+ * requests on the port to which it is bound. Any pending connection requests
+ * are rejected.
+ *
+ * If epd is a connected endpoint, then its peer endpoint is also closed. RMAs
+ * which are in-process through epd or its peer endpoint will complete before
+ * scif_close() returns. Registered windows of the local and peer endpoints are
+ * released as if scif_unregister() was called against each window.
+ *
+ * Closing a SCIF endpoint does not affect local registered memory mapped by
+ * a SCIF endpoint on a remote node. The local memory remains mapped by the peer
+ * SCIF endpoint explicitly removed by calling munmap(..) by the peer.
+ *
+ * If the peer endpoint's receive queue is not empty at the time that epd is
+ * closed, then the peer endpoint can be passed as the endpoint parameter to
+ * scif_recv() until the receive queue is empty.
+ *
+ * epd is freed and may no longer be accessed.
+ *
+ * Return:
+ * Upon successful completion, scif_close() returns 0; otherwise in user mode
+ * -1 is returned and errno is set to indicate the error; in kernel mode the
+ * negative of one of the following errors is returned.
+ *
+ * Errors:
+ * EBADF, ENOTTY - epd is not a valid endpoint descriptor
+ */
+int scif_close(scif_epd_t epd);
+
+/**
+ * scif_send() - Send a message
+ * @epd:        endpoint descriptor
+ * @msg:        message buffer address
+ * @len:        message length
+ * @flags:      blocking mode flags
+ *
+ * scif_send() sends data to the peer of endpoint epd. Up to len bytes of data
+ * are copied from memory starting at address msg. On successful execution the
+ * return value of scif_send() is the number of bytes that were sent, and is
+ * zero if no bytes were sent because len was zero. scif_send() may be called
+ * only when the endpoint is in a connected state.
+ *
+ * If a scif_send() call is non-blocking, then it sends only those bytes which
+ * can be sent without waiting, up to a maximum of len bytes.
+ *
+ * If a scif_send() call is blocking, then it normally returns after sending
+ * all len bytes. If a blocking call is interrupted or the connection is
+ * reset, the call is considered successful if some bytes were sent or len is
+ * zero, otherwise the call is considered unsuccessful.
+ *
+ * In user mode, the select() and poll() functions can be used to determine
+ * when the send queue is not full. In kernel mode, the scif_poll() function
+ * may be used for this purpose.
+ *
+ * It is recommended that scif_send()/scif_recv() only be used for short
+ * control-type message communication between SCIF endpoints. The SCIF RMA
+ * APIs are expected to provide better performance for transfer sizes of
+ * 1024 bytes or longer for the current MIC hardware and software
+ * implementation.
+ *
+ * scif_send() will block until the entire message is sent if SCIF_SEND_BLOCK
+ * is passed as the flags argument.
+ *
+ * Return:
+ * Upon successful completion, scif_send() returns the number of bytes sent;
+ * otherwise in user mode -1 is returned and errno is set to indicate the
+ * error; in kernel mode the negative of one of the following errors is
+ * returned.
+ *
+ * Errors:
+ * EBADF, ENOTTY - epd is not a valid endpoint descriptor
+ * ECONNRESET - Connection reset by peer
+ * EFAULT - An invalid address was specified for a parameter
+ * EINVAL - flags is invalid, or len is negative
+ * ENODEV - The remote node is lost or existed, but is not currently in the
+ * network since it may have crashed
+ * ENOMEM - Not enough space
+ * ENOTCONN - The endpoint is not connected
+ */
+int scif_send(scif_epd_t epd, void *msg, int len, int flags);
+
+/**
+ * scif_recv() - Receive a message
+ * @epd:        endpoint descriptor
+ * @msg:        message buffer address
+ * @len:        message buffer length
+ * @flags:      blocking mode flags
+ *
+ * scif_recv() receives data from the peer of endpoint epd. Up to len bytes of
+ * data are copied to memory starting at address msg. On successful execution
+ * the return value of scif_recv() is the number of bytes that were received,
+ * and is zero if no bytes were received because len was zero. scif_recv() may
+ * be called only when the endpoint is in a connected state.
+ *
+ * If a scif_recv() call is non-blocking, then it receives only those bytes
+ * which can be received without waiting, up to a maximum of len bytes.
+ *
+ * If a scif_recv() call is blocking, then it normally returns after receiving
+ * all len bytes. If the blocking call was interrupted due to a disconnection,
+ * subsequent calls to scif_recv() will copy all bytes received upto the point
+ * of disconnection.
+ *
+ * In user mode, the select() and poll() functions can be used to determine
+ * when data is available to be received. In kernel mode, the scif_poll()
+ * function may be used for this purpose.
+ *
+ * It is recommended that scif_send()/scif_recv() only be used for short
+ * control-type message communication between SCIF endpoints. The SCIF RMA
+ * APIs are expected to provide better performance for transfer sizes of
+ * 1024 bytes or longer for the current MIC hardware and software
+ * implementation.
+ *
+ * scif_recv() will block until the entire message is received if
+ * SCIF_RECV_BLOCK is passed as the flags argument.
+ *
+ * Return:
+ * Upon successful completion, scif_recv() returns the number of bytes
+ * received; otherwise in user mode -1 is returned and errno is set to
+ * indicate the error; in kernel mode the negative of one of the following
+ * errors is returned.
+ *
+ * Errors:
+ * EAGAIN - The destination node is returning from a low power state
+ * EBADF, ENOTTY - epd is not a valid endpoint descriptor
+ * ECONNRESET - Connection reset by peer
+ * EFAULT - An invalid address was specified for a parameter
+ * EINVAL - flags is invalid, or len is negative
+ * ENODEV - The remote node is lost or existed, but is not currently in the
+ * network since it may have crashed
+ * ENOMEM - Not enough space
+ * ENOTCONN - The endpoint is not connected
+ */
+int scif_recv(scif_epd_t epd, void *msg, int len, int flags);
+
+/**
+ * scif_register() - Mark a memory region for remote access.
+ * @epd:                endpoint descriptor
+ * @addr:               starting virtual address
+ * @len:                length of range
+ * @offset:             offset of window
+ * @prot_flags:         read/write protection flags
+ * @map_flags:          mapping flags
+ *
+ * The scif_register() function opens a window, a range of whole pages of the
+ * registered address space of the endpoint epd, starting at offset po and
+ * continuing for len bytes. The value of po, further described below, is a
+ * function of the parameters offset and len, and the value of map_flags. Each
+ * page of the window represents the physical memory page which backs the
+ * corresponding page of the range of virtual address pages starting at addr
+ * and continuing for len bytes. addr and len are constrained to be multiples
+ * of the page size. A successful scif_register() call returns po.
+ *
+ * When SCIF_MAP_FIXED is set in the map_flags argument, po will be offset
+ * exactly, and offset is constrained to be a multiple of the page size. The
+ * mapping established by scif_register() will not replace any existing
+ * registration; an error is returned if any page within the range [offset,
+ * offset + len - 1] intersects an existing window.
+ *
+ * When SCIF_MAP_FIXED is not set, the implementation uses offset in an
+ * implementation-defined manner to arrive at po. The po value so chosen will
+ * be an area of the registered address space that the implementation deems
+ * suitable for a mapping of len bytes. An offset value of 0 is interpreted as
+ * granting the implementation complete freedom in selecting po, subject to
+ * constraints described below. A non-zero value of offset is taken to be a
+ * suggestion of an offset near which the mapping should be placed. When the
+ * implementation selects a value for po, it does not replace any extant
+ * window. In all cases, po will be a multiple of the page size.
+ *
+ * The physical pages which are so represented by a window are available for
+ * access in calls to mmap(), scif_readfrom(), scif_writeto(),
+ * scif_vreadfrom(), and scif_vwriteto(). While a window is registered, the
+ * physical pages represented by the window will not be reused by the memory
+ * subsystem for any other purpose. Note that the same physical page may be
+ * represented by multiple windows.
+ *
+ * Subsequent operations which change the memory pages to which virtual
+ * addresses are mapped (such as mmap(), munmap()) have no effect on
+ * existing window.
+ *
+ * If the process will fork(), it is recommended that the registered
+ * virtual address range be marked with MADV_DONTFORK. Doing so will prevent
+ * problems due to copy-on-write semantics.
+ *
+ * The prot_flags argument is formed by OR'ing together one or more of the
+ * following values.
+ * SCIF_PROT_READ - allow read operations from the window
+ * SCIF_PROT_WRITE - allow write operations to the window
+ *
+ * The map_flags argument can be set to SCIF_MAP_FIXED which interprets a
+ * fixed offset.
+ *
+ * Return:
+ * Upon successful completion, scif_register() returns the offset at which the
+ * mapping was placed (po); otherwise in user mode SCIF_REGISTER_FAILED (that
+ * is (off_t *)-1) is returned and errno is set to indicate the error; in
+ * kernel mode the negative of one of the following errors is returned.
+ *
+ * Errors:
+ * EADDRINUSE - SCIF_MAP_FIXED is set in map_flags, and pages in the range
+ * [offset, offset + len -1] are already registered
+ * EAGAIN - The mapping could not be performed due to lack of resources
+ * EBADF, ENOTTY - epd is not a valid endpoint descriptor
+ * ECONNRESET - Connection reset by peer
+ * EFAULT - Addresses in the range [addr, addr + len - 1] are invalid
+ * EINVAL - map_flags is invalid, or prot_flags is invalid, or SCIF_MAP_FIXED is
+ * set in flags, and offset is not a multiple of the page size, or addr is not a
+ * multiple of the page size, or len is not a multiple of the page size, or is
+ * 0, or offset is negative
+ * ENODEV - The remote node is lost or existed, but is not currently in the
+ * network since it may have crashed
+ * ENOMEM - Not enough space
+ * ENOTCONN -The endpoint is not connected
+ */
+off_t scif_register(scif_epd_t epd, void *addr, size_t len, off_t offset,
+                    int prot_flags, int map_flags);
+
+/**
+ * scif_unregister() - Mark a memory region for remote access.
+ * @epd:        endpoint descriptor
+ * @offset:     start of range to unregister
+ * @len:        length of range to unregister
+ *
+ * The scif_unregister() function closes those previously registered windows
+ * which are entirely within the range [offset, offset + len - 1]. It is an
+ * error to specify a range which intersects only a subrange of a window.
+ *
+ * On a successful return, pages within the window may no longer be specified
+ * in calls to mmap(), scif_readfrom(), scif_writeto(), scif_vreadfrom(),
+ * scif_vwriteto(), scif_get_pages, and scif_fence_signal(). The window,
+ * however, continues to exist until all previous references against it are
+ * removed. A window is referenced if there is a mapping to it created by
+ * mmap(), or if scif_get_pages() was called against the window
+ * (and the pages have not been returned via scif_put_pages()). A window is
+ * also referenced while an RMA, in which some range of the window is a source
+ * or destination, is in progress. Finally a window is referenced while some
+ * offset in that window was specified to scif_fence_signal(), and the RMAs
+ * marked by that call to scif_fence_signal() have not completed. While a
+ * window is in this state, its registered address space pages are not
+ * available for use in a new registered window.
+ *
+ * When all such references to the window have been removed, its references to
+ * all the physical pages which it represents are removed. Similarly, the
+ * registered address space pages of the window become available for
+ * registration in a new window.
+ *
+ * Return:
+ * Upon successful completion, scif_unregister() returns 0; otherwise in user
+ * mode -1 is returned and errno is set to indicate the error; in kernel mode
+ * the negative of one of the following errors is returned. In the event of an
+ * error, no windows are unregistered.
+ *
+ * Errors:
+ * EBADF, ENOTTY - epd is not a valid endpoint descriptor
+ * ECONNRESET - Connection reset by peer
+ * EINVAL - the range [offset, offset + len - 1] intersects a subrange of a
+ * window, or offset is negative
+ * ENODEV - The remote node is lost or existed, but is not currently in the
+ * network since it may have crashed
+ * ENOTCONN - The endpoint is not connected
+ * ENXIO - Offsets in the range [offset, offset + len - 1] are invalid for the
+ * registered address space of epd
+ */
+int scif_unregister(scif_epd_t epd, off_t offset, size_t len);
+
+/**
+ * scif_readfrom() - Copy from a remote address space
+ * @epd:        endpoint descriptor
+ * @loffset:    offset in local registered address space to
+ *              which to copy
+ * @len:        length of range to copy
+ * @roffset:    offset in remote registered address space
+ *              from which to copy
+ * @rma_flags:  transfer mode flags
+ *
+ * scif_readfrom() copies len bytes from the remote registered address space of
+ * the peer of endpoint epd, starting at the offset roffset to the local
+ * registered address space of epd, starting at the offset loffset.
+ *
+ * Each of the specified ranges [loffset, loffset + len - 1] and [roffset,
+ * roffset + len - 1] must be within some registered window or windows of the
+ * local and remote nodes. A range may intersect multiple registered windows,
+ * but only if those windows are contiguous in the registered address space.
+ *
+ * If rma_flags includes SCIF_RMA_USECPU, then the data is copied using
+ * programmed read/writes. Otherwise the data is copied using DMA. If rma_-
+ * flags includes SCIF_RMA_SYNC, then scif_readfrom() will return after the
+ * transfer is complete. Otherwise, the transfer may be performed asynchron-
+ * ously. The order in which any two asynchronous RMA operations complete
+ * is non-deterministic. The synchronization functions, scif_fence_mark()/
+ * scif_fence_wait() and scif_fence_signal(), can be used to synchronize to
+ * the completion of asynchronous RMA operations on the same endpoint.
+ *
+ * The DMA transfer of individual bytes is not guaranteed to complete in
+ * address order. If rma_flags includes SCIF_RMA_ORDERED, then the last
+ * cacheline or partial cacheline of the source range will become visible on
+ * the destination node after all other transferred data in the source
+ * range has become visible on the destination node.
+ *
+ * The optimal DMA performance will likely be realized if both
+ * loffset and roffset are cacheline aligned (are a multiple of 64). Lower
+ * performance will likely be realized if loffset and roffset are not
+ * cacheline aligned but are separated by some multiple of 64. The lowest level
+ * of performance is likely if loffset and roffset are not separated by a
+ * multiple of 64.
+ *
+ * The rma_flags argument is formed by ORing together zero or more of the
+ * following values.
+ * SCIF_RMA_USECPU - perform the transfer using the CPU, otherwise use the DMA
+ *      engine.
+ * SCIF_RMA_SYNC - perform the transfer synchronously, returning after the
+ *              transfer has completed. Passing this flag results in the
+ *              current implementation busy waiting and consuming CPU cycles
+ *              while the DMA transfer is in progress for best performance by
+ *              avoiding the interrupt latency.
+ * SCIF_RMA_ORDERED - ensure that the last cacheline or partial cacheline of
+ *              the source range becomes visible on the destination node
+ *              after all other transferred data in the source range has
+ *              become visible on the destination
+ *
+ * Return:
+ * Upon successful completion, scif_readfrom() returns 0; otherwise in user
+ * mode -1 is returned and errno is set to indicate the error; in kernel mode
+ * the negative of one of the following errors is returned.
+ *
+ * Errors:
+ * EACCESS - Attempt to write to a read-only range
+ * EBADF, ENOTTY - epd is not a valid endpoint descriptor
+ * ECONNRESET - Connection reset by peer
+ * EINVAL - rma_flags is invalid
+ * ENODEV - The remote node is lost or existed, but is not currently in the
+ * network since it may have crashed
+ * ENOTCONN - The endpoint is not connected
+ * ENXIO - The range [loffset, loffset + len - 1] is invalid for the registered
+ * address space of epd, or, The range [roffset, roffset + len - 1] is invalid
+ * for the registered address space of the peer of epd, or loffset or roffset
+ * is negative
+ */
+int scif_readfrom(scif_epd_t epd, off_t loffset, size_t len, off_t
+                  roffset, int rma_flags);
+
+/**
+ * scif_writeto() - Copy to a remote address space
+ * @epd:        endpoint descriptor
+ * @loffset:    offset in local registered address space
+ *              from which to copy
+ * @len:        length of range to copy
+ * @roffset:    offset in remote registered address space to
+ *              which to copy
+ * @rma_flags:  transfer mode flags
+ *
+ * scif_writeto() copies len bytes from the local registered address space of
+ * epd, starting at the offset loffset to the remote registered address space
+ * of the peer of endpoint epd, starting at the offset roffset.
+ *
+ * Each of the specified ranges [loffset, loffset + len - 1] and [roffset,
+ * roffset + len - 1] must be within some registered window or windows of the
+ * local and remote nodes. A range may intersect multiple registered windows,
+ * but only if those windows are contiguous in the registered address space.
+ *
+ * If rma_flags includes SCIF_RMA_USECPU, then the data is copied using
+ * programmed read/writes. Otherwise the data is copied using DMA. If rma_-
+ * flags includes SCIF_RMA_SYNC, then scif_writeto() will return after the
+ * transfer is complete. Otherwise, the transfer may be performed asynchron-
+ * ously. The order in which any two asynchronous RMA operations complete
+ * is non-deterministic. The synchronization functions, scif_fence_mark()/
+ * scif_fence_wait() and scif_fence_signal(), can be used to synchronize to
+ * the completion of asynchronous RMA operations on the same endpoint.
+ *
+ * The DMA transfer of individual bytes is not guaranteed to complete in
+ * address order. If rma_flags includes SCIF_RMA_ORDERED, then the last
+ * cacheline or partial cacheline of the source range will become visible on
+ * the destination node after all other transferred data in the source
+ * range has become visible on the destination node.
+ *
+ * The optimal DMA performance will likely be realized if both
+ * loffset and roffset are cacheline aligned (are a multiple of 64). Lower
+ * performance will likely be realized if loffset and roffset are not cacheline
+ * aligned but are separated by some multiple of 64. The lowest level of
+ * performance is likely if loffset and roffset are not separated by a multiple
+ * of 64.
+ *
+ * The rma_flags argument is formed by ORing together zero or more of the
+ * following values.
+ * SCIF_RMA_USECPU - perform the transfer using the CPU, otherwise use the DMA
+ *                      engine.
+ * SCIF_RMA_SYNC - perform the transfer synchronously, returning after the
+ *              transfer has completed. Passing this flag results in the
+ *              current implementation busy waiting and consuming CPU cycles
+ *              while the DMA transfer is in progress for best performance by
+ *              avoiding the interrupt latency.
+ * SCIF_RMA_ORDERED - ensure that the last cacheline or partial cacheline of
+ *              the source range becomes visible on the destination node
+ *              after all other transferred data in the source range has
+ *              become visible on the destination
+ *
+ * Return:
+ * Upon successful completion, scif_readfrom() returns 0; otherwise in user
+ * mode -1 is returned and errno is set to indicate the error; in kernel mode
+ * the negative of one of the following errors is returned.
+ *
+ * Errors:
+ * EACCESS - Attempt to write to a read-only range
+ * EBADF, ENOTTY - epd is not a valid endpoint descriptor
+ * ECONNRESET - Connection reset by peer
+ * EINVAL - rma_flags is invalid
+ * ENODEV - The remote node is lost or existed, but is not currently in the
+ * network since it may have crashed
+ * ENOTCONN - The endpoint is not connected
+ * ENXIO - The range [loffset, loffset + len - 1] is invalid for the registered
+ * address space of epd, or, The range [roffset , roffset + len -1] is invalid
+ * for the registered address space of the peer of epd, or loffset or roffset
+ * is negative
+ */
+int scif_writeto(scif_epd_t epd, off_t loffset, size_t len, off_t
+                 roffset, int rma_flags);
+
+/**
+ * scif_vreadfrom() - Copy from a remote address space
+ * @epd:        endpoint descriptor
+ * @addr:       address to which to copy
+ * @len:        length of range to copy
+ * @roffset:    offset in remote registered address space
+ *              from which to copy
+ * @rma_flags:  transfer mode flags
+ *
+ * scif_vreadfrom() copies len bytes from the remote registered address
+ * space of the peer of endpoint epd, starting at the offset roffset, to local
+ * memory, starting at addr.
+ *
+ * The specified range [roffset, roffset + len - 1] must be within some
+ * registered window or windows of the remote nodes. The range may
+ * intersect multiple registered windows, but only if those windows are
+ * contiguous in the registered address space.
+ *
+ * If rma_flags includes SCIF_RMA_USECPU, then the data is copied using
+ * programmed read/writes. Otherwise the data is copied using DMA. If rma_-
+ * flags includes SCIF_RMA_SYNC, then scif_vreadfrom() will return after the
+ * transfer is complete. Otherwise, the transfer may be performed asynchron-
+ * ously. The order in which any two asynchronous RMA operations complete
+ * is non-deterministic. The synchronization functions, scif_fence_mark()/
+ * scif_fence_wait() and scif_fence_signal(), can be used to synchronize to
+ * the completion of asynchronous RMA operations on the same endpoint.
+ *
+ * The DMA transfer of individual bytes is not guaranteed to complete in
+ * address order. If rma_flags includes SCIF_RMA_ORDERED, then the last
+ * cacheline or partial cacheline of the source range will become visible on
+ * the destination node after all other transferred data in the source
+ * range has become visible on the destination node.
+ *
+ * If rma_flags includes SCIF_RMA_USECACHE, then the physical pages which back
+ * the specified local memory range may be remain in a pinned state even after
+ * the specified transfer completes. This may reduce overhead if some or all of
+ * the same virtual address range is referenced in a subsequent call of
+ * scif_vreadfrom() or scif_vwriteto().
+ *
+ * The optimal DMA performance will likely be realized if both
+ * addr and roffset are cacheline aligned (are a multiple of 64). Lower
+ * performance will likely be realized if addr and roffset are not
+ * cacheline aligned but are separated by some multiple of 64. The lowest level
+ * of performance is likely if addr and roffset are not separated by a
+ * multiple of 64.
+ *
+ * The rma_flags argument is formed by ORing together zero or more of the
+ * following values.
+ * SCIF_RMA_USECPU - perform the transfer using the CPU, otherwise use the DMA
+ *      engine.
+ * SCIF_RMA_USECACHE - enable registration caching
+ * SCIF_RMA_SYNC - perform the transfer synchronously, returning after the
+ *              transfer has completed. Passing this flag results in the
+ *              current implementation busy waiting and consuming CPU cycles
+ *              while the DMA transfer is in progress for best performance by
+ *              avoiding the interrupt latency.
+ * SCIF_RMA_ORDERED - ensure that the last cacheline or partial cacheline of
+ *      the source range becomes visible on the destination node
+ *      after all other transferred data in the source range has
+ *      become visible on the destination
+ *
+ * Return:
+ * Upon successful completion, scif_vreadfrom() returns 0; otherwise in user
+ * mode -1 is returned and errno is set to indicate the error; in kernel mode
+ * the negative of one of the following errors is returned.
+ *
+ * Errors:
+ * EACCESS - Attempt to write to a read-only range
+ * EBADF, ENOTTY - epd is not a valid endpoint descriptor
+ * ECONNRESET - Connection reset by peer
+ * EFAULT - Addresses in the range [addr, addr + len - 1] are invalid
+ * EINVAL - rma_flags is invalid
+ * ENODEV - The remote node is lost or existed, but is not currently in the
+ * network since it may have crashed
+ * ENOTCONN - The endpoint is not connected
+ * ENXIO - Offsets in the range [roffset, roffset + len - 1] are invalid for the
+ * registered address space of epd
+ */
+int scif_vreadfrom(scif_epd_t epd, void *addr, size_t len, off_t roffset,
+                   int rma_flags);
+
+/**
+ * scif_vwriteto() - Copy to a remote address space
+ * @epd:        endpoint descriptor
+ * @addr:       address from which to copy
+ * @len:        length of range to copy
+ * @roffset:    offset in remote registered address space to
+ *              which to copy
+ * @rma_flags:  transfer mode flags
+ *
+ * scif_vwriteto() copies len bytes from the local memory, starting at addr, to
+ * the remote registered address space of the peer of endpoint epd, starting at
+ * the offset roffset.
+ *
+ * The specified range [roffset, roffset + len - 1] must be within some
+ * registered window or windows of the remote nodes. The range may intersect
+ * multiple registered windows, but only if those windows are contiguous in the
+ * registered address space.
+ *
+ * If rma_flags includes SCIF_RMA_USECPU, then the data is copied using
+ * programmed read/writes. Otherwise the data is copied using DMA. If rma_-
+ * flags includes SCIF_RMA_SYNC, then scif_vwriteto() will return after the
+ * transfer is complete. Otherwise, the transfer may be performed asynchron-
+ * ously. The order in which any two asynchronous RMA operations complete
+ * is non-deterministic. The synchronization functions, scif_fence_mark()/
+ * scif_fence_wait() and scif_fence_signal(), can be used to synchronize to
+ * the completion of asynchronous RMA operations on the same endpoint.
+ *
+ * The DMA transfer of individual bytes is not guaranteed to complete in
+ * address order. If rma_flags includes SCIF_RMA_ORDERED, then the last
+ * cacheline or partial cacheline of the source range will become visible on
+ * the destination node after all other transferred data in the source
+ * range has become visible on the destination node.
+ *
+ * If rma_flags includes SCIF_RMA_USECACHE, then the physical pages which back
+ * the specified local memory range may be remain in a pinned state even after
+ * the specified transfer completes. This may reduce overhead if some or all of
+ * the same virtual address range is referenced in a subsequent call of
+ * scif_vreadfrom() or scif_vwriteto().
+ *
+ * The optimal DMA performance will likely be realized if both
+ * addr and offset are cacheline aligned (are a multiple of 64). Lower
+ * performance will likely be realized if addr and offset are not cacheline
+ * aligned but are separated by some multiple of 64. The lowest level of
+ * performance is likely if addr and offset are not separated by a multiple of
+ * 64.
+ *
+ * The rma_flags argument is formed by ORing together zero or more of the
+ * following values.
+ * SCIF_RMA_USECPU - perform the transfer using the CPU, otherwise use the DMA
+ *      engine.
+ * SCIF_RMA_USECACHE - allow registration caching
+ * SCIF_RMA_SYNC - perform the transfer synchronously, returning after the
+ *              transfer has completed. Passing this flag results in the
+ *              current implementation busy waiting and consuming CPU cycles
+ *              while the DMA transfer is in progress for best performance by
+ *              avoiding the interrupt latency.
+ * SCIF_RMA_ORDERED - ensure that the last cacheline or partial cacheline of
+ *              the source range becomes visible on the destination node
+ *              after all other transferred data in the source range has
+ *              become visible on the destination
+ *
+ * Return:
+ * Upon successful completion, scif_vwriteto() returns 0; otherwise in user
+ * mode -1 is returned and errno is set to indicate the error; in kernel mode
+ * the negative of one of the following errors is returned.
+ *
+ * Errors:
+ * EACCESS - Attempt to write to a read-only range
+ * EBADF, ENOTTY - epd is not a valid endpoint descriptor
+ * ECONNRESET - Connection reset by peer
+ * EFAULT - Addresses in the range [addr, addr + len - 1] are invalid
+ * EINVAL - rma_flags is invalid
+ * ENODEV - The remote node is lost or existed, but is not currently in the
+ * network since it may have crashed
+ * ENOTCONN - The endpoint is not connected
+ * ENXIO - Offsets in the range [roffset, roffset + len - 1] are invalid for the
+ * registered address space of epd
+ */
+int scif_vwriteto(scif_epd_t epd, void *addr, size_t len, off_t roffset,
+                  int rma_flags);
+
+/**
+ * scif_fence_mark() - Mark previously issued RMAs
+ * @epd:        endpoint descriptor
+ * @flags:      control flags
+ * @mark:       marked value returned as output.
+ *
+ * scif_fence_mark() returns after marking the current set of all uncompleted
+ * RMAs initiated through the endpoint epd or the current set of all
+ * uncompleted RMAs initiated through the peer of endpoint epd. The RMAs are
+ * marked with a value returned at mark. The application may subsequently call
+ * scif_fence_wait(), passing the value returned at mark, to await completion
+ * of all RMAs so marked.
+ *
+ * The flags argument has exactly one of the following values.
+ * SCIF_FENCE_INIT_SELF - RMA operations initiated through endpoint
+ *      epd are marked
+ * SCIF_FENCE_INIT_PEER - RMA operations initiated through the peer
+ *      of endpoint epd are marked
+ *
+ * Return:
+ * Upon successful completion, scif_fence_mark() returns 0; otherwise in user
+ * mode -1 is returned and errno is set to indicate the error; in kernel mode
+ * the negative of one of the following errors is returned.
+ *
+ * Errors:
+ * EBADF, ENOTTY - epd is not a valid endpoint descriptor
+ * ECONNRESET - Connection reset by peer
+ * EINVAL - flags is invalid
+ * ENODEV - The remote node is lost or existed, but is not currently in the
+ * network since it may have crashed
+ * ENOTCONN - The endpoint is not connected
+ * ENOMEM - Insufficient kernel memory was available
+ */
+int scif_fence_mark(scif_epd_t epd, int flags, int *mark);
+
+/**
+ * scif_fence_wait() - Wait for completion of marked RMAs
+ * @epd:        endpoint descriptor
+ * @mark:       mark request
+ *
+ * scif_fence_wait() returns after all RMAs marked with mark have completed.
+ * The value passed in mark must have been obtained in a previous call to
+ * scif_fence_mark().
+ *
+ * Return:
+ * Upon successful completion, scif_fence_wait() returns 0; otherwise in user
+ * mode -1 is returned and errno is set to indicate the error; in kernel mode
+ * the negative of one of the following errors is returned.
+ *
+ * Errors:
+ * EBADF, ENOTTY - epd is not a valid endpoint descriptor
+ * ECONNRESET - Connection reset by peer
+ * ENODEV - The remote node is lost or existed, but is not currently in the
+ * network since it may have crashed
+ * ENOTCONN - The endpoint is not connected
+ * ENOMEM - Insufficient kernel memory was available
+ */
+int scif_fence_wait(scif_epd_t epd, int mark);
+
+/**
+ * scif_fence_signal() - Request a memory update on completion of RMAs
+ * @epd:        endpoint descriptor
+ * @loff:       local offset
+ * @lval:       local value to write to loffset
+ * @roff:       remote offset
+ * @rval:       remote value to write to roffset
+ * @flags:      flags
+ *
+ * scif_fence_signal() returns after marking the current set of all uncompleted
+ * RMAs initiated through the endpoint epd or marking the current set of all
+ * uncompleted RMAs initiated through the peer of endpoint epd.
+ *
+ * If flags includes SCIF_SIGNAL_LOCAL, then on completion of the RMAs in the
+ * marked set, lval is written to memory at the address corresponding to offset
+ * loff in the local registered address space of epd. loff must be within a
+ * registered window. If flags includes SCIF_SIGNAL_REMOTE, then on completion
+ * of the RMAs in the marked set, rval is written to memory at the address
+ * corresponding to offset roff in the remote registered address space of epd.
+ * roff must be within a remote registered window of the peer of epd. Note
+ * that any specified offset must be DWORD (4 byte / 32 bit) aligned.
+ *
+ * The flags argument is formed by OR'ing together the following.
+ * Exactly one of the following values.
+ * SCIF_FENCE_INIT_SELF - RMA operations initiated through endpoint
+ *      epd are marked
+ * SCIF_FENCE_INIT_PEER - RMA operations initiated through the peer
+ *      of endpoint epd are marked
+ * One or more of the following values.
+ * SCIF_SIGNAL_LOCAL - On completion of the marked set of RMAs, write lval to
+ *      memory at the address corresponding to offset loff in the local
+ *      registered address space of epd.
+ * SCIF_SIGNAL_REMOTE - On completion of the marked set of RMAs, write rval to
+ *      memory at the address corresponding to offset roff in the remote
+ *      registered address space of epd.
+ *
+ * Return:
+ * Upon successful completion, scif_fence_signal() returns 0; otherwise in
+ * user mode -1 is returned and errno is set to indicate the error; in kernel
+ * mode the negative of one of the following errors is returned.
+ *
+ * Errors:
+ * EBADF, ENOTTY - epd is not a valid endpoint descriptor
+ * ECONNRESET - Connection reset by peer
+ * EINVAL - flags is invalid, or loff or roff are not DWORD aligned
+ * ENODEV - The remote node is lost or existed, but is not currently in the
+ * network since it may have crashed
+ * ENOTCONN - The endpoint is not connected
+ * ENXIO - loff is invalid for the registered address of epd, or roff is invalid
+ * for the registered address space, of the peer of epd
+ */
+int scif_fence_signal(scif_epd_t epd, off_t loff, u64 lval, off_t roff,
+                      u64 rval, int flags);
+
+/**
+ * scif_get_node_ids() - Return information about online nodes
+ * @nodes:      array in which to return online node IDs
+ * @len:        number of entries in the nodes array
+ * @self:       address to place the node ID of the local node
+ *
+ * scif_get_node_ids() fills in the nodes array with up to len node IDs of the
+ * nodes in the SCIF network. If there is not enough space in nodes, as
+ * indicated by the len parameter, only len node IDs are returned in nodes. The
+ * return value of scif_get_node_ids() is the total number of nodes currently in
+ * the SCIF network. By checking the return value against the len parameter,
+ * the user may determine if enough space for nodes was allocated.
+ *
+ * The node ID of the local node is returned at self.
+ *
+ * Return:
+ * Upon successful completion, scif_get_node_ids() returns the actual number of
+ * online nodes in the SCIF network including 'self'; otherwise in user mode
+ * -1 is returned and errno is set to indicate the error; in kernel mode no
+ * errors are returned.
+ *
+ * Errors:
+ * EFAULT - Bad address
+ */
+int scif_get_node_ids(u16 *nodes, int len, u16 *self);
+
+#endif /* __SCIF_H__ */
diff --git a/include/linux/security.h b/include/linux/security.h
index 52febde52479..79d85ddf8093 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -27,6 +27,7 @@
 #include <linux/slab.h>
 #include <linux/err.h>
 #include <linux/string.h>
+#include <linux/mm.h>
 
 struct linux_binprm;
 struct cred;
@@ -53,9 +54,6 @@ struct xattr;
 struct xfrm_sec_ctx;
 struct mm_struct;
 
-/* Maximum number of letters for an LSM name string */
-#define SECURITY_NAME_MAX       10
-
 /* If capable should audit the security request */
 #define SECURITY_CAP_NOAUDIT 0
 #define SECURITY_CAP_AUDIT 1
@@ -68,10 +66,7 @@ struct audit_krule;
 struct user_namespace;
 struct timezone;
 
-/*
- * These functions are in security/capability.c and are used
- * as the default capabilities functions
- */
+/* These functions are in security/commoncap.c */
 extern int cap_capable(const struct cred *cred, struct user_namespace *ns,
                        int cap, int audit);
 extern int cap_settime(const struct timespec *ts, const struct timezone *tz);
@@ -113,10 +108,6 @@ struct xfrm_state;
 struct xfrm_user_sec_ctx;
 struct seq_file;
 
-extern int cap_netlink_send(struct sock *sk, struct sk_buff *skb);
-
-void reset_security_ops(void);
-
 #ifdef CONFIG_MMU
 extern unsigned long mmap_min_addr;
 extern unsigned long dac_mmap_min_addr;
@@ -187,1583 +178,8 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
         opts->num_mnt_opts = 0;
 }
 
-/**
- * struct security_operations - main security structure
- *
- * Security module identifier.
- *
- * @name:
- *      A string that acts as a unique identifier for the LSM with max number
- *      of characters = SECURITY_NAME_MAX.
- *
- * Security hooks for program execution operations.
- *
- * @bprm_set_creds:
- *      Save security information in the bprm->security field, typically based
- *      on information about the bprm->file, for later use by the apply_creds
- *      hook.  This hook may also optionally check permissions (e.g. for
- *      transitions between security domains).
- *      This hook may be called multiple times during a single execve, e.g. for
- *      interpreters.  The hook can tell whether it has already been called by
- *      checking to see if @bprm->security is non-NULL.  If so, then the hook
- *      may decide either to retain the security information saved earlier or
- *      to replace it.
- *      @bprm contains the linux_binprm structure.
- *      Return 0 if the hook is successful and permission is granted.
- * @bprm_check_security:
- *      This hook mediates the point when a search for a binary handler will
- *      begin.  It allows a check the @bprm->security value which is set in the
- *      preceding set_creds call.  The primary difference from set_creds is
- *      that the argv list and envp list are reliably available in @bprm.  This
- *      hook may be called multiple times during a single execve; and in each
- *      pass set_creds is called first.
- *      @bprm contains the linux_binprm structure.
- *      Return 0 if the hook is successful and permission is granted.
- * @bprm_committing_creds:
- *      Prepare to install the new security attributes of a process being
- *      transformed by an execve operation, based on the old credentials
- *      pointed to by @current->cred and the information set in @bprm->cred by
- *      the bprm_set_creds hook.  @bprm points to the linux_binprm structure.
- *      This hook is a good place to perform state changes on the process such
- *      as closing open file descriptors to which access will no longer be
- *      granted when the attributes are changed.  This is called immediately
- *      before commit_creds().
- * @bprm_committed_creds:
- *      Tidy up after the installation of the new security attributes of a
- *      process being transformed by an execve operation.  The new credentials
- *      have, by this point, been set to @current->cred.  @bprm points to the
- *      linux_binprm structure.  This hook is a good place to perform state
- *      changes on the process such as clearing out non-inheritable signal
- *      state.  This is called immediately after commit_creds().
- * @bprm_secureexec:
- *      Return a boolean value (0 or 1) indicating whether a "secure exec"
- *      is required.  The flag is passed in the auxiliary table
- *      on the initial stack to the ELF interpreter to indicate whether libc
- *      should enable secure mode.
- *      @bprm contains the linux_binprm structure.
- *
- * Security hooks for filesystem operations.
- *
- * @sb_alloc_security:
- *      Allocate and attach a security structure to the sb->s_security field.
- *      The s_security field is initialized to NULL when the structure is
- *      allocated.
- *      @sb contains the super_block structure to be modified.
- *      Return 0 if operation was successful.
- * @sb_free_security:
- *      Deallocate and clear the sb->s_security field.
- *      @sb contains the super_block structure to be modified.
- * @sb_statfs:
- *      Check permission before obtaining filesystem statistics for the @mnt
- *      mountpoint.
- *      @dentry is a handle on the superblock for the filesystem.
- *      Return 0 if permission is granted.
- * @sb_mount:
- *      Check permission before an object specified by @dev_name is mounted on
- *      the mount point named by @nd.  For an ordinary mount, @dev_name
- *      identifies a device if the file system type requires a device.  For a
- *      remount (@flags & MS_REMOUNT), @dev_name is irrelevant.  For a
- *      loopback/bind mount (@flags & MS_BIND), @dev_name identifies the
- *      pathname of the object being mounted.
- *      @dev_name contains the name for object being mounted.
- *      @path contains the path for mount point object.
- *      @type contains the filesystem type.
- *      @flags contains the mount flags.
- *      @data contains the filesystem-specific data.
- *      Return 0 if permission is granted.
- * @sb_copy_data:
- *      Allow mount option data to be copied prior to parsing by the filesystem,
- *      so that the security module can extract security-specific mount
- *      options cleanly (a filesystem may modify the data e.g. with strsep()).
- *      This also allows the original mount data to be stripped of security-
- *      specific options to avoid having to make filesystems aware of them.
- *      @type the type of filesystem being mounted.
- *      @orig the original mount data copied from userspace.
- *      @copy copied data which will be passed to the security module.
- *      Returns 0 if the copy was successful.
- * @sb_remount:
- *      Extracts security system specific mount options and verifies no changes
- *      are being made to those options.
- *      @sb superblock being remounted
- *      @data contains the filesystem-specific data.
- *      Return 0 if permission is granted.
- * @sb_umount:
- *      Check permission before the @mnt file system is unmounted.
- *      @mnt contains the mounted file system.
- *      @flags contains the unmount flags, e.g. MNT_FORCE.
- *      Return 0 if permission is granted.
- * @sb_pivotroot:
- *      Check permission before pivoting the root filesystem.
- *      @old_path contains the path for the new location of the current root (put_old).
- *      @new_path contains the path for the new root (new_root).
- *      Return 0 if permission is granted.
- * @sb_set_mnt_opts:
- *      Set the security relevant mount options used for a superblock
- *      @sb the superblock to set security mount options for
- *      @opts binary data structure containing all lsm mount data
- * @sb_clone_mnt_opts:
- *      Copy all security options from a given superblock to another
- *      @oldsb old superblock which contain information to clone
- *      @newsb new superblock which needs filled in
- * @sb_parse_opts_str:
- *      Parse a string of security data filling in the opts structure
- *      @options string containing all mount options known by the LSM
- *      @opts binary data structure usable by the LSM
- * @dentry_init_security:
- *      Compute a context for a dentry as the inode is not yet available
- *      since NFSv4 has no label backed by an EA anyway.
- *      @dentry dentry to use in calculating the context.
- *      @mode mode used to determine resource type.
- *      @name name of the last path component used to create file
- *      @ctx pointer to place the pointer to the resulting context in.
- *      @ctxlen point to place the length of the resulting context.
- *
- *
- * Security hooks for inode operations.
- *
- * @inode_alloc_security:
- *      Allocate and attach a security structure to @inode->i_security.  The
- *      i_security field is initialized to NULL when the inode structure is
- *      allocated.
- *      @inode contains the inode structure.
- *      Return 0 if operation was successful.
- * @inode_free_security:
- *      @inode contains the inode structure.
- *      Deallocate the inode security structure and set @inode->i_security to
- *      NULL.
- * @inode_init_security:
- *      Obtain the security attribute name suffix and value to set on a newly
- *      created inode and set up the incore security field for the new inode.
- *      This hook is called by the fs code as part of the inode creation
- *      transaction and provides for atomic labeling of the inode, unlike
- *      the post_create/mkdir/... hooks called by the VFS.  The hook function
- *      is expected to allocate the name and value via kmalloc, with the caller
- *      being responsible for calling kfree after using them.
- *      If the security module does not use security attributes or does
- *      not wish to put a security attribute on this particular inode,
- *      then it should return -EOPNOTSUPP to skip this processing.
- *      @inode contains the inode structure of the newly created inode.
- *      @dir contains the inode structure of the parent directory.
- *      @qstr contains the last path component of the new object
- *      @name will be set to the allocated name suffix (e.g. selinux).
- *      @value will be set to the allocated attribute value.
- *      @len will be set to the length of the value.
- *      Returns 0 if @name and @value have been successfully set,
- *              -EOPNOTSUPP if no security attribute is needed, or
- *              -ENOMEM on memory allocation failure.
- * @inode_create:
- *      Check permission to create a regular file.
- *      @dir contains inode structure of the parent of the new file.
- *      @dentry contains the dentry structure for the file to be created.
- *      @mode contains the file mode of the file to be created.
- *      Return 0 if permission is granted.
- * @inode_link:
- *      Check permission before creating a new hard link to a file.
- *      @old_dentry contains the dentry structure for an existing link to the file.
- *      @dir contains the inode structure of the parent directory of the new link.
- *      @new_dentry contains the dentry structure for the new link.
- *      Return 0 if permission is granted.
- * @path_link:
- *      Check permission before creating a new hard link to a file.
- *      @old_dentry contains the dentry structure for an existing link
- *      to the file.
- *      @new_dir contains the path structure of the parent directory of
- *      the new link.
- *      @new_dentry contains the dentry structure for the new link.
- *      Return 0 if permission is granted.
- * @inode_unlink:
- *      Check the permission to remove a hard link to a file.
- *      @dir contains the inode structure of parent directory of the file.
- *      @dentry contains the dentry structure for file to be unlinked.
- *      Return 0 if permission is granted.
- * @path_unlink:
- *      Check the permission to remove a hard link to a file.
- *      @dir contains the path structure of parent directory of the file.
- *      @dentry contains the dentry structure for file to be unlinked.
- *      Return 0 if permission is granted.
- * @inode_symlink:
- *      Check the permission to create a symbolic link to a file.
- *      @dir contains the inode structure of parent directory of the symbolic link.
- *      @dentry contains the dentry structure of the symbolic link.
- *      @old_name contains the pathname of file.
- *      Return 0 if permission is granted.
- * @path_symlink:
- *      Check the permission to create a symbolic link to a file.
- *      @dir contains the path structure of parent directory of
- *      the symbolic link.
- *      @dentry contains the dentry structure of the symbolic link.
- *      @old_name contains the pathname of file.
- *      Return 0 if permission is granted.
- * @inode_mkdir:
- *      Check permissions to create a new directory in the existing directory
- *      associated with inode structure @dir.
- *      @dir contains the inode structure of parent of the directory to be created.
- *      @dentry contains the dentry structure of new directory.
- *      @mode contains the mode of new directory.
- *      Return 0 if permission is granted.
- * @path_mkdir:
- *      Check permissions to create a new directory in the existing directory
- *      associated with path structure @path.
- *      @dir contains the path structure of parent of the directory
- *      to be created.
- *      @dentry contains the dentry structure of new directory.
- *      @mode contains the mode of new directory.
- *      Return 0 if permission is granted.
- * @inode_rmdir:
- *      Check the permission to remove a directory.
- *      @dir contains the inode structure of parent of the directory to be removed.
- *      @dentry contains the dentry structure of directory to be removed.
- *      Return 0 if permission is granted.
- * @path_rmdir:
- *      Check the permission to remove a directory.
- *      @dir contains the path structure of parent of the directory to be
- *      removed.
- *      @dentry contains the dentry structure of directory to be removed.
- *      Return 0 if permission is granted.
- * @inode_mknod:
- *      Check permissions when creating a special file (or a socket or a fifo
- *      file created via the mknod system call).  Note that if mknod operation
- *      is being done for a regular file, then the create hook will be called
- *      and not this hook.
- *      @dir contains the inode structure of parent of the new file.
- *      @dentry contains the dentry structure of the new file.
- *      @mode contains the mode of the new file.
- *      @dev contains the device number.
- *      Return 0 if permission is granted.
- * @path_mknod:
- *      Check permissions when creating a file. Note that this hook is called
- *      even if mknod operation is being done for a regular file.
- *      @dir contains the path structure of parent of the new file.
- *      @dentry contains the dentry structure of the new file.
- *      @mode contains the mode of the new file.
- *      @dev contains the undecoded device number. Use new_decode_dev() to get
- *      the decoded device number.
- *      Return 0 if permission is granted.
- * @inode_rename:
- *      Check for permission to rename a file or directory.
- *      @old_dir contains the inode structure for parent of the old link.
- *      @old_dentry contains the dentry structure of the old link.
- *      @new_dir contains the inode structure for parent of the new link.
- *      @new_dentry contains the dentry structure of the new link.
- *      Return 0 if permission is granted.
- * @path_rename:
- *      Check for permission to rename a file or directory.
- *      @old_dir contains the path structure for parent of the old link.
- *      @old_dentry contains the dentry structure of the old link.
- *      @new_dir contains the path structure for parent of the new link.
- *      @new_dentry contains the dentry structure of the new link.
- *      Return 0 if permission is granted.
- * @path_chmod:
- *      Check for permission to change DAC's permission of a file or directory.
- *      @dentry contains the dentry structure.
- *      @mnt contains the vfsmnt structure.
- *      @mode contains DAC's mode.
- *      Return 0 if permission is granted.
- * @path_chown:
- *      Check for permission to change owner/group of a file or directory.
- *      @path contains the path structure.
- *      @uid contains new owner's ID.
- *      @gid contains new group's ID.
- *      Return 0 if permission is granted.
- * @path_chroot:
- *      Check for permission to change root directory.
- *      @path contains the path structure.
- *      Return 0 if permission is granted.
- * @inode_readlink:
- *      Check the permission to read the symbolic link.
- *      @dentry contains the dentry structure for the file link.
- *      Return 0 if permission is granted.
- * @inode_follow_link:
- *      Check permission to follow a symbolic link when looking up a pathname.
- *      @dentry contains the dentry structure for the link.
- *      @inode contains the inode, which itself is not stable in RCU-walk
- *      @rcu indicates whether we are in RCU-walk mode.
- *      Return 0 if permission is granted.
- * @inode_permission:
- *      Check permission before accessing an inode.  This hook is called by the
- *      existing Linux permission function, so a security module can use it to
- *      provide additional checking for existing Linux permission checks.
- *      Notice that this hook is called when a file is opened (as well as many
- *      other operations), whereas the file_security_ops permission hook is
- *      called when the actual read/write operations are performed.
- *      @inode contains the inode structure to check.
- *      @mask contains the permission mask.
- *      Return 0 if permission is granted.
- * @inode_setattr:
- *      Check permission before setting file attributes.  Note that the kernel
- *      call to notify_change is performed from several locations, whenever
- *      file attributes change (such as when a file is truncated, chown/chmod
- *      operations, transferring disk quotas, etc).
- *      @dentry contains the dentry structure for the file.
- *      @attr is the iattr structure containing the new file attributes.
- *      Return 0 if permission is granted.
- * @path_truncate:
- *      Check permission before truncating a file.
- *      @path contains the path structure for the file.
- *      Return 0 if permission is granted.
- * @inode_getattr:
- *      Check permission before obtaining file attributes.
- *      @mnt is the vfsmount where the dentry was looked up
- *      @dentry contains the dentry structure for the file.
- *      Return 0 if permission is granted.
- * @inode_setxattr:
- *      Check permission before setting the extended attributes
- *      @value identified by @name for @dentry.
- *      Return 0 if permission is granted.
- * @inode_post_setxattr:
- *      Update inode security field after successful setxattr operation.
- *      @value identified by @name for @dentry.
- * @inode_getxattr:
- *      Check permission before obtaining the extended attributes
- *      identified by @name for @dentry.
- *      Return 0 if permission is granted.
- * @inode_listxattr:
- *      Check permission before obtaining the list of extended attribute
- *      names for @dentry.
- *      Return 0 if permission is granted.
- * @inode_removexattr:
- *      Check permission before removing the extended attribute
- *      identified by @name for @dentry.
- *      Return 0 if permission is granted.
- * @inode_getsecurity:
- *      Retrieve a copy of the extended attribute representation of the
- *      security label associated with @name for @inode via @buffer.  Note that
- *      @name is the remainder of the attribute name after the security prefix
- *      has been removed. @alloc is used to specify of the call should return a
- *      value via the buffer or just the value length Return size of buffer on
- *      success.
- * @inode_setsecurity:
- *      Set the security label associated with @name for @inode from the
- *      extended attribute value @value.  @size indicates the size of the
- *      @value in bytes.  @flags may be XATTR_CREATE, XATTR_REPLACE, or 0.
- *      Note that @name is the remainder of the attribute name after the
- *      security. prefix has been removed.
- *      Return 0 on success.
- * @inode_listsecurity:
- *      Copy the extended attribute names for the security labels
- *      associated with @inode into @buffer.  The maximum size of @buffer
- *      is specified by @buffer_size.  @buffer may be NULL to request
- *      the size of the buffer required.
- *      Returns number of bytes used/required on success.
- * @inode_need_killpriv:
- *      Called when an inode has been changed.
- *      @dentry is the dentry being changed.
- *      Return <0 on error to abort the inode change operation.
- *      Return 0 if inode_killpriv does not need to be called.
- *      Return >0 if inode_killpriv does need to be called.
- * @inode_killpriv:
- *      The setuid bit is being removed.  Remove similar security labels.
- *      Called with the dentry->d_inode->i_mutex held.
- *      @dentry is the dentry being changed.
- *      Return 0 on success.  If error is returned, then the operation
- *      causing setuid bit removal is failed.
- * @inode_getsecid:
- *      Get the secid associated with the node.
- *      @inode contains a pointer to the inode.
- *      @secid contains a pointer to the location where result will be saved.
- *      In case of failure, @secid will be set to zero.
- *
- * Security hooks for file operations
- *
- * @file_permission:
- *      Check file permissions before accessing an open file.  This hook is
- *      called by various operations that read or write files.  A security
- *      module can use this hook to perform additional checking on these
- *      operations, e.g.  to revalidate permissions on use to support privilege
- *      bracketing or policy changes.  Notice that this hook is used when the
- *      actual read/write operations are performed, whereas the
- *      inode_security_ops hook is called when a file is opened (as well as
- *      many other operations).
- *      Caveat:  Although this hook can be used to revalidate permissions for
- *      various system call operations that read or write files, it does not
- *      address the revalidation of permissions for memory-mapped files.
- *      Security modules must handle this separately if they need such
- *      revalidation.
- *      @file contains the file structure being accessed.
- *      @mask contains the requested permissions.
- *      Return 0 if permission is granted.
- * @file_alloc_security:
- *      Allocate and attach a security structure to the file->f_security field.
- *      The security field is initialized to NULL when the structure is first
- *      created.
- *      @file contains the file structure to secure.
- *      Return 0 if the hook is successful and permission is granted.
- * @file_free_security:
- *      Deallocate and free any security structures stored in file->f_security.
- *      @file contains the file structure being modified.
- * @file_ioctl:
- *      @file contains the file structure.
- *      @cmd contains the operation to perform.
- *      @arg contains the operational arguments.
- *      Check permission for an ioctl operation on @file.  Note that @arg
- *      sometimes represents a user space pointer; in other cases, it may be a
- *      simple integer value.  When @arg represents a user space pointer, it
- *      should never be used by the security module.
- *      Return 0 if permission is granted.
- * @mmap_addr :
- *      Check permissions for a mmap operation at @addr.
- *      @addr contains virtual address that will be used for the operation.
- *      Return 0 if permission is granted.
- * @mmap_file :
- *      Check permissions for a mmap operation.  The @file may be NULL, e.g.
- *      if mapping anonymous memory.
- *      @file contains the file structure for file to map (may be NULL).
- *      @reqprot contains the protection requested by the application.
- *      @prot contains the protection that will be applied by the kernel.
- *      @flags contains the operational flags.
- *      Return 0 if permission is granted.
- * @file_mprotect:
- *      Check permissions before changing memory access permissions.
- *      @vma contains the memory region to modify.
- *      @reqprot contains the protection requested by the application.
- *      @prot contains the protection that will be applied by the kernel.
- *      Return 0 if permission is granted.
- * @file_lock:
- *      Check permission before performing file locking operations.
- *      Note: this hook mediates both flock and fcntl style locks.
- *      @file contains the file structure.
- *      @cmd contains the posix-translated lock operation to perform
- *      (e.g. F_RDLCK, F_WRLCK).
- *      Return 0 if permission is granted.
- * @file_fcntl:
- *      Check permission before allowing the file operation specified by @cmd
- *      from being performed on the file @file.  Note that @arg sometimes
- *      represents a user space pointer; in other cases, it may be a simple
- *      integer value.  When @arg represents a user space pointer, it should
- *      never be used by the security module.
- *      @file contains the file structure.
- *      @cmd contains the operation to be performed.
- *      @arg contains the operational arguments.
- *      Return 0 if permission is granted.
- * @file_set_fowner:
- *      Save owner security information (typically from current->security) in
- *      file->f_security for later use by the send_sigiotask hook.
- *      @file contains the file structure to update.
- *      Return 0 on success.
- * @file_send_sigiotask:
- *      Check permission for the file owner @fown to send SIGIO or SIGURG to the
- *      process @tsk.  Note that this hook is sometimes called from interrupt.
- *      Note that the fown_struct, @fown, is never outside the context of a
- *      struct file, so the file structure (and associated security information)
- *      can always be obtained:
- *              container_of(fown, struct file, f_owner)
- *      @tsk contains the structure of task receiving signal.
- *      @fown contains the file owner information.
- *      @sig is the signal that will be sent.  When 0, kernel sends SIGIO.
- *      Return 0 if permission is granted.
- * @file_receive:
- *      This hook allows security modules to control the ability of a process
- *      to receive an open file descriptor via socket IPC.
- *      @file contains the file structure being received.
- *      Return 0 if permission is granted.
- * @file_open
- *      Save open-time permission checking state for later use upon
- *      file_permission, and recheck access if anything has changed
- *      since inode_permission.
- *
- * Security hooks for task operations.
- *
- * @task_create:
- *      Check permission before creating a child process.  See the clone(2)
- *      manual page for definitions of the @clone_flags.
- *      @clone_flags contains the flags indicating what should be shared.
- *      Return 0 if permission is granted.
- * @task_free:
- *      @task task being freed
- *      Handle release of task-related resources. (Note that this can be called
- *      from interrupt context.)
- * @cred_alloc_blank:
- *      @cred points to the credentials.
- *      @gfp indicates the atomicity of any memory allocations.
- *      Only allocate sufficient memory and attach to @cred such that
- *      cred_transfer() will not get ENOMEM.
- * @cred_free:
- *      @cred points to the credentials.
- *      Deallocate and clear the cred->security field in a set of credentials.
- * @cred_prepare:
- *      @new points to the new credentials.
- *      @old points to the original credentials.
- *      @gfp indicates the atomicity of any memory allocations.
- *      Prepare a new set of credentials by copying the data from the old set.
- * @cred_transfer:
- *      @new points to the new credentials.
- *      @old points to the original credentials.
- *      Transfer data from original creds to new creds
- * @kernel_act_as:
- *      Set the credentials for a kernel service to act as (subjective context).
- *      @new points to the credentials to be modified.
- *      @secid specifies the security ID to be set
- *      The current task must be the one that nominated @secid.
- *      Return 0 if successful.
- * @kernel_create_files_as:
- *      Set the file creation context in a set of credentials to be the same as
- *      the objective context of the specified inode.
- *      @new points to the credentials to be modified.
- *      @inode points to the inode to use as a reference.
- *      The current task must be the one that nominated @inode.
- *      Return 0 if successful.
- * @kernel_fw_from_file:
- *      Load firmware from userspace (not called for built-in firmware).
- *      @file contains the file structure pointing to the file containing
- *      the firmware to load. This argument will be NULL if the firmware
- *      was loaded via the uevent-triggered blob-based interface exposed
- *      by CONFIG_FW_LOADER_USER_HELPER.
- *      @buf pointer to buffer containing firmware contents.
- *      @size length of the firmware contents.
- *      Return 0 if permission is granted.
- * @kernel_module_request:
- *      Ability to trigger the kernel to automatically upcall to userspace for
- *      userspace to load a kernel module with the given name.
- *      @kmod_name name of the module requested by the kernel
- *      Return 0 if successful.
- * @kernel_module_from_file:
- *      Load a kernel module from userspace.
- *      @file contains the file structure pointing to the file containing
- *      the kernel module to load. If the module is being loaded from a blob,
- *      this argument will be NULL.
- *      Return 0 if permission is granted.
- * @task_fix_setuid:
- *      Update the module's state after setting one or more of the user
- *      identity attributes of the current process.  The @flags parameter
- *      indicates which of the set*uid system calls invoked this hook.  If
- *      @new is the set of credentials that will be installed.  Modifications
- *      should be made to this rather than to @current->cred.
- *      @old is the set of credentials that are being replaces
- *      @flags contains one of the LSM_SETID_* values.
- *      Return 0 on success.
- * @task_setpgid:
- *      Check permission before setting the process group identifier of the
- *      process @p to @pgid.
- *      @p contains the task_struct for process being modified.
- *      @pgid contains the new pgid.
- *      Return 0 if permission is granted.
- * @task_getpgid:
- *      Check permission before getting the process group identifier of the
- *      process @p.
- *      @p contains the task_struct for the process.
- *      Return 0 if permission is granted.
- * @task_getsid:
- *      Check permission before getting the session identifier of the process
- *      @p.
- *      @p contains the task_struct for the process.
- *      Return 0 if permission is granted.
- * @task_getsecid:
- *      Retrieve the security identifier of the process @p.
- *      @p contains the task_struct for the process and place is into @secid.
- *      In case of failure, @secid will be set to zero.
- *
- * @task_setnice:
- *      Check permission before setting the nice value of @p to @nice.
- *      @p contains the task_struct of process.
- *      @nice contains the new nice value.
- *      Return 0 if permission is granted.
- * @task_setioprio
- *      Check permission before setting the ioprio value of @p to @ioprio.
- *      @p contains the task_struct of process.
- *      @ioprio contains the new ioprio value
- *      Return 0 if permission is granted.
- * @task_getioprio
- *      Check permission before getting the ioprio value of @p.
- *      @p contains the task_struct of process.
- *      Return 0 if permission is granted.
- * @task_setrlimit:
- *      Check permission before setting the resource limits of the current
- *      process for @resource to @new_rlim.  The old resource limit values can
- *      be examined by dereferencing (current->signal->rlim + resource).
- *      @resource contains the resource whose limit is being set.
- *      @new_rlim contains the new limits for @resource.
- *      Return 0 if permission is granted.
- * @task_setscheduler:
- *      Check permission before setting scheduling policy and/or parameters of
- *      process @p based on @policy and @lp.
- *      @p contains the task_struct for process.
- *      @policy contains the scheduling policy.
- *      @lp contains the scheduling parameters.
- *      Return 0 if permission is granted.
- * @task_getscheduler:
- *      Check permission before obtaining scheduling information for process
- *      @p.
- *      @p contains the task_struct for process.
- *      Return 0 if permission is granted.
- * @task_movememory
- *      Check permission before moving memory owned by process @p.
- *      @p contains the task_struct for process.
- *      Return 0 if permission is granted.
- * @task_kill:
- *      Check permission before sending signal @sig to @p.  @info can be NULL,
- *      the constant 1, or a pointer to a siginfo structure.  If @info is 1 or
- *      SI_FROMKERNEL(info) is true, then the signal should be viewed as coming
- *      from the kernel and should typically be permitted.
- *      SIGIO signals are handled separately by the send_sigiotask hook in
- *      file_security_ops.
- *      @p contains the task_struct for process.
- *      @info contains the signal information.
- *      @sig contains the signal value.
- *      @secid contains the sid of the process where the signal originated
- *      Return 0 if permission is granted.
- * @task_wait:
- *      Check permission before allowing a process to reap a child process @p
- *      and collect its status information.
- *      @p contains the task_struct for process.
- *      Return 0 if permission is granted.
- * @task_prctl:
- *      Check permission before performing a process control operation on the
- *      current process.
- *      @option contains the operation.
- *      @arg2 contains a argument.
- *      @arg3 contains a argument.
- *      @arg4 contains a argument.
- *      @arg5 contains a argument.
- *      Return -ENOSYS if no-one wanted to handle this op, any other value to
- *      cause prctl() to return immediately with that value.
- * @task_to_inode:
- *      Set the security attributes for an inode based on an associated task's
- *      security attributes, e.g. for /proc/pid inodes.
- *      @p contains the task_struct for the task.
- *      @inode contains the inode structure for the inode.
- *
- * Security hooks for Netlink messaging.
- *
- * @netlink_send:
- *      Save security information for a netlink message so that permission
- *      checking can be performed when the message is processed.  The security
- *      information can be saved using the eff_cap field of the
- *      netlink_skb_parms structure.  Also may be used to provide fine
- *      grained control over message transmission.
- *      @sk associated sock of task sending the message.
- *      @skb contains the sk_buff structure for the netlink message.
- *      Return 0 if the information was successfully saved and message
- *      is allowed to be transmitted.
- *
- * Security hooks for Unix domain networking.
- *
- * @unix_stream_connect:
- *      Check permissions before establishing a Unix domain stream connection
- *      between @sock and @other.
- *      @sock contains the sock structure.
- *      @other contains the peer sock structure.
- *      @newsk contains the new sock structure.
- *      Return 0 if permission is granted.
- * @unix_may_send:
- *      Check permissions before connecting or sending datagrams from @sock to
- *      @other.
- *      @sock contains the 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
- * Linux provides an alternative to the conventional file name space for Unix
- * domain sockets.  Whereas binding and connecting to sockets in the file name
- * space is mediated by the typical file permissions (and caught by the mknod
- * and permission hooks in inode_security_ops), binding and connecting to
- * sockets in the abstract name space is completely unmediated.  Sufficient
- * control of Unix domain sockets in the abstract name space isn't possible
- * using only the socket layer hooks, since we need to know the actual target
- * socket, which is not looked up until we are inside the af_unix code.
- *
- * Security hooks for socket operations.
- *
- * @socket_create:
- *      Check permissions prior to creating a new socket.
- *      @family contains the requested protocol family.
- *      @type contains the requested communications type.
- *      @protocol contains the requested protocol.
- *      @kern set to 1 if a kernel socket.
- *      Return 0 if permission is granted.
- * @socket_post_create:
- *      This hook allows a module to update or allocate a per-socket security
- *      structure. Note that the security field was not added directly to the
- *      socket structure, but rather, the socket security information is stored
- *      in the associated inode.  Typically, the inode alloc_security hook will
- *      allocate and and attach security information to
- *      sock->inode->i_security.  This hook may be used to update the
- *      sock->inode->i_security field with additional information that wasn't
- *      available when the inode was allocated.
- *      @sock contains the newly created socket structure.
- *      @family contains the requested protocol family.
- *      @type contains the requested communications type.
- *      @protocol contains the requested protocol.
- *      @kern set to 1 if a kernel socket.
- * @socket_bind:
- *      Check permission before socket protocol layer bind operation is
- *      performed and the socket @sock is bound to the address specified in the
- *      @address parameter.
- *      @sock contains the socket structure.
- *      @address contains the address to bind to.
- *      @addrlen contains the length of address.
- *      Return 0 if permission is granted.
- * @socket_connect:
- *      Check permission before socket protocol layer connect operation
- *      attempts to connect socket @sock to a remote address, @address.
- *      @sock contains the socket structure.
- *      @address contains the address of remote endpoint.
- *      @addrlen contains the length of address.
- *      Return 0 if permission is granted.
- * @socket_listen:
- *      Check permission before socket protocol layer listen operation.
- *      @sock contains the socket structure.
- *      @backlog contains the maximum length for the pending connection queue.
- *      Return 0 if permission is granted.
- * @socket_accept:
- *      Check permission before accepting a new connection.  Note that the new
- *      socket, @newsock, has been created and some information copied to it,
- *      but the accept operation has not actually been performed.
- *      @sock contains the listening socket structure.
- *      @newsock contains the newly created server socket for connection.
- *      Return 0 if permission is granted.
- * @socket_sendmsg:
- *      Check permission before transmitting a message to another socket.
- *      @sock contains the socket structure.
- *      @msg contains the message to be transmitted.
- *      @size contains the size of message.
- *      Return 0 if permission is granted.
- * @socket_recvmsg:
- *      Check permission before receiving a message from a socket.
- *      @sock contains the socket structure.
- *      @msg contains the message structure.
- *      @size contains the size of message structure.
- *      @flags contains the operational flags.
- *      Return 0 if permission is granted.
- * @socket_getsockname:
- *      Check permission before the local address (name) of the socket object
- *      @sock is retrieved.
- *      @sock contains the socket structure.
- *      Return 0 if permission is granted.
- * @socket_getpeername:
- *      Check permission before the remote address (name) of a socket object
- *      @sock is retrieved.
- *      @sock contains the socket structure.
- *      Return 0 if permission is granted.
- * @socket_getsockopt:
- *      Check permissions before retrieving the options associated with socket
- *      @sock.
- *      @sock contains the socket structure.
- *      @level contains the protocol level to retrieve option from.
- *      @optname contains the name of option to retrieve.
- *      Return 0 if permission is granted.
- * @socket_setsockopt:
- *      Check permissions before setting the options associated with socket
- *      @sock.
- *      @sock contains the socket structure.
- *      @level contains the protocol level to set options for.
- *      @optname contains the name of the option to set.
- *      Return 0 if permission is granted.
- * @socket_shutdown:
- *      Checks permission before all or part of a connection on the socket
- *      @sock is shut down.
- *      @sock contains the socket structure.
- *      @how contains the flag indicating how future sends and receives are handled.
- *      Return 0 if permission is granted.
- * @socket_sock_rcv_skb:
- *      Check permissions on incoming network packets.  This hook is distinct
- *      from Netfilter's IP input hooks since it is the first time that the
- *      incoming sk_buff @skb has been associated with a particular socket, @sk.
- *      Must not sleep inside this hook because some callers hold spinlocks.
- *      @sk contains the sock (not socket) associated with the incoming sk_buff.
- *      @skb contains the incoming network data.
- * @socket_getpeersec_stream:
- *      This hook allows the security module to provide peer socket security
- *      state for unix or connected tcp sockets to userspace via getsockopt
- *      SO_GETPEERSEC.  For tcp sockets this can be meaningful if the
- *      socket is associated with an ipsec SA.
- *      @sock is the local socket.
- *      @optval userspace memory where the security state is to be copied.
- *      @optlen userspace int where the module should copy the actual length
- *      of the security state.
- *      @len as input is the maximum length to copy to userspace provided
- *      by the caller.
- *      Return 0 if all is well, otherwise, typical getsockopt return
- *      values.
- * @socket_getpeersec_dgram:
- *      This hook allows the security module to provide peer socket security
- *      state for udp sockets on a per-packet basis to userspace via
- *      getsockopt SO_GETPEERSEC.  The application must first have indicated
- *      the IP_PASSSEC option via getsockopt.  It can then retrieve the
- *      security state returned by this hook for a packet via the SCM_SECURITY
- *      ancillary message type.
- *      @skb is the skbuff for the packet being queried
- *      @secdata is a pointer to a buffer in which to copy the security data
- *      @seclen is the maximum length for @secdata
- *      Return 0 on success, error on failure.
- * @sk_alloc_security:
- *      Allocate and attach a security structure to the sk->sk_security field,
- *      which is used to copy security attributes between local stream sockets.
- * @sk_free_security:
- *      Deallocate security structure.
- * @sk_clone_security:
- *      Clone/copy security structure.
- * @sk_getsecid:
- *      Retrieve the LSM-specific secid for the sock to enable caching of network
- *      authorizations.
- * @sock_graft:
- *      Sets the socket's isec sid to the sock's sid.
- * @inet_conn_request:
- *      Sets the openreq's sid to socket's sid with MLS portion taken from peer sid.
- * @inet_csk_clone:
- *      Sets the new child socket's sid to the openreq sid.
- * @inet_conn_established:
- *      Sets the connection's peersid to the secmark on skb.
- * @secmark_relabel_packet:
- *      check if the process should be allowed to relabel packets to the given secid
- * @security_secmark_refcount_inc
- *      tells the LSM to increment the number of secmark labeling rules loaded
- * @security_secmark_refcount_dec
- *      tells the LSM to decrement the number of secmark labeling rules loaded
- * @req_classify_flow:
- *      Sets the flow's sid to the openreq sid.
- * @tun_dev_alloc_security:
- *      This hook allows a module to allocate a security structure for a TUN
- *      device.
- *      @security pointer to a security structure pointer.
- *      Returns a zero on success, negative values on failure.
- * @tun_dev_free_security:
- *      This hook allows a module to free the security structure for a TUN
- *      device.
- *      @security pointer to the TUN device's security structure
- * @tun_dev_create:
- *      Check permissions prior to creating a new TUN device.
- * @tun_dev_attach_queue:
- *      Check permissions prior to attaching to a TUN device queue.
- *      @security pointer to the TUN device's security structure.
- * @tun_dev_attach:
- *      This hook can be used by the module to update any security state
- *      associated with the TUN device's sock structure.
- *      @sk contains the existing sock structure.
- *      @security pointer to the TUN device's security structure.
- * @tun_dev_open:
- *      This hook can be used by the module to update any security state
- *      associated with the TUN device's security structure.
- *      @security pointer to the TUN devices's security structure.
- * @skb_owned_by:
- *      This hook sets the packet's owning sock.
- *      @skb is the packet.
- *      @sk the sock which owns the packet.
- *
- * Security hooks for XFRM operations.
- *
- * @xfrm_policy_alloc_security:
- *      @ctxp is a pointer to the xfrm_sec_ctx being added to Security Policy
- *      Database used by the XFRM system.
- *      @sec_ctx contains the security context information being provided by
- *      the user-level policy update program (e.g., setkey).
- *      Allocate a security structure to the xp->security field; the security
- *      field is initialized to NULL when the xfrm_policy is allocated.
- *      Return 0 if operation was successful (memory to allocate, legal context)
- *      @gfp is to specify the context for the allocation
- * @xfrm_policy_clone_security:
- *      @old_ctx contains an existing xfrm_sec_ctx.
- *      @new_ctxp contains a new xfrm_sec_ctx being cloned from old.
- *      Allocate a security structure in new_ctxp that contains the
- *      information from the old_ctx structure.
- *      Return 0 if operation was successful (memory to allocate).
- * @xfrm_policy_free_security:
- *      @ctx contains the xfrm_sec_ctx
- *      Deallocate xp->security.
- * @xfrm_policy_delete_security:
- *      @ctx contains the xfrm_sec_ctx.
- *      Authorize deletion of xp->security.
- * @xfrm_state_alloc:
- *      @x contains the xfrm_state being added to the Security Association
- *      Database by the XFRM system.
- *      @sec_ctx contains the security context information being provided by
- *      the user-level SA generation program (e.g., setkey or racoon).
- *      Allocate a security structure to the x->security field; the security
- *      field is initialized to NULL when the xfrm_state is allocated. Set the
- *      context to correspond to sec_ctx. Return 0 if operation was successful
- *      (memory to allocate, legal context).
- * @xfrm_state_alloc_acquire:
- *      @x contains the xfrm_state being added to the Security Association
- *      Database by the XFRM system.
- *      @polsec contains the policy's security context.
- *      @secid contains the secid from which to take the mls portion of the
- *      context.
- *      Allocate a security structure to the x->security field; the security
- *      field is initialized to NULL when the xfrm_state is allocated. Set the
- *      context to correspond to secid. Return 0 if operation was successful
- *      (memory to allocate, legal context).
- * @xfrm_state_free_security:
- *      @x contains the xfrm_state.
- *      Deallocate x->security.
- * @xfrm_state_delete_security:
- *      @x contains the xfrm_state.
- *      Authorize deletion of x->security.
- * @xfrm_policy_lookup:
- *      @ctx contains the xfrm_sec_ctx for which the access control is being
- *      checked.
- *      @fl_secid contains the flow security label that is used to authorize
- *      access to the policy xp.
- *      @dir contains the direction of the flow (input or output).
- *      Check permission when a flow selects a xfrm_policy for processing
- *      XFRMs on a packet.  The hook is called when selecting either a
- *      per-socket policy or a generic xfrm policy.
- *      Return 0 if permission is granted, -ESRCH otherwise, or -errno
- *      on other errors.
- * @xfrm_state_pol_flow_match:
- *      @x contains the state to match.
- *      @xp contains the policy to check for a match.
- *      @fl contains the flow to check for a match.
- *      Return 1 if there is a match.
- * @xfrm_decode_session:
- *      @skb points to skb to decode.
- *      @secid points to the flow key secid to set.
- *      @ckall says if all xfrms used should be checked for same secid.
- *      Return 0 if ckall is zero or all xfrms used have the same secid.
- *
- * Security hooks affecting all Key Management operations
- *
- * @key_alloc:
- *      Permit allocation of a key and assign security data. Note that key does
- *      not have a serial number assigned at this point.
- *      @key points to the key.
- *      @flags is the allocation flags
- *      Return 0 if permission is granted, -ve error otherwise.
- * @key_free:
- *      Notification of destruction; free security data.
- *      @key points to the key.
- *      No return value.
- * @key_permission:
- *      See whether a specific operational right is granted to a process on a
- *      key.
- *      @key_ref refers to the key (key pointer + possession attribute bit).
- *      @cred points to the credentials to provide the context against which to
- *      evaluate the security data on the key.
- *      @perm describes the combination of permissions required of this key.
- *      Return 0 if permission is granted, -ve error otherwise.
- * @key_getsecurity:
- *      Get a textual representation of the security context attached to a key
- *      for the purposes of honouring KEYCTL_GETSECURITY.  This function
- *      allocates the storage for the NUL-terminated string and the caller
- *      should free it.
- *      @key points to the key to be queried.
- *      @_buffer points to a pointer that should be set to point to the
- *      resulting string (if no label or an error occurs).
- *      Return the length of the string (including terminating NUL) or -ve if
- *      an error.
- *      May also return 0 (and a NULL buffer pointer) if there is no label.
- *
- * Security hooks affecting all System V IPC operations.
- *
- * @ipc_permission:
- *      Check permissions for access to IPC
- *      @ipcp contains the kernel IPC permission structure
- *      @flag contains the desired (requested) permission set
- *      Return 0 if permission is granted.
- * @ipc_getsecid:
- *      Get the secid associated with the ipc object.
- *      @ipcp contains the kernel IPC permission structure.
- *      @secid contains a pointer to the location where result will be saved.
- *      In case of failure, @secid will be set to zero.
- *
- * Security hooks for individual messages held in System V IPC message queues
- * @msg_msg_alloc_security:
- *      Allocate and attach a security structure to the msg->security field.
- *      The security field is initialized to NULL when the structure is first
- *      created.
- *      @msg contains the message structure to be modified.
- *      Return 0 if operation was successful and permission is granted.
- * @msg_msg_free_security:
- *      Deallocate the security structure for this message.
- *      @msg contains the message structure to be modified.
- *
- * Security hooks for System V IPC Message Queues
- *
- * @msg_queue_alloc_security:
- *      Allocate and attach a security structure to the
- *      msq->q_perm.security field. The security field is initialized to
- *      NULL when the structure is first created.
- *      @msq contains the message queue structure to be modified.
- *      Return 0 if operation was successful and permission is granted.
- * @msg_queue_free_security:
- *      Deallocate security structure for this message queue.
- *      @msq contains the message queue structure to be modified.
- * @msg_queue_associate:
- *      Check permission when a message queue is requested through the
- *      msgget system call.  This hook is only called when returning the
- *      message queue identifier for an existing message queue, not when a
- *      new message queue is created.
- *      @msq contains the message queue to act upon.
- *      @msqflg contains the operation control flags.
- *      Return 0 if permission is granted.
- * @msg_queue_msgctl:
- *      Check permission when a message control operation specified by @cmd
- *      is to be performed on the message queue @msq.
- *      The @msq may be NULL, e.g. for IPC_INFO or MSG_INFO.
- *      @msq contains the message queue to act upon.  May be NULL.
- *      @cmd contains the operation to be performed.
- *      Return 0 if permission is granted.
- * @msg_queue_msgsnd:
- *      Check permission before a message, @msg, is enqueued on the message
- *      queue, @msq.
- *      @msq contains the message queue to send message to.
- *      @msg contains the message to be enqueued.
- *      @msqflg contains operational flags.
- *      Return 0 if permission is granted.
- * @msg_queue_msgrcv:
- *      Check permission before a message, @msg, is removed from the message
- *      queue, @msq.  The @target task structure contains a pointer to the
- *      process that will be receiving the message (not equal to the current
- *      process when inline receives are being performed).
- *      @msq contains the message queue to retrieve message from.
- *      @msg contains the message destination.
- *      @target contains the task structure for recipient process.
- *      @type contains the type of message requested.
- *      @mode contains the operational flags.
- *      Return 0 if permission is granted.
- *
- * Security hooks for System V Shared Memory Segments
- *
- * @shm_alloc_security:
- *      Allocate and attach a security structure to the shp->shm_perm.security
- *      field.  The security field is initialized to NULL when the structure is
- *      first created.
- *      @shp contains the shared memory structure to be modified.
- *      Return 0 if operation was successful and permission is granted.
- * @shm_free_security:
- *      Deallocate the security struct for this memory segment.
- *      @shp contains the shared memory structure to be modified.
- * @shm_associate:
- *      Check permission when a shared memory region is requested through the
- *      shmget system call.  This hook is only called when returning the shared
- *      memory region identifier for an existing region, not when a new shared
- *      memory region is created.
- *      @shp contains the shared memory structure to be modified.
- *      @shmflg contains the operation control flags.
- *      Return 0 if permission is granted.
- * @shm_shmctl:
- *      Check permission when a shared memory control operation specified by
- *      @cmd is to be performed on the shared memory region @shp.
- *      The @shp may be NULL, e.g. for IPC_INFO or SHM_INFO.
- *      @shp contains shared memory structure to be modified.
- *      @cmd contains the operation to be performed.
- *      Return 0 if permission is granted.
- * @shm_shmat:
- *      Check permissions prior to allowing the shmat system call to attach the
- *      shared memory segment @shp to the data segment of the calling process.
- *      The attaching address is specified by @shmaddr.
- *      @shp contains the shared memory structure to be modified.
- *      @shmaddr contains the address to attach memory region to.
- *      @shmflg contains the operational flags.
- *      Return 0 if permission is granted.
- *
- * Security hooks for System V Semaphores
- *
- * @sem_alloc_security:
- *      Allocate and attach a security structure to the sma->sem_perm.security
- *      field.  The security field is initialized to NULL when the structure is
- *      first created.
- *      @sma contains the semaphore structure
- *      Return 0 if operation was successful and permission is granted.
- * @sem_free_security:
- *      deallocate security struct for this semaphore
- *      @sma contains the semaphore structure.
- * @sem_associate:
- *      Check permission when a semaphore is requested through the semget
- *      system call.  This hook is only called when returning the semaphore
- *      identifier for an existing semaphore, not when a new one must be
- *      created.
- *      @sma contains the semaphore structure.
- *      @semflg contains the operation control flags.
- *      Return 0 if permission is granted.
- * @sem_semctl:
- *      Check permission when a semaphore operation specified by @cmd is to be
- *      performed on the semaphore @sma.  The @sma may be NULL, e.g. for
- *      IPC_INFO or SEM_INFO.
- *      @sma contains the semaphore structure.  May be NULL.
- *      @cmd contains the operation to be performed.
- *      Return 0 if permission is granted.
- * @sem_semop
- *      Check permissions before performing operations on members of the
- *      semaphore set @sma.  If the @alter flag is nonzero, the semaphore set
- *      may be modified.
- *      @sma contains the semaphore structure.
- *      @sops contains the operations to perform.
- *      @nsops contains the number of operations to perform.
- *      @alter contains the flag indicating whether changes are to be made.
- *      Return 0 if permission is granted.
- *
- * @binder_set_context_mgr
- *      Check whether @mgr is allowed to be the binder context manager.
- *      @mgr contains the task_struct for the task being registered.
- *      Return 0 if permission is granted.
- * @binder_transaction
- *      Check whether @from is allowed to invoke a binder transaction call
- *      to @to.
- *      @from contains the task_struct for the sending task.
- *      @to contains the task_struct for the receiving task.
- * @binder_transfer_binder
- *      Check whether @from is allowed to transfer a binder reference to @to.
- *      @from contains the task_struct for the sending task.
- *      @to contains the task_struct for the receiving task.
- * @binder_transfer_file
- *      Check whether @from is allowed to transfer @file to @to.
- *      @from contains the task_struct for the sending task.
- *      @file contains the struct file being transferred.
- *      @to contains the task_struct for the receiving task.
- *
- * @ptrace_access_check:
- *      Check permission before allowing the current process to trace the
- *      @child process.
- *      Security modules may also want to perform a process tracing check
- *      during an execve in the set_security or apply_creds hooks of
- *      tracing check during an execve in the bprm_set_creds hook of
- *      binprm_security_ops if the process is being traced and its security
- *      attributes would be changed by the execve.
- *      @child contains the task_struct structure for the target process.
- *      @mode contains the PTRACE_MODE flags indicating the form of access.
- *      Return 0 if permission is granted.
- * @ptrace_traceme:
- *      Check that the @parent process has sufficient permission to trace the
- *      current process before allowing the current process to present itself
- *      to the @parent process for tracing.
- *      @parent contains the task_struct structure for debugger process.
- *      Return 0 if permission is granted.
- * @capget:
- *      Get the @effective, @inheritable, and @permitted capability sets for
- *      the @target process.  The hook may also perform permission checking to
- *      determine if the current process is allowed to see the capability sets
- *      of the @target process.
- *      @target contains the task_struct structure for target process.
- *      @effective contains the effective capability set.
- *      @inheritable contains the inheritable capability set.
- *      @permitted contains the permitted capability set.
- *      Return 0 if the capability sets were successfully obtained.
- * @capset:
- *      Set the @effective, @inheritable, and @permitted capability sets for
- *      the current process.
- *      @new contains the new credentials structure for target process.
- *      @old contains the current credentials structure for target process.
- *      @effective contains the effective capability set.
- *      @inheritable contains the inheritable capability set.
- *      @permitted contains the permitted capability set.
- *      Return 0 and update @new if permission is granted.
- * @capable:
- *      Check whether the @tsk process has the @cap capability in the indicated
- *      credentials.
- *      @cred contains the credentials to use.
- *      @ns contains the user namespace we want the capability in
- *      @cap contains the capability <include/linux/capability.h>.
- *      @audit: Whether to write an audit message or not
- *      Return 0 if the capability is granted for @tsk.
- * @syslog:
- *      Check permission before accessing the kernel message ring or changing
- *      logging to the console.
- *      See the syslog(2) manual page for an explanation of the @type values.
- *      @type contains the type of action.
- *      @from_file indicates the context of action (if it came from /proc).
- *      Return 0 if permission is granted.
- * @settime:
- *      Check permission to change the system time.
- *      struct timespec and timezone are defined in include/linux/time.h
- *      @ts contains new time
- *      @tz contains new timezone
- *      Return 0 if permission is granted.
- * @vm_enough_memory:
- *      Check permissions for allocating a new virtual mapping.
- *      @mm contains the mm struct it is being added to.
- *      @pages contains the number of pages.
- *      Return 0 if permission is granted.
- *
- * @ismaclabel:
- *      Check if the extended attribute specified by @name
- *      represents a MAC label. Returns 1 if name is a MAC
- *      attribute otherwise returns 0.
- *      @name full extended attribute name to check against
- *      LSM as a MAC label.
- *
- * @secid_to_secctx:
- *      Convert secid to security context.  If secdata is NULL the length of
- *      the result will be returned in seclen, but no secdata will be returned.
- *      This does mean that the length could change between calls to check the
- *      length and the next call which actually allocates and returns the secdata.
- *      @secid contains the security ID.
- *      @secdata contains the pointer that stores the converted security context.
- *      @seclen pointer which contains the length of the data
- * @secctx_to_secid:
- *      Convert security context to secid.
- *      @secid contains the pointer to the generated security ID.
- *      @secdata contains the security context.
- *
- * @release_secctx:
- *      Release the security context.
- *      @secdata contains the security context.
- *      @seclen contains the length of the security context.
- *
- * Security hooks for Audit
- *
- * @audit_rule_init:
- *      Allocate and initialize an LSM audit rule structure.
- *      @field contains the required Audit action. Fields flags are defined in include/linux/audit.h
- *      @op contains the operator the rule uses.
- *      @rulestr contains the context where the rule will be applied to.
- *      @lsmrule contains a pointer to receive the result.
- *      Return 0 if @lsmrule has been successfully set,
- *      -EINVAL in case of an invalid rule.
- *
- * @audit_rule_known:
- *      Specifies whether given @rule contains any fields related to current LSM.
- *      @rule contains the audit rule of interest.
- *      Return 1 in case of relation found, 0 otherwise.
- *
- * @audit_rule_match:
- *      Determine if given @secid matches a rule previously approved
- *      by @audit_rule_known.
- *      @secid contains the security id in question.
- *      @field contains the field which relates to current LSM.
- *      @op contains the operator that will be used for matching.
- *      @rule points to the audit rule that will be checked against.
- *      @actx points to the audit context associated with the check.
- *      Return 1 if secid matches the rule, 0 if it does not, -ERRNO on failure.
- *
- * @audit_rule_free:
- *      Deallocate the LSM audit rule structure previously allocated by
- *      audit_rule_init.
- *      @rule contains the allocated rule
- *
- * @inode_notifysecctx:
- *      Notify the security module of what the security context of an inode
- *      should be.  Initializes the incore security context managed by the
- *      security module for this inode.  Example usage:  NFS client invokes
- *      this hook to initialize the security context in its incore inode to the
- *      value provided by the server for the file when the server returned the
- *      file's attributes to the client.
- *
- *      Must be called with inode->i_mutex locked.
- *
- *      @inode we wish to set the security context of.
- *      @ctx contains the string which we wish to set in the inode.
- *      @ctxlen contains the length of @ctx.
- *
- * @inode_setsecctx:
- *      Change the security context of an inode.  Updates the
- *      incore security context managed by the security module and invokes the
- *      fs code as needed (via __vfs_setxattr_noperm) to update any backing
- *      xattrs that represent the context.  Example usage:  NFS server invokes
- *      this hook to change the security context in its incore inode and on the
- *      backing filesystem to a value provided by the client on a SETATTR
- *      operation.
- *
- *      Must be called with inode->i_mutex locked.
- *
- *      @dentry contains the inode we wish to set the security context of.
- *      @ctx contains the string which we wish to set in the inode.
- *      @ctxlen contains the length of @ctx.
- *
- * @inode_getsecctx:
- *      On success, returns 0 and fills out @ctx and @ctxlen with the security
- *      context for the given @inode.
- *
- *      @inode we wish to get the security context of.
- *      @ctx is a pointer in which to place the allocated security context.
- *      @ctxlen points to the place to put the length of @ctx.
- * This is the main security structure.
- */
-struct security_operations {
-        char name[SECURITY_NAME_MAX + 1];
-
-        int (*binder_set_context_mgr) (struct task_struct *mgr);
-        int (*binder_transaction) (struct task_struct *from,
-                                   struct task_struct *to);
-        int (*binder_transfer_binder) (struct task_struct *from,
-                                       struct task_struct *to);
-        int (*binder_transfer_file) (struct task_struct *from,
-                                     struct task_struct *to, struct file *file);
-
-        int (*ptrace_access_check) (struct task_struct *child, unsigned int mode);
-        int (*ptrace_traceme) (struct task_struct *parent);
-        int (*capget) (struct task_struct *target,
-                       kernel_cap_t *effective,
-                       kernel_cap_t *inheritable, kernel_cap_t *permitted);
-        int (*capset) (struct cred *new,
-                       const struct cred *old,
-                       const kernel_cap_t *effective,
-                       const kernel_cap_t *inheritable,
-                       const kernel_cap_t *permitted);
-        int (*capable) (const struct cred *cred, struct user_namespace *ns,
-                        int cap, int audit);
-        int (*quotactl) (int cmds, int type, int id, struct super_block *sb);
-        int (*quota_on) (struct dentry *dentry);
-        int (*syslog) (int type);
-        int (*settime) (const struct timespec *ts, const struct timezone *tz);
-        int (*vm_enough_memory) (struct mm_struct *mm, long pages);
-
-        int (*bprm_set_creds) (struct linux_binprm *bprm);
-        int (*bprm_check_security) (struct linux_binprm *bprm);
-        int (*bprm_secureexec) (struct linux_binprm *bprm);
-        void (*bprm_committing_creds) (struct linux_binprm *bprm);
-        void (*bprm_committed_creds) (struct linux_binprm *bprm);
-
-        int (*sb_alloc_security) (struct super_block *sb);
-        void (*sb_free_security) (struct super_block *sb);
-        int (*sb_copy_data) (char *orig, char *copy);
-        int (*sb_remount) (struct super_block *sb, void *data);
-        int (*sb_kern_mount) (struct super_block *sb, int flags, void *data);
-        int (*sb_show_options) (struct seq_file *m, struct super_block *sb);
-        int (*sb_statfs) (struct dentry *dentry);
-        int (*sb_mount) (const char *dev_name, struct path *path,
-                         const char *type, unsigned long flags, void *data);
-        int (*sb_umount) (struct vfsmount *mnt, int flags);
-        int (*sb_pivotroot) (struct path *old_path,
-                             struct path *new_path);
-        int (*sb_set_mnt_opts) (struct super_block *sb,
-                                struct security_mnt_opts *opts,
-                                unsigned long kern_flags,
-                                unsigned long *set_kern_flags);
-        int (*sb_clone_mnt_opts) (const struct super_block *oldsb,
-                                   struct super_block *newsb);
-        int (*sb_parse_opts_str) (char *options, struct security_mnt_opts *opts);
-        int (*dentry_init_security) (struct dentry *dentry, int mode,
-                                        struct qstr *name, void **ctx,
-                                        u32 *ctxlen);
-
-
-#ifdef CONFIG_SECURITY_PATH
-        int (*path_unlink) (struct path *dir, struct dentry *dentry);
-        int (*path_mkdir) (struct path *dir, struct dentry *dentry, umode_t mode);
-        int (*path_rmdir) (struct path *dir, struct dentry *dentry);
-        int (*path_mknod) (struct path *dir, struct dentry *dentry, umode_t mode,
-                           unsigned int dev);
-        int (*path_truncate) (struct path *path);
-        int (*path_symlink) (struct path *dir, struct dentry *dentry,
-                             const char *old_name);
-        int (*path_link) (struct dentry *old_dentry, struct path *new_dir,
-                          struct dentry *new_dentry);
-        int (*path_rename) (struct path *old_dir, struct dentry *old_dentry,
-                            struct path *new_dir, struct dentry *new_dentry);
-        int (*path_chmod) (struct path *path, umode_t mode);
-        int (*path_chown) (struct path *path, kuid_t uid, kgid_t gid);
-        int (*path_chroot) (struct path *path);
-#endif
-
-        int (*inode_alloc_security) (struct inode *inode);
-        void (*inode_free_security) (struct inode *inode);
-        int (*inode_init_security) (struct inode *inode, struct inode *dir,
-                                    const struct qstr *qstr, const char **name,
-                                    void **value, size_t *len);
-        int (*inode_create) (struct inode *dir,
-                             struct dentry *dentry, umode_t mode);
-        int (*inode_link) (struct dentry *old_dentry,
-                           struct inode *dir, struct dentry *new_dentry);
-        int (*inode_unlink) (struct inode *dir, struct dentry *dentry);
-        int (*inode_symlink) (struct inode *dir,
-                              struct dentry *dentry, const char *old_name);
-        int (*inode_mkdir) (struct inode *dir, struct dentry *dentry, umode_t mode);
-        int (*inode_rmdir) (struct inode *dir, struct dentry *dentry);
-        int (*inode_mknod) (struct inode *dir, struct dentry *dentry,
-                            umode_t mode, dev_t dev);
-        int (*inode_rename) (struct inode *old_dir, struct dentry *old_dentry,
-                             struct inode *new_dir, struct dentry *new_dentry);
-        int (*inode_readlink) (struct dentry *dentry);
-        int (*inode_follow_link) (struct dentry *dentry, struct inode *inode,
-                                  bool rcu);
-        int (*inode_permission) (struct inode *inode, int mask);
-        int (*inode_setattr)    (struct dentry *dentry, struct iattr *attr);
-        int (*inode_getattr) (const struct path *path);
-        int (*inode_setxattr) (struct dentry *dentry, const char *name,
-                               const void *value, size_t size, int flags);
-        void (*inode_post_setxattr) (struct dentry *dentry, const char *name,
-                                     const void *value, size_t size, int flags);
-        int (*inode_getxattr) (struct dentry *dentry, const char *name);
-        int (*inode_listxattr) (struct dentry *dentry);
-        int (*inode_removexattr) (struct dentry *dentry, const char *name);
-        int (*inode_need_killpriv) (struct dentry *dentry);
-        int (*inode_killpriv) (struct dentry *dentry);
-        int (*inode_getsecurity) (const struct inode *inode, const char *name, void **buffer, bool alloc);
-        int (*inode_setsecurity) (struct inode *inode, const char *name, const void *value, size_t size, int flags);
-        int (*inode_listsecurity) (struct inode *inode, char *buffer, size_t buffer_size);
-        void (*inode_getsecid) (const struct inode *inode, u32 *secid);
-
-        int (*file_permission) (struct file *file, int mask);
-        int (*file_alloc_security) (struct file *file);
-        void (*file_free_security) (struct file *file);
-        int (*file_ioctl) (struct file *file, unsigned int cmd,
-                           unsigned long arg);
-        int (*mmap_addr) (unsigned long addr);
-        int (*mmap_file) (struct file *file,
-                          unsigned long reqprot, unsigned long prot,
-                          unsigned long flags);
-        int (*file_mprotect) (struct vm_area_struct *vma,
-                              unsigned long reqprot,
-                              unsigned long prot);
-        int (*file_lock) (struct file *file, unsigned int cmd);
-        int (*file_fcntl) (struct file *file, unsigned int cmd,
-                           unsigned long arg);
-        void (*file_set_fowner) (struct file *file);
-        int (*file_send_sigiotask) (struct task_struct *tsk,
-                                    struct fown_struct *fown, int sig);
-        int (*file_receive) (struct file *file);
-        int (*file_open) (struct file *file, const struct cred *cred);
-
-        int (*task_create) (unsigned long clone_flags);
-        void (*task_free) (struct task_struct *task);
-        int (*cred_alloc_blank) (struct cred *cred, gfp_t gfp);
-        void (*cred_free) (struct cred *cred);
-        int (*cred_prepare)(struct cred *new, const struct cred *old,
-                            gfp_t gfp);
-        void (*cred_transfer)(struct cred *new, const struct cred *old);
-        int (*kernel_act_as)(struct cred *new, u32 secid);
-        int (*kernel_create_files_as)(struct cred *new, struct inode *inode);
-        int (*kernel_fw_from_file)(struct file *file, char *buf, size_t size);
-        int (*kernel_module_request)(char *kmod_name);
-        int (*kernel_module_from_file)(struct file *file);
-        int (*task_fix_setuid) (struct cred *new, const struct cred *old,
-                                int flags);
-        int (*task_setpgid) (struct task_struct *p, pid_t pgid);
-        int (*task_getpgid) (struct task_struct *p);
-        int (*task_getsid) (struct task_struct *p);
-        void (*task_getsecid) (struct task_struct *p, u32 *secid);
-        int (*task_setnice) (struct task_struct *p, int nice);
-        int (*task_setioprio) (struct task_struct *p, int ioprio);
-        int (*task_getioprio) (struct task_struct *p);
-        int (*task_setrlimit) (struct task_struct *p, unsigned int resource,
-                        struct rlimit *new_rlim);
-        int (*task_setscheduler) (struct task_struct *p);
-        int (*task_getscheduler) (struct task_struct *p);
-        int (*task_movememory) (struct task_struct *p);
-        int (*task_kill) (struct task_struct *p,
-                          struct siginfo *info, int sig, u32 secid);
-        int (*task_wait) (struct task_struct *p);
-        int (*task_prctl) (int option, unsigned long arg2,
-                           unsigned long arg3, unsigned long arg4,
-                           unsigned long arg5);
-        void (*task_to_inode) (struct task_struct *p, struct inode *inode);
-
-        int (*ipc_permission) (struct kern_ipc_perm *ipcp, short flag);
-        void (*ipc_getsecid) (struct kern_ipc_perm *ipcp, u32 *secid);
-
-        int (*msg_msg_alloc_security) (struct msg_msg *msg);
-        void (*msg_msg_free_security) (struct msg_msg *msg);
-
-        int (*msg_queue_alloc_security) (struct msg_queue *msq);
-        void (*msg_queue_free_security) (struct msg_queue *msq);
-        int (*msg_queue_associate) (struct msg_queue *msq, int msqflg);
-        int (*msg_queue_msgctl) (struct msg_queue *msq, int cmd);
-        int (*msg_queue_msgsnd) (struct msg_queue *msq,
-                                 struct msg_msg *msg, int msqflg);
-        int (*msg_queue_msgrcv) (struct msg_queue *msq,
-                                 struct msg_msg *msg,
-                                 struct task_struct *target,
-                                 long type, int mode);
-
-        int (*shm_alloc_security) (struct shmid_kernel *shp);
-        void (*shm_free_security) (struct shmid_kernel *shp);
-        int (*shm_associate) (struct shmid_kernel *shp, int shmflg);
-        int (*shm_shmctl) (struct shmid_kernel *shp, int cmd);
-        int (*shm_shmat) (struct shmid_kernel *shp,
-                          char __user *shmaddr, int shmflg);
-
-        int (*sem_alloc_security) (struct sem_array *sma);
-        void (*sem_free_security) (struct sem_array *sma);
-        int (*sem_associate) (struct sem_array *sma, int semflg);
-        int (*sem_semctl) (struct sem_array *sma, int cmd);
-        int (*sem_semop) (struct sem_array *sma,
-                          struct sembuf *sops, unsigned nsops, int alter);
-
-        int (*netlink_send) (struct sock *sk, struct sk_buff *skb);
-
-        void (*d_instantiate) (struct dentry *dentry, struct inode *inode);
-
-        int (*getprocattr) (struct task_struct *p, char *name, char **value);
-        int (*setprocattr) (struct task_struct *p, char *name, void *value, size_t size);
-        int (*ismaclabel) (const char *name);
-        int (*secid_to_secctx) (u32 secid, char **secdata, u32 *seclen);
-        int (*secctx_to_secid) (const char *secdata, u32 seclen, u32 *secid);
-        void (*release_secctx) (char *secdata, u32 seclen);
-
-        int (*inode_notifysecctx)(struct inode *inode, void *ctx, u32 ctxlen);
-        int (*inode_setsecctx)(struct dentry *dentry, void *ctx, u32 ctxlen);
-        int (*inode_getsecctx)(struct inode *inode, void **ctx, u32 *ctxlen);
-
-#ifdef CONFIG_SECURITY_NETWORK
-        int (*unix_stream_connect) (struct sock *sock, struct sock *other, struct sock *newsk);
-        int (*unix_may_send) (struct socket *sock, struct socket *other);
-
-        int (*socket_create) (int family, int type, int protocol, int kern);
-        int (*socket_post_create) (struct socket *sock, int family,
-                                   int type, int protocol, int kern);
-        int (*socket_bind) (struct socket *sock,
-                            struct sockaddr *address, int addrlen);
-        int (*socket_connect) (struct socket *sock,
-                               struct sockaddr *address, int addrlen);
-        int (*socket_listen) (struct socket *sock, int backlog);
-        int (*socket_accept) (struct socket *sock, struct socket *newsock);
-        int (*socket_sendmsg) (struct socket *sock,
-                               struct msghdr *msg, int size);
-        int (*socket_recvmsg) (struct socket *sock,
-                               struct msghdr *msg, int size, int flags);
-        int (*socket_getsockname) (struct socket *sock);
-        int (*socket_getpeername) (struct socket *sock);
-        int (*socket_getsockopt) (struct socket *sock, int level, int optname);
-        int (*socket_setsockopt) (struct socket *sock, int level, int optname);
-        int (*socket_shutdown) (struct socket *sock, int how);
-        int (*socket_sock_rcv_skb) (struct sock *sk, struct sk_buff *skb);
-        int (*socket_getpeersec_stream) (struct socket *sock, char __user *optval, int __user *optlen, unsigned len);
-        int (*socket_getpeersec_dgram) (struct socket *sock, struct sk_buff *skb, u32 *secid);
-        int (*sk_alloc_security) (struct sock *sk, int family, gfp_t priority);
-        void (*sk_free_security) (struct sock *sk);
-        void (*sk_clone_security) (const struct sock *sk, struct sock *newsk);
-        void (*sk_getsecid) (struct sock *sk, u32 *secid);
-        void (*sock_graft) (struct sock *sk, struct socket *parent);
-        int (*inet_conn_request) (struct sock *sk, struct sk_buff *skb,
-                                  struct request_sock *req);
-        void (*inet_csk_clone) (struct sock *newsk, const struct request_sock *req);
-        void (*inet_conn_established) (struct sock *sk, struct sk_buff *skb);
-        int (*secmark_relabel_packet) (u32 secid);
-        void (*secmark_refcount_inc) (void);
-        void (*secmark_refcount_dec) (void);
-        void (*req_classify_flow) (const struct request_sock *req, struct flowi *fl);
-        int (*tun_dev_alloc_security) (void **security);
-        void (*tun_dev_free_security) (void *security);
-        int (*tun_dev_create) (void);
-        int (*tun_dev_attach_queue) (void *security);
-        int (*tun_dev_attach) (struct sock *sk, void *security);
-        int (*tun_dev_open) (void *security);
-#endif  /* CONFIG_SECURITY_NETWORK */
-
-#ifdef CONFIG_SECURITY_NETWORK_XFRM
-        int (*xfrm_policy_alloc_security) (struct xfrm_sec_ctx **ctxp,
-                        struct xfrm_user_sec_ctx *sec_ctx, gfp_t gfp);
-        int (*xfrm_policy_clone_security) (struct xfrm_sec_ctx *old_ctx, struct xfrm_sec_ctx **new_ctx);
-        void (*xfrm_policy_free_security) (struct xfrm_sec_ctx *ctx);
-        int (*xfrm_policy_delete_security) (struct xfrm_sec_ctx *ctx);
-        int (*xfrm_state_alloc) (struct xfrm_state *x,
-                                 struct xfrm_user_sec_ctx *sec_ctx);
-        int (*xfrm_state_alloc_acquire) (struct xfrm_state *x,
-                                         struct xfrm_sec_ctx *polsec,
-                                         u32 secid);
-        void (*xfrm_state_free_security) (struct xfrm_state *x);
-        int (*xfrm_state_delete_security) (struct xfrm_state *x);
-        int (*xfrm_policy_lookup) (struct xfrm_sec_ctx *ctx, u32 fl_secid, u8 dir);
-        int (*xfrm_state_pol_flow_match) (struct xfrm_state *x,
-                                          struct xfrm_policy *xp,
-                                          const struct flowi *fl);
-        int (*xfrm_decode_session) (struct sk_buff *skb, u32 *secid, int ckall);
-#endif  /* CONFIG_SECURITY_NETWORK_XFRM */
-
-        /* key management security hooks */
-#ifdef CONFIG_KEYS
-        int (*key_alloc) (struct key *key, const struct cred *cred, unsigned long flags);
-        void (*key_free) (struct key *key);
-        int (*key_permission) (key_ref_t key_ref,
-                               const struct cred *cred,
-                               unsigned perm);
-        int (*key_getsecurity)(struct key *key, char **_buffer);
-#endif  /* CONFIG_KEYS */
-
-#ifdef CONFIG_AUDIT
-        int (*audit_rule_init) (u32 field, u32 op, char *rulestr, void **lsmrule);
-        int (*audit_rule_known) (struct audit_krule *krule);
-        int (*audit_rule_match) (u32 secid, u32 field, u32 op, void *lsmrule,
-                                 struct audit_context *actx);
-        void (*audit_rule_free) (void *lsmrule);
-#endif /* CONFIG_AUDIT */
-};
-
 /* prototypes */
 extern int security_init(void);
-extern int security_module_enable(struct security_operations *ops);
-extern int register_security(struct security_operations *ops);
-extern void __init security_fixup_ops(struct security_operations *ops);
-
 
 /* Security operations */
 int security_binder_set_context_mgr(struct task_struct *mgr);
@@ -2049,7 +465,7 @@ static inline int security_settime(const struct timespec *ts,
 
 static inline int security_vm_enough_memory_mm(struct mm_struct *mm, long pages)
 {
-        return cap_vm_enough_memory(mm, pages);
+        return __vm_enough_memory(mm, pages, cap_vm_enough_memory(mm, pages));
 }
 
 static inline int security_bprm_set_creds(struct linux_binprm *bprm)
@@ -2653,7 +1069,7 @@ static inline int security_setprocattr(struct task_struct *p, char *name, void *
 
 static inline int security_netlink_send(struct sock *sk, struct sk_buff *skb)
 {
-        return cap_netlink_send(sk, skb);
+        return 0;
 }
 
 static inline int security_ismaclabel(const char *name)
@@ -3221,36 +1637,5 @@ static inline void free_secdata(void *secdata)
 { }
 #endif /* CONFIG_SECURITY */
 
-#ifdef CONFIG_SECURITY_YAMA
-extern int yama_ptrace_access_check(struct task_struct *child,
-                                    unsigned int mode);
-extern int yama_ptrace_traceme(struct task_struct *parent);
-extern void yama_task_free(struct task_struct *task);
-extern int yama_task_prctl(int option, unsigned long arg2, unsigned long arg3,
-                           unsigned long arg4, unsigned long arg5);
-#else
-static inline int yama_ptrace_access_check(struct task_struct *child,
-                                           unsigned int mode)
-{
-        return 0;
-}
-
-static inline int yama_ptrace_traceme(struct task_struct *parent)
-{
-        return 0;
-}
-
-static inline void yama_task_free(struct task_struct *task)
-{
-}
-
-static inline int yama_task_prctl(int option, unsigned long arg2,
-                                  unsigned long arg3, unsigned long arg4,
-                                  unsigned long arg5)
-{
-        return -ENOSYS;
-}
-#endif /* CONFIG_SECURITY_YAMA */
-
 #endif /* ! __LINUX_SECURITY_H */
 
diff --git a/include/linux/seq_file.h b/include/linux/seq_file.h
index afbb1fd77c77..912a7c482649 100644
--- a/include/linux/seq_file.h
+++ b/include/linux/seq_file.h
@@ -123,6 +123,7 @@ __printf(2, 3) int seq_printf(struct seq_file *, const char *, ...);
 __printf(2, 0) int seq_vprintf(struct seq_file *, const char *, va_list args);
 
 int seq_path(struct seq_file *, const struct path *, const char *);
+int seq_file_path(struct seq_file *, struct file *, const char *);
 int seq_dentry(struct seq_file *, struct dentry *, const char *);
 int seq_path_root(struct seq_file *m, const struct path *path,
                   const struct path *root, const char *esc);
diff --git a/include/linux/seqlock.h b/include/linux/seqlock.h
index 486e685a226a..e0582106ef4f 100644
--- a/include/linux/seqlock.h
+++ b/include/linux/seqlock.h
@@ -35,6 +35,7 @@
 #include <linux/spinlock.h>
 #include <linux/preempt.h>
 #include <linux/lockdep.h>
+#include <linux/compiler.h>
 #include <asm/processor.h>
 
 /*
@@ -274,9 +275,87 @@ static inline void raw_write_seqcount_barrier(seqcount_t *s)
         s->sequence++;
 }
 
-/*
+static inline int raw_read_seqcount_latch(seqcount_t *s)
+{
+        return lockless_dereference(s->sequence);
+}
+
+/**
  * raw_write_seqcount_latch - redirect readers to even/odd copy
  * @s: pointer to seqcount_t
+ *
+ * The latch technique is a multiversion concurrency control method that allows
+ * queries during non-atomic modifications. If you can guarantee queries never
+ * interrupt the modification -- e.g. the concurrency is strictly between CPUs
+ * -- you most likely do not need this.
+ *
+ * Where the traditional RCU/lockless data structures rely on atomic
+ * modifications to ensure queries observe either the old or the new state the
+ * latch allows the same for non-atomic updates. The trade-off is doubling the
+ * cost of storage; we have to maintain two copies of the entire data
+ * structure.
+ *
+ * Very simply put: we first modify one copy and then the other. This ensures
+ * there is always one copy in a stable state, ready to give us an answer.
+ *
+ * The basic form is a data structure like:
+ *
+ * struct latch_struct {
+ *      seqcount_t              seq;
+ *      struct data_struct      data[2];
+ * };
+ *
+ * Where a modification, which is assumed to be externally serialized, does the
+ * following:
+ *
+ * void latch_modify(struct latch_struct *latch, ...)
+ * {
+ *      smp_wmb();      <- Ensure that the last data[1] update is visible
+ *      latch->seq++;
+ *      smp_wmb();      <- Ensure that the seqcount update is visible
+ *
+ *      modify(latch->data[0], ...);
+ *
+ *      smp_wmb();      <- Ensure that the data[0] update is visible
+ *      latch->seq++;
+ *      smp_wmb();      <- Ensure that the seqcount update is visible
+ *
+ *      modify(latch->data[1], ...);
+ * }
+ *
+ * The query will have a form like:
+ *
+ * struct entry *latch_query(struct latch_struct *latch, ...)
+ * {
+ *      struct entry *entry;
+ *      unsigned seq, idx;
+ *
+ *      do {
+ *              seq = lockless_dereference(latch->seq);
+ *
+ *              idx = seq & 0x01;
+ *              entry = data_query(latch->data[idx], ...);
+ *
+ *              smp_rmb();
+ *      } while (seq != latch->seq);
+ *
+ *      return entry;
+ * }
+ *
+ * So during the modification, queries are first redirected to data[1]. Then we
+ * modify data[0]. When that is complete, we redirect queries back to data[0]
+ * and we can modify data[1].
+ *
+ * NOTE: The non-requirement for atomic modifications does _NOT_ include
+ *       the publishing of new entries in the case where data is a dynamic
+ *       data structure.
+ *
+ *       An iteration might start in data[0] and get suspended long enough
+ *       to miss an entire modification sequence, once it resumes it might
+ *       observe the new entry.
+ *
+ * NOTE: When data is a dynamic data structure; one should use regular RCU
+ *       patterns to manage the lifetimes of the objects within.
  */
 static inline void raw_write_seqcount_latch(seqcount_t *s)
 {
diff --git a/include/linux/serial_8250.h b/include/linux/serial_8250.h
index 78097e7a330a..ba82c07feb95 100644
--- a/include/linux/serial_8250.h
+++ b/include/linux/serial_8250.h
@@ -12,6 +12,7 @@
 #define _LINUX_SERIAL_8250_H
 
 #include <linux/serial_core.h>
+#include <linux/serial_reg.h>
 #include <linux/platform_device.h>
 
 /*
@@ -137,6 +138,8 @@ extern int early_serial_setup(struct uart_port *port);
 
 extern unsigned int serial8250_early_in(struct uart_port *port, int offset);
 extern void serial8250_early_out(struct uart_port *port, int offset, int value);
+extern int early_serial8250_setup(struct earlycon_device *device,
+                                         const char *options);
 extern void serial8250_do_set_termios(struct uart_port *port,
                 struct ktermios *termios, struct ktermios *old);
 extern int serial8250_do_startup(struct uart_port *port);
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index 025dad9dcde4..297d4fa1cfe5 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -35,7 +35,7 @@
 #define uart_console(port) \
         ((port)->cons && (port)->cons->index == (port)->line)
 #else
-#define uart_console(port)      (0)
+#define uart_console(port)      ({ (void)port; 0; })
 #endif
 
 struct uart_port;
diff --git a/include/linux/serial_sci.h b/include/linux/serial_sci.h
index 6c5e3bb282b0..7c536ac5be05 100644
--- a/include/linux/serial_sci.h
+++ b/include/linux/serial_sci.h
@@ -1,6 +1,7 @@
 #ifndef __LINUX_SERIAL_SCI_H
 #define __LINUX_SERIAL_SCI_H
 
+#include <linux/bitops.h>
 #include <linux/serial_core.h>
 #include <linux/sh_dma.h>
 
@@ -10,59 +11,16 @@
 
 #define SCIx_NOT_SUPPORTED      (-1)
 
-/* SCSMR (Serial Mode Register) */
-#define SCSMR_CHR       (1 << 6)        /* 7-bit Character Length */
-#define SCSMR_PE        (1 << 5)        /* Parity Enable */
-#define SCSMR_ODD       (1 << 4)        /* Odd Parity */
-#define SCSMR_STOP      (1 << 3)        /* Stop Bit Length */
-#define SCSMR_CKS       0x0003          /* Clock Select */
-
 /* Serial Control Register (@ = not supported by all parts) */
-#define SCSCR_TIE       (1 << 7)        /* Transmit Interrupt Enable */
-#define SCSCR_RIE       (1 << 6)        /* Receive Interrupt Enable */
-#define SCSCR_TE        (1 << 5)        /* Transmit Enable */
-#define SCSCR_RE        (1 << 4)        /* Receive Enable */
-#define SCSCR_REIE      (1 << 3)        /* Receive Error Interrupt Enable @ */
-#define SCSCR_TOIE      (1 << 2)        /* Timeout Interrupt Enable @ */
-#define SCSCR_CKE1      (1 << 1)        /* Clock Enable 1 */
-#define SCSCR_CKE0      (1 << 0)        /* Clock Enable 0 */
-/* SCIFA/SCIFB only */
-#define SCSCR_TDRQE     (1 << 15)       /* Tx Data Transfer Request Enable */
-#define SCSCR_RDRQE     (1 << 14)       /* Rx Data Transfer Request Enable */
-
-/* SCxSR (Serial Status Register) on SCI */
-#define SCI_TDRE  0x80                  /* Transmit Data Register Empty */
-#define SCI_RDRF  0x40                  /* Receive Data Register Full */
-#define SCI_ORER  0x20                  /* Overrun Error */
-#define SCI_FER   0x10                  /* Framing Error */
-#define SCI_PER   0x08                  /* Parity Error */
-#define SCI_TEND  0x04                  /* Transmit End */
-
-#define SCI_DEFAULT_ERROR_MASK (SCI_PER | SCI_FER)
-
-/* SCxSR (Serial Status Register) on SCIF, HSCIF */
-#define SCIF_ER    0x0080               /* Receive Error */
-#define SCIF_TEND  0x0040               /* Transmission End */
-#define SCIF_TDFE  0x0020               /* Transmit FIFO Data Empty */
-#define SCIF_BRK   0x0010               /* Break Detect */
-#define SCIF_FER   0x0008               /* Framing Error */
-#define SCIF_PER   0x0004               /* Parity Error */
-#define SCIF_RDF   0x0002               /* Receive FIFO Data Full */
-#define SCIF_DR    0x0001               /* Receive Data Ready */
-
-#define SCIF_DEFAULT_ERROR_MASK (SCIF_PER | SCIF_FER | SCIF_ER | SCIF_BRK)
-
-/* SCFCR (FIFO Control Register) */
-#define SCFCR_LOOP      (1 << 0)        /* Loopback Test */
-
-/* SCSPTR (Serial Port Register), optional */
-#define SCSPTR_RTSIO    (1 << 7)        /* Serial Port RTS Pin Input/Output */
-#define SCSPTR_CTSIO    (1 << 5)        /* Serial Port CTS Pin Input/Output */
-#define SCSPTR_SPB2IO   (1 << 1)        /* Serial Port Break Input/Output */
-#define SCSPTR_SPB2DT   (1 << 0)        /* Serial Port Break Data */
-
-/* HSSRR HSCIF */
-#define HSCIF_SRE       0x8000          /* Sampling Rate Register Enable */
+#define SCSCR_TIE       BIT(7)  /* Transmit Interrupt Enable */
+#define SCSCR_RIE       BIT(6)  /* Receive Interrupt Enable */
+#define SCSCR_TE        BIT(5)  /* Transmit Enable */
+#define SCSCR_RE        BIT(4)  /* Receive Enable */
+#define SCSCR_REIE      BIT(3)  /* Receive Error Interrupt Enable @ */
+#define SCSCR_TOIE      BIT(2)  /* Timeout Interrupt Enable @ */
+#define SCSCR_CKE1      BIT(1)  /* Clock Enable 1 */
+#define SCSCR_CKE0      BIT(0)  /* Clock Enable 0 */
+
 
 enum {
         SCIx_PROBE_REGTYPE,
@@ -82,28 +40,6 @@ enum {
         SCIx_NR_REGTYPES,
 };
 
-/*
- * SCI register subset common for all port types.
- * Not all registers will exist on all parts.
- */
-enum {
-        SCSMR,                          /* Serial Mode Register */
-        SCBRR,                          /* Bit Rate Register */
-        SCSCR,                          /* Serial Control Register */
-        SCxSR,                          /* Serial Status Register */
-        SCFCR,                          /* FIFO Control Register */
-        SCFDR,                          /* FIFO Data Count Register */
-        SCxTDR,                         /* Transmit (FIFO) Data Register */
-        SCxRDR,                         /* Receive (FIFO) Data Register */
-        SCLSR,                          /* Line Status Register */
-        SCTFDR,                         /* Transmit FIFO Data Count Register */
-        SCRFDR,                         /* Receive FIFO Data Count Register */
-        SCSPTR,                         /* Serial Port Register */
-        HSSRR,                          /* Sampling Rate Register */
-
-        SCIx_NR_REGS,
-};
-
 struct device;
 
 struct plat_sci_port_ops {
@@ -113,7 +49,7 @@ struct plat_sci_port_ops {
 /*
  * Port-specific capabilities
  */
-#define SCIx_HAVE_RTSCTS        (1 << 0)
+#define SCIx_HAVE_RTSCTS        BIT(0)
 
 /*
  * Platform device specific platform_data struct
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index f15154a879c7..d6cdd6e87d53 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -34,7 +34,9 @@
 #include <linux/dma-mapping.h>
 #include <linux/netdev_features.h>
 #include <linux/sched.h>
-#include <net/flow_keys.h>
+#include <net/flow_dissector.h>
+#include <linux/splice.h>
+#include <linux/in6.h>
 
 /* A. Checksumming of received packets by device.
  *
@@ -170,13 +172,19 @@ struct nf_bridge_info {
                 BRNF_PROTO_UNCHANGED,
                 BRNF_PROTO_8021Q,
                 BRNF_PROTO_PPPOE
-        } orig_proto;
+        } orig_proto:8;
         bool                    pkt_otherhost;
+        __u16                   frag_max_size;
         unsigned int            mask;
         struct net_device       *physindev;
-        struct net_device       *physoutdev;
-        char                    neigh_header[8];
-        __be32                  ipv4_daddr;
+        union {
+                struct net_device *physoutdev;
+                char neigh_header[8];
+        };
+        union {
+                __be32          ipv4_daddr;
+                struct in6_addr ipv6_daddr;
+        };
 };
 #endif
 
@@ -859,6 +867,9 @@ int skb_append_datato_frags(struct sock *sk, struct sk_buff *skb,
                                         int len, int odd, struct sk_buff *skb),
                             void *from, int length);
 
+int skb_append_pagefrags(struct sk_buff *skb, struct page *page,
+                         int offset, size_t size);
+
 struct skb_seq_state {
         __u32           lower_offset;
         __u32           upper_offset;
@@ -919,7 +930,6 @@ skb_set_hash(struct sk_buff *skb, __u32 hash, enum pkt_hash_types type)
         skb->hash = hash;
 }
 
-void __skb_get_hash(struct sk_buff *skb);
 static inline __u32 skb_get_hash(struct sk_buff *skb)
 {
         if (!skb->l4_hash && !skb->sw_hash)
@@ -928,6 +938,8 @@ static inline __u32 skb_get_hash(struct sk_buff *skb)
         return skb->hash;
 }
 
+__u32 skb_get_hash_perturb(const struct sk_buff *skb, u32 perturb);
+
 static inline __u32 skb_get_hash_raw(const struct sk_buff *skb)
 {
         return skb->hash;
@@ -1935,8 +1947,8 @@ static inline void skb_probe_transport_header(struct sk_buff *skb,
 
         if (skb_transport_header_was_set(skb))
                 return;
-        else if (skb_flow_dissect(skb, &keys))
-                skb_set_transport_header(skb, keys.thoff);
+        else if (skb_flow_dissect_flow_keys(skb, &keys))
+                skb_set_transport_header(skb, keys.control.thoff);
         else
                 skb_set_transport_header(skb, offset_hint);
 }
@@ -2127,10 +2139,6 @@ static inline void __skb_queue_purge(struct sk_buff_head *list)
                 kfree_skb(skb);
 }
 
-#define NETDEV_FRAG_PAGE_MAX_ORDER get_order(32768)
-#define NETDEV_FRAG_PAGE_MAX_SIZE  (PAGE_SIZE << NETDEV_FRAG_PAGE_MAX_ORDER)
-#define NETDEV_PAGECNT_MAX_BIAS    NETDEV_FRAG_PAGE_MAX_SIZE
-
 void *netdev_alloc_frag(unsigned int fragsz);
 
 struct sk_buff *__netdev_alloc_skb(struct net_device *dev, unsigned int length,
@@ -2185,6 +2193,11 @@ static inline struct sk_buff *netdev_alloc_skb_ip_align(struct net_device *dev,
         return __netdev_alloc_skb_ip_align(dev, length, GFP_ATOMIC);
 }
 
+static inline void skb_free_frag(void *addr)
+{
+        __free_page_frag(addr);
+}
+
 void *napi_alloc_frag(unsigned int fragsz);
 struct sk_buff *__napi_alloc_skb(struct napi_struct *napi,
                                  unsigned int length, gfp_t gfp_mask);
@@ -2692,9 +2705,15 @@ int skb_copy_bits(const struct sk_buff *skb, int offset, void *to, int len);
 int skb_store_bits(struct sk_buff *skb, int offset, const void *from, int len);
 __wsum skb_copy_and_csum_bits(const struct sk_buff *skb, int offset, u8 *to,
                               int len, __wsum csum);
-int skb_splice_bits(struct sk_buff *skb, unsigned int offset,
+ssize_t skb_socket_splice(struct sock *sk,
+                          struct pipe_inode_info *pipe,
+                          struct splice_pipe_desc *spd);
+int skb_splice_bits(struct sk_buff *skb, struct sock *sk, unsigned int offset,
                     struct pipe_inode_info *pipe, unsigned int len,
-                    unsigned int flags);
+                    unsigned int flags,
+                    ssize_t (*splice_cb)(struct sock *,
+                                         struct pipe_inode_info *,
+                                         struct splice_pipe_desc *));
 void skb_copy_and_csum_dev(const struct sk_buff *skb, u8 *to);
 unsigned int skb_zerocopy_headlen(const struct sk_buff *from);
 int skb_zerocopy(struct sk_buff *to, struct sk_buff *from,
@@ -2729,8 +2748,9 @@ __wsum __skb_checksum(const struct sk_buff *skb, int offset, int len,
 __wsum skb_checksum(const struct sk_buff *skb, int offset, int len,
                     __wsum csum);
 
-static inline void *__skb_header_pointer(const struct sk_buff *skb, int offset,
-                                         int len, void *data, int hlen, void *buffer)
+static inline void * __must_check
+__skb_header_pointer(const struct sk_buff *skb, int offset,
+                     int len, void *data, int hlen, void *buffer)
 {
         if (hlen - offset >= len)
                 return data + offset;
@@ -2742,8 +2762,8 @@ static inline void *__skb_header_pointer(const struct sk_buff *skb, int offset,
         return buffer;
 }
 
-static inline void *skb_header_pointer(const struct sk_buff *skb, int offset,
-                                       int len, void *buffer)
+static inline void * __must_check
+skb_header_pointer(const struct sk_buff *skb, int offset, int len, void *buffer)
 {
         return __skb_header_pointer(skb, offset, len, skb->data,
                                     skb_headlen(skb), buffer);
@@ -3050,7 +3070,7 @@ static inline __sum16 __skb_checksum_validate_complete(struct sk_buff *skb,
                 }
         } else if (skb->csum_bad) {
                 /* ip_summed == CHECKSUM_NONE in this case */
-                return 1;
+                return (__force __sum16)1;
         }
 
         skb->csum = psum;
@@ -3298,9 +3318,6 @@ static inline bool skb_rx_queue_recorded(const struct sk_buff *skb)
         return skb->queue_mapping != 0;
 }
 
-u16 __skb_tx_hash(const struct net_device *dev, struct sk_buff *skb,
-                  unsigned int num_tx_queues);
-
 static inline struct sec_path *skb_sec_path(struct sk_buff *skb)
 {
 #ifdef CONFIG_XFRM
@@ -3355,15 +3372,14 @@ static inline int gso_pskb_expand_head(struct sk_buff *skb, int extra)
 static inline __sum16 gso_make_checksum(struct sk_buff *skb, __wsum res)
 {
         int plen = SKB_GSO_CB(skb)->csum_start - skb_headroom(skb) -
-            skb_transport_offset(skb);
-        __u16 csum;
+                   skb_transport_offset(skb);
+        __wsum partial;
 
-        csum = csum_fold(csum_partial(skb_transport_header(skb),
-                                      plen, skb->csum));
+        partial = csum_partial(skb_transport_header(skb), plen, skb->csum);
         skb->csum = res;
         SKB_GSO_CB(skb)->csum_start -= plen;
 
-        return csum;
+        return csum_fold(partial);
 }
 
 static inline bool skb_is_gso(const struct sk_buff *skb)
@@ -3418,10 +3434,9 @@ static inline void skb_checksum_none_assert(const struct sk_buff *skb)
 bool skb_partial_csum_set(struct sk_buff *skb, u16 start, u16 off);
 
 int skb_checksum_setup(struct sk_buff *skb, bool recalculate);
-
-u32 skb_get_poff(const struct sk_buff *skb);
-u32 __skb_get_poff(const struct sk_buff *skb, void *data,
-                   const struct flow_keys *keys, int hlen);
+struct sk_buff *skb_checksum_trimmed(struct sk_buff *skb,
+                                     unsigned int transport_len,
+                                     __sum16(*skb_chkf)(struct sk_buff *skb));
 
 /**
  * skb_head_is_locked - Determine if the skb->head is locked down
diff --git a/include/linux/slab.h b/include/linux/slab.h
index ffd24c830151..a99f0e5243e1 100644
--- a/include/linux/slab.h
+++ b/include/linux/slab.h
@@ -240,8 +240,8 @@ extern struct kmem_cache *kmalloc_dma_caches[KMALLOC_SHIFT_HIGH + 1];
  * belongs to.
  * 0 = zero alloc
  * 1 =  65 .. 96 bytes
- * 2 = 120 .. 192 bytes
- * n = 2^(n-1) .. 2^n -1
+ * 2 = 129 .. 192 bytes
+ * n = 2^(n-1)+1 .. 2^n
  */
 static __always_inline int kmalloc_index(size_t size)
 {
diff --git a/include/linux/smpboot.h b/include/linux/smpboot.h
index d600afb21926..da3c593f9845 100644
--- a/include/linux/smpboot.h
+++ b/include/linux/smpboot.h
@@ -27,6 +27,8 @@ struct smpboot_thread_data;
  * @pre_unpark:         Optional unpark function, called before the thread is
  *                      unparked (cpu online). This is not guaranteed to be
  *                      called on the target cpu of the thread. Careful!
+ * @cpumask:            Internal state.  To update which threads are unparked,
+ *                      call smpboot_update_cpumask_percpu_thread().
  * @selfparking:        Thread is not parked by the park function.
  * @thread_comm:        The base name of the thread
  */
@@ -41,11 +43,14 @@ struct smp_hotplug_thread {
         void                            (*park)(unsigned int cpu);
         void                            (*unpark)(unsigned int cpu);
         void                            (*pre_unpark)(unsigned int cpu);
+        cpumask_var_t                   cpumask;
         bool                            selfparking;
         const char                      *thread_comm;
 };
 
 int smpboot_register_percpu_thread(struct smp_hotplug_thread *plug_thread);
 void smpboot_unregister_percpu_thread(struct smp_hotplug_thread *plug_thread);
+int smpboot_update_cpumask_percpu_thread(struct smp_hotplug_thread *plug_thread,
+                                         const struct cpumask *);
 
 #endif
diff --git a/include/linux/soc/sunxi/sunxi_sram.h b/include/linux/soc/sunxi/sunxi_sram.h
new file mode 100644
index 000000000000..c5f663bba9c2
--- /dev/null
+++ b/include/linux/soc/sunxi/sunxi_sram.h
@@ -0,0 +1,19 @@
+/*
+ * Allwinner SoCs SRAM Controller Driver
+ *
+ * Copyright (C) 2015 Maxime Ripard
+ *
+ * Author: Maxime Ripard <maxime.ripard@free-electrons.com>
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2.  This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#ifndef _SUNXI_SRAM_H_
+#define _SUNXI_SRAM_H_
+
+int sunxi_sram_claim(struct device *dev);
+int sunxi_sram_release(struct device *dev);
+
+#endif /* _SUNXI_SRAM_H_ */
diff --git a/include/linux/sock_diag.h b/include/linux/sock_diag.h
index 083ac388098e..fddebc617469 100644
--- a/include/linux/sock_diag.h
+++ b/include/linux/sock_diag.h
@@ -1,7 +1,10 @@
 #ifndef __SOCK_DIAG_H__
 #define __SOCK_DIAG_H__
 
+#include <linux/netlink.h>
 #include <linux/user_namespace.h>
+#include <net/net_namespace.h>
+#include <net/sock.h>
 #include <uapi/linux/sock_diag.h>
 
 struct sk_buff;
@@ -11,6 +14,7 @@ struct sock;
 struct sock_diag_handler {
         __u8 family;
         int (*dump)(struct sk_buff *skb, struct nlmsghdr *nlh);
+        int (*get_info)(struct sk_buff *skb, struct sock *sk);
 };
 
 int sock_diag_register(const struct sock_diag_handler *h);
@@ -26,4 +30,42 @@ int sock_diag_put_meminfo(struct sock *sk, struct sk_buff *skb, int attr);
 int sock_diag_put_filterinfo(bool may_report_filterinfo, struct sock *sk,
                              struct sk_buff *skb, int attrtype);
 
+static inline
+enum sknetlink_groups sock_diag_destroy_group(const struct sock *sk)
+{
+        switch (sk->sk_family) {
+        case AF_INET:
+                switch (sk->sk_protocol) {
+                case IPPROTO_TCP:
+                        return SKNLGRP_INET_TCP_DESTROY;
+                case IPPROTO_UDP:
+                        return SKNLGRP_INET_UDP_DESTROY;
+                default:
+                        return SKNLGRP_NONE;
+                }
+        case AF_INET6:
+                switch (sk->sk_protocol) {
+                case IPPROTO_TCP:
+                        return SKNLGRP_INET6_TCP_DESTROY;
+                case IPPROTO_UDP:
+                        return SKNLGRP_INET6_UDP_DESTROY;
+                default:
+                        return SKNLGRP_NONE;
+                }
+        default:
+                return SKNLGRP_NONE;
+        }
+}
+
+static inline
+bool sock_diag_has_destroy_listeners(const struct sock *sk)
+{
+        const struct net *n = sock_net(sk);
+        const enum sknetlink_groups group = sock_diag_destroy_group(sk);
+
+        return group != SKNLGRP_NONE && n->diag_nlsk &&
+                netlink_has_listeners(n->diag_nlsk, group);
+}
+void sock_diag_broadcast_destroy(struct sock *sk);
+
 #endif
diff --git a/include/linux/spi/cc2520.h b/include/linux/spi/cc2520.h
index e741e8baad92..85b8ee67e937 100644
--- a/include/linux/spi/cc2520.h
+++ b/include/linux/spi/cc2520.h
@@ -21,7 +21,6 @@ struct cc2520_platform_data {
         int sfd;
         int reset;
         int vreg;
-        bool amplified;
 };
 
 #endif
diff --git a/include/linux/ssb/ssb.h b/include/linux/ssb/ssb.h
index 4568a5cc9ab8..c3d1a525bacc 100644
--- a/include/linux/ssb/ssb.h
+++ b/include/linux/ssb/ssb.h
@@ -29,10 +29,13 @@ struct ssb_sprom {
         u8 il0mac[6] __aligned(sizeof(u16));    /* MAC address for 802.11b/g */
         u8 et0mac[6] __aligned(sizeof(u16));    /* MAC address for Ethernet */
         u8 et1mac[6] __aligned(sizeof(u16));    /* MAC address for 802.11a */
+        u8 et2mac[6] __aligned(sizeof(u16));    /* MAC address for extra Ethernet */
         u8 et0phyaddr;          /* MII address for enet0 */
         u8 et1phyaddr;          /* MII address for enet1 */
+        u8 et2phyaddr;          /* MII address for enet2 */
         u8 et0mdcport;          /* MDIO for enet0 */
         u8 et1mdcport;          /* MDIO for enet1 */
+        u8 et2mdcport;          /* MDIO for enet2 */
         u16 dev_id;             /* Device ID overriding e.g. PCI ID */
         u16 board_rev;          /* Board revision number from SPROM. */
         u16 board_num;          /* Board number from SPROM. */
@@ -88,11 +91,14 @@ struct ssb_sprom {
         u32 ofdm5glpo;          /* 5.2GHz OFDM power offset */
         u32 ofdm5gpo;           /* 5.3GHz OFDM power offset */
         u32 ofdm5ghpo;          /* 5.8GHz OFDM power offset */
+        u32 boardflags;
+        u32 boardflags2;
+        u32 boardflags3;
+        /* TODO: Switch all drivers to new u32 fields and drop below ones */
         u16 boardflags_lo;      /* Board flags (bits 0-15) */
         u16 boardflags_hi;      /* Board flags (bits 16-31) */
         u16 boardflags2_lo;     /* Board flags (bits 32-47) */
         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];
 
diff --git a/include/linux/stddef.h b/include/linux/stddef.h
index 076af437284d..9c61c7cda936 100644
--- a/include/linux/stddef.h
+++ b/include/linux/stddef.h
@@ -3,7 +3,6 @@
 
 #include <uapi/linux/stddef.h>
 
-
 #undef NULL
 #define NULL ((void *)0)
 
@@ -14,10 +13,9 @@ enum {
 
 #undef offsetof
 #ifdef __compiler_offsetof
-#define offsetof(TYPE,MEMBER) __compiler_offsetof(TYPE,MEMBER)
+#define offsetof(TYPE, MEMBER)  __compiler_offsetof(TYPE, MEMBER)
 #else
-#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
-#endif
+#define offsetof(TYPE, MEMBER)  ((size_t)&((TYPE *)0)->MEMBER)
 #endif
 
 /**
@@ -28,3 +26,5 @@ enum {
  */
 #define offsetofend(TYPE, MEMBER) \
         (offsetof(TYPE, MEMBER) + sizeof(((TYPE *)0)->MEMBER))
+
+#endif
diff --git a/include/linux/stmmac.h b/include/linux/stmmac.h
index 7f484a239f53..c735f5c91eea 100644
--- a/include/linux/stmmac.h
+++ b/include/linux/stmmac.h
@@ -99,6 +99,7 @@ struct plat_stmmacenet_data {
         int phy_addr;
         int interface;
         struct stmmac_mdio_bus_data *mdio_bus_data;
+        struct device_node *phy_node;
         struct stmmac_dma_cfg *dma_cfg;
         int clk_csr;
         int has_gmac;
diff --git a/include/linux/string.h b/include/linux/string.h
index e40099e585c9..a8d90db9c4b0 100644
--- a/include/linux/string.h
+++ b/include/linux/string.h
@@ -111,6 +111,7 @@ extern int memcmp(const void *,const void *,__kernel_size_t);
 extern void * memchr(const void *,int,__kernel_size_t);
 #endif
 void *memchr_inv(const void *s, int c, size_t n);
+char *strreplace(char *s, char old, char new);
 
 extern void kfree_const(const void *x);
 
diff --git a/include/linux/sunrpc/bc_xprt.h b/include/linux/sunrpc/bc_xprt.h
index 2ca67b55e0fe..8df43c9f11dc 100644
--- a/include/linux/sunrpc/bc_xprt.h
+++ b/include/linux/sunrpc/bc_xprt.h
@@ -37,7 +37,6 @@ void xprt_complete_bc_request(struct rpc_rqst *req, uint32_t copied);
 void xprt_free_bc_request(struct rpc_rqst *req);
 int xprt_setup_backchannel(struct rpc_xprt *, unsigned int min_reqs);
 void xprt_destroy_backchannel(struct rpc_xprt *, unsigned int max_reqs);
-int bc_send(struct rpc_rqst *req);
 
 /*
  * Determine if a shared backchannel is in use
diff --git a/include/linux/sunrpc/clnt.h b/include/linux/sunrpc/clnt.h
index 598ba80ec30c..131032f15cc1 100644
--- a/include/linux/sunrpc/clnt.h
+++ b/include/linux/sunrpc/clnt.h
@@ -56,6 +56,7 @@ struct rpc_clnt {
         struct rpc_rtt *        cl_rtt;         /* RTO estimator data */
         const struct rpc_timeout *cl_timeout;   /* Timeout strategy */
 
+        atomic_t                cl_swapper;     /* swapfile count */
         int                     cl_nodelen;     /* nodename length */
         char                    cl_nodename[UNX_MAXNODENAME+1];
         struct rpc_pipe_dir_head cl_pipedir_objects;
diff --git a/include/linux/sunrpc/sched.h b/include/linux/sunrpc/sched.h
index 5f1e6bd4c316..d703f0ef37d8 100644
--- a/include/linux/sunrpc/sched.h
+++ b/include/linux/sunrpc/sched.h
@@ -205,8 +205,7 @@ struct rpc_wait_queue {
  */
 struct rpc_task *rpc_new_task(const struct rpc_task_setup *);
 struct rpc_task *rpc_run_task(const struct rpc_task_setup *);
-struct rpc_task *rpc_run_bc_task(struct rpc_rqst *req,
-                                const struct rpc_call_ops *ops);
+struct rpc_task *rpc_run_bc_task(struct rpc_rqst *req);
 void            rpc_put_task(struct rpc_task *);
 void            rpc_put_task_async(struct rpc_task *);
 void            rpc_exit_task(struct rpc_task *);
@@ -269,4 +268,20 @@ static inline void rpc_assign_waitqueue_name(struct rpc_wait_queue *q,
 }
 #endif
 
+#if IS_ENABLED(CONFIG_SUNRPC_SWAP)
+int rpc_clnt_swap_activate(struct rpc_clnt *clnt);
+void rpc_clnt_swap_deactivate(struct rpc_clnt *clnt);
+#else
+static inline int
+rpc_clnt_swap_activate(struct rpc_clnt *clnt)
+{
+        return -EINVAL;
+}
+
+static inline void
+rpc_clnt_swap_deactivate(struct rpc_clnt *clnt)
+{
+}
+#endif /* CONFIG_SUNRPC_SWAP */
+
 #endif /* _LINUX_SUNRPC_SCHED_H_ */
diff --git a/include/linux/sunrpc/svc_rdma.h b/include/linux/sunrpc/svc_rdma.h
index df8edf8ec914..cb94ee4181d4 100644
--- a/include/linux/sunrpc/svc_rdma.h
+++ b/include/linux/sunrpc/svc_rdma.h
@@ -172,6 +172,13 @@ struct svcxprt_rdma {
 #define RDMAXPRT_SQ_PENDING     2
 #define RDMAXPRT_CONN_PENDING   3
 
+#define RPCRDMA_MAX_SVC_SEGS    (64)    /* server max scatter/gather */
+#if RPCSVC_MAXPAYLOAD < (RPCRDMA_MAX_SVC_SEGS << PAGE_SHIFT)
+#define RPCRDMA_MAXPAYLOAD      RPCSVC_MAXPAYLOAD
+#else
+#define RPCRDMA_MAXPAYLOAD      (RPCRDMA_MAX_SVC_SEGS << PAGE_SHIFT)
+#endif
+
 #define RPCRDMA_LISTEN_BACKLOG  10
 /* The default ORD value is based on two outstanding full-size writes with a
  * page size of 4k, or 32k * 2 ops / 4k = 16 outstanding RDMA_READ.  */
@@ -182,10 +189,9 @@ struct svcxprt_rdma {
 
 /* svc_rdma_marshal.c */
 extern int svc_rdma_xdr_decode_req(struct rpcrdma_msg **, struct svc_rqst *);
-extern int svc_rdma_xdr_decode_deferred_req(struct svc_rqst *);
 extern int svc_rdma_xdr_encode_error(struct svcxprt_rdma *,
                                      struct rpcrdma_msg *,
-                                     enum rpcrdma_errcode, u32 *);
+                                     enum rpcrdma_errcode, __be32 *);
 extern void svc_rdma_xdr_encode_write_list(struct rpcrdma_msg *, int);
 extern void svc_rdma_xdr_encode_reply_array(struct rpcrdma_write_array *, int);
 extern void svc_rdma_xdr_encode_array_chunk(struct rpcrdma_write_array *, int,
@@ -212,7 +218,6 @@ extern int svc_rdma_sendto(struct svc_rqst *);
 extern int svc_rdma_send(struct svcxprt_rdma *, struct ib_send_wr *);
 extern void svc_rdma_send_error(struct svcxprt_rdma *, struct rpcrdma_msg *,
                                 enum rpcrdma_errcode);
-struct page *svc_rdma_get_page(void);
 extern int svc_rdma_post_recv(struct svcxprt_rdma *);
 extern int svc_rdma_create_listen(struct svc_serv *, int, struct sockaddr *);
 extern struct svc_rdma_op_ctxt *svc_rdma_get_context(struct svcxprt_rdma *);
diff --git a/include/linux/sunrpc/xprt.h b/include/linux/sunrpc/xprt.h
index 8b93ef53df3c..0fb9acbb4780 100644
--- a/include/linux/sunrpc/xprt.h
+++ b/include/linux/sunrpc/xprt.h
@@ -133,6 +133,9 @@ struct rpc_xprt_ops {
         void            (*close)(struct rpc_xprt *xprt);
         void            (*destroy)(struct rpc_xprt *xprt);
         void            (*print_stats)(struct rpc_xprt *xprt, struct seq_file *seq);
+        int             (*enable_swap)(struct rpc_xprt *xprt);
+        void            (*disable_swap)(struct rpc_xprt *xprt);
+        void            (*inject_disconnect)(struct rpc_xprt *xprt);
 };
 
 /*
@@ -180,7 +183,7 @@ struct rpc_xprt {
         atomic_t                num_reqs;       /* total slots */
         unsigned long           state;          /* transport state */
         unsigned char           resvport   : 1; /* use a reserved port */
-        unsigned int            swapper;        /* we're swapping over this
+        atomic_t                swapper;        /* we're swapping over this
                                                    transport */
         unsigned int            bind_index;     /* bind function index */
 
@@ -212,7 +215,8 @@ struct rpc_xprt {
 #if defined(CONFIG_SUNRPC_BACKCHANNEL)
         struct svc_serv         *bc_serv;       /* The RPC service which will */
                                                 /* process the callback */
-        unsigned int            bc_alloc_count; /* Total number of preallocs */
+        int                     bc_alloc_count; /* Total number of preallocs */
+        atomic_t                bc_free_slots;
         spinlock_t              bc_pa_lock;     /* Protects the preallocated
                                                  * items */
         struct list_head        bc_pa_list;     /* List of preallocated
@@ -241,6 +245,7 @@ struct rpc_xprt {
         const char              *address_strings[RPC_DISPLAY_MAX];
 #if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
         struct dentry           *debugfs;               /* debugfs directory */
+        atomic_t                inject_disconnect;
 #endif
 };
 
@@ -327,6 +332,18 @@ static inline __be32 *xprt_skip_transport_header(struct rpc_xprt *xprt, __be32 *
         return p + xprt->tsh_size;
 }
 
+static inline int
+xprt_enable_swap(struct rpc_xprt *xprt)
+{
+        return xprt->ops->enable_swap(xprt);
+}
+
+static inline void
+xprt_disable_swap(struct rpc_xprt *xprt)
+{
+        xprt->ops->disable_swap(xprt);
+}
+
 /*
  * Transport switch helper functions
  */
@@ -345,7 +362,6 @@ void			xprt_release_rqst_cong(struct rpc_task *task);
 void                    xprt_disconnect_done(struct rpc_xprt *xprt);
 void                    xprt_force_disconnect(struct rpc_xprt *xprt);
 void                    xprt_conditional_disconnect(struct rpc_xprt *xprt, unsigned int cookie);
-int                     xs_swapper(struct rpc_xprt *xprt, int enable);
 
 bool                    xprt_lock_connect(struct rpc_xprt *, struct rpc_task *, void *);
 void                    xprt_unlock_connect(struct rpc_xprt *, void *);
@@ -431,6 +447,23 @@ static inline int xprt_test_and_set_binding(struct rpc_xprt *xprt)
         return test_and_set_bit(XPRT_BINDING, &xprt->state);
 }
 
+#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
+extern unsigned int rpc_inject_disconnect;
+static inline void xprt_inject_disconnect(struct rpc_xprt *xprt)
+{
+        if (!rpc_inject_disconnect)
+                return;
+        if (atomic_dec_return(&xprt->inject_disconnect))
+                return;
+        atomic_set(&xprt->inject_disconnect, rpc_inject_disconnect);
+        xprt->ops->inject_disconnect(xprt);
+}
+#else
+static inline void xprt_inject_disconnect(struct rpc_xprt *xprt)
+{
+}
+#endif
+
 #endif /* __KERNEL__*/
 
 #endif /* _LINUX_SUNRPC_XPRT_H */
diff --git a/include/linux/sunrpc/xprtrdma.h b/include/linux/sunrpc/xprtrdma.h
index c984c85981ea..b17613052cc3 100644
--- a/include/linux/sunrpc/xprtrdma.h
+++ b/include/linux/sunrpc/xprtrdma.h
@@ -56,7 +56,8 @@
 
 #define RPCRDMA_INLINE_PAD_THRESH  (512)/* payload threshold to pad (bytes) */
 
-/* memory registration strategies */
+/* Memory registration strategies, by number.
+ * This is part of a kernel / user space API. Do not remove. */
 enum rpcrdma_memreg {
         RPCRDMA_BOUNCEBUFFERS = 0,
         RPCRDMA_REGISTER,
diff --git a/include/linux/swap.h b/include/linux/swap.h
index cee108cbe2d5..38874729dc5f 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -377,7 +377,6 @@ extern void end_swap_bio_write(struct bio *bio, int err);
 extern int __swap_writepage(struct page *page, struct writeback_control *wbc,
         void (*end_write_func)(struct bio *, int));
 extern int swap_set_page_dirty(struct page *page);
-extern void end_swap_bio_read(struct bio *bio, int err);
 
 int add_swap_extent(struct swap_info_struct *sis, unsigned long start_page,
                 unsigned long nr_pages, sector_t start_block);
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 76d1e38aabe1..b45c45b8c829 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -111,14 +111,14 @@ union bpf_attr;
 #define __SC_STR_ADECL(t, a)    #a
 #define __SC_STR_TDECL(t, a)    #t
 
-extern struct ftrace_event_class event_class_syscall_enter;
-extern struct ftrace_event_class event_class_syscall_exit;
+extern struct trace_event_class event_class_syscall_enter;
+extern struct trace_event_class event_class_syscall_exit;
 extern struct trace_event_functions enter_syscall_print_funcs;
 extern struct trace_event_functions exit_syscall_print_funcs;
 
 #define SYSCALL_TRACE_ENTER_EVENT(sname)                                \
         static struct syscall_metadata __syscall_meta_##sname;          \
-        static struct ftrace_event_call __used                          \
+        static struct trace_event_call __used                           \
           event_enter_##sname = {                                       \
                 .class                  = &event_class_syscall_enter,   \
                 {                                                       \
@@ -128,13 +128,13 @@ extern struct trace_event_functions exit_syscall_print_funcs;
                 .data                   = (void *)&__syscall_meta_##sname,\
                 .flags                  = TRACE_EVENT_FL_CAP_ANY,       \
         };                                                              \
-        static struct ftrace_event_call __used                          \
+        static struct trace_event_call __used                           \
           __attribute__((section("_ftrace_events")))                    \
          *__event_enter_##sname = &event_enter_##sname;
 
 #define SYSCALL_TRACE_EXIT_EVENT(sname)                                 \
         static struct syscall_metadata __syscall_meta_##sname;          \
-        static struct ftrace_event_call __used                          \
+        static struct trace_event_call __used                           \
           event_exit_##sname = {                                        \
                 .class                  = &event_class_syscall_exit,    \
                 {                                                       \
@@ -144,7 +144,7 @@ extern struct trace_event_functions exit_syscall_print_funcs;
                 .data                   = (void *)&__syscall_meta_##sname,\
                 .flags                  = TRACE_EVENT_FL_CAP_ANY,       \
         };                                                              \
-        static struct ftrace_event_call __used                          \
+        static struct trace_event_call __used                           \
           __attribute__((section("_ftrace_events")))                    \
         *__event_exit_##sname = &event_exit_##sname;
 
@@ -827,15 +827,15 @@ asmlinkage long sys_syncfs(int fd);
 asmlinkage long sys_fork(void);
 asmlinkage long sys_vfork(void);
 #ifdef CONFIG_CLONE_BACKWARDS
-asmlinkage long sys_clone(unsigned long, unsigned long, int __user *, int,
+asmlinkage long sys_clone(unsigned long, unsigned long, int __user *, unsigned long,
                int __user *);
 #else
 #ifdef CONFIG_CLONE_BACKWARDS3
 asmlinkage long sys_clone(unsigned long, unsigned long, int, int __user *,
-                          int __user *, int);
+                          int __user *, unsigned long);
 #else
 asmlinkage long sys_clone(unsigned long, unsigned long, int __user *,
-               int __user *, int);
+               int __user *, unsigned long);
 #endif
 #endif
 
diff --git a/include/linux/sysctl.h b/include/linux/sysctl.h
index 795d5fea5697..fa7bc29925c9 100644
--- a/include/linux/sysctl.h
+++ b/include/linux/sysctl.h
@@ -188,6 +188,9 @@ struct ctl_table_header *register_sysctl_paths(const struct ctl_path *path,
 void unregister_sysctl_table(struct ctl_table_header * table);
 
 extern int sysctl_init(void);
+
+extern struct ctl_table sysctl_mount_point[];
+
 #else /* CONFIG_SYSCTL */
 static inline struct ctl_table_header *register_sysctl_table(struct ctl_table * table)
 {
diff --git a/include/linux/sysfs.h b/include/linux/sysfs.h
index 99382c0df17e..9f65758311a4 100644
--- a/include/linux/sysfs.h
+++ b/include/linux/sysfs.h
@@ -210,6 +210,10 @@ int __must_check sysfs_rename_dir_ns(struct kobject *kobj, const char *new_name,
 int __must_check sysfs_move_dir_ns(struct kobject *kobj,
                                    struct kobject *new_parent_kobj,
                                    const void *new_ns);
+int __must_check sysfs_create_mount_point(struct kobject *parent_kobj,
+                                          const char *name);
+void sysfs_remove_mount_point(struct kobject *parent_kobj,
+                              const char *name);
 
 int __must_check sysfs_create_file_ns(struct kobject *kobj,
                                       const struct attribute *attr,
@@ -298,6 +302,17 @@ static inline int sysfs_move_dir_ns(struct kobject *kobj,
         return 0;
 }
 
+static inline int sysfs_create_mount_point(struct kobject *parent_kobj,
+                                           const char *name)
+{
+        return 0;
+}
+
+static inline void sysfs_remove_mount_point(struct kobject *parent_kobj,
+                                            const char *name)
+{
+}
+
 static inline int sysfs_create_file_ns(struct kobject *kobj,
                                        const struct attribute *attr,
                                        const void *ns)
diff --git a/include/linux/syslog.h b/include/linux/syslog.h
index 4b7b875a7ce1..c3a7f0cc3a27 100644
--- a/include/linux/syslog.h
+++ b/include/linux/syslog.h
@@ -47,12 +47,12 @@
 #define SYSLOG_FROM_READER           0
 #define SYSLOG_FROM_PROC             1
 
-int do_syslog(int type, char __user *buf, int count, bool from_file);
+int do_syslog(int type, char __user *buf, int count, int source);
 
 #ifdef CONFIG_PRINTK
-int check_syslog_permissions(int type, bool from_file);
+int check_syslog_permissions(int type, int source);
 #else
-static inline int check_syslog_permissions(int type, bool from_file)
+static inline int check_syslog_permissions(int type, int source)
 {
         return 0;
 }
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index e8bbf403618f..48c3696e8645 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -149,11 +149,16 @@ struct tcp_sock {
                                  * sum(delta(rcv_nxt)), or how many bytes
                                  * were acked.
                                  */
+        u32     segs_in;        /* RFC4898 tcpEStatsPerfSegsIn
+                                 * total number of segments in.
+                                 */
         u32     rcv_nxt;        /* What we want to receive next         */
         u32     copied_seq;     /* Head of yet unread data              */
         u32     rcv_wup;        /* rcv_nxt on last window update sent   */
         u32     snd_nxt;        /* Next sequence we send                */
-
+        u32     segs_out;       /* RFC4898 tcpEStatsPerfSegsOut
+                                 * The total number of segments sent.
+                                 */
         u64     bytes_acked;    /* RFC4898 tcpEStatsAppHCThruOctetsAcked
                                  * sum(delta(snd_una)), or how many bytes
                                  * were acked.
@@ -201,6 +206,7 @@ struct tcp_sock {
                 syn_fastopen:1, /* SYN includes Fast Open option */
                 syn_fastopen_exp:1,/* SYN includes Fast Open exp. option */
                 syn_data_acked:1,/* data in SYN is acked by SYN-ACK */
+                save_syn:1,     /* Save headers of SYN packet */
                 is_cwnd_limited:1;/* forward progress limited by snd_cwnd? */
         u32     tlp_high_seq;   /* snd_nxt at the time of TLP retransmit. */
 
@@ -328,6 +334,7 @@ struct tcp_sock {
          * socket. Used to retransmit SYNACKs etc.
          */
         struct request_sock *fastopen_rsk;
+        u32     *saved_syn;
 };
 
 enum tsq_flags {
@@ -395,4 +402,10 @@ static inline int fastopen_init_queue(struct sock *sk, int backlog)
         return 0;
 }
 
+static inline void tcp_saved_syn_free(struct tcp_sock *tp)
+{
+        kfree(tp->saved_syn);
+        tp->saved_syn = NULL;
+}
+
 #endif  /* _LINUX_TCP_H */
diff --git a/include/linux/thermal.h b/include/linux/thermal.h
index 5eac316490ea..037e9df2f610 100644
--- a/include/linux/thermal.h
+++ b/include/linux/thermal.h
@@ -40,6 +40,9 @@
 /* No upper/lower limit requirement */
 #define THERMAL_NO_LIMIT        ((u32)~0)
 
+/* Default weight of a bound cooling device */
+#define THERMAL_WEIGHT_DEFAULT 0
+
 /* Unit conversion macros */
 #define KELVIN_TO_CELSIUS(t)    (long)(((long)t-2732 >= 0) ?    \
                                 ((long)t-2732+5)/10 : ((long)t-2732-5)/10)
@@ -56,10 +59,13 @@
 #define DEFAULT_THERMAL_GOVERNOR       "fair_share"
 #elif defined(CONFIG_THERMAL_DEFAULT_GOV_USER_SPACE)
 #define DEFAULT_THERMAL_GOVERNOR       "user_space"
+#elif defined(CONFIG_THERMAL_DEFAULT_GOV_POWER_ALLOCATOR)
+#define DEFAULT_THERMAL_GOVERNOR       "power_allocator"
 #endif
 
 struct thermal_zone_device;
 struct thermal_cooling_device;
+struct thermal_instance;
 
 enum thermal_device_mode {
         THERMAL_DEVICE_DISABLED = 0,
@@ -113,6 +119,12 @@ struct thermal_cooling_device_ops {
         int (*get_max_state) (struct thermal_cooling_device *, unsigned long *);
         int (*get_cur_state) (struct thermal_cooling_device *, unsigned long *);
         int (*set_cur_state) (struct thermal_cooling_device *, unsigned long);
+        int (*get_requested_power)(struct thermal_cooling_device *,
+                                   struct thermal_zone_device *, u32 *);
+        int (*state2power)(struct thermal_cooling_device *,
+                           struct thermal_zone_device *, unsigned long, u32 *);
+        int (*power2state)(struct thermal_cooling_device *,
+                           struct thermal_zone_device *, u32, unsigned long *);
 };
 
 struct thermal_cooling_device {
@@ -144,8 +156,7 @@ struct thermal_attr {
  * @devdata:    private pointer for device private data
  * @trips:      number of trip points the thermal zone supports
  * @passive_delay:      number of milliseconds to wait between polls when
- *                      performing passive cooling.  Currenty only used by the
- *                      step-wise governor
+ *                      performing passive cooling.
  * @polling_delay:      number of milliseconds to wait between polls when
  *                      checking whether trip points have been crossed (0 for
  *                      interrupt driven systems)
@@ -155,13 +166,13 @@ struct thermal_attr {
  * @last_temperature:   previous temperature read
  * @emul_temperature:   emulated temperature when using CONFIG_THERMAL_EMULATION
  * @passive:            1 if you've crossed a passive trip point, 0 otherwise.
- *                      Currenty only used by the step-wise governor.
  * @forced_passive:     If > 0, temperature at which to switch on all ACPI
  *                      processor cooling devices.  Currently only used by the
  *                      step-wise governor.
  * @ops:        operations this &thermal_zone_device supports
  * @tzp:        thermal zone parameters
  * @governor:   pointer to the governor for this thermal zone
+ * @governor_data:      private pointer for governor data
  * @thermal_instances:  list of &struct thermal_instance of this thermal zone
  * @idr:        &struct idr to generate unique id for this zone's cooling
  *              devices
@@ -186,8 +197,9 @@ struct thermal_zone_device {
         int passive;
         unsigned int forced_passive;
         struct thermal_zone_device_ops *ops;
-        const struct thermal_zone_params *tzp;
+        struct thermal_zone_params *tzp;
         struct thermal_governor *governor;
+        void *governor_data;
         struct list_head thermal_instances;
         struct idr idr;
         struct mutex lock;
@@ -198,12 +210,19 @@ struct thermal_zone_device {
 /**
  * struct thermal_governor - structure that holds thermal governor information
  * @name:       name of the governor
+ * @bind_to_tz: callback called when binding to a thermal zone.  If it
+ *              returns 0, the governor is bound to the thermal zone,
+ *              otherwise it fails.
+ * @unbind_from_tz:     callback called when a governor is unbound from a
+ *                      thermal zone.
  * @throttle:   callback called for every trip point even if temperature is
  *              below the trip point temperature
  * @governor_list:      node in thermal_governor_list (in thermal_core.c)
  */
 struct thermal_governor {
         char name[THERMAL_NAME_LENGTH];
+        int (*bind_to_tz)(struct thermal_zone_device *tz);
+        void (*unbind_from_tz)(struct thermal_zone_device *tz);
         int (*throttle)(struct thermal_zone_device *tz, int trip);
         struct list_head        governor_list;
 };
@@ -214,9 +233,12 @@ struct thermal_bind_params {
 
         /*
          * This is a measure of 'how effectively these devices can
-         * cool 'this' thermal zone. The shall be determined by platform
-         * characterization. This is on a 'percentage' scale.
-         * See Documentation/thermal/sysfs-api.txt for more information.
+         * cool 'this' thermal zone. It shall be determined by
+         * platform characterization. This value is relative to the
+         * rest of the weights so a cooling device whose weight is
+         * double that of another cooling device is twice as
+         * effective. See Documentation/thermal/sysfs-api.txt for more
+         * information.
          */
         int weight;
 
@@ -253,6 +275,44 @@ struct thermal_zone_params {
 
         int num_tbps;   /* Number of tbp entries */
         struct thermal_bind_params *tbp;
+
+        /*
+         * Sustainable power (heat) that this thermal zone can dissipate in
+         * mW
+         */
+        u32 sustainable_power;
+
+        /*
+         * Proportional parameter of the PID controller when
+         * overshooting (i.e., when temperature is below the target)
+         */
+        s32 k_po;
+
+        /*
+         * Proportional parameter of the PID controller when
+         * undershooting
+         */
+        s32 k_pu;
+
+        /* Integral parameter of the PID controller */
+        s32 k_i;
+
+        /* Derivative parameter of the PID controller */
+        s32 k_d;
+
+        /* threshold below which the error is no longer accumulated */
+        s32 integral_cutoff;
+
+        /*
+         * @slope:      slope of a linear temperature adjustment curve.
+         *              Used by thermal zone drivers.
+         */
+        int slope;
+        /*
+         * @offset:     offset of a linear temperature adjustment curve.
+         *              Used by thermal zone drivers (default 0).
+         */
+        int offset;
 };
 
 struct thermal_genl_event {
@@ -316,14 +376,25 @@ void thermal_zone_of_sensor_unregister(struct device *dev,
 #endif
 
 #if IS_ENABLED(CONFIG_THERMAL)
+static inline bool cdev_is_power_actor(struct thermal_cooling_device *cdev)
+{
+        return cdev->ops->get_requested_power && cdev->ops->state2power &&
+                cdev->ops->power2state;
+}
+
+int power_actor_get_max_power(struct thermal_cooling_device *,
+                              struct thermal_zone_device *tz, u32 *max_power);
+int power_actor_set_power(struct thermal_cooling_device *,
+                          struct thermal_instance *, u32);
 struct thermal_zone_device *thermal_zone_device_register(const char *, int, int,
                 void *, struct thermal_zone_device_ops *,
-                const struct thermal_zone_params *, int, int);
+                struct thermal_zone_params *, int, int);
 void thermal_zone_device_unregister(struct thermal_zone_device *);
 
 int thermal_zone_bind_cooling_device(struct thermal_zone_device *, int,
                                      struct thermal_cooling_device *,
-                                     unsigned long, unsigned long);
+                                     unsigned long, unsigned long,
+                                     unsigned int);
 int thermal_zone_unbind_cooling_device(struct thermal_zone_device *, int,
                                        struct thermal_cooling_device *);
 void thermal_zone_device_update(struct thermal_zone_device *);
@@ -343,6 +414,14 @@ struct thermal_instance *get_thermal_instance(struct thermal_zone_device *,
 void thermal_cdev_update(struct thermal_cooling_device *);
 void thermal_notify_framework(struct thermal_zone_device *, int);
 #else
+static inline bool cdev_is_power_actor(struct thermal_cooling_device *cdev)
+{ return false; }
+static inline int power_actor_get_max_power(struct thermal_cooling_device *cdev,
+                              struct thermal_zone_device *tz, u32 *max_power)
+{ return 0; }
+static inline int power_actor_set_power(struct thermal_cooling_device *cdev,
+                          struct thermal_instance *tz, u32 power)
+{ return 0; }
 static inline struct thermal_zone_device *thermal_zone_device_register(
         const char *type, int trips, int mask, void *devdata,
         struct thermal_zone_device_ops *ops,
diff --git a/include/linux/tick.h b/include/linux/tick.h
index 4191b5623a28..edbfc9a5293e 100644
--- a/include/linux/tick.h
+++ b/include/linux/tick.h
@@ -13,8 +13,6 @@
 
 #ifdef CONFIG_GENERIC_CLOCKEVENTS
 extern void __init tick_init(void);
-extern void tick_freeze(void);
-extern void tick_unfreeze(void);
 /* Should be core only, but ARM BL switcher requires it */
 extern void tick_suspend_local(void);
 /* Should be core only, but XEN resume magic and ARM BL switcher require it */
@@ -23,14 +21,20 @@ extern void tick_handover_do_timer(void);
 extern void tick_cleanup_dead_cpu(int cpu);
 #else /* CONFIG_GENERIC_CLOCKEVENTS */
 static inline void tick_init(void) { }
-static inline void tick_freeze(void) { }
-static inline void tick_unfreeze(void) { }
 static inline void tick_suspend_local(void) { }
 static inline void tick_resume_local(void) { }
 static inline void tick_handover_do_timer(void) { }
 static inline void tick_cleanup_dead_cpu(int cpu) { }
 #endif /* !CONFIG_GENERIC_CLOCKEVENTS */
 
+#if defined(CONFIG_GENERIC_CLOCKEVENTS) && defined(CONFIG_SUSPEND)
+extern void tick_freeze(void);
+extern void tick_unfreeze(void);
+#else
+static inline void tick_freeze(void) { }
+static inline void tick_unfreeze(void) { }
+#endif
+
 #ifdef CONFIG_TICK_ONESHOT
 extern void tick_irq_enter(void);
 #  ifndef arch_needs_cpu
@@ -63,10 +67,13 @@ extern void tick_broadcast_control(enum tick_broadcast_mode mode);
 static inline void tick_broadcast_control(enum tick_broadcast_mode mode) { }
 #endif /* BROADCAST */
 
-#if defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST) && defined(CONFIG_TICK_ONESHOT)
+#ifdef CONFIG_GENERIC_CLOCKEVENTS
 extern int tick_broadcast_oneshot_control(enum tick_broadcast_state state);
 #else
-static inline int tick_broadcast_oneshot_control(enum tick_broadcast_state state) { return 0; }
+static inline int tick_broadcast_oneshot_control(enum tick_broadcast_state state)
+{
+        return 0;
+}
 #endif
 
 static inline void tick_broadcast_enable(void)
diff --git a/include/linux/timekeeping.h b/include/linux/timekeeping.h
index 3aa72e648650..6e191e4e6ab6 100644
--- a/include/linux/timekeeping.h
+++ b/include/linux/timekeeping.h
@@ -145,7 +145,6 @@ static inline void getboottime(struct timespec *ts)
 }
 #endif
 
-#define do_posix_clock_monotonic_gettime(ts) ktime_get_ts(ts)
 #define ktime_get_real_ts64(ts) getnstimeofday64(ts)
 
 /*
diff --git a/include/linux/ftrace_event.h b/include/linux/trace_events.h
index f9ecf63d47f1..1063c850dbab 100644
--- a/include/linux/ftrace_event.h
+++ b/include/linux/trace_events.h
@@ -1,6 +1,6 @@
 
-#ifndef _LINUX_FTRACE_EVENT_H
-#define _LINUX_FTRACE_EVENT_H
+#ifndef _LINUX_TRACE_EVENT_H
+#define _LINUX_TRACE_EVENT_H
 
 #include <linux/ring_buffer.h>
 #include <linux/trace_seq.h>
@@ -25,35 +25,35 @@ struct trace_print_flags_u64 {
         const char              *name;
 };
 
-const char *ftrace_print_flags_seq(struct trace_seq *p, const char *delim,
-                                   unsigned long flags,
-                                   const struct trace_print_flags *flag_array);
+const char *trace_print_flags_seq(struct trace_seq *p, const char *delim,
+                                  unsigned long flags,
+                                  const struct trace_print_flags *flag_array);
 
-const char *ftrace_print_symbols_seq(struct trace_seq *p, unsigned long val,
-                                     const struct trace_print_flags *symbol_array);
+const char *trace_print_symbols_seq(struct trace_seq *p, unsigned long val,
+                                    const struct trace_print_flags *symbol_array);
 
 #if BITS_PER_LONG == 32
-const char *ftrace_print_symbols_seq_u64(struct trace_seq *p,
-                                         unsigned long long val,
-                                         const struct trace_print_flags_u64
+const char *trace_print_symbols_seq_u64(struct trace_seq *p,
+                                        unsigned long long val,
+                                        const struct trace_print_flags_u64
                                                                  *symbol_array);
 #endif
 
-const char *ftrace_print_bitmask_seq(struct trace_seq *p, void *bitmask_ptr,
-                                     unsigned int bitmask_size);
+const char *trace_print_bitmask_seq(struct trace_seq *p, void *bitmask_ptr,
+                                    unsigned int bitmask_size);
 
-const char *ftrace_print_hex_seq(struct trace_seq *p,
-                                 const unsigned char *buf, int len);
+const char *trace_print_hex_seq(struct trace_seq *p,
+                                const unsigned char *buf, int len);
 
-const char *ftrace_print_array_seq(struct trace_seq *p,
+const char *trace_print_array_seq(struct trace_seq *p,
                                    const void *buf, int count,
                                    size_t el_size);
 
 struct trace_iterator;
 struct trace_event;
 
-int ftrace_raw_output_prep(struct trace_iterator *iter,
-                           struct trace_event *event);
+int trace_raw_output_prep(struct trace_iterator *iter,
+                          struct trace_event *event);
 
 /*
  * The trace entry - the most basic unit of tracing. This is what
@@ -68,7 +68,7 @@ struct trace_entry {
         int                     pid;
 };
 
-#define FTRACE_MAX_EVENT                                                \
+#define TRACE_EVENT_TYPE_MAX                                            \
         ((1 << (sizeof(((struct trace_entry *)0)->type) * 8)) - 1)
 
 /*
@@ -132,8 +132,8 @@ struct trace_event {
         struct trace_event_functions    *funcs;
 };
 
-extern int register_ftrace_event(struct trace_event *event);
-extern int unregister_ftrace_event(struct trace_event *event);
+extern int register_trace_event(struct trace_event *event);
+extern int unregister_trace_event(struct trace_event *event);
 
 /* Return values for print_line callback */
 enum print_line_t {
@@ -157,11 +157,11 @@ static inline enum print_line_t trace_handle_return(struct trace_seq *s)
 void tracing_generic_entry_update(struct trace_entry *entry,
                                   unsigned long flags,
                                   int pc);
-struct ftrace_event_file;
+struct trace_event_file;
 
 struct ring_buffer_event *
 trace_event_buffer_lock_reserve(struct ring_buffer **current_buffer,
-                                struct ftrace_event_file *ftrace_file,
+                                struct trace_event_file *trace_file,
                                 int type, unsigned long len,
                                 unsigned long flags, int pc);
 struct ring_buffer_event *
@@ -183,7 +183,7 @@ void trace_current_buffer_discard_commit(struct ring_buffer *buffer,
 
 void tracing_record_cmdline(struct task_struct *tsk);
 
-int ftrace_output_call(struct trace_iterator *iter, char *name, char *fmt, ...);
+int trace_output_call(struct trace_iterator *iter, char *name, char *fmt, ...);
 
 struct event_filter;
 
@@ -200,50 +200,39 @@ enum trace_reg {
 #endif
 };
 
-struct ftrace_event_call;
+struct trace_event_call;
 
-struct ftrace_event_class {
+struct trace_event_class {
         const char              *system;
         void                    *probe;
 #ifdef CONFIG_PERF_EVENTS
         void                    *perf_probe;
 #endif
-        int                     (*reg)(struct ftrace_event_call *event,
+        int                     (*reg)(struct trace_event_call *event,
                                        enum trace_reg type, void *data);
-        int                     (*define_fields)(struct ftrace_event_call *);
-        struct list_head        *(*get_fields)(struct ftrace_event_call *);
+        int                     (*define_fields)(struct trace_event_call *);
+        struct list_head        *(*get_fields)(struct trace_event_call *);
         struct list_head        fields;
-        int                     (*raw_init)(struct ftrace_event_call *);
+        int                     (*raw_init)(struct trace_event_call *);
 };
 
-extern int ftrace_event_reg(struct ftrace_event_call *event,
+extern int trace_event_reg(struct trace_event_call *event,
                             enum trace_reg type, void *data);
 
-int ftrace_output_event(struct trace_iterator *iter, struct ftrace_event_call *event,
-                        char *fmt, ...);
-
-int ftrace_event_define_field(struct ftrace_event_call *call,
-                              char *type, int len, char *item, int offset,
-                              int field_size, int sign, int filter);
-
-struct ftrace_event_buffer {
+struct trace_event_buffer {
         struct ring_buffer              *buffer;
         struct ring_buffer_event        *event;
-        struct ftrace_event_file        *ftrace_file;
+        struct trace_event_file         *trace_file;
         void                            *entry;
         unsigned long                   flags;
         int                             pc;
 };
 
-void *ftrace_event_buffer_reserve(struct ftrace_event_buffer *fbuffer,
-                                  struct ftrace_event_file *ftrace_file,
+void *trace_event_buffer_reserve(struct trace_event_buffer *fbuffer,
+                                  struct trace_event_file *trace_file,
                                   unsigned long len);
 
-void ftrace_event_buffer_commit(struct ftrace_event_buffer *fbuffer);
-
-int ftrace_event_define_field(struct ftrace_event_call *call,
-                              char *type, int len, char *item, int offset,
-                              int field_size, int sign, int filter);
+void trace_event_buffer_commit(struct trace_event_buffer *fbuffer);
 
 enum {
         TRACE_EVENT_FL_FILTERED_BIT,
@@ -261,11 +250,11 @@ enum {
  *  FILTERED      - The event has a filter attached
  *  CAP_ANY       - Any user can enable for perf
  *  NO_SET_FILTER - Set when filter has error and is to be ignored
- *  IGNORE_ENABLE - For ftrace internal events, do not enable with debugfs file
+ *  IGNORE_ENABLE - For trace internal events, do not enable with debugfs file
  *  WAS_ENABLED   - Set and stays set when an event was ever enabled
  *                    (used for module unloading, if a module event is enabled,
  *                     it is best to clear the buffers that used it).
- *  USE_CALL_FILTER - For ftrace internal events, don't use file filter
+ *  USE_CALL_FILTER - For trace internal events, don't use file filter
  *  TRACEPOINT    - Event is a tracepoint
  *  KPROBE        - Event is a kprobe
  */
@@ -280,9 +269,9 @@ enum {
         TRACE_EVENT_FL_KPROBE           = (1 << TRACE_EVENT_FL_KPROBE_BIT),
 };
 
-struct ftrace_event_call {
+struct trace_event_call {
         struct list_head        list;
-        struct ftrace_event_class *class;
+        struct trace_event_class *class;
         union {
                 char                    *name;
                 /* Set TRACE_EVENT_FL_TRACEPOINT flag when using "tp" */
@@ -297,7 +286,7 @@ struct ftrace_event_call {
          *   bit 0:             filter_active
          *   bit 1:             allow trace by non root (cap any)
          *   bit 2:             failed to apply filter
-         *   bit 3:             ftrace internal event (do not enable)
+         *   bit 3:             trace internal event (do not enable)
          *   bit 4:             Event was enabled by module
          *   bit 5:             use call filter rather than file filter
          *   bit 6:             Event is a tracepoint
@@ -309,13 +298,13 @@ struct ftrace_event_call {
         struct hlist_head __percpu      *perf_events;
         struct bpf_prog                 *prog;
 
-        int     (*perf_perm)(struct ftrace_event_call *,
+        int     (*perf_perm)(struct trace_event_call *,
                              struct perf_event *);
 #endif
 };
 
 static inline const char *
-ftrace_event_name(struct ftrace_event_call *call)
+trace_event_name(struct trace_event_call *call)
 {
         if (call->flags & TRACE_EVENT_FL_TRACEPOINT)
                 return call->tp ? call->tp->name : NULL;
@@ -324,21 +313,21 @@ ftrace_event_name(struct ftrace_event_call *call)
 }
 
 struct trace_array;
-struct ftrace_subsystem_dir;
+struct trace_subsystem_dir;
 
 enum {
-        FTRACE_EVENT_FL_ENABLED_BIT,
-        FTRACE_EVENT_FL_RECORDED_CMD_BIT,
-        FTRACE_EVENT_FL_FILTERED_BIT,
-        FTRACE_EVENT_FL_NO_SET_FILTER_BIT,
-        FTRACE_EVENT_FL_SOFT_MODE_BIT,
-        FTRACE_EVENT_FL_SOFT_DISABLED_BIT,
-        FTRACE_EVENT_FL_TRIGGER_MODE_BIT,
-        FTRACE_EVENT_FL_TRIGGER_COND_BIT,
+        EVENT_FILE_FL_ENABLED_BIT,
+        EVENT_FILE_FL_RECORDED_CMD_BIT,
+        EVENT_FILE_FL_FILTERED_BIT,
+        EVENT_FILE_FL_NO_SET_FILTER_BIT,
+        EVENT_FILE_FL_SOFT_MODE_BIT,
+        EVENT_FILE_FL_SOFT_DISABLED_BIT,
+        EVENT_FILE_FL_TRIGGER_MODE_BIT,
+        EVENT_FILE_FL_TRIGGER_COND_BIT,
 };
 
 /*
- * Ftrace event file flags:
+ * Event file flags:
  *  ENABLED       - The event is enabled
  *  RECORDED_CMD  - The comms should be recorded at sched_switch
  *  FILTERED      - The event has a filter attached
@@ -350,23 +339,23 @@ enum {
  *  TRIGGER_COND  - When set, one or more triggers has an associated filter
  */
 enum {
-        FTRACE_EVENT_FL_ENABLED         = (1 << FTRACE_EVENT_FL_ENABLED_BIT),
-        FTRACE_EVENT_FL_RECORDED_CMD    = (1 << FTRACE_EVENT_FL_RECORDED_CMD_BIT),
-        FTRACE_EVENT_FL_FILTERED        = (1 << FTRACE_EVENT_FL_FILTERED_BIT),
-        FTRACE_EVENT_FL_NO_SET_FILTER   = (1 << FTRACE_EVENT_FL_NO_SET_FILTER_BIT),
-        FTRACE_EVENT_FL_SOFT_MODE       = (1 << FTRACE_EVENT_FL_SOFT_MODE_BIT),
-        FTRACE_EVENT_FL_SOFT_DISABLED   = (1 << FTRACE_EVENT_FL_SOFT_DISABLED_BIT),
-        FTRACE_EVENT_FL_TRIGGER_MODE    = (1 << FTRACE_EVENT_FL_TRIGGER_MODE_BIT),
-        FTRACE_EVENT_FL_TRIGGER_COND    = (1 << FTRACE_EVENT_FL_TRIGGER_COND_BIT),
+        EVENT_FILE_FL_ENABLED           = (1 << EVENT_FILE_FL_ENABLED_BIT),
+        EVENT_FILE_FL_RECORDED_CMD      = (1 << EVENT_FILE_FL_RECORDED_CMD_BIT),
+        EVENT_FILE_FL_FILTERED          = (1 << EVENT_FILE_FL_FILTERED_BIT),
+        EVENT_FILE_FL_NO_SET_FILTER     = (1 << EVENT_FILE_FL_NO_SET_FILTER_BIT),
+        EVENT_FILE_FL_SOFT_MODE         = (1 << EVENT_FILE_FL_SOFT_MODE_BIT),
+        EVENT_FILE_FL_SOFT_DISABLED     = (1 << EVENT_FILE_FL_SOFT_DISABLED_BIT),
+        EVENT_FILE_FL_TRIGGER_MODE      = (1 << EVENT_FILE_FL_TRIGGER_MODE_BIT),
+        EVENT_FILE_FL_TRIGGER_COND      = (1 << EVENT_FILE_FL_TRIGGER_COND_BIT),
 };
 
-struct ftrace_event_file {
+struct trace_event_file {
         struct list_head                list;
-        struct ftrace_event_call        *event_call;
+        struct trace_event_call         *event_call;
         struct event_filter             *filter;
         struct dentry                   *dir;
         struct trace_array              *tr;
-        struct ftrace_subsystem_dir     *system;
+        struct trace_subsystem_dir      *system;
         struct list_head                triggers;
 
         /*
@@ -399,7 +388,7 @@ struct ftrace_event_file {
         early_initcall(trace_init_flags_##name);
 
 #define __TRACE_EVENT_PERF_PERM(name, expr...)                          \
-        static int perf_perm_##name(struct ftrace_event_call *tp_event, \
+        static int perf_perm_##name(struct trace_event_call *tp_event, \
                                     struct perf_event *p_event)         \
         {                                                               \
                 return ({ expr; });                                     \
@@ -425,19 +414,19 @@ enum event_trigger_type {
 
 extern int filter_match_preds(struct event_filter *filter, void *rec);
 
-extern int filter_check_discard(struct ftrace_event_file *file, void *rec,
+extern int filter_check_discard(struct trace_event_file *file, void *rec,
                                 struct ring_buffer *buffer,
                                 struct ring_buffer_event *event);
-extern int call_filter_check_discard(struct ftrace_event_call *call, void *rec,
+extern int call_filter_check_discard(struct trace_event_call *call, void *rec,
                                      struct ring_buffer *buffer,
                                      struct ring_buffer_event *event);
-extern enum event_trigger_type event_triggers_call(struct ftrace_event_file *file,
+extern enum event_trigger_type event_triggers_call(struct trace_event_file *file,
                                                    void *rec);
-extern void event_triggers_post_call(struct ftrace_event_file *file,
+extern void event_triggers_post_call(struct trace_event_file *file,
                                      enum event_trigger_type tt);
 
 /**
- * ftrace_trigger_soft_disabled - do triggers and test if soft disabled
+ * trace_trigger_soft_disabled - do triggers and test if soft disabled
  * @file: The file pointer of the event to test
  *
  * If any triggers without filters are attached to this event, they
@@ -446,14 +435,14 @@ extern void event_triggers_post_call(struct ftrace_event_file *file,
  * otherwise false.
  */
 static inline bool
-ftrace_trigger_soft_disabled(struct ftrace_event_file *file)
+trace_trigger_soft_disabled(struct trace_event_file *file)
 {
         unsigned long eflags = file->flags;
 
-        if (!(eflags & FTRACE_EVENT_FL_TRIGGER_COND)) {
-                if (eflags & FTRACE_EVENT_FL_TRIGGER_MODE)
+        if (!(eflags & EVENT_FILE_FL_TRIGGER_COND)) {
+                if (eflags & EVENT_FILE_FL_TRIGGER_MODE)
                         event_triggers_call(file, NULL);
-                if (eflags & FTRACE_EVENT_FL_SOFT_DISABLED)
+                if (eflags & EVENT_FILE_FL_SOFT_DISABLED)
                         return true;
         }
         return false;
@@ -473,7 +462,7 @@ ftrace_trigger_soft_disabled(struct ftrace_event_file *file)
  * Returns true if the event is discarded, false otherwise.
  */
 static inline bool
-__event_trigger_test_discard(struct ftrace_event_file *file,
+__event_trigger_test_discard(struct trace_event_file *file,
                              struct ring_buffer *buffer,
                              struct ring_buffer_event *event,
                              void *entry,
@@ -481,10 +470,10 @@ __event_trigger_test_discard(struct ftrace_event_file *file,
 {
         unsigned long eflags = file->flags;
 
-        if (eflags & FTRACE_EVENT_FL_TRIGGER_COND)
+        if (eflags & EVENT_FILE_FL_TRIGGER_COND)
                 *tt = event_triggers_call(file, entry);
 
-        if (test_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags))
+        if (test_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags))
                 ring_buffer_discard_commit(buffer, event);
         else if (!filter_check_discard(file, entry, buffer, event))
                 return false;
@@ -506,7 +495,7 @@ __event_trigger_test_discard(struct ftrace_event_file *file,
  * if the event is soft disabled and should be discarded.
  */
 static inline void
-event_trigger_unlock_commit(struct ftrace_event_file *file,
+event_trigger_unlock_commit(struct trace_event_file *file,
                             struct ring_buffer *buffer,
                             struct ring_buffer_event *event,
                             void *entry, unsigned long irq_flags, int pc)
@@ -537,7 +526,7 @@ event_trigger_unlock_commit(struct ftrace_event_file *file,
  * trace_buffer_unlock_commit_regs() instead of trace_buffer_unlock_commit().
  */
 static inline void
-event_trigger_unlock_commit_regs(struct ftrace_event_file *file,
+event_trigger_unlock_commit_regs(struct trace_event_file *file,
                                  struct ring_buffer *buffer,
                                  struct ring_buffer_event *event,
                                  void *entry, unsigned long irq_flags, int pc,
@@ -570,12 +559,12 @@ enum {
         FILTER_TRACE_FN,
 };
 
-extern int trace_event_raw_init(struct ftrace_event_call *call);
-extern int trace_define_field(struct ftrace_event_call *call, const char *type,
+extern int trace_event_raw_init(struct trace_event_call *call);
+extern int trace_define_field(struct trace_event_call *call, const char *type,
                               const char *name, int offset, int size,
                               int is_signed, int filter_type);
-extern int trace_add_event_call(struct ftrace_event_call *call);
-extern int trace_remove_event_call(struct ftrace_event_call *call);
+extern int trace_add_event_call(struct trace_event_call *call);
+extern int trace_remove_event_call(struct trace_event_call *call);
 
 #define is_signed_type(type)    (((type)(-1)) < (type)1)
 
@@ -624,4 +613,4 @@ perf_trace_buf_submit(void *raw_data, int size, int rctx, u64 addr,
 }
 #endif
 
-#endif /* _LINUX_FTRACE_EVENT_H */
+#endif /* _LINUX_TRACE_EVENT_H */
diff --git a/include/linux/tty.h b/include/linux/tty.h
index d76631f615c2..ad6c8913aa3e 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -422,7 +422,7 @@ static inline struct tty_struct *tty_kref_get(struct tty_struct *tty)
 
 extern int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
                               const char *routine);
-extern char *tty_name(struct tty_struct *tty, char *buf);
+extern const char *tty_name(const struct tty_struct *tty);
 extern void tty_wait_until_sent(struct tty_struct *tty, long timeout);
 extern int tty_check_change(struct tty_struct *tty);
 extern void __stop_tty(struct tty_struct *tty);
diff --git a/include/linux/u64_stats_sync.h b/include/linux/u64_stats_sync.h
index 4b4439e75f45..df89c9bcba7d 100644
--- a/include/linux/u64_stats_sync.h
+++ b/include/linux/u64_stats_sync.h
@@ -68,11 +68,12 @@ struct u64_stats_sync {
 };
 
 
+static inline void u64_stats_init(struct u64_stats_sync *syncp)
+{
 #if BITS_PER_LONG == 32 && defined(CONFIG_SMP)
-# define u64_stats_init(syncp)  seqcount_init(syncp.seq)
-#else
-# define u64_stats_init(syncp)  do { } while (0)
+        seqcount_init(&syncp->seq);
 #endif
+}
 
 static inline void u64_stats_update_begin(struct u64_stats_sync *syncp)
 {
diff --git a/include/linux/ulpi/driver.h b/include/linux/ulpi/driver.h
new file mode 100644
index 000000000000..388f6e08b9d4
--- /dev/null
+++ b/include/linux/ulpi/driver.h
@@ -0,0 +1,60 @@
+#ifndef __LINUX_ULPI_DRIVER_H
+#define __LINUX_ULPI_DRIVER_H
+
+#include <linux/mod_devicetable.h>
+
+#include <linux/device.h>
+
+struct ulpi_ops;
+
+/**
+ * struct ulpi - describes ULPI PHY device
+ * @id: vendor and product ids for ULPI device
+ * @ops: I/O access
+ * @dev: device interface
+ */
+struct ulpi {
+        struct ulpi_device_id id;
+        struct ulpi_ops *ops;
+        struct device dev;
+};
+
+#define to_ulpi_dev(d) container_of(d, struct ulpi, dev)
+
+static inline void ulpi_set_drvdata(struct ulpi *ulpi, void *data)
+{
+        dev_set_drvdata(&ulpi->dev, data);
+}
+
+static inline void *ulpi_get_drvdata(struct ulpi *ulpi)
+{
+        return dev_get_drvdata(&ulpi->dev);
+}
+
+/**
+ * struct ulpi_driver - describes a ULPI PHY driver
+ * @id_table: array of device identifiers supported by this driver
+ * @probe: binds this driver to ULPI device
+ * @remove: unbinds this driver from ULPI device
+ * @driver: the name and owner members must be initialized by the drivers
+ */
+struct ulpi_driver {
+        const struct ulpi_device_id *id_table;
+        int (*probe)(struct ulpi *ulpi);
+        void (*remove)(struct ulpi *ulpi);
+        struct device_driver driver;
+};
+
+#define to_ulpi_driver(d) container_of(d, struct ulpi_driver, driver)
+
+int ulpi_register_driver(struct ulpi_driver *drv);
+void ulpi_unregister_driver(struct ulpi_driver *drv);
+
+#define module_ulpi_driver(__ulpi_driver) \
+        module_driver(__ulpi_driver, ulpi_register_driver, \
+                      ulpi_unregister_driver)
+
+int ulpi_read(struct ulpi *ulpi, u8 addr);
+int ulpi_write(struct ulpi *ulpi, u8 addr, u8 val);
+
+#endif /* __LINUX_ULPI_DRIVER_H */
diff --git a/include/linux/ulpi/interface.h b/include/linux/ulpi/interface.h
new file mode 100644
index 000000000000..4de8ab491038
--- /dev/null
+++ b/include/linux/ulpi/interface.h
@@ -0,0 +1,23 @@
+#ifndef __LINUX_ULPI_INTERFACE_H
+#define __LINUX_ULPI_INTERFACE_H
+
+#include <linux/types.h>
+
+struct ulpi;
+
+/**
+ * struct ulpi_ops - ULPI register access
+ * @dev: the interface provider
+ * @read: read operation for ULPI register access
+ * @write: write operation for ULPI register access
+ */
+struct ulpi_ops {
+        struct device *dev;
+        int (*read)(struct ulpi_ops *ops, u8 addr);
+        int (*write)(struct ulpi_ops *ops, u8 addr, u8 val);
+};
+
+struct ulpi *ulpi_register_interface(struct device *, struct ulpi_ops *);
+void ulpi_unregister_interface(struct ulpi *);
+
+#endif /* __LINUX_ULPI_INTERFACE_H */
diff --git a/include/linux/ulpi/regs.h b/include/linux/ulpi/regs.h
new file mode 100644
index 000000000000..b5b8b8804560
--- /dev/null
+++ b/include/linux/ulpi/regs.h
@@ -0,0 +1,130 @@
+#ifndef __LINUX_ULPI_REGS_H
+#define __LINUX_ULPI_REGS_H
+
+/*
+ * Macros for Set and Clear
+ * See ULPI 1.1 specification to find the registers with Set and Clear offsets
+ */
+#define ULPI_SET(a)                             (a + 1)
+#define ULPI_CLR(a)                             (a + 2)
+
+/*
+ * Register Map
+ */
+#define ULPI_VENDOR_ID_LOW                      0x00
+#define ULPI_VENDOR_ID_HIGH                     0x01
+#define ULPI_PRODUCT_ID_LOW                     0x02
+#define ULPI_PRODUCT_ID_HIGH                    0x03
+#define ULPI_FUNC_CTRL                          0x04
+#define ULPI_IFC_CTRL                           0x07
+#define ULPI_OTG_CTRL                           0x0a
+#define ULPI_USB_INT_EN_RISE                    0x0d
+#define ULPI_USB_INT_EN_FALL                    0x10
+#define ULPI_USB_INT_STS                        0x13
+#define ULPI_USB_INT_LATCH                      0x14
+#define ULPI_DEBUG                              0x15
+#define ULPI_SCRATCH                            0x16
+/* Optional Carkit Registers */
+#define ULPI_CARKIT_CTRL                        0x19
+#define ULPI_CARKIT_INT_DELAY                   0x1c
+#define ULPI_CARKIT_INT_EN                      0x1d
+#define ULPI_CARKIT_INT_STS                     0x20
+#define ULPI_CARKIT_INT_LATCH                   0x21
+#define ULPI_CARKIT_PLS_CTRL                    0x22
+/* Other Optional Registers */
+#define ULPI_TX_POS_WIDTH                       0x25
+#define ULPI_TX_NEG_WIDTH                       0x26
+#define ULPI_POLARITY_RECOVERY                  0x27
+/* Access Extended Register Set */
+#define ULPI_ACCESS_EXTENDED                    0x2f
+/* Vendor Specific */
+#define ULPI_VENDOR_SPECIFIC                    0x30
+/* Extended Registers */
+#define ULPI_EXT_VENDOR_SPECIFIC                0x80
+
+/*
+ * Register Bits
+ */
+
+/* Function Control */
+#define ULPI_FUNC_CTRL_XCVRSEL                  BIT(0)
+#define  ULPI_FUNC_CTRL_XCVRSEL_MASK            0x3
+#define  ULPI_FUNC_CTRL_HIGH_SPEED              0x0
+#define  ULPI_FUNC_CTRL_FULL_SPEED              0x1
+#define  ULPI_FUNC_CTRL_LOW_SPEED               0x2
+#define  ULPI_FUNC_CTRL_FS4LS                   0x3
+#define ULPI_FUNC_CTRL_TERMSELECT               BIT(2)
+#define ULPI_FUNC_CTRL_OPMODE                   BIT(3)
+#define  ULPI_FUNC_CTRL_OPMODE_MASK             (0x3 << 3)
+#define  ULPI_FUNC_CTRL_OPMODE_NORMAL           (0x0 << 3)
+#define  ULPI_FUNC_CTRL_OPMODE_NONDRIVING       (0x1 << 3)
+#define  ULPI_FUNC_CTRL_OPMODE_DISABLE_NRZI     (0x2 << 3)
+#define  ULPI_FUNC_CTRL_OPMODE_NOSYNC_NOEOP     (0x3 << 3)
+#define ULPI_FUNC_CTRL_RESET                    BIT(5)
+#define ULPI_FUNC_CTRL_SUSPENDM                 BIT(6)
+
+/* Interface Control */
+#define ULPI_IFC_CTRL_6_PIN_SERIAL_MODE         BIT(0)
+#define ULPI_IFC_CTRL_3_PIN_SERIAL_MODE         BIT(1)
+#define ULPI_IFC_CTRL_CARKITMODE                BIT(2)
+#define ULPI_IFC_CTRL_CLOCKSUSPENDM             BIT(3)
+#define ULPI_IFC_CTRL_AUTORESUME                BIT(4)
+#define ULPI_IFC_CTRL_EXTERNAL_VBUS             BIT(5)
+#define ULPI_IFC_CTRL_PASSTHRU                  BIT(6)
+#define ULPI_IFC_CTRL_PROTECT_IFC_DISABLE       BIT(7)
+
+/* OTG Control */
+#define ULPI_OTG_CTRL_ID_PULLUP                 BIT(0)
+#define ULPI_OTG_CTRL_DP_PULLDOWN               BIT(1)
+#define ULPI_OTG_CTRL_DM_PULLDOWN               BIT(2)
+#define ULPI_OTG_CTRL_DISCHRGVBUS               BIT(3)
+#define ULPI_OTG_CTRL_CHRGVBUS                  BIT(4)
+#define ULPI_OTG_CTRL_DRVVBUS                   BIT(5)
+#define ULPI_OTG_CTRL_DRVVBUS_EXT               BIT(6)
+#define ULPI_OTG_CTRL_EXTVBUSIND                BIT(7)
+
+/* USB Interrupt Enable Rising,
+ * USB Interrupt Enable Falling,
+ * USB Interrupt Status and
+ * USB Interrupt Latch
+ */
+#define ULPI_INT_HOST_DISCONNECT                BIT(0)
+#define ULPI_INT_VBUS_VALID                     BIT(1)
+#define ULPI_INT_SESS_VALID                     BIT(2)
+#define ULPI_INT_SESS_END                       BIT(3)
+#define ULPI_INT_IDGRD                          BIT(4)
+
+/* Debug */
+#define ULPI_DEBUG_LINESTATE0                   BIT(0)
+#define ULPI_DEBUG_LINESTATE1                   BIT(1)
+
+/* Carkit Control */
+#define ULPI_CARKIT_CTRL_CARKITPWR              BIT(0)
+#define ULPI_CARKIT_CTRL_IDGNDDRV               BIT(1)
+#define ULPI_CARKIT_CTRL_TXDEN                  BIT(2)
+#define ULPI_CARKIT_CTRL_RXDEN                  BIT(3)
+#define ULPI_CARKIT_CTRL_SPKLEFTEN              BIT(4)
+#define ULPI_CARKIT_CTRL_SPKRIGHTEN             BIT(5)
+#define ULPI_CARKIT_CTRL_MICEN                  BIT(6)
+
+/* Carkit Interrupt Enable */
+#define ULPI_CARKIT_INT_EN_IDFLOAT_RISE         BIT(0)
+#define ULPI_CARKIT_INT_EN_IDFLOAT_FALL         BIT(1)
+#define ULPI_CARKIT_INT_EN_CARINTDET            BIT(2)
+#define ULPI_CARKIT_INT_EN_DP_RISE              BIT(3)
+#define ULPI_CARKIT_INT_EN_DP_FALL              BIT(4)
+
+/* Carkit Interrupt Status and
+ * Carkit Interrupt Latch
+ */
+#define ULPI_CARKIT_INT_IDFLOAT                 BIT(0)
+#define ULPI_CARKIT_INT_CARINTDET               BIT(1)
+#define ULPI_CARKIT_INT_DP                      BIT(2)
+
+/* Carkit Pulse Control*/
+#define ULPI_CARKIT_PLS_CTRL_TXPLSEN            BIT(0)
+#define ULPI_CARKIT_PLS_CTRL_RXPLSEN            BIT(1)
+#define ULPI_CARKIT_PLS_CTRL_SPKRLEFT_BIASEN    BIT(2)
+#define ULPI_CARKIT_PLS_CTRL_SPKRRIGHT_BIASEN   BIT(3)
+
+#endif /* __LINUX_ULPI_REGS_H */
diff --git a/include/linux/usb/cdc_ncm.h b/include/linux/usb/cdc_ncm.h
index 7c9b484735c5..1f6526c76ee8 100644
--- a/include/linux/usb/cdc_ncm.h
+++ b/include/linux/usb/cdc_ncm.h
@@ -80,6 +80,9 @@
 #define CDC_NCM_TIMER_INTERVAL_MIN              5UL
 #define CDC_NCM_TIMER_INTERVAL_MAX              (U32_MAX / NSEC_PER_USEC)
 
+/* Driver flags */
+#define CDC_NCM_FLAG_NDP_TO_END 0x02            /* NDP is placed at end of frame */
+
 #define cdc_ncm_comm_intf_is_mbim(x)  ((x)->desc.bInterfaceSubClass == USB_CDC_SUBCLASS_MBIM && \
                                        (x)->desc.bInterfaceProtocol == USB_CDC_PROTO_NONE)
 #define cdc_ncm_data_intf_is_mbim(x)  ((x)->desc.bInterfaceProtocol == USB_CDC_MBIM_PROTO_NTB)
@@ -103,9 +106,11 @@ struct cdc_ncm_ctx {
 
         spinlock_t mtx;
         atomic_t stop;
+        int drvflags;
 
         u32 timer_interval;
         u32 max_ndp_size;
+        struct usb_cdc_ncm_ndp16 *delayed_ndp16;
 
         u32 tx_timer_pending;
         u32 tx_curr_frame_num;
@@ -133,7 +138,7 @@ struct cdc_ncm_ctx {
 };
 
 u8 cdc_ncm_select_altsetting(struct usb_interface *intf);
-int cdc_ncm_bind_common(struct usbnet *dev, struct usb_interface *intf, u8 data_altsetting);
+int cdc_ncm_bind_common(struct usbnet *dev, struct usb_interface *intf, u8 data_altsetting, int drvflags);
 void cdc_ncm_unbind(struct usbnet *dev, struct usb_interface *intf);
 struct sk_buff *cdc_ncm_fill_tx_frame(struct usbnet *dev, struct sk_buff *skb, __le32 sign);
 int cdc_ncm_rx_verify_nth16(struct cdc_ncm_ctx *ctx, struct sk_buff *skb_in);
diff --git a/include/linux/usb/hcd.h b/include/linux/usb/hcd.h
index 68b1e836dff1..c9aa7792de10 100644
--- a/include/linux/usb/hcd.h
+++ b/include/linux/usb/hcd.h
@@ -622,8 +622,6 @@ extern struct list_head usb_bus_list;
 extern struct mutex usb_bus_list_lock;
 extern wait_queue_head_t usb_kill_urb_queue;
 
-extern int usb_find_interface_driver(struct usb_device *dev,
-        struct usb_interface *interface);
 
 #define usb_endpoint_out(ep_dir)        (!((ep_dir) & USB_DIR_IN))
 
diff --git a/include/linux/usb/msm_hsusb.h b/include/linux/usb/msm_hsusb.h
index 7dbecf9a4656..e55a1504266e 100644
--- a/include/linux/usb/msm_hsusb.h
+++ b/include/linux/usb/msm_hsusb.h
@@ -18,6 +18,7 @@
 #ifndef __ASM_ARCH_MSM_HSUSB_H
 #define __ASM_ARCH_MSM_HSUSB_H
 
+#include <linux/extcon.h>
 #include <linux/types.h>
 #include <linux/usb/otg.h>
 #include <linux/clk.h>
@@ -120,6 +121,17 @@ struct msm_otg_platform_data {
 };
 
 /**
+ * struct msm_usb_cable - structure for exteternal connector cable
+ *                        state tracking
+ * @nb: hold event notification callback
+ * @conn: used for notification registration
+ */
+struct msm_usb_cable {
+        struct notifier_block           nb;
+        struct extcon_specific_cable_nb conn;
+};
+
+/**
  * struct msm_otg: OTG driver data. Shared by HCD and DCD.
  * @otg: USB OTG Transceiver structure.
  * @pdata: otg device platform data.
@@ -138,6 +150,11 @@ struct msm_otg_platform_data {
  * @chg_type: The type of charger attached.
  * @dcd_retires: The retry count used to track Data contact
  *               detection process.
+ * @manual_pullup: true if VBUS is not routed to USB controller/phy
+ *      and controller driver therefore enables pull-up explicitly before
+ *      starting controller using usbcmd run/stop bit.
+ * @vbus: VBUS signal state trakining, using extcon framework
+ * @id: ID signal state trakining, using extcon framework
  */
 struct msm_otg {
         struct usb_phy phy;
@@ -166,6 +183,11 @@ struct msm_otg {
         struct reset_control *phy_rst;
         struct reset_control *link_rst;
         int vdd_levels[3];
+
+        bool manual_pullup;
+
+        struct msm_usb_cable vbus;
+        struct msm_usb_cable id;
 };
 
 #endif
diff --git a/include/linux/usb/msm_hsusb_hw.h b/include/linux/usb/msm_hsusb_hw.h
index a29f6030afb1..e159b39f67a2 100644
--- a/include/linux/usb/msm_hsusb_hw.h
+++ b/include/linux/usb/msm_hsusb_hw.h
@@ -21,6 +21,8 @@
 
 #define USB_AHBBURST         (MSM_USB_BASE + 0x0090)
 #define USB_AHBMODE          (MSM_USB_BASE + 0x0098)
+#define USB_GENCONFIG_2      (MSM_USB_BASE + 0x00a0)
+
 #define USB_CAPLENGTH        (MSM_USB_BASE + 0x0100) /* 8 bit */
 
 #define USB_USBCMD           (MSM_USB_BASE + 0x0140)
@@ -30,6 +32,9 @@
 #define USB_PHY_CTRL         (MSM_USB_BASE + 0x0240)
 #define USB_PHY_CTRL2        (MSM_USB_BASE + 0x0278)
 
+#define GENCONFIG_2_SESS_VLD_CTRL_EN    BIT(7)
+#define USBCMD_SESS_VLD_CTRL            BIT(25)
+
 #define USBCMD_RESET   2
 #define USB_USBINTR          (MSM_USB_BASE + 0x0148)
 
@@ -50,6 +55,10 @@
 #define ULPI_PWR_CLK_MNG_REG    0x88
 #define OTG_COMP_DISABLE        BIT(0)
 
+#define ULPI_MISC_A                     0x96
+#define ULPI_MISC_A_VBUSVLDEXTSEL       BIT(1)
+#define ULPI_MISC_A_VBUSVLDEXT          BIT(0)
+
 #define ASYNC_INTR_CTRL         (1 << 29) /* Enable async interrupt */
 #define ULPI_STP_CTRL           (1 << 30) /* Block communication with PHY */
 #define PHY_RETEN               (1 << 1) /* PHY retention enable/disable */
diff --git a/include/linux/usb/net2280.h b/include/linux/usb/net2280.h
index 148b8fa5b1a2..725120224472 100644
--- a/include/linux/usb/net2280.h
+++ b/include/linux/usb/net2280.h
@@ -168,6 +168,9 @@ struct net2280_regs {
 #define     ENDPOINT_B_INTERRUPT                                2
 #define     ENDPOINT_A_INTERRUPT                                1
 #define     ENDPOINT_0_INTERRUPT                                0
+#define     USB3380_IRQSTAT0_EP_INTR_MASK_IN (0xF << 17)
+#define     USB3380_IRQSTAT0_EP_INTR_MASK_OUT (0xF << 1)
+
         u32             irqstat1;
 #define     POWER_STATE_CHANGE_INTERRUPT                        27
 #define     PCI_ARBITER_TIMEOUT_INTERRUPT                       26
diff --git a/include/linux/usb/phy.h b/include/linux/usb/phy.h
index bc91b5d380fd..e39f251cf861 100644
--- a/include/linux/usb/phy.h
+++ b/include/linux/usb/phy.h
@@ -205,6 +205,8 @@ extern struct usb_phy *usb_get_phy_dev(struct device *dev, u8 index);
 extern struct usb_phy *devm_usb_get_phy_dev(struct device *dev, u8 index);
 extern struct usb_phy *devm_usb_get_phy_by_phandle(struct device *dev,
         const char *phandle, u8 index);
+extern struct usb_phy *devm_usb_get_phy_by_node(struct device *dev,
+        struct device_node *node, struct notifier_block *nb);
 extern void usb_put_phy(struct usb_phy *);
 extern void devm_usb_put_phy(struct device *dev, struct usb_phy *x);
 extern int usb_bind_phy(const char *dev_name, u8 index,
@@ -238,6 +240,12 @@ static inline struct usb_phy *devm_usb_get_phy_by_phandle(struct device *dev,
         return ERR_PTR(-ENXIO);
 }
 
+static inline struct usb_phy *devm_usb_get_phy_by_node(struct device *dev,
+        struct device_node *node, struct notifier_block *nb)
+{
+        return ERR_PTR(-ENXIO);
+}
+
 static inline void usb_put_phy(struct usb_phy *x)
 {
 }
diff --git a/include/linux/usb/renesas_usbhs.h b/include/linux/usb/renesas_usbhs.h
index f06529c14141..3dd5a781da99 100644
--- a/include/linux/usb/renesas_usbhs.h
+++ b/include/linux/usb/renesas_usbhs.h
@@ -169,8 +169,7 @@ struct renesas_usbhs_driver_param {
 #define USBHS_USB_DMAC_XFER_SIZE        32      /* hardcode the xfer size */
 };
 
-#define USBHS_TYPE_R8A7790 1
-#define USBHS_TYPE_R8A7791 2
+#define USBHS_TYPE_RCAR_GEN2    1
 
 /*
  * option:
diff --git a/include/linux/usb/ulpi.h b/include/linux/usb/ulpi.h
index 5c295c26ad37..5f07407a367a 100644
--- a/include/linux/usb/ulpi.h
+++ b/include/linux/usb/ulpi.h
@@ -12,6 +12,8 @@
 #define __LINUX_USB_ULPI_H
 
 #include <linux/usb/otg.h>
+#include <linux/ulpi/regs.h>
+
 /*-------------------------------------------------------------------------*/
 
 /*
@@ -49,138 +51,6 @@
 
 /*-------------------------------------------------------------------------*/
 
-/*
- * Macros for Set and Clear
- * See ULPI 1.1 specification to find the registers with Set and Clear offsets
- */
-#define ULPI_SET(a)                             (a + 1)
-#define ULPI_CLR(a)                             (a + 2)
-
-/*-------------------------------------------------------------------------*/
-
-/*
- * Register Map
- */
-#define ULPI_VENDOR_ID_LOW                      0x00
-#define ULPI_VENDOR_ID_HIGH                     0x01
-#define ULPI_PRODUCT_ID_LOW                     0x02
-#define ULPI_PRODUCT_ID_HIGH                    0x03
-#define ULPI_FUNC_CTRL                          0x04
-#define ULPI_IFC_CTRL                           0x07
-#define ULPI_OTG_CTRL                           0x0a
-#define ULPI_USB_INT_EN_RISE                    0x0d
-#define ULPI_USB_INT_EN_FALL                    0x10
-#define ULPI_USB_INT_STS                        0x13
-#define ULPI_USB_INT_LATCH                      0x14
-#define ULPI_DEBUG                              0x15
-#define ULPI_SCRATCH                            0x16
-/* Optional Carkit Registers */
-#define ULPI_CARCIT_CTRL                        0x19
-#define ULPI_CARCIT_INT_DELAY                   0x1c
-#define ULPI_CARCIT_INT_EN                      0x1d
-#define ULPI_CARCIT_INT_STS                     0x20
-#define ULPI_CARCIT_INT_LATCH                   0x21
-#define ULPI_CARCIT_PLS_CTRL                    0x22
-/* Other Optional Registers */
-#define ULPI_TX_POS_WIDTH                       0x25
-#define ULPI_TX_NEG_WIDTH                       0x26
-#define ULPI_POLARITY_RECOVERY                  0x27
-/* Access Extended Register Set */
-#define ULPI_ACCESS_EXTENDED                    0x2f
-/* Vendor Specific */
-#define ULPI_VENDOR_SPECIFIC                    0x30
-/* Extended Registers */
-#define ULPI_EXT_VENDOR_SPECIFIC                0x80
-
-/*-------------------------------------------------------------------------*/
-
-/*
- * Register Bits
- */
-
-/* Function Control */
-#define ULPI_FUNC_CTRL_XCVRSEL                  (1 << 0)
-#define  ULPI_FUNC_CTRL_XCVRSEL_MASK            (3 << 0)
-#define  ULPI_FUNC_CTRL_HIGH_SPEED              (0 << 0)
-#define  ULPI_FUNC_CTRL_FULL_SPEED              (1 << 0)
-#define  ULPI_FUNC_CTRL_LOW_SPEED               (2 << 0)
-#define  ULPI_FUNC_CTRL_FS4LS                   (3 << 0)
-#define ULPI_FUNC_CTRL_TERMSELECT               (1 << 2)
-#define ULPI_FUNC_CTRL_OPMODE                   (1 << 3)
-#define  ULPI_FUNC_CTRL_OPMODE_MASK             (3 << 3)
-#define  ULPI_FUNC_CTRL_OPMODE_NORMAL           (0 << 3)
-#define  ULPI_FUNC_CTRL_OPMODE_NONDRIVING       (1 << 3)
-#define  ULPI_FUNC_CTRL_OPMODE_DISABLE_NRZI     (2 << 3)
-#define  ULPI_FUNC_CTRL_OPMODE_NOSYNC_NOEOP     (3 << 3)
-#define ULPI_FUNC_CTRL_RESET                    (1 << 5)
-#define ULPI_FUNC_CTRL_SUSPENDM                 (1 << 6)
-
-/* Interface Control */
-#define ULPI_IFC_CTRL_6_PIN_SERIAL_MODE         (1 << 0)
-#define ULPI_IFC_CTRL_3_PIN_SERIAL_MODE         (1 << 1)
-#define ULPI_IFC_CTRL_CARKITMODE                (1 << 2)
-#define ULPI_IFC_CTRL_CLOCKSUSPENDM             (1 << 3)
-#define ULPI_IFC_CTRL_AUTORESUME                (1 << 4)
-#define ULPI_IFC_CTRL_EXTERNAL_VBUS             (1 << 5)
-#define ULPI_IFC_CTRL_PASSTHRU                  (1 << 6)
-#define ULPI_IFC_CTRL_PROTECT_IFC_DISABLE       (1 << 7)
-
-/* OTG Control */
-#define ULPI_OTG_CTRL_ID_PULLUP                 (1 << 0)
-#define ULPI_OTG_CTRL_DP_PULLDOWN               (1 << 1)
-#define ULPI_OTG_CTRL_DM_PULLDOWN               (1 << 2)
-#define ULPI_OTG_CTRL_DISCHRGVBUS               (1 << 3)
-#define ULPI_OTG_CTRL_CHRGVBUS                  (1 << 4)
-#define ULPI_OTG_CTRL_DRVVBUS                   (1 << 5)
-#define ULPI_OTG_CTRL_DRVVBUS_EXT               (1 << 6)
-#define ULPI_OTG_CTRL_EXTVBUSIND                (1 << 7)
-
-/* USB Interrupt Enable Rising,
- * USB Interrupt Enable Falling,
- * USB Interrupt Status and
- * USB Interrupt Latch
- */
-#define ULPI_INT_HOST_DISCONNECT                (1 << 0)
-#define ULPI_INT_VBUS_VALID                     (1 << 1)
-#define ULPI_INT_SESS_VALID                     (1 << 2)
-#define ULPI_INT_SESS_END                       (1 << 3)
-#define ULPI_INT_IDGRD                          (1 << 4)
-
-/* Debug */
-#define ULPI_DEBUG_LINESTATE0                   (1 << 0)
-#define ULPI_DEBUG_LINESTATE1                   (1 << 1)
-
-/* Carkit Control */
-#define ULPI_CARKIT_CTRL_CARKITPWR              (1 << 0)
-#define ULPI_CARKIT_CTRL_IDGNDDRV               (1 << 1)
-#define ULPI_CARKIT_CTRL_TXDEN                  (1 << 2)
-#define ULPI_CARKIT_CTRL_RXDEN                  (1 << 3)
-#define ULPI_CARKIT_CTRL_SPKLEFTEN              (1 << 4)
-#define ULPI_CARKIT_CTRL_SPKRIGHTEN             (1 << 5)
-#define ULPI_CARKIT_CTRL_MICEN                  (1 << 6)
-
-/* Carkit Interrupt Enable */
-#define ULPI_CARKIT_INT_EN_IDFLOAT_RISE         (1 << 0)
-#define ULPI_CARKIT_INT_EN_IDFLOAT_FALL         (1 << 1)
-#define ULPI_CARKIT_INT_EN_CARINTDET            (1 << 2)
-#define ULPI_CARKIT_INT_EN_DP_RISE              (1 << 3)
-#define ULPI_CARKIT_INT_EN_DP_FALL              (1 << 4)
-
-/* Carkit Interrupt Status and
- * Carkit Interrupt Latch
- */
-#define ULPI_CARKIT_INT_IDFLOAT                 (1 << 0)
-#define ULPI_CARKIT_INT_CARINTDET               (1 << 1)
-#define ULPI_CARKIT_INT_DP                      (1 << 2)
-
-/* Carkit Pulse Control*/
-#define ULPI_CARKIT_PLS_CTRL_TXPLSEN            (1 << 0)
-#define ULPI_CARKIT_PLS_CTRL_RXPLSEN            (1 << 1)
-#define ULPI_CARKIT_PLS_CTRL_SPKRLEFT_BIASEN    (1 << 2)
-#define ULPI_CARKIT_PLS_CTRL_SPKRRIGHT_BIASEN   (1 << 3)
-
-/*-------------------------------------------------------------------------*/
-
 #if IS_ENABLED(CONFIG_USB_ULPI)
 struct usb_phy *otg_ulpi_create(struct usb_phy_io_ops *ops,
                                         unsigned int flags);
diff --git a/include/linux/usb/usb338x.h b/include/linux/usb/usb338x.h
index f92eb635b9d3..11525d8d89a7 100644
--- a/include/linux/usb/usb338x.h
+++ b/include/linux/usb/usb338x.h
@@ -43,6 +43,10 @@
 #define     IN_ENDPOINT_TYPE                    12
 #define     OUT_ENDPOINT_ENABLE                 10
 #define     OUT_ENDPOINT_TYPE                    8
+#define USB3380_EP_CFG_MASK_IN ((0x3 << IN_ENDPOINT_TYPE) | \
+                                BIT(IN_ENDPOINT_ENABLE))
+#define USB3380_EP_CFG_MASK_OUT ((0x3 << OUT_ENDPOINT_TYPE) | \
+                                BIT(OUT_ENDPOINT_ENABLE))
 
 struct usb338x_usb_ext_regs {
         u32     usbclass;
diff --git a/include/linux/virtio_byteorder.h b/include/linux/virtio_byteorder.h
index 51865d05b267..ce63a2c3a612 100644
--- a/include/linux/virtio_byteorder.h
+++ b/include/linux/virtio_byteorder.h
@@ -3,17 +3,21 @@
 #include <linux/types.h>
 #include <uapi/linux/virtio_types.h>
 
-/*
- * Low-level memory accessors for handling virtio in modern little endian and in
- * compatibility native endian format.
- */
+static inline bool virtio_legacy_is_little_endian(void)
+{
+#ifdef __LITTLE_ENDIAN
+        return true;
+#else
+        return false;
+#endif
+}
 
 static inline u16 __virtio16_to_cpu(bool little_endian, __virtio16 val)
 {
         if (little_endian)
                 return le16_to_cpu((__force __le16)val);
         else
-                return (__force u16)val;
+                return be16_to_cpu((__force __be16)val);
 }
 
 static inline __virtio16 __cpu_to_virtio16(bool little_endian, u16 val)
@@ -21,7 +25,7 @@ static inline __virtio16 __cpu_to_virtio16(bool little_endian, u16 val)
         if (little_endian)
                 return (__force __virtio16)cpu_to_le16(val);
         else
-                return (__force __virtio16)val;
+                return (__force __virtio16)cpu_to_be16(val);
 }
 
 static inline u32 __virtio32_to_cpu(bool little_endian, __virtio32 val)
@@ -29,7 +33,7 @@ static inline u32 __virtio32_to_cpu(bool little_endian, __virtio32 val)
         if (little_endian)
                 return le32_to_cpu((__force __le32)val);
         else
-                return (__force u32)val;
+                return be32_to_cpu((__force __be32)val);
 }
 
 static inline __virtio32 __cpu_to_virtio32(bool little_endian, u32 val)
@@ -37,7 +41,7 @@ static inline __virtio32 __cpu_to_virtio32(bool little_endian, u32 val)
         if (little_endian)
                 return (__force __virtio32)cpu_to_le32(val);
         else
-                return (__force __virtio32)val;
+                return (__force __virtio32)cpu_to_be32(val);
 }
 
 static inline u64 __virtio64_to_cpu(bool little_endian, __virtio64 val)
@@ -45,7 +49,7 @@ static inline u64 __virtio64_to_cpu(bool little_endian, __virtio64 val)
         if (little_endian)
                 return le64_to_cpu((__force __le64)val);
         else
-                return (__force u64)val;
+                return be64_to_cpu((__force __be64)val);
 }
 
 static inline __virtio64 __cpu_to_virtio64(bool little_endian, u64 val)
@@ -53,7 +57,7 @@ static inline __virtio64 __cpu_to_virtio64(bool little_endian, u64 val)
         if (little_endian)
                 return (__force __virtio64)cpu_to_le64(val);
         else
-                return (__force __virtio64)val;
+                return (__force __virtio64)cpu_to_be64(val);
 }
 
 #endif /* _LINUX_VIRTIO_BYTEORDER */
diff --git a/include/linux/virtio_config.h b/include/linux/virtio_config.h
index 1e306f727edc..e5ce8ab0b8b0 100644
--- a/include/linux/virtio_config.h
+++ b/include/linux/virtio_config.h
@@ -205,35 +205,41 @@ int virtqueue_set_affinity(struct virtqueue *vq, int cpu)
         return 0;
 }
 
+static inline bool virtio_is_little_endian(struct virtio_device *vdev)
+{
+        return virtio_has_feature(vdev, VIRTIO_F_VERSION_1) ||
+                virtio_legacy_is_little_endian();
+}
+
 /* Memory accessors */
 static inline u16 virtio16_to_cpu(struct virtio_device *vdev, __virtio16 val)
 {
-        return __virtio16_to_cpu(virtio_has_feature(vdev, VIRTIO_F_VERSION_1), val);
+        return __virtio16_to_cpu(virtio_is_little_endian(vdev), val);
 }
 
 static inline __virtio16 cpu_to_virtio16(struct virtio_device *vdev, u16 val)
 {
-        return __cpu_to_virtio16(virtio_has_feature(vdev, VIRTIO_F_VERSION_1), val);
+        return __cpu_to_virtio16(virtio_is_little_endian(vdev), val);
 }
 
 static inline u32 virtio32_to_cpu(struct virtio_device *vdev, __virtio32 val)
 {
-        return __virtio32_to_cpu(virtio_has_feature(vdev, VIRTIO_F_VERSION_1), val);
+        return __virtio32_to_cpu(virtio_is_little_endian(vdev), val);
 }
 
 static inline __virtio32 cpu_to_virtio32(struct virtio_device *vdev, u32 val)
 {
-        return __cpu_to_virtio32(virtio_has_feature(vdev, VIRTIO_F_VERSION_1), val);
+        return __cpu_to_virtio32(virtio_is_little_endian(vdev), val);
 }
 
 static inline u64 virtio64_to_cpu(struct virtio_device *vdev, __virtio64 val)
 {
-        return __virtio64_to_cpu(virtio_has_feature(vdev, VIRTIO_F_VERSION_1), val);
+        return __virtio64_to_cpu(virtio_is_little_endian(vdev), val);
 }
 
 static inline __virtio64 cpu_to_virtio64(struct virtio_device *vdev, u64 val)
 {
-        return __cpu_to_virtio64(virtio_has_feature(vdev, VIRTIO_F_VERSION_1), val);
+        return __cpu_to_virtio64(virtio_is_little_endian(vdev), val);
 }
 
 /* Config space accessors. */
diff --git a/include/linux/vme.h b/include/linux/vme.h
index 79242e9c06b8..c0131358f351 100644
--- a/include/linux/vme.h
+++ b/include/linux/vme.h
@@ -120,6 +120,8 @@ void vme_free_consistent(struct vme_resource *, size_t,  void *,
         dma_addr_t);
 
 size_t vme_get_size(struct vme_resource *);
+int vme_check_window(u32 aspace, unsigned long long vme_base,
+                     unsigned long long size);
 
 struct vme_resource *vme_slave_request(struct vme_dev *, u32, u32);
 int vme_slave_set(struct vme_resource *, int, unsigned long long,
diff --git a/include/linux/vringh.h b/include/linux/vringh.h
index a3fa537e717a..bc6c28d04263 100644
--- a/include/linux/vringh.h
+++ b/include/linux/vringh.h
@@ -226,33 +226,39 @@ static inline void vringh_notify(struct vringh *vrh)
                 vrh->notify(vrh);
 }
 
+static inline bool vringh_is_little_endian(const struct vringh *vrh)
+{
+        return vrh->little_endian ||
+                virtio_legacy_is_little_endian();
+}
+
 static inline u16 vringh16_to_cpu(const struct vringh *vrh, __virtio16 val)
 {
-        return __virtio16_to_cpu(vrh->little_endian, val);
+        return __virtio16_to_cpu(vringh_is_little_endian(vrh), val);
 }
 
 static inline __virtio16 cpu_to_vringh16(const struct vringh *vrh, u16 val)
 {
-        return __cpu_to_virtio16(vrh->little_endian, val);
+        return __cpu_to_virtio16(vringh_is_little_endian(vrh), val);
 }
 
 static inline u32 vringh32_to_cpu(const struct vringh *vrh, __virtio32 val)
 {
-        return __virtio32_to_cpu(vrh->little_endian, val);
+        return __virtio32_to_cpu(vringh_is_little_endian(vrh), val);
 }
 
 static inline __virtio32 cpu_to_vringh32(const struct vringh *vrh, u32 val)
 {
-        return __cpu_to_virtio32(vrh->little_endian, val);
+        return __cpu_to_virtio32(vringh_is_little_endian(vrh), val);
 }
 
 static inline u64 vringh64_to_cpu(const struct vringh *vrh, __virtio64 val)
 {
-        return __virtio64_to_cpu(vrh->little_endian, val);
+        return __virtio64_to_cpu(vringh_is_little_endian(vrh), val);
 }
 
 static inline __virtio64 cpu_to_vringh64(const struct vringh *vrh, u64 val)
 {
-        return __cpu_to_virtio64(vrh->little_endian, val);
+        return __cpu_to_virtio64(vringh_is_little_endian(vrh), val);
 }
 #endif /* _LINUX_VRINGH_H */
diff --git a/include/linux/wait.h b/include/linux/wait.h
index d69ac4ecc88b..1e1bf9f963a9 100644
--- a/include/linux/wait.h
+++ b/include/linux/wait.h
@@ -358,6 +358,19 @@ do {									\
         __ret;                                                          \
 })
 
+#define __wait_event_exclusive_cmd(wq, condition, cmd1, cmd2)           \
+        (void)___wait_event(wq, condition, TASK_UNINTERRUPTIBLE, 1, 0,  \
+                            cmd1; schedule(); cmd2)
+/*
+ * Just like wait_event_cmd(), except it sets exclusive flag
+ */
+#define wait_event_exclusive_cmd(wq, condition, cmd1, cmd2)             \
+do {                                                                    \
+        if (condition)                                                  \
+                break;                                                  \
+        __wait_event_exclusive_cmd(wq, condition, cmd1, cmd2);          \
+} while (0)
+
 #define __wait_event_cmd(wq, condition, cmd1, cmd2)                     \
         (void)___wait_event(wq, condition, TASK_UNINTERRUPTIBLE, 0, 0,  \
                             cmd1; schedule(); cmd2)
diff --git a/include/linux/watchdog.h b/include/linux/watchdog.h
index a746bf5216f8..f47feada5b42 100644
--- a/include/linux/watchdog.h
+++ b/include/linux/watchdog.h
@@ -65,6 +65,8 @@ struct watchdog_ops {
  * @driver-data:Pointer to the drivers private data.
  * @lock:       Lock for watchdog core internal use only.
  * @status:     Field that contains the devices internal status bits.
+ * @deferred: entry in wtd_deferred_reg_list which is used to
+ *                         register early initialized watchdogs.
  *
  * The watchdog_device structure contains all information about a
  * watchdog timer device.
@@ -95,6 +97,7 @@ struct watchdog_device {
 #define WDOG_ALLOW_RELEASE      2       /* Did we receive the magic char ? */
 #define WDOG_NO_WAY_OUT         3       /* Is 'nowayout' feature set ? */
 #define WDOG_UNREGISTERED       4       /* Has the device been unregistered */
+        struct list_head deferred;
 };
 
 #define WATCHDOG_NOWAYOUT               IS_BUILTIN(CONFIG_WATCHDOG_NOWAYOUT)
diff --git a/include/linux/workqueue.h b/include/linux/workqueue.h
index deee212af8e0..738b30b39b68 100644
--- a/include/linux/workqueue.h
+++ b/include/linux/workqueue.h
@@ -424,6 +424,7 @@ struct workqueue_attrs *alloc_workqueue_attrs(gfp_t gfp_mask);
 void free_workqueue_attrs(struct workqueue_attrs *attrs);
 int apply_workqueue_attrs(struct workqueue_struct *wq,
                           const struct workqueue_attrs *attrs);
+int workqueue_set_unbound_cpumask(cpumask_var_t cpumask);
 
 extern bool queue_work_on(int cpu, struct workqueue_struct *wq,
                         struct work_struct *work);
@@ -434,7 +435,6 @@ extern bool mod_delayed_work_on(int cpu, struct workqueue_struct *wq,
 
 extern void flush_workqueue(struct workqueue_struct *wq);
 extern void drain_workqueue(struct workqueue_struct *wq);
-extern void flush_scheduled_work(void);
 
 extern int schedule_on_each_cpu(work_func_t func);
 
@@ -531,6 +531,35 @@ static inline bool schedule_work(struct work_struct *work)
 }
 
 /**
+ * flush_scheduled_work - ensure that any scheduled work has run to completion.
+ *
+ * Forces execution of the kernel-global workqueue and blocks until its
+ * completion.
+ *
+ * Think twice before calling this function!  It's very easy to get into
+ * trouble if you don't take great care.  Either of the following situations
+ * will lead to deadlock:
+ *
+ *      One of the work items currently on the workqueue needs to acquire
+ *      a lock held by your code or its caller.
+ *
+ *      Your code is running in the context of a work routine.
+ *
+ * They will be detected by lockdep when they occur, but the first might not
+ * occur very often.  It depends on what work items are on the workqueue and
+ * what locks they need, which you have no control over.
+ *
+ * In most situations flushing the entire workqueue is overkill; you merely
+ * need to know that a particular work item isn't queued and isn't running.
+ * In such cases you should use cancel_delayed_work_sync() or
+ * cancel_work_sync() instead.
+ */
+static inline void flush_scheduled_work(void)
+{
+        flush_workqueue(system_wq);
+}
+
+/**
  * schedule_delayed_work_on - queue work in global workqueue on CPU after delay
  * @cpu: cpu to use
  * @dwork: job to be done
diff --git a/include/linux/writeback.h b/include/linux/writeback.h
index b2dd371ec0ca..b333c945e571 100644
--- a/include/linux/writeback.h
+++ b/include/linux/writeback.h
@@ -7,6 +7,8 @@
 #include <linux/sched.h>
 #include <linux/workqueue.h>
 #include <linux/fs.h>
+#include <linux/flex_proportions.h>
+#include <linux/backing-dev-defs.h>
 
 DECLARE_PER_CPU(int, dirty_throttle_leaks);
 
@@ -84,18 +86,95 @@ struct writeback_control {
         unsigned for_reclaim:1;         /* Invoked from the page allocator */
         unsigned range_cyclic:1;        /* range_start is cyclic */
         unsigned for_sync:1;            /* sync(2) WB_SYNC_ALL writeback */
+#ifdef CONFIG_CGROUP_WRITEBACK
+        struct bdi_writeback *wb;       /* wb this writeback is issued under */
+        struct inode *inode;            /* inode being written out */
+
+        /* foreign inode detection, see wbc_detach_inode() */
+        int wb_id;                      /* current wb id */
+        int wb_lcand_id;                /* last foreign candidate wb id */
+        int wb_tcand_id;                /* this foreign candidate wb id */
+        size_t wb_bytes;                /* bytes written by current wb */
+        size_t wb_lcand_bytes;          /* bytes written by last candidate */
+        size_t wb_tcand_bytes;          /* bytes written by this candidate */
+#endif
 };
 
 /*
+ * A wb_domain represents a domain that wb's (bdi_writeback's) belong to
+ * and are measured against each other in.  There always is one global
+ * domain, global_wb_domain, that every wb in the system is a member of.
+ * This allows measuring the relative bandwidth of each wb to distribute
+ * dirtyable memory accordingly.
+ */
+struct wb_domain {
+        spinlock_t lock;
+
+        /*
+         * Scale the writeback cache size proportional to the relative
+         * writeout speed.
+         *
+         * We do this by keeping a floating proportion between BDIs, based
+         * on page writeback completions [end_page_writeback()]. Those
+         * devices that write out pages fastest will get the larger share,
+         * while the slower will get a smaller share.
+         *
+         * We use page writeout completions because we are interested in
+         * getting rid of dirty pages. Having them written out is the
+         * primary goal.
+         *
+         * We introduce a concept of time, a period over which we measure
+         * these events, because demand can/will vary over time. The length
+         * of this period itself is measured in page writeback completions.
+         */
+        struct fprop_global completions;
+        struct timer_list period_timer; /* timer for aging of completions */
+        unsigned long period_time;
+
+        /*
+         * The dirtyable memory and dirty threshold could be suddenly
+         * knocked down by a large amount (eg. on the startup of KVM in a
+         * swapless system). This may throw the system into deep dirty
+         * exceeded state and throttle heavy/light dirtiers alike. To
+         * retain good responsiveness, maintain global_dirty_limit for
+         * tracking slowly down to the knocked down dirty threshold.
+         *
+         * Both fields are protected by ->lock.
+         */
+        unsigned long dirty_limit_tstamp;
+        unsigned long dirty_limit;
+};
+
+/**
+ * wb_domain_size_changed - memory available to a wb_domain has changed
+ * @dom: wb_domain of interest
+ *
+ * This function should be called when the amount of memory available to
+ * @dom has changed.  It resets @dom's dirty limit parameters to prevent
+ * the past values which don't match the current configuration from skewing
+ * dirty throttling.  Without this, when memory size of a wb_domain is
+ * greatly reduced, the dirty throttling logic may allow too many pages to
+ * be dirtied leading to consecutive unnecessary OOMs and may get stuck in
+ * that situation.
+ */
+static inline void wb_domain_size_changed(struct wb_domain *dom)
+{
+        spin_lock(&dom->lock);
+        dom->dirty_limit_tstamp = jiffies;
+        dom->dirty_limit = 0;
+        spin_unlock(&dom->lock);
+}
+
+/*
  * fs/fs-writeback.c
  */     
 struct bdi_writeback;
 void writeback_inodes_sb(struct super_block *, enum wb_reason reason);
 void writeback_inodes_sb_nr(struct super_block *, unsigned long nr,
                                                         enum wb_reason reason);
-int try_to_writeback_inodes_sb(struct super_block *, enum wb_reason reason);
-int try_to_writeback_inodes_sb_nr(struct super_block *, unsigned long nr,
-                                  enum wb_reason reason);
+bool try_to_writeback_inodes_sb(struct super_block *, enum wb_reason reason);
+bool try_to_writeback_inodes_sb_nr(struct super_block *, unsigned long nr,
+                                   enum wb_reason reason);
 void sync_inodes_sb(struct super_block *);
 void wakeup_flusher_threads(long nr_pages, enum wb_reason reason);
 void inode_wait_for_writeback(struct inode *inode);
@@ -107,6 +186,123 @@ static inline void wait_on_inode(struct inode *inode)
         wait_on_bit(&inode->i_state, __I_NEW, TASK_UNINTERRUPTIBLE);
 }
 
+#ifdef CONFIG_CGROUP_WRITEBACK
+
+#include <linux/cgroup.h>
+#include <linux/bio.h>
+
+void __inode_attach_wb(struct inode *inode, struct page *page);
+void wbc_attach_and_unlock_inode(struct writeback_control *wbc,
+                                 struct inode *inode)
+        __releases(&inode->i_lock);
+void wbc_detach_inode(struct writeback_control *wbc);
+void wbc_account_io(struct writeback_control *wbc, struct page *page,
+                    size_t bytes);
+
+/**
+ * inode_attach_wb - associate an inode with its wb
+ * @inode: inode of interest
+ * @page: page being dirtied (may be NULL)
+ *
+ * If @inode doesn't have its wb, associate it with the wb matching the
+ * memcg of @page or, if @page is NULL, %current.  May be called w/ or w/o
+ * @inode->i_lock.
+ */
+static inline void inode_attach_wb(struct inode *inode, struct page *page)
+{
+        if (!inode->i_wb)
+                __inode_attach_wb(inode, page);
+}
+
+/**
+ * inode_detach_wb - disassociate an inode from its wb
+ * @inode: inode of interest
+ *
+ * @inode is being freed.  Detach from its wb.
+ */
+static inline void inode_detach_wb(struct inode *inode)
+{
+        if (inode->i_wb) {
+                wb_put(inode->i_wb);
+                inode->i_wb = NULL;
+        }
+}
+
+/**
+ * wbc_attach_fdatawrite_inode - associate wbc and inode for fdatawrite
+ * @wbc: writeback_control of interest
+ * @inode: target inode
+ *
+ * This function is to be used by __filemap_fdatawrite_range(), which is an
+ * alternative entry point into writeback code, and first ensures @inode is
+ * associated with a bdi_writeback and attaches it to @wbc.
+ */
+static inline void wbc_attach_fdatawrite_inode(struct writeback_control *wbc,
+                                               struct inode *inode)
+{
+        spin_lock(&inode->i_lock);
+        inode_attach_wb(inode, NULL);
+        wbc_attach_and_unlock_inode(wbc, inode);
+}
+
+/**
+ * wbc_init_bio - writeback specific initializtion of bio
+ * @wbc: writeback_control for the writeback in progress
+ * @bio: bio to be initialized
+ *
+ * @bio is a part of the writeback in progress controlled by @wbc.  Perform
+ * writeback specific initialization.  This is used to apply the cgroup
+ * writeback context.
+ */
+static inline void wbc_init_bio(struct writeback_control *wbc, struct bio *bio)
+{
+        /*
+         * pageout() path doesn't attach @wbc to the inode being written
+         * out.  This is intentional as we don't want the function to block
+         * behind a slow cgroup.  Ultimately, we want pageout() to kick off
+         * regular writeback instead of writing things out itself.
+         */
+        if (wbc->wb)
+                bio_associate_blkcg(bio, wbc->wb->blkcg_css);
+}
+
+#else   /* CONFIG_CGROUP_WRITEBACK */
+
+static inline void inode_attach_wb(struct inode *inode, struct page *page)
+{
+}
+
+static inline void inode_detach_wb(struct inode *inode)
+{
+}
+
+static inline void wbc_attach_and_unlock_inode(struct writeback_control *wbc,
+                                               struct inode *inode)
+        __releases(&inode->i_lock)
+{
+        spin_unlock(&inode->i_lock);
+}
+
+static inline void wbc_attach_fdatawrite_inode(struct writeback_control *wbc,
+                                               struct inode *inode)
+{
+}
+
+static inline void wbc_detach_inode(struct writeback_control *wbc)
+{
+}
+
+static inline void wbc_init_bio(struct writeback_control *wbc, struct bio *bio)
+{
+}
+
+static inline void wbc_account_io(struct writeback_control *wbc,
+                                  struct page *page, size_t bytes)
+{
+}
+
+#endif  /* CONFIG_CGROUP_WRITEBACK */
+
 /*
  * mm/page-writeback.c
  */
@@ -120,8 +316,12 @@ static inline void laptop_sync_completion(void) { }
 #endif
 void throttle_vm_writeout(gfp_t gfp_mask);
 bool zone_dirty_ok(struct zone *zone);
+int wb_domain_init(struct wb_domain *dom, gfp_t gfp);
+#ifdef CONFIG_CGROUP_WRITEBACK
+void wb_domain_exit(struct wb_domain *dom);
+#endif
 
-extern unsigned long global_dirty_limit;
+extern struct wb_domain global_wb_domain;
 
 /* These are exported to sysctl. */
 extern int dirty_background_ratio;
@@ -155,19 +355,12 @@ int dirty_writeback_centisecs_handler(struct ctl_table *, int,
                                       void __user *, size_t *, loff_t *);
 
 void global_dirty_limits(unsigned long *pbackground, unsigned long *pdirty);
-unsigned long bdi_dirty_limit(struct backing_dev_info *bdi,
-                               unsigned long dirty);
-
-void __bdi_update_bandwidth(struct backing_dev_info *bdi,
-                            unsigned long thresh,
-                            unsigned long bg_thresh,
-                            unsigned long dirty,
-                            unsigned long bdi_thresh,
-                            unsigned long bdi_dirty,
-                            unsigned long start_time);
+unsigned long wb_calc_thresh(struct bdi_writeback *wb, unsigned long thresh);
 
+void wb_update_bandwidth(struct bdi_writeback *wb, unsigned long start_time);
 void page_writeback_init(void);
 void balance_dirty_pages_ratelimited(struct address_space *mapping);
+bool wb_over_bg_thresh(struct bdi_writeback *wb);
 
 typedef int (*writepage_t)(struct page *page, struct writeback_control *wbc,
                                 void *data);
diff --git a/include/linux/zpool.h b/include/linux/zpool.h
index 56529b34dc63..d30eff3d84d5 100644
--- a/include/linux/zpool.h
+++ b/include/linux/zpool.h
@@ -81,7 +81,8 @@ struct zpool_driver {
         atomic_t refcount;
         struct list_head list;
 
-        void *(*create)(char *name, gfp_t gfp, struct zpool_ops *ops);
+        void *(*create)(char *name, gfp_t gfp, struct zpool_ops *ops,
+                        struct zpool *zpool);
         void (*destroy)(void *pool);
 
         int (*malloc)(void *pool, size_t size, gfp_t gfp,
@@ -102,6 +103,4 @@ void zpool_register_driver(struct zpool_driver *driver);
 
 int zpool_unregister_driver(struct zpool_driver *driver);
 
-int zpool_evict(void *pool, unsigned long handle);
-
 #endif
diff --git a/include/media/adp1653.h b/include/media/adp1653.h
index 1d9b48a3bd80..9779c8549eb4 100644
--- a/include/media/adp1653.h
+++ b/include/media/adp1653.h
@@ -100,9 +100,11 @@ struct adp1653_platform_data {
         int (*power)(struct v4l2_subdev *sd, int on);
 
         u32 max_flash_timeout;          /* flash light timeout in us */
-        u32 max_flash_intensity;        /* led intensity, flash mode */
-        u32 max_torch_intensity;        /* led intensity, torch mode */
-        u32 max_indicator_intensity;    /* indicator led intensity */
+        u32 max_flash_intensity;        /* led intensity, flash mode, mA */
+        u32 max_torch_intensity;        /* led intensity, torch mode, mA */
+        u32 max_indicator_intensity;    /* indicator led intensity, uA */
+
+        struct gpio_desc *enable_gpio;  /* for device-tree based boot */
 };
 
 #define to_adp1653_flash(sd)    container_of(sd, struct adp1653_flash, subdev)
diff --git a/include/media/adv7511.h b/include/media/adv7511.h
index bb78bed9a5b8..d83b91d80764 100644
--- a/include/media/adv7511.h
+++ b/include/media/adv7511.h
@@ -40,9 +40,10 @@ struct adv7511_cec_arg {
 };
 
 struct adv7511_platform_data {
-        uint8_t i2c_edid;
-        uint8_t i2c_cec;
-        uint32_t cec_clk;
+        u8 i2c_edid;
+        u8 i2c_cec;
+        u8 i2c_pktmem;
+        u32 cec_clk;
 };
 
 #endif
diff --git a/include/media/adv7604.h b/include/media/adv7604.h
index 9ecf353160c1..a913859bfd30 100644
--- a/include/media/adv7604.h
+++ b/include/media/adv7604.h
@@ -168,6 +168,5 @@ enum adv76xx_pad {
 
 /* notify events */
 #define ADV76XX_HOTPLUG         1
-#define ADV76XX_FMT_CHANGE      2
 
 #endif
diff --git a/include/media/adv7842.h b/include/media/adv7842.h
index 924cbb8d004a..bc249709bf35 100644
--- a/include/media/adv7842.h
+++ b/include/media/adv7842.h
@@ -30,14 +30,38 @@ enum adv7842_ain_sel {
         ADV7842_AIN9_4_5_6_SYNC_2_1 = 4,
 };
 
-/* Bus rotation and reordering (IO register 0x04, [7:5]) */
-enum adv7842_op_ch_sel {
-        ADV7842_OP_CH_SEL_GBR = 0,
-        ADV7842_OP_CH_SEL_GRB = 1,
-        ADV7842_OP_CH_SEL_BGR = 2,
-        ADV7842_OP_CH_SEL_RGB = 3,
-        ADV7842_OP_CH_SEL_BRG = 4,
-        ADV7842_OP_CH_SEL_RBG = 5,
+/*
+ * Bus rotation and reordering. This is used to specify component reordering on
+ * the board and describes the components order on the bus when the ADV7842
+ * outputs RGB.
+ */
+enum adv7842_bus_order {
+        ADV7842_BUS_ORDER_RGB,          /* No operation */
+        ADV7842_BUS_ORDER_GRB,          /* Swap 1-2     */
+        ADV7842_BUS_ORDER_RBG,          /* Swap 2-3     */
+        ADV7842_BUS_ORDER_BGR,          /* Swap 1-3     */
+        ADV7842_BUS_ORDER_BRG,          /* Rotate right */
+        ADV7842_BUS_ORDER_GBR,          /* Rotate left  */
+};
+
+/* Input Color Space (IO register 0x02, [7:4]) */
+enum adv7842_inp_color_space {
+        ADV7842_INP_COLOR_SPACE_LIM_RGB = 0,
+        ADV7842_INP_COLOR_SPACE_FULL_RGB = 1,
+        ADV7842_INP_COLOR_SPACE_LIM_YCbCr_601 = 2,
+        ADV7842_INP_COLOR_SPACE_LIM_YCbCr_709 = 3,
+        ADV7842_INP_COLOR_SPACE_XVYCC_601 = 4,
+        ADV7842_INP_COLOR_SPACE_XVYCC_709 = 5,
+        ADV7842_INP_COLOR_SPACE_FULL_YCbCr_601 = 6,
+        ADV7842_INP_COLOR_SPACE_FULL_YCbCr_709 = 7,
+        ADV7842_INP_COLOR_SPACE_AUTO = 0xf,
+};
+
+/* Select output format (IO register 0x03, [4:2]) */
+enum adv7842_op_format_mode_sel {
+        ADV7842_OP_FORMAT_MODE0 = 0x00,
+        ADV7842_OP_FORMAT_MODE1 = 0x04,
+        ADV7842_OP_FORMAT_MODE2 = 0x08,
 };
 
 /* Mode of operation */
@@ -61,44 +85,6 @@ enum adv7842_vid_std_select {
         ADV7842_HDMI_COMP_VID_STD_HD_1250P = 0x1e,
 };
 
-/* Input Color Space (IO register 0x02, [7:4]) */
-enum adv7842_inp_color_space {
-        ADV7842_INP_COLOR_SPACE_LIM_RGB = 0,
-        ADV7842_INP_COLOR_SPACE_FULL_RGB = 1,
-        ADV7842_INP_COLOR_SPACE_LIM_YCbCr_601 = 2,
-        ADV7842_INP_COLOR_SPACE_LIM_YCbCr_709 = 3,
-        ADV7842_INP_COLOR_SPACE_XVYCC_601 = 4,
-        ADV7842_INP_COLOR_SPACE_XVYCC_709 = 5,
-        ADV7842_INP_COLOR_SPACE_FULL_YCbCr_601 = 6,
-        ADV7842_INP_COLOR_SPACE_FULL_YCbCr_709 = 7,
-        ADV7842_INP_COLOR_SPACE_AUTO = 0xf,
-};
-
-/* Select output format (IO register 0x03, [7:0]) */
-enum adv7842_op_format_sel {
-        ADV7842_OP_FORMAT_SEL_SDR_ITU656_8 = 0x00,
-        ADV7842_OP_FORMAT_SEL_SDR_ITU656_10 = 0x01,
-        ADV7842_OP_FORMAT_SEL_SDR_ITU656_12_MODE0 = 0x02,
-        ADV7842_OP_FORMAT_SEL_SDR_ITU656_12_MODE1 = 0x06,
-        ADV7842_OP_FORMAT_SEL_SDR_ITU656_12_MODE2 = 0x0a,
-        ADV7842_OP_FORMAT_SEL_DDR_422_8 = 0x20,
-        ADV7842_OP_FORMAT_SEL_DDR_422_10 = 0x21,
-        ADV7842_OP_FORMAT_SEL_DDR_422_12_MODE0 = 0x22,
-        ADV7842_OP_FORMAT_SEL_DDR_422_12_MODE1 = 0x23,
-        ADV7842_OP_FORMAT_SEL_DDR_422_12_MODE2 = 0x24,
-        ADV7842_OP_FORMAT_SEL_SDR_444_24 = 0x40,
-        ADV7842_OP_FORMAT_SEL_SDR_444_30 = 0x41,
-        ADV7842_OP_FORMAT_SEL_SDR_444_36_MODE0 = 0x42,
-        ADV7842_OP_FORMAT_SEL_DDR_444_24 = 0x60,
-        ADV7842_OP_FORMAT_SEL_DDR_444_30 = 0x61,
-        ADV7842_OP_FORMAT_SEL_DDR_444_36 = 0x62,
-        ADV7842_OP_FORMAT_SEL_SDR_ITU656_16 = 0x80,
-        ADV7842_OP_FORMAT_SEL_SDR_ITU656_20 = 0x81,
-        ADV7842_OP_FORMAT_SEL_SDR_ITU656_24_MODE0 = 0x82,
-        ADV7842_OP_FORMAT_SEL_SDR_ITU656_24_MODE1 = 0x86,
-        ADV7842_OP_FORMAT_SEL_SDR_ITU656_24_MODE2 = 0x8a,
-};
-
 enum adv7842_select_input {
         ADV7842_SELECT_HDMI_PORT_A,
         ADV7842_SELECT_HDMI_PORT_B,
@@ -117,35 +103,35 @@ enum adv7842_drive_strength {
 
 struct adv7842_sdp_csc_coeff {
         bool manual;
-        uint16_t scaling;
-        uint16_t A1;
-        uint16_t A2;
-        uint16_t A3;
-        uint16_t A4;
-        uint16_t B1;
-        uint16_t B2;
-        uint16_t B3;
-        uint16_t B4;
-        uint16_t C1;
-        uint16_t C2;
-        uint16_t C3;
-        uint16_t C4;
+        u16 scaling;
+        u16 A1;
+        u16 A2;
+        u16 A3;
+        u16 A4;
+        u16 B1;
+        u16 B2;
+        u16 B3;
+        u16 B4;
+        u16 C1;
+        u16 C2;
+        u16 C3;
+        u16 C4;
 };
 
 struct adv7842_sdp_io_sync_adjustment {
         bool adjust;
-        uint16_t hs_beg;
-        uint16_t hs_width;
-        uint16_t de_beg;
-        uint16_t de_end;
-        uint8_t vs_beg_o;
-        uint8_t vs_beg_e;
-        uint8_t vs_end_o;
-        uint8_t vs_end_e;
-        uint8_t de_v_beg_o;
-        uint8_t de_v_beg_e;
-        uint8_t de_v_end_o;
-        uint8_t de_v_end_e;
+        u16 hs_beg;
+        u16 hs_width;
+        u16 de_beg;
+        u16 de_end;
+        u8 vs_beg_o;
+        u8 vs_beg_e;
+        u8 vs_end_o;
+        u8 vs_end_e;
+        u8 de_v_beg_o;
+        u8 de_v_beg_e;
+        u8 de_v_end_o;
+        u8 de_v_end_e;
 };
 
 /* Platform dependent definition */
@@ -163,7 +149,10 @@ struct adv7842_platform_data {
         enum adv7842_ain_sel ain_sel;
 
         /* Bus rotation and reordering */
-        enum adv7842_op_ch_sel op_ch_sel;
+        enum adv7842_bus_order bus_order;
+
+        /* Select output format mode */
+        enum adv7842_op_format_mode_sel op_format_mode_sel;
 
         /* Default mode */
         enum adv7842_mode mode;
@@ -174,20 +163,15 @@ struct adv7842_platform_data {
         /* Video standard */
         enum adv7842_vid_std_select vid_std_select;
 
-        /* Select output format */
-        enum adv7842_op_format_sel op_format_sel;
-
         /* IO register 0x02 */
         unsigned alt_gamma:1;
         unsigned op_656_range:1;
-        unsigned rgb_out:1;
         unsigned alt_data_sat:1;
 
         /* IO register 0x05 */
         unsigned blank_data:1;
         unsigned insert_av_codes:1;
         unsigned replicate_av_codes:1;
-        unsigned invert_cbcr:1;
 
         /* IO register 0x30 */
         unsigned output_bus_lsb_to_msb:1;
@@ -246,9 +230,6 @@ struct adv7842_platform_data {
 #define V4L2_CID_ADV_RX_FREE_RUN_COLOR_MANUAL   (V4L2_CID_DV_CLASS_BASE + 0x1001)
 #define V4L2_CID_ADV_RX_FREE_RUN_COLOR          (V4L2_CID_DV_CLASS_BASE + 0x1002)
 
-/* notify events */
-#define ADV7842_FMT_CHANGE      1
-
 /* custom ioctl, used to test the external RAM that's used by the
  * deinterlacer. */
 #define ADV7842_CMD_RAM_TEST _IO('V', BASE_VIDIOC_PRIVATE)
@@ -256,5 +237,6 @@ struct adv7842_platform_data {
 #define ADV7842_EDID_PORT_A   0
 #define ADV7842_EDID_PORT_B   1
 #define ADV7842_EDID_PORT_VGA 2
+#define ADV7842_PAD_SOURCE    3
 
 #endif
diff --git a/include/media/rc-core.h b/include/media/rc-core.h
index 2c7fbca40b69..45534da57759 100644
--- a/include/media/rc-core.h
+++ b/include/media/rc-core.h
@@ -74,6 +74,8 @@ enum rc_filter_type {
  * @input_dev: the input child device used to communicate events to userspace
  * @driver_type: specifies if protocol decoding is done in hardware or software
  * @idle: used to keep track of RX state
+ * @encode_wakeup: wakeup filtering uses IR encode API, therefore the allowed
+ *      wakeup protocols is the set of all raw encoders
  * @allowed_protocols: bitmask with the supported RC_BIT_* protocols
  * @enabled_protocols: bitmask with the enabled RC_BIT_* protocols
  * @allowed_wakeup_protocols: bitmask with the supported RC_BIT_* wakeup protocols
@@ -134,6 +136,7 @@ struct rc_dev {
         struct input_dev                *input_dev;
         enum rc_driver_type             driver_type;
         bool                            idle;
+        bool                            encode_wakeup;
         u64                             allowed_protocols;
         u64                             enabled_protocols;
         u64                             allowed_wakeup_protocols;
@@ -239,10 +242,11 @@ static inline void init_ir_raw_event(struct ir_raw_event *ev)
         memset(ev, 0, sizeof(*ev));
 }
 
-#define IR_MAX_DURATION         0xFFFFFFFF      /* a bit more than 4 seconds */
+#define IR_MAX_DURATION         500000000       /* 500 ms */
 #define US_TO_NS(usec)          ((usec) * 1000)
 #define MS_TO_US(msec)          ((msec) * 1000)
 #define MS_TO_NS(msec)          ((msec) * 1000 * 1000)
+#define NS_TO_US(nsec)          DIV_ROUND_UP(nsec, 1000L)
 
 void ir_raw_event_handle(struct rc_dev *dev);
 int ir_raw_event_store(struct rc_dev *dev, struct ir_raw_event *ev);
@@ -250,6 +254,9 @@ int ir_raw_event_store_edge(struct rc_dev *dev, enum raw_event_type type);
 int ir_raw_event_store_with_filter(struct rc_dev *dev,
                                 struct ir_raw_event *ev);
 void ir_raw_event_set_idle(struct rc_dev *dev, bool idle);
+int ir_raw_encode_scancode(u64 protocols,
+                           const struct rc_scancode_filter *scancode,
+                           struct ir_raw_event *events, unsigned int max);
 
 static inline void ir_raw_event_reset(struct rc_dev *dev)
 {
diff --git a/include/media/rc-map.h b/include/media/rc-map.h
index e7a1514075ec..27763d5bd261 100644
--- a/include/media/rc-map.h
+++ b/include/media/rc-map.h
@@ -194,7 +194,10 @@ void rc_map_init(void);
 #define RC_MAP_SNAPSTREAM_FIREFLY        "rc-snapstream-firefly"
 #define RC_MAP_STREAMZAP                 "rc-streamzap"
 #define RC_MAP_TBS_NEC                   "rc-tbs-nec"
+#define RC_MAP_TECHNISAT_TS35            "rc-technisat-ts35"
 #define RC_MAP_TECHNISAT_USB2            "rc-technisat-usb2"
+#define RC_MAP_TERRATEC_CINERGY_C_PCI    "rc-terratec-cinergy-c-pci"
+#define RC_MAP_TERRATEC_CINERGY_S2_HD    "rc-terratec-cinergy-s2-hd"
 #define RC_MAP_TERRATEC_CINERGY_XS       "rc-terratec-cinergy-xs"
 #define RC_MAP_TERRATEC_SLIM             "rc-terratec-slim"
 #define RC_MAP_TERRATEC_SLIM_2           "rc-terratec-slim-2"
@@ -204,6 +207,7 @@ void rc_map_init(void);
 #define RC_MAP_TOTAL_MEDIA_IN_HAND_02    "rc-total-media-in-hand-02"
 #define RC_MAP_TREKSTOR                  "rc-trekstor"
 #define RC_MAP_TT_1500                   "rc-tt-1500"
+#define RC_MAP_TWINHAN_DTV_CAB_CI        "rc-twinhan-dtv-cab-ci"
 #define RC_MAP_TWINHAN_VP1027_DVBS       "rc-twinhan1027"
 #define RC_MAP_VIDEOMATE_K100            "rc-videomate-k100"
 #define RC_MAP_VIDEOMATE_S350            "rc-videomate-s350"
diff --git a/include/media/v4l2-dv-timings.h b/include/media/v4l2-dv-timings.h
index 4becc6716393..eecd3102a618 100644
--- a/include/media/v4l2-dv-timings.h
+++ b/include/media/v4l2-dv-timings.h
@@ -117,6 +117,7 @@ void v4l2_print_dv_timings(const char *dev_prefix, const char *prefix,
  * @vsync - the height of the vertical sync in lines.
  * @polarities - the horizontal and vertical polarities (same as struct
  *              v4l2_bt_timings polarities).
+ * @interlaced - if this flag is true, it indicates interlaced format
  * @fmt - the resulting timings.
  *
  * This function will attempt to detect if the given values correspond to a
@@ -124,7 +125,7 @@ void v4l2_print_dv_timings(const char *dev_prefix, const char *prefix,
  * in with the found CVT timings.
  */
 bool v4l2_detect_cvt(unsigned frame_height, unsigned hfreq, unsigned vsync,
-                u32 polarities, struct v4l2_dv_timings *fmt);
+                u32 polarities, bool interlaced, struct v4l2_dv_timings *fmt);
 
 /** v4l2_detect_gtf - detect if the given timings follow the GTF standard
  * @frame_height - the total height of the frame (including blanking) in lines.
@@ -132,6 +133,7 @@ bool v4l2_detect_cvt(unsigned frame_height, unsigned hfreq, unsigned vsync,
  * @vsync - the height of the vertical sync in lines.
  * @polarities - the horizontal and vertical polarities (same as struct
  *              v4l2_bt_timings polarities).
+ * @interlaced - if this flag is true, it indicates interlaced format
  * @aspect - preferred aspect ratio. GTF has no method of determining the
  *              aspect ratio in order to derive the image width from the
  *              image height, so it has to be passed explicitly. Usually
@@ -144,7 +146,7 @@ bool v4l2_detect_cvt(unsigned frame_height, unsigned hfreq, unsigned vsync,
  * in with the found GTF timings.
  */
 bool v4l2_detect_gtf(unsigned frame_height, unsigned hfreq, unsigned vsync,
-                u32 polarities, struct v4l2_fract aspect,
+                u32 polarities, bool interlaced, struct v4l2_fract aspect,
                 struct v4l2_dv_timings *fmt);
 
 /** v4l2_calc_aspect_ratio - calculate the aspect ratio based on bytes
diff --git a/include/media/v4l2-flash-led-class.h b/include/media/v4l2-flash-led-class.h
new file mode 100644
index 000000000000..098236c083b8
--- /dev/null
+++ b/include/media/v4l2-flash-led-class.h
@@ -0,0 +1,148 @@
+/*
+ * V4L2 flash LED sub-device registration helpers.
+ *
+ *      Copyright (C) 2015 Samsung Electronics Co., Ltd
+ *      Author: Jacek Anaszewski <j.anaszewski@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef _V4L2_FLASH_H
+#define _V4L2_FLASH_H
+
+#include <media/v4l2-ctrls.h>
+#include <media/v4l2-subdev.h>
+
+struct led_classdev_flash;
+struct led_classdev;
+struct v4l2_flash;
+enum led_brightness;
+
+/*
+ * struct v4l2_flash_ctrl_data - flash control initialization data, filled
+ *                              basing on the features declared by the LED flash
+ *                              class driver in the v4l2_flash_config
+ * @config:     initialization data for a control
+ * @cid:        contains v4l2 flash control id if the config
+ *              field was initialized, 0 otherwise
+ */
+struct v4l2_flash_ctrl_data {
+        struct v4l2_ctrl_config config;
+        u32 cid;
+};
+
+struct v4l2_flash_ops {
+        /* setup strobing the flash by hardware pin state assertion */
+        int (*external_strobe_set)(struct v4l2_flash *v4l2_flash,
+                                        bool enable);
+        /* convert intensity to brightness in a device specific manner */
+        enum led_brightness (*intensity_to_led_brightness)
+                (struct v4l2_flash *v4l2_flash, s32 intensity);
+        /* convert brightness to intensity in a device specific manner */
+        s32 (*led_brightness_to_intensity)
+                (struct v4l2_flash *v4l2_flash, enum led_brightness);
+};
+
+/**
+ * struct v4l2_flash_config - V4L2 Flash sub-device initialization data
+ * @dev_name:                   the name of the media entity,
+                                unique in the system
+ * @torch_intensity:            constraints for the LED in torch mode
+ * @indicator_intensity:        constraints for the indicator LED
+ * @flash_faults:               bitmask of flash faults that the LED flash class
+                                device can report; corresponding LED_FAULT* bit
+                                definitions are available in the header file
+                                <linux/led-class-flash.h>
+ * @has_external_strobe:        external strobe capability
+ */
+struct v4l2_flash_config {
+        char dev_name[32];
+        struct led_flash_setting torch_intensity;
+        struct led_flash_setting indicator_intensity;
+        u32 flash_faults;
+        unsigned int has_external_strobe:1;
+};
+
+/**
+ * struct v4l2_flash - Flash sub-device context
+ * @fled_cdev:          LED flash class device controlled by this sub-device
+ * @iled_cdev:          LED class device representing indicator LED associated
+ *                      with the LED flash class device
+ * @ops:                V4L2 specific flash ops
+ * @sd:                 V4L2 sub-device
+ * @hdl:                flash controls handler
+ * @ctrls:              array of pointers to controls, whose values define
+ *                      the sub-device state
+ */
+struct v4l2_flash {
+        struct led_classdev_flash *fled_cdev;
+        struct led_classdev_flash *iled_cdev;
+        const struct v4l2_flash_ops *ops;
+
+        struct v4l2_subdev sd;
+        struct v4l2_ctrl_handler hdl;
+        struct v4l2_ctrl **ctrls;
+};
+
+static inline struct v4l2_flash *v4l2_subdev_to_v4l2_flash(
+                                                        struct v4l2_subdev *sd)
+{
+        return container_of(sd, struct v4l2_flash, sd);
+}
+
+static inline struct v4l2_flash *v4l2_ctrl_to_v4l2_flash(struct v4l2_ctrl *c)
+{
+        return container_of(c->handler, struct v4l2_flash, hdl);
+}
+
+#if IS_ENABLED(CONFIG_V4L2_FLASH_LED_CLASS)
+/**
+ * v4l2_flash_init - initialize V4L2 flash led sub-device
+ * @dev:        flash device, e.g. an I2C device
+ * @of_node:    of_node of the LED, may be NULL if the same as device's
+ * @fled_cdev:  LED flash class device to wrap
+ * @iled_cdev:  LED flash class device representing indicator LED associated
+ *              with fled_cdev, may be NULL
+ * @flash_ops:  V4L2 Flash device ops
+ * @config:     initialization data for V4L2 Flash sub-device
+ *
+ * Create V4L2 Flash sub-device wrapping given LED subsystem device.
+ *
+ * Returns: A valid pointer, or, when an error occurs, the return
+ * value is encoded using ERR_PTR(). Use IS_ERR() to check and
+ * PTR_ERR() to obtain the numeric return value.
+ */
+struct v4l2_flash *v4l2_flash_init(
+        struct device *dev, struct device_node *of_node,
+        struct led_classdev_flash *fled_cdev,
+        struct led_classdev_flash *iled_cdev,
+        const struct v4l2_flash_ops *ops,
+        struct v4l2_flash_config *config);
+
+/**
+ * v4l2_flash_release - release V4L2 Flash sub-device
+ * @flash: the V4L2 Flash sub-device to release
+ *
+ * Release V4L2 Flash sub-device.
+ */
+void v4l2_flash_release(struct v4l2_flash *v4l2_flash);
+
+#else
+static inline struct v4l2_flash *v4l2_flash_init(
+        struct device *dev, struct device_node *of_node,
+        struct led_classdev_flash *fled_cdev,
+        struct led_classdev_flash *iled_cdev,
+        const struct v4l2_flash_ops *ops,
+        struct v4l2_flash_config *config)
+{
+        return NULL;
+}
+
+static inline void v4l2_flash_release(struct v4l2_flash *v4l2_flash)
+{
+}
+#endif /* CONFIG_V4L2_FLASH_LED_CLASS */
+
+#endif /* _V4L2_FLASH_H */
diff --git a/include/media/v4l2-mediabus.h b/include/media/v4l2-mediabus.h
index 38d960d8dccd..73069e4c2796 100644
--- a/include/media/v4l2-mediabus.h
+++ b/include/media/v4l2-mediabus.h
@@ -96,6 +96,7 @@ static inline void v4l2_fill_pix_format(struct v4l2_pix_format *pix_fmt,
         pix_fmt->colorspace = mbus_fmt->colorspace;
         pix_fmt->ycbcr_enc = mbus_fmt->ycbcr_enc;
         pix_fmt->quantization = mbus_fmt->quantization;
+        pix_fmt->xfer_func = mbus_fmt->xfer_func;
 }
 
 static inline void v4l2_fill_mbus_format(struct v4l2_mbus_framefmt *mbus_fmt,
@@ -108,6 +109,7 @@ static inline void v4l2_fill_mbus_format(struct v4l2_mbus_framefmt *mbus_fmt,
         mbus_fmt->colorspace = pix_fmt->colorspace;
         mbus_fmt->ycbcr_enc = pix_fmt->ycbcr_enc;
         mbus_fmt->quantization = pix_fmt->quantization;
+        mbus_fmt->xfer_func = pix_fmt->xfer_func;
         mbus_fmt->code = code;
 }
 
diff --git a/include/media/v4l2-mem2mem.h b/include/media/v4l2-mem2mem.h
index c5f3914bc4d8..3bbd96da25c9 100644
--- a/include/media/v4l2-mem2mem.h
+++ b/include/media/v4l2-mem2mem.h
@@ -116,6 +116,8 @@ int v4l2_m2m_qbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
                   struct v4l2_buffer *buf);
 int v4l2_m2m_dqbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
                    struct v4l2_buffer *buf);
+int v4l2_m2m_prepare_buf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
+                         struct v4l2_buffer *buf);
 int v4l2_m2m_create_bufs(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
                          struct v4l2_create_buffers *create);
 
@@ -248,6 +250,8 @@ int v4l2_m2m_ioctl_qbuf(struct file *file, void *fh,
                                 struct v4l2_buffer *buf);
 int v4l2_m2m_ioctl_dqbuf(struct file *file, void *fh,
                                 struct v4l2_buffer *buf);
+int v4l2_m2m_ioctl_prepare_buf(struct file *file, void *fh,
+                               struct v4l2_buffer *buf);
 int v4l2_m2m_ioctl_streamon(struct file *file, void *fh,
                                 enum v4l2_buf_type type);
 int v4l2_m2m_ioctl_streamoff(struct file *file, void *fh,
diff --git a/include/media/v4l2-of.h b/include/media/v4l2-of.h
index f831c9c225b6..4dc34b245d47 100644
--- a/include/media/v4l2-of.h
+++ b/include/media/v4l2-of.h
@@ -57,16 +57,19 @@ struct v4l2_of_bus_parallel {
  * @base: struct of_endpoint containing port, id, and local of_node
  * @bus_type: bus type
  * @bus: bus configuration data structure
- * @head: list head for this structure
+ * @link_frequencies: array of supported link frequencies
+ * @nr_of_link_frequencies: number of elements in link_frequenccies array
  */
 struct v4l2_of_endpoint {
         struct of_endpoint base;
+        /* Fields below this line will be zeroed by v4l2_of_parse_endpoint() */
         enum v4l2_mbus_type bus_type;
         union {
                 struct v4l2_of_bus_parallel parallel;
                 struct v4l2_of_bus_mipi_csi2 mipi_csi2;
         } bus;
-        struct list_head head;
+        u64 *link_frequencies;
+        unsigned int nr_of_link_frequencies;
 };
 
 /**
@@ -86,6 +89,9 @@ struct v4l2_of_link {
 #ifdef CONFIG_OF
 int v4l2_of_parse_endpoint(const struct device_node *node,
                            struct v4l2_of_endpoint *endpoint);
+struct v4l2_of_endpoint *v4l2_of_alloc_parse_endpoint(
+        const struct device_node *node);
+void v4l2_of_free_endpoint(struct v4l2_of_endpoint *endpoint);
 int v4l2_of_parse_link(const struct device_node *node,
                        struct v4l2_of_link *link);
 void v4l2_of_put_link(struct v4l2_of_link *link);
@@ -97,6 +103,16 @@ static inline int v4l2_of_parse_endpoint(const struct device_node *node,
         return -ENOSYS;
 }
 
+static inline struct v4l2_of_endpoint *v4l2_of_alloc_parse_endpoint(
+        const struct device_node *node)
+{
+        return NULL;
+}
+
+static inline void v4l2_of_free_endpoint(struct v4l2_of_endpoint *endpoint)
+{
+}
+
 static inline int v4l2_of_parse_link(const struct device_node *node,
                                      struct v4l2_of_link *link)
 {
diff --git a/include/media/v4l2-subdev.h b/include/media/v4l2-subdev.h
index 2f0a345a7fed..4e18318eb425 100644
--- a/include/media/v4l2-subdev.h
+++ b/include/media/v4l2-subdev.h
@@ -40,6 +40,8 @@
 #define V4L2_SUBDEV_IR_TX_NOTIFY                _IOW('v', 1, u32)
 #define V4L2_SUBDEV_IR_TX_FIFO_SERVICE_REQ      0x00000001
 
+#define V4L2_DEVICE_NOTIFY_EVENT                _IOW('v', 2, struct v4l2_event)
+
 struct v4l2_device;
 struct v4l2_ctrl_handler;
 struct v4l2_event_subscription;
@@ -293,14 +295,6 @@ struct v4l2_mbus_frame_desc {
 
    g_dv_timings(): Get custom dv timings in the sub device.
 
-   enum_mbus_fmt: enumerate pixel formats, provided by a video data source
-
-   g_mbus_fmt: get the current pixel format, provided by a video data source
-
-   try_mbus_fmt: try to set a pixel format on a video data source
-
-   s_mbus_fmt: set a pixel format on a video data source
-
    g_mbus_config: get supported mediabus configurations
 
    s_mbus_config: set a certain mediabus configuration. This operation is added
@@ -338,14 +332,6 @@ struct v4l2_subdev_video_ops {
                         struct v4l2_dv_timings *timings);
         int (*query_dv_timings)(struct v4l2_subdev *sd,
                         struct v4l2_dv_timings *timings);
-        int (*enum_mbus_fmt)(struct v4l2_subdev *sd, unsigned int index,
-                             u32 *code);
-        int (*g_mbus_fmt)(struct v4l2_subdev *sd,
-                          struct v4l2_mbus_framefmt *fmt);
-        int (*try_mbus_fmt)(struct v4l2_subdev *sd,
-                            struct v4l2_mbus_framefmt *fmt);
-        int (*s_mbus_fmt)(struct v4l2_subdev *sd,
-                          struct v4l2_mbus_framefmt *fmt);
         int (*g_mbus_config)(struct v4l2_subdev *sd,
                              struct v4l2_mbus_config *cfg);
         int (*s_mbus_config)(struct v4l2_subdev *sd,
@@ -619,6 +605,8 @@ struct v4l2_subdev {
         struct video_device *devnode;
         /* pointer to the physical device, if any */
         struct device *dev;
+        /* The device_node of the subdev, usually the same as dev->of_node. */
+        struct device_node *of_node;
         /* Links this subdev to a global subdev_list or @notifier->done list. */
         struct list_head async_list;
         /* Pointer to respective struct v4l2_async_subdev. */
diff --git a/include/media/videobuf2-core.h b/include/media/videobuf2-core.h
index a5790fd5d125..22a44c2f5963 100644
--- a/include/media/videobuf2-core.h
+++ b/include/media/videobuf2-core.h
@@ -381,6 +381,9 @@ struct v4l2_fh;
  * @waiting_for_buffers: used in poll() to check if vb2 is still waiting for
  *              buffers. Only set for capture queues if qbuf has not yet been
  *              called since poll() needs to return POLLERR in that situation.
+ * @last_buffer_dequeued: used in poll() and DQBUF to immediately return if the
+ *              last decoded buffer was already dequeued. Set for capture queues
+ *              when a buffer with the V4L2_BUF_FLAG_LAST is dequeued.
  * @fileio:     file io emulator internal data, used only if emulator is active
  * @threadio:   thread io internal data, used only if thread is active
  */
@@ -423,6 +426,7 @@ struct vb2_queue {
         unsigned int                    start_streaming_called:1;
         unsigned int                    error:1;
         unsigned int                    waiting_for_buffers:1;
+        unsigned int                    last_buffer_dequeued:1;
 
         struct vb2_fileio_data          *fileio;
         struct vb2_threadio_data        *threadio;
@@ -603,6 +607,15 @@ static inline bool vb2_start_streaming_called(struct vb2_queue *q)
         return q->start_streaming_called;
 }
 
+/**
+ * vb2_clear_last_buffer_dequeued() - clear last buffer dequeued flag of queue
+ * @q:          videobuf queue
+ */
+static inline void vb2_clear_last_buffer_dequeued(struct vb2_queue *q)
+{
+        q->last_buffer_dequeued = false;
+}
+
 /*
  * The following functions are not part of the vb2 core API, but are simple
  * helper functions that you can use in your struct v4l2_file_operations,
diff --git a/include/misc/cxl-base.h b/include/misc/cxl-base.h
new file mode 100644
index 000000000000..5ae962512fb8
--- /dev/null
+++ b/include/misc/cxl-base.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2014 IBM Corp.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#ifndef _MISC_CXL_BASE_H
+#define _MISC_CXL_BASE_H
+
+#ifdef CONFIG_CXL_BASE
+
+#define CXL_IRQ_RANGES 4
+
+struct cxl_irq_ranges {
+        irq_hw_number_t offset[CXL_IRQ_RANGES];
+        irq_hw_number_t range[CXL_IRQ_RANGES];
+};
+
+extern atomic_t cxl_use_count;
+
+static inline bool cxl_ctx_in_use(void)
+{
+       return (atomic_read(&cxl_use_count) != 0);
+}
+
+static inline void cxl_ctx_get(void)
+{
+       atomic_inc(&cxl_use_count);
+}
+
+static inline void cxl_ctx_put(void)
+{
+       atomic_dec(&cxl_use_count);
+}
+
+void cxl_slbia(struct mm_struct *mm);
+
+#else /* CONFIG_CXL_BASE */
+
+static inline bool cxl_ctx_in_use(void) { return false; }
+static inline void cxl_slbia(struct mm_struct *mm) {}
+
+#endif /* CONFIG_CXL_BASE */
+
+#endif
diff --git a/include/misc/cxl.h b/include/misc/cxl.h
index 975cc7861f18..7a6c1d6cc173 100644
--- a/include/misc/cxl.h
+++ b/include/misc/cxl.h
@@ -1,5 +1,5 @@
 /*
- * Copyright 2014 IBM Corp.
+ * Copyright 2015 IBM Corp.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -10,39 +10,194 @@
 #ifndef _MISC_CXL_H
 #define _MISC_CXL_H
 
-#ifdef CONFIG_CXL_BASE
+#include <linux/pci.h>
+#include <linux/poll.h>
+#include <linux/interrupt.h>
+#include <uapi/misc/cxl.h>
 
-#define CXL_IRQ_RANGES 4
+/*
+ * This documents the in kernel API for driver to use CXL. It allows kernel
+ * drivers to bind to AFUs using an AFU configuration record exposed as a PCI
+ * configuration record.
+ *
+ * This API enables control over AFU and contexts which can't be part of the
+ * generic PCI API. This API is agnostic to the actual AFU.
+ */
+
+/* Get the AFU associated with a pci_dev */
+struct cxl_afu *cxl_pci_to_afu(struct pci_dev *dev);
+
+/* Get the AFU conf record number associated with a pci_dev */
+unsigned int cxl_pci_to_cfg_record(struct pci_dev *dev);
+
+/* Get the physical device (ie. the PCIe card) which the AFU is attached */
+struct device *cxl_get_phys_dev(struct pci_dev *dev);
+
+
+/*
+ * Context lifetime overview:
+ *
+ * An AFU context may be inited and then started and stoppped multiple times
+ * before it's released. ie.
+ *    - cxl_dev_context_init()
+ *      - cxl_start_context()
+ *      - cxl_stop_context()
+ *      - cxl_start_context()
+ *      - cxl_stop_context()
+ *     ...repeat...
+ *    - cxl_release_context()
+ * Once released, a context can't be started again.
+ *
+ * One context is inited by the cxl driver for every pci_dev. This is to be
+ * used as a default kernel context. cxl_get_context() will get this
+ * context. This context will be released by PCI hot unplug, so doesn't need to
+ * be released explicitly by drivers.
+ *
+ * Additional kernel contexts may be inited using cxl_dev_context_init().
+ * These must be released using cxl_context_detach().
+ *
+ * Once a context has been inited, IRQs may be configured. Firstly these IRQs
+ * must be allocated (cxl_allocate_afu_irqs()), then individually mapped to
+ * specific handlers (cxl_map_afu_irq()).
+ *
+ * These IRQs can be unmapped (cxl_unmap_afu_irq()) and finally released
+ * (cxl_free_afu_irqs()).
+ *
+ * The AFU can be reset (cxl_afu_reset()). This will cause the PSL/AFU
+ * hardware to lose track of all contexts. It's upto the caller of
+ * cxl_afu_reset() to restart these contexts.
+ */
+
+/*
+ * On pci_enabled_device(), the cxl driver will init a single cxl context for
+ * use by the driver. It doesn't start this context (as that will likely
+ * generate DMA traffic for most AFUs).
+ *
+ * This gets the default context associated with this pci_dev.  This context
+ * doesn't need to be released as this will be done by the PCI subsystem on hot
+ * unplug.
+ */
+struct cxl_context *cxl_get_context(struct pci_dev *dev);
+/*
+ * Allocate and initalise a context associated with a AFU PCI device. This
+ * doesn't start the context in the AFU.
+ */
+struct cxl_context *cxl_dev_context_init(struct pci_dev *dev);
+/*
+ * Release and free a context. Context should be stopped before calling.
+ */
+int cxl_release_context(struct cxl_context *ctx);
 
-struct cxl_irq_ranges {
-        irq_hw_number_t offset[CXL_IRQ_RANGES];
-        irq_hw_number_t range[CXL_IRQ_RANGES];
-};
+/*
+ * Allocate AFU interrupts for this context. num=0 will allocate the default
+ * for this AFU as given in the AFU descriptor. This number doesn't include the
+ * interrupt 0 (CAIA defines AFU IRQ 0 for page faults). Each interrupt to be
+ * used must map a handler with cxl_map_afu_irq.
+ */
+int cxl_allocate_afu_irqs(struct cxl_context *cxl, int num);
+/* Free allocated interrupts */
+void cxl_free_afu_irqs(struct cxl_context *cxl);
+
+/*
+ * Map a handler for an AFU interrupt associated with a particular context. AFU
+ * IRQS numbers start from 1 (CAIA defines AFU IRQ 0 for page faults). cookie
+ * is private data is that will be provided to the interrupt handler.
+ */
+int cxl_map_afu_irq(struct cxl_context *cxl, int num,
+                    irq_handler_t handler, void *cookie, char *name);
+/* unmap mapped IRQ handlers */
+void cxl_unmap_afu_irq(struct cxl_context *cxl, int num, void *cookie);
 
-extern atomic_t cxl_use_count;
+/*
+ * Start work on the AFU. This starts an cxl context and associates it with a
+ * task. task == NULL will make it a kernel context.
+ */
+int cxl_start_context(struct cxl_context *ctx, u64 wed,
+                      struct task_struct *task);
+/*
+ * Stop a context and remove it from the PSL
+ */
+int cxl_stop_context(struct cxl_context *ctx);
 
-static inline bool cxl_ctx_in_use(void)
-{
-       return (atomic_read(&cxl_use_count) != 0);
-}
+/* Reset the AFU */
+int cxl_afu_reset(struct cxl_context *ctx);
 
-static inline void cxl_ctx_get(void)
-{
-       atomic_inc(&cxl_use_count);
-}
+/*
+ * Set a context as a master context.
+ * This sets the default problem space area mapped as the full space, rather
+ * than just the per context area (for slaves).
+ */
+void cxl_set_master(struct cxl_context *ctx);
 
-static inline void cxl_ctx_put(void)
-{
-       atomic_dec(&cxl_use_count);
-}
+/*
+ * Map and unmap the AFU Problem Space area. The amount and location mapped
+ * depends on if this context is a master or slave.
+ */
+void __iomem *cxl_psa_map(struct cxl_context *ctx);
+void cxl_psa_unmap(void __iomem *addr);
 
-void cxl_slbia(struct mm_struct *mm);
+/*  Get the process element for this context */
+int cxl_process_element(struct cxl_context *ctx);
 
-#else /* CONFIG_CXL_BASE */
 
-static inline bool cxl_ctx_in_use(void) { return false; }
-static inline void cxl_slbia(struct mm_struct *mm) {}
+/*
+ * These calls allow drivers to create their own file descriptors and make them
+ * identical to the cxl file descriptor user API. An example use case:
+ *
+ * struct file_operations cxl_my_fops = {};
+ * ......
+ *      // Init the context
+ *      ctx = cxl_dev_context_init(dev);
+ *      if (IS_ERR(ctx))
+ *              return PTR_ERR(ctx);
+ *      // Create and attach a new file descriptor to my file ops
+ *      file = cxl_get_fd(ctx, &cxl_my_fops, &fd);
+ *      // Start context
+ *      rc = cxl_start_work(ctx, &work.work);
+ *      if (rc) {
+ *              fput(file);
+ *              put_unused_fd(fd);
+ *              return -ENODEV;
+ *      }
+ *      // No error paths after installing the fd
+ *      fd_install(fd, file);
+ *      return fd;
+ *
+ * This inits a context, and gets a file descriptor and associates some file
+ * ops to that file descriptor. If the file ops are blank, the cxl driver will
+ * fill them in with the default ones that mimic the standard user API.  Once
+ * completed, the file descriptor can be installed. Once the file descriptor is
+ * installed, it's visible to the user so no errors must occur past this point.
+ *
+ * If cxl_fd_release() file op call is installed, the context will be stopped
+ * and released when the fd is released. Hence the driver won't need to manage
+ * this itself.
+ */
 
-#endif /* CONFIG_CXL_BASE */
+/*
+ * Take a context and associate it with my file ops. Returns the associated
+ * file and file descriptor. Any file ops which are blank are filled in by the
+ * cxl driver with the default ops to mimic the standard API.
+ */
+struct file *cxl_get_fd(struct cxl_context *ctx, struct file_operations *fops,
+                        int *fd);
+/* Get the context associated with this file */
+struct cxl_context *cxl_fops_get_context(struct file *file);
+/*
+ * Start a context associated a struct cxl_ioctl_start_work used by the
+ * standard cxl user API.
+ */
+int cxl_start_work(struct cxl_context *ctx,
+                   struct cxl_ioctl_start_work *work);
+/*
+ * Export all the existing fops so drivers can use them
+ */
+int cxl_fd_open(struct inode *inode, struct file *file);
+int cxl_fd_release(struct inode *inode, struct file *file);
+long cxl_fd_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
+int cxl_fd_mmap(struct file *file, struct vm_area_struct *vm);
+unsigned int cxl_fd_poll(struct file *file, struct poll_table_struct *poll);
+ssize_t cxl_fd_read(struct file *file, char __user *buf, size_t count,
+                           loff_t *off);
 
-#endif
+#endif /* _MISC_CXL_H */
diff --git a/include/net/act_api.h b/include/net/act_api.h
index 3ee4c92afd1b..931738bc5bba 100644
--- a/include/net/act_api.h
+++ b/include/net/act_api.h
@@ -99,7 +99,6 @@ struct tc_action_ops {
 
 int tcf_hash_search(struct tc_action *a, u32 index);
 void tcf_hash_destroy(struct tc_action *a);
-int tcf_hash_release(struct tc_action *a, int bind);
 u32 tcf_hash_new_index(struct tcf_hashinfo *hinfo);
 int tcf_hash_check(u32 index, struct tc_action *a, int bind);
 int tcf_hash_create(u32 index, struct nlattr *est, struct tc_action *a,
@@ -107,6 +106,13 @@ int tcf_hash_create(u32 index, struct nlattr *est, struct tc_action *a,
 void tcf_hash_cleanup(struct tc_action *a, struct nlattr *est);
 void tcf_hash_insert(struct tc_action *a);
 
+int __tcf_hash_release(struct tc_action *a, bool bind, bool strict);
+
+static inline int tcf_hash_release(struct tc_action *a, bool bind)
+{
+        return __tcf_hash_release(a, bind, false);
+}
+
 int tcf_register_action(struct tc_action_ops *a, unsigned int mask);
 int tcf_unregister_action(struct tc_action_ops *a);
 int tcf_action_destroy(struct list_head *actions, int bind);
diff --git a/include/net/addrconf.h b/include/net/addrconf.h
index 80456f72d70a..def59d3a34d5 100644
--- a/include/net/addrconf.h
+++ b/include/net/addrconf.h
@@ -142,6 +142,7 @@ void ipv6_mc_unmap(struct inet6_dev *idev);
 void ipv6_mc_remap(struct inet6_dev *idev);
 void ipv6_mc_init_dev(struct inet6_dev *idev);
 void ipv6_mc_destroy_dev(struct inet6_dev *idev);
+int ipv6_mc_check_mld(struct sk_buff *skb, struct sk_buff **skb_trimmed);
 void addrconf_dad_failure(struct inet6_ifaddr *ifp);
 
 bool ipv6_chk_mcast_addr(struct net_device *dev, const struct in6_addr *group,
diff --git a/include/net/af_unix.h b/include/net/af_unix.h
index a175ba4a7adb..4a167b30a12f 100644
--- a/include/net/af_unix.h
+++ b/include/net/af_unix.h
@@ -39,7 +39,6 @@ struct unix_skb_parms {
 };
 
 #define UNIXCB(skb)     (*(struct unix_skb_parms *)&((skb)->cb))
-#define UNIXSID(skb)    (&UNIXCB((skb)).secid)
 
 #define unix_state_lock(s)      spin_lock(&unix_sk(s)->lock)
 #define unix_state_unlock(s)    spin_unlock(&unix_sk(s)->lock)
diff --git a/include/net/af_vsock.h b/include/net/af_vsock.h
index 172632dd9930..db639a4c5ab8 100644
--- a/include/net/af_vsock.h
+++ b/include/net/af_vsock.h
@@ -74,7 +74,7 @@ void vsock_pending_work(struct work_struct *work);
 struct sock *__vsock_create(struct net *net,
                             struct socket *sock,
                             struct sock *parent,
-                            gfp_t priority, unsigned short type);
+                            gfp_t priority, unsigned short type, int kern);
 
 /**** TRANSPORT ****/
 
diff --git a/include/net/ax25.h b/include/net/ax25.h
index 16a923a3a43a..e602f8177ebf 100644
--- a/include/net/ax25.h
+++ b/include/net/ax25.h
@@ -13,6 +13,7 @@
 #include <linux/slab.h>
 #include <linux/atomic.h>
 #include <net/neighbour.h>
+#include <net/sock.h>
 
 #define AX25_T1CLAMPLO                  1
 #define AX25_T1CLAMPHI                  (30 * HZ)
@@ -246,7 +247,20 @@ typedef struct ax25_cb {
         atomic_t                refcount;
 } ax25_cb;
 
-#define ax25_sk(__sk) ((ax25_cb *)(__sk)->sk_protinfo)
+struct ax25_sock {
+        struct sock             sk;
+        struct ax25_cb          *cb;
+};
+
+static inline struct ax25_sock *ax25_sk(const struct sock *sk)
+{
+        return (struct ax25_sock *) sk;
+}
+
+static inline struct ax25_cb *sk_to_ax25(const struct sock *sk)
+{
+        return ax25_sk(sk)->cb;
+}
 
 #define ax25_for_each(__ax25, list) \
         hlist_for_each_entry(__ax25, list, ax25_node)
diff --git a/include/net/bluetooth/bluetooth.h b/include/net/bluetooth/bluetooth.h
index 7dba80546f16..38d8a34d3589 100644
--- a/include/net/bluetooth/bluetooth.h
+++ b/include/net/bluetooth/bluetooth.h
@@ -365,8 +365,19 @@ extern struct dentry *bt_debugfs;
 int l2cap_init(void);
 void l2cap_exit(void);
 
+#if IS_ENABLED(CONFIG_BT_BREDR)
 int sco_init(void);
 void sco_exit(void);
+#else
+static inline int sco_init(void)
+{
+        return 0;
+}
+
+static inline void sco_exit(void)
+{
+}
+#endif
 
 int mgmt_init(void);
 void mgmt_exit(void);
diff --git a/include/net/bluetooth/hci.h b/include/net/bluetooth/hci.h
index d95da83cb1b0..7ca6690355ea 100644
--- a/include/net/bluetooth/hci.h
+++ b/include/net/bluetooth/hci.h
@@ -1202,6 +1202,16 @@ struct hci_rp_read_clock {
         __le16   accuracy;
 } __packed;
 
+#define HCI_OP_READ_ENC_KEY_SIZE        0x1408
+struct hci_cp_read_enc_key_size {
+        __le16   handle;
+} __packed;
+struct hci_rp_read_enc_key_size {
+        __u8     status;
+        __le16   handle;
+        __u8     key_size;
+} __packed;
+
 #define HCI_OP_READ_LOCAL_AMP_INFO      0x1409
 struct hci_rp_read_local_amp_info {
         __u8     status;
diff --git a/include/net/bluetooth/hci_core.h b/include/net/bluetooth/hci_core.h
index a056c2bfeb81..3bd618d3e55d 100644
--- a/include/net/bluetooth/hci_core.h
+++ b/include/net/bluetooth/hci_core.h
@@ -156,16 +156,22 @@ struct oob_data {
 };
 
 struct adv_info {
-        struct delayed_work timeout_exp;
+        struct list_head list;
+        bool pending;
         __u8    instance;
         __u32   flags;
         __u16   timeout;
+        __u16   remaining_time;
+        __u16   duration;
         __u16   adv_data_len;
         __u8    adv_data[HCI_MAX_AD_LENGTH];
         __u16   scan_rsp_len;
         __u8    scan_rsp_data[HCI_MAX_AD_LENGTH];
 };
 
+#define HCI_MAX_ADV_INSTANCES           5
+#define HCI_DEFAULT_ADV_DURATION        2
+
 #define HCI_MAX_SHORT_NAME_LENGTH       10
 
 /* Default LE RPA expiry time, 15 minutes */
@@ -373,7 +379,11 @@ struct hci_dev {
         __u8                    scan_rsp_data[HCI_MAX_AD_LENGTH];
         __u8                    scan_rsp_data_len;
 
-        struct adv_info         adv_instance;
+        struct list_head        adv_instances;
+        unsigned int            adv_instance_cnt;
+        __u8                    cur_adv_instance;
+        __u16                   adv_instance_timeout;
+        struct delayed_work     adv_instance_expire;
 
         __u8                    irk[16];
         __u32                   rpa_timeout;
@@ -530,10 +540,22 @@ extern struct mutex hci_cb_list_lock;
 /* ----- HCI interface to upper protocols ----- */
 int l2cap_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr);
 int l2cap_disconn_ind(struct hci_conn *hcon);
-int l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, u16 flags);
+void l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, u16 flags);
 
+#if IS_ENABLED(CONFIG_BT_BREDR)
 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags);
-int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb);
+void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb);
+#else
+static inline int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr,
+                                  __u8 *flags)
+{
+        return 0;
+}
+
+static inline void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
+{
+}
+#endif
 
 /* ----- Inquiry cache ----- */
 #define INQUIRY_CACHE_AGE_MAX   (HZ*30)   /* 30 seconds */
@@ -561,11 +583,6 @@ static inline void hci_discovery_filter_clear(struct hci_dev *hdev)
         hdev->discovery.scan_duration = 0;
 }
 
-static inline void adv_info_init(struct hci_dev *hdev)
-{
-        memset(&hdev->adv_instance, 0, sizeof(struct adv_info));
-}
-
 bool hci_discovery_active(struct hci_dev *hdev);
 
 void hci_discovery_set_state(struct hci_dev *hdev, int state);
@@ -1007,6 +1024,15 @@ int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr,
 int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr,
                                u8 bdaddr_type);
 
+void hci_adv_instances_clear(struct hci_dev *hdev);
+struct adv_info *hci_find_adv_instance(struct hci_dev *hdev, u8 instance);
+struct adv_info *hci_get_next_instance(struct hci_dev *hdev, u8 instance);
+int hci_add_adv_instance(struct hci_dev *hdev, u8 instance, u32 flags,
+                         u16 adv_data_len, u8 *adv_data,
+                         u16 scan_rsp_len, u8 *scan_rsp_data,
+                         u16 timeout, u16 duration);
+int hci_remove_adv_instance(struct hci_dev *hdev, u8 instance);
+
 void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb);
 
 int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb);
@@ -1350,6 +1376,7 @@ void mgmt_set_powered_failed(struct hci_dev *hdev, int err);
 int mgmt_powered(struct hci_dev *hdev, u8 powered);
 int mgmt_update_adv_data(struct hci_dev *hdev);
 void mgmt_discoverable_timeout(struct hci_dev *hdev);
+void mgmt_adv_timeout_expired(struct hci_dev *hdev);
 void mgmt_new_link_key(struct hci_dev *hdev, struct link_key *key,
                        bool persistent);
 void mgmt_device_connected(struct hci_dev *hdev, struct hci_conn *conn,
@@ -1408,7 +1435,7 @@ void mgmt_smp_complete(struct hci_conn *conn, bool complete);
 u8 hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max, u16 latency,
                       u16 to_multiplier);
 void hci_le_start_enc(struct hci_conn *conn, __le16 ediv, __le64 rand,
-                                                        __u8 ltk[16]);
+                      __u8 ltk[16], __u8 key_size);
 
 void hci_copy_identity_address(struct hci_dev *hdev, bdaddr_t *bdaddr,
                                u8 *bdaddr_type);
diff --git a/include/net/bond_options.h b/include/net/bond_options.h
index ea6546d2c946..c28aca25320e 100644
--- a/include/net/bond_options.h
+++ b/include/net/bond_options.h
@@ -63,6 +63,9 @@ enum {
         BOND_OPT_LP_INTERVAL,
         BOND_OPT_SLAVES,
         BOND_OPT_TLB_DYNAMIC_LB,
+        BOND_OPT_AD_ACTOR_SYS_PRIO,
+        BOND_OPT_AD_ACTOR_SYSTEM,
+        BOND_OPT_AD_USER_PORT_KEY,
         BOND_OPT_LAST
 };
 
diff --git a/include/net/bonding.h b/include/net/bonding.h
index 78ed135e9dea..20defc0353d1 100644
--- a/include/net/bonding.h
+++ b/include/net/bonding.h
@@ -136,6 +136,9 @@ struct bond_params {
         int packets_per_slave;
         int tlb_dynamic_lb;
         struct reciprocal_value reciprocal_packets_per_slave;
+        u16 ad_actor_sys_prio;
+        u16 ad_user_port_key;
+        u8 ad_actor_system[ETH_ALEN];
 };
 
 struct bond_parm_tbl {
diff --git a/include/net/cfg80211.h b/include/net/cfg80211.h
index f8d6813cd5b2..883fe1e7c5a1 100644
--- a/include/net/cfg80211.h
+++ b/include/net/cfg80211.h
@@ -111,7 +111,7 @@ enum ieee80211_band {
  *      This may be due to the driver or due to regulatory bandwidth
  *      restrictions.
  * @IEEE80211_CHAN_INDOOR_ONLY: see %NL80211_FREQUENCY_ATTR_INDOOR_ONLY
- * @IEEE80211_CHAN_GO_CONCURRENT: see %NL80211_FREQUENCY_ATTR_GO_CONCURRENT
+ * @IEEE80211_CHAN_IR_CONCURRENT: see %NL80211_FREQUENCY_ATTR_IR_CONCURRENT
  * @IEEE80211_CHAN_NO_20MHZ: 20 MHz bandwidth is not permitted
  *      on this channel.
  * @IEEE80211_CHAN_NO_10MHZ: 10 MHz bandwidth is not permitted
@@ -129,7 +129,7 @@ enum ieee80211_channel_flags {
         IEEE80211_CHAN_NO_80MHZ         = 1<<7,
         IEEE80211_CHAN_NO_160MHZ        = 1<<8,
         IEEE80211_CHAN_INDOOR_ONLY      = 1<<9,
-        IEEE80211_CHAN_GO_CONCURRENT    = 1<<10,
+        IEEE80211_CHAN_IR_CONCURRENT    = 1<<10,
         IEEE80211_CHAN_NO_20MHZ         = 1<<11,
         IEEE80211_CHAN_NO_10MHZ         = 1<<12,
 };
@@ -4575,13 +4575,15 @@ void cfg80211_roamed_bss(struct net_device *dev, struct cfg80211_bss *bss,
  * @ie: information elements of the deauth/disassoc frame (may be %NULL)
  * @ie_len: length of IEs
  * @reason: reason code for the disconnection, set it to 0 if unknown
+ * @locally_generated: disconnection was requested locally
  * @gfp: allocation flags
  *
  * After it calls this function, the driver should enter an idle state
  * and not try to connect to any AP any more.
  */
 void cfg80211_disconnected(struct net_device *dev, u16 reason,
-                           const u8 *ie, size_t ie_len, gfp_t gfp);
+                           const u8 *ie, size_t ie_len,
+                           bool locally_generated, gfp_t gfp);
 
 /**
  * cfg80211_ready_on_channel - notification of remain_on_channel start
@@ -4866,6 +4868,23 @@ bool cfg80211_reg_can_beacon(struct wiphy *wiphy,
                              struct cfg80211_chan_def *chandef,
                              enum nl80211_iftype iftype);
 
+/**
+ * cfg80211_reg_can_beacon_relax - check if beaconing is allowed with relaxation
+ * @wiphy: the wiphy
+ * @chandef: the channel definition
+ * @iftype: interface type
+ *
+ * Return: %true if there is no secondary channel or the secondary channel(s)
+ * can be used for beaconing (i.e. is not a radar channel etc.). This version
+ * also checks if IR-relaxation conditions apply, to allow beaconing under
+ * more permissive conditions.
+ *
+ * Requires the RTNL to be held.
+ */
+bool cfg80211_reg_can_beacon_relax(struct wiphy *wiphy,
+                                   struct cfg80211_chan_def *chandef,
+                                   enum nl80211_iftype iftype);
+
 /*
  * cfg80211_ch_switch_notify - update wdev channel and notify userspace
  * @dev: the device which switched channels
diff --git a/include/net/cfg802154.h b/include/net/cfg802154.h
index 6ea16c84293b..290a9a69af07 100644
--- a/include/net/cfg802154.h
+++ b/include/net/cfg802154.h
@@ -44,6 +44,8 @@ struct cfg802154_ops {
         int     (*set_channel)(struct wpan_phy *wpan_phy, u8 page, u8 channel);
         int     (*set_cca_mode)(struct wpan_phy *wpan_phy,
                                 const struct wpan_phy_cca *cca);
+        int     (*set_cca_ed_level)(struct wpan_phy *wpan_phy, s32 ed_level);
+        int     (*set_tx_power)(struct wpan_phy *wpan_phy, s32 power);
         int     (*set_pan_id)(struct wpan_phy *wpan_phy,
                               struct wpan_dev *wpan_dev, __le16 pan_id);
         int     (*set_short_addr)(struct wpan_phy *wpan_phy,
@@ -61,14 +63,66 @@ struct cfg802154_ops {
                                 struct wpan_dev *wpan_dev, bool mode);
 };
 
+static inline bool
+wpan_phy_supported_bool(bool b, enum nl802154_supported_bool_states st)
+{
+        switch (st) {
+        case NL802154_SUPPORTED_BOOL_TRUE:
+                return b;
+        case NL802154_SUPPORTED_BOOL_FALSE:
+                return !b;
+        case NL802154_SUPPORTED_BOOL_BOTH:
+                return true;
+        default:
+                WARN_ON(1);
+        }
+
+        return false;
+}
+
+struct wpan_phy_supported {
+        u32 channels[IEEE802154_MAX_PAGE + 1],
+            cca_modes, cca_opts, iftypes;
+        enum nl802154_supported_bool_states lbt;
+        u8 min_minbe, max_minbe, min_maxbe, max_maxbe,
+           min_csma_backoffs, max_csma_backoffs;
+        s8 min_frame_retries, max_frame_retries;
+        size_t tx_powers_size, cca_ed_levels_size;
+        const s32 *tx_powers, *cca_ed_levels;
+};
+
 struct wpan_phy_cca {
         enum nl802154_cca_modes mode;
         enum nl802154_cca_opts opt;
 };
 
-struct wpan_phy {
-        struct mutex pib_lock;
+static inline bool
+wpan_phy_cca_cmp(const struct wpan_phy_cca *a, const struct wpan_phy_cca *b)
+{
+        if (a->mode != b->mode)
+                return false;
+
+        if (a->mode == NL802154_CCA_ENERGY_CARRIER)
+                return a->opt == b->opt;
 
+        return true;
+}
+
+/**
+ * @WPAN_PHY_FLAG_TRANSMIT_POWER: Indicates that transceiver will support
+ *      transmit power setting.
+ * @WPAN_PHY_FLAG_CCA_ED_LEVEL: Indicates that transceiver will support cca ed
+ *      level setting.
+ * @WPAN_PHY_FLAG_CCA_MODE: Indicates that transceiver will support cca mode
+ *      setting.
+ */
+enum wpan_phy_flags {
+        WPAN_PHY_FLAG_TXPOWER           = BIT(1),
+        WPAN_PHY_FLAG_CCA_ED_LEVEL      = BIT(2),
+        WPAN_PHY_FLAG_CCA_MODE          = BIT(3),
+};
+
+struct wpan_phy {
         /* If multiple wpan_phys are registered and you're handed e.g.
          * a regular netdev with assigned ieee802154_ptr, you won't
          * know whether it points to a wpan_phy your driver has registered
@@ -77,6 +131,8 @@ struct wpan_phy {
          */
         const void *privid;
 
+        u32 flags;
+
         /*
          * This is a PIB according to 802.15.4-2011.
          * We do not provide timing-related variables, as they
@@ -84,12 +140,14 @@ struct wpan_phy {
          */
         u8 current_channel;
         u8 current_page;
-        u32 channels_supported[IEEE802154_MAX_PAGE + 1];
-        s8 transmit_power;
+        struct wpan_phy_supported supported;
+        /* current transmit_power in mBm */
+        s32 transmit_power;
         struct wpan_phy_cca cca;
 
         __le64 perm_extended_addr;
 
+        /* current cca ed threshold in mBm */
         s32 cca_ed_level;
 
         /* PHY depended MAC PIB values */
@@ -121,9 +179,9 @@ struct wpan_dev {
         __le64 extended_addr;
 
         /* MAC BSN field */
-        u8 bsn;
+        atomic_t bsn;
         /* MAC DSN field */
-        u8 dsn;
+        atomic_t dsn;
 
         u8 min_be;
         u8 max_be;
diff --git a/include/net/checksum.h b/include/net/checksum.h
index 0a55ac715077..2d1d73cb773e 100644
--- a/include/net/checksum.h
+++ b/include/net/checksum.h
@@ -122,7 +122,9 @@ static inline __wsum csum_partial_ext(const void *buff, int len, __wsum sum)
 
 static inline void csum_replace4(__sum16 *sum, __be32 from, __be32 to)
 {
-        *sum = csum_fold(csum_add(csum_sub(~csum_unfold(*sum), from), to));
+        __wsum tmp = csum_sub(~csum_unfold(*sum), (__force __wsum)from);
+
+        *sum = csum_fold(csum_add(tmp, (__force __wsum)to));
 }
 
 /* Implements RFC 1624 (Incremental Internet Checksum)
diff --git a/include/net/codel.h b/include/net/codel.h
index 1e18005f7f65..267e70210061 100644
--- a/include/net/codel.h
+++ b/include/net/codel.h
@@ -7,7 +7,7 @@
  *  Copyright (C) 2011-2012 Kathleen Nichols <nichols@pollere.com>
  *  Copyright (C) 2011-2012 Van Jacobson <van@pollere.net>
  *  Copyright (C) 2012 Michael D. Taht <dave.taht@bufferbloat.net>
- *  Copyright (C) 2012 Eric Dumazet <edumazet@google.com>
+ *  Copyright (C) 2012,2015 Eric Dumazet <edumazet@google.com>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -119,12 +119,14 @@ static inline u32 codel_time_to_us(codel_time_t val)
 /**
  * struct codel_params - contains codel parameters
  * @target:     target queue size (in time units)
+ * @ce_threshold:  threshold for marking packets with ECN CE
  * @interval:   width of moving time window
  * @mtu:        device mtu, or minimal queue backlog in bytes.
  * @ecn:        is Explicit Congestion Notification enabled
  */
 struct codel_params {
         codel_time_t    target;
+        codel_time_t    ce_threshold;
         codel_time_t    interval;
         u32             mtu;
         bool            ecn;
@@ -161,19 +163,24 @@ struct codel_vars {
  * @maxpacket:  largest packet we've seen so far
  * @drop_count: temp count of dropped packets in dequeue()
  * ecn_mark:    number of packets we ECN marked instead of dropping
+ * ce_mark:     number of packets CE marked because sojourn time was above ce_threshold
  */
 struct codel_stats {
         u32             maxpacket;
         u32             drop_count;
         u32             ecn_mark;
+        u32             ce_mark;
 };
 
+#define CODEL_DISABLED_THRESHOLD INT_MAX
+
 static void codel_params_init(struct codel_params *params,
                               const struct Qdisc *sch)
 {
         params->interval = MS2TIME(100);
         params->target = MS2TIME(5);
         params->mtu = psched_mtu(qdisc_dev(sch));
+        params->ce_threshold = CODEL_DISABLED_THRESHOLD;
         params->ecn = false;
 }
 
@@ -354,6 +361,9 @@ static struct sk_buff *codel_dequeue(struct Qdisc *sch,
                                                     vars->rec_inv_sqrt);
         }
 end:
+        if (skb && codel_time_after(vars->ldelay, params->ce_threshold) &&
+            INET_ECN_set_ce(skb))
+                stats->ce_mark++;
         return skb;
 }
 #endif
diff --git a/include/net/dst.h b/include/net/dst.h
index 0fb99a26e973..2bc73f8a00a9 100644
--- a/include/net/dst.h
+++ b/include/net/dst.h
@@ -109,7 +109,6 @@ u32 *dst_cow_metrics_generic(struct dst_entry *dst, unsigned long old);
 extern const u32 dst_default_metrics[];
 
 #define DST_METRICS_READ_ONLY           0x1UL
-#define DST_METRICS_FORCE_OVERWRITE     0x2UL
 #define DST_METRICS_FLAGS               0x3UL
 #define __DST_METRICS_PTR(Y)    \
         ((u32 *)((Y) & ~DST_METRICS_FLAGS))
@@ -120,11 +119,6 @@ static inline bool dst_metrics_read_only(const struct dst_entry *dst)
         return dst->_metrics & DST_METRICS_READ_ONLY;
 }
 
-static inline void dst_metrics_set_force_overwrite(struct dst_entry *dst)
-{
-        dst->_metrics |= DST_METRICS_FORCE_OVERWRITE;
-}
-
 void __dst_destroy_metrics_generic(struct dst_entry *dst, unsigned long old);
 
 static inline void dst_destroy_metrics_generic(struct dst_entry *dst)
@@ -355,18 +349,6 @@ static inline void skb_tunnel_rx(struct sk_buff *skb, struct net_device *dev,
         __skb_tunnel_rx(skb, dev, net);
 }
 
-/* Children define the path of the packet through the
- * Linux networking.  Thus, destinations are stackable.
- */
-
-static inline struct dst_entry *skb_dst_pop(struct sk_buff *skb)
-{
-        struct dst_entry *child = dst_clone(skb_dst(skb)->child);
-
-        skb_dst_drop(skb);
-        return child;
-}
-
 int dst_discard_sk(struct sock *sk, struct sk_buff *skb);
 static inline int dst_discard(struct sk_buff *skb)
 {
diff --git a/include/net/fib_rules.h b/include/net/fib_rules.h
index 6d67383a5114..903a55efbffe 100644
--- a/include/net/fib_rules.h
+++ b/include/net/fib_rules.h
@@ -36,7 +36,8 @@ struct fib_lookup_arg {
         void                    *result;
         struct fib_rule         *rule;
         int                     flags;
-#define FIB_LOOKUP_NOREF        1
+#define FIB_LOOKUP_NOREF                1
+#define FIB_LOOKUP_IGNORE_LINKSTATE     2
 };
 
 struct fib_rules_ops {
diff --git a/include/net/flow_dissector.h b/include/net/flow_dissector.h
new file mode 100644
index 000000000000..1a8c22419936
--- /dev/null
+++ b/include/net/flow_dissector.h
@@ -0,0 +1,220 @@
+#ifndef _NET_FLOW_DISSECTOR_H
+#define _NET_FLOW_DISSECTOR_H
+
+#include <linux/types.h>
+#include <linux/skbuff.h>
+#include <linux/in6.h>
+#include <uapi/linux/if_ether.h>
+
+/**
+ * struct flow_dissector_key_control:
+ * @thoff: Transport header offset
+ */
+struct flow_dissector_key_control {
+        u16     thoff;
+        u16     addr_type;
+};
+
+/**
+ * struct flow_dissector_key_basic:
+ * @thoff: Transport header offset
+ * @n_proto: Network header protocol (eg. IPv4/IPv6)
+ * @ip_proto: Transport header protocol (eg. TCP/UDP)
+ */
+struct flow_dissector_key_basic {
+        __be16  n_proto;
+        u8      ip_proto;
+        u8      padding;
+};
+
+struct flow_dissector_key_tags {
+        u32     vlan_id:12,
+                flow_label:20;
+};
+
+struct flow_dissector_key_keyid {
+        __be32  keyid;
+};
+
+/**
+ * struct flow_dissector_key_ipv4_addrs:
+ * @src: source ip address
+ * @dst: destination ip address
+ */
+struct flow_dissector_key_ipv4_addrs {
+        /* (src,dst) must be grouped, in the same way than in IP header */
+        __be32 src;
+        __be32 dst;
+};
+
+/**
+ * struct flow_dissector_key_ipv6_addrs:
+ * @src: source ip address
+ * @dst: destination ip address
+ */
+struct flow_dissector_key_ipv6_addrs {
+        /* (src,dst) must be grouped, in the same way than in IP header */
+        struct in6_addr src;
+        struct in6_addr dst;
+};
+
+/**
+ * struct flow_dissector_key_tipc_addrs:
+ * @srcnode: source node address
+ */
+struct flow_dissector_key_tipc_addrs {
+        __be32 srcnode;
+};
+
+/**
+ * struct flow_dissector_key_addrs:
+ * @v4addrs: IPv4 addresses
+ * @v6addrs: IPv6 addresses
+ */
+struct flow_dissector_key_addrs {
+        union {
+                struct flow_dissector_key_ipv4_addrs v4addrs;
+                struct flow_dissector_key_ipv6_addrs v6addrs;
+                struct flow_dissector_key_tipc_addrs tipcaddrs;
+        };
+};
+
+/**
+ * flow_dissector_key_tp_ports:
+ *      @ports: port numbers of Transport header
+ *              src: source port number
+ *              dst: destination port number
+ */
+struct flow_dissector_key_ports {
+        union {
+                __be32 ports;
+                struct {
+                        __be16 src;
+                        __be16 dst;
+                };
+        };
+};
+
+
+/**
+ * struct flow_dissector_key_eth_addrs:
+ * @src: source Ethernet address
+ * @dst: destination Ethernet address
+ */
+struct flow_dissector_key_eth_addrs {
+        /* (dst,src) must be grouped, in the same way than in ETH header */
+        unsigned char dst[ETH_ALEN];
+        unsigned char src[ETH_ALEN];
+};
+
+enum flow_dissector_key_id {
+        FLOW_DISSECTOR_KEY_CONTROL, /* struct flow_dissector_key_control */
+        FLOW_DISSECTOR_KEY_BASIC, /* struct flow_dissector_key_basic */
+        FLOW_DISSECTOR_KEY_IPV4_ADDRS, /* struct flow_dissector_key_ipv4_addrs */
+        FLOW_DISSECTOR_KEY_IPV6_ADDRS, /* struct flow_dissector_key_ipv6_addrs */
+        FLOW_DISSECTOR_KEY_PORTS, /* struct flow_dissector_key_ports */
+        FLOW_DISSECTOR_KEY_ETH_ADDRS, /* struct flow_dissector_key_eth_addrs */
+        FLOW_DISSECTOR_KEY_TIPC_ADDRS, /* struct flow_dissector_key_tipc_addrs */
+        FLOW_DISSECTOR_KEY_VLANID, /* struct flow_dissector_key_flow_tags */
+        FLOW_DISSECTOR_KEY_FLOW_LABEL, /* struct flow_dissector_key_flow_tags */
+        FLOW_DISSECTOR_KEY_GRE_KEYID, /* struct flow_dissector_key_keyid */
+        FLOW_DISSECTOR_KEY_MPLS_ENTROPY, /* struct flow_dissector_key_keyid */
+
+        FLOW_DISSECTOR_KEY_MAX,
+};
+
+struct flow_dissector_key {
+        enum flow_dissector_key_id key_id;
+        size_t offset; /* offset of struct flow_dissector_key_*
+                          in target the struct */
+};
+
+struct flow_dissector {
+        unsigned int used_keys; /* each bit repesents presence of one key id */
+        unsigned short int offset[FLOW_DISSECTOR_KEY_MAX];
+};
+
+void skb_flow_dissector_init(struct flow_dissector *flow_dissector,
+                             const struct flow_dissector_key *key,
+                             unsigned int key_count);
+
+bool __skb_flow_dissect(const struct sk_buff *skb,
+                        struct flow_dissector *flow_dissector,
+                        void *target_container,
+                        void *data, __be16 proto, int nhoff, int hlen);
+
+static inline bool skb_flow_dissect(const struct sk_buff *skb,
+                                    struct flow_dissector *flow_dissector,
+                                    void *target_container)
+{
+        return __skb_flow_dissect(skb, flow_dissector, target_container,
+                                  NULL, 0, 0, 0);
+}
+
+struct flow_keys {
+        struct flow_dissector_key_control control;
+#define FLOW_KEYS_HASH_START_FIELD basic
+        struct flow_dissector_key_basic basic;
+        struct flow_dissector_key_tags tags;
+        struct flow_dissector_key_keyid keyid;
+        struct flow_dissector_key_ports ports;
+        struct flow_dissector_key_addrs addrs;
+};
+
+#define FLOW_KEYS_HASH_OFFSET           \
+        offsetof(struct flow_keys, FLOW_KEYS_HASH_START_FIELD)
+
+__be32 flow_get_u32_src(const struct flow_keys *flow);
+__be32 flow_get_u32_dst(const struct flow_keys *flow);
+
+extern struct flow_dissector flow_keys_dissector;
+extern struct flow_dissector flow_keys_buf_dissector;
+
+static inline bool skb_flow_dissect_flow_keys(const struct sk_buff *skb,
+                                              struct flow_keys *flow)
+{
+        memset(flow, 0, sizeof(*flow));
+        return __skb_flow_dissect(skb, &flow_keys_dissector, flow,
+                                  NULL, 0, 0, 0);
+}
+
+static inline bool skb_flow_dissect_flow_keys_buf(struct flow_keys *flow,
+                                                  void *data, __be16 proto,
+                                                  int nhoff, int hlen)
+{
+        memset(flow, 0, sizeof(*flow));
+        return __skb_flow_dissect(NULL, &flow_keys_buf_dissector, flow,
+                                  data, proto, nhoff, hlen);
+}
+
+__be32 __skb_flow_get_ports(const struct sk_buff *skb, int thoff, u8 ip_proto,
+                            void *data, int hlen_proto);
+
+static inline __be32 skb_flow_get_ports(const struct sk_buff *skb,
+                                        int thoff, u8 ip_proto)
+{
+        return __skb_flow_get_ports(skb, thoff, ip_proto, NULL, 0);
+}
+
+u32 flow_hash_from_keys(struct flow_keys *keys);
+void __skb_get_hash(struct sk_buff *skb);
+u32 skb_get_poff(const struct sk_buff *skb);
+u32 __skb_get_poff(const struct sk_buff *skb, void *data,
+                   const struct flow_keys *keys, int hlen);
+
+/* struct flow_keys_digest:
+ *
+ * This structure is used to hold a digest of the full flow keys. This is a
+ * larger "hash" of a flow to allow definitively matching specific flows where
+ * the 32 bit skb->hash is not large enough. The size is limited to 16 bytes so
+ * that it can by used in CB of skb (see sch_choke for an example).
+ */
+#define FLOW_KEYS_DIGEST_LEN    16
+struct flow_keys_digest {
+        u8      data[FLOW_KEYS_DIGEST_LEN];
+};
+
+void make_flow_keys_digest(struct flow_keys_digest *digest,
+                           const struct flow_keys *flow);
+
+#endif
diff --git a/include/net/flow_keys.h b/include/net/flow_keys.h
deleted file mode 100644
index dc8fd81412bf..000000000000
--- a/include/net/flow_keys.h
+++ /dev/null
@@ -1,45 +0,0 @@
-#ifndef _NET_FLOW_KEYS_H
-#define _NET_FLOW_KEYS_H
-
-/* struct flow_keys:
- *      @src: source ip address in case of IPv4
- *            For IPv6 it contains 32bit hash of src address
- *      @dst: destination ip address in case of IPv4
- *            For IPv6 it contains 32bit hash of dst address
- *      @ports: port numbers of Transport header
- *              port16[0]: src port number
- *              port16[1]: dst port number
- *      @thoff: Transport header offset
- *      @n_proto: Network header protocol (eg. IPv4/IPv6)
- *      @ip_proto: Transport header protocol (eg. TCP/UDP)
- * All the members, except thoff, are in network byte order.
- */
-struct flow_keys {
-        /* (src,dst) must be grouped, in the same way than in IP header */
-        __be32 src;
-        __be32 dst;
-        union {
-                __be32 ports;
-                __be16 port16[2];
-        };
-        u16     thoff;
-        __be16  n_proto;
-        u8      ip_proto;
-};
-
-bool __skb_flow_dissect(const struct sk_buff *skb, struct flow_keys *flow,
-                        void *data, __be16 proto, int nhoff, int hlen);
-static inline bool skb_flow_dissect(const struct sk_buff *skb, struct flow_keys *flow)
-{
-        return __skb_flow_dissect(skb, flow, NULL, 0, 0, 0);
-}
-__be32 __skb_flow_get_ports(const struct sk_buff *skb, int thoff, u8 ip_proto,
-                            void *data, int hlen_proto);
-static inline __be32 skb_flow_get_ports(const struct sk_buff *skb, int thoff, u8 ip_proto)
-{
-        return __skb_flow_get_ports(skb, thoff, ip_proto, NULL, 0);
-}
-u32 flow_hash_from_keys(struct flow_keys *keys);
-unsigned int flow_get_hlen(const unsigned char *data, unsigned int max_len,
-                           __be16 protocol);
-#endif
diff --git a/include/net/geneve.h b/include/net/geneve.h
index 14fb8d3390b4..2a0543a1899d 100644
--- a/include/net/geneve.h
+++ b/include/net/geneve.h
@@ -62,6 +62,11 @@ struct genevehdr {
         struct geneve_opt options[];
 };
 
+static inline struct genevehdr *geneve_hdr(const struct sk_buff *skb)
+{
+        return (struct genevehdr *)(udp_hdr(skb) + 1);
+}
+
 #ifdef CONFIG_INET
 struct geneve_sock;
 
diff --git a/include/net/ieee802154_netdev.h b/include/net/ieee802154_netdev.h
index 94a297052442..2c10a9f0c6d9 100644
--- a/include/net/ieee802154_netdev.h
+++ b/include/net/ieee802154_netdev.h
@@ -346,15 +346,15 @@ struct ieee802154_mac_params {
 struct wpan_phy;
 
 enum {
-        IEEE802154_LLSEC_PARAM_ENABLED = 1 << 0,
-        IEEE802154_LLSEC_PARAM_FRAME_COUNTER = 1 << 1,
-        IEEE802154_LLSEC_PARAM_OUT_LEVEL = 1 << 2,
-        IEEE802154_LLSEC_PARAM_OUT_KEY = 1 << 3,
-        IEEE802154_LLSEC_PARAM_KEY_SOURCE = 1 << 4,
-        IEEE802154_LLSEC_PARAM_PAN_ID = 1 << 5,
-        IEEE802154_LLSEC_PARAM_HWADDR = 1 << 6,
-        IEEE802154_LLSEC_PARAM_COORD_HWADDR = 1 << 7,
-        IEEE802154_LLSEC_PARAM_COORD_SHORTADDR = 1 << 8,
+        IEEE802154_LLSEC_PARAM_ENABLED          = BIT(0),
+        IEEE802154_LLSEC_PARAM_FRAME_COUNTER    = BIT(1),
+        IEEE802154_LLSEC_PARAM_OUT_LEVEL        = BIT(2),
+        IEEE802154_LLSEC_PARAM_OUT_KEY          = BIT(3),
+        IEEE802154_LLSEC_PARAM_KEY_SOURCE       = BIT(4),
+        IEEE802154_LLSEC_PARAM_PAN_ID           = BIT(5),
+        IEEE802154_LLSEC_PARAM_HWADDR           = BIT(6),
+        IEEE802154_LLSEC_PARAM_COORD_HWADDR     = BIT(7),
+        IEEE802154_LLSEC_PARAM_COORD_SHORTADDR  = BIT(8),
 };
 
 struct ieee802154_llsec_ops {
@@ -422,16 +422,6 @@ struct ieee802154_mlme_ops {
                                struct ieee802154_mac_params *params);
 
         struct ieee802154_llsec_ops *llsec;
-
-        /* The fields below are required. */
-
-        /*
-         * FIXME: these should become the part of PIB/MIB interface.
-         * However we still don't have IB interface of any kind
-         */
-        __le16 (*get_pan_id)(const struct net_device *dev);
-        __le16 (*get_short_addr)(const struct net_device *dev);
-        u8 (*get_dsn)(const struct net_device *dev);
 };
 
 static inline struct ieee802154_mlme_ops *
@@ -440,10 +430,4 @@ ieee802154_mlme_ops(const struct net_device *dev)
         return dev->ml_priv;
 }
 
-static inline struct ieee802154_reduced_mlme_ops *
-ieee802154_reduced_mlme_ops(const struct net_device *dev)
-{
-        return dev->ml_priv;
-}
-
 #endif
diff --git a/include/net/inet_common.h b/include/net/inet_common.h
index 4a92423eefa5..279f83591971 100644
--- a/include/net/inet_common.h
+++ b/include/net/inet_common.h
@@ -41,7 +41,7 @@ int inet_recv_error(struct sock *sk, struct msghdr *msg, int len,
 
 static inline void inet_ctl_sock_destroy(struct sock *sk)
 {
-        sk_release_kernel(sk);
+        sock_release(sk->sk_socket);
 }
 
 #endif
diff --git a/include/net/inet_frag.h b/include/net/inet_frag.h
index 8d1765577acc..53eead2da743 100644
--- a/include/net/inet_frag.h
+++ b/include/net/inet_frag.h
@@ -21,13 +21,11 @@ struct netns_frags {
  * @INET_FRAG_FIRST_IN: first fragment has arrived
  * @INET_FRAG_LAST_IN: final fragment has arrived
  * @INET_FRAG_COMPLETE: frag queue has been processed and is due for destruction
- * @INET_FRAG_EVICTED: frag queue is being evicted
  */
 enum {
         INET_FRAG_FIRST_IN      = BIT(0),
         INET_FRAG_LAST_IN       = BIT(1),
         INET_FRAG_COMPLETE      = BIT(2),
-        INET_FRAG_EVICTED       = BIT(3)
 };
 
 /**
@@ -43,8 +41,9 @@ enum {
  * @len: total length of the original datagram
  * @meat: length of received fragments so far
  * @flags: fragment queue flags
- * @max_size: (ipv4 only) maximum received fragment size with IP_DF set
+ * @max_size: maximum received fragment size
  * @net: namespace that this frag belongs to
+ * @list_evictor: list of queues to forcefully evict (e.g. due to low memory)
  */
 struct inet_frag_queue {
         spinlock_t              lock;
@@ -59,6 +58,7 @@ struct inet_frag_queue {
         __u8                    flags;
         u16                     max_size;
         struct netns_frags      *net;
+        struct hlist_node       list_evictor;
 };
 
 #define INETFRAGS_HASHSZ        1024
@@ -125,6 +125,11 @@ static inline void inet_frag_put(struct inet_frag_queue *q, struct inet_frags *f
                 inet_frag_destroy(q, f);
 }
 
+static inline bool inet_frag_evicting(struct inet_frag_queue *q)
+{
+        return !hlist_unhashed(&q->list_evictor);
+}
+
 /* Memory Tracking Functions. */
 
 /* The default percpu_counter batch size is not big enough to scale to
@@ -139,14 +144,14 @@ static inline int frag_mem_limit(struct netns_frags *nf)
         return percpu_counter_read(&nf->mem);
 }
 
-static inline void sub_frag_mem_limit(struct inet_frag_queue *q, int i)
+static inline void sub_frag_mem_limit(struct netns_frags *nf, int i)
 {
-        __percpu_counter_add(&q->net->mem, -i, frag_percpu_counter_batch);
+        __percpu_counter_add(&nf->mem, -i, frag_percpu_counter_batch);
 }
 
-static inline void add_frag_mem_limit(struct inet_frag_queue *q, int i)
+static inline void add_frag_mem_limit(struct netns_frags *nf, int i)
 {
-        __percpu_counter_add(&q->net->mem, i, frag_percpu_counter_batch);
+        __percpu_counter_add(&nf->mem, i, frag_percpu_counter_batch);
 }
 
 static inline void init_frag_mem_limit(struct netns_frags *nf)
diff --git a/include/net/inet_hashtables.h b/include/net/inet_hashtables.h
index 73fe0f9525d9..b73c88a19dd4 100644
--- a/include/net/inet_hashtables.h
+++ b/include/net/inet_hashtables.h
@@ -24,7 +24,6 @@
 #include <linux/spinlock.h>
 #include <linux/types.h>
 #include <linux/wait.h>
-#include <linux/vmalloc.h>
 
 #include <net/inet_connection_sock.h>
 #include <net/inet_sock.h>
@@ -148,8 +147,6 @@ struct inet_hashinfo {
          */
         struct inet_listen_hashbucket   listening_hash[INET_LHTABLE_SIZE]
                                         ____cacheline_aligned_in_smp;
-
-        atomic_t                        bsockets;
 };
 
 static inline struct inet_ehash_bucket *inet_ehash_bucket(
@@ -166,52 +163,12 @@ static inline spinlock_t *inet_ehash_lockp(
         return &hashinfo->ehash_locks[hash & hashinfo->ehash_locks_mask];
 }
 
-static inline int inet_ehash_locks_alloc(struct inet_hashinfo *hashinfo)
-{
-        unsigned int i, size = 256;
-#if defined(CONFIG_PROVE_LOCKING)
-        unsigned int nr_pcpus = 2;
-#else
-        unsigned int nr_pcpus = num_possible_cpus();
-#endif
-        if (nr_pcpus >= 4)
-                size = 512;
-        if (nr_pcpus >= 8)
-                size = 1024;
-        if (nr_pcpus >= 16)
-                size = 2048;
-        if (nr_pcpus >= 32)
-                size = 4096;
-        if (sizeof(spinlock_t) != 0) {
-#ifdef CONFIG_NUMA
-                if (size * sizeof(spinlock_t) > PAGE_SIZE)
-                        hashinfo->ehash_locks = vmalloc(size * sizeof(spinlock_t));
-                else
-#endif
-                hashinfo->ehash_locks = kmalloc(size * sizeof(spinlock_t),
-                                                GFP_KERNEL);
-                if (!hashinfo->ehash_locks)
-                        return ENOMEM;
-                for (i = 0; i < size; i++)
-                        spin_lock_init(&hashinfo->ehash_locks[i]);
-        }
-        hashinfo->ehash_locks_mask = size - 1;
-        return 0;
-}
+int inet_ehash_locks_alloc(struct inet_hashinfo *hashinfo);
 
 static inline void inet_ehash_locks_free(struct inet_hashinfo *hashinfo)
 {
-        if (hashinfo->ehash_locks) {
-#ifdef CONFIG_NUMA
-                unsigned int size = (hashinfo->ehash_locks_mask + 1) *
-                                                        sizeof(spinlock_t);
-                if (size > PAGE_SIZE)
-                        vfree(hashinfo->ehash_locks);
-                else
-#endif
-                kfree(hashinfo->ehash_locks);
-                hashinfo->ehash_locks = NULL;
-        }
+        kvfree(hashinfo->ehash_locks);
+        hashinfo->ehash_locks = NULL;
 }
 
 struct inet_bind_bucket *
diff --git a/include/net/inet_sock.h b/include/net/inet_sock.h
index b6c3737da4e9..47eb67b08abd 100644
--- a/include/net/inet_sock.h
+++ b/include/net/inet_sock.h
@@ -187,6 +187,7 @@ struct inet_sock {
                                 transparent:1,
                                 mc_all:1,
                                 nodefrag:1;
+        __u8                    bind_address_no_port:1;
         __u8                    rcv_tos;
         __u8                    convert_csum;
         int                     uc_index;
diff --git a/include/net/ip.h b/include/net/ip.h
index d14af7edd197..d5fe9f2ab699 100644
--- a/include/net/ip.h
+++ b/include/net/ip.h
@@ -31,7 +31,7 @@
 #include <net/route.h>
 #include <net/snmp.h>
 #include <net/flow.h>
-#include <net/flow_keys.h>
+#include <net/flow_dissector.h>
 
 struct sock;
 
@@ -45,6 +45,7 @@ struct inet_skb_parm {
 #define IPSKB_FRAG_COMPLETE     BIT(3)
 #define IPSKB_REROUTED          BIT(4)
 #define IPSKB_DOREDIRECT        BIT(5)
+#define IPSKB_FRAG_PMTU         BIT(6)
 
         u16                     frag_max_size;
 };
@@ -108,9 +109,8 @@ int ip_local_deliver(struct sk_buff *skb);
 int ip_mr_input(struct sk_buff *skb);
 int ip_output(struct sock *sk, struct sk_buff *skb);
 int ip_mc_output(struct sock *sk, struct sk_buff *skb);
-int ip_fragment(struct sock *sk, struct sk_buff *skb,
-                int (*output)(struct sock *, struct sk_buff *));
-int ip_do_nat(struct sk_buff *skb);
+int ip_do_fragment(struct sock *sk, struct sk_buff *skb,
+                   int (*output)(struct sock *, struct sk_buff *));
 void ip_send_check(struct iphdr *ip);
 int __ip_local_out(struct sk_buff *skb);
 int ip_local_out_sk(struct sock *sk, struct sk_buff *skb);
@@ -161,6 +161,7 @@ static inline __u8 get_rtconn_flags(struct ipcm_cookie* ipc, struct sock* sk)
 }
 
 /* datagram.c */
+int __ip4_datagram_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len);
 int ip4_datagram_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len);
 
 void ip4_datagram_release_cb(struct sock *sk);
@@ -355,15 +356,32 @@ static inline __wsum inet_compute_pseudo(struct sk_buff *skb, int proto)
                                   skb->len, proto, 0);
 }
 
+/* copy IPv4 saddr & daddr to flow_keys, possibly using 64bit load/store
+ * Equivalent to :      flow->v4addrs.src = iph->saddr;
+ *                      flow->v4addrs.dst = iph->daddr;
+ */
+static inline void iph_to_flow_copy_v4addrs(struct flow_keys *flow,
+                                            const struct iphdr *iph)
+{
+        BUILD_BUG_ON(offsetof(typeof(flow->addrs), v4addrs.dst) !=
+                     offsetof(typeof(flow->addrs), v4addrs.src) +
+                              sizeof(flow->addrs.v4addrs.src));
+        memcpy(&flow->addrs.v4addrs, &iph->saddr, sizeof(flow->addrs.v4addrs));
+        flow->control.addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS;
+}
+
 static inline void inet_set_txhash(struct sock *sk)
 {
         struct inet_sock *inet = inet_sk(sk);
         struct flow_keys keys;
 
-        keys.src = inet->inet_saddr;
-        keys.dst = inet->inet_daddr;
-        keys.port16[0] = inet->inet_sport;
-        keys.port16[1] = inet->inet_dport;
+        memset(&keys, 0, sizeof(keys));
+
+        keys.addrs.v4addrs.src = inet->inet_saddr;
+        keys.addrs.v4addrs.dst = inet->inet_daddr;
+        keys.control.addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS;
+        keys.ports.src = inet->inet_sport;
+        keys.ports.dst = inet->inet_dport;
 
         sk->sk_txhash = flow_hash_from_keys(&keys);
 }
@@ -478,6 +496,16 @@ enum ip_defrag_users {
         IP_DEFRAG_MACVLAN,
 };
 
+/* Return true if the value of 'user' is between 'lower_bond'
+ * and 'upper_bond' inclusively.
+ */
+static inline bool ip_defrag_user_in_between(u32 user,
+                                             enum ip_defrag_users lower_bond,
+                                             enum ip_defrag_users upper_bond)
+{
+        return user >= lower_bond && user <= upper_bond;
+}
+
 int ip_defrag(struct sk_buff *skb, u32 user);
 #ifdef CONFIG_INET
 struct sk_buff *ip_check_defrag(struct sk_buff *skb, u32 user);
diff --git a/include/net/ip6_fib.h b/include/net/ip6_fib.h
index 20e80fa7bbdd..3b76849c190f 100644
--- a/include/net/ip6_fib.h
+++ b/include/net/ip6_fib.h
@@ -120,45 +120,19 @@ struct rt6_info {
         struct rt6key                   rt6i_src;
         struct rt6key                   rt6i_prefsrc;
 
+        struct list_head                rt6i_uncached;
+        struct uncached_list            *rt6i_uncached_list;
+
         struct inet6_dev                *rt6i_idev;
-        unsigned long                   _rt6i_peer;
+        struct rt6_info * __percpu      *rt6i_pcpu;
 
         u32                             rt6i_metric;
+        u32                             rt6i_pmtu;
         /* more non-fragment space at head required */
         unsigned short                  rt6i_nfheader_len;
         u8                              rt6i_protocol;
 };
 
-static inline struct inet_peer *rt6_peer_ptr(struct rt6_info *rt)
-{
-        return inetpeer_ptr(rt->_rt6i_peer);
-}
-
-static inline bool rt6_has_peer(struct rt6_info *rt)
-{
-        return inetpeer_ptr_is_peer(rt->_rt6i_peer);
-}
-
-static inline void __rt6_set_peer(struct rt6_info *rt, struct inet_peer *peer)
-{
-        __inetpeer_ptr_set_peer(&rt->_rt6i_peer, peer);
-}
-
-static inline bool rt6_set_peer(struct rt6_info *rt, struct inet_peer *peer)
-{
-        return inetpeer_ptr_set_peer(&rt->_rt6i_peer, peer);
-}
-
-static inline void rt6_init_peer(struct rt6_info *rt, struct inet_peer_base *base)
-{
-        inetpeer_init_ptr(&rt->_rt6i_peer, base);
-}
-
-static inline void rt6_transfer_peer(struct rt6_info *rt, struct rt6_info *ort)
-{
-        inetpeer_transfer_peer(&rt->_rt6i_peer, &ort->_rt6i_peer);
-}
-
 static inline struct inet6_dev *ip6_dst_idev(struct dst_entry *dst)
 {
         return ((struct rt6_info *)dst)->rt6i_idev;
@@ -189,13 +163,12 @@ static inline void rt6_update_expires(struct rt6_info *rt0, int timeout)
         rt0->rt6i_flags |= RTF_EXPIRES;
 }
 
-static inline void rt6_set_from(struct rt6_info *rt, struct rt6_info *from)
+static inline u32 rt6_get_cookie(const struct rt6_info *rt)
 {
-        struct dst_entry *new = (struct dst_entry *) from;
+        if (rt->rt6i_flags & RTF_PCPU || unlikely(rt->dst.flags & DST_NOCACHE))
+                rt = (struct rt6_info *)(rt->dst.from);
 
-        rt->rt6i_flags &= ~RTF_EXPIRES;
-        dst_hold(new);
-        rt->dst.from = new;
+        return rt->rt6i_node ? rt->rt6i_node->fn_sernum : 0;
 }
 
 static inline void ip6_rt_put(struct rt6_info *rt)
diff --git a/include/net/ip6_route.h b/include/net/ip6_route.h
index 5e192068e6cb..297629aadb19 100644
--- a/include/net/ip6_route.h
+++ b/include/net/ip6_route.h
@@ -145,7 +145,7 @@ static inline void __ip6_dst_store(struct sock *sk, struct dst_entry *dst,
 #ifdef CONFIG_IPV6_SUBTREES
         np->saddr_cache = saddr;
 #endif
-        np->dst_cookie = rt->rt6i_node ? rt->rt6i_node->fn_sernum : 0;
+        np->dst_cookie = rt6_get_cookie(rt);
 }
 
 static inline void ip6_dst_store(struct sock *sk, struct dst_entry *dst,
@@ -163,11 +163,14 @@ static inline bool ipv6_unicast_destination(const struct sk_buff *skb)
         return rt->rt6i_flags & RTF_LOCAL;
 }
 
-static inline bool ipv6_anycast_destination(const struct sk_buff *skb)
+static inline bool ipv6_anycast_destination(const struct dst_entry *dst,
+                                            const struct in6_addr *daddr)
 {
-        struct rt6_info *rt = (struct rt6_info *) skb_dst(skb);
+        struct rt6_info *rt = (struct rt6_info *)dst;
 
-        return rt->rt6i_flags & RTF_ANYCAST;
+        return rt->rt6i_flags & RTF_ANYCAST ||
+                (rt->rt6i_dst.plen != 128 &&
+                 ipv6_addr_equal(&rt->rt6i_dst.addr, daddr));
 }
 
 int ip6_fragment(struct sock *sk, struct sk_buff *skb,
@@ -194,9 +197,15 @@ static inline bool ip6_sk_ignore_df(const struct sock *sk)
                inet6_sk(sk)->pmtudisc == IPV6_PMTUDISC_OMIT;
 }
 
-static inline struct in6_addr *rt6_nexthop(struct rt6_info *rt)
+static inline struct in6_addr *rt6_nexthop(struct rt6_info *rt,
+                                           struct in6_addr *daddr)
 {
-        return &rt->rt6i_gateway;
+        if (rt->rt6i_flags & RTF_GATEWAY)
+                return &rt->rt6i_gateway;
+        else if (unlikely(rt->rt6i_flags & RTF_CACHE))
+                return &rt->rt6i_dst.addr;
+        else
+                return daddr;
 }
 
 #endif
diff --git a/include/net/ip_fib.h b/include/net/ip_fib.h
index 54271ed0ed45..5fa643b4e891 100644
--- a/include/net/ip_fib.h
+++ b/include/net/ip_fib.h
@@ -183,7 +183,6 @@ __be32 fib_info_update_nh_saddr(struct net *net, struct fib_nh *nh);
 struct fib_table {
         struct hlist_node       tb_hlist;
         u32                     tb_id;
-        int                     tb_default;
         int                     tb_num_default;
         struct rcu_head         rcu;
         unsigned long           *tb_data;
@@ -226,7 +225,7 @@ static inline struct fib_table *fib_new_table(struct net *net, u32 id)
 }
 
 static inline int fib_lookup(struct net *net, const struct flowi4 *flp,
-                             struct fib_result *res)
+                             struct fib_result *res, unsigned int flags)
 {
         struct fib_table *tb;
         int err = -ENETUNREACH;
@@ -234,7 +233,7 @@ static inline int fib_lookup(struct net *net, const struct flowi4 *flp,
         rcu_read_lock();
 
         tb = fib_get_table(net, RT_TABLE_MAIN);
-        if (tb && !fib_table_lookup(tb, flp, res, FIB_LOOKUP_NOREF))
+        if (tb && !fib_table_lookup(tb, flp, res, flags | FIB_LOOKUP_NOREF))
                 err = 0;
 
         rcu_read_unlock();
@@ -249,16 +248,18 @@ void __net_exit fib4_rules_exit(struct net *net);
 struct fib_table *fib_new_table(struct net *net, u32 id);
 struct fib_table *fib_get_table(struct net *net, u32 id);
 
-int __fib_lookup(struct net *net, struct flowi4 *flp, struct fib_result *res);
+int __fib_lookup(struct net *net, struct flowi4 *flp,
+                 struct fib_result *res, unsigned int flags);
 
 static inline int fib_lookup(struct net *net, struct flowi4 *flp,
-                             struct fib_result *res)
+                             struct fib_result *res, unsigned int flags)
 {
         struct fib_table *tb;
         int err;
 
+        flags |= FIB_LOOKUP_NOREF;
         if (net->ipv4.fib_has_custom_rules)
-                return __fib_lookup(net, flp, res);
+                return __fib_lookup(net, flp, res, flags);
 
         rcu_read_lock();
 
@@ -266,11 +267,11 @@ static inline int fib_lookup(struct net *net, struct flowi4 *flp,
 
         for (err = 0; !err; err = -ENETUNREACH) {
                 tb = rcu_dereference_rtnl(net->ipv4.fib_main);
-                if (tb && !fib_table_lookup(tb, flp, res, FIB_LOOKUP_NOREF))
+                if (tb && !fib_table_lookup(tb, flp, res, flags))
                         break;
 
                 tb = rcu_dereference_rtnl(net->ipv4.fib_default);
-                if (tb && !fib_table_lookup(tb, flp, res, FIB_LOOKUP_NOREF))
+                if (tb && !fib_table_lookup(tb, flp, res, flags))
                         break;
         }
 
@@ -288,7 +289,7 @@ __be32 fib_compute_spec_dst(struct sk_buff *skb);
 int fib_validate_source(struct sk_buff *skb, __be32 src, __be32 dst,
                         u8 tos, int oif, struct net_device *dev,
                         struct in_device *idev, u32 *itag);
-void fib_select_default(struct fib_result *res);
+void fib_select_default(const struct flowi4 *flp, struct fib_result *res);
 #ifdef CONFIG_IP_ROUTE_CLASSID
 static inline int fib_num_tclassid_users(struct net *net)
 {
@@ -305,9 +306,9 @@ void fib_flush_external(struct net *net);
 
 /* Exported by fib_semantics.c */
 int ip_fib_check_default(__be32 gw, struct net_device *dev);
-int fib_sync_down_dev(struct net_device *dev, int force);
+int fib_sync_down_dev(struct net_device *dev, unsigned long event);
 int fib_sync_down_addr(struct net *net, __be32 local);
-int fib_sync_up(struct net_device *dev);
+int fib_sync_up(struct net_device *dev, unsigned int nh_flags);
 void fib_select_multipath(struct fib_result *res);
 
 /* Exported by fib_trie.c */
diff --git a/include/net/ipv6.h b/include/net/ipv6.h
index eec8ad3c9843..82dbdb092a5d 100644
--- a/include/net/ipv6.h
+++ b/include/net/ipv6.h
@@ -19,7 +19,7 @@
 #include <net/if_inet6.h>
 #include <net/ndisc.h>
 #include <net/flow.h>
-#include <net/flow_keys.h>
+#include <net/flow_dissector.h>
 #include <net/snmp.h>
 
 #define SIN6_LEN_RFC2133        24
@@ -239,8 +239,10 @@ struct ip6_flowlabel {
         struct net              *fl_net;
 };
 
-#define IPV6_FLOWINFO_MASK      cpu_to_be32(0x0FFFFFFF)
-#define IPV6_FLOWLABEL_MASK     cpu_to_be32(0x000FFFFF)
+#define IPV6_FLOWINFO_MASK              cpu_to_be32(0x0FFFFFFF)
+#define IPV6_FLOWLABEL_MASK             cpu_to_be32(0x000FFFFF)
+#define IPV6_FLOWLABEL_STATELESS_FLAG   cpu_to_be32(0x00080000)
+
 #define IPV6_TCLASS_MASK (IPV6_FLOWINFO_MASK & ~IPV6_FLOWLABEL_MASK)
 #define IPV6_TCLASS_SHIFT       20
 
@@ -669,8 +671,9 @@ static inline int ipv6_addr_diff(const struct in6_addr *a1, const struct in6_add
         return __ipv6_addr_diff(a1, a2, sizeof(struct in6_addr));
 }
 
-void ipv6_select_ident(struct net *net, struct frag_hdr *fhdr,
-                       struct rt6_info *rt);
+__be32 ipv6_select_ident(struct net *net,
+                         const struct in6_addr *daddr,
+                         const struct in6_addr *saddr);
 void ipv6_proxy_select_ident(struct net *net, struct sk_buff *skb);
 
 int ip6_dst_hoplimit(struct dst_entry *dst);
@@ -689,6 +692,20 @@ static inline int ip6_sk_dst_hoplimit(struct ipv6_pinfo *np, struct flowi6 *fl6,
         return hlimit;
 }
 
+/* copy IPv6 saddr & daddr to flow_keys, possibly using 64bit load/store
+ * Equivalent to :      flow->v6addrs.src = iph->saddr;
+ *                      flow->v6addrs.dst = iph->daddr;
+ */
+static inline void iph_to_flow_copy_v6addrs(struct flow_keys *flow,
+                                            const struct ipv6hdr *iph)
+{
+        BUILD_BUG_ON(offsetof(typeof(flow->addrs), v6addrs.dst) !=
+                     offsetof(typeof(flow->addrs), v6addrs.src) +
+                     sizeof(flow->addrs.v6addrs.src));
+        memcpy(&flow->addrs.v6addrs, &iph->saddr, sizeof(flow->addrs.v6addrs));
+        flow->control.addr_type = FLOW_DISSECTOR_KEY_IPV6_ADDRS;
+}
+
 #if IS_ENABLED(CONFIG_IPV6)
 static inline void ip6_set_txhash(struct sock *sk)
 {
@@ -696,10 +713,15 @@ static inline void ip6_set_txhash(struct sock *sk)
         struct ipv6_pinfo *np = inet6_sk(sk);
         struct flow_keys keys;
 
-        keys.src = (__force __be32)ipv6_addr_hash(&np->saddr);
-        keys.dst = (__force __be32)ipv6_addr_hash(&sk->sk_v6_daddr);
-        keys.port16[0] = inet->inet_sport;
-        keys.port16[1] = inet->inet_dport;
+        memset(&keys, 0, sizeof(keys));
+
+        memcpy(&keys.addrs.v6addrs.src, &np->saddr,
+               sizeof(keys.addrs.v6addrs.src));
+        memcpy(&keys.addrs.v6addrs.dst, &sk->sk_v6_daddr,
+               sizeof(keys.addrs.v6addrs.dst));
+        keys.control.addr_type = FLOW_DISSECTOR_KEY_IPV6_ADDRS;
+        keys.ports.src = inet->inet_sport;
+        keys.ports.dst = inet->inet_dport;
 
         sk->sk_txhash = flow_hash_from_keys(&keys);
 }
@@ -719,6 +741,9 @@ static inline __be32 ip6_make_flowlabel(struct net *net, struct sk_buff *skb,
                 hash ^= hash >> 12;
 
                 flowlabel = (__force __be32)hash & IPV6_FLOWLABEL_MASK;
+
+                if (net->ipv6.sysctl.flowlabel_state_ranges)
+                        flowlabel |= IPV6_FLOWLABEL_STATELESS_FLAG;
         }
 
         return flowlabel;
diff --git a/include/net/llc_conn.h b/include/net/llc_conn.h
index 0134681acc4c..fe994d2e5286 100644
--- a/include/net/llc_conn.h
+++ b/include/net/llc_conn.h
@@ -96,7 +96,7 @@ static __inline__ char llc_backlog_type(struct sk_buff *skb)
 }
 
 struct sock *llc_sk_alloc(struct net *net, int family, gfp_t priority,
-                          struct proto *prot);
+                          struct proto *prot, int kern);
 void llc_sk_free(struct sock *sk);
 
 void llc_sk_reset(struct sock *sk);
diff --git a/include/net/mac80211.h b/include/net/mac80211.h
index fc57f6b82fc5..6b1077c2a63f 100644
--- a/include/net/mac80211.h
+++ b/include/net/mac80211.h
@@ -337,10 +337,16 @@ enum ieee80211_bss_change {
  * enum ieee80211_event_type - event to be notified to the low level driver
  * @RSSI_EVENT: AP's rssi crossed the a threshold set by the driver.
  * @MLME_EVENT: event related to MLME
+ * @BAR_RX_EVENT: a BAR was received
+ * @BA_FRAME_TIMEOUT: Frames were released from the reordering buffer because
+ *      they timed out. This won't be called for each frame released, but only
+ *      once each time the timeout triggers.
  */
 enum ieee80211_event_type {
         RSSI_EVENT,
         MLME_EVENT,
+        BAR_RX_EVENT,
+        BA_FRAME_TIMEOUT,
 };
 
 /**
@@ -400,17 +406,31 @@ struct ieee80211_mlme_event {
 };
 
 /**
+ * struct ieee80211_ba_event - data attached for BlockAck related events
+ * @sta: pointer to the &ieee80211_sta to which this event relates
+ * @tid: the tid
+ * @ssn: the starting sequence number (for %BAR_RX_EVENT)
+ */
+struct ieee80211_ba_event {
+        struct ieee80211_sta *sta;
+        u16 tid;
+        u16 ssn;
+};
+
+/**
  * struct ieee80211_event - event to be sent to the driver
  * @type: The event itself. See &enum ieee80211_event_type.
  * @rssi: relevant if &type is %RSSI_EVENT
  * @mlme: relevant if &type is %AUTH_EVENT
- * @u:    union holding the above two fields
+ * @ba: relevant if &type is %BAR_RX_EVENT or %BA_FRAME_TIMEOUT
+ * @u:union holding the fields above
  */
 struct ieee80211_event {
         enum ieee80211_event_type type;
         union {
                 struct ieee80211_rssi_event rssi;
                 struct ieee80211_mlme_event mlme;
+                struct ieee80211_ba_event ba;
         } u;
 };
 
@@ -426,12 +446,8 @@ struct ieee80211_event {
  * @ibss_creator: indicates if a new IBSS network is being created
  * @aid: association ID number, valid only when @assoc is true
  * @use_cts_prot: use CTS protection
- * @use_short_preamble: use 802.11b short preamble;
- *      if the hardware cannot handle this it must set the
- *      IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE hardware flag
- * @use_short_slot: use short slot time (only relevant for ERP);
- *      if the hardware cannot handle this it must set the
- *      IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE hardware flag
+ * @use_short_preamble: use 802.11b short preamble
+ * @use_short_slot: use short slot time (only relevant for ERP)
  * @dtim_period: num of beacons before the next DTIM, for beaconing,
  *      valid in station mode only if after the driver was notified
  *      with the %BSS_CHANGED_BEACON_INFO flag, will be non-zero then.
@@ -855,6 +871,9 @@ struct ieee80211_tx_info {
                         /* 4 bytes free */
                 } control;
                 struct {
+                        u64 cookie;
+                } ack;
+                struct {
                         struct ieee80211_tx_rate rates[IEEE80211_TX_MAX_RATES];
                         s32 ack_signal;
                         u8 ampdu_ack_len;
@@ -1459,6 +1478,9 @@ enum ieee80211_key_flags {
  *      wants to be given when a frame is transmitted and needs to be
  *      encrypted in hardware.
  * @cipher: The key's cipher suite selector.
+ * @tx_pn: PN used for TX on non-TKIP keys, may be used by the driver
+ *      as well if it needs to do software PN assignment by itself
+ *      (e.g. due to TSO)
  * @flags: key flags, see &enum ieee80211_key_flags.
  * @keyidx: the key index (0-3)
  * @keylen: key material length
@@ -1471,6 +1493,7 @@ enum ieee80211_key_flags {
  * @iv_len: The IV length for this key type
  */
 struct ieee80211_key_conf {
+        atomic64_t tx_pn;
         u32 cipher;
         u8 icv_len;
         u8 iv_len;
@@ -1481,6 +1504,47 @@ struct ieee80211_key_conf {
         u8 key[0];
 };
 
+#define IEEE80211_MAX_PN_LEN    16
+
+/**
+ * struct ieee80211_key_seq - key sequence counter
+ *
+ * @tkip: TKIP data, containing IV32 and IV16 in host byte order
+ * @ccmp: PN data, most significant byte first (big endian,
+ *      reverse order than in packet)
+ * @aes_cmac: PN data, most significant byte first (big endian,
+ *      reverse order than in packet)
+ * @aes_gmac: PN data, most significant byte first (big endian,
+ *      reverse order than in packet)
+ * @gcmp: PN data, most significant byte first (big endian,
+ *      reverse order than in packet)
+ * @hw: data for HW-only (e.g. cipher scheme) keys
+ */
+struct ieee80211_key_seq {
+        union {
+                struct {
+                        u32 iv32;
+                        u16 iv16;
+                } tkip;
+                struct {
+                        u8 pn[6];
+                } ccmp;
+                struct {
+                        u8 pn[6];
+                } aes_cmac;
+                struct {
+                        u8 pn[6];
+                } aes_gmac;
+                struct {
+                        u8 pn[6];
+                } gcmp;
+                struct {
+                        u8 seq[IEEE80211_MAX_PN_LEN];
+                        u8 seq_len;
+                } hw;
+        };
+};
+
 /**
  * struct ieee80211_cipher_scheme - cipher scheme
  *
@@ -1667,8 +1731,7 @@ struct ieee80211_tx_control {
  * @sta: station table entry, %NULL for per-vif queue
  * @tid: the TID for this queue (unused for per-vif queue)
  * @ac: the AC for this queue
- * @drv_priv: data area for driver use, will always be aligned to
- *      sizeof(void *).
+ * @drv_priv: driver private area, sized by hw->txq_data_size
  *
  * The driver can obtain packets from this queue by calling
  * ieee80211_tx_dequeue().
@@ -1717,13 +1780,6 @@ struct ieee80211_txq {
  *      multicast frames when there are power saving stations so that
  *      the driver can fetch them with ieee80211_get_buffered_bc().
  *
- * @IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE:
- *      Hardware is not capable of short slot operation on the 2.4 GHz band.
- *
- * @IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE:
- *      Hardware is not capable of receiving frames with short preamble on
- *      the 2.4 GHz band.
- *
  * @IEEE80211_HW_SIGNAL_UNSPEC:
  *      Hardware can provide signal values but we don't know its units. We
  *      expect values between 0 and @max_signal.
@@ -1798,6 +1854,10 @@ struct ieee80211_txq {
  *      the driver returns 1. This also forces the driver to advertise its
  *      supported cipher suites.
  *
+ * @IEEE80211_HW_SUPPORT_FAST_XMIT: The driver/hardware supports fast-xmit,
+ *      this currently requires only the ability to calculate the duration
+ *      for frames.
+ *
  * @IEEE80211_HW_QUEUE_CONTROL: The driver wants to control per-interface
  *      queue mapping in order to use different queues (not just one per AC)
  *      for different virtual interfaces. See the doc section on HW queue
@@ -1825,41 +1885,44 @@ struct ieee80211_txq {
  * @IEEE80211_HW_SUPPORTS_CLONED_SKBS: The driver will never modify the payload
  *      or tailroom of TX skbs without copying them first.
  *
- * @IEEE80211_SINGLE_HW_SCAN_ON_ALL_BANDS: The HW supports scanning on all bands
+ * @IEEE80211_HW_SINGLE_SCAN_ON_ALL_BANDS: The HW supports scanning on all bands
  *      in one command, mac80211 doesn't have to run separate scans per band.
+ *
+ * @NUM_IEEE80211_HW_FLAGS: number of hardware flags, used for sizing arrays
  */
 enum ieee80211_hw_flags {
-        IEEE80211_HW_HAS_RATE_CONTROL                   = 1<<0,
-        IEEE80211_HW_RX_INCLUDES_FCS                    = 1<<1,
-        IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING        = 1<<2,
-        IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE          = 1<<3,
-        IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE      = 1<<4,
-        IEEE80211_HW_SIGNAL_UNSPEC                      = 1<<5,
-        IEEE80211_HW_SIGNAL_DBM                         = 1<<6,
-        IEEE80211_HW_NEED_DTIM_BEFORE_ASSOC             = 1<<7,
-        IEEE80211_HW_SPECTRUM_MGMT                      = 1<<8,
-        IEEE80211_HW_AMPDU_AGGREGATION                  = 1<<9,
-        IEEE80211_HW_SUPPORTS_PS                        = 1<<10,
-        IEEE80211_HW_PS_NULLFUNC_STACK                  = 1<<11,
-        IEEE80211_HW_SUPPORTS_DYNAMIC_PS                = 1<<12,
-        IEEE80211_HW_MFP_CAPABLE                        = 1<<13,
-        IEEE80211_HW_WANT_MONITOR_VIF                   = 1<<14,
-        IEEE80211_HW_NO_AUTO_VIF                        = 1<<15,
-        IEEE80211_HW_SW_CRYPTO_CONTROL                  = 1<<16,
-        /* free slots */
-        IEEE80211_HW_REPORTS_TX_ACK_STATUS              = 1<<18,
-        IEEE80211_HW_CONNECTION_MONITOR                 = 1<<19,
-        IEEE80211_HW_QUEUE_CONTROL                      = 1<<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_SUPPORTS_RC_TABLE                  = 1<<24,
-        IEEE80211_HW_P2P_DEV_ADDR_FOR_INTF              = 1<<25,
-        IEEE80211_HW_TIMING_BEACON_ONLY                 = 1<<26,
-        IEEE80211_HW_SUPPORTS_HT_CCK_RATES              = 1<<27,
-        IEEE80211_HW_CHANCTX_STA_CSA                    = 1<<28,
-        IEEE80211_HW_SUPPORTS_CLONED_SKBS               = 1<<29,
-        IEEE80211_SINGLE_HW_SCAN_ON_ALL_BANDS           = 1<<30,
+        IEEE80211_HW_HAS_RATE_CONTROL,
+        IEEE80211_HW_RX_INCLUDES_FCS,
+        IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING,
+        IEEE80211_HW_SIGNAL_UNSPEC,
+        IEEE80211_HW_SIGNAL_DBM,
+        IEEE80211_HW_NEED_DTIM_BEFORE_ASSOC,
+        IEEE80211_HW_SPECTRUM_MGMT,
+        IEEE80211_HW_AMPDU_AGGREGATION,
+        IEEE80211_HW_SUPPORTS_PS,
+        IEEE80211_HW_PS_NULLFUNC_STACK,
+        IEEE80211_HW_SUPPORTS_DYNAMIC_PS,
+        IEEE80211_HW_MFP_CAPABLE,
+        IEEE80211_HW_WANT_MONITOR_VIF,
+        IEEE80211_HW_NO_AUTO_VIF,
+        IEEE80211_HW_SW_CRYPTO_CONTROL,
+        IEEE80211_HW_SUPPORT_FAST_XMIT,
+        IEEE80211_HW_REPORTS_TX_ACK_STATUS,
+        IEEE80211_HW_CONNECTION_MONITOR,
+        IEEE80211_HW_QUEUE_CONTROL,
+        IEEE80211_HW_SUPPORTS_PER_STA_GTK,
+        IEEE80211_HW_AP_LINK_PS,
+        IEEE80211_HW_TX_AMPDU_SETUP_IN_HW,
+        IEEE80211_HW_SUPPORTS_RC_TABLE,
+        IEEE80211_HW_P2P_DEV_ADDR_FOR_INTF,
+        IEEE80211_HW_TIMING_BEACON_ONLY,
+        IEEE80211_HW_SUPPORTS_HT_CCK_RATES,
+        IEEE80211_HW_CHANCTX_STA_CSA,
+        IEEE80211_HW_SUPPORTS_CLONED_SKBS,
+        IEEE80211_HW_SINGLE_SCAN_ON_ALL_BANDS,
+
+        /* keep last, obviously */
+        NUM_IEEE80211_HW_FLAGS
 };
 
 /**
@@ -1940,8 +2003,8 @@ enum ieee80211_hw_flags {
  *      Use the %IEEE80211_RADIOTAP_VHT_KNOWN_* values.
  *
  * @netdev_features: netdev features to be set in each netdev created
- *      from this HW. Note only HW checksum features are currently
- *      compatible with mac80211. Other feature bits will be rejected.
+ *      from this HW. Note that not all features are usable with mac80211,
+ *      other features will be rejected during HW registration.
  *
  * @uapsd_queues: This bitmap is included in (re)association frame to indicate
  *      for each access category if it is uAPSD trigger-enabled and delivery-
@@ -1966,7 +2029,7 @@ struct ieee80211_hw {
         struct wiphy *wiphy;
         const char *rate_control_algorithm;
         void *priv;
-        u32 flags;
+        unsigned long flags[BITS_TO_LONGS(NUM_IEEE80211_HW_FLAGS)];
         unsigned int extra_tx_headroom;
         unsigned int extra_beacon_tailroom;
         int vif_data_size;
@@ -1992,6 +2055,20 @@ struct ieee80211_hw {
         int txq_ac_max_pending;
 };
 
+static inline bool _ieee80211_hw_check(struct ieee80211_hw *hw,
+                                       enum ieee80211_hw_flags flg)
+{
+        return test_bit(flg, hw->flags);
+}
+#define ieee80211_hw_check(hw, flg)     _ieee80211_hw_check(hw, IEEE80211_HW_##flg)
+
+static inline void _ieee80211_hw_set(struct ieee80211_hw *hw,
+                                     enum ieee80211_hw_flags flg)
+{
+        return __set_bit(flg, hw->flags);
+}
+#define ieee80211_hw_set(hw, flg)       _ieee80211_hw_set(hw, IEEE80211_HW_##flg)
+
 /**
  * struct ieee80211_scan_request - hw scan request
  *
@@ -2505,10 +2582,6 @@ void ieee80211_free_txskb(struct ieee80211_hw *hw, struct sk_buff *skb);
  * stack. It is always safe to pass more frames than requested,
  * but this has negative impact on power consumption.
  *
- * @FIF_PROMISC_IN_BSS: promiscuous mode within your BSS,
- *      think of the BSS as your network segment and then this corresponds
- *      to the regular ethernet device promiscuous mode.
- *
  * @FIF_ALLMULTI: pass all multicast frames, this is used if requested
  *      by the user or if the hardware is not capable of filtering by
  *      multicast address.
@@ -2525,18 +2598,16 @@ void ieee80211_free_txskb(struct ieee80211_hw *hw, struct sk_buff *skb);
  *      mac80211 needs to do and the amount of CPU wakeups, so you should
  *      honour this flag if possible.
  *
- * @FIF_CONTROL: pass control frames (except for PS Poll), if PROMISC_IN_BSS
- *      is not set then only those addressed to this station.
+ * @FIF_CONTROL: pass control frames (except for PS Poll) addressed to this
+ *      station
  *
  * @FIF_OTHER_BSS: pass frames destined to other BSSes
  *
- * @FIF_PSPOLL: pass PS Poll frames, if PROMISC_IN_BSS is not set then only
- *      those addressed to this station.
+ * @FIF_PSPOLL: pass PS Poll frames
  *
  * @FIF_PROBE_REQ: pass probe request frames
  */
 enum ieee80211_filter_flags {
-        FIF_PROMISC_IN_BSS      = 1<<0,
         FIF_ALLMULTI            = 1<<1,
         FIF_FCSFAIL             = 1<<2,
         FIF_PLCPFAIL            = 1<<3,
@@ -2819,9 +2890,9 @@ enum ieee80211_reconfig_type {
  *      Returns zero if statistics are available.
  *      The callback can sleep.
  *
- * @get_tkip_seq: If your device implements TKIP encryption in hardware this
- *      callback should be provided to read the TKIP transmit IVs (both IV32
- *      and IV16) for the given key from hardware.
+ * @get_key_seq: If your device implements encryption in hardware and does
+ *      IV/PN assignment then this callback should be provided to read the
+ *      IV/PN for the given key from hardware.
  *      The callback must be atomic.
  *
  * @set_frag_threshold: Configuration of fragmentation threshold. Assign this
@@ -3004,7 +3075,7 @@ enum ieee80211_reconfig_type {
  *      The callback can sleep.
  * @event_callback: Notify driver about any event in mac80211. See
  *      &enum ieee80211_event_type for the different types.
- *      The callback can sleep.
+ *      The callback must be atomic.
  *
  * @release_buffered_frames: Release buffered frames according to the given
  *      parameters. In the case where the driver buffers some frames for
@@ -3220,8 +3291,9 @@ struct ieee80211_ops {
                                  struct ieee80211_vif *vif);
         int (*get_stats)(struct ieee80211_hw *hw,
                          struct ieee80211_low_level_stats *stats);
-        void (*get_tkip_seq)(struct ieee80211_hw *hw, u8 hw_key_idx,
-                             u32 *iv32, u16 *iv16);
+        void (*get_key_seq)(struct ieee80211_hw *hw,
+                            struct ieee80211_key_conf *key,
+                            struct ieee80211_key_seq *seq);
         int (*set_frag_threshold)(struct ieee80211_hw *hw, u32 value);
         int (*set_rts_threshold)(struct ieee80211_hw *hw, u32 value);
         int (*sta_add)(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
@@ -3469,14 +3541,15 @@ enum ieee80211_tpt_led_trigger_flags {
 };
 
 #ifdef CONFIG_MAC80211_LEDS
-char *__ieee80211_get_tx_led_name(struct ieee80211_hw *hw);
-char *__ieee80211_get_rx_led_name(struct ieee80211_hw *hw);
-char *__ieee80211_get_assoc_led_name(struct ieee80211_hw *hw);
-char *__ieee80211_get_radio_led_name(struct ieee80211_hw *hw);
-char *__ieee80211_create_tpt_led_trigger(struct ieee80211_hw *hw,
-                                         unsigned int flags,
-                                         const struct ieee80211_tpt_blink *blink_table,
-                                         unsigned int blink_table_len);
+const char *__ieee80211_get_tx_led_name(struct ieee80211_hw *hw);
+const char *__ieee80211_get_rx_led_name(struct ieee80211_hw *hw);
+const char *__ieee80211_get_assoc_led_name(struct ieee80211_hw *hw);
+const char *__ieee80211_get_radio_led_name(struct ieee80211_hw *hw);
+const char *
+__ieee80211_create_tpt_led_trigger(struct ieee80211_hw *hw,
+                                   unsigned int flags,
+                                   const struct ieee80211_tpt_blink *blink_table,
+                                   unsigned int blink_table_len);
 #endif
 /**
  * ieee80211_get_tx_led_name - get name of TX LED
@@ -3490,7 +3563,7 @@ char *__ieee80211_create_tpt_led_trigger(struct ieee80211_hw *hw,
  *
  * Return: The name of the LED trigger. %NULL if not configured for LEDs.
  */
-static inline char *ieee80211_get_tx_led_name(struct ieee80211_hw *hw)
+static inline const char *ieee80211_get_tx_led_name(struct ieee80211_hw *hw)
 {
 #ifdef CONFIG_MAC80211_LEDS
         return __ieee80211_get_tx_led_name(hw);
@@ -3511,7 +3584,7 @@ static inline char *ieee80211_get_tx_led_name(struct ieee80211_hw *hw)
  *
  * Return: The name of the LED trigger. %NULL if not configured for LEDs.
  */
-static inline char *ieee80211_get_rx_led_name(struct ieee80211_hw *hw)
+static inline const char *ieee80211_get_rx_led_name(struct ieee80211_hw *hw)
 {
 #ifdef CONFIG_MAC80211_LEDS
         return __ieee80211_get_rx_led_name(hw);
@@ -3532,7 +3605,7 @@ static inline char *ieee80211_get_rx_led_name(struct ieee80211_hw *hw)
  *
  * Return: The name of the LED trigger. %NULL if not configured for LEDs.
  */
-static inline char *ieee80211_get_assoc_led_name(struct ieee80211_hw *hw)
+static inline const char *ieee80211_get_assoc_led_name(struct ieee80211_hw *hw)
 {
 #ifdef CONFIG_MAC80211_LEDS
         return __ieee80211_get_assoc_led_name(hw);
@@ -3553,7 +3626,7 @@ static inline char *ieee80211_get_assoc_led_name(struct ieee80211_hw *hw)
  *
  * Return: The name of the LED trigger. %NULL if not configured for LEDs.
  */
-static inline char *ieee80211_get_radio_led_name(struct ieee80211_hw *hw)
+static inline const char *ieee80211_get_radio_led_name(struct ieee80211_hw *hw)
 {
 #ifdef CONFIG_MAC80211_LEDS
         return __ieee80211_get_radio_led_name(hw);
@@ -3574,7 +3647,7 @@ static inline char *ieee80211_get_radio_led_name(struct ieee80211_hw *hw)
  *
  * Note: This function must be called before ieee80211_register_hw().
  */
-static inline char *
+static inline const char *
 ieee80211_create_tpt_led_trigger(struct ieee80211_hw *hw, unsigned int flags,
                                  const struct ieee80211_tpt_blink *blink_table,
                                  unsigned int blink_table_len)
@@ -4255,40 +4328,6 @@ void ieee80211_aes_cmac_calculate_k1_k2(struct ieee80211_key_conf *keyconf,
                                         u8 *k1, u8 *k2);
 
 /**
- * struct ieee80211_key_seq - key sequence counter
- *
- * @tkip: TKIP data, containing IV32 and IV16 in host byte order
- * @ccmp: PN data, most significant byte first (big endian,
- *      reverse order than in packet)
- * @aes_cmac: PN data, most significant byte first (big endian,
- *      reverse order than in packet)
- * @aes_gmac: PN data, most significant byte first (big endian,
- *      reverse order than in packet)
- * @gcmp: PN data, most significant byte first (big endian,
- *      reverse order than in packet)
- */
-struct ieee80211_key_seq {
-        union {
-                struct {
-                        u32 iv32;
-                        u16 iv16;
-                } tkip;
-                struct {
-                        u8 pn[6];
-                } ccmp;
-                struct {
-                        u8 pn[6];
-                } aes_cmac;
-                struct {
-                        u8 pn[6];
-                } aes_gmac;
-                struct {
-                        u8 pn[6];
-                } gcmp;
-        };
-};
-
-/**
  * ieee80211_get_key_tx_seq - get key TX sequence counter
  *
  * @keyconf: the parameter passed with the set key
diff --git a/include/net/mac802154.h b/include/net/mac802154.h
index 7df28a4c23f9..f534a46911dc 100644
--- a/include/net/mac802154.h
+++ b/include/net/mac802154.h
@@ -31,99 +31,122 @@
  */
 #define MAC802154_FRAME_HARD_HEADER_LEN         (2 + 1 + 20 + 14)
 
-/* The following flags are used to indicate changed address settings from
+/**
+ * enum ieee802154_hw_addr_filt_flags - hardware address filtering flags
+ *
+ * The following flags are used to indicate changed address settings from
  * the stack to the hardware.
+ *
+ * @IEEE802154_AFILT_SADDR_CHANGED: Indicates that the short address will be
+ *      change.
+ *
+ * @IEEE802154_AFILT_IEEEADDR_CHANGED: Indicates that the extended address
+ *      will be change.
+ *
+ * @IEEE802154_AFILT_PANID_CHANGED: Indicates that the pan id will be change.
+ *
+ * @IEEE802154_AFILT_PANC_CHANGED: Indicates that the address filter will
+ *      do frame address filtering as a pan coordinator.
  */
+enum ieee802154_hw_addr_filt_flags {
+        IEEE802154_AFILT_SADDR_CHANGED          = BIT(0),
+        IEEE802154_AFILT_IEEEADDR_CHANGED       = BIT(1),
+        IEEE802154_AFILT_PANID_CHANGED          = BIT(2),
+        IEEE802154_AFILT_PANC_CHANGED           = BIT(3),
+};
 
-/* indicates that the Short Address changed */
-#define IEEE802154_AFILT_SADDR_CHANGED          0x00000001
-/* indicates that the IEEE Address changed */
-#define IEEE802154_AFILT_IEEEADDR_CHANGED       0x00000002
-/* indicates that the PAN ID changed */
-#define IEEE802154_AFILT_PANID_CHANGED          0x00000004
-/* indicates that PAN Coordinator status changed */
-#define IEEE802154_AFILT_PANC_CHANGED           0x00000008
-
+/**
+ * struct ieee802154_hw_addr_filt - hardware address filtering settings
+ *
+ * @pan_id: pan_id which should be set to the hardware address filter.
+ *
+ * @short_addr: short_addr which should be set to the hardware address filter.
+ *
+ * @ieee_addr: extended address which should be set to the hardware address
+ *      filter.
+ *
+ * @pan_coord: boolean if hardware filtering should be operate as coordinator.
+ */
 struct ieee802154_hw_addr_filt {
-        __le16  pan_id;         /* Each independent PAN selects a unique
-                                 * identifier. This PAN id allows communication
-                                 * between devices within a network using short
-                                 * addresses and enables transmissions between
-                                 * devices across independent networks.
-                                 */
+        __le16  pan_id;
         __le16  short_addr;
         __le64  ieee_addr;
-        u8      pan_coord;
-};
-
-struct ieee802154_vif {
-        int type;
-
-        /* must be last */
-        u8 drv_priv[0] __aligned(sizeof(void *));
+        bool    pan_coord;
 };
 
+/**
+ * struct ieee802154_hw - ieee802154 hardware
+ *
+ * @extra_tx_headroom: headroom to reserve in each transmit skb for use by the
+ *      driver (e.g. for transmit headers.)
+ *
+ * @flags: hardware flags, see &enum ieee802154_hw_flags
+ *
+ * @parent: parent device of the hardware.
+ *
+ * @priv: pointer to private area that was allocated for driver use along with
+ *      this structure.
+ *
+ * @phy: This points to the &struct wpan_phy allocated for this 802.15.4 PHY.
+ */
 struct ieee802154_hw {
         /* filled by the driver */
         int     extra_tx_headroom;
         u32     flags;
         struct  device *parent;
+        void    *priv;
 
         /* filled by mac802154 core */
-        struct  ieee802154_hw_addr_filt hw_filt;
-        void    *priv;
         struct  wpan_phy *phy;
-        size_t vif_data_size;
 };
 
-/* Checksum is in hardware and is omitted from a packet
+/**
+ * enum ieee802154_hw_flags - hardware flags
  *
- * These following flags are used to indicate hardware capabilities to
+ * These flags are used to indicate hardware capabilities to
  * the stack. Generally, flags here should have their meaning
  * done in a way that the simplest hardware doesn't need setting
  * any particular flags. There are some exceptions to this rule,
  * however, so you are advised to review these flags carefully.
+ *
+ * @IEEE802154_HW_TX_OMIT_CKSUM: Indicates that xmitter will add FCS on it's
+ *      own.
+ *
+ * @IEEE802154_HW_LBT: Indicates that transceiver will support listen before
+ *      transmit.
+ *
+ * @IEEE802154_HW_CSMA_PARAMS: Indicates that transceiver will support csma
+ *      parameters (max_be, min_be, backoff exponents).
+ *
+ * @IEEE802154_HW_FRAME_RETRIES: Indicates that transceiver will support ARET
+ *      frame retries setting.
+ *
+ * @IEEE802154_HW_AFILT: Indicates that transceiver will support hardware
+ *      address filter setting.
+ *
+ * @IEEE802154_HW_PROMISCUOUS: Indicates that transceiver will support
+ *      promiscuous mode setting.
+ *
+ * @IEEE802154_HW_RX_OMIT_CKSUM: Indicates that receiver omits FCS.
+ *
+ * @IEEE802154_HW_RX_DROP_BAD_CKSUM: Indicates that receiver will not filter
+ *      frames with bad checksum.
  */
-
-/* Indicates that xmitter will add FCS on it's own. */
-#define IEEE802154_HW_TX_OMIT_CKSUM     0x00000001
-/* Indicates that receiver will autorespond with ACK frames. */
-#define IEEE802154_HW_AACK              0x00000002
-/* Indicates that transceiver will support transmit power setting. */
-#define IEEE802154_HW_TXPOWER           0x00000004
-/* Indicates that transceiver will support listen before transmit. */
-#define IEEE802154_HW_LBT               0x00000008
-/* Indicates that transceiver will support cca mode setting. */
-#define IEEE802154_HW_CCA_MODE          0x00000010
-/* Indicates that transceiver will support cca ed level setting. */
-#define IEEE802154_HW_CCA_ED_LEVEL      0x00000020
-/* Indicates that transceiver will support csma (max_be, min_be, csma retries)
- * settings. */
-#define IEEE802154_HW_CSMA_PARAMS       0x00000040
-/* Indicates that transceiver will support ARET frame retries setting. */
-#define IEEE802154_HW_FRAME_RETRIES     0x00000080
-/* Indicates that transceiver will support hardware address filter setting. */
-#define IEEE802154_HW_AFILT             0x00000100
-/* Indicates that transceiver will support promiscuous mode setting. */
-#define IEEE802154_HW_PROMISCUOUS       0x00000200
-/* Indicates that receiver omits FCS. */
-#define IEEE802154_HW_RX_OMIT_CKSUM     0x00000400
-/* Indicates that receiver will not filter frames with bad checksum. */
-#define IEEE802154_HW_RX_DROP_BAD_CKSUM 0x00000800
+enum ieee802154_hw_flags {
+        IEEE802154_HW_TX_OMIT_CKSUM     = BIT(0),
+        IEEE802154_HW_LBT               = BIT(1),
+        IEEE802154_HW_CSMA_PARAMS       = BIT(2),
+        IEEE802154_HW_FRAME_RETRIES     = BIT(3),
+        IEEE802154_HW_AFILT             = BIT(4),
+        IEEE802154_HW_PROMISCUOUS       = BIT(5),
+        IEEE802154_HW_RX_OMIT_CKSUM     = BIT(6),
+        IEEE802154_HW_RX_DROP_BAD_CKSUM = BIT(7),
+};
 
 /* Indicates that receiver omits FCS and xmitter will add FCS on it's own. */
 #define IEEE802154_HW_OMIT_CKSUM        (IEEE802154_HW_TX_OMIT_CKSUM | \
                                          IEEE802154_HW_RX_OMIT_CKSUM)
 
-/* This groups the most common CSMA support fields into one. */
-#define IEEE802154_HW_CSMA              (IEEE802154_HW_CCA_MODE | \
-                                         IEEE802154_HW_CCA_ED_LEVEL | \
-                                         IEEE802154_HW_CSMA_PARAMS)
-
-/* This groups the most common ARET support fields into one. */
-#define IEEE802154_HW_ARET              (IEEE802154_HW_CSMA | \
-                                         IEEE802154_HW_FRAME_RETRIES)
-
 /* struct ieee802154_ops - callbacks from mac802154 to the driver
  *
  * This structure contains various callbacks that the driver may
@@ -171,7 +194,7 @@ struct ieee802154_hw {
  *        Returns either zero, or negative errno.
  *
  * set_txpower:
- *        Set radio transmit power in dB. Called with pib_lock held.
+ *        Set radio transmit power in mBm. Called with pib_lock held.
  *        Returns either zero, or negative errno.
  *
  * set_lbt
@@ -184,7 +207,7 @@ struct ieee802154_hw {
  *        Returns either zero, or negative errno.
  *
  * set_cca_ed_level
- *        Sets the CCA energy detection threshold in dBm. Called with pib_lock
+ *        Sets the CCA energy detection threshold in mBm. Called with pib_lock
  *        held.
  *        Returns either zero, or negative errno.
  *
@@ -213,12 +236,11 @@ struct ieee802154_ops {
         int             (*set_hw_addr_filt)(struct ieee802154_hw *hw,
                                             struct ieee802154_hw_addr_filt *filt,
                                             unsigned long changed);
-        int             (*set_txpower)(struct ieee802154_hw *hw, s8 dbm);
+        int             (*set_txpower)(struct ieee802154_hw *hw, s32 mbm);
         int             (*set_lbt)(struct ieee802154_hw *hw, bool on);
         int             (*set_cca_mode)(struct ieee802154_hw *hw,
                                         const struct wpan_phy_cca *cca);
-        int             (*set_cca_ed_level)(struct ieee802154_hw *hw,
-                                            s32 level);
+        int             (*set_cca_ed_level)(struct ieee802154_hw *hw, s32 mbm);
         int             (*set_csma_params)(struct ieee802154_hw *hw,
                                            u8 min_be, u8 max_be, u8 retries);
         int             (*set_frame_retries)(struct ieee802154_hw *hw,
diff --git a/include/net/net_namespace.h b/include/net/net_namespace.h
index f733656404de..e951453e0a23 100644
--- a/include/net/net_namespace.h
+++ b/include/net/net_namespace.h
@@ -28,6 +28,8 @@
 #include <net/netns/xfrm.h>
 #include <net/netns/mpls.h>
 #include <linux/ns_common.h>
+#include <linux/idr.h>
+#include <linux/skbuff.h>
 
 struct user_namespace;
 struct proc_dir_entry;
@@ -58,6 +60,7 @@ struct net {
         struct list_head        exit_list;      /* Use only net_mutex */
 
         struct user_namespace   *user_ns;       /* Owning user namespace */
+        spinlock_t              nsid_lock;
         struct idr              netns_ids;
 
         struct ns_common        ns;
@@ -271,7 +274,9 @@ static inline struct net *read_pnet(const possible_net_t *pnet)
 #define __net_initconst __initconst
 #endif
 
+int peernet2id_alloc(struct net *net, struct net *peer);
 int peernet2id(struct net *net, struct net *peer);
+bool peernet_has_id(struct net *net, struct net *peer);
 struct net *get_net_ns_by_id(struct net *net, int id);
 
 struct pernet_operations {
diff --git a/include/net/netfilter/br_netfilter.h b/include/net/netfilter/br_netfilter.h
index 2aa6048a55c1..bab824bde92c 100644
--- a/include/net/netfilter/br_netfilter.h
+++ b/include/net/netfilter/br_netfilter.h
@@ -1,6 +1,66 @@
 #ifndef _BR_NETFILTER_H_
 #define _BR_NETFILTER_H_
 
+#include "../../../net/bridge/br_private.h"
+
+static inline struct nf_bridge_info *nf_bridge_alloc(struct sk_buff *skb)
+{
+        skb->nf_bridge = kzalloc(sizeof(struct nf_bridge_info), GFP_ATOMIC);
+
+        if (likely(skb->nf_bridge))
+                atomic_set(&(skb->nf_bridge->use), 1);
+
+        return skb->nf_bridge;
+}
+
+void nf_bridge_update_protocol(struct sk_buff *skb);
+
+static inline struct nf_bridge_info *
+nf_bridge_info_get(const struct sk_buff *skb)
+{
+        return skb->nf_bridge;
+}
+
+unsigned int nf_bridge_encap_header_len(const struct sk_buff *skb);
+
+static inline void nf_bridge_push_encap_header(struct sk_buff *skb)
+{
+        unsigned int len = nf_bridge_encap_header_len(skb);
+
+        skb_push(skb, len);
+        skb->network_header -= len;
+}
+
+int br_nf_pre_routing_finish_bridge(struct sock *sk, struct sk_buff *skb);
+
+static inline struct rtable *bridge_parent_rtable(const struct net_device *dev)
+{
+        struct net_bridge_port *port;
+
+        port = br_port_get_rcu(dev);
+        return port ? &port->br->fake_rtable : NULL;
+}
+
+struct net_device *setup_pre_routing(struct sk_buff *skb);
 void br_netfilter_enable(void);
 
+#if IS_ENABLED(CONFIG_IPV6)
+int br_validate_ipv6(struct sk_buff *skb);
+unsigned int br_nf_pre_routing_ipv6(const struct nf_hook_ops *ops,
+                                    struct sk_buff *skb,
+                                    const struct nf_hook_state *state);
+#else
+static inline int br_validate_ipv6(struct sk_buff *skb)
+{
+        return -1;
+}
+
+static inline unsigned int
+br_nf_pre_routing_ipv6(const struct nf_hook_ops *ops, struct sk_buff *skb,
+                       const struct nf_hook_state *state)
+{
+        return NF_DROP;
+}
+#endif
+
 #endif /* _BR_NETFILTER_H_ */
diff --git a/include/net/netfilter/nf_conntrack.h b/include/net/netfilter/nf_conntrack.h
index 095433b8a8b0..37cd3911d5c5 100644
--- a/include/net/netfilter/nf_conntrack.h
+++ b/include/net/netfilter/nf_conntrack.h
@@ -291,7 +291,7 @@ extern unsigned int nf_conntrack_max;
 extern unsigned int nf_conntrack_hash_rnd;
 void init_nf_conntrack_hash_rnd(void);
 
-void nf_conntrack_tmpl_insert(struct net *net, struct nf_conn *tmpl);
+struct nf_conn *nf_ct_tmpl_alloc(struct net *net, u16 zone, gfp_t flags);
 
 #define NF_CT_STAT_INC(net, count)        __this_cpu_inc((net)->ct.stat->count)
 #define NF_CT_STAT_INC_ATOMIC(net, count) this_cpu_inc((net)->ct.stat->count)
diff --git a/include/net/netfilter/nf_queue.h b/include/net/netfilter/nf_queue.h
index d81d584157e1..e8635854a55b 100644
--- a/include/net/netfilter/nf_queue.h
+++ b/include/net/netfilter/nf_queue.h
@@ -24,6 +24,8 @@ struct nf_queue_entry {
 struct nf_queue_handler {
         int                     (*outfn)(struct nf_queue_entry *entry,
                                          unsigned int queuenum);
+        void                    (*nf_hook_drop)(struct net *net,
+                                                struct nf_hook_ops *ops);
 };
 
 void nf_register_queue_handler(const struct nf_queue_handler *qh);
diff --git a/include/net/netfilter/nf_tables.h b/include/net/netfilter/nf_tables.h
index e6bcf55dcf20..2a246680a6c3 100644
--- a/include/net/netfilter/nf_tables.h
+++ b/include/net/netfilter/nf_tables.h
@@ -781,6 +781,7 @@ struct nft_stats {
 };
 
 #define NFT_HOOK_OPS_MAX                2
+#define NFT_BASECHAIN_DISABLED          (1 << 0)
 
 /**
  *      struct nft_base_chain - nf_tables base chain
@@ -791,14 +792,17 @@ struct nft_stats {
  *      @policy: default policy
  *      @stats: per-cpu chain stats
  *      @chain: the chain
+ *      @dev_name: device name that this base chain is attached to (if any)
  */
 struct nft_base_chain {
         struct nf_hook_ops              ops[NFT_HOOK_OPS_MAX];
         possible_net_t                  pnet;
         const struct nf_chain_type      *type;
         u8                              policy;
+        u8                              flags;
         struct nft_stats __percpu       *stats;
         struct nft_chain                chain;
+        char                            dev_name[IFNAMSIZ];
 };
 
 static inline struct nft_base_chain *nft_base_chain(const struct nft_chain *chain)
@@ -806,6 +810,11 @@ static inline struct nft_base_chain *nft_base_chain(const struct nft_chain *chai
         return container_of(chain, struct nft_base_chain, chain);
 }
 
+int nft_register_basechain(struct nft_base_chain *basechain,
+                           unsigned int hook_nops);
+void nft_unregister_basechain(struct nft_base_chain *basechain,
+                              unsigned int hook_nops);
+
 unsigned int nft_do_chain(struct nft_pktinfo *pkt,
                           const struct nf_hook_ops *ops);
 
@@ -830,6 +839,10 @@ struct nft_table {
         char                            name[NFT_TABLE_MAXNAMELEN];
 };
 
+enum nft_af_flags {
+        NFT_AF_NEEDS_DEV        = (1 << 0),
+};
+
 /**
  *      struct nft_af_info - nf_tables address family info
  *
@@ -838,6 +851,7 @@ struct nft_table {
  *      @nhooks: number of hooks in this family
  *      @owner: module owner
  *      @tables: used internally
+ *      @flags: family flags
  *      @nops: number of hook ops in this family
  *      @hook_ops_init: initialization function for chain hook ops
  *      @hooks: hookfn overrides for packet validation
@@ -848,6 +862,7 @@ struct nft_af_info {
         unsigned int                    nhooks;
         struct module                   *owner;
         struct list_head                tables;
+        u32                             flags;
         unsigned int                    nops;
         void                            (*hook_ops_init)(struct nf_hook_ops *,
                                                          unsigned int);
diff --git a/include/net/netns/conntrack.h b/include/net/netns/conntrack.h
index 29d6a94db54d..723b61c82b3f 100644
--- a/include/net/netns/conntrack.h
+++ b/include/net/netns/conntrack.h
@@ -68,7 +68,6 @@ struct ct_pcpu {
         spinlock_t              lock;
         struct hlist_nulls_head unconfirmed;
         struct hlist_nulls_head dying;
-        struct hlist_nulls_head tmpl;
 };
 
 struct netns_ct {
diff --git a/include/net/netns/ipv4.h b/include/net/netns/ipv4.h
index 614a49be68a9..c68926b4899c 100644
--- a/include/net/netns/ipv4.h
+++ b/include/net/netns/ipv4.h
@@ -19,6 +19,7 @@ struct sock;
 struct local_ports {
         seqlock_t       lock;
         int             range[2];
+        bool            warned;
 };
 
 struct ping_group_range {
@@ -77,6 +78,8 @@ struct netns_ipv4 {
         struct local_ports ip_local_ports;
 
         int sysctl_tcp_ecn;
+        int sysctl_tcp_ecn_fallback;
+
         int sysctl_ip_no_pmtu_disc;
         int sysctl_ip_fwd_use_pmtu;
         int sysctl_ip_nonlocal_bind;
diff --git a/include/net/netns/ipv6.h b/include/net/netns/ipv6.h
index d2527bf81142..8d93544a2d2b 100644
--- a/include/net/netns/ipv6.h
+++ b/include/net/netns/ipv6.h
@@ -34,6 +34,7 @@ struct netns_sysctl_ipv6 {
         int fwmark_reflect;
         int idgen_retries;
         int idgen_delay;
+        int flowlabel_state_ranges;
 };
 
 struct netns_ipv6 {
diff --git a/include/net/netns/netfilter.h b/include/net/netns/netfilter.h
index 88740024ccf3..532e4ba64f49 100644
--- a/include/net/netns/netfilter.h
+++ b/include/net/netns/netfilter.h
@@ -1,9 +1,9 @@
 #ifndef __NETNS_NETFILTER_H
 #define __NETNS_NETFILTER_H
 
-#include <linux/proc_fs.h>
-#include <linux/netfilter.h>
+#include <linux/netfilter_defs.h>
 
+struct proc_dir_entry;
 struct nf_logger;
 
 struct netns_nf {
diff --git a/include/net/netns/nftables.h b/include/net/netns/nftables.h
index eee608b12cc9..c80781146019 100644
--- a/include/net/netns/nftables.h
+++ b/include/net/netns/nftables.h
@@ -13,6 +13,7 @@ struct netns_nftables {
         struct nft_af_info      *inet;
         struct nft_af_info      *arp;
         struct nft_af_info      *bridge;
+        struct nft_af_info      *netdev;
         unsigned int            base_seq;
         u8                      gencursor;
 };
diff --git a/include/net/netns/sctp.h b/include/net/netns/sctp.h
index 3573a81815ad..8ba379f9e467 100644
--- a/include/net/netns/sctp.h
+++ b/include/net/netns/sctp.h
@@ -31,6 +31,7 @@ struct netns_sctp {
         struct list_head addr_waitq;
         struct timer_list addr_wq_timer;
         struct list_head auto_asconf_splist;
+        /* Lock that protects both addr_waitq and auto_asconf_splist */
         spinlock_t addr_wq_lock;
 
         /* Lock that protects the local_addr_list writers */
diff --git a/include/net/netns/x_tables.h b/include/net/netns/x_tables.h
index 4d6597ad6067..c8a7681efa6a 100644
--- a/include/net/netns/x_tables.h
+++ b/include/net/netns/x_tables.h
@@ -2,7 +2,7 @@
 #define __NETNS_X_TABLES_H
 
 #include <linux/list.h>
-#include <linux/netfilter.h>
+#include <linux/netfilter_defs.h>
 
 struct ebt_table;
 
diff --git a/include/net/nfc/hci.h b/include/net/nfc/hci.h
index 020a814bc8ed..316694dafa5b 100644
--- a/include/net/nfc/hci.h
+++ b/include/net/nfc/hci.h
@@ -179,6 +179,13 @@ void nfc_hci_unregister_device(struct nfc_hci_dev *hdev);
 void nfc_hci_set_clientdata(struct nfc_hci_dev *hdev, void *clientdata);
 void *nfc_hci_get_clientdata(struct nfc_hci_dev *hdev);
 
+static inline int nfc_hci_set_vendor_cmds(struct nfc_hci_dev *hdev,
+                                          struct nfc_vendor_cmd *cmds,
+                                          int n_cmds)
+{
+        return nfc_set_vendor_cmds(hdev->ndev, cmds, n_cmds);
+}
+
 void nfc_hci_driver_failure(struct nfc_hci_dev *hdev, int err);
 
 int nfc_hci_result_to_errno(u8 result);
diff --git a/include/net/nfc/nci.h b/include/net/nfc/nci.h
index a2f2f3d3196d..75d2e1880059 100644
--- a/include/net/nfc/nci.h
+++ b/include/net/nfc/nci.h
@@ -35,6 +35,7 @@
 #define NCI_MAX_NUM_RF_CONFIGS                                  10
 #define NCI_MAX_NUM_CONN                                        10
 #define NCI_MAX_PARAM_LEN                                       251
+#define NCI_MAX_PACKET_SIZE                                     258
 
 /* NCI Status Codes */
 #define NCI_STATUS_OK                                           0x00
diff --git a/include/net/nfc/nci_core.h b/include/net/nfc/nci_core.h
index d4dcc7199fd7..01fc8c531115 100644
--- a/include/net/nfc/nci_core.h
+++ b/include/net/nfc/nci_core.h
@@ -31,6 +31,7 @@
 
 #include <linux/interrupt.h>
 #include <linux/skbuff.h>
+#include <linux/tty.h>
 
 #include <net/nfc/nfc.h>
 #include <net/nfc/nci.h>
@@ -66,7 +67,14 @@ enum nci_state {
 
 struct nci_dev;
 
+struct nci_prop_ops {
+        __u16 opcode;
+        int (*rsp)(struct nci_dev *dev, struct sk_buff *skb);
+        int (*ntf)(struct nci_dev *dev, struct sk_buff *skb);
+};
+
 struct nci_ops {
+        int   (*init)(struct nci_dev *ndev);
         int   (*open)(struct nci_dev *ndev);
         int   (*close)(struct nci_dev *ndev);
         int   (*send)(struct nci_dev *ndev, struct sk_buff *skb);
@@ -84,12 +92,16 @@ struct nci_ops {
                                     struct sk_buff *skb);
         void  (*hci_cmd_received)(struct nci_dev *ndev, u8 pipe, u8 cmd,
                                   struct sk_buff *skb);
+
+        struct nci_prop_ops *prop_ops;
+        size_t n_prop_ops;
 };
 
 #define NCI_MAX_SUPPORTED_RF_INTERFACES         4
 #define NCI_MAX_DISCOVERED_TARGETS              10
 #define NCI_MAX_NUM_NFCEE   255
 #define NCI_MAX_CONN_ID         7
+#define NCI_MAX_PROPRIETARY_CMD 64
 
 struct nci_conn_info {
         struct list_head list;
@@ -264,6 +276,8 @@ int nci_request(struct nci_dev *ndev,
                 void (*req)(struct nci_dev *ndev,
                             unsigned long opt),
                 unsigned long opt, __u32 timeout);
+int nci_prop_cmd(struct nci_dev *ndev, __u8 oid, size_t len, __u8 *payload);
+
 int nci_recv_frame(struct nci_dev *ndev, struct sk_buff *skb);
 int nci_set_config(struct nci_dev *ndev, __u8 id, size_t len, __u8 *val);
 
@@ -318,8 +332,19 @@ static inline void *nci_get_drvdata(struct nci_dev *ndev)
         return ndev->driver_data;
 }
 
+static inline int nci_set_vendor_cmds(struct nci_dev *ndev,
+                                      struct nfc_vendor_cmd *cmds,
+                                      int n_cmds)
+{
+        return nfc_set_vendor_cmds(ndev->nfc_dev, cmds, n_cmds);
+}
+
 void nci_rsp_packet(struct nci_dev *ndev, struct sk_buff *skb);
 void nci_ntf_packet(struct nci_dev *ndev, struct sk_buff *skb);
+int nci_prop_rsp_packet(struct nci_dev *ndev, __u16 opcode,
+                        struct sk_buff *skb);
+int nci_prop_ntf_packet(struct nci_dev *ndev, __u16 opcode,
+                        struct sk_buff *skb);
 void nci_rx_data_packet(struct nci_dev *ndev, struct sk_buff *skb);
 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);
@@ -367,4 +392,50 @@ int nci_spi_send(struct nci_spi *nspi,
                  struct sk_buff *skb);
 struct sk_buff *nci_spi_read(struct nci_spi *nspi);
 
+/* ----- NCI UART ---- */
+
+/* Ioctl */
+#define NCIUARTSETDRIVER        _IOW('U', 0, char *)
+
+enum nci_uart_driver {
+        NCI_UART_DRIVER_MARVELL = 0,
+        NCI_UART_DRIVER_MAX
+};
+
+struct nci_uart;
+
+struct nci_uart_ops {
+        int (*open)(struct nci_uart *nci_uart);
+        void (*close)(struct nci_uart *nci_uart);
+        int (*recv)(struct nci_uart *nci_uart, struct sk_buff *skb);
+        int (*recv_buf)(struct nci_uart *nci_uart, const u8 *data, char *flags,
+                        int count);
+        int (*send)(struct nci_uart *nci_uart, struct sk_buff *skb);
+        void (*tx_start)(struct nci_uart *nci_uart);
+        void (*tx_done)(struct nci_uart *nci_uart);
+};
+
+struct nci_uart {
+        struct module           *owner;
+        struct nci_uart_ops     ops;
+        const char              *name;
+        enum nci_uart_driver    driver;
+
+        /* Dynamic data */
+        struct nci_dev          *ndev;
+        spinlock_t              rx_lock;
+        struct work_struct      write_work;
+        struct tty_struct       *tty;
+        unsigned long           tx_state;
+        struct sk_buff_head     tx_q;
+        struct sk_buff          *tx_skb;
+        struct sk_buff          *rx_skb;
+        int                     rx_packet_len;
+        void                    *drv_data;
+};
+
+int nci_uart_register(struct nci_uart *nu);
+void nci_uart_unregister(struct nci_uart *nu);
+void nci_uart_set_config(struct nci_uart *nu, int baudrate, int flow_ctrl);
+
 #endif /* __NCI_CORE_H */
diff --git a/include/net/nfc/nfc.h b/include/net/nfc/nfc.h
index 7ac029c07546..f9e58ae45f9c 100644
--- a/include/net/nfc/nfc.h
+++ b/include/net/nfc/nfc.h
@@ -165,6 +165,12 @@ struct nfc_genl_data {
         struct mutex genl_data_mutex;
 };
 
+struct nfc_vendor_cmd {
+        __u32 vendor_id;
+        __u32 subcmd;
+        int (*doit)(struct nfc_dev *dev, void *data, size_t data_len);
+};
+
 struct nfc_dev {
         int idx;
         u32 target_next_idx;
@@ -193,6 +199,9 @@ struct nfc_dev {
 
         struct rfkill *rfkill;
 
+        struct nfc_vendor_cmd *vendor_cmds;
+        int n_vendor_cmds;
+
         struct nfc_ops *ops;
 };
 #define to_nfc_dev(_dev) container_of(_dev, struct nfc_dev, dev)
@@ -296,4 +305,17 @@ struct nfc_se *nfc_find_se(struct nfc_dev *dev, u32 se_idx);
 void nfc_send_to_raw_sock(struct nfc_dev *dev, struct sk_buff *skb,
                           u8 payload_type, u8 direction);
 
+static inline int nfc_set_vendor_cmds(struct nfc_dev *dev,
+                                      struct nfc_vendor_cmd *cmds,
+                                      int n_cmds)
+{
+        if (dev->vendor_cmds || dev->n_vendor_cmds)
+                return -EINVAL;
+
+        dev->vendor_cmds = cmds;
+        dev->n_vendor_cmds = n_cmds;
+
+        return 0;
+}
+
 #endif /* __NET_NFC_H */
diff --git a/include/net/nl802154.h b/include/net/nl802154.h
index f8b5bc997959..b0ab530d28cd 100644
--- a/include/net/nl802154.h
+++ b/include/net/nl802154.h
@@ -100,6 +100,10 @@ enum nl802154_attrs {
 
         NL802154_ATTR_EXTENDED_ADDR,
 
+        NL802154_ATTR_WPAN_PHY_CAPS,
+
+        NL802154_ATTR_SUPPORTED_COMMANDS,
+
         /* add attributes here, update the policy in nl802154.c */
 
         __NL802154_ATTR_AFTER_LAST,
@@ -120,6 +124,61 @@ enum nl802154_iftype {
 };
 
 /**
+ * enum nl802154_wpan_phy_capability_attr - wpan phy capability attributes
+ *
+ * @__NL802154_CAP_ATTR_INVALID: attribute number 0 is reserved
+ * @NL802154_CAP_ATTR_CHANNELS: a nested attribute for nl802154_channel_attr
+ * @NL802154_CAP_ATTR_TX_POWERS: a nested attribute for
+ *      nl802154_wpan_phy_tx_power
+ * @NL802154_CAP_ATTR_MIN_CCA_ED_LEVEL: minimum value for cca_ed_level
+ * @NL802154_CAP_ATTR_MAX_CCA_ED_LEVEL: maxmimum value for cca_ed_level
+ * @NL802154_CAP_ATTR_CCA_MODES: nl802154_cca_modes flags
+ * @NL802154_CAP_ATTR_CCA_OPTS: nl802154_cca_opts flags
+ * @NL802154_CAP_ATTR_MIN_MINBE: minimum of minbe value
+ * @NL802154_CAP_ATTR_MAX_MINBE: maximum of minbe value
+ * @NL802154_CAP_ATTR_MIN_MAXBE: minimum of maxbe value
+ * @NL802154_CAP_ATTR_MAX_MINBE: maximum of maxbe value
+ * @NL802154_CAP_ATTR_MIN_CSMA_BACKOFFS: minimum of csma backoff value
+ * @NL802154_CAP_ATTR_MAX_CSMA_BACKOFFS: maximum of csma backoffs value
+ * @NL802154_CAP_ATTR_MIN_FRAME_RETRIES: minimum of frame retries value
+ * @NL802154_CAP_ATTR_MAX_FRAME_RETRIES: maximum of frame retries value
+ * @NL802154_CAP_ATTR_IFTYPES: nl802154_iftype flags
+ * @NL802154_CAP_ATTR_LBT: nl802154_supported_bool_states flags
+ * @NL802154_CAP_ATTR_MAX: highest cap attribute currently defined
+ * @__NL802154_CAP_ATTR_AFTER_LAST: internal use
+ */
+enum nl802154_wpan_phy_capability_attr {
+        __NL802154_CAP_ATTR_INVALID,
+
+        NL802154_CAP_ATTR_IFTYPES,
+
+        NL802154_CAP_ATTR_CHANNELS,
+        NL802154_CAP_ATTR_TX_POWERS,
+
+        NL802154_CAP_ATTR_CCA_ED_LEVELS,
+        NL802154_CAP_ATTR_CCA_MODES,
+        NL802154_CAP_ATTR_CCA_OPTS,
+
+        NL802154_CAP_ATTR_MIN_MINBE,
+        NL802154_CAP_ATTR_MAX_MINBE,
+
+        NL802154_CAP_ATTR_MIN_MAXBE,
+        NL802154_CAP_ATTR_MAX_MAXBE,
+
+        NL802154_CAP_ATTR_MIN_CSMA_BACKOFFS,
+        NL802154_CAP_ATTR_MAX_CSMA_BACKOFFS,
+
+        NL802154_CAP_ATTR_MIN_FRAME_RETRIES,
+        NL802154_CAP_ATTR_MAX_FRAME_RETRIES,
+
+        NL802154_CAP_ATTR_LBT,
+
+        /* keep last */
+        __NL802154_CAP_ATTR_AFTER_LAST,
+        NL802154_CAP_ATTR_MAX = __NL802154_CAP_ATTR_AFTER_LAST - 1
+};
+
+/**
  * enum nl802154_cca_modes - cca modes
  *
  * @__NL802154_CCA_INVALID: cca mode number 0 is reserved
@@ -128,7 +187,7 @@ enum nl802154_iftype {
  * @NL802154_CCA_ENERGY_CARRIER: Carrier sense with energy above threshold
  * @NL802154_CCA_ALOHA: CCA shall always report an idle medium
  * @NL802154_CCA_UWB_SHR: UWB preamble sense based on the SHR of a frame
- * @NL802154_CCA_UWB_MULTIPEXED: UWB preamble sense based on the packet with
+ * @NL802154_CCA_UWB_MULTIPLEXED: UWB preamble sense based on the packet with
  *      the multiplexed preamble
  * @__NL802154_CCA_ATTR_AFTER_LAST: Internal
  * @NL802154_CCA_ATTR_MAX: Maximum CCA attribute number
@@ -140,7 +199,7 @@ enum nl802154_cca_modes {
         NL802154_CCA_ENERGY_CARRIER,
         NL802154_CCA_ALOHA,
         NL802154_CCA_UWB_SHR,
-        NL802154_CCA_UWB_MULTIPEXED,
+        NL802154_CCA_UWB_MULTIPLEXED,
 
         /* keep last */
         __NL802154_CCA_ATTR_AFTER_LAST,
@@ -162,4 +221,26 @@ enum nl802154_cca_opts {
         NL802154_CCA_OPT_ATTR_MAX = __NL802154_CCA_OPT_ATTR_AFTER_LAST - 1
 };
 
+/**
+ * enum nl802154_supported_bool_states - bool states for bool capability entry
+ *
+ * @NL802154_SUPPORTED_BOOL_FALSE: indicates to set false
+ * @NL802154_SUPPORTED_BOOL_TRUE: indicates to set true
+ * @__NL802154_SUPPORTED_BOOL_INVALD: reserved
+ * @NL802154_SUPPORTED_BOOL_BOTH: indicates to set true and false
+ * @__NL802154_SUPPORTED_BOOL_AFTER_LAST: Internal
+ * @NL802154_SUPPORTED_BOOL_MAX: highest value for bool states
+ */
+enum nl802154_supported_bool_states {
+        NL802154_SUPPORTED_BOOL_FALSE,
+        NL802154_SUPPORTED_BOOL_TRUE,
+        /* to handle them in a mask */
+        __NL802154_SUPPORTED_BOOL_INVALD,
+        NL802154_SUPPORTED_BOOL_BOTH,
+
+        /* keep last */
+        __NL802154_SUPPORTED_BOOL_AFTER_LAST,
+        NL802154_SUPPORTED_BOOL_MAX = __NL802154_SUPPORTED_BOOL_AFTER_LAST - 1
+};
+
 #endif /* __NL802154_H */
diff --git a/include/net/request_sock.h b/include/net/request_sock.h
index 9f4265ce8892..87935cad2f7b 100644
--- a/include/net/request_sock.h
+++ b/include/net/request_sock.h
@@ -64,6 +64,7 @@ struct request_sock {
         struct timer_list               rsk_timer;
         const struct request_sock_ops   *rsk_ops;
         struct sock                     *sk;
+        u32                             *saved_syn;
         u32                             secid;
         u32                             peer_secid;
 };
@@ -77,7 +78,7 @@ reqsk_alloc(const struct request_sock_ops *ops, struct sock *sk_listener)
                 req->rsk_ops = ops;
                 sock_hold(sk_listener);
                 req->rsk_listener = sk_listener;
-
+                req->saved_syn = NULL;
                 /* Following is temporary. It is coupled with debugging
                  * helpers in reqsk_put() & reqsk_free()
                  */
@@ -104,6 +105,7 @@ static inline void reqsk_free(struct request_sock *req)
         req->rsk_ops->destructor(req);
         if (req->rsk_listener)
                 sock_put(req->rsk_listener);
+        kfree(req->saved_syn);
         kmem_cache_free(req->rsk_ops->slab, req);
 }
 
diff --git a/include/net/sch_generic.h b/include/net/sch_generic.h
index 6d778efcfdfd..2738f6f87908 100644
--- a/include/net/sch_generic.h
+++ b/include/net/sch_generic.h
@@ -501,12 +501,6 @@ static inline int qdisc_enqueue(struct sk_buff *skb, struct Qdisc *sch)
         return sch->enqueue(skb, sch);
 }
 
-static inline int qdisc_enqueue_root(struct sk_buff *skb, struct Qdisc *sch)
-{
-        qdisc_skb_cb(skb)->pkt_len = skb->len;
-        return qdisc_enqueue(skb, sch) & NET_XMIT_MASK;
-}
-
 static inline bool qdisc_is_percpu_stats(const struct Qdisc *q)
 {
         return q->flags & TCQ_F_CPUSTATS;
@@ -745,23 +739,6 @@ static inline u32 qdisc_l2t(struct qdisc_rate_table* rtab, unsigned int pktlen)
         return rtab->data[slot];
 }
 
-#ifdef CONFIG_NET_CLS_ACT
-static inline struct sk_buff *skb_act_clone(struct sk_buff *skb, gfp_t gfp_mask,
-                                            int action)
-{
-        struct sk_buff *n;
-
-        n = skb_clone(skb, gfp_mask);
-
-        if (n) {
-                n->tc_verd = SET_TC_VERD(n->tc_verd, 0);
-                n->tc_verd = CLR_TC_OK2MUNGE(n->tc_verd);
-                n->tc_verd = CLR_TC_MUNGED(n->tc_verd);
-        }
-        return n;
-}
-#endif
-
 struct psched_ratecfg {
         u64     rate_bytes_ps; /* bytes per second */
         u32     mult;
diff --git a/include/net/sctp/structs.h b/include/net/sctp/structs.h
index 2bb2fcf5b11f..495c87e367b3 100644
--- a/include/net/sctp/structs.h
+++ b/include/net/sctp/structs.h
@@ -223,6 +223,10 @@ struct sctp_sock {
         atomic_t pd_mode;
         /* Receive to here while partial delivery is in effect. */
         struct sk_buff_head pd_lobby;
+
+        /* These must be the last fields, as they will skipped on copies,
+         * like on accept and peeloff operations
+         */
         struct list_head auto_asconf_list;
         int do_auto_asconf;
 };
diff --git a/include/net/sock.h b/include/net/sock.h
index 3a4898ec8c67..f21f0708ec59 100644
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@ -184,6 +184,7 @@ struct sock_common {
         unsigned char           skc_reuse:4;
         unsigned char           skc_reuseport:1;
         unsigned char           skc_ipv6only:1;
+        unsigned char           skc_net_refcnt:1;
         int                     skc_bound_dev_if;
         union {
                 struct hlist_node       skc_bind_node;
@@ -276,7 +277,6 @@ struct cg_proto;
   *     @sk_incoming_cpu: record cpu processing incoming packets
   *     @sk_txhash: computed flow hash for use on transmit
   *     @sk_filter: socket filtering instructions
-  *     @sk_protinfo: private area, net family specific, when not using slab
   *     @sk_timer: sock cleanup timer
   *     @sk_stamp: time stamp of last packet received
   *     @sk_tsflags: SO_TIMESTAMPING socket options
@@ -323,6 +323,7 @@ struct sock {
 #define sk_reuse                __sk_common.skc_reuse
 #define sk_reuseport            __sk_common.skc_reuseport
 #define sk_ipv6only             __sk_common.skc_ipv6only
+#define sk_net_refcnt           __sk_common.skc_net_refcnt
 #define sk_bound_dev_if         __sk_common.skc_bound_dev_if
 #define sk_bind_node            __sk_common.skc_bind_node
 #define sk_prot                 __sk_common.skc_prot
@@ -414,7 +415,6 @@ struct sock {
         const struct cred       *sk_peer_cred;
         long                    sk_rcvtimeo;
         long                    sk_sndtimeo;
-        void                    *sk_protinfo;
         struct timer_list       sk_timer;
         ktime_t                 sk_stamp;
         u16                     sk_tsflags;
@@ -902,7 +902,7 @@ void sk_stream_kill_queues(struct sock *sk);
 void sk_set_memalloc(struct sock *sk);
 void sk_clear_memalloc(struct sock *sk);
 
-int sk_wait_data(struct sock *sk, long *timeo);
+int sk_wait_data(struct sock *sk, long *timeo, const struct sk_buff *skb);
 
 struct request_sock_ops;
 struct timewait_sock_ops;
@@ -924,7 +924,6 @@ static inline void sk_prot_clear_nulls(struct sock *sk, int size)
 
 /* Networking protocol blocks we attach to sockets.
  * socket layer -> transport layer interface
- * transport -> network interface is defined by struct inet_proto
  */
 struct proto {
         void                    (*close)(struct sock *sk,
@@ -1366,7 +1365,7 @@ static inline struct inode *SOCK_INODE(struct socket *socket)
  * Functions for memory accounting
  */
 int __sk_mem_schedule(struct sock *sk, int size, int kind);
-void __sk_mem_reclaim(struct sock *sk);
+void __sk_mem_reclaim(struct sock *sk, int amount);
 
 #define SK_MEM_QUANTUM ((int)PAGE_SIZE)
 #define SK_MEM_QUANTUM_SHIFT ilog2(SK_MEM_QUANTUM)
@@ -1407,7 +1406,7 @@ static inline void sk_mem_reclaim(struct sock *sk)
         if (!sk_has_account(sk))
                 return;
         if (sk->sk_forward_alloc >= SK_MEM_QUANTUM)
-                __sk_mem_reclaim(sk);
+                __sk_mem_reclaim(sk, sk->sk_forward_alloc);
 }
 
 static inline void sk_mem_reclaim_partial(struct sock *sk)
@@ -1415,7 +1414,7 @@ static inline void sk_mem_reclaim_partial(struct sock *sk)
         if (!sk_has_account(sk))
                 return;
         if (sk->sk_forward_alloc > SK_MEM_QUANTUM)
-                __sk_mem_reclaim(sk);
+                __sk_mem_reclaim(sk, sk->sk_forward_alloc - 1);
 }
 
 static inline void sk_mem_charge(struct sock *sk, int size)
@@ -1514,9 +1513,9 @@ static inline void unlock_sock_fast(struct sock *sk, bool slow)
 
 
 struct sock *sk_alloc(struct net *net, int family, gfp_t priority,
-                      struct proto *prot);
+                      struct proto *prot, int kern);
 void sk_free(struct sock *sk);
-void sk_release_kernel(struct sock *sk);
+void sk_destruct(struct sock *sk);
 struct sock *sk_clone_lock(const struct sock *sk, const gfp_t priority);
 
 struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force,
@@ -2024,7 +2023,8 @@ static inline void sk_stream_moderate_sndbuf(struct sock *sk)
         }
 }
 
-struct sk_buff *sk_stream_alloc_skb(struct sock *sk, int size, gfp_t gfp);
+struct sk_buff *sk_stream_alloc_skb(struct sock *sk, int size, gfp_t gfp,
+                                    bool force_schedule);
 
 /**
  * sk_page_frag - return an appropriate page_frag
@@ -2192,22 +2192,6 @@ void sock_net_set(struct sock *sk, struct net *net)
         write_pnet(&sk->sk_net, net);
 }
 
-/*
- * Kernel sockets, f.e. rtnl or icmp_socket, are a part of a namespace.
- * They should not hold a reference to a namespace in order to allow
- * to stop it.
- * Sockets after sk_change_net should be released using sk_release_kernel
- */
-static inline void sk_change_net(struct sock *sk, struct net *net)
-{
-        struct net *current_net = sock_net(sk);
-
-        if (!net_eq(current_net, net)) {
-                put_net(current_net);
-                sock_net_set(sk, net);
-        }
-}
-
 static inline struct sock *skb_steal_sock(struct sk_buff *skb)
 {
         if (skb->sk) {
diff --git a/include/net/switchdev.h b/include/net/switchdev.h
index d2e69ee3019a..d5671f118bfc 100644
--- a/include/net/switchdev.h
+++ b/include/net/switchdev.h
@@ -14,154 +14,261 @@
 #include <linux/netdevice.h>
 #include <linux/notifier.h>
 
+#define SWITCHDEV_F_NO_RECURSE          BIT(0)
+
+enum switchdev_trans {
+        SWITCHDEV_TRANS_NONE,
+        SWITCHDEV_TRANS_PREPARE,
+        SWITCHDEV_TRANS_ABORT,
+        SWITCHDEV_TRANS_COMMIT,
+};
+
+enum switchdev_attr_id {
+        SWITCHDEV_ATTR_UNDEFINED,
+        SWITCHDEV_ATTR_PORT_PARENT_ID,
+        SWITCHDEV_ATTR_PORT_STP_STATE,
+        SWITCHDEV_ATTR_PORT_BRIDGE_FLAGS,
+};
+
+struct switchdev_attr {
+        enum switchdev_attr_id id;
+        enum switchdev_trans trans;
+        u32 flags;
+        union {
+                struct netdev_phys_item_id ppid;        /* PORT_PARENT_ID */
+                u8 stp_state;                           /* PORT_STP_STATE */
+                unsigned long brport_flags;             /* PORT_BRIDGE_FLAGS */
+        } u;
+};
+
 struct fib_info;
 
+enum switchdev_obj_id {
+        SWITCHDEV_OBJ_UNDEFINED,
+        SWITCHDEV_OBJ_PORT_VLAN,
+        SWITCHDEV_OBJ_IPV4_FIB,
+        SWITCHDEV_OBJ_PORT_FDB,
+};
+
+struct switchdev_obj {
+        enum switchdev_obj_id id;
+        enum switchdev_trans trans;
+        int (*cb)(struct net_device *dev, struct switchdev_obj *obj);
+        union {
+                struct switchdev_obj_vlan {             /* PORT_VLAN */
+                        u16 flags;
+                        u16 vid_begin;
+                        u16 vid_end;
+                } vlan;
+                struct switchdev_obj_ipv4_fib {         /* IPV4_FIB */
+                        u32 dst;
+                        int dst_len;
+                        struct fib_info *fi;
+                        u8 tos;
+                        u8 type;
+                        u32 nlflags;
+                        u32 tb_id;
+                } ipv4_fib;
+                struct switchdev_obj_fdb {              /* PORT_FDB */
+                        const unsigned char *addr;
+                        u16 vid;
+                } fdb;
+        } u;
+};
+
 /**
  * struct switchdev_ops - switchdev operations
  *
- * @swdev_parent_id_get: Called to get an ID of the switch chip this port
- *   is part of.  If driver implements this, it indicates that it
- *   represents a port of a switch chip.
+ * @switchdev_port_attr_get: Get a port attribute (see switchdev_attr).
+ *
+ * @switchdev_port_attr_set: Set a port attribute (see switchdev_attr).
  *
- * @swdev_port_stp_update: Called to notify switch device port of bridge
- *   port STP state change.
+ * @switchdev_port_obj_add: Add an object to port (see switchdev_obj).
  *
- * @swdev_fib_ipv4_add: Called to add/modify IPv4 route to switch device.
+ * @switchdev_port_obj_del: Delete an object from port (see switchdev_obj).
  *
- * @swdev_fib_ipv4_del: Called to delete IPv4 route from switch device.
+ * @switchdev_port_obj_dump: Dump port objects (see switchdev_obj).
  */
-struct swdev_ops {
-        int     (*swdev_parent_id_get)(struct net_device *dev,
-                                       struct netdev_phys_item_id *psid);
-        int     (*swdev_port_stp_update)(struct net_device *dev, u8 state);
-        int     (*swdev_fib_ipv4_add)(struct net_device *dev, __be32 dst,
-                                      int dst_len, struct fib_info *fi,
-                                      u8 tos, u8 type, u32 nlflags,
-                                      u32 tb_id);
-        int     (*swdev_fib_ipv4_del)(struct net_device *dev, __be32 dst,
-                                      int dst_len, struct fib_info *fi,
-                                      u8 tos, u8 type, u32 tb_id);
+struct switchdev_ops {
+        int     (*switchdev_port_attr_get)(struct net_device *dev,
+                                           struct switchdev_attr *attr);
+        int     (*switchdev_port_attr_set)(struct net_device *dev,
+                                           struct switchdev_attr *attr);
+        int     (*switchdev_port_obj_add)(struct net_device *dev,
+                                          struct switchdev_obj *obj);
+        int     (*switchdev_port_obj_del)(struct net_device *dev,
+                                          struct switchdev_obj *obj);
+        int     (*switchdev_port_obj_dump)(struct net_device *dev,
+                                          struct switchdev_obj *obj);
 };
 
-enum netdev_switch_notifier_type {
-        NETDEV_SWITCH_FDB_ADD = 1,
-        NETDEV_SWITCH_FDB_DEL,
+enum switchdev_notifier_type {
+        SWITCHDEV_FDB_ADD = 1,
+        SWITCHDEV_FDB_DEL,
 };
 
-struct netdev_switch_notifier_info {
+struct switchdev_notifier_info {
         struct net_device *dev;
 };
 
-struct netdev_switch_notifier_fdb_info {
-        struct netdev_switch_notifier_info info; /* must be first */
+struct switchdev_notifier_fdb_info {
+        struct switchdev_notifier_info info; /* must be first */
         const unsigned char *addr;
         u16 vid;
 };
 
 static inline struct net_device *
-netdev_switch_notifier_info_to_dev(const struct netdev_switch_notifier_info *info)
+switchdev_notifier_info_to_dev(const struct switchdev_notifier_info *info)
 {
         return info->dev;
 }
 
 #ifdef CONFIG_NET_SWITCHDEV
 
-int netdev_switch_parent_id_get(struct net_device *dev,
-                                struct netdev_phys_item_id *psid);
-int netdev_switch_port_stp_update(struct net_device *dev, u8 state);
-int register_netdev_switch_notifier(struct notifier_block *nb);
-int unregister_netdev_switch_notifier(struct notifier_block *nb);
-int call_netdev_switch_notifiers(unsigned long val, struct net_device *dev,
-                                 struct netdev_switch_notifier_info *info);
-int netdev_switch_port_bridge_setlink(struct net_device *dev,
-                                struct nlmsghdr *nlh, u16 flags);
-int netdev_switch_port_bridge_dellink(struct net_device *dev,
-                                struct nlmsghdr *nlh, u16 flags);
-int ndo_dflt_netdev_switch_port_bridge_dellink(struct net_device *dev,
-                                               struct nlmsghdr *nlh, u16 flags);
-int ndo_dflt_netdev_switch_port_bridge_setlink(struct net_device *dev,
-                                               struct nlmsghdr *nlh, u16 flags);
-int netdev_switch_fib_ipv4_add(u32 dst, int dst_len, struct fib_info *fi,
-                               u8 tos, u8 type, u32 nlflags, u32 tb_id);
-int netdev_switch_fib_ipv4_del(u32 dst, int dst_len, struct fib_info *fi,
-                               u8 tos, u8 type, u32 tb_id);
-void netdev_switch_fib_ipv4_abort(struct fib_info *fi);
+int switchdev_port_attr_get(struct net_device *dev,
+                            struct switchdev_attr *attr);
+int switchdev_port_attr_set(struct net_device *dev,
+                            struct switchdev_attr *attr);
+int switchdev_port_obj_add(struct net_device *dev, struct switchdev_obj *obj);
+int switchdev_port_obj_del(struct net_device *dev, struct switchdev_obj *obj);
+int switchdev_port_obj_dump(struct net_device *dev, struct switchdev_obj *obj);
+int register_switchdev_notifier(struct notifier_block *nb);
+int unregister_switchdev_notifier(struct notifier_block *nb);
+int call_switchdev_notifiers(unsigned long val, struct net_device *dev,
+                             struct switchdev_notifier_info *info);
+int switchdev_port_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq,
+                                  struct net_device *dev, u32 filter_mask,
+                                  int nlflags);
+int switchdev_port_bridge_setlink(struct net_device *dev,
+                                  struct nlmsghdr *nlh, u16 flags);
+int switchdev_port_bridge_dellink(struct net_device *dev,
+                                  struct nlmsghdr *nlh, u16 flags);
+int switchdev_fib_ipv4_add(u32 dst, int dst_len, struct fib_info *fi,
+                           u8 tos, u8 type, u32 nlflags, u32 tb_id);
+int switchdev_fib_ipv4_del(u32 dst, int dst_len, struct fib_info *fi,
+                           u8 tos, u8 type, u32 tb_id);
+void switchdev_fib_ipv4_abort(struct fib_info *fi);
+int switchdev_port_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
+                           struct net_device *dev, const unsigned char *addr,
+                           u16 vid, u16 nlm_flags);
+int switchdev_port_fdb_del(struct ndmsg *ndm, struct nlattr *tb[],
+                           struct net_device *dev, const unsigned char *addr,
+                           u16 vid);
+int switchdev_port_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb,
+                            struct net_device *dev,
+                            struct net_device *filter_dev, int idx);
 
 #else
 
-static inline int netdev_switch_parent_id_get(struct net_device *dev,
-                                              struct netdev_phys_item_id *psid)
+static inline int switchdev_port_attr_get(struct net_device *dev,
+                                          struct switchdev_attr *attr)
+{
+        return -EOPNOTSUPP;
+}
+
+static inline int switchdev_port_attr_set(struct net_device *dev,
+                                          struct switchdev_attr *attr)
+{
+        return -EOPNOTSUPP;
+}
+
+static inline int switchdev_port_obj_add(struct net_device *dev,
+                                         struct switchdev_obj *obj)
 {
         return -EOPNOTSUPP;
 }
 
-static inline int netdev_switch_port_stp_update(struct net_device *dev,
-                                                u8 state)
+static inline int switchdev_port_obj_del(struct net_device *dev,
+                                         struct switchdev_obj *obj)
 {
         return -EOPNOTSUPP;
 }
 
-static inline int register_netdev_switch_notifier(struct notifier_block *nb)
+static inline int switchdev_port_obj_dump(struct net_device *dev,
+                                          struct switchdev_obj *obj)
+{
+        return -EOPNOTSUPP;
+}
+
+static inline int register_switchdev_notifier(struct notifier_block *nb)
 {
         return 0;
 }
 
-static inline int unregister_netdev_switch_notifier(struct notifier_block *nb)
+static inline int unregister_switchdev_notifier(struct notifier_block *nb)
 {
         return 0;
 }
 
-static inline int call_netdev_switch_notifiers(unsigned long val, struct net_device *dev,
-                                               struct netdev_switch_notifier_info *info)
+static inline int call_switchdev_notifiers(unsigned long val,
+                                           struct net_device *dev,
+                                           struct switchdev_notifier_info *info)
 {
         return NOTIFY_DONE;
 }
 
-static inline int netdev_switch_port_bridge_setlink(struct net_device *dev,
-                                                    struct nlmsghdr *nlh,
-                                                    u16 flags)
+static inline int switchdev_port_bridge_getlink(struct sk_buff *skb, u32 pid,
+                                            u32 seq, struct net_device *dev,
+                                            u32 filter_mask, int nlflags)
 {
         return -EOPNOTSUPP;
 }
 
-static inline int netdev_switch_port_bridge_dellink(struct net_device *dev,
-                                                    struct nlmsghdr *nlh,
-                                                    u16 flags)
+static inline int switchdev_port_bridge_setlink(struct net_device *dev,
+                                                struct nlmsghdr *nlh,
+                                                u16 flags)
 {
         return -EOPNOTSUPP;
 }
 
-static inline int ndo_dflt_netdev_switch_port_bridge_dellink(struct net_device *dev,
-                                                        struct nlmsghdr *nlh,
-                                                        u16 flags)
+static inline int switchdev_port_bridge_dellink(struct net_device *dev,
+                                                struct nlmsghdr *nlh,
+                                                u16 flags)
 {
-        return 0;
+        return -EOPNOTSUPP;
 }
 
-static inline int ndo_dflt_netdev_switch_port_bridge_setlink(struct net_device *dev,
-                                                        struct nlmsghdr *nlh,
-                                                        u16 flags)
+static inline int switchdev_fib_ipv4_add(u32 dst, int dst_len,
+                                         struct fib_info *fi,
+                                         u8 tos, u8 type,
+                                         u32 nlflags, u32 tb_id)
 {
         return 0;
 }
 
-static inline int netdev_switch_fib_ipv4_add(u32 dst, int dst_len,
-                                             struct fib_info *fi,
-                                             u8 tos, u8 type,
-                                             u32 nlflags, u32 tb_id)
+static inline int switchdev_fib_ipv4_del(u32 dst, int dst_len,
+                                         struct fib_info *fi,
+                                         u8 tos, u8 type, u32 tb_id)
 {
         return 0;
 }
 
-static inline int netdev_switch_fib_ipv4_del(u32 dst, int dst_len,
-                                             struct fib_info *fi,
-                                             u8 tos, u8 type, u32 tb_id)
+static inline void switchdev_fib_ipv4_abort(struct fib_info *fi)
 {
-        return 0;
 }
 
-static inline void netdev_switch_fib_ipv4_abort(struct fib_info *fi)
+static inline int switchdev_port_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
+                                         struct net_device *dev,
+                                         const unsigned char *addr,
+                                         u16 vid, u16 nlm_flags)
 {
+        return -EOPNOTSUPP;
+}
+
+static inline int switchdev_port_fdb_del(struct ndmsg *ndm, struct nlattr *tb[],
+                                         struct net_device *dev,
+                                         const unsigned char *addr, u16 vid)
+{
+        return -EOPNOTSUPP;
+}
+
+static inline int switchdev_port_fdb_dump(struct sk_buff *skb,
+                                          struct netlink_callback *cb,
+                                          struct net_device *dev,
+                                          struct net_device *filter_dev,
+                                          int idx)
+{
+        return -EOPNOTSUPP;
 }
 
 #endif
diff --git a/include/net/tcp.h b/include/net/tcp.h
index 6d204f3f9df8..950cfecaad3c 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -286,6 +286,14 @@ extern atomic_long_t tcp_memory_allocated;
 extern struct percpu_counter tcp_sockets_allocated;
 extern int tcp_memory_pressure;
 
+/* optimized version of sk_under_memory_pressure() for TCP sockets */
+static inline bool tcp_under_memory_pressure(const struct sock *sk)
+{
+        if (mem_cgroup_sockets_enabled && sk->sk_cgrp)
+                return !!sk->sk_cgrp->memory_pressure;
+
+        return tcp_memory_pressure;
+}
 /*
  * The next routines deal with comparing 32 bit unsigned ints
  * and worry about wraparound (automatic with unsigned arithmetic).
@@ -311,6 +319,8 @@ static inline bool tcp_out_of_memory(struct sock *sk)
         return false;
 }
 
+void sk_forced_mem_schedule(struct sock *sk, int size);
+
 static inline bool tcp_too_many_orphans(struct sock *sk, int shift)
 {
         struct percpu_counter *ocp = sk->sk_prot->orphan_count;
@@ -326,18 +336,6 @@ static inline bool tcp_too_many_orphans(struct sock *sk, int shift)
 
 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)
-{
-        tcp_sk(sk)->rx_opt.ts_recent_stamp = jiffies;
-}
-
-/* syncookies: no recent synqueue overflow on this listening socket? */
-static inline bool tcp_synq_no_recent_overflow(const struct sock *sk)
-{
-        unsigned long last_overflow = tcp_sk(sk)->rx_opt.ts_recent_stamp;
-        return time_after(jiffies, last_overflow + TCP_TIMEOUT_FALLBACK);
-}
 
 extern struct proto tcp_prot;
 
@@ -471,6 +469,9 @@ int tcp_send_rcvq(struct sock *sk, struct msghdr *msg, size_t size);
 void inet_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb);
 
 /* From syncookies.c */
+struct sock *tcp_get_cookie_sock(struct sock *sk, struct sk_buff *skb,
+                                 struct request_sock *req,
+                                 struct dst_entry *dst);
 int __cookie_v4_check(const struct iphdr *iph, const struct tcphdr *th,
                       u32 cookie);
 struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb);
@@ -483,13 +484,35 @@ struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb);
  * i.e. a sent cookie is valid only at most for 2*60 seconds (or less if
  * the counter advances immediately after a cookie is generated).
  */
-#define MAX_SYNCOOKIE_AGE 2
+#define MAX_SYNCOOKIE_AGE       2
+#define TCP_SYNCOOKIE_PERIOD    (60 * HZ)
+#define TCP_SYNCOOKIE_VALID     (MAX_SYNCOOKIE_AGE * TCP_SYNCOOKIE_PERIOD)
+
+/* syncookies: remember time of last synqueue overflow
+ * But do not dirty this field too often (once per second is enough)
+ */
+static inline void tcp_synq_overflow(struct sock *sk)
+{
+        unsigned long last_overflow = tcp_sk(sk)->rx_opt.ts_recent_stamp;
+        unsigned long now = jiffies;
+
+        if (time_after(now, last_overflow + HZ))
+                tcp_sk(sk)->rx_opt.ts_recent_stamp = now;
+}
+
+/* syncookies: no recent synqueue overflow on this listening socket? */
+static inline bool tcp_synq_no_recent_overflow(const struct sock *sk)
+{
+        unsigned long last_overflow = tcp_sk(sk)->rx_opt.ts_recent_stamp;
+
+        return time_after(jiffies, last_overflow + TCP_SYNCOOKIE_VALID);
+}
 
 static inline u32 tcp_cookie_time(void)
 {
         u64 val = get_jiffies_64();
 
-        do_div(val, 60 * HZ);
+        do_div(val, TCP_SYNCOOKIE_PERIOD);
         return val;
 }
 
@@ -527,7 +550,7 @@ int tcp_fragment(struct sock *, struct sk_buff *, u32, unsigned int, gfp_t);
 
 void tcp_send_probe0(struct sock *);
 void tcp_send_partial(struct sock *);
-int tcp_write_wakeup(struct sock *);
+int tcp_write_wakeup(struct sock *, int mib);
 void tcp_send_fin(struct sock *sk);
 void tcp_send_active_reset(struct sock *sk, gfp_t priority);
 int tcp_send_synack(struct sock *);
@@ -692,6 +715,8 @@ static inline u32 tcp_skb_timestamp(const struct sk_buff *skb)
 #define TCPHDR_ECE 0x40
 #define TCPHDR_CWR 0x80
 
+#define TCPHDR_SYN_ECN  (TCPHDR_SYN | TCPHDR_ECE | TCPHDR_CWR)
+
 /* This is what the send packet queuing engine uses to pass
  * TCP per-packet control information to the transmission code.
  * We also store the host-order sequence numbers in here too.
@@ -705,11 +730,14 @@ struct tcp_skb_cb {
                 /* Note : tcp_tw_isn is used in input path only
                  *        (isn chosen by tcp_timewait_state_process())
                  *
-                 *        tcp_gso_segs is used in write queue only,
-                 *        cf tcp_skb_pcount()
+                 *        tcp_gso_segs/size are used in write queue only,
+                 *        cf tcp_skb_pcount()/tcp_skb_mss()
                  */
                 __u32           tcp_tw_isn;
-                __u32           tcp_gso_segs;
+                struct {
+                        u16     tcp_gso_segs;
+                        u16     tcp_gso_size;
+                };
         };
         __u8            tcp_flags;      /* TCP header flags. (tcp[13])  */
 
@@ -765,10 +793,10 @@ static inline void tcp_skb_pcount_add(struct sk_buff *skb, int segs)
         TCP_SKB_CB(skb)->tcp_gso_segs += segs;
 }
 
-/* This is valid iff tcp_skb_pcount() > 1. */
+/* This is valid iff skb is in write queue and tcp_skb_pcount() > 1. */
 static inline int tcp_skb_mss(const struct sk_buff *skb)
 {
-        return skb_shinfo(skb)->gso_size;
+        return TCP_SKB_CB(skb)->tcp_gso_size;
 }
 
 /* Events passed to congestion control interface */
@@ -1043,14 +1071,31 @@ static inline bool tcp_is_cwnd_limited(const struct sock *sk)
         return tp->is_cwnd_limited;
 }
 
-static inline void tcp_check_probe_timer(struct sock *sk)
+/* Something is really bad, we could not queue an additional packet,
+ * because qdisc is full or receiver sent a 0 window.
+ * We do not want to add fuel to the fire, or abort too early,
+ * so make sure the timer we arm now is at least 200ms in the future,
+ * regardless of current icsk_rto value (as it could be ~2ms)
+ */
+static inline unsigned long tcp_probe0_base(const struct sock *sk)
 {
-        const struct tcp_sock *tp = tcp_sk(sk);
-        const struct inet_connection_sock *icsk = inet_csk(sk);
+        return max_t(unsigned long, inet_csk(sk)->icsk_rto, TCP_RTO_MIN);
+}
+
+/* Variant of inet_csk_rto_backoff() used for zero window probes */
+static inline unsigned long tcp_probe0_when(const struct sock *sk,
+                                            unsigned long max_when)
+{
+        u64 when = (u64)tcp_probe0_base(sk) << inet_csk(sk)->icsk_backoff;
 
-        if (!tp->packets_out && !icsk->icsk_pending)
+        return (unsigned long)min_t(u64, when, max_when);
+}
+
+static inline void tcp_check_probe_timer(struct sock *sk)
+{
+        if (!tcp_sk(sk)->packets_out && !inet_csk(sk)->icsk_pending)
                 inet_csk_reset_xmit_timer(sk, ICSK_TIME_PROBE0,
-                                          icsk->icsk_rto, TCP_RTO_MAX);
+                                          tcp_probe0_base(sk), TCP_RTO_MAX);
 }
 
 static inline void tcp_init_wl(struct tcp_sock *tp, u32 seq)
diff --git a/include/ras/ras_event.h b/include/ras/ras_event.h
index 79abb9c71772..1443d79e4fe6 100644
--- a/include/ras/ras_event.h
+++ b/include/ras/ras_event.h
@@ -11,6 +11,7 @@
 #include <linux/pci.h>
 #include <linux/aer.h>
 #include <linux/cper.h>
+#include <linux/mm.h>
 
 /*
  * MCE Extended Error Log trace event
@@ -232,6 +233,90 @@ TRACE_EVENT(aer_event,
                 __print_flags(__entry->status, "|", aer_uncorrectable_errors))
 );
 
+/*
+ * memory-failure recovery action result event
+ *
+ * unsigned long pfn -  Page Frame Number of the corrupted page
+ * int type     -       Page types of the corrupted page
+ * int result   -       Result of recovery action
+ */
+
+#ifdef CONFIG_MEMORY_FAILURE
+#define MF_ACTION_RESULT        \
+        EM ( MF_IGNORED, "Ignored" )    \
+        EM ( MF_FAILED,  "Failed" )     \
+        EM ( MF_DELAYED, "Delayed" )    \
+        EMe ( MF_RECOVERED, "Recovered" )
+
+#define MF_PAGE_TYPE            \
+        EM ( MF_MSG_KERNEL, "reserved kernel page" )                    \
+        EM ( MF_MSG_KERNEL_HIGH_ORDER, "high-order kernel page" )       \
+        EM ( MF_MSG_SLAB, "kernel slab page" )                          \
+        EM ( MF_MSG_DIFFERENT_COMPOUND, "different compound page after locking" ) \
+        EM ( MF_MSG_POISONED_HUGE, "huge page already hardware poisoned" )      \
+        EM ( MF_MSG_HUGE, "huge page" )                                 \
+        EM ( MF_MSG_FREE_HUGE, "free huge page" )                       \
+        EM ( MF_MSG_UNMAP_FAILED, "unmapping failed page" )             \
+        EM ( MF_MSG_DIRTY_SWAPCACHE, "dirty swapcache page" )           \
+        EM ( MF_MSG_CLEAN_SWAPCACHE, "clean swapcache page" )           \
+        EM ( MF_MSG_DIRTY_MLOCKED_LRU, "dirty mlocked LRU page" )       \
+        EM ( MF_MSG_CLEAN_MLOCKED_LRU, "clean mlocked LRU page" )       \
+        EM ( MF_MSG_DIRTY_UNEVICTABLE_LRU, "dirty unevictable LRU page" )       \
+        EM ( MF_MSG_CLEAN_UNEVICTABLE_LRU, "clean unevictable LRU page" )       \
+        EM ( MF_MSG_DIRTY_LRU, "dirty LRU page" )                       \
+        EM ( MF_MSG_CLEAN_LRU, "clean LRU page" )                       \
+        EM ( MF_MSG_TRUNCATED_LRU, "already truncated LRU page" )       \
+        EM ( MF_MSG_BUDDY, "free buddy page" )                          \
+        EM ( MF_MSG_BUDDY_2ND, "free buddy page (2nd try)" )            \
+        EMe ( MF_MSG_UNKNOWN, "unknown page" )
+
+/*
+ * First define the enums in MM_ACTION_RESULT to be exported to userspace
+ * via TRACE_DEFINE_ENUM().
+ */
+#undef EM
+#undef EMe
+#define EM(a, b) TRACE_DEFINE_ENUM(a);
+#define EMe(a, b)       TRACE_DEFINE_ENUM(a);
+
+MF_ACTION_RESULT
+MF_PAGE_TYPE
+
+/*
+ * Now redefine the EM() and EMe() macros to map the enums to the strings
+ * that will be printed in the output.
+ */
+#undef EM
+#undef EMe
+#define EM(a, b)                { a, b },
+#define EMe(a, b)       { a, b }
+
+TRACE_EVENT(memory_failure_event,
+        TP_PROTO(unsigned long pfn,
+                 int type,
+                 int result),
+
+        TP_ARGS(pfn, type, result),
+
+        TP_STRUCT__entry(
+                __field(unsigned long, pfn)
+                __field(int, type)
+                __field(int, result)
+        ),
+
+        TP_fast_assign(
+                __entry->pfn    = pfn;
+                __entry->type   = type;
+                __entry->result = result;
+        ),
+
+        TP_printk("pfn %#lx: recovery action for %s: %s",
+                __entry->pfn,
+                __print_symbolic(__entry->type, MF_PAGE_TYPE),
+                __print_symbolic(__entry->result, MF_ACTION_RESULT)
+        )
+);
+#endif /* CONFIG_MEMORY_FAILURE */
 #endif /* _TRACE_HW_EVENT_MC_H */
 
 /* This part must be outside protection */
diff --git a/include/rdma/ib_addr.h b/include/rdma/ib_addr.h
index ac54c27a2bfd..fde33ac6b58a 100644
--- a/include/rdma/ib_addr.h
+++ b/include/rdma/ib_addr.h
@@ -111,8 +111,8 @@ int rdma_copy_addr(struct rdma_dev_addr *dev_addr, struct net_device *dev,
 int rdma_addr_size(struct sockaddr *addr);
 
 int rdma_addr_find_smac_by_sgid(union ib_gid *sgid, u8 *smac, u16 *vlan_id);
-int rdma_addr_find_dmac_by_grh(union ib_gid *sgid, union ib_gid *dgid, u8 *smac,
-                               u16 *vlan_id);
+int rdma_addr_find_dmac_by_grh(const union ib_gid *sgid, const union ib_gid *dgid,
+                               u8 *smac, u16 *vlan_id);
 
 static inline u16 ib_addr_get_pkey(struct rdma_dev_addr *dev_addr)
 {
@@ -160,7 +160,7 @@ static inline int rdma_ip2gid(struct sockaddr *addr, union ib_gid *gid)
 }
 
 /* Important - sockaddr should be a union of sockaddr_in and sockaddr_in6 */
-static inline void rdma_gid2ip(struct sockaddr *out, union ib_gid *gid)
+static inline void rdma_gid2ip(struct sockaddr *out, const union ib_gid *gid)
 {
         if (ipv6_addr_v4mapped((struct in6_addr *)gid)) {
                 struct sockaddr_in *out_in = (struct sockaddr_in *)out;
diff --git a/include/rdma/ib_cache.h b/include/rdma/ib_cache.h
index ad9a3c280944..bd92130f4ac5 100644
--- a/include/rdma/ib_cache.h
+++ b/include/rdma/ib_cache.h
@@ -64,10 +64,10 @@ int ib_get_cached_gid(struct ib_device    *device,
  * ib_find_cached_gid() searches for the specified GID value in
  * the local software cache.
  */
-int ib_find_cached_gid(struct ib_device *device,
-                       union ib_gid     *gid,
-                       u8               *port_num,
-                       u16              *index);
+int ib_find_cached_gid(struct ib_device   *device,
+                       const union ib_gid *gid,
+                       u8                 *port_num,
+                       u16                *index);
 
 /**
  * ib_get_cached_pkey - Returns a cached PKey table entry
diff --git a/include/rdma/ib_mad.h b/include/rdma/ib_mad.h
index 9bb99e983f58..c8422d5a5a91 100644
--- a/include/rdma/ib_mad.h
+++ b/include/rdma/ib_mad.h
@@ -42,8 +42,11 @@
 #include <rdma/ib_verbs.h>
 #include <uapi/rdma/ib_user_mad.h>
 
-/* Management base version */
+/* Management base versions */
 #define IB_MGMT_BASE_VERSION                    1
+#define OPA_MGMT_BASE_VERSION                   0x80
+
+#define OPA_SMP_CLASS_VERSION                   0x80
 
 /* Management classes */
 #define IB_MGMT_CLASS_SUBN_LID_ROUTED           0x01
@@ -135,6 +138,10 @@ enum {
         IB_MGMT_SA_DATA = 200,
         IB_MGMT_DEVICE_HDR = 64,
         IB_MGMT_DEVICE_DATA = 192,
+        IB_MGMT_MAD_SIZE = IB_MGMT_MAD_HDR + IB_MGMT_MAD_DATA,
+        OPA_MGMT_MAD_DATA = 2024,
+        OPA_MGMT_RMPP_DATA = 2012,
+        OPA_MGMT_MAD_SIZE = IB_MGMT_MAD_HDR + OPA_MGMT_MAD_DATA,
 };
 
 struct ib_mad_hdr {
@@ -181,12 +188,23 @@ struct ib_mad {
         u8                      data[IB_MGMT_MAD_DATA];
 };
 
+struct opa_mad {
+        struct ib_mad_hdr       mad_hdr;
+        u8                      data[OPA_MGMT_MAD_DATA];
+};
+
 struct ib_rmpp_mad {
         struct ib_mad_hdr       mad_hdr;
         struct ib_rmpp_hdr      rmpp_hdr;
         u8                      data[IB_MGMT_RMPP_DATA];
 };
 
+struct opa_rmpp_mad {
+        struct ib_mad_hdr       mad_hdr;
+        struct ib_rmpp_hdr      rmpp_hdr;
+        u8                      data[OPA_MGMT_RMPP_DATA];
+};
+
 struct ib_sa_mad {
         struct ib_mad_hdr       mad_hdr;
         struct ib_rmpp_hdr      rmpp_hdr;
@@ -235,7 +253,10 @@ struct ib_class_port_info {
  *   includes the common MAD, RMPP, and class specific headers.
  * @data_len: Indicates the total size of user-transferred data.
  * @seg_count: The number of RMPP segments allocated for this send.
- * @seg_size: Size of each RMPP segment.
+ * @seg_size: Size of the data in each RMPP segment.  This does not include
+ *   class specific headers.
+ * @seg_rmpp_size: Size of each RMPP segment including the class specific
+ *   headers.
  * @timeout_ms: Time to wait for a response.
  * @retries: Number of times to retry a request for a response.  For MADs
  *   using RMPP, this applies per window.  On completion, returns the number
@@ -255,6 +276,7 @@ struct ib_mad_send_buf {
         int                     data_len;
         int                     seg_count;
         int                     seg_size;
+        int                     seg_rmpp_size;
         int                     timeout_ms;
         int                     retries;
 };
@@ -263,7 +285,7 @@ struct ib_mad_send_buf {
  * ib_response_mad - Returns if the specified MAD has been generated in
  *   response to a sent request or trap.
  */
-int ib_response_mad(struct ib_mad *mad);
+int ib_response_mad(const struct ib_mad_hdr *hdr);
 
 /**
  * ib_get_rmpp_resptime - Returns the RMPP response time.
@@ -401,7 +423,10 @@ struct ib_mad_send_wc {
 struct ib_mad_recv_buf {
         struct list_head        list;
         struct ib_grh           *grh;
-        struct ib_mad           *mad;
+        union {
+                struct ib_mad   *mad;
+                struct opa_mad  *opa_mad;
+        };
 };
 
 /**
@@ -410,6 +435,7 @@ struct ib_mad_recv_buf {
  * @recv_buf: Specifies the location of the received data buffer(s).
  * @rmpp_list: Specifies a list of RMPP reassembled received MAD buffers.
  * @mad_len: The length of the received MAD, without duplicated headers.
+ * @mad_seg_size: The size of individual MAD segments
  *
  * For received response, the wr_id contains a pointer to the ib_mad_send_buf
  *   for the corresponding send request.
@@ -419,6 +445,7 @@ struct ib_mad_recv_wc {
         struct ib_mad_recv_buf  recv_buf;
         struct list_head        rmpp_list;
         int                     mad_len;
+        size_t                  mad_seg_size;
 };
 
 /**
@@ -618,6 +645,7 @@ int ib_process_mad_wc(struct ib_mad_agent *mad_agent,
  *   automatically adjust the allocated buffer size to account for any
  *   additional padding that may be necessary.
  * @gfp_mask: GFP mask used for the memory allocation.
+ * @base_version: Base Version of this MAD
  *
  * This routine allocates a MAD for sending.  The returned MAD send buffer
  * will reference a data buffer usable for sending a MAD, along
@@ -633,7 +661,8 @@ struct ib_mad_send_buf *ib_create_send_mad(struct ib_mad_agent *mad_agent,
                                            u32 remote_qpn, u16 pkey_index,
                                            int rmpp_active,
                                            int hdr_len, int data_len,
-                                           gfp_t gfp_mask);
+                                           gfp_t gfp_mask,
+                                           u8 base_version);
 
 /**
  * ib_is_mad_class_rmpp - returns whether given management class
@@ -675,6 +704,6 @@ void ib_free_send_mad(struct ib_mad_send_buf *send_buf);
  * @agent: the agent in question
  * @return: true if agent is performing rmpp, false otherwise.
  */
-int ib_mad_kernel_rmpp_agent(struct ib_mad_agent *agent);
+int ib_mad_kernel_rmpp_agent(const struct ib_mad_agent *agent);
 
 #endif /* IB_MAD_H */
diff --git a/include/rdma/ib_verbs.h b/include/rdma/ib_verbs.h
index 65994a19e840..b0f898e3b2e7 100644
--- a/include/rdma/ib_verbs.h
+++ b/include/rdma/ib_verbs.h
@@ -81,6 +81,13 @@ enum rdma_transport_type {
         RDMA_TRANSPORT_USNIC_UDP
 };
 
+enum rdma_protocol_type {
+        RDMA_PROTOCOL_IB,
+        RDMA_PROTOCOL_IBOE,
+        RDMA_PROTOCOL_IWARP,
+        RDMA_PROTOCOL_USNIC_UDP
+};
+
 __attribute_const__ enum rdma_transport_type
 rdma_node_get_transport(enum rdma_node_type node_type);
 
@@ -166,6 +173,16 @@ struct ib_odp_caps {
         } per_transport_caps;
 };
 
+enum ib_cq_creation_flags {
+        IB_CQ_FLAGS_TIMESTAMP_COMPLETION   = 1 << 0,
+};
+
+struct ib_cq_init_attr {
+        unsigned int    cqe;
+        int             comp_vector;
+        u32             flags;
+};
+
 struct ib_device_attr {
         u64                     fw_ver;
         __be64                  sys_image_guid;
@@ -210,6 +227,8 @@ struct ib_device_attr {
         int                     sig_prot_cap;
         int                     sig_guard_cap;
         struct ib_odp_caps      odp_caps;
+        uint64_t                timestamp_mask;
+        uint64_t                hca_core_clock; /* in KHZ */
 };
 
 enum ib_mtu {
@@ -346,6 +365,42 @@ union rdma_protocol_stats {
         struct iw_protocol_stats        iw;
 };
 
+/* Define bits for the various functionality this port needs to be supported by
+ * the core.
+ */
+/* Management                           0x00000FFF */
+#define RDMA_CORE_CAP_IB_MAD            0x00000001
+#define RDMA_CORE_CAP_IB_SMI            0x00000002
+#define RDMA_CORE_CAP_IB_CM             0x00000004
+#define RDMA_CORE_CAP_IW_CM             0x00000008
+#define RDMA_CORE_CAP_IB_SA             0x00000010
+#define RDMA_CORE_CAP_OPA_MAD           0x00000020
+
+/* Address format                       0x000FF000 */
+#define RDMA_CORE_CAP_AF_IB             0x00001000
+#define RDMA_CORE_CAP_ETH_AH            0x00002000
+
+/* Protocol                             0xFFF00000 */
+#define RDMA_CORE_CAP_PROT_IB           0x00100000
+#define RDMA_CORE_CAP_PROT_ROCE         0x00200000
+#define RDMA_CORE_CAP_PROT_IWARP        0x00400000
+
+#define RDMA_CORE_PORT_IBA_IB          (RDMA_CORE_CAP_PROT_IB  \
+                                        | RDMA_CORE_CAP_IB_MAD \
+                                        | RDMA_CORE_CAP_IB_SMI \
+                                        | RDMA_CORE_CAP_IB_CM  \
+                                        | RDMA_CORE_CAP_IB_SA  \
+                                        | RDMA_CORE_CAP_AF_IB)
+#define RDMA_CORE_PORT_IBA_ROCE        (RDMA_CORE_CAP_PROT_ROCE \
+                                        | RDMA_CORE_CAP_IB_MAD  \
+                                        | RDMA_CORE_CAP_IB_CM   \
+                                        | RDMA_CORE_CAP_AF_IB   \
+                                        | RDMA_CORE_CAP_ETH_AH)
+#define RDMA_CORE_PORT_IWARP           (RDMA_CORE_CAP_PROT_IWARP \
+                                        | RDMA_CORE_CAP_IW_CM)
+#define RDMA_CORE_PORT_INTEL_OPA       (RDMA_CORE_PORT_IBA_IB  \
+                                        | RDMA_CORE_CAP_OPA_MAD)
+
 struct ib_port_attr {
         enum ib_port_state      state;
         enum ib_mtu             max_mtu;
@@ -412,6 +467,8 @@ enum ib_event_type {
         IB_EVENT_GID_CHANGE,
 };
 
+__attribute_const__ const char *ib_event_msg(enum ib_event_type event);
+
 struct ib_event {
         struct ib_device        *device;
         union {
@@ -663,6 +720,8 @@ enum ib_wc_status {
         IB_WC_GENERAL_ERR
 };
 
+__attribute_const__ const char *ib_wc_status_msg(enum ib_wc_status status);
+
 enum ib_wc_opcode {
         IB_WC_SEND,
         IB_WC_RDMA_WRITE,
@@ -1407,7 +1466,7 @@ struct ib_flow {
         struct ib_uobject       *uobject;
 };
 
-struct ib_mad;
+struct ib_mad_hdr;
 struct ib_grh;
 
 enum ib_process_mad_flags {
@@ -1474,6 +1533,13 @@ struct ib_dma_mapping_ops {
 
 struct iw_cm_verbs;
 
+struct ib_port_immutable {
+        int                           pkey_tbl_len;
+        int                           gid_tbl_len;
+        u32                           core_cap_flags;
+        u32                           max_mad_size;
+};
+
 struct ib_device {
         struct device                *dma_device;
 
@@ -1487,8 +1553,10 @@ struct ib_device {
         struct list_head              client_data_list;
 
         struct ib_cache               cache;
-        int                          *pkey_tbl_len;
-        int                          *gid_tbl_len;
+        /**
+         * port_immutable is indexed by port number
+         */
+        struct ib_port_immutable     *port_immutable;
 
         int                           num_comp_vectors;
 
@@ -1497,7 +1565,8 @@ struct ib_device {
         int                        (*get_protocol_stats)(struct ib_device *device,
                                                          union rdma_protocol_stats *stats);
         int                        (*query_device)(struct ib_device *device,
-                                                   struct ib_device_attr *device_attr);
+                                                   struct ib_device_attr *device_attr,
+                                                   struct ib_udata *udata);
         int                        (*query_port)(struct ib_device *device,
                                                  u8 port_num,
                                                  struct ib_port_attr *port_attr);
@@ -1561,8 +1630,8 @@ struct ib_device {
         int                        (*post_recv)(struct ib_qp *qp,
                                                 struct ib_recv_wr *recv_wr,
                                                 struct ib_recv_wr **bad_recv_wr);
-        struct ib_cq *             (*create_cq)(struct ib_device *device, int cqe,
-                                                int comp_vector,
+        struct ib_cq *             (*create_cq)(struct ib_device *device,
+                                                const struct ib_cq_init_attr *attr,
                                                 struct ib_ucontext *context,
                                                 struct ib_udata *udata);
         int                        (*modify_cq)(struct ib_cq *cq, u16 cq_count,
@@ -1637,10 +1706,13 @@ struct ib_device {
         int                        (*process_mad)(struct ib_device *device,
                                                   int process_mad_flags,
                                                   u8 port_num,
-                                                  struct ib_wc *in_wc,
-                                                  struct ib_grh *in_grh,
-                                                  struct ib_mad *in_mad,
-                                                  struct ib_mad *out_mad);
+                                                  const struct ib_wc *in_wc,
+                                                  const struct ib_grh *in_grh,
+                                                  const struct ib_mad_hdr *in_mad,
+                                                  size_t in_mad_size,
+                                                  struct ib_mad_hdr *out_mad,
+                                                  size_t *out_mad_size,
+                                                  u16 *out_mad_pkey_index);
         struct ib_xrcd *           (*alloc_xrcd)(struct ib_device *device,
                                                  struct ib_ucontext *ucontext,
                                                  struct ib_udata *udata);
@@ -1673,8 +1745,17 @@ struct ib_device {
         char                         node_desc[64];
         __be64                       node_guid;
         u32                          local_dma_lkey;
+        u16                          is_switch:1;
         u8                           node_type;
         u8                           phys_port_cnt;
+
+        /**
+         * The following mandatory functions are used only at device
+         * registration.  Keep functions such as these at the end of this
+         * structure to avoid cache line misses when accessing struct ib_device
+         * in fast paths.
+         */
+        int (*get_port_immutable)(struct ib_device *, u8, struct ib_port_immutable *);
 };
 
 struct ib_client {
@@ -1743,6 +1824,297 @@ int ib_query_port(struct ib_device *device,
 enum rdma_link_layer rdma_port_get_link_layer(struct ib_device *device,
                                                u8 port_num);
 
+/**
+ * rdma_cap_ib_switch - Check if the device is IB switch
+ * @device: Device to check
+ *
+ * Device driver is responsible for setting is_switch bit on
+ * in ib_device structure at init time.
+ *
+ * Return: true if the device is IB switch.
+ */
+static inline bool rdma_cap_ib_switch(const struct ib_device *device)
+{
+        return device->is_switch;
+}
+
+/**
+ * rdma_start_port - Return the first valid port number for the device
+ * specified
+ *
+ * @device: Device to be checked
+ *
+ * Return start port number
+ */
+static inline u8 rdma_start_port(const struct ib_device *device)
+{
+        return rdma_cap_ib_switch(device) ? 0 : 1;
+}
+
+/**
+ * rdma_end_port - Return the last valid port number for the device
+ * specified
+ *
+ * @device: Device to be checked
+ *
+ * Return last port number
+ */
+static inline u8 rdma_end_port(const struct ib_device *device)
+{
+        return rdma_cap_ib_switch(device) ? 0 : device->phys_port_cnt;
+}
+
+static inline bool rdma_protocol_ib(const struct ib_device *device, u8 port_num)
+{
+        return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_PROT_IB;
+}
+
+static inline bool rdma_protocol_roce(const struct ib_device *device, u8 port_num)
+{
+        return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_PROT_ROCE;
+}
+
+static inline bool rdma_protocol_iwarp(const struct ib_device *device, u8 port_num)
+{
+        return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_PROT_IWARP;
+}
+
+static inline bool rdma_ib_or_roce(const struct ib_device *device, u8 port_num)
+{
+        return device->port_immutable[port_num].core_cap_flags &
+                (RDMA_CORE_CAP_PROT_IB | RDMA_CORE_CAP_PROT_ROCE);
+}
+
+/**
+ * rdma_cap_ib_mad - Check if the port of a device supports Infiniband
+ * Management Datagrams.
+ * @device: Device to check
+ * @port_num: Port number to check
+ *
+ * Management Datagrams (MAD) are a required part of the InfiniBand
+ * specification and are supported on all InfiniBand devices.  A slightly
+ * extended version are also supported on OPA interfaces.
+ *
+ * Return: true if the port supports sending/receiving of MAD packets.
+ */
+static inline bool rdma_cap_ib_mad(const struct ib_device *device, u8 port_num)
+{
+        return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_IB_MAD;
+}
+
+/**
+ * rdma_cap_opa_mad - Check if the port of device provides support for OPA
+ * Management Datagrams.
+ * @device: Device to check
+ * @port_num: Port number to check
+ *
+ * Intel OmniPath devices extend and/or replace the InfiniBand Management
+ * datagrams with their own versions.  These OPA MADs share many but not all of
+ * the characteristics of InfiniBand MADs.
+ *
+ * OPA MADs differ in the following ways:
+ *
+ *    1) MADs are variable size up to 2K
+ *       IBTA defined MADs remain fixed at 256 bytes
+ *    2) OPA SMPs must carry valid PKeys
+ *    3) OPA SMP packets are a different format
+ *
+ * Return: true if the port supports OPA MAD packet formats.
+ */
+static inline bool rdma_cap_opa_mad(struct ib_device *device, u8 port_num)
+{
+        return (device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_OPA_MAD)
+                == RDMA_CORE_CAP_OPA_MAD;
+}
+
+/**
+ * rdma_cap_ib_smi - Check if the port of a device provides an Infiniband
+ * Subnet Management Agent (SMA) on the Subnet Management Interface (SMI).
+ * @device: Device to check
+ * @port_num: Port number to check
+ *
+ * Each InfiniBand node is required to provide a Subnet Management Agent
+ * that the subnet manager can access.  Prior to the fabric being fully
+ * configured by the subnet manager, the SMA is accessed via a well known
+ * interface called the Subnet Management Interface (SMI).  This interface
+ * uses directed route packets to communicate with the SM to get around the
+ * chicken and egg problem of the SM needing to know what's on the fabric
+ * in order to configure the fabric, and needing to configure the fabric in
+ * order to send packets to the devices on the fabric.  These directed
+ * route packets do not need the fabric fully configured in order to reach
+ * their destination.  The SMI is the only method allowed to send
+ * directed route packets on an InfiniBand fabric.
+ *
+ * Return: true if the port provides an SMI.
+ */
+static inline bool rdma_cap_ib_smi(const struct ib_device *device, u8 port_num)
+{
+        return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_IB_SMI;
+}
+
+/**
+ * rdma_cap_ib_cm - Check if the port of device has the capability Infiniband
+ * Communication Manager.
+ * @device: Device to check
+ * @port_num: Port number to check
+ *
+ * The InfiniBand Communication Manager is one of many pre-defined General
+ * Service Agents (GSA) that are accessed via the General Service
+ * Interface (GSI).  It's role is to facilitate establishment of connections
+ * between nodes as well as other management related tasks for established
+ * connections.
+ *
+ * Return: true if the port supports an IB CM (this does not guarantee that
+ * a CM is actually running however).
+ */
+static inline bool rdma_cap_ib_cm(const struct ib_device *device, u8 port_num)
+{
+        return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_IB_CM;
+}
+
+/**
+ * rdma_cap_iw_cm - Check if the port of device has the capability IWARP
+ * Communication Manager.
+ * @device: Device to check
+ * @port_num: Port number to check
+ *
+ * Similar to above, but specific to iWARP connections which have a different
+ * managment protocol than InfiniBand.
+ *
+ * Return: true if the port supports an iWARP CM (this does not guarantee that
+ * a CM is actually running however).
+ */
+static inline bool rdma_cap_iw_cm(const struct ib_device *device, u8 port_num)
+{
+        return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_IW_CM;
+}
+
+/**
+ * rdma_cap_ib_sa - Check if the port of device has the capability Infiniband
+ * Subnet Administration.
+ * @device: Device to check
+ * @port_num: Port number to check
+ *
+ * An InfiniBand Subnet Administration (SA) service is a pre-defined General
+ * Service Agent (GSA) provided by the Subnet Manager (SM).  On InfiniBand
+ * fabrics, devices should resolve routes to other hosts by contacting the
+ * SA to query the proper route.
+ *
+ * Return: true if the port should act as a client to the fabric Subnet
+ * Administration interface.  This does not imply that the SA service is
+ * running locally.
+ */
+static inline bool rdma_cap_ib_sa(const struct ib_device *device, u8 port_num)
+{
+        return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_IB_SA;
+}
+
+/**
+ * rdma_cap_ib_mcast - Check if the port of device has the capability Infiniband
+ * Multicast.
+ * @device: Device to check
+ * @port_num: Port number to check
+ *
+ * InfiniBand multicast registration is more complex than normal IPv4 or
+ * IPv6 multicast registration.  Each Host Channel Adapter must register
+ * with the Subnet Manager when it wishes to join a multicast group.  It
+ * should do so only once regardless of how many queue pairs it subscribes
+ * to this group.  And it should leave the group only after all queue pairs
+ * attached to the group have been detached.
+ *
+ * Return: true if the port must undertake the additional adminstrative
+ * overhead of registering/unregistering with the SM and tracking of the
+ * total number of queue pairs attached to the multicast group.
+ */
+static inline bool rdma_cap_ib_mcast(const struct ib_device *device, u8 port_num)
+{
+        return rdma_cap_ib_sa(device, port_num);
+}
+
+/**
+ * rdma_cap_af_ib - Check if the port of device has the capability
+ * Native Infiniband Address.
+ * @device: Device to check
+ * @port_num: Port number to check
+ *
+ * InfiniBand addressing uses a port's GUID + Subnet Prefix to make a default
+ * GID.  RoCE uses a different mechanism, but still generates a GID via
+ * a prescribed mechanism and port specific data.
+ *
+ * Return: true if the port uses a GID address to identify devices on the
+ * network.
+ */
+static inline bool rdma_cap_af_ib(const struct ib_device *device, u8 port_num)
+{
+        return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_AF_IB;
+}
+
+/**
+ * rdma_cap_eth_ah - Check if the port of device has the capability
+ * Ethernet Address Handle.
+ * @device: Device to check
+ * @port_num: Port number to check
+ *
+ * RoCE is InfiniBand over Ethernet, and it uses a well defined technique
+ * to fabricate GIDs over Ethernet/IP specific addresses native to the
+ * port.  Normally, packet headers are generated by the sending host
+ * adapter, but when sending connectionless datagrams, we must manually
+ * inject the proper headers for the fabric we are communicating over.
+ *
+ * Return: true if we are running as a RoCE port and must force the
+ * addition of a Global Route Header built from our Ethernet Address
+ * Handle into our header list for connectionless packets.
+ */
+static inline bool rdma_cap_eth_ah(const struct ib_device *device, u8 port_num)
+{
+        return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_ETH_AH;
+}
+
+/**
+ * rdma_cap_read_multi_sge - Check if the port of device has the capability
+ * RDMA Read Multiple Scatter-Gather Entries.
+ * @device: Device to check
+ * @port_num: Port number to check
+ *
+ * iWARP has a restriction that RDMA READ requests may only have a single
+ * Scatter/Gather Entry (SGE) in the work request.
+ *
+ * NOTE: although the linux kernel currently assumes all devices are either
+ * single SGE RDMA READ devices or identical SGE maximums for RDMA READs and
+ * WRITEs, according to Tom Talpey, this is not accurate.  There are some
+ * devices out there that support more than a single SGE on RDMA READ
+ * requests, but do not support the same number of SGEs as they do on
+ * RDMA WRITE requests.  The linux kernel would need rearchitecting to
+ * support these imbalanced READ/WRITE SGEs allowed devices.  So, for now,
+ * suffice with either the device supports the same READ/WRITE SGEs, or
+ * it only gets one READ sge.
+ *
+ * Return: true for any device that allows more than one SGE in RDMA READ
+ * requests.
+ */
+static inline bool rdma_cap_read_multi_sge(struct ib_device *device,
+                                           u8 port_num)
+{
+        return !(device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_PROT_IWARP);
+}
+
+/**
+ * rdma_max_mad_size - Return the max MAD size required by this RDMA Port.
+ *
+ * @device: Device
+ * @port_num: Port number
+ *
+ * This MAD size includes the MAD headers and MAD payload.  No other headers
+ * are included.
+ *
+ * Return the max MAD size required by the Port.  Will return 0 if the port
+ * does not support MADs
+ */
+static inline size_t rdma_max_mad_size(const struct ib_device *device, u8 port_num)
+{
+        return device->port_immutable[port_num].max_mad_size;
+}
+
 int ib_query_gid(struct ib_device *device,
                  u8 port_num, int index, union ib_gid *gid);
 
@@ -1799,8 +2171,9 @@ struct ib_ah *ib_create_ah(struct ib_pd *pd, struct ib_ah_attr *ah_attr);
  * @ah_attr: Returned attributes that can be used when creating an address
  *   handle for replying to the message.
  */
-int ib_init_ah_from_wc(struct ib_device *device, u8 port_num, struct ib_wc *wc,
-                       struct ib_grh *grh, struct ib_ah_attr *ah_attr);
+int ib_init_ah_from_wc(struct ib_device *device, u8 port_num,
+                       const struct ib_wc *wc, const struct ib_grh *grh,
+                       struct ib_ah_attr *ah_attr);
 
 /**
  * ib_create_ah_from_wc - Creates an address handle associated with the
@@ -1814,8 +2187,8 @@ int ib_init_ah_from_wc(struct ib_device *device, u8 port_num, struct ib_wc *wc,
  * The address handle is used to reference a local or global destination
  * in all UD QP post sends.
  */
-struct ib_ah *ib_create_ah_from_wc(struct ib_pd *pd, struct ib_wc *wc,
-                                   struct ib_grh *grh, u8 port_num);
+struct ib_ah *ib_create_ah_from_wc(struct ib_pd *pd, const struct ib_wc *wc,
+                                   const struct ib_grh *grh, u8 port_num);
 
 /**
  * ib_modify_ah - Modifies the address vector associated with an address
@@ -2011,16 +2384,15 @@ static inline int ib_post_recv(struct ib_qp *qp,
  *   asynchronous event not associated with a completion occurs on the CQ.
  * @cq_context: Context associated with the CQ returned to the user via
  *   the associated completion and event handlers.
- * @cqe: The minimum size of the CQ.
- * @comp_vector - Completion vector used to signal completion events.
- *     Must be >= 0 and < context->num_comp_vectors.
+ * @cq_attr: The attributes the CQ should be created upon.
  *
  * Users can examine the cq structure to determine the actual CQ size.
  */
 struct ib_cq *ib_create_cq(struct ib_device *device,
                            ib_comp_handler comp_handler,
                            void (*event_handler)(struct ib_event *, void *),
-                           void *cq_context, int cqe, int comp_vector);
+                           void *cq_context,
+                           const struct ib_cq_init_attr *cq_attr);
 
 /**
  * ib_resize_cq - Modifies the capacity of the CQ.
diff --git a/include/rdma/iw_cm.h b/include/rdma/iw_cm.h
index 1017e0bdf8ba..036bd2772662 100644
--- a/include/rdma/iw_cm.h
+++ b/include/rdma/iw_cm.h
@@ -91,6 +91,7 @@ struct iw_cm_id {
         /* Used by provider to add and remove refs on IW cm_id */
         void (*add_ref)(struct iw_cm_id *);
         void (*rem_ref)(struct iw_cm_id *);
+        u8  tos;
 };
 
 struct iw_cm_conn_param {
diff --git a/include/rdma/opa_smi.h b/include/rdma/opa_smi.h
new file mode 100644
index 000000000000..29063e84c253
--- /dev/null
+++ b/include/rdma/opa_smi.h
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2014 Intel Corporation.  All rights reserved.
+ *
+ * This software is available to you under a choice of one of two
+ * licenses.  You may choose to be licensed under the terms of the GNU
+ * General Public License (GPL) Version 2, available from the file
+ * COPYING in the main directory of this source tree, or the
+ * OpenIB.org BSD license below:
+ *
+ *     Redistribution and use in source and binary forms, with or
+ *     without modification, are permitted provided that the following
+ *     conditions are met:
+ *
+ *      - Redistributions of source code must retain the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer.
+ *
+ *      - Redistributions in binary form must reproduce the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ * 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. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#if !defined(OPA_SMI_H)
+#define OPA_SMI_H
+
+#include <rdma/ib_mad.h>
+#include <rdma/ib_smi.h>
+
+#define OPA_SMP_LID_DATA_SIZE                   2016
+#define OPA_SMP_DR_DATA_SIZE                    1872
+#define OPA_SMP_MAX_PATH_HOPS                   64
+
+#define OPA_SMI_CLASS_VERSION                   0x80
+
+#define OPA_LID_PERMISSIVE                      cpu_to_be32(0xFFFFFFFF)
+
+struct opa_smp {
+        u8      base_version;
+        u8      mgmt_class;
+        u8      class_version;
+        u8      method;
+        __be16  status;
+        u8      hop_ptr;
+        u8      hop_cnt;
+        __be64  tid;
+        __be16  attr_id;
+        __be16  resv;
+        __be32  attr_mod;
+        __be64  mkey;
+        union {
+                struct {
+                        uint8_t data[OPA_SMP_LID_DATA_SIZE];
+                } lid;
+                struct {
+                        __be32  dr_slid;
+                        __be32  dr_dlid;
+                        u8      initial_path[OPA_SMP_MAX_PATH_HOPS];
+                        u8      return_path[OPA_SMP_MAX_PATH_HOPS];
+                        u8      reserved[8];
+                        u8      data[OPA_SMP_DR_DATA_SIZE];
+                } dr;
+        } route;
+} __packed;
+
+
+static inline u8
+opa_get_smp_direction(struct opa_smp *smp)
+{
+        return ib_get_smp_direction((struct ib_smp *)smp);
+}
+
+static inline u8 *opa_get_smp_data(struct opa_smp *smp)
+{
+        if (smp->mgmt_class == IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE)
+                return smp->route.dr.data;
+
+        return smp->route.lid.data;
+}
+
+static inline size_t opa_get_smp_data_size(struct opa_smp *smp)
+{
+        if (smp->mgmt_class == IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE)
+                return sizeof(smp->route.dr.data);
+
+        return sizeof(smp->route.lid.data);
+}
+
+static inline size_t opa_get_smp_header_size(struct opa_smp *smp)
+{
+        if (smp->mgmt_class == IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE)
+                return sizeof(*smp) - sizeof(smp->route.dr.data);
+
+        return sizeof(*smp) - sizeof(smp->route.lid.data);
+}
+
+#endif /* OPA_SMI_H */
diff --git a/include/rdma/rdma_cm.h b/include/rdma/rdma_cm.h
index 1ed2088dc9f5..c92522c192d2 100644
--- a/include/rdma/rdma_cm.h
+++ b/include/rdma/rdma_cm.h
@@ -62,6 +62,8 @@ enum rdma_cm_event_type {
         RDMA_CM_EVENT_TIMEWAIT_EXIT
 };
 
+__attribute_const__ const char *rdma_event_msg(enum rdma_cm_event_type event);
+
 enum rdma_port_space {
         RDMA_PS_SDP   = 0x0001,
         RDMA_PS_IPOIB = 0x0002,
diff --git a/include/scsi/scsi.h b/include/scsi/scsi.h
index d0a66aa1868d..e0a3398b1547 100644
--- a/include/scsi/scsi.h
+++ b/include/scsi/scsi.h
@@ -1,9 +1,6 @@
 /*
  * This header file contains public constants and structures used by
- * the scsi code for linux.
- *
- * For documentation on the OPCODES, MESSAGES, and SENSE values,
- * please consult the SCSI standard.
+ * the SCSI initiator code.
  */
 #ifndef _SCSI_SCSI_H
 #define _SCSI_SCSI_H
@@ -11,6 +8,8 @@
 #include <linux/types.h>
 #include <linux/scatterlist.h>
 #include <linux/kernel.h>
+#include <scsi/scsi_common.h>
+#include <scsi/scsi_proto.h>
 
 struct scsi_cmnd;
 
@@ -49,187 +48,6 @@ enum scsi_timeouts {
  */
 #define SCAN_WILD_CARD  ~0
 
-/*
- *      SCSI opcodes
- */
-
-#define TEST_UNIT_READY       0x00
-#define REZERO_UNIT           0x01
-#define REQUEST_SENSE         0x03
-#define FORMAT_UNIT           0x04
-#define READ_BLOCK_LIMITS     0x05
-#define REASSIGN_BLOCKS       0x07
-#define INITIALIZE_ELEMENT_STATUS 0x07
-#define READ_6                0x08
-#define WRITE_6               0x0a
-#define SEEK_6                0x0b
-#define READ_REVERSE          0x0f
-#define WRITE_FILEMARKS       0x10
-#define SPACE                 0x11
-#define INQUIRY               0x12
-#define RECOVER_BUFFERED_DATA 0x14
-#define MODE_SELECT           0x15
-#define RESERVE               0x16
-#define RELEASE               0x17
-#define COPY                  0x18
-#define ERASE                 0x19
-#define MODE_SENSE            0x1a
-#define START_STOP            0x1b
-#define RECEIVE_DIAGNOSTIC    0x1c
-#define SEND_DIAGNOSTIC       0x1d
-#define ALLOW_MEDIUM_REMOVAL  0x1e
-
-#define READ_FORMAT_CAPACITIES 0x23
-#define SET_WINDOW            0x24
-#define READ_CAPACITY         0x25
-#define READ_10               0x28
-#define WRITE_10              0x2a
-#define SEEK_10               0x2b
-#define POSITION_TO_ELEMENT   0x2b
-#define WRITE_VERIFY          0x2e
-#define VERIFY                0x2f
-#define SEARCH_HIGH           0x30
-#define SEARCH_EQUAL          0x31
-#define SEARCH_LOW            0x32
-#define SET_LIMITS            0x33
-#define PRE_FETCH             0x34
-#define READ_POSITION         0x34
-#define SYNCHRONIZE_CACHE     0x35
-#define LOCK_UNLOCK_CACHE     0x36
-#define READ_DEFECT_DATA      0x37
-#define MEDIUM_SCAN           0x38
-#define COMPARE               0x39
-#define COPY_VERIFY           0x3a
-#define WRITE_BUFFER          0x3b
-#define READ_BUFFER           0x3c
-#define UPDATE_BLOCK          0x3d
-#define READ_LONG             0x3e
-#define WRITE_LONG            0x3f
-#define CHANGE_DEFINITION     0x40
-#define WRITE_SAME            0x41
-#define UNMAP                 0x42
-#define READ_TOC              0x43
-#define READ_HEADER           0x44
-#define GET_EVENT_STATUS_NOTIFICATION 0x4a
-#define LOG_SELECT            0x4c
-#define LOG_SENSE             0x4d
-#define XDWRITEREAD_10        0x53
-#define MODE_SELECT_10        0x55
-#define RESERVE_10            0x56
-#define RELEASE_10            0x57
-#define MODE_SENSE_10         0x5a
-#define PERSISTENT_RESERVE_IN 0x5e
-#define PERSISTENT_RESERVE_OUT 0x5f
-#define VARIABLE_LENGTH_CMD   0x7f
-#define REPORT_LUNS           0xa0
-#define SECURITY_PROTOCOL_IN  0xa2
-#define MAINTENANCE_IN        0xa3
-#define MAINTENANCE_OUT       0xa4
-#define MOVE_MEDIUM           0xa5
-#define EXCHANGE_MEDIUM       0xa6
-#define READ_12               0xa8
-#define SERVICE_ACTION_OUT_12 0xa9
-#define WRITE_12              0xaa
-#define READ_MEDIA_SERIAL_NUMBER 0xab /* Obsolete with SPC-2 */
-#define SERVICE_ACTION_IN_12  0xab
-#define WRITE_VERIFY_12       0xae
-#define VERIFY_12             0xaf
-#define SEARCH_HIGH_12        0xb0
-#define SEARCH_EQUAL_12       0xb1
-#define SEARCH_LOW_12         0xb2
-#define SECURITY_PROTOCOL_OUT 0xb5
-#define READ_ELEMENT_STATUS   0xb8
-#define SEND_VOLUME_TAG       0xb6
-#define WRITE_LONG_2          0xea
-#define EXTENDED_COPY         0x83
-#define RECEIVE_COPY_RESULTS  0x84
-#define ACCESS_CONTROL_IN     0x86
-#define ACCESS_CONTROL_OUT    0x87
-#define READ_16               0x88
-#define COMPARE_AND_WRITE     0x89
-#define WRITE_16              0x8a
-#define READ_ATTRIBUTE        0x8c
-#define WRITE_ATTRIBUTE       0x8d
-#define VERIFY_16             0x8f
-#define SYNCHRONIZE_CACHE_16  0x91
-#define WRITE_SAME_16         0x93
-#define SERVICE_ACTION_BIDIRECTIONAL 0x9d
-#define SERVICE_ACTION_IN_16  0x9e
-#define SERVICE_ACTION_OUT_16 0x9f
-/* values for service action in */
-#define SAI_READ_CAPACITY_16  0x10
-#define SAI_GET_LBA_STATUS    0x12
-#define SAI_REPORT_REFERRALS  0x13
-/* values for VARIABLE_LENGTH_CMD service action codes
- * see spc4r17 Section D.3.5, table D.7 and D.8 */
-#define VLC_SA_RECEIVE_CREDENTIAL 0x1800
-/* values for maintenance in */
-#define MI_REPORT_IDENTIFYING_INFORMATION 0x05
-#define MI_REPORT_TARGET_PGS  0x0a
-#define MI_REPORT_ALIASES     0x0b
-#define MI_REPORT_SUPPORTED_OPERATION_CODES 0x0c
-#define MI_REPORT_SUPPORTED_TASK_MANAGEMENT_FUNCTIONS 0x0d
-#define MI_REPORT_PRIORITY    0x0e
-#define MI_REPORT_TIMESTAMP   0x0f
-#define MI_MANAGEMENT_PROTOCOL_IN 0x10
-/* value for MI_REPORT_TARGET_PGS ext header */
-#define MI_EXT_HDR_PARAM_FMT  0x20
-/* values for maintenance out */
-#define MO_SET_IDENTIFYING_INFORMATION 0x06
-#define MO_SET_TARGET_PGS     0x0a
-#define MO_CHANGE_ALIASES     0x0b
-#define MO_SET_PRIORITY       0x0e
-#define MO_SET_TIMESTAMP      0x0f
-#define MO_MANAGEMENT_PROTOCOL_OUT 0x10
-/* values for variable length command */
-#define XDREAD_32             0x03
-#define XDWRITE_32            0x04
-#define XPWRITE_32            0x06
-#define XDWRITEREAD_32        0x07
-#define READ_32               0x09
-#define VERIFY_32             0x0a
-#define WRITE_32              0x0b
-#define WRITE_SAME_32         0x0d
-
-/* Values for T10/04-262r7 */
-#define ATA_16                0x85      /* 16-byte pass-thru */
-#define ATA_12                0xa1      /* 12-byte pass-thru */
-
-/* Vendor specific CDBs start here */
-#define VENDOR_SPECIFIC_CDB 0xc0
-
-/*
- *      SCSI command lengths
- */
-
-#define SCSI_MAX_VARLEN_CDB_SIZE 260
-
-/* defined in T10 SCSI Primary Commands-2 (SPC2) */
-struct scsi_varlen_cdb_hdr {
-        __u8 opcode;        /* opcode always == VARIABLE_LENGTH_CMD */
-        __u8 control;
-        __u8 misc[5];
-        __u8 additional_cdb_length;         /* total cdb length - 8 */
-        __be16 service_action;
-        /* service specific data follows */
-};
-
-static inline unsigned
-scsi_varlen_cdb_length(const void *hdr)
-{
-        return ((struct scsi_varlen_cdb_hdr *)hdr)->additional_cdb_length + 8;
-}
-
-extern const unsigned char scsi_command_size_tbl[8];
-#define COMMAND_SIZE(opcode) scsi_command_size_tbl[((opcode) >> 5) & 7]
-
-static inline unsigned
-scsi_command_size(const unsigned char *cmnd)
-{
-        return (cmnd[0] == VARIABLE_LENGTH_CMD) ?
-                scsi_varlen_cdb_length(cmnd) : COMMAND_SIZE(cmnd[0]);
-}
-
 #ifdef CONFIG_ACPI
 struct acpi_bus_type;
 
@@ -240,22 +58,6 @@ extern void
 scsi_unregister_acpi_bus_type(struct acpi_bus_type *bus);
 #endif
 
-/*
- *  SCSI Architecture Model (SAM) Status codes. Taken from SAM-3 draft
- *  T10/1561-D Revision 4 Draft dated 7th November 2002.
- */
-#define SAM_STAT_GOOD            0x00
-#define SAM_STAT_CHECK_CONDITION 0x02
-#define SAM_STAT_CONDITION_MET   0x04
-#define SAM_STAT_BUSY            0x08
-#define SAM_STAT_INTERMEDIATE    0x10
-#define SAM_STAT_INTERMEDIATE_CONDITION_MET 0x14
-#define SAM_STAT_RESERVATION_CONFLICT 0x18
-#define SAM_STAT_COMMAND_TERMINATED 0x22        /* obsolete in SAM-3 */
-#define SAM_STAT_TASK_SET_FULL   0x28
-#define SAM_STAT_ACA_ACTIVE      0x30
-#define SAM_STAT_TASK_ABORTED    0x40
-
 /** scsi_status_is_good - check the status return.
  *
  * @status: the status passed up from the driver (including host and
@@ -279,86 +81,6 @@ static inline int scsi_status_is_good(int status)
                 (status == SAM_STAT_COMMAND_TERMINATED));
 }
 
-/*
- *  Status codes. These are deprecated as they are shifted 1 bit right
- *  from those found in the SCSI standards. This causes confusion for
- *  applications that are ported to several OSes. Prefer SAM Status codes
- *  above.
- */
-
-#define GOOD                 0x00
-#define CHECK_CONDITION      0x01
-#define CONDITION_GOOD       0x02
-#define BUSY                 0x04
-#define INTERMEDIATE_GOOD    0x08
-#define INTERMEDIATE_C_GOOD  0x0a
-#define RESERVATION_CONFLICT 0x0c
-#define COMMAND_TERMINATED   0x11
-#define QUEUE_FULL           0x14
-#define ACA_ACTIVE           0x18
-#define TASK_ABORTED         0x20
-
-#define STATUS_MASK          0xfe
-
-/*
- *  SENSE KEYS
- */
-
-#define NO_SENSE            0x00
-#define RECOVERED_ERROR     0x01
-#define NOT_READY           0x02
-#define MEDIUM_ERROR        0x03
-#define HARDWARE_ERROR      0x04
-#define ILLEGAL_REQUEST     0x05
-#define UNIT_ATTENTION      0x06
-#define DATA_PROTECT        0x07
-#define BLANK_CHECK         0x08
-#define COPY_ABORTED        0x0a
-#define ABORTED_COMMAND     0x0b
-#define VOLUME_OVERFLOW     0x0d
-#define MISCOMPARE          0x0e
-
-
-/*
- *  DEVICE TYPES
- *  Please keep them in 0x%02x format for $MODALIAS to work
- */
-
-#define TYPE_DISK           0x00
-#define TYPE_TAPE           0x01
-#define TYPE_PRINTER        0x02
-#define TYPE_PROCESSOR      0x03    /* HP scanners use this */
-#define TYPE_WORM           0x04    /* Treated as ROM by our system */
-#define TYPE_ROM            0x05
-#define TYPE_SCANNER        0x06
-#define TYPE_MOD            0x07    /* Magneto-optical disk - 
-                                     * - treated as TYPE_DISK */
-#define TYPE_MEDIUM_CHANGER 0x08
-#define TYPE_COMM           0x09    /* Communications device */
-#define TYPE_RAID           0x0c
-#define TYPE_ENCLOSURE      0x0d    /* Enclosure Services Device */
-#define TYPE_RBC            0x0e
-#define TYPE_OSD            0x11
-#define TYPE_ZBC            0x14
-#define TYPE_WLUN           0x1e    /* well-known logical unit */
-#define TYPE_NO_LUN         0x7f
-
-/* SCSI protocols; these are taken from SPC-3 section 7.5 */
-enum scsi_protocol {
-        SCSI_PROTOCOL_FCP = 0,  /* Fibre Channel */
-        SCSI_PROTOCOL_SPI = 1,  /* parallel SCSI */
-        SCSI_PROTOCOL_SSA = 2,  /* Serial Storage Architecture - Obsolete */
-        SCSI_PROTOCOL_SBP = 3,  /* firewire */
-        SCSI_PROTOCOL_SRP = 4,  /* Infiniband RDMA */
-        SCSI_PROTOCOL_ISCSI = 5,
-        SCSI_PROTOCOL_SAS = 6,
-        SCSI_PROTOCOL_ADT = 7,  /* Media Changers */
-        SCSI_PROTOCOL_ATA = 8,
-        SCSI_PROTOCOL_UNSPEC = 0xf, /* No specific protocol */
-};
-
-/* Returns a human-readable name for the device */
-extern const char * scsi_device_type(unsigned type);
 
 /*
  * standard mode-select header prepended to all mode-select commands
@@ -380,13 +102,6 @@ struct ccs_modesel_head {
 };
 
 /*
- * ScsiLun: 8 byte LUN.
- */
-struct scsi_lun {
-        __u8 scsi_lun[8];
-};
-
-/*
  * The Well Known LUNS (SAM-3) in our int representation of a LUN
  */
 #define SCSI_W_LUN_BASE 0xc100
diff --git a/include/scsi/scsi_common.h b/include/scsi/scsi_common.h
new file mode 100644
index 000000000000..676b03b78e57
--- /dev/null
+++ b/include/scsi/scsi_common.h
@@ -0,0 +1,64 @@
+/*
+ * Functions used by both the SCSI initiator code and the SCSI target code.
+ */
+
+#ifndef _SCSI_COMMON_H_
+#define _SCSI_COMMON_H_
+
+#include <linux/types.h>
+#include <scsi/scsi_proto.h>
+
+static inline unsigned
+scsi_varlen_cdb_length(const void *hdr)
+{
+        return ((struct scsi_varlen_cdb_hdr *)hdr)->additional_cdb_length + 8;
+}
+
+extern const unsigned char scsi_command_size_tbl[8];
+#define COMMAND_SIZE(opcode) scsi_command_size_tbl[((opcode) >> 5) & 7]
+
+static inline unsigned
+scsi_command_size(const unsigned char *cmnd)
+{
+        return (cmnd[0] == VARIABLE_LENGTH_CMD) ?
+                scsi_varlen_cdb_length(cmnd) : COMMAND_SIZE(cmnd[0]);
+}
+
+/* Returns a human-readable name for the device */
+extern const char *scsi_device_type(unsigned type);
+
+extern void int_to_scsilun(u64, struct scsi_lun *);
+extern u64 scsilun_to_int(struct scsi_lun *);
+
+/*
+ * This is a slightly modified SCSI sense "descriptor" format header.
+ * The addition is to allow the 0x70 and 0x71 response codes. The idea
+ * is to place the salient data from either "fixed" or "descriptor" sense
+ * format into one structure to ease application processing.
+ *
+ * The original sense buffer should be kept around for those cases
+ * in which more information is required (e.g. the LBA of a MEDIUM ERROR).
+ */
+struct scsi_sense_hdr {         /* See SPC-3 section 4.5 */
+        u8 response_code;       /* permit: 0x0, 0x70, 0x71, 0x72, 0x73 */
+        u8 sense_key;
+        u8 asc;
+        u8 ascq;
+        u8 byte4;
+        u8 byte5;
+        u8 byte6;
+        u8 additional_length;   /* always 0 for fixed sense format */
+};
+
+static inline bool scsi_sense_valid(const struct scsi_sense_hdr *sshdr)
+{
+        if (!sshdr)
+                return false;
+
+        return (sshdr->response_code & 0x70) == 0x70;
+}
+
+extern bool scsi_normalize_sense(const u8 *sense_buffer, int sb_len,
+                                 struct scsi_sense_hdr *sshdr);
+
+#endif /* _SCSI_COMMON_H_ */
diff --git a/include/scsi/scsi_device.h b/include/scsi/scsi_device.h
index a4c9336811d1..ae84b2214d40 100644
--- a/include/scsi/scsi_device.h
+++ b/include/scsi/scsi_device.h
@@ -413,8 +413,6 @@ extern void scsi_target_reap(struct scsi_target *);
 extern void scsi_target_block(struct device *);
 extern void scsi_target_unblock(struct device *, enum scsi_device_state);
 extern void scsi_remove_target(struct device *);
-extern void int_to_scsilun(u64, struct scsi_lun *);
-extern u64 scsilun_to_int(struct scsi_lun *);
 extern const char *scsi_device_state_name(enum scsi_device_state);
 extern int scsi_is_sdev_device(const struct device *);
 extern int scsi_is_target_device(const struct device *);
diff --git a/include/scsi/scsi_eh.h b/include/scsi/scsi_eh.h
index 5a4bb5bb66b3..4942710ef720 100644
--- a/include/scsi/scsi_eh.h
+++ b/include/scsi/scsi_eh.h
@@ -7,43 +7,12 @@
 struct scsi_device;
 struct Scsi_Host;
 
-/*
- * This is a slightly modified SCSI sense "descriptor" format header.
- * The addition is to allow the 0x70 and 0x71 response codes. The idea
- * is to place the salient data from either "fixed" or "descriptor" sense
- * format into one structure to ease application processing.
- *
- * The original sense buffer should be kept around for those cases
- * in which more information is required (e.g. the LBA of a MEDIUM ERROR).
- */
-struct scsi_sense_hdr {         /* See SPC-3 section 4.5 */
-        u8 response_code;       /* permit: 0x0, 0x70, 0x71, 0x72, 0x73 */
-        u8 sense_key;
-        u8 asc;
-        u8 ascq;
-        u8 byte4;
-        u8 byte5;
-        u8 byte6;
-        u8 additional_length;   /* always 0 for fixed sense format */
-};
-
-static inline bool scsi_sense_valid(const struct scsi_sense_hdr *sshdr)
-{
-        if (!sshdr)
-                return false;
-
-        return (sshdr->response_code & 0x70) == 0x70;
-}
-
-
 extern void scsi_eh_finish_cmd(struct scsi_cmnd *scmd,
                                struct list_head *done_q);
 extern void scsi_eh_flush_done_q(struct list_head *done_q);
 extern void scsi_report_bus_reset(struct Scsi_Host *, int);
 extern void scsi_report_device_reset(struct Scsi_Host *, int, int);
 extern int scsi_block_when_processing_errors(struct scsi_device *);
-extern bool scsi_normalize_sense(const u8 *sense_buffer, int sb_len,
-                                 struct scsi_sense_hdr *sshdr);
 extern bool scsi_command_normalize_sense(const struct scsi_cmnd *cmd,
                                          struct scsi_sense_hdr *sshdr);
 
diff --git a/include/scsi/scsi_proto.h b/include/scsi/scsi_proto.h
new file mode 100644
index 000000000000..a9fbf1b38e71
--- /dev/null
+++ b/include/scsi/scsi_proto.h
@@ -0,0 +1,281 @@
+/*
+ * This header file contains public constants and structures used by
+ * both the SCSI initiator and the SCSI target code.
+ *
+ * For documentation on the OPCODES, MESSAGES, and SENSE values,
+ * please consult the SCSI standard.
+ */
+
+#ifndef _SCSI_PROTO_H_
+#define _SCSI_PROTO_H_
+
+#include <linux/types.h>
+
+/*
+ *      SCSI opcodes
+ */
+
+#define TEST_UNIT_READY       0x00
+#define REZERO_UNIT           0x01
+#define REQUEST_SENSE         0x03
+#define FORMAT_UNIT           0x04
+#define READ_BLOCK_LIMITS     0x05
+#define REASSIGN_BLOCKS       0x07
+#define INITIALIZE_ELEMENT_STATUS 0x07
+#define READ_6                0x08
+#define WRITE_6               0x0a
+#define SEEK_6                0x0b
+#define READ_REVERSE          0x0f
+#define WRITE_FILEMARKS       0x10
+#define SPACE                 0x11
+#define INQUIRY               0x12
+#define RECOVER_BUFFERED_DATA 0x14
+#define MODE_SELECT           0x15
+#define RESERVE               0x16
+#define RELEASE               0x17
+#define COPY                  0x18
+#define ERASE                 0x19
+#define MODE_SENSE            0x1a
+#define START_STOP            0x1b
+#define RECEIVE_DIAGNOSTIC    0x1c
+#define SEND_DIAGNOSTIC       0x1d
+#define ALLOW_MEDIUM_REMOVAL  0x1e
+
+#define READ_FORMAT_CAPACITIES 0x23
+#define SET_WINDOW            0x24
+#define READ_CAPACITY         0x25
+#define READ_10               0x28
+#define WRITE_10              0x2a
+#define SEEK_10               0x2b
+#define POSITION_TO_ELEMENT   0x2b
+#define WRITE_VERIFY          0x2e
+#define VERIFY                0x2f
+#define SEARCH_HIGH           0x30
+#define SEARCH_EQUAL          0x31
+#define SEARCH_LOW            0x32
+#define SET_LIMITS            0x33
+#define PRE_FETCH             0x34
+#define READ_POSITION         0x34
+#define SYNCHRONIZE_CACHE     0x35
+#define LOCK_UNLOCK_CACHE     0x36
+#define READ_DEFECT_DATA      0x37
+#define MEDIUM_SCAN           0x38
+#define COMPARE               0x39
+#define COPY_VERIFY           0x3a
+#define WRITE_BUFFER          0x3b
+#define READ_BUFFER           0x3c
+#define UPDATE_BLOCK          0x3d
+#define READ_LONG             0x3e
+#define WRITE_LONG            0x3f
+#define CHANGE_DEFINITION     0x40
+#define WRITE_SAME            0x41
+#define UNMAP                 0x42
+#define READ_TOC              0x43
+#define READ_HEADER           0x44
+#define GET_EVENT_STATUS_NOTIFICATION 0x4a
+#define LOG_SELECT            0x4c
+#define LOG_SENSE             0x4d
+#define XDWRITEREAD_10        0x53
+#define MODE_SELECT_10        0x55
+#define RESERVE_10            0x56
+#define RELEASE_10            0x57
+#define MODE_SENSE_10         0x5a
+#define PERSISTENT_RESERVE_IN 0x5e
+#define PERSISTENT_RESERVE_OUT 0x5f
+#define VARIABLE_LENGTH_CMD   0x7f
+#define REPORT_LUNS           0xa0
+#define SECURITY_PROTOCOL_IN  0xa2
+#define MAINTENANCE_IN        0xa3
+#define MAINTENANCE_OUT       0xa4
+#define MOVE_MEDIUM           0xa5
+#define EXCHANGE_MEDIUM       0xa6
+#define READ_12               0xa8
+#define SERVICE_ACTION_OUT_12 0xa9
+#define WRITE_12              0xaa
+#define READ_MEDIA_SERIAL_NUMBER 0xab /* Obsolete with SPC-2 */
+#define SERVICE_ACTION_IN_12  0xab
+#define WRITE_VERIFY_12       0xae
+#define VERIFY_12             0xaf
+#define SEARCH_HIGH_12        0xb0
+#define SEARCH_EQUAL_12       0xb1
+#define SEARCH_LOW_12         0xb2
+#define SECURITY_PROTOCOL_OUT 0xb5
+#define READ_ELEMENT_STATUS   0xb8
+#define SEND_VOLUME_TAG       0xb6
+#define WRITE_LONG_2          0xea
+#define EXTENDED_COPY         0x83
+#define RECEIVE_COPY_RESULTS  0x84
+#define ACCESS_CONTROL_IN     0x86
+#define ACCESS_CONTROL_OUT    0x87
+#define READ_16               0x88
+#define COMPARE_AND_WRITE     0x89
+#define WRITE_16              0x8a
+#define READ_ATTRIBUTE        0x8c
+#define WRITE_ATTRIBUTE       0x8d
+#define VERIFY_16             0x8f
+#define SYNCHRONIZE_CACHE_16  0x91
+#define WRITE_SAME_16         0x93
+#define SERVICE_ACTION_BIDIRECTIONAL 0x9d
+#define SERVICE_ACTION_IN_16  0x9e
+#define SERVICE_ACTION_OUT_16 0x9f
+/* values for service action in */
+#define SAI_READ_CAPACITY_16  0x10
+#define SAI_GET_LBA_STATUS    0x12
+#define SAI_REPORT_REFERRALS  0x13
+/* values for VARIABLE_LENGTH_CMD service action codes
+ * see spc4r17 Section D.3.5, table D.7 and D.8 */
+#define VLC_SA_RECEIVE_CREDENTIAL 0x1800
+/* values for maintenance in */
+#define MI_REPORT_IDENTIFYING_INFORMATION 0x05
+#define MI_REPORT_TARGET_PGS  0x0a
+#define MI_REPORT_ALIASES     0x0b
+#define MI_REPORT_SUPPORTED_OPERATION_CODES 0x0c
+#define MI_REPORT_SUPPORTED_TASK_MANAGEMENT_FUNCTIONS 0x0d
+#define MI_REPORT_PRIORITY    0x0e
+#define MI_REPORT_TIMESTAMP   0x0f
+#define MI_MANAGEMENT_PROTOCOL_IN 0x10
+/* value for MI_REPORT_TARGET_PGS ext header */
+#define MI_EXT_HDR_PARAM_FMT  0x20
+/* values for maintenance out */
+#define MO_SET_IDENTIFYING_INFORMATION 0x06
+#define MO_SET_TARGET_PGS     0x0a
+#define MO_CHANGE_ALIASES     0x0b
+#define MO_SET_PRIORITY       0x0e
+#define MO_SET_TIMESTAMP      0x0f
+#define MO_MANAGEMENT_PROTOCOL_OUT 0x10
+/* values for variable length command */
+#define XDREAD_32             0x03
+#define XDWRITE_32            0x04
+#define XPWRITE_32            0x06
+#define XDWRITEREAD_32        0x07
+#define READ_32               0x09
+#define VERIFY_32             0x0a
+#define WRITE_32              0x0b
+#define WRITE_SAME_32         0x0d
+
+/* Values for T10/04-262r7 */
+#define ATA_16                0x85      /* 16-byte pass-thru */
+#define ATA_12                0xa1      /* 12-byte pass-thru */
+
+/* Vendor specific CDBs start here */
+#define VENDOR_SPECIFIC_CDB 0xc0
+
+/*
+ *      SCSI command lengths
+ */
+
+#define SCSI_MAX_VARLEN_CDB_SIZE 260
+
+/* defined in T10 SCSI Primary Commands-2 (SPC2) */
+struct scsi_varlen_cdb_hdr {
+        __u8 opcode;        /* opcode always == VARIABLE_LENGTH_CMD */
+        __u8 control;
+        __u8 misc[5];
+        __u8 additional_cdb_length;         /* total cdb length - 8 */
+        __be16 service_action;
+        /* service specific data follows */
+};
+
+/*
+ *  SCSI Architecture Model (SAM) Status codes. Taken from SAM-3 draft
+ *  T10/1561-D Revision 4 Draft dated 7th November 2002.
+ */
+#define SAM_STAT_GOOD            0x00
+#define SAM_STAT_CHECK_CONDITION 0x02
+#define SAM_STAT_CONDITION_MET   0x04
+#define SAM_STAT_BUSY            0x08
+#define SAM_STAT_INTERMEDIATE    0x10
+#define SAM_STAT_INTERMEDIATE_CONDITION_MET 0x14
+#define SAM_STAT_RESERVATION_CONFLICT 0x18
+#define SAM_STAT_COMMAND_TERMINATED 0x22        /* obsolete in SAM-3 */
+#define SAM_STAT_TASK_SET_FULL   0x28
+#define SAM_STAT_ACA_ACTIVE      0x30
+#define SAM_STAT_TASK_ABORTED    0x40
+
+/*
+ *  Status codes. These are deprecated as they are shifted 1 bit right
+ *  from those found in the SCSI standards. This causes confusion for
+ *  applications that are ported to several OSes. Prefer SAM Status codes
+ *  above.
+ */
+
+#define GOOD                 0x00
+#define CHECK_CONDITION      0x01
+#define CONDITION_GOOD       0x02
+#define BUSY                 0x04
+#define INTERMEDIATE_GOOD    0x08
+#define INTERMEDIATE_C_GOOD  0x0a
+#define RESERVATION_CONFLICT 0x0c
+#define COMMAND_TERMINATED   0x11
+#define QUEUE_FULL           0x14
+#define ACA_ACTIVE           0x18
+#define TASK_ABORTED         0x20
+
+#define STATUS_MASK          0xfe
+
+/*
+ *  SENSE KEYS
+ */
+
+#define NO_SENSE            0x00
+#define RECOVERED_ERROR     0x01
+#define NOT_READY           0x02
+#define MEDIUM_ERROR        0x03
+#define HARDWARE_ERROR      0x04
+#define ILLEGAL_REQUEST     0x05
+#define UNIT_ATTENTION      0x06
+#define DATA_PROTECT        0x07
+#define BLANK_CHECK         0x08
+#define COPY_ABORTED        0x0a
+#define ABORTED_COMMAND     0x0b
+#define VOLUME_OVERFLOW     0x0d
+#define MISCOMPARE          0x0e
+
+
+/*
+ *  DEVICE TYPES
+ *  Please keep them in 0x%02x format for $MODALIAS to work
+ */
+
+#define TYPE_DISK           0x00
+#define TYPE_TAPE           0x01
+#define TYPE_PRINTER        0x02
+#define TYPE_PROCESSOR      0x03    /* HP scanners use this */
+#define TYPE_WORM           0x04    /* Treated as ROM by our system */
+#define TYPE_ROM            0x05
+#define TYPE_SCANNER        0x06
+#define TYPE_MOD            0x07    /* Magneto-optical disk -
+                                     * - treated as TYPE_DISK */
+#define TYPE_MEDIUM_CHANGER 0x08
+#define TYPE_COMM           0x09    /* Communications device */
+#define TYPE_RAID           0x0c
+#define TYPE_ENCLOSURE      0x0d    /* Enclosure Services Device */
+#define TYPE_RBC            0x0e
+#define TYPE_OSD            0x11
+#define TYPE_ZBC            0x14
+#define TYPE_WLUN           0x1e    /* well-known logical unit */
+#define TYPE_NO_LUN         0x7f
+
+/* SCSI protocols; these are taken from SPC-3 section 7.5 */
+enum scsi_protocol {
+        SCSI_PROTOCOL_FCP = 0,  /* Fibre Channel */
+        SCSI_PROTOCOL_SPI = 1,  /* parallel SCSI */
+        SCSI_PROTOCOL_SSA = 2,  /* Serial Storage Architecture - Obsolete */
+        SCSI_PROTOCOL_SBP = 3,  /* firewire */
+        SCSI_PROTOCOL_SRP = 4,  /* Infiniband RDMA */
+        SCSI_PROTOCOL_ISCSI = 5,
+        SCSI_PROTOCOL_SAS = 6,
+        SCSI_PROTOCOL_ADT = 7,  /* Media Changers */
+        SCSI_PROTOCOL_ATA = 8,
+        SCSI_PROTOCOL_UNSPEC = 0xf, /* No specific protocol */
+};
+
+/*
+ * ScsiLun: 8 byte LUN.
+ */
+struct scsi_lun {
+        __u8 scsi_lun[8];
+};
+
+
+#endif /* _SCSI_PROTO_H_ */
diff --git a/include/scsi/scsi_transport_srp.h b/include/scsi/scsi_transport_srp.h
index cdb05dd1d440..d40d3ef25707 100644
--- a/include/scsi/scsi_transport_srp.h
+++ b/include/scsi/scsi_transport_srp.h
@@ -119,6 +119,7 @@ extern struct srp_rport *srp_rport_add(struct Scsi_Host *,
 extern void srp_rport_del(struct srp_rport *);
 extern int srp_tmo_valid(int reconnect_delay, int fast_io_fail_tmo,
                          int dev_loss_tmo);
+int srp_parse_tmo(int *tmo, const char *buf);
 extern int srp_reconnect_rport(struct srp_rport *rport);
 extern void srp_start_tl_fail_timers(struct srp_rport *rport);
 extern void srp_remove_host(struct Scsi_Host *);
diff --git a/include/scsi/srp.h b/include/scsi/srp.h
index 1ae84db4c9fb..5be834de491a 100644
--- a/include/scsi/srp.h
+++ b/include/scsi/srp.h
@@ -42,6 +42,7 @@
  */
 
 #include <linux/types.h>
+#include <scsi/scsi.h>
 
 enum {
         SRP_LOGIN_REQ   = 0x00,
@@ -179,7 +180,7 @@ struct srp_tsk_mgmt {
         u8      reserved1[6];
         u64     tag;
         u8      reserved2[4];
-        __be64  lun __attribute__((packed));
+        struct scsi_lun lun;
         u8      reserved3[2];
         u8      tsk_mgmt_func;
         u8      reserved4;
@@ -200,7 +201,7 @@ struct srp_cmd {
         u8      data_in_desc_cnt;
         u64     tag;
         u8      reserved2[4];
-        __be64  lun __attribute__((packed));
+        struct scsi_lun lun;
         u8      reserved3;
         u8      task_attr;
         u8      reserved4;
@@ -265,7 +266,7 @@ struct srp_aer_req {
         __be32  req_lim_delta;
         u64     tag;
         u32     reserved2;
-        __be64  lun;
+        struct scsi_lun lun;
         __be32  sense_data_len;
         u32     reserved3;
         u8      sense_data[0];
diff --git a/include/soc/at91/at91rm9200_sdramc.h b/include/soc/at91/at91rm9200_sdramc.h
deleted file mode 100644
index aa047f458f1b..000000000000
--- a/include/soc/at91/at91rm9200_sdramc.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * arch/arm/mach-at91/include/mach/at91rm9200_sdramc.h
- *
- * Copyright (C) 2005 Ivan Kokshaysky
- * Copyright (C) SAN People
- *
- * Memory Controllers (SDRAMC only) - System peripherals registers.
- * Based on AT91RM9200 datasheet revision E.
- *
- * 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 AT91RM9200_SDRAMC_H
-#define AT91RM9200_SDRAMC_H
-
-/* SDRAM Controller registers */
-#define AT91RM9200_SDRAMC_MR            0x90                    /* Mode Register */
-#define         AT91RM9200_SDRAMC_MODE  (0xf << 0)              /* Command Mode */
-#define                 AT91RM9200_SDRAMC_MODE_NORMAL           (0 << 0)
-#define                 AT91RM9200_SDRAMC_MODE_NOP              (1 << 0)
-#define                 AT91RM9200_SDRAMC_MODE_PRECHARGE        (2 << 0)
-#define                 AT91RM9200_SDRAMC_MODE_LMR              (3 << 0)
-#define                 AT91RM9200_SDRAMC_MODE_REFRESH  (4 << 0)
-#define         AT91RM9200_SDRAMC_DBW           (1   << 4)              /* Data Bus Width */
-#define                 AT91RM9200_SDRAMC_DBW_32        (0 << 4)
-#define                 AT91RM9200_SDRAMC_DBW_16        (1 << 4)
-
-#define AT91RM9200_SDRAMC_TR            0x94                    /* Refresh Timer Register */
-#define         AT91RM9200_SDRAMC_COUNT (0xfff << 0)            /* Refresh Timer Count */
-
-#define AT91RM9200_SDRAMC_CR            0x98                    /* Configuration Register */
-#define         AT91RM9200_SDRAMC_NC            (3   <<  0)             /* Number of Column Bits */
-#define                 AT91RM9200_SDRAMC_NC_8  (0 << 0)
-#define                 AT91RM9200_SDRAMC_NC_9  (1 << 0)
-#define                 AT91RM9200_SDRAMC_NC_10 (2 << 0)
-#define                 AT91RM9200_SDRAMC_NC_11 (3 << 0)
-#define         AT91RM9200_SDRAMC_NR            (3   <<  2)             /* Number of Row Bits */
-#define                 AT91RM9200_SDRAMC_NR_11 (0 << 2)
-#define                 AT91RM9200_SDRAMC_NR_12 (1 << 2)
-#define                 AT91RM9200_SDRAMC_NR_13 (2 << 2)
-#define         AT91RM9200_SDRAMC_NB            (1   <<  4)             /* Number of Banks */
-#define                 AT91RM9200_SDRAMC_NB_2  (0 << 4)
-#define                 AT91RM9200_SDRAMC_NB_4  (1 << 4)
-#define         AT91RM9200_SDRAMC_CAS           (3   <<  5)             /* CAS Latency */
-#define                 AT91RM9200_SDRAMC_CAS_2 (2 << 5)
-#define         AT91RM9200_SDRAMC_TWR           (0xf <<  7)             /* Write Recovery Delay */
-#define         AT91RM9200_SDRAMC_TRC           (0xf << 11)             /* Row Cycle Delay */
-#define         AT91RM9200_SDRAMC_TRP           (0xf << 15)             /* Row Precharge Delay */
-#define         AT91RM9200_SDRAMC_TRCD  (0xf << 19)             /* Row to Column Delay */
-#define         AT91RM9200_SDRAMC_TRAS  (0xf << 23)             /* Active to Precharge Delay */
-#define         AT91RM9200_SDRAMC_TXSR  (0xf << 27)             /* Exit Self Refresh to Active Delay */
-
-#define AT91RM9200_SDRAMC_SRR           0x9c                    /* Self Refresh Register */
-#define AT91RM9200_SDRAMC_LPR           0xa0                    /* Low Power Register */
-#define AT91RM9200_SDRAMC_IER           0xa4                    /* Interrupt Enable Register */
-#define AT91RM9200_SDRAMC_IDR           0xa8                    /* Interrupt Disable Register */
-#define AT91RM9200_SDRAMC_IMR           0xac                    /* Interrupt Mask Register */
-#define AT91RM9200_SDRAMC_ISR           0xb0                    /* Interrupt Status Register */
-
-#endif
diff --git a/include/soc/imx/revision.h b/include/soc/imx/revision.h
new file mode 100644
index 000000000000..9ea346924c35
--- /dev/null
+++ b/include/soc/imx/revision.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2015 Linaro Ltd.
+ *
+ * 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 __SOC_IMX_REVISION_H__
+#define __SOC_IMX_REVISION_H__
+
+#define IMX_CHIP_REVISION_1_0           0x10
+#define IMX_CHIP_REVISION_1_1           0x11
+#define IMX_CHIP_REVISION_1_2           0x12
+#define IMX_CHIP_REVISION_1_3           0x13
+#define IMX_CHIP_REVISION_1_4           0x14
+#define IMX_CHIP_REVISION_1_5           0x15
+#define IMX_CHIP_REVISION_2_0           0x20
+#define IMX_CHIP_REVISION_2_1           0x21
+#define IMX_CHIP_REVISION_2_2           0x22
+#define IMX_CHIP_REVISION_2_3           0x23
+#define IMX_CHIP_REVISION_3_0           0x30
+#define IMX_CHIP_REVISION_3_1           0x31
+#define IMX_CHIP_REVISION_3_2           0x32
+#define IMX_CHIP_REVISION_3_3           0x33
+#define IMX_CHIP_REVISION_UNKNOWN       0xff
+
+int mx27_revision(void);
+int mx31_revision(void);
+int mx35_revision(void);
+int mx51_revision(void);
+int mx53_revision(void);
+
+unsigned int imx_get_soc_revision(void);
+void imx_print_silicon_rev(const char *cpu, int srev);
+
+#endif /* __SOC_IMX_REVISION_H__ */
diff --git a/include/soc/imx/timer.h b/include/soc/imx/timer.h
new file mode 100644
index 000000000000..bbbafd65f464
--- /dev/null
+++ b/include/soc/imx/timer.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2015 Linaro Ltd.
+ *
+ * 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 __SOC_IMX_TIMER_H__
+#define __SOC_IMX_TIMER_H__
+
+enum imx_gpt_type {
+        GPT_TYPE_IMX1,          /* i.MX1 */
+        GPT_TYPE_IMX21,         /* i.MX21/27 */
+        GPT_TYPE_IMX31,         /* i.MX31/35/25/37/51/6Q */
+        GPT_TYPE_IMX6DL,        /* i.MX6DL/SX/SL */
+};
+
+/*
+ * This is a stop-gap solution for clock drivers like imx1/imx21 which call
+ * mxc_timer_init() to initialize timer for non-DT boot.  It can be removed
+ * when these legacy non-DT support is converted or dropped.
+ */
+void mxc_timer_init(unsigned long pbase, int irq, enum imx_gpt_type type);
+
+#endif  /* __SOC_IMX_TIMER_H__ */
diff --git a/include/soc/sa1100/pwer.h b/include/soc/sa1100/pwer.h
new file mode 100644
index 000000000000..15a545b5a1f6
--- /dev/null
+++ b/include/soc/sa1100/pwer.h
@@ -0,0 +1,15 @@
+#ifndef SOC_SA1100_PWER_H
+#define SOC_SA1100_PWER_H
+
+/*
+ * Copyright (C) 2015, Dmitry Eremin-Solenikov
+ *
+ * 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.
+ */
+
+int sa11x0_gpio_set_wake(unsigned int gpio, unsigned int on);
+int sa11x0_sc_set_wake(unsigned int irq, unsigned int on);
+
+#endif
diff --git a/include/soc/tegra/emc.h b/include/soc/tegra/emc.h
new file mode 100644
index 000000000000..f6db33b579ec
--- /dev/null
+++ b/include/soc/tegra/emc.h
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2014 NVIDIA Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef __SOC_TEGRA_EMC_H__
+#define __SOC_TEGRA_EMC_H__
+
+struct tegra_emc;
+
+int tegra_emc_prepare_timing_change(struct tegra_emc *emc,
+                                    unsigned long rate);
+void tegra_emc_complete_timing_change(struct tegra_emc *emc,
+                                      unsigned long rate);
+
+#endif /* __SOC_TEGRA_EMC_H__ */
diff --git a/include/soc/tegra/fuse.h b/include/soc/tegra/fuse.h
index b5f7b5f8d008..b019e3465f11 100644
--- a/include/soc/tegra/fuse.h
+++ b/include/soc/tegra/fuse.h
@@ -56,6 +56,7 @@ struct tegra_sku_info {
 };
 
 u32 tegra_read_straps(void);
+u32 tegra_read_ram_code(void);
 u32 tegra_read_chipid(void);
 int tegra_fuse_readl(unsigned long offset, u32 *value);
 
diff --git a/include/soc/tegra/mc.h b/include/soc/tegra/mc.h
index 63deb8d9f82a..1ab2813273cd 100644
--- a/include/soc/tegra/mc.h
+++ b/include/soc/tegra/mc.h
@@ -20,6 +20,12 @@ struct tegra_smmu_enable {
         unsigned int bit;
 };
 
+struct tegra_mc_timing {
+        unsigned long rate;
+
+        u32 *emem_data;
+};
+
 /* latency allowance */
 struct tegra_mc_la {
         unsigned int reg;
@@ -40,6 +46,7 @@ struct tegra_mc_client {
 };
 
 struct tegra_smmu_swgroup {
+        const char *name;
         unsigned int swgroup;
         unsigned int reg;
 };
@@ -71,6 +78,7 @@ struct tegra_smmu;
 struct tegra_smmu *tegra_smmu_probe(struct device *dev,
                                     const struct tegra_smmu_soc *soc,
                                     struct tegra_mc *mc);
+void tegra_smmu_remove(struct tegra_smmu *smmu);
 #else
 static inline struct tegra_smmu *
 tegra_smmu_probe(struct device *dev, const struct tegra_smmu_soc *soc,
@@ -78,13 +86,17 @@ tegra_smmu_probe(struct device *dev, const struct tegra_smmu_soc *soc,
 {
         return NULL;
 }
+
+static inline void tegra_smmu_remove(struct tegra_smmu *smmu)
+{
+}
 #endif
 
 struct tegra_mc_soc {
         const struct tegra_mc_client *clients;
         unsigned int num_clients;
 
-        const unsigned int *emem_regs;
+        const unsigned long *emem_regs;
         unsigned int num_emem_regs;
 
         unsigned int num_address_bits;
@@ -102,6 +114,12 @@ struct tegra_mc {
 
         const struct tegra_mc_soc *soc;
         unsigned long tick;
+
+        struct tegra_mc_timing *timings;
+        unsigned int num_timings;
 };
 
+void tegra_mc_write_emem_configuration(struct tegra_mc *mc, unsigned long rate);
+unsigned int tegra_mc_get_emem_device_count(struct tegra_mc *mc);
+
 #endif /* __SOC_TEGRA_MC_H__ */
diff --git a/include/soc/tegra/pmc.h b/include/soc/tegra/pmc.h
index 65a93273e72f..f5c0de43a5fa 100644
--- a/include/soc/tegra/pmc.h
+++ b/include/soc/tegra/pmc.h
@@ -26,8 +26,6 @@
 struct clk;
 struct reset_control;
 
-void tegra_pmc_restart(enum reboot_mode mode, const char *cmd);
-
 #ifdef CONFIG_PM_SLEEP
 enum tegra_suspend_mode tegra_pmc_get_suspend_mode(void);
 void tegra_pmc_set_suspend_mode(enum tegra_suspend_mode mode);
diff --git a/include/sound/control.h b/include/sound/control.h
index 95aad6d3fd1a..21d047f229a1 100644
--- a/include/sound/control.h
+++ b/include/sound/control.h
@@ -252,7 +252,7 @@ void snd_ctl_sync_vmaster(struct snd_kcontrol *kctl, bool hook_only);
  * Helper functions for jack-detection controls
  */
 struct snd_kcontrol *
-snd_kctl_jack_new(const char *name, int idx, void *private_data);
+snd_kctl_jack_new(const char *name, struct snd_card *card);
 void snd_kctl_jack_report(struct snd_card *card,
                           struct snd_kcontrol *kctl, bool status);
 
diff --git a/include/sound/core.h b/include/sound/core.h
index b12931f513f4..cdfecafff0f4 100644
--- a/include/sound/core.h
+++ b/include/sound/core.h
@@ -224,16 +224,13 @@ void *snd_lookup_oss_minor_data(unsigned int minor, int type);
 #endif
 
 int snd_minor_info_init(void);
-int snd_minor_info_done(void);
 
 /* sound_oss.c */
 
 #ifdef CONFIG_SND_OSSEMUL
 int snd_minor_info_oss_init(void);
-int snd_minor_info_oss_done(void);
 #else
 static inline int snd_minor_info_oss_init(void) { return 0; }
-static inline int snd_minor_info_oss_done(void) { return 0; }
 #endif
 
 /* memory.c */
@@ -262,7 +259,6 @@ int snd_card_free_when_closed(struct snd_card *card);
 void snd_card_set_id(struct snd_card *card, const char *id);
 int snd_card_register(struct snd_card *card);
 int snd_card_info_init(void);
-int snd_card_info_done(void);
 int snd_card_add_dev_attr(struct snd_card *card,
                           const struct attribute_group *group);
 int snd_component_add(struct snd_card *card, const char *component);
diff --git a/include/sound/dmaengine_pcm.h b/include/sound/dmaengine_pcm.h
index eb73a3a39ec2..f86ef5ea9b01 100644
--- a/include/sound/dmaengine_pcm.h
+++ b/include/sound/dmaengine_pcm.h
@@ -91,11 +91,6 @@ void snd_dmaengine_pcm_set_config_from_dai_data(
  */
 #define SND_DMAENGINE_PCM_FLAG_NO_DT BIT(1)
 /*
- * The platforms dmaengine driver does not support reporting the amount of
- * bytes that are still left to transfer.
- */
-#define SND_DMAENGINE_PCM_FLAG_NO_RESIDUE BIT(2)
-/*
  * The PCM is half duplex and the DMA channel is shared between capture and
  * playback.
  */
diff --git a/include/sound/emux_synth.h b/include/sound/emux_synth.h
index fb81f3722b6a..a0a40b74bf13 100644
--- a/include/sound/emux_synth.h
+++ b/include/sound/emux_synth.h
@@ -125,7 +125,7 @@ struct snd_emux {
 
         struct snd_util_memhdr *memhdr; /* memory chunk information */
 
-#ifdef CONFIG_PROC_FS
+#ifdef CONFIG_SND_PROC_FS
         struct snd_info_entry *proc;
 #endif
 
diff --git a/include/sound/hda_i915.h b/include/sound/hda_i915.h
new file mode 100644
index 000000000000..adb5ba5cbd9d
--- /dev/null
+++ b/include/sound/hda_i915.h
@@ -0,0 +1,36 @@
+/*
+ * HD-Audio helpers to sync with i915 driver
+ */
+#ifndef __SOUND_HDA_I915_H
+#define __SOUND_HDA_I915_H
+
+#ifdef CONFIG_SND_HDA_I915
+int snd_hdac_set_codec_wakeup(struct hdac_bus *bus, bool enable);
+int snd_hdac_display_power(struct hdac_bus *bus, bool enable);
+int snd_hdac_get_display_clk(struct hdac_bus *bus);
+int snd_hdac_i915_init(struct hdac_bus *bus);
+int snd_hdac_i915_exit(struct hdac_bus *bus);
+#else
+static int snd_hdac_set_codec_wakeup(struct hdac_bus *bus, bool enable)
+{
+        return 0;
+}
+static inline int snd_hdac_display_power(struct hdac_bus *bus, bool enable)
+{
+        return 0;
+}
+static inline int snd_hdac_get_display_clk(struct hdac_bus *bus)
+{
+        return 0;
+}
+static inline int snd_hdac_i915_init(struct hdac_bus *bus)
+{
+        return -ENODEV;
+}
+static inline int snd_hdac_i915_exit(struct hdac_bus *bus)
+{
+        return 0;
+}
+#endif
+
+#endif /* __SOUND_HDA_I915_H */
diff --git a/include/sound/hda_register.h b/include/sound/hda_register.h
new file mode 100644
index 000000000000..ae995e523ff8
--- /dev/null
+++ b/include/sound/hda_register.h
@@ -0,0 +1,244 @@
+/*
+ * HD-audio controller (Azalia) registers and helpers
+ *
+ * For traditional reasons, we still use azx_ prefix here
+ */
+
+#ifndef __SOUND_HDA_REGISTER_H
+#define __SOUND_HDA_REGISTER_H
+
+#include <linux/io.h>
+#include <sound/hdaudio.h>
+
+#define AZX_REG_GCAP                    0x00
+#define   AZX_GCAP_64OK         (1 << 0)   /* 64bit address support */
+#define   AZX_GCAP_NSDO         (3 << 1)   /* # of serial data out signals */
+#define   AZX_GCAP_BSS          (31 << 3)  /* # of bidirectional streams */
+#define   AZX_GCAP_ISS          (15 << 8)  /* # of input streams */
+#define   AZX_GCAP_OSS          (15 << 12) /* # of output streams */
+#define AZX_REG_VMIN                    0x02
+#define AZX_REG_VMAJ                    0x03
+#define AZX_REG_OUTPAY                  0x04
+#define AZX_REG_INPAY                   0x06
+#define AZX_REG_GCTL                    0x08
+#define   AZX_GCTL_RESET        (1 << 0)   /* controller reset */
+#define   AZX_GCTL_FCNTRL       (1 << 1)   /* flush control */
+#define   AZX_GCTL_UNSOL        (1 << 8)   /* accept unsol. response enable */
+#define AZX_REG_WAKEEN                  0x0c
+#define AZX_REG_STATESTS                0x0e
+#define AZX_REG_GSTS                    0x10
+#define   AZX_GSTS_FSTS         (1 << 1)   /* flush status */
+#define AZX_REG_GCAP2                   0x12
+#define AZX_REG_LLCH                    0x14
+#define AZX_REG_OUTSTRMPAY              0x18
+#define AZX_REG_INSTRMPAY               0x1A
+#define AZX_REG_INTCTL                  0x20
+#define AZX_REG_INTSTS                  0x24
+#define AZX_REG_WALLCLK                 0x30    /* 24Mhz source */
+#define AZX_REG_OLD_SSYNC               0x34    /* SSYNC for old ICH */
+#define AZX_REG_SSYNC                   0x38
+#define AZX_REG_CORBLBASE               0x40
+#define AZX_REG_CORBUBASE               0x44
+#define AZX_REG_CORBWP                  0x48
+#define AZX_REG_CORBRP                  0x4a
+#define   AZX_CORBRP_RST        (1 << 15)  /* read pointer reset */
+#define AZX_REG_CORBCTL                 0x4c
+#define   AZX_CORBCTL_RUN       (1 << 1)   /* enable DMA */
+#define   AZX_CORBCTL_CMEIE     (1 << 0)   /* enable memory error irq */
+#define AZX_REG_CORBSTS                 0x4d
+#define   AZX_CORBSTS_CMEI      (1 << 0)   /* memory error indication */
+#define AZX_REG_CORBSIZE                0x4e
+
+#define AZX_REG_RIRBLBASE               0x50
+#define AZX_REG_RIRBUBASE               0x54
+#define AZX_REG_RIRBWP                  0x58
+#define   AZX_RIRBWP_RST        (1 << 15)  /* write pointer reset */
+#define AZX_REG_RINTCNT                 0x5a
+#define AZX_REG_RIRBCTL                 0x5c
+#define   AZX_RBCTL_IRQ_EN      (1 << 0)   /* enable IRQ */
+#define   AZX_RBCTL_DMA_EN      (1 << 1)   /* enable DMA */
+#define   AZX_RBCTL_OVERRUN_EN  (1 << 2)   /* enable overrun irq */
+#define AZX_REG_RIRBSTS                 0x5d
+#define   AZX_RBSTS_IRQ         (1 << 0)   /* response irq */
+#define   AZX_RBSTS_OVERRUN     (1 << 2)   /* overrun irq */
+#define AZX_REG_RIRBSIZE                0x5e
+
+#define AZX_REG_IC                      0x60
+#define AZX_REG_IR                      0x64
+#define AZX_REG_IRS                     0x68
+#define   AZX_IRS_VALID         (1<<1)
+#define   AZX_IRS_BUSY          (1<<0)
+
+#define AZX_REG_DPLBASE                 0x70
+#define AZX_REG_DPUBASE                 0x74
+#define   AZX_DPLBASE_ENABLE    0x1     /* Enable position buffer */
+
+/* SD offset: SDI0=0x80, SDI1=0xa0, ... SDO3=0x160 */
+enum { SDI0, SDI1, SDI2, SDI3, SDO0, SDO1, SDO2, SDO3 };
+
+/* stream register offsets from stream base */
+#define AZX_REG_SD_CTL                  0x00
+#define AZX_REG_SD_STS                  0x03
+#define AZX_REG_SD_LPIB                 0x04
+#define AZX_REG_SD_CBL                  0x08
+#define AZX_REG_SD_LVI                  0x0c
+#define AZX_REG_SD_FIFOW                0x0e
+#define AZX_REG_SD_FIFOSIZE             0x10
+#define AZX_REG_SD_FORMAT               0x12
+#define AZX_REG_SD_FIFOL                0x14
+#define AZX_REG_SD_BDLPL                0x18
+#define AZX_REG_SD_BDLPU                0x1c
+
+/* Haswell/Broadwell display HD-A controller Extended Mode registers */
+#define AZX_REG_HSW_EM4                 0x100c
+#define AZX_REG_HSW_EM5                 0x1010
+
+/* PCI space */
+#define AZX_PCIREG_TCSEL                0x44
+
+/*
+ * other constants
+ */
+
+/* max number of fragments - we may use more if allocating more pages for BDL */
+#define BDL_SIZE                4096
+#define AZX_MAX_BDL_ENTRIES     (BDL_SIZE / 16)
+#define AZX_MAX_FRAG            32
+/* max buffer size - no h/w limit, you can increase as you like */
+#define AZX_MAX_BUF_SIZE        (1024*1024*1024)
+
+/* RIRB int mask: overrun[2], response[0] */
+#define RIRB_INT_RESPONSE       0x01
+#define RIRB_INT_OVERRUN        0x04
+#define RIRB_INT_MASK           0x05
+
+/* STATESTS int mask: S3,SD2,SD1,SD0 */
+#define STATESTS_INT_MASK       ((1 << HDA_MAX_CODECS) - 1)
+
+/* SD_CTL bits */
+#define SD_CTL_STREAM_RESET     0x01    /* stream reset bit */
+#define SD_CTL_DMA_START        0x02    /* stream DMA start bit */
+#define SD_CTL_STRIPE           (3 << 16)       /* stripe control */
+#define SD_CTL_TRAFFIC_PRIO     (1 << 18)       /* traffic priority */
+#define SD_CTL_DIR              (1 << 19)       /* bi-directional stream */
+#define SD_CTL_STREAM_TAG_MASK  (0xf << 20)
+#define SD_CTL_STREAM_TAG_SHIFT 20
+
+/* SD_CTL and SD_STS */
+#define SD_INT_DESC_ERR         0x10    /* descriptor error interrupt */
+#define SD_INT_FIFO_ERR         0x08    /* FIFO error interrupt */
+#define SD_INT_COMPLETE         0x04    /* completion interrupt */
+#define SD_INT_MASK             (SD_INT_DESC_ERR|SD_INT_FIFO_ERR|\
+                                 SD_INT_COMPLETE)
+
+/* SD_STS */
+#define SD_STS_FIFO_READY       0x20    /* FIFO ready */
+
+/* INTCTL and INTSTS */
+#define AZX_INT_ALL_STREAM      0xff       /* all stream interrupts */
+#define AZX_INT_CTRL_EN 0x40000000 /* controller interrupt enable bit */
+#define AZX_INT_GLOBAL_EN       0x80000000 /* global interrupt enable bit */
+
+/* below are so far hardcoded - should read registers in future */
+#define AZX_MAX_CORB_ENTRIES    256
+#define AZX_MAX_RIRB_ENTRIES    256
+
+/* Capability header  Structure */
+#define AZX_REG_CAP_HDR                 0x0
+#define AZX_CAP_HDR_VER_OFF             28
+#define AZX_CAP_HDR_VER_MASK            (0xF << AZX_CAP_HDR_VER_OFF)
+#define AZX_CAP_HDR_ID_OFF              16
+#define AZX_CAP_HDR_ID_MASK             (0xFFF << AZX_CAP_HDR_ID_OFF)
+#define AZX_CAP_HDR_NXT_PTR_MASK        0xFFFF
+
+/* registers of Software Position Based FIFO Capability Structure */
+#define AZX_SPB_CAP_ID                  0x4
+#define AZX_REG_SPB_BASE_ADDR           0x700
+#define AZX_REG_SPB_SPBFCH              0x00
+#define AZX_REG_SPB_SPBFCCTL            0x04
+/* Base used to calculate the iterating register offset */
+#define AZX_SPB_BASE                    0x08
+/* Interval used to calculate the iterating register offset */
+#define AZX_SPB_INTERVAL                0x08
+
+/* registers of Global Time Synchronization Capability Structure */
+#define AZX_GTS_CAP_ID                  0x1
+#define AZX_REG_GTS_GTSCH               0x00
+#define AZX_REG_GTS_GTSCD               0x04
+#define AZX_REG_GTS_GTSCTLAC            0x0C
+#define AZX_GTS_BASE                    0x20
+#define AZX_GTS_INTERVAL                0x20
+
+/* registers for Processing Pipe Capability Structure */
+#define AZX_PP_CAP_ID                   0x3
+#define AZX_REG_PP_PPCH                 0x10
+#define AZX_REG_PP_PPCTL                0x04
+#define AZX_PPCTL_PIE                   (1<<31)
+#define AZX_PPCTL_GPROCEN               (1<<30)
+/* _X_ = dma engine # and cannot * exceed 29 (per spec max 30 dma engines) */
+#define AZX_PPCTL_PROCEN(_X_)           (1<<(_X_))
+
+#define AZX_REG_PP_PPSTS                0x08
+
+#define AZX_PPHC_BASE                   0x10
+#define AZX_PPHC_INTERVAL               0x10
+
+#define AZX_REG_PPHCLLPL                0x0
+#define AZX_REG_PPHCLLPU                0x4
+#define AZX_REG_PPHCLDPL                0x8
+#define AZX_REG_PPHCLDPU                0xC
+
+#define AZX_PPLC_BASE                   0x10
+#define AZX_PPLC_MULTI                  0x10
+#define AZX_PPLC_INTERVAL               0x10
+
+#define AZX_REG_PPLCCTL                 0x0
+#define AZX_PPLCCTL_STRM_BITS           4
+#define AZX_PPLCCTL_STRM_SHIFT          20
+#define AZX_REG_MASK(bit_num, offset) \
+        (((1 << (bit_num)) - 1) << (offset))
+#define AZX_PPLCCTL_STRM_MASK \
+        AZX_REG_MASK(AZX_PPLCCTL_STRM_BITS, AZX_PPLCCTL_STRM_SHIFT)
+#define AZX_PPLCCTL_RUN                 (1<<1)
+#define AZX_PPLCCTL_STRST               (1<<0)
+
+#define AZX_REG_PPLCFMT                 0x4
+#define AZX_REG_PPLCLLPL                0x8
+#define AZX_REG_PPLCLLPU                0xC
+
+/* registers for Multiple Links Capability Structure */
+#define AZX_ML_CAP_ID                   0x2
+#define AZX_REG_ML_MLCH                 0x00
+#define AZX_REG_ML_MLCD                 0x04
+#define AZX_ML_BASE                     0x40
+#define AZX_ML_INTERVAL                 0x40
+
+#define AZX_REG_ML_LCAP                 0x00
+#define AZX_REG_ML_LCTL                 0x04
+#define AZX_REG_ML_LOSIDV               0x08
+#define AZX_REG_ML_LSDIID               0x0C
+#define AZX_REG_ML_LPSOO                0x10
+#define AZX_REG_ML_LPSIO                0x12
+#define AZX_REG_ML_LWALFC               0x18
+#define AZX_REG_ML_LOUTPAY              0x20
+#define AZX_REG_ML_LINPAY               0x30
+
+#define AZX_MLCTL_SPA                   (1<<16)
+#define AZX_MLCTL_CPA                   23
+
+/*
+ * helpers to read the stream position
+ */
+static inline unsigned int
+snd_hdac_stream_get_pos_lpib(struct hdac_stream *stream)
+{
+        return snd_hdac_stream_readl(stream, SD_LPIB);
+}
+
+static inline unsigned int
+snd_hdac_stream_get_pos_posbuf(struct hdac_stream *stream)
+{
+        return le32_to_cpu(*stream->posbuf);
+}
+
+#endif /* __SOUND_HDA_REGISTER_H */
diff --git a/include/sound/hdaudio.h b/include/sound/hdaudio.h
index 2a8aa9dfb83d..4caf1fde8a4f 100644
--- a/include/sound/hdaudio.h
+++ b/include/sound/hdaudio.h
@@ -6,12 +6,18 @@
 #define __SOUND_HDAUDIO_H
 
 #include <linux/device.h>
+#include <linux/interrupt.h>
+#include <linux/timecounter.h>
+#include <sound/core.h>
+#include <sound/memalloc.h>
 #include <sound/hda_verbs.h>
+#include <drm/i915_component.h>
 
 /* codec node id */
 typedef u16 hda_nid_t;
 
 struct hdac_bus;
+struct hdac_stream;
 struct hdac_device;
 struct hdac_driver;
 struct hdac_widget_tree;
@@ -22,6 +28,16 @@ struct hdac_widget_tree;
 extern struct bus_type snd_hda_bus_type;
 
 /*
+ * HDA device table
+ */
+struct hda_device_id {
+        __u32 vendor_id;
+        __u32 rev_id;
+        const char *name;
+        unsigned long driver_data;
+};
+
+/*
  * generic arrays
  */
 struct snd_array {
@@ -69,6 +85,7 @@ struct hdac_device {
 
         /* misc flags */
         atomic_t in_pm;         /* suspend/resume being performed */
+        bool  link_power_control:1;
 
         /* sysfs */
         struct hdac_widget_tree *widgets;
@@ -85,6 +102,7 @@ struct hdac_device {
 enum {
         HDA_DEV_CORE,
         HDA_DEV_LEGACY,
+        HDA_DEV_ASOC,
 };
 
 /* direction */
@@ -118,6 +136,15 @@ int snd_hdac_get_connections(struct hdac_device *codec, hda_nid_t nid,
                              hda_nid_t *conn_list, int max_conns);
 int snd_hdac_get_sub_nodes(struct hdac_device *codec, hda_nid_t nid,
                            hda_nid_t *start_id);
+unsigned int snd_hdac_calc_stream_format(unsigned int rate,
+                                         unsigned int channels,
+                                         unsigned int format,
+                                         unsigned int maxbps,
+                                         unsigned short spdif_ctls);
+int snd_hdac_query_supported_pcm(struct hdac_device *codec, hda_nid_t nid,
+                                u32 *ratesp, u64 *formatsp, unsigned int *bpsp);
+bool snd_hdac_is_supported_format(struct hdac_device *codec, hda_nid_t nid,
+                                  unsigned int format);
 
 /**
  * snd_hdac_read_parm - read a codec parameter
@@ -154,14 +181,18 @@ static inline void snd_hdac_power_down_pm(struct hdac_device *codec) {}
 struct hdac_driver {
         struct device_driver driver;
         int type;
+        const struct hda_device_id *id_table;
         int (*match)(struct hdac_device *dev, struct hdac_driver *drv);
         void (*unsol_event)(struct hdac_device *dev, unsigned int event);
 };
 
 #define drv_to_hdac_driver(_drv) container_of(_drv, struct hdac_driver, driver)
 
+const struct hda_device_id *
+hdac_get_device_id(struct hdac_device *hdev, struct hdac_driver *drv);
+
 /*
- * HD-audio bus base driver
+ * Bus verb operators
  */
 struct hdac_bus_ops {
         /* send a single command */
@@ -169,13 +200,59 @@ struct hdac_bus_ops {
         /* get a response from the last command */
         int (*get_response)(struct hdac_bus *bus, unsigned int addr,
                             unsigned int *res);
+        /* control the link power  */
+        int (*link_power)(struct hdac_bus *bus, bool enable);
+};
+
+/*
+ * Lowlevel I/O operators
+ */
+struct hdac_io_ops {
+        /* mapped register accesses */
+        void (*reg_writel)(u32 value, u32 __iomem *addr);
+        u32 (*reg_readl)(u32 __iomem *addr);
+        void (*reg_writew)(u16 value, u16 __iomem *addr);
+        u16 (*reg_readw)(u16 __iomem *addr);
+        void (*reg_writeb)(u8 value, u8 __iomem *addr);
+        u8 (*reg_readb)(u8 __iomem *addr);
+        /* Allocation ops */
+        int (*dma_alloc_pages)(struct hdac_bus *bus, int type, size_t size,
+                               struct snd_dma_buffer *buf);
+        void (*dma_free_pages)(struct hdac_bus *bus,
+                               struct snd_dma_buffer *buf);
 };
 
 #define HDA_UNSOL_QUEUE_SIZE    64
+#define HDA_MAX_CODECS          8       /* limit by controller side */
+
+/* HD Audio class code */
+#define PCI_CLASS_MULTIMEDIA_HD_AUDIO   0x0403
+
+/*
+ * CORB/RIRB
+ *
+ * Each CORB entry is 4byte, RIRB is 8byte
+ */
+struct hdac_rb {
+        __le32 *buf;            /* virtual address of CORB/RIRB buffer */
+        dma_addr_t addr;        /* physical address of CORB/RIRB buffer */
+        unsigned short rp, wp;  /* RIRB read/write pointers */
+        int cmds[HDA_MAX_CODECS];       /* number of pending requests */
+        u32 res[HDA_MAX_CODECS];        /* last read value */
+};
 
+/*
+ * HD-audio bus base driver
+ */
 struct hdac_bus {
         struct device *dev;
         const struct hdac_bus_ops *ops;
+        const struct hdac_io_ops *io_ops;
+
+        /* h/w resources */
+        unsigned long addr;
+        void __iomem *remap_addr;
+        int irq;
 
         /* codec linked list */
         struct list_head codec_list;
@@ -189,18 +266,49 @@ struct hdac_bus {
         unsigned int unsol_rp, unsol_wp;
         struct work_struct unsol_work;
 
+        /* bit flags of detected codecs */
+        unsigned long codec_mask;
+
         /* bit flags of powered codecs */
         unsigned long codec_powered;
 
-        /* flags */
+        /* CORB/RIRB */
+        struct hdac_rb corb;
+        struct hdac_rb rirb;
+        unsigned int last_cmd[HDA_MAX_CODECS];  /* last sent command */
+
+        /* CORB/RIRB and position buffers */
+        struct snd_dma_buffer rb;
+        struct snd_dma_buffer posbuf;
+
+        /* hdac_stream linked list */
+        struct list_head stream_list;
+
+        /* operation state */
+        bool chip_init:1;               /* h/w initialized */
+
+        /* behavior flags */
         bool sync_write:1;              /* sync after verb write */
+        bool use_posbuf:1;              /* use position buffer */
+        bool snoop:1;                   /* enable snooping */
+        bool align_bdle_4k:1;           /* BDLE align 4K boundary */
+        bool reverse_assign:1;          /* assign devices in reverse order */
+        bool corbrp_self_clear:1;       /* CORBRP clears itself after reset */
+
+        int bdl_pos_adj;                /* BDL position adjustment */
 
         /* locks */
+        spinlock_t reg_lock;
         struct mutex cmd_mutex;
+
+        /* i915 component interface */
+        struct i915_audio_component *audio_component;
+        int i915_power_refcount;
 };
 
 int snd_hdac_bus_init(struct hdac_bus *bus, struct device *dev,
-                      const struct hdac_bus_ops *ops);
+                      const struct hdac_bus_ops *ops,
+                      const struct hdac_io_ops *io_ops);
 void snd_hdac_bus_exit(struct hdac_bus *bus);
 int snd_hdac_bus_exec_verb(struct hdac_bus *bus, unsigned int addr,
                            unsigned int cmd, unsigned int *res);
@@ -222,6 +330,201 @@ static inline void snd_hdac_codec_link_down(struct hdac_device *codec)
         clear_bit(codec->addr, &codec->bus->codec_powered);
 }
 
+int snd_hdac_bus_send_cmd(struct hdac_bus *bus, unsigned int val);
+int snd_hdac_bus_get_response(struct hdac_bus *bus, unsigned int addr,
+                              unsigned int *res);
+int snd_hdac_link_power(struct hdac_device *codec, bool enable);
+
+bool snd_hdac_bus_init_chip(struct hdac_bus *bus, bool full_reset);
+void snd_hdac_bus_stop_chip(struct hdac_bus *bus);
+void snd_hdac_bus_init_cmd_io(struct hdac_bus *bus);
+void snd_hdac_bus_stop_cmd_io(struct hdac_bus *bus);
+void snd_hdac_bus_enter_link_reset(struct hdac_bus *bus);
+void snd_hdac_bus_exit_link_reset(struct hdac_bus *bus);
+
+void snd_hdac_bus_update_rirb(struct hdac_bus *bus);
+void snd_hdac_bus_handle_stream_irq(struct hdac_bus *bus, unsigned int status,
+                                    void (*ack)(struct hdac_bus *,
+                                                struct hdac_stream *));
+
+int snd_hdac_bus_alloc_stream_pages(struct hdac_bus *bus);
+void snd_hdac_bus_free_stream_pages(struct hdac_bus *bus);
+
+/*
+ * macros for easy use
+ */
+#define _snd_hdac_chip_write(type, chip, reg, value) \
+        ((chip)->io_ops->reg_write ## type(value, (chip)->remap_addr + (reg)))
+#define _snd_hdac_chip_read(type, chip, reg) \
+        ((chip)->io_ops->reg_read ## type((chip)->remap_addr + (reg)))
+
+/* read/write a register, pass without AZX_REG_ prefix */
+#define snd_hdac_chip_writel(chip, reg, value) \
+        _snd_hdac_chip_write(l, chip, AZX_REG_ ## reg, value)
+#define snd_hdac_chip_writew(chip, reg, value) \
+        _snd_hdac_chip_write(w, chip, AZX_REG_ ## reg, value)
+#define snd_hdac_chip_writeb(chip, reg, value) \
+        _snd_hdac_chip_write(b, chip, AZX_REG_ ## reg, value)
+#define snd_hdac_chip_readl(chip, reg) \
+        _snd_hdac_chip_read(l, chip, AZX_REG_ ## reg)
+#define snd_hdac_chip_readw(chip, reg) \
+        _snd_hdac_chip_read(w, chip, AZX_REG_ ## reg)
+#define snd_hdac_chip_readb(chip, reg) \
+        _snd_hdac_chip_read(b, chip, AZX_REG_ ## reg)
+
+/* update a register, pass without AZX_REG_ prefix */
+#define snd_hdac_chip_updatel(chip, reg, mask, val) \
+        snd_hdac_chip_writel(chip, reg, \
+                             (snd_hdac_chip_readl(chip, reg) & ~(mask)) | (val))
+#define snd_hdac_chip_updatew(chip, reg, mask, val) \
+        snd_hdac_chip_writew(chip, reg, \
+                             (snd_hdac_chip_readw(chip, reg) & ~(mask)) | (val))
+#define snd_hdac_chip_updateb(chip, reg, mask, val) \
+        snd_hdac_chip_writeb(chip, reg, \
+                             (snd_hdac_chip_readb(chip, reg) & ~(mask)) | (val))
+
+/*
+ * HD-audio stream
+ */
+struct hdac_stream {
+        struct hdac_bus *bus;
+        struct snd_dma_buffer bdl; /* BDL buffer */
+        __le32 *posbuf;         /* position buffer pointer */
+        int direction;          /* playback / capture (SNDRV_PCM_STREAM_*) */
+
+        unsigned int bufsize;   /* size of the play buffer in bytes */
+        unsigned int period_bytes; /* size of the period in bytes */
+        unsigned int frags;     /* number for period in the play buffer */
+        unsigned int fifo_size; /* FIFO size */
+
+        void __iomem *sd_addr;  /* stream descriptor pointer */
+
+        u32 sd_int_sta_mask;    /* stream int status mask */
+
+        /* pcm support */
+        struct snd_pcm_substream *substream;    /* assigned substream,
+                                                 * set in PCM open
+                                                 */
+        unsigned int format_val;        /* format value to be set in the
+                                         * controller and the codec
+                                         */
+        unsigned char stream_tag;       /* assigned stream */
+        unsigned char index;            /* stream index */
+        int assigned_key;               /* last device# key assigned to */
+
+        bool opened:1;
+        bool running:1;
+        bool prepared:1;
+        bool no_period_wakeup:1;
+        bool locked:1;
+
+        /* timestamp */
+        unsigned long start_wallclk;    /* start + minimum wallclk */
+        unsigned long period_wallclk;   /* wallclk for period */
+        struct timecounter  tc;
+        struct cyclecounter cc;
+        int delay_negative_threshold;
+
+        struct list_head list;
+#ifdef CONFIG_SND_HDA_DSP_LOADER
+        /* DSP access mutex */
+        struct mutex dsp_mutex;
+#endif
+};
+
+void snd_hdac_stream_init(struct hdac_bus *bus, struct hdac_stream *azx_dev,
+                          int idx, int direction, int tag);
+struct hdac_stream *snd_hdac_stream_assign(struct hdac_bus *bus,
+                                           struct snd_pcm_substream *substream);
+void snd_hdac_stream_release(struct hdac_stream *azx_dev);
+
+int snd_hdac_stream_setup(struct hdac_stream *azx_dev);
+void snd_hdac_stream_cleanup(struct hdac_stream *azx_dev);
+int snd_hdac_stream_setup_periods(struct hdac_stream *azx_dev);
+int snd_hdac_stream_set_params(struct hdac_stream *azx_dev,
+                                unsigned int format_val);
+void snd_hdac_stream_start(struct hdac_stream *azx_dev, bool fresh_start);
+void snd_hdac_stream_clear(struct hdac_stream *azx_dev);
+void snd_hdac_stream_stop(struct hdac_stream *azx_dev);
+void snd_hdac_stream_reset(struct hdac_stream *azx_dev);
+void snd_hdac_stream_sync_trigger(struct hdac_stream *azx_dev, bool set,
+                                  unsigned int streams, unsigned int reg);
+void snd_hdac_stream_sync(struct hdac_stream *azx_dev, bool start,
+                          unsigned int streams);
+void snd_hdac_stream_timecounter_init(struct hdac_stream *azx_dev,
+                                      unsigned int streams);
+/*
+ * macros for easy use
+ */
+#define _snd_hdac_stream_write(type, dev, reg, value)                   \
+        ((dev)->bus->io_ops->reg_write ## type(value, (dev)->sd_addr + (reg)))
+#define _snd_hdac_stream_read(type, dev, reg)                           \
+        ((dev)->bus->io_ops->reg_read ## type((dev)->sd_addr + (reg)))
+
+/* read/write a register, pass without AZX_REG_ prefix */
+#define snd_hdac_stream_writel(dev, reg, value) \
+        _snd_hdac_stream_write(l, dev, AZX_REG_ ## reg, value)
+#define snd_hdac_stream_writew(dev, reg, value) \
+        _snd_hdac_stream_write(w, dev, AZX_REG_ ## reg, value)
+#define snd_hdac_stream_writeb(dev, reg, value) \
+        _snd_hdac_stream_write(b, dev, AZX_REG_ ## reg, value)
+#define snd_hdac_stream_readl(dev, reg) \
+        _snd_hdac_stream_read(l, dev, AZX_REG_ ## reg)
+#define snd_hdac_stream_readw(dev, reg) \
+        _snd_hdac_stream_read(w, dev, AZX_REG_ ## reg)
+#define snd_hdac_stream_readb(dev, reg) \
+        _snd_hdac_stream_read(b, dev, AZX_REG_ ## reg)
+
+/* update a register, pass without AZX_REG_ prefix */
+#define snd_hdac_stream_updatel(dev, reg, mask, val) \
+        snd_hdac_stream_writel(dev, reg, \
+                               (snd_hdac_stream_readl(dev, reg) & \
+                                ~(mask)) | (val))
+#define snd_hdac_stream_updatew(dev, reg, mask, val) \
+        snd_hdac_stream_writew(dev, reg, \
+                               (snd_hdac_stream_readw(dev, reg) & \
+                                ~(mask)) | (val))
+#define snd_hdac_stream_updateb(dev, reg, mask, val) \
+        snd_hdac_stream_writeb(dev, reg, \
+                               (snd_hdac_stream_readb(dev, reg) & \
+                                ~(mask)) | (val))
+
+#ifdef CONFIG_SND_HDA_DSP_LOADER
+/* DSP lock helpers */
+#define snd_hdac_dsp_lock_init(dev)     mutex_init(&(dev)->dsp_mutex)
+#define snd_hdac_dsp_lock(dev)          mutex_lock(&(dev)->dsp_mutex)
+#define snd_hdac_dsp_unlock(dev)        mutex_unlock(&(dev)->dsp_mutex)
+#define snd_hdac_stream_is_locked(dev)  ((dev)->locked)
+/* DSP loader helpers */
+int snd_hdac_dsp_prepare(struct hdac_stream *azx_dev, unsigned int format,
+                         unsigned int byte_size, struct snd_dma_buffer *bufp);
+void snd_hdac_dsp_trigger(struct hdac_stream *azx_dev, bool start);
+void snd_hdac_dsp_cleanup(struct hdac_stream *azx_dev,
+                          struct snd_dma_buffer *dmab);
+#else /* CONFIG_SND_HDA_DSP_LOADER */
+#define snd_hdac_dsp_lock_init(dev)     do {} while (0)
+#define snd_hdac_dsp_lock(dev)          do {} while (0)
+#define snd_hdac_dsp_unlock(dev)        do {} while (0)
+#define snd_hdac_stream_is_locked(dev)  0
+
+static inline int
+snd_hdac_dsp_prepare(struct hdac_stream *azx_dev, unsigned int format,
+                     unsigned int byte_size, struct snd_dma_buffer *bufp)
+{
+        return 0;
+}
+
+static inline void snd_hdac_dsp_trigger(struct hdac_stream *azx_dev, bool start)
+{
+}
+
+static inline void snd_hdac_dsp_cleanup(struct hdac_stream *azx_dev,
+                                        struct snd_dma_buffer *dmab)
+{
+}
+#endif /* CONFIG_SND_HDA_DSP_LOADER */
+
+
 /*
  * generic array helpers
  */
diff --git a/include/sound/hdaudio_ext.h b/include/sound/hdaudio_ext.h
new file mode 100644
index 000000000000..0f89df1511dc
--- /dev/null
+++ b/include/sound/hdaudio_ext.h
@@ -0,0 +1,132 @@
+#ifndef __SOUND_HDAUDIO_EXT_H
+#define __SOUND_HDAUDIO_EXT_H
+
+#include <sound/hdaudio.h>
+
+/**
+ * hdac_ext_bus: HDAC extended bus for extended HDA caps
+ *
+ * @bus: hdac bus
+ * @num_streams: streams supported
+ * @ppcap: pp capabilities pointer
+ * @spbcap: SPIB capabilities pointer
+ * @mlcap: MultiLink capabilities pointer
+ * @gtscap: gts capabilities pointer
+ * @hlink_list: link list of HDA links
+ */
+struct hdac_ext_bus {
+        struct hdac_bus bus;
+        int num_streams;
+        int idx;
+
+        void __iomem *ppcap;
+        void __iomem *spbcap;
+        void __iomem *mlcap;
+        void __iomem *gtscap;
+
+        struct list_head hlink_list;
+};
+
+int snd_hdac_ext_bus_init(struct hdac_ext_bus *sbus, struct device *dev,
+                      const struct hdac_bus_ops *ops,
+                      const struct hdac_io_ops *io_ops);
+
+void snd_hdac_ext_bus_exit(struct hdac_ext_bus *sbus);
+int snd_hdac_ext_bus_device_init(struct hdac_ext_bus *sbus, int addr);
+void snd_hdac_ext_bus_device_exit(struct hdac_device *hdev);
+
+#define ebus_to_hbus(ebus)      (&(ebus)->bus)
+#define hbus_to_ebus(_bus) \
+        container_of(_bus, struct hdac_ext_bus, bus)
+
+int snd_hdac_ext_bus_parse_capabilities(struct hdac_ext_bus *sbus);
+void snd_hdac_ext_bus_ppcap_enable(struct hdac_ext_bus *chip, bool enable);
+void snd_hdac_ext_bus_ppcap_int_enable(struct hdac_ext_bus *chip, bool enable);
+
+void snd_hdac_ext_stream_spbcap_enable(struct hdac_ext_bus *chip,
+                                 bool enable, int index);
+
+int snd_hdac_ext_bus_get_ml_capabilities(struct hdac_ext_bus *bus);
+struct hdac_ext_link *snd_hdac_ext_bus_get_link(struct hdac_ext_bus *bus,
+                                                const char *codec_name);
+
+enum hdac_ext_stream_type {
+        HDAC_EXT_STREAM_TYPE_COUPLED = 0,
+        HDAC_EXT_STREAM_TYPE_HOST,
+        HDAC_EXT_STREAM_TYPE_LINK
+};
+
+/**
+ * hdac_ext_stream: HDAC extended stream for extended HDA caps
+ *
+ * @hstream: hdac_stream
+ * @pphc_addr: processing pipe host stream pointer
+ * @pplc_addr: processing pipe link stream pointer
+ * @decoupled: stream host and link is decoupled
+ * @link_locked: link is locked
+ * @link_prepared: link is prepared
+ * link_substream: link substream
+ */
+struct hdac_ext_stream {
+        struct hdac_stream hstream;
+
+        void __iomem *pphc_addr;
+        void __iomem *pplc_addr;
+
+        bool decoupled:1;
+        bool link_locked:1;
+        bool link_prepared;
+
+        struct snd_pcm_substream *link_substream;
+};
+
+#define hdac_stream(s)          (&(s)->hstream)
+#define stream_to_hdac_ext_stream(s) \
+        container_of(s, struct hdac_ext_stream, hstream)
+
+void snd_hdac_ext_stream_init(struct hdac_ext_bus *bus,
+                                struct hdac_ext_stream *stream, int idx,
+                                int direction, int tag);
+int snd_hdac_ext_stream_init_all(struct hdac_ext_bus *ebus, int start_idx,
+                int num_stream, int dir);
+void snd_hdac_stream_free_all(struct hdac_ext_bus *ebus);
+void snd_hdac_link_free_all(struct hdac_ext_bus *ebus);
+struct hdac_ext_stream *snd_hdac_ext_stream_assign(struct hdac_ext_bus *bus,
+                                           struct snd_pcm_substream *substream,
+                                           int type);
+void snd_hdac_ext_stream_release(struct hdac_ext_stream *azx_dev, int type);
+void snd_hdac_ext_stream_decouple(struct hdac_ext_bus *bus,
+                                struct hdac_ext_stream *azx_dev, bool decouple);
+void snd_hdac_ext_stop_streams(struct hdac_ext_bus *sbus);
+
+void snd_hdac_ext_link_stream_start(struct hdac_ext_stream *hstream);
+void snd_hdac_ext_link_stream_clear(struct hdac_ext_stream *hstream);
+void snd_hdac_ext_link_stream_reset(struct hdac_ext_stream *hstream);
+int snd_hdac_ext_link_stream_setup(struct hdac_ext_stream *stream, int fmt);
+
+struct hdac_ext_link {
+        struct hdac_bus *bus;
+        int index;
+        void __iomem *ml_addr; /* link output stream reg pointer */
+        u32 lcaps;   /* link capablities */
+        u16 lsdiid;  /* link sdi identifier */
+        struct list_head list;
+};
+
+int snd_hdac_ext_bus_link_power_up(struct hdac_ext_link *link);
+int snd_hdac_ext_bus_link_power_down(struct hdac_ext_link *link);
+void snd_hdac_ext_link_set_stream_id(struct hdac_ext_link *link,
+                                 int stream);
+void snd_hdac_ext_link_clear_stream_id(struct hdac_ext_link *link,
+                                 int stream);
+
+/* update register macro */
+#define snd_hdac_updatel(addr, reg, mask, val)          \
+        writel(((readl(addr + reg) & ~(mask)) | (val)), \
+                addr + reg)
+
+#define snd_hdac_updatew(addr, reg, mask, val)          \
+        writew(((readw(addr + reg) & ~(mask)) | (val)), \
+                addr + reg)
+
+#endif /* __SOUND_HDAUDIO_EXT_H */
diff --git a/include/sound/info.h b/include/sound/info.h
index 9ca1a493d370..67390ee846aa 100644
--- a/include/sound/info.h
+++ b/include/sound/info.h
@@ -23,6 +23,8 @@
  */
 
 #include <linux/poll.h>
+#include <linux/seq_file.h>
+#include <sound/core.h>
 
 /* buffer for information */
 struct snd_info_buffer {
@@ -90,16 +92,14 @@ struct snd_info_entry {
         struct list_head list;
 };
 
-#if defined(CONFIG_SND_OSSEMUL) && defined(CONFIG_PROC_FS)
+#if defined(CONFIG_SND_OSSEMUL) && defined(CONFIG_SND_PROC_FS)
 int snd_info_minor_register(void);
-int snd_info_minor_unregister(void);
 #else
-#define snd_info_minor_register() /* NOP */
-#define snd_info_minor_unregister() /* NOP */
+#define snd_info_minor_register()       0
 #endif
 
 
-#ifdef CONFIG_PROC_FS
+#ifdef CONFIG_SND_PROC_FS
 
 extern struct snd_info_entry *snd_seq_root;
 #ifdef CONFIG_SND_OSSEMUL
@@ -110,8 +110,18 @@ void snd_card_info_read_oss(struct snd_info_buffer *buffer);
 static inline void snd_card_info_read_oss(struct snd_info_buffer *buffer) {}
 #endif
 
-__printf(2, 3)
-int snd_iprintf(struct snd_info_buffer *buffer, const char *fmt, ...);
+/**
+ * snd_iprintf - printf on the procfs buffer
+ * @buf: the procfs buffer
+ * @fmt: the printf format
+ *
+ * Outputs the string on the procfs buffer just like printf().
+ *
+ * Return: zero for success, or a negative error code.
+ */
+#define snd_iprintf(buf, fmt, args...) \
+        seq_printf((struct seq_file *)(buf)->buffer, fmt, ##args)
+
 int snd_info_init(void);
 int snd_info_done(void);
 
@@ -135,8 +145,12 @@ void snd_info_card_id_change(struct snd_card *card);
 int snd_info_register(struct snd_info_entry *entry);
 
 /* for card drivers */
-int snd_card_proc_new(struct snd_card *card, const char *name,
-                      struct snd_info_entry **entryp);
+static inline int snd_card_proc_new(struct snd_card *card, const char *name,
+                                    struct snd_info_entry **entryp)
+{
+        *entryp = snd_info_create_card_entry(card, name, card->proc_root);
+        return *entryp ? 0 : -ENOMEM;
+}
 
 static inline void snd_info_set_text_ops(struct snd_info_entry *entry, 
         void *private_data,
@@ -175,7 +189,6 @@ static inline int snd_card_proc_new(struct snd_card *card, const char *name,
 static inline void snd_info_set_text_ops(struct snd_info_entry *entry __attribute__((unused)),
                                          void *private_data,
                                          void (*read)(struct snd_info_entry *, struct snd_info_buffer *)) {}
-
 static inline int snd_info_check_reserved_words(const char *str) { return 1; }
 
 #endif
@@ -184,7 +197,7 @@ static inline int snd_info_check_reserved_words(const char *str) { return 1; }
  * OSS info part
  */
 
-#if defined(CONFIG_SND_OSSEMUL) && defined(CONFIG_PROC_FS)
+#if defined(CONFIG_SND_OSSEMUL) && defined(CONFIG_SND_PROC_FS)
 
 #define SNDRV_OSS_INFO_DEV_AUDIO        0
 #define SNDRV_OSS_INFO_DEV_SYNTH        1
@@ -197,6 +210,6 @@ static inline int snd_info_check_reserved_words(const char *str) { return 1; }
 int snd_oss_info_register(int dev, int num, char *string);
 #define snd_oss_info_unregister(dev, num) snd_oss_info_register(dev, num, NULL)
 
-#endif /* CONFIG_SND_OSSEMUL && CONFIG_PROC_FS */
+#endif /* CONFIG_SND_OSSEMUL && CONFIG_SND_PROC_FS */
 
 #endif /* __SOUND_INFO_H */
diff --git a/include/sound/jack.h b/include/sound/jack.h
index 218235030ebc..23bede121c78 100644
--- a/include/sound/jack.h
+++ b/include/sound/jack.h
@@ -73,6 +73,8 @@ enum snd_jack_types {
 
 struct snd_jack {
         struct input_dev *input_dev;
+        struct list_head kctl_list;
+        struct snd_card *card;
         int registered;
         int type;
         const char *id;
@@ -85,7 +87,8 @@ struct snd_jack {
 #ifdef CONFIG_SND_JACK
 
 int snd_jack_new(struct snd_card *card, const char *id, int type,
-                 struct snd_jack **jack);
+                 struct snd_jack **jack, bool initial_kctl, bool phantom_jack);
+int snd_jack_add_new_kctl(struct snd_jack *jack, const char * name, int mask);
 void snd_jack_set_parent(struct snd_jack *jack, struct device *parent);
 int snd_jack_set_key(struct snd_jack *jack, enum snd_jack_types type,
                      int keytype);
@@ -93,9 +96,13 @@ int snd_jack_set_key(struct snd_jack *jack, enum snd_jack_types type,
 void snd_jack_report(struct snd_jack *jack, int status);
 
 #else
-
 static inline int snd_jack_new(struct snd_card *card, const char *id, int type,
-                               struct snd_jack **jack)
+                               struct snd_jack **jack, bool initial_kctl, bool phantom_jack)
+{
+        return 0;
+}
+
+static inline int snd_jack_add_new_kctl(struct snd_jack *jack, const char * name, int mask)
 {
         return 0;
 }
diff --git a/include/sound/pcm.h b/include/sound/pcm.h
index 0cb7f3f5df7b..691e7ee0a510 100644
--- a/include/sound/pcm.h
+++ b/include/sound/pcm.h
@@ -224,9 +224,10 @@ typedef int (*snd_pcm_hw_rule_func_t)(struct snd_pcm_hw_params *params,
 
 struct snd_pcm_hw_rule {
         unsigned int cond;
-        snd_pcm_hw_rule_func_t func;
         int var;
         int deps[4];
+
+        snd_pcm_hw_rule_func_t func;
         void *private;
 };
 
@@ -273,8 +274,8 @@ struct snd_pcm_hw_constraint_ratdens {
 };
 
 struct snd_pcm_hw_constraint_list {
-        unsigned int count;
         const unsigned int *list;
+        unsigned int count;
         unsigned int mask;
 };
 
diff --git a/include/sound/pcm_drm_eld.h b/include/sound/pcm_drm_eld.h
new file mode 100644
index 000000000000..93357b25d2e2
--- /dev/null
+++ b/include/sound/pcm_drm_eld.h
@@ -0,0 +1,6 @@
+#ifndef __SOUND_PCM_DRM_ELD_H
+#define __SOUND_PCM_DRM_ELD_H
+
+int snd_pcm_hw_constraint_eld(struct snd_pcm_runtime *runtime, void *eld);
+
+#endif
diff --git a/include/sound/pcm_iec958.h b/include/sound/pcm_iec958.h
new file mode 100644
index 000000000000..0eed397aca8e
--- /dev/null
+++ b/include/sound/pcm_iec958.h
@@ -0,0 +1,9 @@
+#ifndef __SOUND_PCM_IEC958_H
+#define __SOUND_PCM_IEC958_H
+
+#include <linux/types.h>
+
+int snd_pcm_create_iec958_consumer(struct snd_pcm_runtime *runtime, u8 *cs,
+        size_t len);
+
+#endif
diff --git a/include/sound/rt5645.h b/include/sound/rt5645.h
index 120d9610054e..22734bc3ffd4 100644
--- a/include/sound/rt5645.h
+++ b/include/sound/rt5645.h
@@ -15,17 +15,11 @@ struct rt5645_platform_data {
         /* IN2 can optionally be differential */
         bool in2_diff;
 
-        bool dmic_en;
         unsigned int dmic1_data_pin;
         /* 0 = IN2N; 1 = GPIO5; 2 = GPIO11 */
         unsigned int dmic2_data_pin;
         /* 0 = IN2P; 1 = GPIO6; 2 = GPIO10; 3 = GPIO12 */
 
-        unsigned int hp_det_gpio;
-        bool gpio_hp_det_active_high;
-
-        /* true if codec's jd function is used */
-        bool en_jd_func;
         unsigned int jd_mode;
 };
 
diff --git a/include/sound/soc-dapm.h b/include/sound/soc-dapm.h
index 1065095c6973..37d95a898275 100644
--- a/include/sound/soc-dapm.h
+++ b/include/sound/soc-dapm.h
@@ -15,6 +15,8 @@
 
 #include <linux/types.h>
 #include <sound/control.h>
+#include <sound/soc-topology.h>
+#include <sound/asoc.h>
 
 struct device;
 
@@ -107,6 +109,10 @@ struct device;
 {       .id = snd_soc_dapm_mux, .name = wname, \
         SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
         .kcontrol_news = wcontrols, .num_kcontrols = 1}
+#define SND_SOC_DAPM_DEMUX(wname, wreg, wshift, winvert, wcontrols) \
+{       .id = snd_soc_dapm_demux, .name = wname, \
+        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
+        .kcontrol_news = wcontrols, .num_kcontrols = 1}
 
 /* Simplified versions of above macros, assuming wncontrols = ARRAY_SIZE(wcontrols) */
 #define SOC_PGA_ARRAY(wname, wreg, wshift, winvert,\
@@ -444,11 +450,15 @@ int snd_soc_dapm_dai_get_connected_widgets(struct snd_soc_dai *dai, int stream,
 struct snd_soc_dapm_context *snd_soc_dapm_kcontrol_dapm(
         struct snd_kcontrol *kcontrol);
 
+int snd_soc_dapm_force_bias_level(struct snd_soc_dapm_context *dapm,
+        enum snd_soc_bias_level level);
+
 /* dapm widget types */
 enum snd_soc_dapm_type {
         snd_soc_dapm_input = 0,         /* input pin */
         snd_soc_dapm_output,            /* output pin */
         snd_soc_dapm_mux,                       /* selects 1 analog signal from many inputs */
+        snd_soc_dapm_demux,                     /* connects the input to one of multiple outputs */
         snd_soc_dapm_mixer,                     /* mixes several analog signals together */
         snd_soc_dapm_mixer_named_ctl,           /* mixer with named controls */
         snd_soc_dapm_pga,                       /* programmable gain/attenuation (volume) */
@@ -563,6 +573,7 @@ struct snd_soc_dapm_widget {
         int num_kcontrols;
         const struct snd_kcontrol_new *kcontrol_news;
         struct snd_kcontrol **kcontrols;
+        struct snd_soc_dobj dobj;
 
         /* widget input and outputs */
         struct list_head sources;
@@ -585,6 +596,10 @@ struct snd_soc_dapm_update {
         int val;
 };
 
+struct snd_soc_dapm_wcache {
+        struct snd_soc_dapm_widget *widget;
+};
+
 /* DAPM context */
 struct snd_soc_dapm_context {
         enum snd_soc_bias_level bias_level;
@@ -606,6 +621,9 @@ struct snd_soc_dapm_context {
         int (*set_bias_level)(struct snd_soc_dapm_context *dapm,
                               enum snd_soc_bias_level level);
 
+        struct snd_soc_dapm_wcache path_sink_cache;
+        struct snd_soc_dapm_wcache path_source_cache;
+
 #ifdef CONFIG_DEBUG_FS
         struct dentry *debugfs_dapm;
 #endif
@@ -623,4 +641,35 @@ struct snd_soc_dapm_stats {
         int neighbour_checks;
 };
 
+/**
+ * snd_soc_dapm_init_bias_level() - Initialize DAPM bias level
+ * @dapm: The DAPM context to initialize
+ * @level: The DAPM level to initialize to
+ *
+ * This function only sets the driver internal state of the DAPM level and will
+ * not modify the state of the device. Hence it should not be used during normal
+ * operation, but only to synchronize the internal state to the device state.
+ * E.g. during driver probe to set the DAPM level to the one corresponding with
+ * the power-on reset state of the device.
+ *
+ * To change the DAPM state of the device use snd_soc_dapm_set_bias_level().
+ */
+static inline void snd_soc_dapm_init_bias_level(
+        struct snd_soc_dapm_context *dapm, enum snd_soc_bias_level level)
+{
+        dapm->bias_level = level;
+}
+
+/**
+ * snd_soc_dapm_get_bias_level() - Get current DAPM bias level
+ * @dapm: The context for which to get the bias level
+ *
+ * Returns: The current bias level of the passed DAPM context.
+ */
+static inline enum snd_soc_bias_level snd_soc_dapm_get_bias_level(
+        struct snd_soc_dapm_context *dapm)
+{
+        return dapm->bias_level;
+}
+
 #endif
diff --git a/include/sound/soc-topology.h b/include/sound/soc-topology.h
new file mode 100644
index 000000000000..865a141b118b
--- /dev/null
+++ b/include/sound/soc-topology.h
@@ -0,0 +1,168 @@
+/*
+ * linux/sound/soc-topology.h -- ALSA SoC Firmware Controls and DAPM
+ *
+ * Copyright (C) 2012 Texas Instruments Inc.
+ * Copyright (C) 2015 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.
+ *
+ * Simple file API to load FW that includes mixers, coefficients, DAPM graphs,
+ * algorithms, equalisers, DAIs, widgets, FE caps, BE caps, codec link caps etc.
+ */
+
+#ifndef __LINUX_SND_SOC_TPLG_H
+#define __LINUX_SND_SOC_TPLG_H
+
+#include <sound/asoc.h>
+#include <linux/list.h>
+
+struct firmware;
+struct snd_kcontrol;
+struct snd_soc_tplg_pcm_be;
+struct snd_ctl_elem_value;
+struct snd_ctl_elem_info;
+struct snd_soc_dapm_widget;
+struct snd_soc_component;
+struct snd_soc_tplg_pcm_fe;
+struct snd_soc_dapm_context;
+struct snd_soc_card;
+
+/* object scan be loaded and unloaded in groups with identfying indexes */
+#define SND_SOC_TPLG_INDEX_ALL  0       /* ID that matches all FW objects */
+
+/* dynamic object type */
+enum snd_soc_dobj_type {
+        SND_SOC_DOBJ_NONE               = 0,    /* object is not dynamic */
+        SND_SOC_DOBJ_MIXER,
+        SND_SOC_DOBJ_ENUM,
+        SND_SOC_DOBJ_BYTES,
+        SND_SOC_DOBJ_PCM,
+        SND_SOC_DOBJ_DAI_LINK,
+        SND_SOC_DOBJ_CODEC_LINK,
+        SND_SOC_DOBJ_WIDGET,
+};
+
+/* dynamic control object */
+struct snd_soc_dobj_control {
+        struct snd_kcontrol *kcontrol;
+        char **dtexts;
+        unsigned long *dvalues;
+};
+
+/* dynamic widget object */
+struct snd_soc_dobj_widget {
+        unsigned int kcontrol_enum:1;   /* this widget is an enum kcontrol */
+};
+
+/* dynamic PCM DAI object */
+struct snd_soc_dobj_pcm_dai {
+        struct snd_soc_tplg_pcm_dai *pd;
+        unsigned int count;
+};
+
+/* generic dynamic object - all dynamic objects belong to this struct */
+struct snd_soc_dobj {
+        enum snd_soc_dobj_type type;
+        unsigned int index;     /* objects can belong in different groups */
+        struct list_head list;
+        struct snd_soc_tplg_ops *ops;
+        union {
+                struct snd_soc_dobj_control control;
+                struct snd_soc_dobj_widget widget;
+                struct snd_soc_dobj_pcm_dai pcm_dai;
+        };
+        void *private; /* core does not touch this */
+};
+
+/*
+ * Kcontrol operations - used to map handlers onto firmware based controls.
+ */
+struct snd_soc_tplg_kcontrol_ops {
+        u32 id;
+        int (*get)(struct snd_kcontrol *kcontrol,
+                        struct snd_ctl_elem_value *ucontrol);
+        int (*put)(struct snd_kcontrol *kcontrol,
+                        struct snd_ctl_elem_value *ucontrol);
+        int (*info)(struct snd_kcontrol *kcontrol,
+                struct snd_ctl_elem_info *uinfo);
+};
+
+/*
+ * DAPM widget event handlers - used to map handlers onto widgets.
+ */
+struct snd_soc_tplg_widget_events {
+        u16 type;
+        int (*event_handler)(struct snd_soc_dapm_widget *w,
+                        struct snd_kcontrol *k, int event);
+};
+
+/*
+ * Public API - Used by component drivers to load and unload dynamic objects
+ * and their resources.
+ */
+struct snd_soc_tplg_ops {
+
+        /* external kcontrol init - used for any driver specific init */
+        int (*control_load)(struct snd_soc_component *,
+                struct snd_kcontrol_new *, struct snd_soc_tplg_ctl_hdr *);
+        int (*control_unload)(struct snd_soc_component *,
+                struct snd_soc_dobj *);
+
+        /* external widget init - used for any driver specific init */
+        int (*widget_load)(struct snd_soc_component *,
+                struct snd_soc_dapm_widget *,
+                struct snd_soc_tplg_dapm_widget *);
+        int (*widget_unload)(struct snd_soc_component *,
+                struct snd_soc_dobj *);
+
+        /* FE - used for any driver specific init */
+        int (*pcm_dai_load)(struct snd_soc_component *,
+                struct snd_soc_tplg_pcm_dai *pcm_dai, int num_fe);
+        int (*pcm_dai_unload)(struct snd_soc_component *,
+                struct snd_soc_dobj *);
+
+        /* callback to handle vendor bespoke data */
+        int (*vendor_load)(struct snd_soc_component *,
+                struct snd_soc_tplg_hdr *);
+        int (*vendor_unload)(struct snd_soc_component *,
+                struct snd_soc_tplg_hdr *);
+
+        /* completion - called at completion of firmware loading */
+        void (*complete)(struct snd_soc_component *);
+
+        /* manifest - optional to inform component of manifest */
+        int (*manifest)(struct snd_soc_component *,
+                struct snd_soc_tplg_manifest *);
+
+        /* bespoke kcontrol handlers available for binding */
+        const struct snd_soc_tplg_kcontrol_ops *io_ops;
+        int io_ops_count;
+};
+
+/* gets a pointer to data from the firmware block header */
+static inline const void *snd_soc_tplg_get_data(struct snd_soc_tplg_hdr *hdr)
+{
+        const void *ptr = hdr;
+
+        return ptr + sizeof(*hdr);
+}
+
+/* Dynamic Object loading and removal for component drivers */
+int snd_soc_tplg_component_load(struct snd_soc_component *comp,
+        struct snd_soc_tplg_ops *ops, const struct firmware *fw,
+        u32 index);
+int snd_soc_tplg_component_remove(struct snd_soc_component *comp, u32 index);
+
+/* Widget removal - widgets also removed wth component API */
+void snd_soc_tplg_widget_remove(struct snd_soc_dapm_widget *w);
+void snd_soc_tplg_widget_remove_all(struct snd_soc_dapm_context *dapm,
+        u32 index);
+
+/* Binds event handlers to dynamic widgets */
+int snd_soc_tplg_widget_bind_event(struct snd_soc_dapm_widget *w,
+        const struct snd_soc_tplg_widget_events *events, int num_events,
+        u16 event_type);
+
+#endif
diff --git a/include/sound/soc.h b/include/sound/soc.h
index f6226914acfe..93df8bf9d54a 100644
--- a/include/sound/soc.h
+++ b/include/sound/soc.h
@@ -27,6 +27,7 @@
 #include <sound/compress_driver.h>
 #include <sound/control.h>
 #include <sound/ac97_codec.h>
+#include <sound/soc-topology.h>
 
 /*
  * Convenience kcontrol builders
@@ -190,8 +191,12 @@
 #define SOC_VALUE_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmask, xitems, xtexts, xvalues) \
 {       .reg = xreg, .shift_l = xshift_l, .shift_r = xshift_r, \
         .mask = xmask, .items = xitems, .texts = xtexts, .values = xvalues}
-#define SOC_VALUE_ENUM_SINGLE(xreg, xshift, xmask, xnitmes, xtexts, xvalues) \
-        SOC_VALUE_ENUM_DOUBLE(xreg, xshift, xshift, xmask, xnitmes, xtexts, xvalues)
+#define SOC_VALUE_ENUM_SINGLE(xreg, xshift, xmask, xitems, xtexts, xvalues) \
+        SOC_VALUE_ENUM_DOUBLE(xreg, xshift, xshift, xmask, xitems, xtexts, xvalues)
+#define SOC_VALUE_ENUM_SINGLE_AUTODISABLE(xreg, xshift, xmask, xitems, xtexts, xvalues) \
+{       .reg = xreg, .shift_l = xshift, .shift_r = xshift, \
+        .mask = xmask, .items = xitems, .texts = xtexts, \
+        .values = xvalues, .autodisable = 1}
 #define SOC_ENUM_SINGLE_VIRT(xitems, xtexts) \
         SOC_ENUM_SINGLE(SND_SOC_NOPM, 0, xitems, xtexts)
 #define SOC_ENUM(xname, xenum) \
@@ -312,6 +317,11 @@
                                                         ARRAY_SIZE(xtexts), xtexts, xvalues)
 #define SOC_VALUE_ENUM_SINGLE_DECL(name, xreg, xshift, xmask, xtexts, xvalues) \
         SOC_VALUE_ENUM_DOUBLE_DECL(name, xreg, xshift, xshift, xmask, xtexts, xvalues)
+
+#define SOC_VALUE_ENUM_SINGLE_AUTODISABLE_DECL(name, xreg, xshift, xmask, xtexts, xvalues) \
+        const struct soc_enum name = SOC_VALUE_ENUM_SINGLE_AUTODISABLE(xreg, \
+                xshift, xmask, ARRAY_SIZE(xtexts), xtexts, xvalues)
+
 #define SOC_ENUM_SINGLE_VIRT_DECL(name, xtexts) \
         const struct soc_enum name = SOC_ENUM_SINGLE_VIRT(ARRAY_SIZE(xtexts), xtexts)
 
@@ -767,6 +777,9 @@ struct snd_soc_component {
 
         struct mutex io_mutex;
 
+        /* attached dynamic objects */
+        struct list_head dobj_list;
+
 #ifdef CONFIG_DEBUG_FS
         struct dentry *debugfs_root;
 #endif
@@ -819,7 +832,7 @@ struct snd_soc_codec {
         /* component */
         struct snd_soc_component component;
 
-        /* dapm */
+        /* Don't access this directly, use snd_soc_codec_get_dapm() */
         struct snd_soc_dapm_context dapm;
 
 #ifdef CONFIG_DEBUG_FS
@@ -961,6 +974,24 @@ struct snd_soc_dai_link {
 
         enum snd_soc_dpcm_trigger trigger[2]; /* trigger type for DPCM */
 
+        /* codec/machine specific init - e.g. add machine controls */
+        int (*init)(struct snd_soc_pcm_runtime *rtd);
+
+        /* optional hw_params re-writing for BE and FE sync */
+        int (*be_hw_params_fixup)(struct snd_soc_pcm_runtime *rtd,
+                        struct snd_pcm_hw_params *params);
+
+        /* machine stream operations */
+        const struct snd_soc_ops *ops;
+        const struct snd_soc_compr_ops *compr_ops;
+
+        /* For unidirectional dai links */
+        bool playback_only;
+        bool capture_only;
+
+        /* Mark this pcm with non atomic ops */
+        bool nonatomic;
+
         /* Keep DAI active over suspend */
         unsigned int ignore_suspend:1;
 
@@ -969,9 +1000,6 @@ struct snd_soc_dai_link {
         unsigned int symmetric_channels:1;
         unsigned int symmetric_samplebits:1;
 
-        /* Mark this pcm with non atomic ops */
-        bool nonatomic;
-
         /* Do not create a PCM for this DAI link (Backend link) */
         unsigned int no_pcm:1;
 
@@ -982,23 +1010,11 @@ struct snd_soc_dai_link {
         unsigned int dpcm_capture:1;
         unsigned int dpcm_playback:1;
 
+        /* DPCM used FE & BE merged format */
+        unsigned int dpcm_merged_format:1;
+
         /* pmdown_time is ignored at stop */
         unsigned int ignore_pmdown_time:1;
-
-        /* codec/machine specific init - e.g. add machine controls */
-        int (*init)(struct snd_soc_pcm_runtime *rtd);
-
-        /* optional hw_params re-writing for BE and FE sync */
-        int (*be_hw_params_fixup)(struct snd_soc_pcm_runtime *rtd,
-                        struct snd_pcm_hw_params *params);
-
-        /* machine stream operations */
-        const struct snd_soc_ops *ops;
-        const struct snd_soc_compr_ops *compr_ops;
-
-        /* For unidirectional dai links */
-        bool playback_only;
-        bool capture_only;
 };
 
 struct snd_soc_codec_conf {
@@ -1111,6 +1127,9 @@ struct snd_soc_card {
         struct list_head dapm_list;
         struct list_head dapm_dirty;
 
+        /* attached dynamic objects */
+        struct list_head dobj_list;
+
         /* Generic DAPM context for the card */
         struct snd_soc_dapm_context dapm;
         struct snd_soc_dapm_stats dapm_stats;
@@ -1170,6 +1189,7 @@ struct soc_mixer_control {
         unsigned int sign_bit;
         unsigned int invert:1;
         unsigned int autodisable:1;
+        struct snd_soc_dobj dobj;
 };
 
 struct soc_bytes {
@@ -1180,6 +1200,8 @@ struct soc_bytes {
 
 struct soc_bytes_ext {
         int max;
+        struct snd_soc_dobj dobj;
+
         /* used for TLV byte control */
         int (*get)(unsigned int __user *bytes, unsigned int size);
         int (*put)(const unsigned int __user *bytes, unsigned int size);
@@ -1200,6 +1222,8 @@ struct soc_enum {
         unsigned int mask;
         const char * const *texts;
         const unsigned int *values;
+        unsigned int autodisable:1;
+        struct snd_soc_dobj dobj;
 };
 
 /**
@@ -1282,6 +1306,58 @@ static inline struct snd_soc_dapm_context *snd_soc_component_get_dapm(
 }
 
 /**
+ * snd_soc_codec_get_dapm() - Returns the DAPM context for the CODEC
+ * @codec: The CODEC for which to get the DAPM context
+ *
+ * Note: Use this function instead of directly accessing the CODEC's dapm field
+ */
+static inline struct snd_soc_dapm_context *snd_soc_codec_get_dapm(
+        struct snd_soc_codec *codec)
+{
+        return &codec->dapm;
+}
+
+/**
+ * snd_soc_dapm_init_bias_level() - Initialize CODEC DAPM bias level
+ * @dapm: The CODEC for which to initialize the DAPM bias level
+ * @level: The DAPM level to initialize to
+ *
+ * Initializes the CODEC DAPM bias level. See snd_soc_dapm_init_bias_level().
+ */
+static inline void snd_soc_codec_init_bias_level(struct snd_soc_codec *codec,
+        enum snd_soc_bias_level level)
+{
+        snd_soc_dapm_init_bias_level(snd_soc_codec_get_dapm(codec), level);
+}
+
+/**
+ * snd_soc_dapm_get_bias_level() - Get current CODEC DAPM bias level
+ * @codec: The CODEC for which to get the DAPM bias level
+ *
+ * Returns: The current DAPM bias level of the CODEC.
+ */
+static inline enum snd_soc_bias_level snd_soc_codec_get_bias_level(
+        struct snd_soc_codec *codec)
+{
+        return snd_soc_dapm_get_bias_level(snd_soc_codec_get_dapm(codec));
+}
+
+/**
+ * snd_soc_codec_force_bias_level() - Set the CODEC DAPM bias level
+ * @codec: The CODEC for which to set the level
+ * @level: The level to set to
+ *
+ * Forces the CODEC bias level to a specific state. See
+ * snd_soc_dapm_force_bias_level().
+ */
+static inline int snd_soc_codec_force_bias_level(struct snd_soc_codec *codec,
+        enum snd_soc_bias_level level)
+{
+        return snd_soc_dapm_force_bias_level(snd_soc_codec_get_dapm(codec),
+                level);
+}
+
+/**
  * snd_soc_dapm_kcontrol_codec() - Returns the codec associated to a kcontrol
  * @kcontrol: The kcontrol
  *
diff --git a/include/sound/tlv.h b/include/sound/tlv.h
index e11e179420a1..df97d1966468 100644
--- a/include/sound/tlv.h
+++ b/include/sound/tlv.h
@@ -31,12 +31,7 @@
  *                       ~(sizeof(unsigned int) - 1)) ....
  */
 
-#define SNDRV_CTL_TLVT_CONTAINER 0      /* one level down - group of TLVs */
-#define SNDRV_CTL_TLVT_DB_SCALE 1       /* dB scale */
-#define SNDRV_CTL_TLVT_DB_LINEAR 2      /* linear volume */
-#define SNDRV_CTL_TLVT_DB_RANGE 3       /* dB range container */
-#define SNDRV_CTL_TLVT_DB_MINMAX 4      /* dB scale with min/max */
-#define SNDRV_CTL_TLVT_DB_MINMAX_MUTE 5 /* dB scale with min/max with mute */
+#include <uapi/sound/tlv.h>
 
 #define TLV_ITEM(type, ...) \
         (type), TLV_LENGTH(__VA_ARGS__), __VA_ARGS__
@@ -90,12 +85,4 @@
 
 #define TLV_DB_GAIN_MUTE        -9999999
 
-/*
- * channel-mapping TLV items
- *  TLV length must match with num_channels
- */
-#define SNDRV_CTL_TLVT_CHMAP_FIXED      0x101   /* fixed channel position */
-#define SNDRV_CTL_TLVT_CHMAP_VAR        0x102   /* channels freely swappable */
-#define SNDRV_CTL_TLVT_CHMAP_PAIRED     0x103   /* pair-wise swappable */
-
 #endif /* __SOUND_TLV_H */
diff --git a/include/target/iscsi/iscsi_target_core.h b/include/target/iscsi/iscsi_target_core.h
index 54e7af301888..0aedbb2c10e0 100644
--- a/include/target/iscsi/iscsi_target_core.h
+++ b/include/target/iscsi/iscsi_target_core.h
@@ -5,7 +5,6 @@
 #include <linux/configfs.h>
 #include <net/sock.h>
 #include <net/tcp.h>
-#include <scsi/scsi_cmnd.h>
 #include <scsi/iscsi_proto.h>
 #include <target/target_core_base.h>
 
@@ -248,10 +247,6 @@ struct iscsi_conn_ops {
         u8      DataDigest;                     /* [0,1] == [None,CRC32C] */
         u32     MaxRecvDataSegmentLength;       /* [512..2**24-1] */
         u32     MaxXmitDataSegmentLength;       /* [512..2**24-1] */
-        u8      OFMarker;                       /* [0,1] == [No,Yes] */
-        u8      IFMarker;                       /* [0,1] == [No,Yes] */
-        u32     OFMarkInt;                      /* [1..65535] */
-        u32     IFMarkInt;                      /* [1..65535] */
         /*
          * iSER specific connection parameters
          */
@@ -532,12 +527,6 @@ struct iscsi_conn {
         u32                     exp_statsn;
         /* Per connection status sequence number */
         u32                     stat_sn;
-        /* IFMarkInt's Current Value */
-        u32                     if_marker;
-        /* OFMarkInt's Current Value */
-        u32                     of_marker;
-        /* Used for calculating OFMarker offset to next PDU */
-        u32                     of_marker_offset;
 #define IPV6_ADDRESS_SPACE                              48
         unsigned char           login_ip[IPV6_ADDRESS_SPACE];
         unsigned char           local_ip[IPV6_ADDRESS_SPACE];
@@ -606,6 +595,7 @@ struct iscsi_conn {
         int                     bitmap_id;
         int                     rx_thread_active;
         struct task_struct      *rx_thread;
+        struct completion       rx_login_comp;
         int                     tx_thread_active;
         struct task_struct      *tx_thread;
         /* list_head for session connection list */
@@ -755,10 +745,10 @@ struct iscsi_node_stat_grps {
 };
 
 struct iscsi_node_acl {
+        struct se_node_acl      se_node_acl;
         struct iscsi_node_attrib node_attrib;
         struct iscsi_node_auth  node_auth;
         struct iscsi_node_stat_grps node_stat_grps;
-        struct se_node_acl      se_node_acl;
 };
 
 struct iscsi_tpg_attrib {
diff --git a/include/target/target_core_backend.h b/include/target/target_core_backend.h
index 5f1225706993..1e5c8f949bae 100644
--- a/include/target/target_core_backend.h
+++ b/include/target/target_core_backend.h
@@ -3,18 +3,7 @@
 
 #define TRANSPORT_FLAG_PASSTHROUGH              1
 
-struct target_backend_cits {
-        struct config_item_type tb_dev_cit;
-        struct config_item_type tb_dev_attrib_cit;
-        struct config_item_type tb_dev_pr_cit;
-        struct config_item_type tb_dev_wwn_cit;
-        struct config_item_type tb_dev_alua_tg_pt_gps_cit;
-        struct config_item_type tb_dev_stat_cit;
-};
-
-struct se_subsystem_api {
-        struct list_head sub_api_list;
-
+struct target_backend_ops {
         char name[16];
         char inquiry_prod[16];
         char inquiry_rev[4];
@@ -52,7 +41,7 @@ struct se_subsystem_api {
         int (*format_prot)(struct se_device *);
         void (*free_prot)(struct se_device *);
 
-        struct target_backend_cits tb_cits;
+        struct configfs_attribute **tb_dev_attrib_attrs;
 };
 
 struct sbc_ops {
@@ -60,12 +49,12 @@ struct sbc_ops {
                                      u32, enum dma_data_direction);
         sense_reason_t (*execute_sync_cache)(struct se_cmd *cmd);
         sense_reason_t (*execute_write_same)(struct se_cmd *cmd);
-        sense_reason_t (*execute_write_same_unmap)(struct se_cmd *cmd);
-        sense_reason_t (*execute_unmap)(struct se_cmd *cmd);
+        sense_reason_t (*execute_unmap)(struct se_cmd *cmd,
+                                sector_t lba, sector_t nolb);
 };
 
-int     transport_subsystem_register(struct se_subsystem_api *);
-void    transport_subsystem_release(struct se_subsystem_api *);
+int     transport_backend_register(const struct target_backend_ops *);
+void    target_backend_unregister(const struct target_backend_ops *);
 
 void    target_complete_cmd(struct se_cmd *, u8);
 void    target_complete_cmd_with_length(struct se_cmd *, u8, int);
@@ -79,22 +68,19 @@ sense_reason_t	sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops);
 u32     sbc_get_device_rev(struct se_device *dev);
 u32     sbc_get_device_type(struct se_device *dev);
 sector_t        sbc_get_write_same_sectors(struct se_cmd *cmd);
-sense_reason_t sbc_execute_unmap(struct se_cmd *cmd,
-        sense_reason_t (*do_unmap_fn)(struct se_cmd *cmd, void *priv,
-                                      sector_t lba, sector_t nolb),
-        void *priv);
 void    sbc_dif_generate(struct se_cmd *);
-sense_reason_t  sbc_dif_verify_write(struct se_cmd *, sector_t, unsigned int,
+sense_reason_t  sbc_dif_verify(struct se_cmd *, sector_t, unsigned int,
                                      unsigned int, struct scatterlist *, int);
-sense_reason_t  sbc_dif_verify_read(struct se_cmd *, sector_t, unsigned int,
-                                    unsigned int, struct scatterlist *, int);
-sense_reason_t  sbc_dif_read_strip(struct se_cmd *);
-
+void sbc_dif_copy_prot(struct se_cmd *, unsigned int, bool,
+                       struct scatterlist *, int);
 void    transport_set_vpd_proto_id(struct t10_vpd *, unsigned char *);
 int     transport_set_vpd_assoc(struct t10_vpd *, unsigned char *);
 int     transport_set_vpd_ident_type(struct t10_vpd *, unsigned char *);
 int     transport_set_vpd_ident(struct t10_vpd *, unsigned char *);
 
+extern struct configfs_attribute *sbc_attrib_attrs[];
+extern struct configfs_attribute *passthrough_attrib_attrs[];
+
 /* core helpers also used by command snooping in pscsi */
 void    *transport_kmap_data_sg(struct se_cmd *);
 void    transport_kunmap_data_sg(struct se_cmd *);
@@ -103,39 +89,7 @@ int	target_alloc_sgl(struct scatterlist **, unsigned int *, u32, bool);
 sense_reason_t  transport_generic_map_mem_to_cmd(struct se_cmd *,
                 struct scatterlist *, u32, struct scatterlist *, u32);
 
-void    array_free(void *array, int n);
-
-/* From target_core_configfs.c to setup default backend config_item_types */
-void    target_core_setup_sub_cits(struct se_subsystem_api *);
-
-/* attribute helpers from target_core_device.c for backend drivers */
-bool    se_dev_check_wce(struct se_device *);
-int     se_dev_set_max_unmap_lba_count(struct se_device *, u32);
-int     se_dev_set_max_unmap_block_desc_count(struct se_device *, u32);
-int     se_dev_set_unmap_granularity(struct se_device *, u32);
-int     se_dev_set_unmap_granularity_alignment(struct se_device *, u32);
-int     se_dev_set_max_write_same_len(struct se_device *, u32);
-int     se_dev_set_emulate_model_alias(struct se_device *, int);
-int     se_dev_set_emulate_dpo(struct se_device *, int);
-int     se_dev_set_emulate_fua_write(struct se_device *, int);
-int     se_dev_set_emulate_fua_read(struct se_device *, int);
-int     se_dev_set_emulate_write_cache(struct se_device *, int);
-int     se_dev_set_emulate_ua_intlck_ctrl(struct se_device *, int);
-int     se_dev_set_emulate_tas(struct se_device *, int);
-int     se_dev_set_emulate_tpu(struct se_device *, int);
-int     se_dev_set_emulate_tpws(struct se_device *, int);
-int     se_dev_set_emulate_caw(struct se_device *, int);
-int     se_dev_set_emulate_3pc(struct se_device *, int);
-int     se_dev_set_pi_prot_type(struct se_device *, int);
-int     se_dev_set_pi_prot_format(struct se_device *, int);
-int     se_dev_set_enforce_pr_isids(struct se_device *, int);
-int     se_dev_set_force_pr_aptpl(struct se_device *, int);
-int     se_dev_set_is_nonrot(struct se_device *, int);
-int     se_dev_set_emulate_rest_reord(struct se_device *dev, int);
-int     se_dev_set_queue_depth(struct se_device *, u32);
-int     se_dev_set_max_sectors(struct se_device *, u32);
-int     se_dev_set_optimal_sectors(struct se_device *, u32);
-int     se_dev_set_block_size(struct se_device *, u32);
+bool    target_lun_is_rdonly(struct se_cmd *);
 sense_reason_t passthrough_parse_cdb(struct se_cmd *cmd,
         sense_reason_t (*exec_cmd)(struct se_cmd *cmd));
 
diff --git a/include/target/target_core_backend_configfs.h b/include/target/target_core_backend_configfs.h
deleted file mode 100644
index 186f7a923570..000000000000
--- a/include/target/target_core_backend_configfs.h
+++ /dev/null
@@ -1,118 +0,0 @@
-#ifndef TARGET_CORE_BACKEND_CONFIGFS_H
-#define TARGET_CORE_BACKEND_CONFIGFS_H
-
-#include <target/configfs_macros.h>
-
-#define DEF_TB_DEV_ATTRIB_SHOW(_backend, _name)                         \
-static ssize_t _backend##_dev_show_attr_##_name(                        \
-        struct se_dev_attrib *da,                                       \
-        char *page)                                                     \
-{                                                                       \
-        return snprintf(page, PAGE_SIZE, "%u\n",                        \
-                        (u32)da->da_dev->dev_attrib._name);             \
-}
-
-#define DEF_TB_DEV_ATTRIB_STORE(_backend, _name)                        \
-static ssize_t _backend##_dev_store_attr_##_name(                       \
-        struct se_dev_attrib *da,                                       \
-        const char *page,                                               \
-        size_t count)                                                   \
-{                                                                       \
-        unsigned long val;                                              \
-        int ret;                                                        \
-                                                                        \
-        ret = kstrtoul(page, 0, &val);                                  \
-        if (ret < 0) {                                                  \
-                pr_err("kstrtoul() failed with ret: %d\n", ret);        \
-                return -EINVAL;                                         \
-        }                                                               \
-        ret = se_dev_set_##_name(da->da_dev, (u32)val);                 \
-                                                                        \
-        return (!ret) ? count : -EINVAL;                                \
-}
-
-#define DEF_TB_DEV_ATTRIB(_backend, _name)                              \
-DEF_TB_DEV_ATTRIB_SHOW(_backend, _name);                                \
-DEF_TB_DEV_ATTRIB_STORE(_backend, _name);
-
-#define DEF_TB_DEV_ATTRIB_RO(_backend, name)                            \
-DEF_TB_DEV_ATTRIB_SHOW(_backend, name);
-
-CONFIGFS_EATTR_STRUCT(target_backend_dev_attrib, se_dev_attrib);
-#define TB_DEV_ATTR(_backend, _name, _mode)                             \
-static struct target_backend_dev_attrib_attribute _backend##_dev_attrib_##_name = \
-                __CONFIGFS_EATTR(_name, _mode,                          \
-                _backend##_dev_show_attr_##_name,                       \
-                _backend##_dev_store_attr_##_name);
-
-#define TB_DEV_ATTR_RO(_backend, _name)                                         \
-static struct target_backend_dev_attrib_attribute _backend##_dev_attrib_##_name = \
-        __CONFIGFS_EATTR_RO(_name,                                      \
-        _backend##_dev_show_attr_##_name);
-
-/*
- * Default list of target backend device attributes as defined by
- * struct se_dev_attrib
- */
-
-#define DEF_TB_DEFAULT_ATTRIBS(_backend)                                \
-        DEF_TB_DEV_ATTRIB(_backend, emulate_model_alias);               \
-        TB_DEV_ATTR(_backend, emulate_model_alias, S_IRUGO | S_IWUSR);  \
-        DEF_TB_DEV_ATTRIB(_backend, emulate_dpo);                       \
-        TB_DEV_ATTR(_backend, emulate_dpo, S_IRUGO | S_IWUSR);          \
-        DEF_TB_DEV_ATTRIB(_backend, emulate_fua_write);                 \
-        TB_DEV_ATTR(_backend, emulate_fua_write, S_IRUGO | S_IWUSR);    \
-        DEF_TB_DEV_ATTRIB(_backend, emulate_fua_read);                  \
-        TB_DEV_ATTR(_backend, emulate_fua_read, S_IRUGO | S_IWUSR);     \
-        DEF_TB_DEV_ATTRIB(_backend, emulate_write_cache);               \
-        TB_DEV_ATTR(_backend, emulate_write_cache, S_IRUGO | S_IWUSR);  \
-        DEF_TB_DEV_ATTRIB(_backend, emulate_ua_intlck_ctrl);            \
-        TB_DEV_ATTR(_backend, emulate_ua_intlck_ctrl, S_IRUGO | S_IWUSR); \
-        DEF_TB_DEV_ATTRIB(_backend, emulate_tas);                       \
-        TB_DEV_ATTR(_backend, emulate_tas, S_IRUGO | S_IWUSR);          \
-        DEF_TB_DEV_ATTRIB(_backend, emulate_tpu);                       \
-        TB_DEV_ATTR(_backend, emulate_tpu, S_IRUGO | S_IWUSR);          \
-        DEF_TB_DEV_ATTRIB(_backend, emulate_tpws);                      \
-        TB_DEV_ATTR(_backend, emulate_tpws, S_IRUGO | S_IWUSR);         \
-        DEF_TB_DEV_ATTRIB(_backend, emulate_caw);                       \
-        TB_DEV_ATTR(_backend, emulate_caw, S_IRUGO | S_IWUSR);          \
-        DEF_TB_DEV_ATTRIB(_backend, emulate_3pc);                       \
-        TB_DEV_ATTR(_backend, emulate_3pc, S_IRUGO | S_IWUSR);          \
-        DEF_TB_DEV_ATTRIB(_backend, pi_prot_type);                      \
-        TB_DEV_ATTR(_backend, pi_prot_type, S_IRUGO | S_IWUSR);         \
-        DEF_TB_DEV_ATTRIB_RO(_backend, hw_pi_prot_type);                \
-        TB_DEV_ATTR_RO(_backend, hw_pi_prot_type);                      \
-        DEF_TB_DEV_ATTRIB(_backend, pi_prot_format);                    \
-        TB_DEV_ATTR(_backend, pi_prot_format, S_IRUGO | S_IWUSR);       \
-        DEF_TB_DEV_ATTRIB(_backend, enforce_pr_isids);                  \
-        TB_DEV_ATTR(_backend, enforce_pr_isids, S_IRUGO | S_IWUSR);     \
-        DEF_TB_DEV_ATTRIB(_backend, is_nonrot);                         \
-        TB_DEV_ATTR(_backend, is_nonrot, S_IRUGO | S_IWUSR);            \
-        DEF_TB_DEV_ATTRIB(_backend, emulate_rest_reord);                \
-        TB_DEV_ATTR(_backend, emulate_rest_reord, S_IRUGO | S_IWUSR);   \
-        DEF_TB_DEV_ATTRIB(_backend, force_pr_aptpl);                    \
-        TB_DEV_ATTR(_backend, force_pr_aptpl, S_IRUGO | S_IWUSR);       \
-        DEF_TB_DEV_ATTRIB_RO(_backend, hw_block_size);                  \
-        TB_DEV_ATTR_RO(_backend, hw_block_size);                        \
-        DEF_TB_DEV_ATTRIB(_backend, block_size);                        \
-        TB_DEV_ATTR(_backend, block_size, S_IRUGO | S_IWUSR);           \
-        DEF_TB_DEV_ATTRIB_RO(_backend, hw_max_sectors);                 \
-        TB_DEV_ATTR_RO(_backend, hw_max_sectors);                       \
-        DEF_TB_DEV_ATTRIB(_backend, optimal_sectors);                   \
-        TB_DEV_ATTR(_backend, optimal_sectors, S_IRUGO | S_IWUSR);      \
-        DEF_TB_DEV_ATTRIB_RO(_backend, hw_queue_depth);                 \
-        TB_DEV_ATTR_RO(_backend, hw_queue_depth);                       \
-        DEF_TB_DEV_ATTRIB(_backend, queue_depth);                       \
-        TB_DEV_ATTR(_backend, queue_depth, S_IRUGO | S_IWUSR);          \
-        DEF_TB_DEV_ATTRIB(_backend, max_unmap_lba_count);               \
-        TB_DEV_ATTR(_backend, max_unmap_lba_count, S_IRUGO | S_IWUSR);  \
-        DEF_TB_DEV_ATTRIB(_backend, max_unmap_block_desc_count);        \
-        TB_DEV_ATTR(_backend, max_unmap_block_desc_count, S_IRUGO | S_IWUSR); \
-        DEF_TB_DEV_ATTRIB(_backend, unmap_granularity);                 \
-        TB_DEV_ATTR(_backend, unmap_granularity, S_IRUGO | S_IWUSR);    \
-        DEF_TB_DEV_ATTRIB(_backend, unmap_granularity_alignment);       \
-        TB_DEV_ATTR(_backend, unmap_granularity_alignment, S_IRUGO | S_IWUSR); \
-        DEF_TB_DEV_ATTRIB(_backend, max_write_same_len);                \
-        TB_DEV_ATTR(_backend, max_write_same_len, S_IRUGO | S_IWUSR);
-
-#endif /* TARGET_CORE_BACKEND_CONFIGFS_H */
diff --git a/include/target/target_core_base.h b/include/target/target_core_base.h
index 480e9f82dfea..17ae2d6a4891 100644
--- a/include/target/target_core_base.h
+++ b/include/target/target_core_base.h
@@ -6,34 +6,21 @@
 #include <linux/dma-mapping.h>
 #include <linux/blkdev.h>
 #include <linux/percpu_ida.h>
-#include <scsi/scsi_cmnd.h>
 #include <net/sock.h>
 #include <net/tcp.h>
 
-#define TARGET_CORE_MOD_VERSION         "v4.1.0"
-#define TARGET_CORE_VERSION             TARGET_CORE_MOD_VERSION
+#define TARGET_CORE_VERSION             "v5.0"
 
-/* Maximum Number of LUNs per Target Portal Group */
-/* Don't raise above 511 or REPORT_LUNS needs to handle >1 page */
-#define TRANSPORT_MAX_LUNS_PER_TPG              256
 /*
- * By default we use 32-byte CDBs in TCM Core and subsystem plugin code.
- *
- * Note that both include/scsi/scsi_cmnd.h:MAX_COMMAND_SIZE and
- * include/linux/blkdev.h:BLOCK_MAX_CDB as of v2.6.36-rc4 still use
- * 16-byte CDBs by default and require an extra allocation for
- * 32-byte CDBs to because of legacy issues.
- *
- * Within TCM Core there are no such legacy limitiations, so we go ahead
- * use 32-byte CDBs by default and use include/scsi/scsi.h:scsi_command_size()
- * within all TCM Core and subsystem plugin code.
+ * Maximum size of a CDB that can be stored in se_cmd without allocating
+ * memory dynamically for the CDB.
  */
 #define TCM_MAX_COMMAND_SIZE                    32
 /*
  * From include/scsi/scsi_cmnd.h:SCSI_SENSE_BUFFERSIZE, currently
  * defined 96, but the real limit is 252 (or 260 including the header)
  */
-#define TRANSPORT_SENSE_BUFFER                  SCSI_SENSE_BUFFERSIZE
+#define TRANSPORT_SENSE_BUFFER                  96
 /* Used by transport_send_check_condition_and_sense() */
 #define SPC_SENSE_KEY_OFFSET                    2
 #define SPC_ADD_SENSE_LEN_OFFSET                7
@@ -79,12 +66,6 @@
 #define DA_MAX_WRITE_SAME_LEN                   0
 /* Use a model alias based on the configfs backend device name */
 #define DA_EMULATE_MODEL_ALIAS                  0
-/* Emulation for Direct Page Out */
-#define DA_EMULATE_DPO                          0
-/* Emulation for Forced Unit Access WRITEs */
-#define DA_EMULATE_FUA_WRITE                    1
-/* Emulation for Forced Unit Access READs */
-#define DA_EMULATE_FUA_READ                     0
 /* Emulation for WriteCache and SYNCHRONIZE_CACHE */
 #define DA_EMULATE_WRITE_CACHE                  0
 /* Emulation for UNIT ATTENTION Interlock Control */
@@ -125,18 +106,6 @@ enum hba_flags_table {
         HBA_FLAGS_PSCSI_MODE    = 0x02,
 };
 
-/* struct se_lun->lun_status */
-enum transport_lun_status_table {
-        TRANSPORT_LUN_STATUS_FREE = 0,
-        TRANSPORT_LUN_STATUS_ACTIVE = 1,
-};
-
-/* struct se_portal_group->se_tpg_type */
-enum transport_tpg_type_table {
-        TRANSPORT_TPG_TYPE_NORMAL = 0,
-        TRANSPORT_TPG_TYPE_DISCOVERY = 1,
-};
-
 /* Special transport agnostic struct se_cmd->t_states */
 enum transport_state_table {
         TRANSPORT_NO_STATE      = 0,
@@ -167,14 +136,13 @@ enum se_cmd_flags_table {
         SCF_PASSTHROUGH_SG_TO_MEM_NOALLOC = 0x00020000,
         SCF_COMPARE_AND_WRITE           = 0x00080000,
         SCF_COMPARE_AND_WRITE_POST      = 0x00100000,
+        SCF_PASSTHROUGH_PROT_SG_TO_MEM_NOALLOC = 0x00200000,
 };
 
 /* struct se_dev_entry->lun_flags and struct se_lun->lun_access */
 enum transport_lunflags_table {
-        TRANSPORT_LUNFLAGS_NO_ACCESS            = 0x00,
-        TRANSPORT_LUNFLAGS_INITIATOR_ACCESS     = 0x01,
-        TRANSPORT_LUNFLAGS_READ_ONLY            = 0x02,
-        TRANSPORT_LUNFLAGS_READ_WRITE           = 0x04,
+        TRANSPORT_LUNFLAGS_READ_ONLY            = 0x01,
+        TRANSPORT_LUNFLAGS_READ_WRITE           = 0x02,
 };
 
 /*
@@ -323,22 +291,13 @@ struct t10_alua_tg_pt_gp {
         struct se_device *tg_pt_gp_dev;
         struct config_group tg_pt_gp_group;
         struct list_head tg_pt_gp_list;
-        struct list_head tg_pt_gp_mem_list;
-        struct se_port *tg_pt_gp_alua_port;
+        struct list_head tg_pt_gp_lun_list;
+        struct se_lun *tg_pt_gp_alua_lun;
         struct se_node_acl *tg_pt_gp_alua_nacl;
         struct delayed_work tg_pt_gp_transition_work;
         struct completion *tg_pt_gp_transition_complete;
 };
 
-struct t10_alua_tg_pt_gp_member {
-        bool tg_pt_gp_assoc;
-        atomic_t tg_pt_gp_mem_ref_cnt;
-        spinlock_t tg_pt_gp_mem_lock;
-        struct t10_alua_tg_pt_gp *tg_pt_gp;
-        struct se_port *tg_pt;
-        struct list_head tg_pt_gp_mem_list;
-};
-
 struct t10_vpd {
         unsigned char device_identifier[INQUIRY_VPD_DEVICE_IDENTIFIER_LEN];
         int protocol_identifier_set;
@@ -383,15 +342,16 @@ struct t10_pr_registration {
         int pr_res_scope;
         /* Used for fabric initiator WWPNs using a ISID */
         bool isid_present_at_reg;
-        u32 pr_res_mapped_lun;
-        u32 pr_aptpl_target_lun;
+        u64 pr_res_mapped_lun;
+        u64 pr_aptpl_target_lun;
+        u16 tg_pt_sep_rtpi;
         u32 pr_res_generation;
         u64 pr_reg_bin_isid;
         u64 pr_res_key;
         atomic_t pr_res_holders;
         struct se_node_acl *pr_reg_nacl;
+        /* Used by ALL_TG_PT=1 registration with deve->pr_ref taken */
         struct se_dev_entry *pr_reg_deve;
-        struct se_lun *pr_reg_tg_pt_lun;
         struct list_head pr_reg_list;
         struct list_head pr_reg_abort_list;
         struct list_head pr_reg_aptpl_list;
@@ -431,7 +391,7 @@ struct se_tmr_req {
         u8                      response;
         int                     call_transport;
         /* Reference to ITT that Task Mgmt should be performed */
-        u32                     ref_task_tag;
+        u64                     ref_task_tag;
         void                    *fabric_tmr_ptr;
         struct se_cmd           *task_cmd;
         struct se_device        *tmr_dev;
@@ -484,6 +444,7 @@ struct se_cmd {
         u8                      scsi_asc;
         u8                      scsi_ascq;
         u16                     scsi_sense_length;
+        u64                     tag; /* SAM command identifier aka task tag */
         /* Delay for ALUA Active/NonOptimized state access in milliseconds */
         int                     alua_nonop_delay;
         /* See include/linux/dma-mapping.h */
@@ -502,7 +463,7 @@ struct se_cmd {
         /* Total size in bytes associated with command */
         u32                     data_length;
         u32                     residual_count;
-        u32                     orig_fe_lun;
+        u64                     orig_fe_lun;
         /* Persistent Reservation key */
         u64                     pr_res_key;
         /* Used for sense data */
@@ -510,7 +471,6 @@ struct se_cmd {
         struct list_head        se_delayed_node;
         struct list_head        se_qf_node;
         struct se_device      *se_dev;
-        struct se_dev_entry   *se_deve;
         struct se_lun           *se_lun;
         /* Only used for internal passthrough and legacy TCM fabric modules */
         struct se_session       *se_sess;
@@ -520,9 +480,8 @@ struct se_cmd {
         struct kref             cmd_kref;
         const struct target_core_fabric_ops *se_tfo;
         sense_reason_t          (*execute_cmd)(struct se_cmd *);
-        sense_reason_t          (*execute_rw)(struct se_cmd *, struct scatterlist *,
-                                              u32, enum dma_data_direction);
         sense_reason_t (*transport_complete_callback)(struct se_cmd *, bool);
+        void                    *protocol_data;
 
         unsigned char           *t_task_cdb;
         unsigned char           __t_task_cdb[TCM_MAX_COMMAND_SIZE];
@@ -578,7 +537,6 @@ struct se_cmd {
 struct se_ua {
         u8                      ua_asc;
         u8                      ua_ascq;
-        struct se_node_acl      *ua_nacl;
         struct list_head        ua_nacl_list;
 };
 
@@ -594,10 +552,10 @@ struct se_node_acl {
         char                    acl_tag[MAX_ACL_TAG_SIZE];
         /* Used for PR SPEC_I_PT=1 and REGISTER_AND_MOVE */
         atomic_t                acl_pr_ref_count;
-        struct se_dev_entry     **device_list;
+        struct hlist_head       lun_entry_hlist;
         struct se_session       *nacl_sess;
         struct se_portal_group *se_tpg;
-        spinlock_t              device_list_lock;
+        struct mutex            lun_entry_mutex;
         spinlock_t              nacl_sess_lock;
         struct config_group     acl_group;
         struct config_group     acl_attrib_group;
@@ -641,33 +599,37 @@ struct se_ml_stat_grps {
 
 struct se_lun_acl {
         char                    initiatorname[TRANSPORT_IQN_LEN];
-        u32                     mapped_lun;
+        u64                     mapped_lun;
         struct se_node_acl      *se_lun_nacl;
         struct se_lun           *se_lun;
-        struct list_head        lacl_list;
         struct config_group     se_lun_group;
         struct se_ml_stat_grps  ml_stat_grps;
 };
 
 struct se_dev_entry {
-        bool                    def_pr_registered;
         /* See transport_lunflags_table */
-        u32                     lun_flags;
-        u32                     mapped_lun;
-        u32                     total_cmds;
+        u64                     mapped_lun;
         u64                     pr_res_key;
         u64                     creation_time;
+        u32                     lun_flags;
         u32                     attach_count;
-        u64                     read_bytes;
-        u64                     write_bytes;
+        atomic_long_t           total_cmds;
+        atomic_long_t           read_bytes;
+        atomic_long_t           write_bytes;
         atomic_t                ua_count;
         /* Used for PR SPEC_I_PT=1 and REGISTER_AND_MOVE */
-        atomic_t                pr_ref_count;
-        struct se_lun_acl       *se_lun_acl;
+        struct kref             pr_kref;
+        struct completion       pr_comp;
+        struct se_lun_acl __rcu *se_lun_acl;
         spinlock_t              ua_lock;
-        struct se_lun           *se_lun;
+        struct se_lun __rcu     *se_lun;
+#define DEF_PR_REG_ACTIVE               1
+        unsigned long           deve_flags;
         struct list_head        alua_port_list;
+        struct list_head        lun_link;
         struct list_head        ua_list;
+        struct hlist_node       link;
+        struct rcu_head         rcu_head;
 };
 
 struct se_dev_attrib {
@@ -712,25 +674,48 @@ struct se_port_stat_grps {
         struct config_group scsi_transport_group;
 };
 
+struct scsi_port_stats {
+        atomic_long_t   cmd_pdus;
+        atomic_long_t   tx_data_octets;
+        atomic_long_t   rx_data_octets;
+};
+
 struct se_lun {
+        u64                     unpacked_lun;
 #define SE_LUN_LINK_MAGIC                       0xffff7771
         u32                     lun_link_magic;
-        /* See transport_lun_status_table */
-        enum transport_lun_status_table lun_status;
         u32                     lun_access;
         u32                     lun_flags;
-        u32                     unpacked_lun;
+        u32                     lun_index;
+
+        /* RELATIVE TARGET PORT IDENTIFER */
+        u16                     lun_rtpi;
         atomic_t                lun_acl_count;
-        spinlock_t              lun_acl_lock;
-        spinlock_t              lun_sep_lock;
-        struct completion       lun_shutdown_comp;
-        struct list_head        lun_acl_list;
-        struct se_device        *lun_se_dev;
-        struct se_port          *lun_sep;
+        struct se_device __rcu  *lun_se_dev;
+
+        struct list_head        lun_deve_list;
+        spinlock_t              lun_deve_lock;
+
+        /* ALUA state */
+        int                     lun_tg_pt_secondary_stat;
+        int                     lun_tg_pt_secondary_write_md;
+        atomic_t                lun_tg_pt_secondary_offline;
+        struct mutex            lun_tg_pt_md_mutex;
+
+        /* ALUA target port group linkage */
+        struct list_head        lun_tg_pt_gp_link;
+        struct t10_alua_tg_pt_gp *lun_tg_pt_gp;
+        spinlock_t              lun_tg_pt_gp_lock;
+
+        struct se_portal_group  *lun_tpg;
+        struct scsi_port_stats  lun_stats;
         struct config_group     lun_group;
         struct se_port_stat_grps port_stat_grps;
         struct completion       lun_ref_comp;
         struct percpu_ref       lun_ref;
+        struct list_head        lun_dev_link;
+        struct hlist_node       link;
+        struct rcu_head         rcu_head;
 };
 
 struct se_dev_stat_grps {
@@ -753,7 +738,6 @@ struct se_device {
 #define DF_EMULATED_VPD_UNIT_SERIAL             0x00000004
 #define DF_USING_UDEV_PATH                      0x00000008
 #define DF_USING_ALIAS                          0x00000010
-        u32                     dev_port_count;
         /* Physical device queue depth */
         u32                     queue_depth;
         /* Used for SPC-2 reservations enforce of ISIDs */
@@ -770,7 +754,7 @@ struct se_device {
         atomic_t                dev_ordered_id;
         atomic_t                dev_ordered_sync;
         atomic_t                dev_qf_count;
-        int                     export_count;
+        u32                     export_count;
         spinlock_t              delayed_cmd_lock;
         spinlock_t              execute_task_lock;
         spinlock_t              dev_reservation_lock;
@@ -812,12 +796,15 @@ struct se_device {
 #define SE_UDEV_PATH_LEN 512            /* must be less than PAGE_SIZE */
         unsigned char           udev_path[SE_UDEV_PATH_LEN];
         /* Pointer to template of function pointers for transport */
-        struct se_subsystem_api *transport;
+        const struct target_backend_ops *transport;
         /* Linked list for struct se_hba struct se_device list */
         struct list_head        dev_list;
         struct se_lun           xcopy_lun;
         /* Protection Information */
         int                     prot_length;
+        /* For se_lun->lun_se_dev RCU read-side critical access */
+        u32                     hba_index;
+        struct rcu_head         rcu_head;
 };
 
 struct se_hba {
@@ -834,33 +821,7 @@ struct se_hba {
         spinlock_t              device_lock;
         struct config_group     hba_group;
         struct mutex            hba_access_mutex;
-        struct se_subsystem_api *transport;
-};
-
-struct scsi_port_stats {
-       u64     cmd_pdus;
-       u64     tx_data_octets;
-       u64     rx_data_octets;
-};
-
-struct se_port {
-        /* RELATIVE TARGET PORT IDENTIFER */
-        u16             sep_rtpi;
-        int             sep_tg_pt_secondary_stat;
-        int             sep_tg_pt_secondary_write_md;
-        u32             sep_index;
-        struct scsi_port_stats sep_stats;
-        /* Used for ALUA Target Port Groups membership */
-        atomic_t        sep_tg_pt_secondary_offline;
-        /* Used for PR ALL_TG_PT=1 */
-        atomic_t        sep_tg_pt_ref_cnt;
-        spinlock_t      sep_alua_lock;
-        struct mutex    sep_tg_pt_md_mutex;
-        struct t10_alua_tg_pt_gp_member *sep_alua_tg_pt_gp_mem;
-        struct se_lun *sep_lun;
-        struct se_portal_group *sep_tpg;
-        struct list_head sep_alua_list;
-        struct list_head sep_list;
+        struct target_backend   *backend;
 };
 
 struct se_tpg_np {
@@ -869,24 +830,26 @@ struct se_tpg_np {
 };
 
 struct se_portal_group {
-        /* Type of target portal group, see transport_tpg_type_table */
-        enum transport_tpg_type_table se_tpg_type;
+        /*
+         * PROTOCOL IDENTIFIER value per SPC4, 7.5.1.
+         *
+         * Negative values can be used by fabric drivers for internal use TPGs.
+         */
+        int                     proto_id;
         /* Number of ACLed Initiator Nodes for this TPG */
         u32                     num_node_acls;
         /* Used for PR SPEC_I_PT=1 and REGISTER_AND_MOVE */
         atomic_t                tpg_pr_ref_count;
         /* Spinlock for adding/removing ACLed Nodes */
-        spinlock_t              acl_node_lock;
+        struct mutex            acl_node_mutex;
         /* Spinlock for adding/removing sessions */
         spinlock_t              session_lock;
-        spinlock_t              tpg_lun_lock;
-        /* Pointer to $FABRIC_MOD portal group */
-        void                    *se_tpg_fabric_ptr;
+        struct mutex            tpg_lun_mutex;
         struct list_head        se_tpg_node;
         /* linked list for initiator ACL list */
         struct list_head        acl_node_list;
-        struct se_lun           **tpg_lun_list;
-        struct se_lun           tpg_virt_lun0;
+        struct hlist_head       tpg_lun_hlist;
+        struct se_lun           *tpg_virt_lun0;
         /* List of TCM sessions associated wth this TPG */
         struct list_head        tpg_sess_list;
         /* Pointer to $FABRIC_MOD dependent code */
diff --git a/include/target/target_core_configfs.h b/include/target/target_core_configfs.h
deleted file mode 100644
index b99c01170392..000000000000
--- a/include/target/target_core_configfs.h
+++ /dev/null
@@ -1,48 +0,0 @@
-#define TARGET_CORE_CONFIGFS_VERSION TARGET_CORE_MOD_VERSION
-
-#define TARGET_CORE_CONFIG_ROOT "/sys/kernel/config"
-
-#define TARGET_CORE_NAME_MAX_LEN        64
-#define TARGET_FABRIC_NAME_SIZE         32
-
-struct target_fabric_configfs_template {
-        struct config_item_type tfc_discovery_cit;
-        struct config_item_type tfc_wwn_cit;
-        struct config_item_type tfc_wwn_fabric_stats_cit;
-        struct config_item_type tfc_tpg_cit;
-        struct config_item_type tfc_tpg_base_cit;
-        struct config_item_type tfc_tpg_lun_cit;
-        struct config_item_type tfc_tpg_port_cit;
-        struct config_item_type tfc_tpg_port_stat_cit;
-        struct config_item_type tfc_tpg_np_cit;
-        struct config_item_type tfc_tpg_np_base_cit;
-        struct config_item_type tfc_tpg_attrib_cit;
-        struct config_item_type tfc_tpg_auth_cit;
-        struct config_item_type tfc_tpg_param_cit;
-        struct config_item_type tfc_tpg_nacl_cit;
-        struct config_item_type tfc_tpg_nacl_base_cit;
-        struct config_item_type tfc_tpg_nacl_attrib_cit;
-        struct config_item_type tfc_tpg_nacl_auth_cit;
-        struct config_item_type tfc_tpg_nacl_param_cit;
-        struct config_item_type tfc_tpg_nacl_stat_cit;
-        struct config_item_type tfc_tpg_mappedlun_cit;
-        struct config_item_type tfc_tpg_mappedlun_stat_cit;
-};
-
-struct target_fabric_configfs {
-        char                    tf_name[TARGET_FABRIC_NAME_SIZE];
-        atomic_t                tf_access_cnt;
-        struct list_head        tf_list;
-        struct config_group     tf_group;
-        struct config_group     tf_disc_group;
-        struct config_group     *tf_default_groups[2];
-        /* Pointer to fabric's config_item */
-        struct config_item      *tf_fabric;
-        /* Passed from fabric modules */
-        struct config_item_type *tf_fabric_cit;
-        /* Pointer to fabric's struct module */
-        struct module *tf_module;
-        struct target_core_fabric_ops tf_ops;
-        struct target_fabric_configfs_template tf_cit_tmpl;
-};
-
diff --git a/include/target/target_core_fabric.h b/include/target/target_core_fabric.h
index 0f4dc3768587..18afef91b447 100644
--- a/include/target/target_core_fabric.h
+++ b/include/target/target_core_fabric.h
@@ -4,20 +4,11 @@
 struct target_core_fabric_ops {
         struct module *module;
         const char *name;
+        size_t node_acl_size;
         char *(*get_fabric_name)(void);
-        u8 (*get_fabric_proto_ident)(struct se_portal_group *);
         char *(*tpg_get_wwn)(struct se_portal_group *);
         u16 (*tpg_get_tag)(struct se_portal_group *);
         u32 (*tpg_get_default_depth)(struct se_portal_group *);
-        u32 (*tpg_get_pr_transport_id)(struct se_portal_group *,
-                                struct se_node_acl *,
-                                struct t10_pr_registration *, int *,
-                                unsigned char *);
-        u32 (*tpg_get_pr_transport_id_len)(struct se_portal_group *,
-                                struct se_node_acl *,
-                                struct t10_pr_registration *, int *);
-        char *(*tpg_parse_pr_out_transport_id)(struct se_portal_group *,
-                                const char *, u32 *, char **);
         int (*tpg_check_demo_mode)(struct se_portal_group *);
         int (*tpg_check_demo_mode_cache)(struct se_portal_group *);
         int (*tpg_check_demo_mode_write_protect)(struct se_portal_group *);
@@ -36,10 +27,6 @@ struct target_core_fabric_ops {
          * WRITE_STRIP and READ_INSERT operations.
          */
         int (*tpg_check_prot_fabric_only)(struct se_portal_group *);
-        struct se_node_acl *(*tpg_alloc_fabric_acl)(
-                                        struct se_portal_group *);
-        void (*tpg_release_fabric_acl)(struct se_portal_group *,
-                                        struct se_node_acl *);
         u32 (*tpg_get_inst_index)(struct se_portal_group *);
         /*
          * Optional to release struct se_cmd and fabric dependent allocated
@@ -50,7 +37,6 @@ struct target_core_fabric_ops {
          */
         int (*check_stop_free)(struct se_cmd *);
         void (*release_cmd)(struct se_cmd *);
-        void (*put_session)(struct se_session *);
         /*
          * Called with spin_lock_bh(struct se_portal_group->session_lock held.
          */
@@ -66,7 +52,6 @@ struct target_core_fabric_ops {
         int (*write_pending)(struct se_cmd *);
         int (*write_pending_status)(struct se_cmd *);
         void (*set_default_node_attributes)(struct se_node_acl *);
-        u32 (*get_task_tag)(struct se_cmd *);
         int (*get_cmd_state)(struct se_cmd *);
         int (*queue_data_in)(struct se_cmd *);
         int (*queue_status)(struct se_cmd *);
@@ -88,9 +73,8 @@ struct target_core_fabric_ops {
         struct se_tpg_np *(*fabric_make_np)(struct se_portal_group *,
                                 struct config_group *, const char *);
         void (*fabric_drop_np)(struct se_tpg_np *);
-        struct se_node_acl *(*fabric_make_nodeacl)(struct se_portal_group *,
-                                struct config_group *, const char *);
-        void (*fabric_drop_nodeacl)(struct se_node_acl *);
+        int (*fabric_init_nodeacl)(struct se_node_acl *, const char *);
+        void (*fabric_cleanup_nodeacl)(struct se_node_acl *);
 
         struct configfs_attribute **tfc_discovery_attrs;
         struct configfs_attribute **tfc_wwn_attrs;
@@ -132,16 +116,16 @@ void	transport_deregister_session(struct se_session *);
 void    transport_init_se_cmd(struct se_cmd *,
                 const struct target_core_fabric_ops *,
                 struct se_session *, u32, int, int, unsigned char *);
-sense_reason_t transport_lookup_cmd_lun(struct se_cmd *, u32);
+sense_reason_t transport_lookup_cmd_lun(struct se_cmd *, u64);
 sense_reason_t target_setup_cmd_from_cdb(struct se_cmd *, unsigned char *);
 int     target_submit_cmd_map_sgls(struct se_cmd *, struct se_session *,
-                unsigned char *, unsigned char *, u32, u32, int, int, int,
+                unsigned char *, unsigned char *, u64, u32, int, int, int,
                 struct scatterlist *, u32, struct scatterlist *, u32,
                 struct scatterlist *, u32);
 int     target_submit_cmd(struct se_cmd *, struct se_session *, unsigned char *,
-                unsigned char *, u32, u32, int, int, int);
+                unsigned char *, u64, u32, int, int, int);
 int     target_submit_tmr(struct se_cmd *se_cmd, struct se_session *se_sess,
-                unsigned char *sense, u32 unpacked_lun,
+                unsigned char *sense, u64 unpacked_lun,
                 void *fabric_tmr_ptr, unsigned char tm_type,
                 gfp_t, unsigned int, int);
 int     transport_handle_cdb_direct(struct se_cmd *);
@@ -155,8 +139,8 @@ bool	transport_wait_for_tasks(struct se_cmd *);
 int     transport_check_aborted_status(struct se_cmd *, int);
 int     transport_send_check_condition_and_sense(struct se_cmd *,
                 sense_reason_t, int);
-int     target_get_sess_cmd(struct se_session *, struct se_cmd *, bool);
-int     target_put_sess_cmd(struct se_session *, struct se_cmd *);
+int     target_get_sess_cmd(struct se_cmd *, bool);
+int     target_put_sess_cmd(struct se_cmd *);
 void    target_sess_cmd_list_set_waiting(struct se_session *);
 void    target_wait_for_sess_cmds(struct se_session *);
 
@@ -167,52 +151,19 @@ void	core_tmr_release_req(struct se_tmr_req *);
 int     transport_generic_handle_tmr(struct se_cmd *);
 void    transport_generic_request_failure(struct se_cmd *, sense_reason_t);
 void    __target_execute_cmd(struct se_cmd *);
-int     transport_lookup_tmr_lun(struct se_cmd *, u32);
+int     transport_lookup_tmr_lun(struct se_cmd *, u64);
 
 struct se_node_acl *core_tpg_get_initiator_node_acl(struct se_portal_group *tpg,
                 unsigned char *);
 struct se_node_acl *core_tpg_check_initiator_node_acl(struct se_portal_group *,
                 unsigned char *);
-void    core_tpg_clear_object_luns(struct se_portal_group *);
-struct se_node_acl *core_tpg_add_initiator_node_acl(struct se_portal_group *,
-                struct se_node_acl *, const char *, u32);
-int     core_tpg_del_initiator_node_acl(struct se_portal_group *,
-                struct se_node_acl *, int);
 int     core_tpg_set_initiator_node_queue_depth(struct se_portal_group *,
                 unsigned char *, u32, int);
 int     core_tpg_set_initiator_node_tag(struct se_portal_group *,
                 struct se_node_acl *, const char *);
-int     core_tpg_register(const struct target_core_fabric_ops *,
-                struct se_wwn *, struct se_portal_group *, void *, int);
+int     core_tpg_register(struct se_wwn *, struct se_portal_group *, int);
 int     core_tpg_deregister(struct se_portal_group *);
 
-/* SAS helpers */
-u8      sas_get_fabric_proto_ident(struct se_portal_group *);
-u32     sas_get_pr_transport_id(struct se_portal_group *, struct se_node_acl *,
-                struct t10_pr_registration *, int *, unsigned char *);
-u32     sas_get_pr_transport_id_len(struct se_portal_group *, struct se_node_acl *,
-                struct t10_pr_registration *, int *);
-char    *sas_parse_pr_out_transport_id(struct se_portal_group *, const char *,
-                u32 *, char **);
-
-/* FC helpers */
-u8      fc_get_fabric_proto_ident(struct se_portal_group *);
-u32     fc_get_pr_transport_id(struct se_portal_group *, struct se_node_acl *,
-                struct t10_pr_registration *, int *, unsigned char *);
-u32     fc_get_pr_transport_id_len(struct se_portal_group *, struct se_node_acl *,
-                struct t10_pr_registration *, int *);
-char    *fc_parse_pr_out_transport_id(struct se_portal_group *, const char *,
-                u32 *, char **);
-
-/* iSCSI helpers */
-u8      iscsi_get_fabric_proto_ident(struct se_portal_group *);
-u32     iscsi_get_pr_transport_id(struct se_portal_group *, struct se_node_acl *,
-                struct t10_pr_registration *, int *, unsigned char *);
-u32     iscsi_get_pr_transport_id_len(struct se_portal_group *, struct se_node_acl *,
-                struct t10_pr_registration *, int *);
-char    *iscsi_parse_pr_out_transport_id(struct se_portal_group *, const char *,
-                u32 *, char **);
-
 /*
  * The LIO target core uses DMA_TO_DEVICE to mean that data is going
  * to the target (eg handling a WRITE) and DMA_FROM_DEVICE to mean
diff --git a/include/trace/define_trace.h b/include/trace/define_trace.h
index 02e1003568a4..09b3880105a9 100644
--- a/include/trace/define_trace.h
+++ b/include/trace/define_trace.h
@@ -87,7 +87,8 @@
 #define DECLARE_TRACE(name, proto, args)
 
 #ifdef CONFIG_EVENT_TRACING
-#include <trace/ftrace.h>
+#include <trace/trace_events.h>
+#include <trace/perf.h>
 #endif
 
 #undef TRACE_EVENT
diff --git a/include/trace/events/btrfs.h b/include/trace/events/btrfs.h
index 7f79cf459591..0b73af9be12f 100644
--- a/include/trace/events/btrfs.h
+++ b/include/trace/events/btrfs.h
@@ -1117,61 +1117,6 @@ DEFINE_EVENT(btrfs__workqueue_done, btrfs_workqueue_destroy,
         TP_ARGS(wq)
 );
 
-#define show_oper_type(type)                                            \
-        __print_symbolic(type,                                          \
-                { BTRFS_QGROUP_OPER_ADD_EXCL,   "OPER_ADD_EXCL" },      \
-                { BTRFS_QGROUP_OPER_ADD_SHARED, "OPER_ADD_SHARED" },    \
-                { BTRFS_QGROUP_OPER_SUB_EXCL,   "OPER_SUB_EXCL" },      \
-                { BTRFS_QGROUP_OPER_SUB_SHARED, "OPER_SUB_SHARED" })
-
-DECLARE_EVENT_CLASS(btrfs_qgroup_oper,
-
-        TP_PROTO(struct btrfs_qgroup_operation *oper),
-
-        TP_ARGS(oper),
-
-        TP_STRUCT__entry(
-                __field(        u64,  ref_root          )
-                __field(        u64,  bytenr            )
-                __field(        u64,  num_bytes         )
-                __field(        u64,  seq               )
-                __field(        int,  type              )
-                __field(        u64,  elem_seq          )
-        ),
-
-        TP_fast_assign(
-                __entry->ref_root       = oper->ref_root;
-                __entry->bytenr         = oper->bytenr,
-                __entry->num_bytes      = oper->num_bytes;
-                __entry->seq            = oper->seq;
-                __entry->type           = oper->type;
-                __entry->elem_seq       = oper->elem.seq;
-        ),
-
-        TP_printk("ref_root = %llu, bytenr = %llu, num_bytes = %llu, "
-                  "seq = %llu, elem.seq = %llu, type = %s",
-                  (unsigned long long)__entry->ref_root,
-                  (unsigned long long)__entry->bytenr,
-                  (unsigned long long)__entry->num_bytes,
-                  (unsigned long long)__entry->seq,
-                  (unsigned long long)__entry->elem_seq,
-                  show_oper_type(__entry->type))
-);
-
-DEFINE_EVENT(btrfs_qgroup_oper, btrfs_qgroup_account,
-
-        TP_PROTO(struct btrfs_qgroup_operation *oper),
-
-        TP_ARGS(oper)
-);
-
-DEFINE_EVENT(btrfs_qgroup_oper, btrfs_qgroup_record_ref,
-
-        TP_PROTO(struct btrfs_qgroup_operation *oper),
-
-        TP_ARGS(oper)
-);
-
 #endif /* _TRACE_BTRFS_H */
 
 /* This part must be outside protection */
diff --git a/include/trace/events/ext4.h b/include/trace/events/ext4.h
index 08ec3dd27630..594b4b29a224 100644
--- a/include/trace/events/ext4.h
+++ b/include/trace/events/ext4.h
@@ -1185,15 +1185,14 @@ TRACE_EVENT(ext4_da_update_reserve_space,
 );
 
 TRACE_EVENT(ext4_da_reserve_space,
-        TP_PROTO(struct inode *inode, int md_needed),
+        TP_PROTO(struct inode *inode),
 
-        TP_ARGS(inode, md_needed),
+        TP_ARGS(inode),
 
         TP_STRUCT__entry(
                 __field(        dev_t,  dev                     )
                 __field(        ino_t,  ino                     )
                 __field(        __u64,  i_blocks                )
-                __field(        int,    md_needed               )
                 __field(        int,    reserved_data_blocks    )
                 __field(        int,    reserved_meta_blocks    )
                 __field(        __u16,  mode                    )
@@ -1203,18 +1202,17 @@ TRACE_EVENT(ext4_da_reserve_space,
                 __entry->dev    = inode->i_sb->s_dev;
                 __entry->ino    = inode->i_ino;
                 __entry->i_blocks = inode->i_blocks;
-                __entry->md_needed = md_needed;
                 __entry->reserved_data_blocks = EXT4_I(inode)->i_reserved_data_blocks;
                 __entry->reserved_meta_blocks = EXT4_I(inode)->i_reserved_meta_blocks;
                 __entry->mode   = inode->i_mode;
         ),
 
-        TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu md_needed %d "
+        TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu "
                   "reserved_data_blocks %d reserved_meta_blocks %d",
                   MAJOR(__entry->dev), MINOR(__entry->dev),
                   (unsigned long) __entry->ino,
                   __entry->mode, __entry->i_blocks,
-                  __entry->md_needed, __entry->reserved_data_blocks,
+                  __entry->reserved_data_blocks,
                   __entry->reserved_meta_blocks)
 );
 
@@ -2478,6 +2476,31 @@ TRACE_EVENT(ext4_collapse_range,
                   __entry->offset, __entry->len)
 );
 
+TRACE_EVENT(ext4_insert_range,
+        TP_PROTO(struct inode *inode, loff_t offset, loff_t len),
+
+        TP_ARGS(inode, offset, len),
+
+        TP_STRUCT__entry(
+                __field(dev_t,  dev)
+                __field(ino_t,  ino)
+                __field(loff_t, offset)
+                __field(loff_t, len)
+        ),
+
+        TP_fast_assign(
+                __entry->dev    = inode->i_sb->s_dev;
+                __entry->ino    = inode->i_ino;
+                __entry->offset = offset;
+                __entry->len    = len;
+        ),
+
+        TP_printk("dev %d,%d ino %lu offset %lld len %lld",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  (unsigned long) __entry->ino,
+                  __entry->offset, __entry->len)
+);
+
 TRACE_EVENT(ext4_es_shrink,
         TP_PROTO(struct super_block *sb, int nr_shrunk, u64 scan_time,
                  int nr_skipped, int retried),
diff --git a/include/trace/events/f2fs.h b/include/trace/events/f2fs.h
index e202dec22e1d..04856a2d8c82 100644
--- a/include/trace/events/f2fs.h
+++ b/include/trace/events/f2fs.h
@@ -13,6 +13,10 @@ TRACE_DEFINE_ENUM(NODE);
 TRACE_DEFINE_ENUM(DATA);
 TRACE_DEFINE_ENUM(META);
 TRACE_DEFINE_ENUM(META_FLUSH);
+TRACE_DEFINE_ENUM(INMEM);
+TRACE_DEFINE_ENUM(INMEM_DROP);
+TRACE_DEFINE_ENUM(IPU);
+TRACE_DEFINE_ENUM(OPU);
 TRACE_DEFINE_ENUM(CURSEG_HOT_DATA);
 TRACE_DEFINE_ENUM(CURSEG_WARM_DATA);
 TRACE_DEFINE_ENUM(CURSEG_COLD_DATA);
@@ -37,6 +41,7 @@ TRACE_DEFINE_ENUM(__REQ_META);
 TRACE_DEFINE_ENUM(CP_UMOUNT);
 TRACE_DEFINE_ENUM(CP_FASTBOOT);
 TRACE_DEFINE_ENUM(CP_SYNC);
+TRACE_DEFINE_ENUM(CP_RECOVERY);
 TRACE_DEFINE_ENUM(CP_DISCARD);
 
 #define show_block_type(type)                                           \
@@ -112,6 +117,7 @@ TRACE_DEFINE_ENUM(CP_DISCARD);
                 { CP_DISCARD,   "Discard" })
 
 struct victim_sel_policy;
+struct f2fs_map_blocks;
 
 DECLARE_EVENT_CLASS(f2fs__inode,
 
@@ -476,36 +482,35 @@ TRACE_EVENT(f2fs_truncate_partial_nodes,
                 __entry->err)
 );
 
-TRACE_EVENT(f2fs_get_data_block,
-        TP_PROTO(struct inode *inode, sector_t iblock,
-                                struct buffer_head *bh, int ret),
+TRACE_EVENT(f2fs_map_blocks,
+        TP_PROTO(struct inode *inode, struct f2fs_map_blocks *map, int ret),
 
-        TP_ARGS(inode, iblock, bh, ret),
+        TP_ARGS(inode, map, ret),
 
         TP_STRUCT__entry(
                 __field(dev_t,  dev)
                 __field(ino_t,  ino)
-                __field(sector_t,       iblock)
-                __field(sector_t,       bh_start)
-                __field(size_t, bh_size)
+                __field(block_t,        m_lblk)
+                __field(block_t,        m_pblk)
+                __field(unsigned int,   m_len)
                 __field(int,    ret)
         ),
 
         TP_fast_assign(
                 __entry->dev            = inode->i_sb->s_dev;
                 __entry->ino            = inode->i_ino;
-                __entry->iblock         = iblock;
-                __entry->bh_start       = bh->b_blocknr;
-                __entry->bh_size        = bh->b_size;
+                __entry->m_lblk         = map->m_lblk;
+                __entry->m_pblk         = map->m_pblk;
+                __entry->m_len          = map->m_len;
                 __entry->ret            = ret;
         ),
 
         TP_printk("dev = (%d,%d), ino = %lu, file offset = %llu, "
-                "start blkaddr = 0x%llx, len = 0x%llx bytes, err = %d",
+                "start blkaddr = 0x%llx, len = 0x%llx, err = %d",
                 show_dev_ino(__entry),
-                (unsigned long long)__entry->iblock,
-                (unsigned long long)__entry->bh_start,
-                (unsigned long long)__entry->bh_size,
+                (unsigned long long)__entry->m_lblk,
+                (unsigned long long)__entry->m_pblk,
+                (unsigned long long)__entry->m_len,
                 __entry->ret)
 );
 
diff --git a/include/trace/events/power.h b/include/trace/events/power.h
index d19840b0cac8..284244ebfe8d 100644
--- a/include/trace/events/power.h
+++ b/include/trace/events/power.h
@@ -7,7 +7,7 @@
 #include <linux/ktime.h>
 #include <linux/pm_qos.h>
 #include <linux/tracepoint.h>
-#include <linux/ftrace_event.h>
+#include <linux/trace_events.h>
 
 #define TPS(x)  tracepoint_string(x)
 
@@ -42,45 +42,54 @@ TRACE_EVENT(pstate_sample,
 
         TP_PROTO(u32 core_busy,
                 u32 scaled_busy,
-                u32 state,
+                u32 from,
+                u32 to,
                 u64 mperf,
                 u64 aperf,
+                u64 tsc,
                 u32 freq
                 ),
 
         TP_ARGS(core_busy,
                 scaled_busy,
-                state,
+                from,
+                to,
                 mperf,
                 aperf,
+                tsc,
                 freq
                 ),
 
         TP_STRUCT__entry(
                 __field(u32, core_busy)
                 __field(u32, scaled_busy)
-                __field(u32, state)
+                __field(u32, from)
+                __field(u32, to)
                 __field(u64, mperf)
                 __field(u64, aperf)
+                __field(u64, tsc)
                 __field(u32, freq)
-
-        ),
+                ),
 
         TP_fast_assign(
                 __entry->core_busy = core_busy;
                 __entry->scaled_busy = scaled_busy;
-                __entry->state = state;
+                __entry->from = from;
+                __entry->to = to;
                 __entry->mperf = mperf;
                 __entry->aperf = aperf;
+                __entry->tsc = tsc;
                 __entry->freq = freq;
                 ),
 
-        TP_printk("core_busy=%lu scaled=%lu state=%lu mperf=%llu aperf=%llu freq=%lu ",
+        TP_printk("core_busy=%lu scaled=%lu from=%lu to=%lu mperf=%llu aperf=%llu tsc=%llu freq=%lu ",
                 (unsigned long)__entry->core_busy,
                 (unsigned long)__entry->scaled_busy,
-                (unsigned long)__entry->state,
+                (unsigned long)__entry->from,
+                (unsigned long)__entry->to,
                 (unsigned long long)__entry->mperf,
                 (unsigned long long)__entry->aperf,
+                (unsigned long long)__entry->tsc,
                 (unsigned long)__entry->freq
                 )
 
diff --git a/include/trace/events/target.h b/include/trace/events/target.h
index 04c3c6efdcc2..50fea660c0f8 100644
--- a/include/trace/events/target.h
+++ b/include/trace/events/target.h
@@ -6,7 +6,7 @@
 
 #include <linux/tracepoint.h>
 #include <linux/trace_seq.h>
-#include <scsi/scsi.h>
+#include <scsi/scsi_proto.h>
 #include <scsi/scsi_tcq.h>
 #include <target/target_core_base.h>
 
diff --git a/include/trace/events/thermal.h b/include/trace/events/thermal.h
index 0f4f95d63c03..8b1f80682b80 100644
--- a/include/trace/events/thermal.h
+++ b/include/trace/events/thermal.h
@@ -77,6 +77,64 @@ TRACE_EVENT(thermal_zone_trip,
                 __entry->trip_type)
 );
 
+TRACE_EVENT(thermal_power_cpu_get_power,
+        TP_PROTO(const struct cpumask *cpus, unsigned long freq, u32 *load,
+                size_t load_len, u32 dynamic_power, u32 static_power),
+
+        TP_ARGS(cpus, freq, load, load_len, dynamic_power, static_power),
+
+        TP_STRUCT__entry(
+                __bitmask(cpumask, num_possible_cpus())
+                __field(unsigned long, freq          )
+                __dynamic_array(u32,   load, load_len)
+                __field(size_t,        load_len      )
+                __field(u32,           dynamic_power )
+                __field(u32,           static_power  )
+        ),
+
+        TP_fast_assign(
+                __assign_bitmask(cpumask, cpumask_bits(cpus),
+                                num_possible_cpus());
+                __entry->freq = freq;
+                memcpy(__get_dynamic_array(load), load,
+                        load_len * sizeof(*load));
+                __entry->load_len = load_len;
+                __entry->dynamic_power = dynamic_power;
+                __entry->static_power = static_power;
+        ),
+
+        TP_printk("cpus=%s freq=%lu load={%s} dynamic_power=%d static_power=%d",
+                __get_bitmask(cpumask), __entry->freq,
+                __print_array(__get_dynamic_array(load), __entry->load_len, 4),
+                __entry->dynamic_power, __entry->static_power)
+);
+
+TRACE_EVENT(thermal_power_cpu_limit,
+        TP_PROTO(const struct cpumask *cpus, unsigned int freq,
+                unsigned long cdev_state, u32 power),
+
+        TP_ARGS(cpus, freq, cdev_state, power),
+
+        TP_STRUCT__entry(
+                __bitmask(cpumask, num_possible_cpus())
+                __field(unsigned int,  freq      )
+                __field(unsigned long, cdev_state)
+                __field(u32,           power     )
+        ),
+
+        TP_fast_assign(
+                __assign_bitmask(cpumask, cpumask_bits(cpus),
+                                num_possible_cpus());
+                __entry->freq = freq;
+                __entry->cdev_state = cdev_state;
+                __entry->power = power;
+        ),
+
+        TP_printk("cpus=%s freq=%u cdev_state=%lu power=%u",
+                __get_bitmask(cpumask), __entry->freq, __entry->cdev_state,
+                __entry->power)
+);
+
 #endif /* _TRACE_THERMAL_H */
 
 /* This part must be outside protection */
diff --git a/include/trace/events/thermal_power_allocator.h b/include/trace/events/thermal_power_allocator.h
new file mode 100644
index 000000000000..12e1321c4e0c
--- /dev/null
+++ b/include/trace/events/thermal_power_allocator.h
@@ -0,0 +1,87 @@
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM thermal_power_allocator
+
+#if !defined(_TRACE_THERMAL_POWER_ALLOCATOR_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_THERMAL_POWER_ALLOCATOR_H
+
+#include <linux/tracepoint.h>
+
+TRACE_EVENT(thermal_power_allocator,
+        TP_PROTO(struct thermal_zone_device *tz, u32 *req_power,
+                 u32 total_req_power, u32 *granted_power,
+                 u32 total_granted_power, size_t num_actors,
+                 u32 power_range, u32 max_allocatable_power,
+                 unsigned long current_temp, s32 delta_temp),
+        TP_ARGS(tz, req_power, total_req_power, granted_power,
+                total_granted_power, num_actors, power_range,
+                max_allocatable_power, current_temp, delta_temp),
+        TP_STRUCT__entry(
+                __field(int,           tz_id          )
+                __dynamic_array(u32,   req_power, num_actors    )
+                __field(u32,           total_req_power          )
+                __dynamic_array(u32,   granted_power, num_actors)
+                __field(u32,           total_granted_power      )
+                __field(size_t,        num_actors               )
+                __field(u32,           power_range              )
+                __field(u32,           max_allocatable_power    )
+                __field(unsigned long, current_temp             )
+                __field(s32,           delta_temp               )
+        ),
+        TP_fast_assign(
+                __entry->tz_id = tz->id;
+                memcpy(__get_dynamic_array(req_power), req_power,
+                        num_actors * sizeof(*req_power));
+                __entry->total_req_power = total_req_power;
+                memcpy(__get_dynamic_array(granted_power), granted_power,
+                        num_actors * sizeof(*granted_power));
+                __entry->total_granted_power = total_granted_power;
+                __entry->num_actors = num_actors;
+                __entry->power_range = power_range;
+                __entry->max_allocatable_power = max_allocatable_power;
+                __entry->current_temp = current_temp;
+                __entry->delta_temp = delta_temp;
+        ),
+
+        TP_printk("thermal_zone_id=%d req_power={%s} total_req_power=%u granted_power={%s} total_granted_power=%u power_range=%u max_allocatable_power=%u current_temperature=%lu delta_temperature=%d",
+                __entry->tz_id,
+                __print_array(__get_dynamic_array(req_power),
+                              __entry->num_actors, 4),
+                __entry->total_req_power,
+                __print_array(__get_dynamic_array(granted_power),
+                              __entry->num_actors, 4),
+                __entry->total_granted_power, __entry->power_range,
+                __entry->max_allocatable_power, __entry->current_temp,
+                __entry->delta_temp)
+);
+
+TRACE_EVENT(thermal_power_allocator_pid,
+        TP_PROTO(struct thermal_zone_device *tz, s32 err, s32 err_integral,
+                 s64 p, s64 i, s64 d, s32 output),
+        TP_ARGS(tz, err, err_integral, p, i, d, output),
+        TP_STRUCT__entry(
+                __field(int, tz_id       )
+                __field(s32, err         )
+                __field(s32, err_integral)
+                __field(s64, p           )
+                __field(s64, i           )
+                __field(s64, d           )
+                __field(s32, output      )
+        ),
+        TP_fast_assign(
+                __entry->tz_id = tz->id;
+                __entry->err = err;
+                __entry->err_integral = err_integral;
+                __entry->p = p;
+                __entry->i = i;
+                __entry->d = d;
+                __entry->output = output;
+        ),
+
+        TP_printk("thermal_zone_id=%d err=%d err_integral=%d p=%lld i=%lld d=%lld output=%d",
+                  __entry->tz_id, __entry->err, __entry->err_integral,
+                  __entry->p, __entry->i, __entry->d, __entry->output)
+);
+#endif /* _TRACE_THERMAL_POWER_ALLOCATOR_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>
diff --git a/include/trace/events/v4l2.h b/include/trace/events/v4l2.h
index 20112170ff11..89d0497c058a 100644
--- a/include/trace/events/v4l2.h
+++ b/include/trace/events/v4l2.h
@@ -83,7 +83,8 @@ SHOW_FIELD
                 { V4L2_BUF_FLAG_TIMESTAMP_MASK,      "TIMESTAMP_MASK" },      \
                 { V4L2_BUF_FLAG_TIMESTAMP_UNKNOWN,   "TIMESTAMP_UNKNOWN" },   \
                 { V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC, "TIMESTAMP_MONOTONIC" }, \
-                { V4L2_BUF_FLAG_TIMESTAMP_COPY,      "TIMESTAMP_COPY" })
+                { V4L2_BUF_FLAG_TIMESTAMP_COPY,      "TIMESTAMP_COPY" },      \
+                { V4L2_BUF_FLAG_LAST,                "LAST" })
 
 #define show_timecode_flags(flags)                                        \
         __print_flags(flags, "|",                                         \
diff --git a/include/trace/events/writeback.h b/include/trace/events/writeback.h
index c178d13d6f4c..a7aa607a4c55 100644
--- a/include/trace/events/writeback.h
+++ b/include/trace/events/writeback.h
@@ -360,7 +360,7 @@ TRACE_EVENT(global_dirty_state,
                 __entry->nr_written     = global_page_state(NR_WRITTEN);
                 __entry->background_thresh = background_thresh;
                 __entry->dirty_thresh   = dirty_thresh;
-                __entry->dirty_limit = global_dirty_limit;
+                __entry->dirty_limit    = global_wb_domain.dirty_limit;
         ),
 
         TP_printk("dirty=%lu writeback=%lu unstable=%lu "
@@ -399,13 +399,13 @@ TRACE_EVENT(bdi_dirty_ratelimit,
 
         TP_fast_assign(
                 strlcpy(__entry->bdi, dev_name(bdi->dev), 32);
-                __entry->write_bw       = KBps(bdi->write_bandwidth);
-                __entry->avg_write_bw   = KBps(bdi->avg_write_bandwidth);
+                __entry->write_bw       = KBps(bdi->wb.write_bandwidth);
+                __entry->avg_write_bw   = KBps(bdi->wb.avg_write_bandwidth);
                 __entry->dirty_rate     = KBps(dirty_rate);
-                __entry->dirty_ratelimit = KBps(bdi->dirty_ratelimit);
+                __entry->dirty_ratelimit = KBps(bdi->wb.dirty_ratelimit);
                 __entry->task_ratelimit = KBps(task_ratelimit);
                 __entry->balanced_dirty_ratelimit =
-                                          KBps(bdi->balanced_dirty_ratelimit);
+                                        KBps(bdi->wb.balanced_dirty_ratelimit);
         ),
 
         TP_printk("bdi %s: "
@@ -462,8 +462,9 @@ TRACE_EVENT(balance_dirty_pages,
                 unsigned long freerun = (thresh + bg_thresh) / 2;
                 strlcpy(__entry->bdi, dev_name(bdi->dev), 32);
 
-                __entry->limit          = global_dirty_limit;
-                __entry->setpoint       = (global_dirty_limit + freerun) / 2;
+                __entry->limit          = global_wb_domain.dirty_limit;
+                __entry->setpoint       = (global_wb_domain.dirty_limit +
+                                                freerun) / 2;
                 __entry->dirty          = dirty;
                 __entry->bdi_setpoint   = __entry->setpoint *
                                                 bdi_thresh / (thresh + 1);
diff --git a/include/trace/perf.h b/include/trace/perf.h
new file mode 100644
index 000000000000..1b5443cebedc
--- /dev/null
+++ b/include/trace/perf.h
@@ -0,0 +1,350 @@
+/*
+ * Stage 4 of the trace events.
+ *
+ * Override the macros in <trace/trace_events.h> to include the following:
+ *
+ * For those macros defined with TRACE_EVENT:
+ *
+ * static struct trace_event_call event_<call>;
+ *
+ * static void trace_event_raw_event_<call>(void *__data, proto)
+ * {
+ *      struct trace_event_file *trace_file = __data;
+ *      struct trace_event_call *event_call = trace_file->event_call;
+ *      struct trace_event_data_offsets_<call> __maybe_unused __data_offsets;
+ *      unsigned long eflags = trace_file->flags;
+ *      enum event_trigger_type __tt = ETT_NONE;
+ *      struct ring_buffer_event *event;
+ *      struct trace_event_raw_<call> *entry; <-- defined in stage 1
+ *      struct ring_buffer *buffer;
+ *      unsigned long irq_flags;
+ *      int __data_size;
+ *      int pc;
+ *
+ *      if (!(eflags & EVENT_FILE_FL_TRIGGER_COND)) {
+ *              if (eflags & EVENT_FILE_FL_TRIGGER_MODE)
+ *                      event_triggers_call(trace_file, NULL);
+ *              if (eflags & EVENT_FILE_FL_SOFT_DISABLED)
+ *                      return;
+ *      }
+ *
+ *      local_save_flags(irq_flags);
+ *      pc = preempt_count();
+ *
+ *      __data_size = trace_event_get_offsets_<call>(&__data_offsets, args);
+ *
+ *      event = trace_event_buffer_lock_reserve(&buffer, trace_file,
+ *                                event_<call>->event.type,
+ *                                sizeof(*entry) + __data_size,
+ *                                irq_flags, pc);
+ *      if (!event)
+ *              return;
+ *      entry   = ring_buffer_event_data(event);
+ *
+ *      { <assign>; }  <-- Here we assign the entries by the __field and
+ *                         __array macros.
+ *
+ *      if (eflags & EVENT_FILE_FL_TRIGGER_COND)
+ *              __tt = event_triggers_call(trace_file, entry);
+ *
+ *      if (test_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT,
+ *                   &trace_file->flags))
+ *              ring_buffer_discard_commit(buffer, event);
+ *      else if (!filter_check_discard(trace_file, entry, buffer, event))
+ *              trace_buffer_unlock_commit(buffer, event, irq_flags, pc);
+ *
+ *      if (__tt)
+ *              event_triggers_post_call(trace_file, __tt);
+ * }
+ *
+ * static struct trace_event ftrace_event_type_<call> = {
+ *      .trace                  = trace_raw_output_<call>, <-- stage 2
+ * };
+ *
+ * static char print_fmt_<call>[] = <TP_printk>;
+ *
+ * static struct trace_event_class __used event_class_<template> = {
+ *      .system                 = "<system>",
+ *      .define_fields          = trace_event_define_fields_<call>,
+ *      .fields                 = LIST_HEAD_INIT(event_class_##call.fields),
+ *      .raw_init               = trace_event_raw_init,
+ *      .probe                  = trace_event_raw_event_##call,
+ *      .reg                    = trace_event_reg,
+ * };
+ *
+ * static struct trace_event_call event_<call> = {
+ *      .class                  = event_class_<template>,
+ *      {
+ *              .tp                     = &__tracepoint_<call>,
+ *      },
+ *      .event                  = &ftrace_event_type_<call>,
+ *      .print_fmt              = print_fmt_<call>,
+ *      .flags                  = TRACE_EVENT_FL_TRACEPOINT,
+ * };
+ * // its only safe to use pointers when doing linker tricks to
+ * // create an array.
+ * static struct trace_event_call __used
+ * __attribute__((section("_ftrace_events"))) *__event_<call> = &event_<call>;
+ *
+ */
+
+#ifdef CONFIG_PERF_EVENTS
+
+#define _TRACE_PERF_PROTO(call, proto)                                  \
+        static notrace void                                             \
+        perf_trace_##call(void *__data, proto);
+
+#define _TRACE_PERF_INIT(call)                                          \
+        .perf_probe             = perf_trace_##call,
+
+#else
+#define _TRACE_PERF_PROTO(call, proto)
+#define _TRACE_PERF_INIT(call)
+#endif /* CONFIG_PERF_EVENTS */
+
+#undef __entry
+#define __entry entry
+
+#undef __field
+#define __field(type, item)
+
+#undef __field_struct
+#define __field_struct(type, item)
+
+#undef __array
+#define __array(type, item, len)
+
+#undef __dynamic_array
+#define __dynamic_array(type, item, len)                                \
+        __entry->__data_loc_##item = __data_offsets.item;
+
+#undef __string
+#define __string(item, src) __dynamic_array(char, item, -1)
+
+#undef __assign_str
+#define __assign_str(dst, src)                                          \
+        strcpy(__get_str(dst), (src) ? (const char *)(src) : "(null)");
+
+#undef __bitmask
+#define __bitmask(item, nr_bits) __dynamic_array(unsigned long, item, -1)
+
+#undef __get_bitmask
+#define __get_bitmask(field) (char *)__get_dynamic_array(field)
+
+#undef __assign_bitmask
+#define __assign_bitmask(dst, src, nr_bits)                                     \
+        memcpy(__get_bitmask(dst), (src), __bitmask_size_in_bytes(nr_bits))
+
+#undef TP_fast_assign
+#define TP_fast_assign(args...) args
+
+#undef __perf_addr
+#define __perf_addr(a)  (a)
+
+#undef __perf_count
+#define __perf_count(c) (c)
+
+#undef __perf_task
+#define __perf_task(t)  (t)
+
+#undef DECLARE_EVENT_CLASS
+#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)  \
+                                                                        \
+static notrace void                                                     \
+trace_event_raw_event_##call(void *__data, proto)                       \
+{                                                                       \
+        struct trace_event_file *trace_file = __data;                   \
+        struct trace_event_data_offsets_##call __maybe_unused __data_offsets;\
+        struct trace_event_buffer fbuffer;                              \
+        struct trace_event_raw_##call *entry;                           \
+        int __data_size;                                                \
+                                                                        \
+        if (trace_trigger_soft_disabled(trace_file))                    \
+                return;                                                 \
+                                                                        \
+        __data_size = trace_event_get_offsets_##call(&__data_offsets, args); \
+                                                                        \
+        entry = trace_event_buffer_reserve(&fbuffer, trace_file,        \
+                                 sizeof(*entry) + __data_size);         \
+                                                                        \
+        if (!entry)                                                     \
+                return;                                                 \
+                                                                        \
+        tstruct                                                         \
+                                                                        \
+        { assign; }                                                     \
+                                                                        \
+        trace_event_buffer_commit(&fbuffer);                            \
+}
+/*
+ * The ftrace_test_probe is compiled out, it is only here as a build time check
+ * to make sure that if the tracepoint handling changes, the ftrace probe will
+ * fail to compile unless it too is updated.
+ */
+
+#undef DEFINE_EVENT
+#define DEFINE_EVENT(template, call, proto, args)                       \
+static inline void ftrace_test_probe_##call(void)                       \
+{                                                                       \
+        check_trace_callback_type_##call(trace_event_raw_event_##template); \
+}
+
+#undef DEFINE_EVENT_PRINT
+#define DEFINE_EVENT_PRINT(template, name, proto, args, print)
+
+#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
+
+#undef __entry
+#define __entry REC
+
+#undef __print_flags
+#undef __print_symbolic
+#undef __print_hex
+#undef __get_dynamic_array
+#undef __get_dynamic_array_len
+#undef __get_str
+#undef __get_bitmask
+#undef __print_array
+
+#undef TP_printk
+#define TP_printk(fmt, args...) "\"" fmt "\", "  __stringify(args)
+
+#undef DECLARE_EVENT_CLASS
+#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)  \
+_TRACE_PERF_PROTO(call, PARAMS(proto));                                 \
+static char print_fmt_##call[] = print;                                 \
+static struct trace_event_class __used __refdata event_class_##call = { \
+        .system                 = TRACE_SYSTEM_STRING,                  \
+        .define_fields          = trace_event_define_fields_##call,     \
+        .fields                 = LIST_HEAD_INIT(event_class_##call.fields),\
+        .raw_init               = trace_event_raw_init,                 \
+        .probe                  = trace_event_raw_event_##call,         \
+        .reg                    = trace_event_reg,                      \
+        _TRACE_PERF_INIT(call)                                          \
+};
+
+#undef DEFINE_EVENT
+#define DEFINE_EVENT(template, call, proto, args)                       \
+                                                                        \
+static struct trace_event_call __used event_##call = {                  \
+        .class                  = &event_class_##template,              \
+        {                                                               \
+                .tp                     = &__tracepoint_##call,         \
+        },                                                              \
+        .event.funcs            = &trace_event_type_funcs_##template,   \
+        .print_fmt              = print_fmt_##template,                 \
+        .flags                  = TRACE_EVENT_FL_TRACEPOINT,            \
+};                                                                      \
+static struct trace_event_call __used                                   \
+__attribute__((section("_ftrace_events"))) *__event_##call = &event_##call
+
+#undef DEFINE_EVENT_PRINT
+#define DEFINE_EVENT_PRINT(template, call, proto, args, print)          \
+                                                                        \
+static char print_fmt_##call[] = print;                                 \
+                                                                        \
+static struct trace_event_call __used event_##call = {                  \
+        .class                  = &event_class_##template,              \
+        {                                                               \
+                .tp                     = &__tracepoint_##call,         \
+        },                                                              \
+        .event.funcs            = &trace_event_type_funcs_##call,       \
+        .print_fmt              = print_fmt_##call,                     \
+        .flags                  = TRACE_EVENT_FL_TRACEPOINT,            \
+};                                                                      \
+static struct trace_event_call __used                                   \
+__attribute__((section("_ftrace_events"))) *__event_##call = &event_##call
+
+#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
+
+#undef TRACE_SYSTEM_VAR
+
+#ifdef CONFIG_PERF_EVENTS
+
+#undef __entry
+#define __entry entry
+
+#undef __get_dynamic_array
+#define __get_dynamic_array(field)      \
+                ((void *)__entry + (__entry->__data_loc_##field & 0xffff))
+
+#undef __get_dynamic_array_len
+#define __get_dynamic_array_len(field)  \
+                ((__entry->__data_loc_##field >> 16) & 0xffff)
+
+#undef __get_str
+#define __get_str(field) (char *)__get_dynamic_array(field)
+
+#undef __get_bitmask
+#define __get_bitmask(field) (char *)__get_dynamic_array(field)
+
+#undef __perf_addr
+#define __perf_addr(a)  (__addr = (a))
+
+#undef __perf_count
+#define __perf_count(c) (__count = (c))
+
+#undef __perf_task
+#define __perf_task(t)  (__task = (t))
+
+#undef DECLARE_EVENT_CLASS
+#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)  \
+static notrace void                                                     \
+perf_trace_##call(void *__data, proto)                                  \
+{                                                                       \
+        struct trace_event_call *event_call = __data;                   \
+        struct trace_event_data_offsets_##call __maybe_unused __data_offsets;\
+        struct trace_event_raw_##call *entry;                           \
+        struct pt_regs *__regs;                                         \
+        u64 __addr = 0, __count = 1;                                    \
+        struct task_struct *__task = NULL;                              \
+        struct hlist_head *head;                                        \
+        int __entry_size;                                               \
+        int __data_size;                                                \
+        int rctx;                                                       \
+                                                                        \
+        __data_size = trace_event_get_offsets_##call(&__data_offsets, args); \
+                                                                        \
+        head = this_cpu_ptr(event_call->perf_events);                   \
+        if (__builtin_constant_p(!__task) && !__task &&                 \
+                                hlist_empty(head))                      \
+                return;                                                 \
+                                                                        \
+        __entry_size = ALIGN(__data_size + sizeof(*entry) + sizeof(u32),\
+                             sizeof(u64));                              \
+        __entry_size -= sizeof(u32);                                    \
+                                                                        \
+        entry = perf_trace_buf_prepare(__entry_size,                    \
+                        event_call->event.type, &__regs, &rctx);        \
+        if (!entry)                                                     \
+                return;                                                 \
+                                                                        \
+        perf_fetch_caller_regs(__regs);                                 \
+                                                                        \
+        tstruct                                                         \
+                                                                        \
+        { assign; }                                                     \
+                                                                        \
+        perf_trace_buf_submit(entry, __entry_size, rctx, __addr,        \
+                __count, __regs, head, __task);                         \
+}
+
+/*
+ * This part is compiled out, it is only here as a build time check
+ * to make sure that if the tracepoint handling changes, the
+ * perf probe will fail to compile unless it too is updated.
+ */
+#undef DEFINE_EVENT
+#define DEFINE_EVENT(template, call, proto, args)                       \
+static inline void perf_test_probe_##call(void)                         \
+{                                                                       \
+        check_trace_callback_type_##call(perf_trace_##template);        \
+}
+
+
+#undef DEFINE_EVENT_PRINT
+#define DEFINE_EVENT_PRINT(template, name, proto, args, print)  \
+        DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
+
+#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
+#endif /* CONFIG_PERF_EVENTS */
diff --git a/include/trace/syscall.h b/include/trace/syscall.h
index 9674145e2f6a..7434f0f5d3f6 100644
--- a/include/trace/syscall.h
+++ b/include/trace/syscall.h
@@ -3,7 +3,7 @@
 
 #include <linux/tracepoint.h>
 #include <linux/unistd.h>
-#include <linux/ftrace_event.h>
+#include <linux/trace_events.h>
 #include <linux/thread_info.h>
 
 #include <asm/ptrace.h>
@@ -29,8 +29,8 @@ struct syscall_metadata {
         const char      **args;
         struct list_head enter_fields;
 
-        struct ftrace_event_call *enter_event;
-        struct ftrace_event_call *exit_event;
+        struct trace_event_call *enter_event;
+        struct trace_event_call *exit_event;
 };
 
 #if defined(CONFIG_TRACEPOINTS) && defined(CONFIG_HAVE_SYSCALL_TRACEPOINTS)
diff --git a/include/trace/ftrace.h b/include/trace/trace_events.h
index 37d4b10b111d..43be3b0e44d3 100644
--- a/include/trace/ftrace.h
+++ b/include/trace/trace_events.h
@@ -3,7 +3,7 @@
  *
  * Override the macros in <trace/trace_events.h> to include the following:
  *
- * struct ftrace_raw_<call> {
+ * struct trace_event_raw_<call> {
  *      struct trace_entry              ent;
  *      <type>                          <item>;
  *      <type2>                         <item2>[<len>];
@@ -16,7 +16,7 @@
  * in the structure.
  */
 
-#include <linux/ftrace_event.h>
+#include <linux/trace_events.h>
 
 #ifndef TRACE_SYSTEM_VAR
 #define TRACE_SYSTEM_VAR TRACE_SYSTEM
@@ -95,17 +95,17 @@ TRACE_MAKE_SYSTEM_STR();
 
 #undef DECLARE_EVENT_CLASS
 #define DECLARE_EVENT_CLASS(name, proto, args, tstruct, assign, print)  \
-        struct ftrace_raw_##name {                                      \
+        struct trace_event_raw_##name {                                 \
                 struct trace_entry      ent;                            \
                 tstruct                                                 \
                 char                    __data[0];                      \
         };                                                              \
                                                                         \
-        static struct ftrace_event_class event_class_##name;
+        static struct trace_event_class event_class_##name;
 
 #undef DEFINE_EVENT
 #define DEFINE_EVENT(template, name, proto, args)       \
-        static struct ftrace_event_call __used          \
+        static struct trace_event_call  __used          \
         __attribute__((__aligned__(4))) event_##name
 
 #undef DEFINE_EVENT_FN
@@ -138,7 +138,7 @@ TRACE_MAKE_SYSTEM_STR();
  *
  * Include the following:
  *
- * struct ftrace_data_offsets_<call> {
+ * struct trace_event_data_offsets_<call> {
  *      u32                             <item1>;
  *      u32                             <item2>;
  *      [...]
@@ -178,7 +178,7 @@ TRACE_MAKE_SYSTEM_STR();
 
 #undef DECLARE_EVENT_CLASS
 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)  \
-        struct ftrace_data_offsets_##call {                             \
+        struct trace_event_data_offsets_##call {                        \
                 tstruct;                                                \
         };
 
@@ -203,10 +203,10 @@ TRACE_MAKE_SYSTEM_STR();
  * Override the macros in <trace/trace_events.h> to include the following:
  *
  * enum print_line_t
- * ftrace_raw_output_<call>(struct trace_iterator *iter, int flags)
+ * trace_raw_output_<call>(struct trace_iterator *iter, int flags)
  * {
  *      struct trace_seq *s = &iter->seq;
- *      struct ftrace_raw_<call> *field; <-- defined in stage 1
+ *      struct trace_event_raw_<call> *field; <-- defined in stage 1
  *      struct trace_entry *entry;
  *      struct trace_seq *p = &iter->tmp_seq;
  *      int ret;
@@ -258,7 +258,7 @@ TRACE_MAKE_SYSTEM_STR();
                 void *__bitmask = __get_dynamic_array(field);           \
                 unsigned int __bitmask_size;                            \
                 __bitmask_size = __get_dynamic_array_len(field);        \
-                ftrace_print_bitmask_seq(p, __bitmask, __bitmask_size); \
+                trace_print_bitmask_seq(p, __bitmask, __bitmask_size);  \
         })
 
 #undef __print_flags
@@ -266,7 +266,7 @@ TRACE_MAKE_SYSTEM_STR();
         ({                                                              \
                 static const struct trace_print_flags __flags[] =       \
                         { flag_array, { -1, NULL }};                    \
-                ftrace_print_flags_seq(p, delim, flag, __flags);        \
+                trace_print_flags_seq(p, delim, flag, __flags); \
         })
 
 #undef __print_symbolic
@@ -274,7 +274,7 @@ TRACE_MAKE_SYSTEM_STR();
         ({                                                              \
                 static const struct trace_print_flags symbols[] =       \
                         { symbol_array, { -1, NULL }};                  \
-                ftrace_print_symbols_seq(p, value, symbols);            \
+                trace_print_symbols_seq(p, value, symbols);             \
         })
 
 #undef __print_symbolic_u64
@@ -283,7 +283,7 @@ TRACE_MAKE_SYSTEM_STR();
         ({                                                              \
                 static const struct trace_print_flags_u64 symbols[] =   \
                         { symbol_array, { -1, NULL } };                 \
-                ftrace_print_symbols_seq_u64(p, value, symbols);        \
+                trace_print_symbols_seq_u64(p, value, symbols); \
         })
 #else
 #define __print_symbolic_u64(value, symbol_array...)                    \
@@ -291,30 +291,30 @@ TRACE_MAKE_SYSTEM_STR();
 #endif
 
 #undef __print_hex
-#define __print_hex(buf, buf_len) ftrace_print_hex_seq(p, buf, buf_len)
+#define __print_hex(buf, buf_len) trace_print_hex_seq(p, buf, buf_len)
 
 #undef __print_array
 #define __print_array(array, count, el_size)                            \
         ({                                                              \
                 BUILD_BUG_ON(el_size != 1 && el_size != 2 &&            \
                              el_size != 4 && el_size != 8);             \
-                ftrace_print_array_seq(p, array, count, el_size);       \
+                trace_print_array_seq(p, array, count, el_size);        \
         })
 
 #undef DECLARE_EVENT_CLASS
 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)  \
 static notrace enum print_line_t                                        \
-ftrace_raw_output_##call(struct trace_iterator *iter, int flags,        \
-                         struct trace_event *trace_event)               \
+trace_raw_output_##call(struct trace_iterator *iter, int flags,         \
+                        struct trace_event *trace_event)                \
 {                                                                       \
         struct trace_seq *s = &iter->seq;                               \
         struct trace_seq __maybe_unused *p = &iter->tmp_seq;            \
-        struct ftrace_raw_##call *field;                                \
+        struct trace_event_raw_##call *field;                           \
         int ret;                                                        \
                                                                         \
         field = (typeof(field))iter->ent;                               \
                                                                         \
-        ret = ftrace_raw_output_prep(iter, trace_event);                \
+        ret = trace_raw_output_prep(iter, trace_event);                 \
         if (ret != TRACE_TYPE_HANDLED)                                  \
                 return ret;                                             \
                                                                         \
@@ -322,17 +322,17 @@ ftrace_raw_output_##call(struct trace_iterator *iter, int flags,	\
                                                                         \
         return trace_handle_return(s);                                  \
 }                                                                       \
-static struct trace_event_functions ftrace_event_type_funcs_##call = {  \
-        .trace                  = ftrace_raw_output_##call,             \
+static struct trace_event_functions trace_event_type_funcs_##call = {   \
+        .trace                  = trace_raw_output_##call,              \
 };
 
 #undef DEFINE_EVENT_PRINT
 #define DEFINE_EVENT_PRINT(template, call, proto, args, print)          \
 static notrace enum print_line_t                                        \
-ftrace_raw_output_##call(struct trace_iterator *iter, int flags,        \
+trace_raw_output_##call(struct trace_iterator *iter, int flags,         \
                          struct trace_event *event)                     \
 {                                                                       \
-        struct ftrace_raw_##template *field;                            \
+        struct trace_event_raw_##template *field;                       \
         struct trace_entry *entry;                                      \
         struct trace_seq *p = &iter->tmp_seq;                           \
                                                                         \
@@ -346,10 +346,10 @@ ftrace_raw_output_##call(struct trace_iterator *iter, int flags,	\
         field = (typeof(field))entry;                                   \
                                                                         \
         trace_seq_init(p);                                              \
-        return ftrace_output_call(iter, #call, print);                  \
+        return trace_output_call(iter, #call, print);                   \
 }                                                                       \
-static struct trace_event_functions ftrace_event_type_funcs_##call = {  \
-        .trace                  = ftrace_raw_output_##call,             \
+static struct trace_event_functions trace_event_type_funcs_##call = {   \
+        .trace                  = trace_raw_output_##call,              \
 };
 
 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
@@ -407,9 +407,9 @@ static struct trace_event_functions ftrace_event_type_funcs_##call = {	\
 #undef DECLARE_EVENT_CLASS
 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, func, print)    \
 static int notrace __init                                               \
-ftrace_define_fields_##call(struct ftrace_event_call *event_call)       \
+trace_event_define_fields_##call(struct trace_event_call *event_call)   \
 {                                                                       \
-        struct ftrace_raw_##call field;                                 \
+        struct trace_event_raw_##call field;                            \
         int ret;                                                        \
                                                                         \
         tstruct;                                                        \
@@ -485,12 +485,12 @@ ftrace_define_fields_##call(struct ftrace_event_call *event_call)	\
 
 #undef DECLARE_EVENT_CLASS
 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)  \
-static inline notrace int ftrace_get_offsets_##call(                    \
-        struct ftrace_data_offsets_##call *__data_offsets, proto)       \
+static inline notrace int trace_event_get_offsets_##call(               \
+        struct trace_event_data_offsets_##call *__data_offsets, proto)  \
 {                                                                       \
         int __data_size = 0;                                            \
         int __maybe_unused __item_length;                               \
-        struct ftrace_raw_##call __maybe_unused *entry;                 \
+        struct trace_event_raw_##call __maybe_unused *entry;            \
                                                                         \
         tstruct;                                                        \
                                                                         \
@@ -506,354 +506,3 @@ static inline notrace int ftrace_get_offsets_##call(			\
 
 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
 
-/*
- * Stage 4 of the trace events.
- *
- * Override the macros in <trace/trace_events.h> to include the following:
- *
- * For those macros defined with TRACE_EVENT:
- *
- * static struct ftrace_event_call event_<call>;
- *
- * static void ftrace_raw_event_<call>(void *__data, proto)
- * {
- *      struct ftrace_event_file *ftrace_file = __data;
- *      struct ftrace_event_call *event_call = ftrace_file->event_call;
- *      struct ftrace_data_offsets_<call> __maybe_unused __data_offsets;
- *      unsigned long eflags = ftrace_file->flags;
- *      enum event_trigger_type __tt = ETT_NONE;
- *      struct ring_buffer_event *event;
- *      struct ftrace_raw_<call> *entry; <-- defined in stage 1
- *      struct ring_buffer *buffer;
- *      unsigned long irq_flags;
- *      int __data_size;
- *      int pc;
- *
- *      if (!(eflags & FTRACE_EVENT_FL_TRIGGER_COND)) {
- *              if (eflags & FTRACE_EVENT_FL_TRIGGER_MODE)
- *                      event_triggers_call(ftrace_file, NULL);
- *              if (eflags & FTRACE_EVENT_FL_SOFT_DISABLED)
- *                      return;
- *      }
- *
- *      local_save_flags(irq_flags);
- *      pc = preempt_count();
- *
- *      __data_size = ftrace_get_offsets_<call>(&__data_offsets, args);
- *
- *      event = trace_event_buffer_lock_reserve(&buffer, ftrace_file,
- *                                event_<call>->event.type,
- *                                sizeof(*entry) + __data_size,
- *                                irq_flags, pc);
- *      if (!event)
- *              return;
- *      entry   = ring_buffer_event_data(event);
- *
- *      { <assign>; }  <-- Here we assign the entries by the __field and
- *                         __array macros.
- *
- *      if (eflags & FTRACE_EVENT_FL_TRIGGER_COND)
- *              __tt = event_triggers_call(ftrace_file, entry);
- *
- *      if (test_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT,
- *                   &ftrace_file->flags))
- *              ring_buffer_discard_commit(buffer, event);
- *      else if (!filter_check_discard(ftrace_file, entry, buffer, event))
- *              trace_buffer_unlock_commit(buffer, event, irq_flags, pc);
- *
- *      if (__tt)
- *              event_triggers_post_call(ftrace_file, __tt);
- * }
- *
- * static struct trace_event ftrace_event_type_<call> = {
- *      .trace                  = ftrace_raw_output_<call>, <-- stage 2
- * };
- *
- * static char print_fmt_<call>[] = <TP_printk>;
- *
- * static struct ftrace_event_class __used event_class_<template> = {
- *      .system                 = "<system>",
- *      .define_fields          = ftrace_define_fields_<call>,
- *      .fields                 = LIST_HEAD_INIT(event_class_##call.fields),
- *      .raw_init               = trace_event_raw_init,
- *      .probe                  = ftrace_raw_event_##call,
- *      .reg                    = ftrace_event_reg,
- * };
- *
- * static struct ftrace_event_call event_<call> = {
- *      .class                  = event_class_<template>,
- *      {
- *              .tp                     = &__tracepoint_<call>,
- *      },
- *      .event                  = &ftrace_event_type_<call>,
- *      .print_fmt              = print_fmt_<call>,
- *      .flags                  = TRACE_EVENT_FL_TRACEPOINT,
- * };
- * // its only safe to use pointers when doing linker tricks to
- * // create an array.
- * static struct ftrace_event_call __used
- * __attribute__((section("_ftrace_events"))) *__event_<call> = &event_<call>;
- *
- */
-
-#ifdef CONFIG_PERF_EVENTS
-
-#define _TRACE_PERF_PROTO(call, proto)                                  \
-        static notrace void                                             \
-        perf_trace_##call(void *__data, proto);
-
-#define _TRACE_PERF_INIT(call)                                          \
-        .perf_probe             = perf_trace_##call,
-
-#else
-#define _TRACE_PERF_PROTO(call, proto)
-#define _TRACE_PERF_INIT(call)
-#endif /* CONFIG_PERF_EVENTS */
-
-#undef __entry
-#define __entry entry
-
-#undef __field
-#define __field(type, item)
-
-#undef __field_struct
-#define __field_struct(type, item)
-
-#undef __array
-#define __array(type, item, len)
-
-#undef __dynamic_array
-#define __dynamic_array(type, item, len)                                \
-        __entry->__data_loc_##item = __data_offsets.item;
-
-#undef __string
-#define __string(item, src) __dynamic_array(char, item, -1)
-
-#undef __assign_str
-#define __assign_str(dst, src)                                          \
-        strcpy(__get_str(dst), (src) ? (const char *)(src) : "(null)");
-
-#undef __bitmask
-#define __bitmask(item, nr_bits) __dynamic_array(unsigned long, item, -1)
-
-#undef __get_bitmask
-#define __get_bitmask(field) (char *)__get_dynamic_array(field)
-
-#undef __assign_bitmask
-#define __assign_bitmask(dst, src, nr_bits)                                     \
-        memcpy(__get_bitmask(dst), (src), __bitmask_size_in_bytes(nr_bits))
-
-#undef TP_fast_assign
-#define TP_fast_assign(args...) args
-
-#undef __perf_addr
-#define __perf_addr(a)  (a)
-
-#undef __perf_count
-#define __perf_count(c) (c)
-
-#undef __perf_task
-#define __perf_task(t)  (t)
-
-#undef DECLARE_EVENT_CLASS
-#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)  \
-                                                                        \
-static notrace void                                                     \
-ftrace_raw_event_##call(void *__data, proto)                            \
-{                                                                       \
-        struct ftrace_event_file *ftrace_file = __data;                 \
-        struct ftrace_data_offsets_##call __maybe_unused __data_offsets;\
-        struct ftrace_event_buffer fbuffer;                             \
-        struct ftrace_raw_##call *entry;                                \
-        int __data_size;                                                \
-                                                                        \
-        if (ftrace_trigger_soft_disabled(ftrace_file))                  \
-                return;                                                 \
-                                                                        \
-        __data_size = ftrace_get_offsets_##call(&__data_offsets, args); \
-                                                                        \
-        entry = ftrace_event_buffer_reserve(&fbuffer, ftrace_file,      \
-                                 sizeof(*entry) + __data_size);         \
-                                                                        \
-        if (!entry)                                                     \
-                return;                                                 \
-                                                                        \
-        tstruct                                                         \
-                                                                        \
-        { assign; }                                                     \
-                                                                        \
-        ftrace_event_buffer_commit(&fbuffer);                           \
-}
-/*
- * The ftrace_test_probe is compiled out, it is only here as a build time check
- * to make sure that if the tracepoint handling changes, the ftrace probe will
- * fail to compile unless it too is updated.
- */
-
-#undef DEFINE_EVENT
-#define DEFINE_EVENT(template, call, proto, args)                       \
-static inline void ftrace_test_probe_##call(void)                       \
-{                                                                       \
-        check_trace_callback_type_##call(ftrace_raw_event_##template);  \
-}
-
-#undef DEFINE_EVENT_PRINT
-#define DEFINE_EVENT_PRINT(template, name, proto, args, print)
-
-#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
-
-#undef __entry
-#define __entry REC
-
-#undef __print_flags
-#undef __print_symbolic
-#undef __print_hex
-#undef __get_dynamic_array
-#undef __get_dynamic_array_len
-#undef __get_str
-#undef __get_bitmask
-#undef __print_array
-
-#undef TP_printk
-#define TP_printk(fmt, args...) "\"" fmt "\", "  __stringify(args)
-
-#undef DECLARE_EVENT_CLASS
-#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)  \
-_TRACE_PERF_PROTO(call, PARAMS(proto));                                 \
-static char print_fmt_##call[] = print;                                 \
-static struct ftrace_event_class __used __refdata event_class_##call = { \
-        .system                 = TRACE_SYSTEM_STRING,                  \
-        .define_fields          = ftrace_define_fields_##call,          \
-        .fields                 = LIST_HEAD_INIT(event_class_##call.fields),\
-        .raw_init               = trace_event_raw_init,                 \
-        .probe                  = ftrace_raw_event_##call,              \
-        .reg                    = ftrace_event_reg,                     \
-        _TRACE_PERF_INIT(call)                                          \
-};
-
-#undef DEFINE_EVENT
-#define DEFINE_EVENT(template, call, proto, args)                       \
-                                                                        \
-static struct ftrace_event_call __used event_##call = {                 \
-        .class                  = &event_class_##template,              \
-        {                                                               \
-                .tp                     = &__tracepoint_##call,         \
-        },                                                              \
-        .event.funcs            = &ftrace_event_type_funcs_##template,  \
-        .print_fmt              = print_fmt_##template,                 \
-        .flags                  = TRACE_EVENT_FL_TRACEPOINT,            \
-};                                                                      \
-static struct ftrace_event_call __used                                  \
-__attribute__((section("_ftrace_events"))) *__event_##call = &event_##call
-
-#undef DEFINE_EVENT_PRINT
-#define DEFINE_EVENT_PRINT(template, call, proto, args, print)          \
-                                                                        \
-static char print_fmt_##call[] = print;                                 \
-                                                                        \
-static struct ftrace_event_call __used event_##call = {                 \
-        .class                  = &event_class_##template,              \
-        {                                                               \
-                .tp                     = &__tracepoint_##call,         \
-        },                                                              \
-        .event.funcs            = &ftrace_event_type_funcs_##call,      \
-        .print_fmt              = print_fmt_##call,                     \
-        .flags                  = TRACE_EVENT_FL_TRACEPOINT,            \
-};                                                                      \
-static struct ftrace_event_call __used                                  \
-__attribute__((section("_ftrace_events"))) *__event_##call = &event_##call
-
-#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
-
-#undef TRACE_SYSTEM_VAR
-
-#ifdef CONFIG_PERF_EVENTS
-
-#undef __entry
-#define __entry entry
-
-#undef __get_dynamic_array
-#define __get_dynamic_array(field)      \
-                ((void *)__entry + (__entry->__data_loc_##field & 0xffff))
-
-#undef __get_dynamic_array_len
-#define __get_dynamic_array_len(field)  \
-                ((__entry->__data_loc_##field >> 16) & 0xffff)
-
-#undef __get_str
-#define __get_str(field) (char *)__get_dynamic_array(field)
-
-#undef __get_bitmask
-#define __get_bitmask(field) (char *)__get_dynamic_array(field)
-
-#undef __perf_addr
-#define __perf_addr(a)  (__addr = (a))
-
-#undef __perf_count
-#define __perf_count(c) (__count = (c))
-
-#undef __perf_task
-#define __perf_task(t)  (__task = (t))
-
-#undef DECLARE_EVENT_CLASS
-#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)  \
-static notrace void                                                     \
-perf_trace_##call(void *__data, proto)                                  \
-{                                                                       \
-        struct ftrace_event_call *event_call = __data;                  \
-        struct ftrace_data_offsets_##call __maybe_unused __data_offsets;\
-        struct ftrace_raw_##call *entry;                                \
-        struct pt_regs *__regs;                                         \
-        u64 __addr = 0, __count = 1;                                    \
-        struct task_struct *__task = NULL;                              \
-        struct hlist_head *head;                                        \
-        int __entry_size;                                               \
-        int __data_size;                                                \
-        int rctx;                                                       \
-                                                                        \
-        __data_size = ftrace_get_offsets_##call(&__data_offsets, args); \
-                                                                        \
-        head = this_cpu_ptr(event_call->perf_events);                   \
-        if (__builtin_constant_p(!__task) && !__task &&                 \
-                                hlist_empty(head))                      \
-                return;                                                 \
-                                                                        \
-        __entry_size = ALIGN(__data_size + sizeof(*entry) + sizeof(u32),\
-                             sizeof(u64));                              \
-        __entry_size -= sizeof(u32);                                    \
-                                                                        \
-        entry = perf_trace_buf_prepare(__entry_size,                    \
-                        event_call->event.type, &__regs, &rctx);        \
-        if (!entry)                                                     \
-                return;                                                 \
-                                                                        \
-        perf_fetch_caller_regs(__regs);                                 \
-                                                                        \
-        tstruct                                                         \
-                                                                        \
-        { assign; }                                                     \
-                                                                        \
-        perf_trace_buf_submit(entry, __entry_size, rctx, __addr,        \
-                __count, __regs, head, __task);                         \
-}
-
-/*
- * This part is compiled out, it is only here as a build time check
- * to make sure that if the tracepoint handling changes, the
- * perf probe will fail to compile unless it too is updated.
- */
-#undef DEFINE_EVENT
-#define DEFINE_EVENT(template, call, proto, args)                       \
-static inline void perf_test_probe_##call(void)                         \
-{                                                                       \
-        check_trace_callback_type_##call(perf_trace_##template);        \
-}
-
-
-#undef DEFINE_EVENT_PRINT
-#define DEFINE_EVENT_PRINT(template, name, proto, args, print)  \
-        DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
-
-#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
-#endif /* CONFIG_PERF_EVENTS */
-
diff --git a/include/uapi/drm/amdgpu_drm.h b/include/uapi/drm/amdgpu_drm.h
new file mode 100644
index 000000000000..fbdd11851725
--- /dev/null
+++ b/include/uapi/drm/amdgpu_drm.h
@@ -0,0 +1,645 @@
+/* amdgpu_drm.h -- Public header for the amdgpu driver -*- linux-c -*-
+ *
+ * Copyright 2000 Precision Insight, Inc., Cedar Park, Texas.
+ * Copyright 2000 VA Linux Systems, Inc., Fremont, California.
+ * Copyright 2002 Tungsten Graphics, Inc., Cedar Park, Texas.
+ * Copyright 2014 Advanced Micro Devices, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * 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.  IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Kevin E. Martin <martin@valinux.com>
+ *    Gareth Hughes <gareth@valinux.com>
+ *    Keith Whitwell <keith@tungstengraphics.com>
+ */
+
+#ifndef __AMDGPU_DRM_H__
+#define __AMDGPU_DRM_H__
+
+#include "drm.h"
+
+#define DRM_AMDGPU_GEM_CREATE           0x00
+#define DRM_AMDGPU_GEM_MMAP             0x01
+#define DRM_AMDGPU_CTX                  0x02
+#define DRM_AMDGPU_BO_LIST              0x03
+#define DRM_AMDGPU_CS                   0x04
+#define DRM_AMDGPU_INFO                 0x05
+#define DRM_AMDGPU_GEM_METADATA         0x06
+#define DRM_AMDGPU_GEM_WAIT_IDLE        0x07
+#define DRM_AMDGPU_GEM_VA               0x08
+#define DRM_AMDGPU_WAIT_CS              0x09
+#define DRM_AMDGPU_GEM_OP               0x10
+#define DRM_AMDGPU_GEM_USERPTR          0x11
+
+#define DRM_IOCTL_AMDGPU_GEM_CREATE     DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_GEM_CREATE, union drm_amdgpu_gem_create)
+#define DRM_IOCTL_AMDGPU_GEM_MMAP       DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_GEM_MMAP, union drm_amdgpu_gem_mmap)
+#define DRM_IOCTL_AMDGPU_CTX            DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_CTX, union drm_amdgpu_ctx)
+#define DRM_IOCTL_AMDGPU_BO_LIST        DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_BO_LIST, union drm_amdgpu_bo_list)
+#define DRM_IOCTL_AMDGPU_CS             DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_CS, union drm_amdgpu_cs)
+#define DRM_IOCTL_AMDGPU_INFO           DRM_IOW(DRM_COMMAND_BASE + DRM_AMDGPU_INFO, struct drm_amdgpu_info)
+#define DRM_IOCTL_AMDGPU_GEM_METADATA   DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_GEM_METADATA, struct drm_amdgpu_gem_metadata)
+#define DRM_IOCTL_AMDGPU_GEM_WAIT_IDLE  DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_GEM_WAIT_IDLE, union drm_amdgpu_gem_wait_idle)
+#define DRM_IOCTL_AMDGPU_GEM_VA         DRM_IOW(DRM_COMMAND_BASE + DRM_AMDGPU_GEM_VA, struct drm_amdgpu_gem_va)
+#define DRM_IOCTL_AMDGPU_WAIT_CS        DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_WAIT_CS, union drm_amdgpu_wait_cs)
+#define DRM_IOCTL_AMDGPU_GEM_OP         DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_GEM_OP, struct drm_amdgpu_gem_op)
+#define DRM_IOCTL_AMDGPU_GEM_USERPTR    DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_GEM_USERPTR, struct drm_amdgpu_gem_userptr)
+
+#define AMDGPU_GEM_DOMAIN_CPU           0x1
+#define AMDGPU_GEM_DOMAIN_GTT           0x2
+#define AMDGPU_GEM_DOMAIN_VRAM          0x4
+#define AMDGPU_GEM_DOMAIN_GDS           0x8
+#define AMDGPU_GEM_DOMAIN_GWS           0x10
+#define AMDGPU_GEM_DOMAIN_OA            0x20
+
+/* Flag that CPU access will be required for the case of VRAM domain */
+#define AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED   (1 << 0)
+/* Flag that CPU access will not work, this VRAM domain is invisible */
+#define AMDGPU_GEM_CREATE_NO_CPU_ACCESS         (1 << 1)
+/* Flag that USWC attributes should be used for GTT */
+#define AMDGPU_GEM_CREATE_CPU_GTT_USWC          (1 << 2)
+
+struct drm_amdgpu_gem_create_in  {
+        /** the requested memory size */
+        uint64_t bo_size;
+        /** physical start_addr alignment in bytes for some HW requirements */
+        uint64_t alignment;
+        /** the requested memory domains */
+        uint64_t domains;
+        /** allocation flags */
+        uint64_t domain_flags;
+};
+
+struct drm_amdgpu_gem_create_out  {
+        /** returned GEM object handle */
+        uint32_t handle;
+        uint32_t _pad;
+};
+
+union drm_amdgpu_gem_create {
+        struct drm_amdgpu_gem_create_in         in;
+        struct drm_amdgpu_gem_create_out        out;
+};
+
+/** Opcode to create new residency list.  */
+#define AMDGPU_BO_LIST_OP_CREATE        0
+/** Opcode to destroy previously created residency list */
+#define AMDGPU_BO_LIST_OP_DESTROY       1
+/** Opcode to update resource information in the list */
+#define AMDGPU_BO_LIST_OP_UPDATE        2
+
+struct drm_amdgpu_bo_list_in {
+        /** Type of operation */
+        uint32_t operation;
+        /** Handle of list or 0 if we want to create one */
+        uint32_t list_handle;
+        /** Number of BOs in list  */
+        uint32_t bo_number;
+        /** Size of each element describing BO */
+        uint32_t bo_info_size;
+        /** Pointer to array describing BOs */
+        uint64_t bo_info_ptr;
+};
+
+struct drm_amdgpu_bo_list_entry {
+        /** Handle of BO */
+        uint32_t bo_handle;
+        /** New (if specified) BO priority to be used during migration */
+        uint32_t bo_priority;
+};
+
+struct drm_amdgpu_bo_list_out {
+        /** Handle of resource list  */
+        uint32_t list_handle;
+        uint32_t _pad;
+};
+
+union drm_amdgpu_bo_list {
+        struct drm_amdgpu_bo_list_in in;
+        struct drm_amdgpu_bo_list_out out;
+};
+
+/* context related */
+#define AMDGPU_CTX_OP_ALLOC_CTX 1
+#define AMDGPU_CTX_OP_FREE_CTX  2
+#define AMDGPU_CTX_OP_QUERY_STATE       3
+
+/* GPU reset status */
+#define AMDGPU_CTX_NO_RESET             0
+/* this the context caused it */
+#define AMDGPU_CTX_GUILTY_RESET         1
+/* some other context caused it */
+#define AMDGPU_CTX_INNOCENT_RESET       2
+/* unknown cause */
+#define AMDGPU_CTX_UNKNOWN_RESET        3
+
+struct drm_amdgpu_ctx_in {
+        /** AMDGPU_CTX_OP_* */
+        uint32_t        op;
+        /** For future use, no flags defined so far */
+        uint32_t        flags;
+        uint32_t        ctx_id;
+        uint32_t        _pad;
+};
+
+union drm_amdgpu_ctx_out {
+                struct {
+                        uint32_t        ctx_id;
+                        uint32_t        _pad;
+                } alloc;
+
+                struct {
+                        /** For future use, no flags defined so far */
+                        uint64_t        flags;
+                        /** Number of resets caused by this context so far. */
+                        uint32_t        hangs;
+                        /** Reset status since the last call of the ioctl. */
+                        uint32_t        reset_status;
+                } state;
+};
+
+union drm_amdgpu_ctx {
+        struct drm_amdgpu_ctx_in in;
+        union drm_amdgpu_ctx_out out;
+};
+
+/*
+ * This is not a reliable API and you should expect it to fail for any
+ * number of reasons and have fallback path that do not use userptr to
+ * perform any operation.
+ */
+#define AMDGPU_GEM_USERPTR_READONLY     (1 << 0)
+#define AMDGPU_GEM_USERPTR_ANONONLY     (1 << 1)
+#define AMDGPU_GEM_USERPTR_VALIDATE     (1 << 2)
+#define AMDGPU_GEM_USERPTR_REGISTER     (1 << 3)
+
+struct drm_amdgpu_gem_userptr {
+        uint64_t                addr;
+        uint64_t                size;
+        /* AMDGPU_GEM_USERPTR_* */
+        uint32_t                flags;
+        /* Resulting GEM handle */
+        uint32_t                handle;
+};
+
+/* same meaning as the GB_TILE_MODE and GL_MACRO_TILE_MODE fields */
+#define AMDGPU_TILING_ARRAY_MODE_SHIFT                  0
+#define AMDGPU_TILING_ARRAY_MODE_MASK                   0xf
+#define AMDGPU_TILING_PIPE_CONFIG_SHIFT                 4
+#define AMDGPU_TILING_PIPE_CONFIG_MASK                  0x1f
+#define AMDGPU_TILING_TILE_SPLIT_SHIFT                  9
+#define AMDGPU_TILING_TILE_SPLIT_MASK                   0x7
+#define AMDGPU_TILING_MICRO_TILE_MODE_SHIFT             12
+#define AMDGPU_TILING_MICRO_TILE_MODE_MASK              0x7
+#define AMDGPU_TILING_BANK_WIDTH_SHIFT                  15
+#define AMDGPU_TILING_BANK_WIDTH_MASK                   0x3
+#define AMDGPU_TILING_BANK_HEIGHT_SHIFT                 17
+#define AMDGPU_TILING_BANK_HEIGHT_MASK                  0x3
+#define AMDGPU_TILING_MACRO_TILE_ASPECT_SHIFT           19
+#define AMDGPU_TILING_MACRO_TILE_ASPECT_MASK            0x3
+#define AMDGPU_TILING_NUM_BANKS_SHIFT                   21
+#define AMDGPU_TILING_NUM_BANKS_MASK                    0x3
+
+#define AMDGPU_TILING_SET(field, value) \
+        (((value) & AMDGPU_TILING_##field##_MASK) << AMDGPU_TILING_##field##_SHIFT)
+#define AMDGPU_TILING_GET(value, field) \
+        (((value) >> AMDGPU_TILING_##field##_SHIFT) & AMDGPU_TILING_##field##_MASK)
+
+#define AMDGPU_GEM_METADATA_OP_SET_METADATA                  1
+#define AMDGPU_GEM_METADATA_OP_GET_METADATA                  2
+
+/** The same structure is shared for input/output */
+struct drm_amdgpu_gem_metadata {
+        /** GEM Object handle */
+        uint32_t        handle;
+        /** Do we want get or set metadata */
+        uint32_t        op;
+        struct {
+                /** For future use, no flags defined so far */
+                uint64_t        flags;
+                /** family specific tiling info */
+                uint64_t        tiling_info;
+                uint32_t        data_size_bytes;
+                uint32_t        data[64];
+        } data;
+};
+
+struct drm_amdgpu_gem_mmap_in {
+        /** the GEM object handle */
+        uint32_t handle;
+        uint32_t _pad;
+};
+
+struct drm_amdgpu_gem_mmap_out {
+        /** mmap offset from the vma offset manager */
+        uint64_t addr_ptr;
+};
+
+union drm_amdgpu_gem_mmap {
+        struct drm_amdgpu_gem_mmap_in   in;
+        struct drm_amdgpu_gem_mmap_out out;
+};
+
+struct drm_amdgpu_gem_wait_idle_in {
+        /** GEM object handle */
+        uint32_t handle;
+        /** For future use, no flags defined so far */
+        uint32_t flags;
+        /** Absolute timeout to wait */
+        uint64_t timeout;
+};
+
+struct drm_amdgpu_gem_wait_idle_out {
+        /** BO status:  0 - BO is idle, 1 - BO is busy */
+        uint32_t status;
+        /** Returned current memory domain */
+        uint32_t domain;
+};
+
+union drm_amdgpu_gem_wait_idle {
+        struct drm_amdgpu_gem_wait_idle_in  in;
+        struct drm_amdgpu_gem_wait_idle_out out;
+};
+
+struct drm_amdgpu_wait_cs_in {
+        /** Command submission handle */
+        uint64_t handle;
+        /** Absolute timeout to wait */
+        uint64_t timeout;
+        uint32_t ip_type;
+        uint32_t ip_instance;
+        uint32_t ring;
+        uint32_t ctx_id;
+};
+
+struct drm_amdgpu_wait_cs_out {
+        /** CS status:  0 - CS completed, 1 - CS still busy */
+        uint64_t status;
+};
+
+union drm_amdgpu_wait_cs {
+        struct drm_amdgpu_wait_cs_in in;
+        struct drm_amdgpu_wait_cs_out out;
+};
+
+#define AMDGPU_GEM_OP_GET_GEM_CREATE_INFO       0
+#define AMDGPU_GEM_OP_SET_PLACEMENT             1
+
+/* Sets or returns a value associated with a buffer. */
+struct drm_amdgpu_gem_op {
+        /** GEM object handle */
+        uint32_t        handle;
+        /** AMDGPU_GEM_OP_* */
+        uint32_t        op;
+        /** Input or return value */
+        uint64_t        value;
+};
+
+#define AMDGPU_VA_OP_MAP                        1
+#define AMDGPU_VA_OP_UNMAP                      2
+
+/* Delay the page table update till the next CS */
+#define AMDGPU_VM_DELAY_UPDATE          (1 << 0)
+
+/* Mapping flags */
+/* readable mapping */
+#define AMDGPU_VM_PAGE_READABLE         (1 << 1)
+/* writable mapping */
+#define AMDGPU_VM_PAGE_WRITEABLE        (1 << 2)
+/* executable mapping, new for VI */
+#define AMDGPU_VM_PAGE_EXECUTABLE       (1 << 3)
+
+struct drm_amdgpu_gem_va {
+        /** GEM object handle */
+        uint32_t handle;
+        uint32_t _pad;
+        /** AMDGPU_VA_OP_* */
+        uint32_t operation;
+        /** AMDGPU_VM_PAGE_* */
+        uint32_t flags;
+        /** va address to assign . Must be correctly aligned.*/
+        uint64_t va_address;
+        /** Specify offset inside of BO to assign. Must be correctly aligned.*/
+        uint64_t offset_in_bo;
+        /** Specify mapping size. Must be correctly aligned. */
+        uint64_t map_size;
+};
+
+#define AMDGPU_HW_IP_GFX          0
+#define AMDGPU_HW_IP_COMPUTE      1
+#define AMDGPU_HW_IP_DMA          2
+#define AMDGPU_HW_IP_UVD          3
+#define AMDGPU_HW_IP_VCE          4
+#define AMDGPU_HW_IP_NUM          5
+
+#define AMDGPU_HW_IP_INSTANCE_MAX_COUNT 1
+
+#define AMDGPU_CHUNK_ID_IB              0x01
+#define AMDGPU_CHUNK_ID_FENCE           0x02
+#define AMDGPU_CHUNK_ID_DEPENDENCIES    0x03
+
+struct drm_amdgpu_cs_chunk {
+        uint32_t                chunk_id;
+        uint32_t                length_dw;
+        uint64_t                chunk_data;
+};
+
+struct drm_amdgpu_cs_in {
+        /** Rendering context id */
+        uint32_t                ctx_id;
+        /**  Handle of resource list associated with CS */
+        uint32_t                bo_list_handle;
+        uint32_t                num_chunks;
+        uint32_t                _pad;
+        /** this points to uint64_t * which point to cs chunks */
+        uint64_t                chunks;
+};
+
+struct drm_amdgpu_cs_out {
+        uint64_t handle;
+};
+
+union drm_amdgpu_cs {
+        struct drm_amdgpu_cs_in in;
+        struct drm_amdgpu_cs_out out;
+};
+
+/* Specify flags to be used for IB */
+
+/* This IB should be submitted to CE */
+#define AMDGPU_IB_FLAG_CE       (1<<0)
+
+/* CE Preamble */
+#define AMDGPU_IB_FLAG_PREAMBLE (1<<1)
+
+struct drm_amdgpu_cs_chunk_ib {
+        uint32_t _pad;
+        /** AMDGPU_IB_FLAG_* */
+        uint32_t flags;
+        /** Virtual address to begin IB execution */
+        uint64_t va_start;
+        /** Size of submission */
+        uint32_t ib_bytes;
+        /** HW IP to submit to */
+        uint32_t ip_type;
+        /** HW IP index of the same type to submit to  */
+        uint32_t ip_instance;
+        /** Ring index to submit to */
+        uint32_t ring;
+};
+
+struct drm_amdgpu_cs_chunk_dep {
+        uint32_t ip_type;
+        uint32_t ip_instance;
+        uint32_t ring;
+        uint32_t ctx_id;
+        uint64_t handle;
+};
+
+struct drm_amdgpu_cs_chunk_fence {
+        uint32_t handle;
+        uint32_t offset;
+};
+
+struct drm_amdgpu_cs_chunk_data {
+        union {
+                struct drm_amdgpu_cs_chunk_ib           ib_data;
+                struct drm_amdgpu_cs_chunk_fence        fence_data;
+        };
+};
+
+/**
+ *  Query h/w info: Flag that this is integrated (a.h.a. fusion) GPU
+ *
+ */
+#define AMDGPU_IDS_FLAGS_FUSION         0x1
+
+/* indicate if acceleration can be working */
+#define AMDGPU_INFO_ACCEL_WORKING               0x00
+/* get the crtc_id from the mode object id? */
+#define AMDGPU_INFO_CRTC_FROM_ID                0x01
+/* query hw IP info */
+#define AMDGPU_INFO_HW_IP_INFO                  0x02
+/* query hw IP instance count for the specified type */
+#define AMDGPU_INFO_HW_IP_COUNT                 0x03
+/* timestamp for GL_ARB_timer_query */
+#define AMDGPU_INFO_TIMESTAMP                   0x05
+/* Query the firmware version */
+#define AMDGPU_INFO_FW_VERSION                  0x0e
+        /* Subquery id: Query VCE firmware version */
+        #define AMDGPU_INFO_FW_VCE              0x1
+        /* Subquery id: Query UVD firmware version */
+        #define AMDGPU_INFO_FW_UVD              0x2
+        /* Subquery id: Query GMC firmware version */
+        #define AMDGPU_INFO_FW_GMC              0x03
+        /* Subquery id: Query GFX ME firmware version */
+        #define AMDGPU_INFO_FW_GFX_ME           0x04
+        /* Subquery id: Query GFX PFP firmware version */
+        #define AMDGPU_INFO_FW_GFX_PFP          0x05
+        /* Subquery id: Query GFX CE firmware version */
+        #define AMDGPU_INFO_FW_GFX_CE           0x06
+        /* Subquery id: Query GFX RLC firmware version */
+        #define AMDGPU_INFO_FW_GFX_RLC          0x07
+        /* Subquery id: Query GFX MEC firmware version */
+        #define AMDGPU_INFO_FW_GFX_MEC          0x08
+        /* Subquery id: Query SMC firmware version */
+        #define AMDGPU_INFO_FW_SMC              0x0a
+        /* Subquery id: Query SDMA firmware version */
+        #define AMDGPU_INFO_FW_SDMA             0x0b
+/* number of bytes moved for TTM migration */
+#define AMDGPU_INFO_NUM_BYTES_MOVED             0x0f
+/* the used VRAM size */
+#define AMDGPU_INFO_VRAM_USAGE                  0x10
+/* the used GTT size */
+#define AMDGPU_INFO_GTT_USAGE                   0x11
+/* Information about GDS, etc. resource configuration */
+#define AMDGPU_INFO_GDS_CONFIG                  0x13
+/* Query information about VRAM and GTT domains */
+#define AMDGPU_INFO_VRAM_GTT                    0x14
+/* Query information about register in MMR address space*/
+#define AMDGPU_INFO_READ_MMR_REG                0x15
+/* Query information about device: rev id, family, etc. */
+#define AMDGPU_INFO_DEV_INFO                    0x16
+/* visible vram usage */
+#define AMDGPU_INFO_VIS_VRAM_USAGE              0x17
+
+#define AMDGPU_INFO_MMR_SE_INDEX_SHIFT  0
+#define AMDGPU_INFO_MMR_SE_INDEX_MASK   0xff
+#define AMDGPU_INFO_MMR_SH_INDEX_SHIFT  8
+#define AMDGPU_INFO_MMR_SH_INDEX_MASK   0xff
+
+/* Input structure for the INFO ioctl */
+struct drm_amdgpu_info {
+        /* Where the return value will be stored */
+        uint64_t return_pointer;
+        /* The size of the return value. Just like "size" in "snprintf",
+         * it limits how many bytes the kernel can write. */
+        uint32_t return_size;
+        /* The query request id. */
+        uint32_t query;
+
+        union {
+                struct {
+                        uint32_t id;
+                        uint32_t _pad;
+                } mode_crtc;
+
+                struct {
+                        /** AMDGPU_HW_IP_* */
+                        uint32_t type;
+                        /**
+                         * Index of the IP if there are more IPs of the same
+                         * type. Ignored by AMDGPU_INFO_HW_IP_COUNT.
+                         */
+                        uint32_t ip_instance;
+                } query_hw_ip;
+
+                struct {
+                        uint32_t dword_offset;
+                        /** number of registers to read */
+                        uint32_t count;
+                        uint32_t instance;
+                        /** For future use, no flags defined so far */
+                        uint32_t flags;
+                } read_mmr_reg;
+
+                struct {
+                        /** AMDGPU_INFO_FW_* */
+                        uint32_t fw_type;
+                        /**
+                         * Index of the IP if there are more IPs of
+                         * the same type.
+                         */
+                        uint32_t ip_instance;
+                        /**
+                         * Index of the engine. Whether this is used depends
+                         * on the firmware type. (e.g. MEC, SDMA)
+                         */
+                        uint32_t index;
+                        uint32_t _pad;
+                } query_fw;
+        };
+};
+
+struct drm_amdgpu_info_gds {
+        /** GDS GFX partition size */
+        uint32_t gds_gfx_partition_size;
+        /** GDS compute partition size */
+        uint32_t compute_partition_size;
+        /** total GDS memory size */
+        uint32_t gds_total_size;
+        /** GWS size per GFX partition */
+        uint32_t gws_per_gfx_partition;
+        /** GSW size per compute partition */
+        uint32_t gws_per_compute_partition;
+        /** OA size per GFX partition */
+        uint32_t oa_per_gfx_partition;
+        /** OA size per compute partition */
+        uint32_t oa_per_compute_partition;
+        uint32_t _pad;
+};
+
+struct drm_amdgpu_info_vram_gtt {
+        uint64_t vram_size;
+        uint64_t vram_cpu_accessible_size;
+        uint64_t gtt_size;
+};
+
+struct drm_amdgpu_info_firmware {
+        uint32_t ver;
+        uint32_t feature;
+};
+
+#define AMDGPU_VRAM_TYPE_UNKNOWN 0
+#define AMDGPU_VRAM_TYPE_GDDR1 1
+#define AMDGPU_VRAM_TYPE_DDR2  2
+#define AMDGPU_VRAM_TYPE_GDDR3 3
+#define AMDGPU_VRAM_TYPE_GDDR4 4
+#define AMDGPU_VRAM_TYPE_GDDR5 5
+#define AMDGPU_VRAM_TYPE_HBM   6
+#define AMDGPU_VRAM_TYPE_DDR3  7
+
+struct drm_amdgpu_info_device {
+        /** PCI Device ID */
+        uint32_t device_id;
+        /** Internal chip revision: A0, A1, etc.) */
+        uint32_t chip_rev;
+        uint32_t external_rev;
+        /** Revision id in PCI Config space */
+        uint32_t pci_rev;
+        uint32_t family;
+        uint32_t num_shader_engines;
+        uint32_t num_shader_arrays_per_engine;
+        /* in KHz */
+        uint32_t gpu_counter_freq;
+        uint64_t max_engine_clock;
+        uint64_t max_memory_clock;
+        /* cu information */
+        uint32_t cu_active_number;
+        uint32_t cu_ao_mask;
+        uint32_t cu_bitmap[4][4];
+        /** Render backend pipe mask. One render backend is CB+DB. */
+        uint32_t enabled_rb_pipes_mask;
+        uint32_t num_rb_pipes;
+        uint32_t num_hw_gfx_contexts;
+        uint32_t _pad;
+        uint64_t ids_flags;
+        /** Starting virtual address for UMDs. */
+        uint64_t virtual_address_offset;
+        /** The maximum virtual address */
+        uint64_t virtual_address_max;
+        /** Required alignment of virtual addresses. */
+        uint32_t virtual_address_alignment;
+        /** Page table entry - fragment size */
+        uint32_t pte_fragment_size;
+        uint32_t gart_page_size;
+        /** constant engine ram size*/
+        uint32_t ce_ram_size;
+        /** video memory type info*/
+        uint32_t vram_type;
+        /** video memory bit width*/
+        uint32_t vram_bit_width;
+        /* vce harvesting instance */
+        uint32_t vce_harvest_config;
+};
+
+struct drm_amdgpu_info_hw_ip {
+        /** Version of h/w IP */
+        uint32_t  hw_ip_version_major;
+        uint32_t  hw_ip_version_minor;
+        /** Capabilities */
+        uint64_t  capabilities_flags;
+        /** command buffer address start alignment*/
+        uint32_t  ib_start_alignment;
+        /** command buffer size alignment*/
+        uint32_t  ib_size_alignment;
+        /** Bitmask of available rings. Bit 0 means ring 0, etc. */
+        uint32_t  available_rings;
+        uint32_t  _pad;
+};
+
+/*
+ * Supported GPU families
+ */
+#define AMDGPU_FAMILY_UNKNOWN                   0
+#define AMDGPU_FAMILY_CI                        120 /* Bonaire, Hawaii */
+#define AMDGPU_FAMILY_KV                        125 /* Kaveri, Kabini, Mullins */
+#define AMDGPU_FAMILY_VI                        130 /* Iceland, Tonga */
+#define AMDGPU_FAMILY_CZ                        135 /* Carrizo */
+
+#endif
diff --git a/include/uapi/drm/drm.h b/include/uapi/drm/drm.h
index ff6ef62d084b..3801584a0c53 100644
--- a/include/uapi/drm/drm.h
+++ b/include/uapi/drm/drm.h
@@ -786,6 +786,8 @@ struct drm_prime_handle {
 #define DRM_IOCTL_MODE_OBJ_SETPROPERTY  DRM_IOWR(0xBA, struct drm_mode_obj_set_property)
 #define DRM_IOCTL_MODE_CURSOR2          DRM_IOWR(0xBB, struct drm_mode_cursor2)
 #define DRM_IOCTL_MODE_ATOMIC           DRM_IOWR(0xBC, struct drm_mode_atomic)
+#define DRM_IOCTL_MODE_CREATEPROPBLOB   DRM_IOWR(0xBD, struct drm_mode_create_blob)
+#define DRM_IOCTL_MODE_DESTROYPROPBLOB  DRM_IOWR(0xBE, struct drm_mode_destroy_blob)
 
 /**
  * Device specific ioctls should only be in their respective headers
diff --git a/include/uapi/drm/drm_fourcc.h b/include/uapi/drm/drm_fourcc.h
index 07735822a28f..2f295cde657e 100644
--- a/include/uapi/drm/drm_fourcc.h
+++ b/include/uapi/drm/drm_fourcc.h
@@ -207,4 +207,19 @@
  */
 #define I915_FORMAT_MOD_Yf_TILED fourcc_mod_code(INTEL, 3)
 
+/*
+ * Tiled, NV12MT, grouped in 64 (pixels) x 32 (lines) -sized macroblocks
+ *
+ * Macroblocks are laid in a Z-shape, and each pixel data is following the
+ * standard NV12 style.
+ * As for NV12, an image is the result of two frame buffers: one for Y,
+ * one for the interleaved Cb/Cr components (1/2 the height of the Y buffer).
+ * Alignment requirements are (for each buffer):
+ * - multiple of 128 pixels for the width
+ * - multiple of  32 pixels for the height
+ *
+ * For more information: see http://linuxtv.org/downloads/v4l-dvb-apis/re32.html
+ */
+#define DRM_FORMAT_MOD_SAMSUNG_64_32_TILE       fourcc_mod_code(SAMSUNG, 1)
+
 #endif /* DRM_FOURCC_H */
diff --git a/include/uapi/drm/drm_mode.h b/include/uapi/drm/drm_mode.h
index dbeba949462a..359107ab629e 100644
--- a/include/uapi/drm/drm_mode.h
+++ b/include/uapi/drm/drm_mode.h
@@ -558,4 +558,24 @@ struct drm_mode_atomic {
         __u64 user_data;
 };
 
+/**
+ * Create a new 'blob' data property, copying length bytes from data pointer,
+ * and returning new blob ID.
+ */
+struct drm_mode_create_blob {
+        /** Pointer to data to copy. */
+        __u64 data;
+        /** Length of data to copy. */
+        __u32 length;
+        /** Return: new property ID. */
+        __u32 blob_id;
+};
+
+/**
+ * Destroy a user-created blob property.
+ */
+struct drm_mode_destroy_blob {
+        __u32 blob_id;
+};
+
 #endif
diff --git a/include/uapi/drm/i915_drm.h b/include/uapi/drm/i915_drm.h
index 551b6737f5df..db809b722985 100644
--- a/include/uapi/drm/i915_drm.h
+++ b/include/uapi/drm/i915_drm.h
@@ -171,8 +171,12 @@ typedef struct _drm_i915_sarea {
 #define I915_BOX_TEXTURE_LOAD  0x8
 #define I915_BOX_LOST_CONTEXT  0x10
 
-/* I915 specific ioctls
- * The device specific ioctl range is 0x40 to 0x79.
+/*
+ * i915 specific ioctls.
+ *
+ * The device specific ioctl range is [DRM_COMMAND_BASE, DRM_COMMAND_END) ie
+ * [0x40, 0xa0) (a0 is excluded). The numbers below are defined as offset
+ * against DRM_COMMAND_BASE and should be between [0x0, 0x60).
  */
 #define DRM_I915_INIT           0x00
 #define DRM_I915_FLUSH          0x01
@@ -996,6 +1000,7 @@ struct drm_intel_overlay_put_image {
 /* flags */
 #define I915_OVERLAY_UPDATE_ATTRS       (1<<0)
 #define I915_OVERLAY_UPDATE_GAMMA       (1<<1)
+#define I915_OVERLAY_DISABLE_DEST_COLORKEY      (1<<2)
 struct drm_intel_overlay_attrs {
         __u32 flags;
         __u32 color_key;
@@ -1065,6 +1070,14 @@ struct drm_i915_reg_read {
         __u64 offset;
         __u64 val; /* Return value */
 };
+/* Known registers:
+ *
+ * Render engine timestamp - 0x2358 + 64bit - gen7+
+ * - Note this register returns an invalid value if using the default
+ *   single instruction 8byte read, in order to workaround that use
+ *   offset (0x2538 | 1) instead.
+ *
+ */
 
 struct drm_i915_reset_stats {
         __u32 ctx_id;
diff --git a/include/uapi/drm/msm_drm.h b/include/uapi/drm/msm_drm.h
index 0664c31f010c..75a232b9a970 100644
--- a/include/uapi/drm/msm_drm.h
+++ b/include/uapi/drm/msm_drm.h
@@ -23,7 +23,7 @@
 
 /* Please note that modifications to all structs defined here are
  * subject to backwards-compatibility constraints:
- *  1) Do not use pointers, use uint64_t instead for 32 bit / 64 bit
+ *  1) Do not use pointers, use __u64 instead for 32 bit / 64 bit
  *     user/kernel compatibility
  *  2) Keep fields aligned to their size
  *  3) Because of how drm_ioctl() works, we can add new fields at
@@ -44,8 +44,8 @@
  * same as 'struct timespec' but 32/64b ABI safe.
  */
 struct drm_msm_timespec {
-        int64_t tv_sec;          /* seconds */
-        int64_t tv_nsec;         /* nanoseconds */
+        __s64 tv_sec;          /* seconds */
+        __s64 tv_nsec;         /* nanoseconds */
 };
 
 #define MSM_PARAM_GPU_ID     0x01
@@ -53,9 +53,9 @@ struct drm_msm_timespec {
 #define MSM_PARAM_CHIP_ID    0x03
 
 struct drm_msm_param {
-        uint32_t pipe;           /* in, MSM_PIPE_x */
-        uint32_t param;          /* in, MSM_PARAM_x */
-        uint64_t value;          /* out (get_param) or in (set_param) */
+        __u32 pipe;           /* in, MSM_PIPE_x */
+        __u32 param;          /* in, MSM_PARAM_x */
+        __u64 value;          /* out (get_param) or in (set_param) */
 };
 
 /*
@@ -77,15 +77,15 @@ struct drm_msm_param {
                               MSM_BO_UNCACHED)
 
 struct drm_msm_gem_new {
-        uint64_t size;           /* in */
-        uint32_t flags;          /* in, mask of MSM_BO_x */
-        uint32_t handle;         /* out */
+        __u64 size;           /* in */
+        __u32 flags;          /* in, mask of MSM_BO_x */
+        __u32 handle;         /* out */
 };
 
 struct drm_msm_gem_info {
-        uint32_t handle;         /* in */
-        uint32_t pad;
-        uint64_t offset;         /* out, offset to pass to mmap() */
+        __u32 handle;         /* in */
+        __u32 pad;
+        __u64 offset;         /* out, offset to pass to mmap() */
 };
 
 #define MSM_PREP_READ        0x01
@@ -95,13 +95,13 @@ struct drm_msm_gem_info {
 #define MSM_PREP_FLAGS       (MSM_PREP_READ | MSM_PREP_WRITE | MSM_PREP_NOSYNC)
 
 struct drm_msm_gem_cpu_prep {
-        uint32_t handle;         /* in */
-        uint32_t op;             /* in, mask of MSM_PREP_x */
+        __u32 handle;         /* in */
+        __u32 op;             /* in, mask of MSM_PREP_x */
         struct drm_msm_timespec timeout;   /* in */
 };
 
 struct drm_msm_gem_cpu_fini {
-        uint32_t handle;         /* in */
+        __u32 handle;         /* in */
 };
 
 /*
@@ -120,11 +120,11 @@ struct drm_msm_gem_cpu_fini {
  * otherwise EINVAL.
  */
 struct drm_msm_gem_submit_reloc {
-        uint32_t submit_offset;  /* in, offset from submit_bo */
-        uint32_t or;             /* in, value OR'd with result */
-        int32_t  shift;          /* in, amount of left shift (can be negative) */
-        uint32_t reloc_idx;      /* in, index of reloc_bo buffer */
-        uint64_t reloc_offset;   /* in, offset from start of reloc_bo */
+        __u32 submit_offset;  /* in, offset from submit_bo */
+        __u32 or;             /* in, value OR'd with result */
+        __s32  shift;          /* in, amount of left shift (can be negative) */
+        __u32 reloc_idx;      /* in, index of reloc_bo buffer */
+        __u64 reloc_offset;   /* in, offset from start of reloc_bo */
 };
 
 /* submit-types:
@@ -139,13 +139,13 @@ struct drm_msm_gem_submit_reloc {
 #define MSM_SUBMIT_CMD_IB_TARGET_BUF   0x0002
 #define MSM_SUBMIT_CMD_CTX_RESTORE_BUF 0x0003
 struct drm_msm_gem_submit_cmd {
-        uint32_t type;           /* in, one of MSM_SUBMIT_CMD_x */
-        uint32_t submit_idx;     /* in, index of submit_bo cmdstream buffer */
-        uint32_t submit_offset;  /* in, offset into submit_bo */
-        uint32_t size;           /* in, cmdstream size */
-        uint32_t pad;
-        uint32_t nr_relocs;      /* in, number of submit_reloc's */
-        uint64_t __user relocs;  /* in, ptr to array of submit_reloc's */
+        __u32 type;           /* in, one of MSM_SUBMIT_CMD_x */
+        __u32 submit_idx;     /* in, index of submit_bo cmdstream buffer */
+        __u32 submit_offset;  /* in, offset into submit_bo */
+        __u32 size;           /* in, cmdstream size */
+        __u32 pad;
+        __u32 nr_relocs;      /* in, number of submit_reloc's */
+        __u64 __user relocs;  /* in, ptr to array of submit_reloc's */
 };
 
 /* Each buffer referenced elsewhere in the cmdstream submit (ie. the
@@ -165,9 +165,9 @@ struct drm_msm_gem_submit_cmd {
 #define MSM_SUBMIT_BO_FLAGS            (MSM_SUBMIT_BO_READ | MSM_SUBMIT_BO_WRITE)
 
 struct drm_msm_gem_submit_bo {
-        uint32_t flags;          /* in, mask of MSM_SUBMIT_BO_x */
-        uint32_t handle;         /* in, GEM handle */
-        uint64_t presumed;       /* in/out, presumed buffer address */
+        __u32 flags;          /* in, mask of MSM_SUBMIT_BO_x */
+        __u32 handle;         /* in, GEM handle */
+        __u64 presumed;       /* in/out, presumed buffer address */
 };
 
 /* Each cmdstream submit consists of a table of buffers involved, and
@@ -175,12 +175,12 @@ struct drm_msm_gem_submit_bo {
  * (context-restore), and IB buffers needed for per tile/bin draw cmds.
  */
 struct drm_msm_gem_submit {
-        uint32_t pipe;           /* in, MSM_PIPE_x */
-        uint32_t fence;          /* out */
-        uint32_t nr_bos;         /* in, number of submit_bo's */
-        uint32_t nr_cmds;        /* in, number of submit_cmd's */
-        uint64_t __user bos;     /* in, ptr to array of submit_bo's */
-        uint64_t __user cmds;    /* in, ptr to array of submit_cmd's */
+        __u32 pipe;           /* in, MSM_PIPE_x */
+        __u32 fence;          /* out */
+        __u32 nr_bos;         /* in, number of submit_bo's */
+        __u32 nr_cmds;        /* in, number of submit_cmd's */
+        __u64 __user bos;     /* in, ptr to array of submit_bo's */
+        __u64 __user cmds;    /* in, ptr to array of submit_cmd's */
 };
 
 /* The normal way to synchronize with the GPU is just to CPU_PREP on
@@ -191,8 +191,8 @@ struct drm_msm_gem_submit {
  * APIs without requiring a dummy bo to synchronize on.
  */
 struct drm_msm_wait_fence {
-        uint32_t fence;          /* in */
-        uint32_t pad;
+        __u32 fence;          /* in */
+        __u32 pad;
         struct drm_msm_timespec timeout;   /* in */
 };
 
diff --git a/include/uapi/drm/radeon_drm.h b/include/uapi/drm/radeon_drm.h
index 94d44ab2fda1..01aa2a8e3f8d 100644
--- a/include/uapi/drm/radeon_drm.h
+++ b/include/uapi/drm/radeon_drm.h
@@ -33,7 +33,7 @@
 #ifndef __RADEON_DRM_H__
 #define __RADEON_DRM_H__
 
-#include <drm/drm.h>
+#include "drm.h"
 
 /* WARNING: If you change any of these defines, make sure to change the
  * defines in the X server file (radeon_sarea.h)
@@ -1039,6 +1039,7 @@ struct drm_radeon_cs {
 #define RADEON_INFO_CURRENT_GPU_MCLK    0x23
 #define RADEON_INFO_READ_REG            0x24
 #define RADEON_INFO_VA_UNMAP_WORKING    0x25
+#define RADEON_INFO_GPU_RESET_COUNTER   0x26
 
 struct drm_radeon_info {
         uint32_t                request;
diff --git a/include/uapi/linux/Kbuild b/include/uapi/linux/Kbuild
index 1a0006a76b00..1ff9942718fe 100644
--- a/include/uapi/linux/Kbuild
+++ b/include/uapi/linux/Kbuild
@@ -138,6 +138,7 @@ header-y += genetlink.h
 header-y += gen_stats.h
 header-y += gfs2_ondisk.h
 header-y += gigaset_dev.h
+header-y += gsmmux.h
 header-y += hdlcdrv.h
 header-y += hdlc.h
 header-y += hdreg.h
@@ -271,6 +272,7 @@ header-y += ncp_fs.h
 header-y += ncp.h
 header-y += ncp_mount.h
 header-y += ncp_no.h
+header-y += ndctl.h
 header-y += neighbour.h
 header-y += netconf.h
 header-y += netdevice.h
@@ -352,6 +354,7 @@ header-y += rtc.h
 header-y += rtnetlink.h
 header-y += scc.h
 header-y += sched.h
+header-y += scif_ioctl.h
 header-y += screen_info.h
 header-y += sctp.h
 header-y += sdla.h
@@ -430,6 +433,7 @@ header-y += virtio_balloon.h
 header-y += virtio_blk.h
 header-y += virtio_config.h
 header-y += virtio_console.h
+header-y += virtio_gpu.h
 header-y += virtio_ids.h
 header-y += virtio_input.h
 header-y += virtio_net.h
diff --git a/include/uapi/linux/bpf.h b/include/uapi/linux/bpf.h
index a9ebdf5701e8..29ef6f99e43d 100644
--- a/include/uapi/linux/bpf.h
+++ b/include/uapi/linux/bpf.h
@@ -113,6 +113,7 @@ enum bpf_map_type {
         BPF_MAP_TYPE_UNSPEC,
         BPF_MAP_TYPE_HASH,
         BPF_MAP_TYPE_ARRAY,
+        BPF_MAP_TYPE_PROG_ARRAY,
 };
 
 enum bpf_prog_type {
@@ -210,6 +211,44 @@ enum bpf_func_id {
          * Return: 0 on success
          */
         BPF_FUNC_l4_csum_replace,
+
+        /**
+         * bpf_tail_call(ctx, prog_array_map, index) - jump into another BPF program
+         * @ctx: context pointer passed to next program
+         * @prog_array_map: pointer to map which type is BPF_MAP_TYPE_PROG_ARRAY
+         * @index: index inside array that selects specific program to run
+         * Return: 0 on success
+         */
+        BPF_FUNC_tail_call,
+
+        /**
+         * bpf_clone_redirect(skb, ifindex, flags) - redirect to another netdev
+         * @skb: pointer to skb
+         * @ifindex: ifindex of the net device
+         * @flags: bit 0 - if set, redirect to ingress instead of egress
+         *         other bits - reserved
+         * Return: 0 on success
+         */
+        BPF_FUNC_clone_redirect,
+
+        /**
+         * u64 bpf_get_current_pid_tgid(void)
+         * Return: current->tgid << 32 | current->pid
+         */
+        BPF_FUNC_get_current_pid_tgid,
+
+        /**
+         * u64 bpf_get_current_uid_gid(void)
+         * Return: current_gid << 32 | current_uid
+         */
+        BPF_FUNC_get_current_uid_gid,
+
+        /**
+         * bpf_get_current_comm(char *buf, int size_of_buf)
+         * stores current->comm into buf
+         * Return: 0 on success
+         */
+        BPF_FUNC_get_current_comm,
         __BPF_FUNC_MAX_ID,
 };
 
@@ -226,6 +265,10 @@ struct __sk_buff {
         __u32 vlan_tci;
         __u32 vlan_proto;
         __u32 priority;
+        __u32 ingress_ifindex;
+        __u32 ifindex;
+        __u32 tc_index;
+        __u32 cb[5];
 };
 
 #endif /* _UAPI__LINUX_BPF_H__ */
diff --git a/include/uapi/linux/can.h b/include/uapi/linux/can.h
index 41892f720057..9692cda5f8fc 100644
--- a/include/uapi/linux/can.h
+++ b/include/uapi/linux/can.h
@@ -95,11 +95,17 @@ typedef __u32 can_err_mask_t;
  * @can_dlc: frame payload length in byte (0 .. 8) aka data length code
  *           N.B. the DLC field from ISO 11898-1 Chapter 8.4.2.3 has a 1:1
  *           mapping of the 'data length code' to the real payload length
+ * @__pad:   padding
+ * @__res0:  reserved / padding
+ * @__res1:  reserved / padding
  * @data:    CAN frame payload (up to 8 byte)
  */
 struct can_frame {
         canid_t can_id;  /* 32 bit CAN_ID + EFF/RTR/ERR flags */
         __u8    can_dlc; /* frame payload length in byte (0 .. CAN_MAX_DLEN) */
+        __u8    __pad;   /* padding */
+        __u8    __res0;  /* reserved / padding */
+        __u8    __res1;  /* reserved / padding */
         __u8    data[CAN_MAX_DLEN] __attribute__((aligned(8)));
 };
 
diff --git a/include/uapi/linux/can/gw.h b/include/uapi/linux/can/gw.h
index 3e6184cf2f6d..5079b9d57e31 100644
--- a/include/uapi/linux/can/gw.h
+++ b/include/uapi/linux/can/gw.h
@@ -78,6 +78,7 @@ enum {
         CGW_FILTER,     /* specify struct can_filter on source CAN device */
         CGW_DELETED,    /* number of deleted CAN frames (see max_hops param) */
         CGW_LIM_HOPS,   /* limit the number of hops of this specific rule */
+        CGW_MOD_UID,    /* user defined identifier for modification updates */
         __CGW_MAX
 };
 
@@ -162,6 +163,10 @@ enum {
  * load time of the can-gw module). This value is used to reduce the number of
  * possible hops for this gateway rule to a value smaller then max_hops.
  *
+ * CGW_MOD_UID (length 4 bytes):
+ * Optional non-zero user defined routing job identifier to alter existing
+ * modification settings at runtime.
+ *
  * CGW_CS_XOR (length 4 bytes):
  * Set a simple XOR checksum starting with an initial value into
  * data[result-idx] using data[start-idx] .. data[end-idx]
diff --git a/include/uapi/linux/dcbnl.h b/include/uapi/linux/dcbnl.h
index 6497d7933d5b..3ea470f35e40 100644
--- a/include/uapi/linux/dcbnl.h
+++ b/include/uapi/linux/dcbnl.h
@@ -207,8 +207,7 @@ struct cee_pfc {
 #define IEEE_8021QAZ_APP_SEL_ANY        4
 
 /* This structure contains the IEEE 802.1Qaz APP managed object. This
- * object is also used for the CEE std as well. There is no difference
- * between the objects.
+ * object is also used for the CEE std as well.
  *
  * @selector: protocol identifier type
  * @protocol: protocol of type indicated
@@ -216,13 +215,18 @@ struct cee_pfc {
  *            8-bit 802.1p user priority bitmap for CEE
  *
  * ----
- *  Selector field values
+ *  Selector field values for IEEE 802.1Qaz
  *      0       Reserved
  *      1       Ethertype
  *      2       Well known port number over TCP or SCTP
  *      3       Well known port number over UDP or DCCP
  *      4       Well known port number over TCP, SCTP, UDP, or DCCP
  *      5-7     Reserved
+ *
+ *  Selector field values for CEE
+ *      0       Ethertype
+ *      1       Well known port number over TCP or UDP
+ *      2-3     Reserved
  */
 struct dcb_app {
         __u8    selector;
diff --git a/include/uapi/linux/dm-ioctl.h b/include/uapi/linux/dm-ioctl.h
index eac8c3641f39..061aca3a962d 100644
--- a/include/uapi/linux/dm-ioctl.h
+++ b/include/uapi/linux/dm-ioctl.h
@@ -267,9 +267,9 @@ enum {
 #define DM_DEV_SET_GEOMETRY     _IOWR(DM_IOCTL, DM_DEV_SET_GEOMETRY_CMD, struct dm_ioctl)
 
 #define DM_VERSION_MAJOR        4
-#define DM_VERSION_MINOR        31
+#define DM_VERSION_MINOR        32
 #define DM_VERSION_PATCHLEVEL   0
-#define DM_VERSION_EXTRA        "-ioctl (2015-3-12)"
+#define DM_VERSION_EXTRA        "-ioctl (2015-6-26)"
 
 /* Status bits */
 #define DM_READONLY_FLAG        (1 << 0) /* In/Out */
diff --git a/include/uapi/linux/dvb/dmx.h b/include/uapi/linux/dvb/dmx.h
index b4fb650d9d4f..427e4899ed69 100644
--- a/include/uapi/linux/dvb/dmx.h
+++ b/include/uapi/linux/dvb/dmx.h
@@ -32,7 +32,7 @@
 
 #define DMX_FILTER_SIZE 16
 
-typedef enum
+enum dmx_output
 {
         DMX_OUT_DECODER, /* Streaming directly to decoder. */
         DMX_OUT_TAP,     /* Output going to a memory buffer */
@@ -41,10 +41,11 @@ typedef enum
                          /* (to be retrieved by reading from the */
                          /* logical DVR device).                 */
         DMX_OUT_TSDEMUX_TAP /* Like TS_TAP but retrieved from the DMX device */
-} dmx_output_t;
+};
 
+typedef enum dmx_output dmx_output_t;
 
-typedef enum
+typedef enum dmx_input
 {
         DMX_IN_FRONTEND, /* Input from a front-end device.  */
         DMX_IN_DVR       /* Input from the logical DVR device.  */
@@ -122,7 +123,7 @@ typedef struct dmx_caps {
         int num_decoders;
 } dmx_caps_t;
 
-typedef enum {
+typedef enum dmx_source {
         DMX_SOURCE_FRONT0 = 0,
         DMX_SOURCE_FRONT1,
         DMX_SOURCE_FRONT2,
@@ -139,7 +140,6 @@ struct dmx_stc {
         __u64 stc;              /* output: stc in 'base'*90 kHz units */
 };
 
-
 #define DMX_START                _IO('o', 41)
 #define DMX_STOP                 _IO('o', 42)
 #define DMX_SET_FILTER           _IOW('o', 43, struct dmx_sct_filter_params)
diff --git a/include/uapi/linux/dvb/frontend.h b/include/uapi/linux/dvb/frontend.h
index c56d77c496a5..00a20cd21ee2 100644
--- a/include/uapi/linux/dvb/frontend.h
+++ b/include/uapi/linux/dvb/frontend.h
@@ -28,15 +28,14 @@
 
 #include <linux/types.h>
 
-typedef enum fe_type {
+enum fe_type {
         FE_QPSK,
         FE_QAM,
         FE_OFDM,
         FE_ATSC
-} fe_type_t;
-
+};
 
-typedef enum fe_caps {
+enum fe_caps {
         FE_IS_STUPID                    = 0,
         FE_CAN_INVERSION_AUTO           = 0x1,
         FE_CAN_FEC_1_2                  = 0x2,
@@ -68,12 +67,11 @@ typedef enum fe_caps {
         FE_NEEDS_BENDING                = 0x20000000, /* not supported anymore, don't use (frontend requires frequency bending) */
         FE_CAN_RECOVER                  = 0x40000000, /* frontend can recover from a cable unplug automatically */
         FE_CAN_MUTE_TS                  = 0x80000000  /* frontend can stop spurious TS data output */
-} fe_caps_t;
-
+};
 
 struct dvb_frontend_info {
         char       name[128];
-        fe_type_t  type;                        /* DEPRECATED. Use DTV_ENUM_DELSYS instead */
+        enum fe_type type;      /* DEPRECATED. Use DTV_ENUM_DELSYS instead */
         __u32      frequency_min;
         __u32      frequency_max;
         __u32      frequency_stepsize;
@@ -82,7 +80,7 @@ struct dvb_frontend_info {
         __u32      symbol_rate_max;
         __u32      symbol_rate_tolerance;       /* ppm */
         __u32      notifier_delay;              /* DEPRECATED */
-        fe_caps_t  caps;
+        enum fe_caps caps;
 };
 
 
@@ -95,32 +93,27 @@ struct dvb_diseqc_master_cmd {
         __u8 msg_len;   /*  valid values are 3...6  */
 };
 
-
 struct dvb_diseqc_slave_reply {
         __u8 msg [4];   /*  { framing, data [3] } */
         __u8 msg_len;   /*  valid values are 0...4, 0 means no msg  */
         int  timeout;   /*  return from ioctl after timeout ms with */
 };                      /*  errorcode when no message was received  */
 
-
-typedef enum fe_sec_voltage {
+enum fe_sec_voltage {
         SEC_VOLTAGE_13,
         SEC_VOLTAGE_18,
         SEC_VOLTAGE_OFF
-} fe_sec_voltage_t;
-
+};
 
-typedef enum fe_sec_tone_mode {
+enum fe_sec_tone_mode {
         SEC_TONE_ON,
         SEC_TONE_OFF
-} fe_sec_tone_mode_t;
-
+};
 
-typedef enum fe_sec_mini_cmd {
+enum fe_sec_mini_cmd {
         SEC_MINI_A,
         SEC_MINI_B
-} fe_sec_mini_cmd_t;
-
+};
 
 /**
  * enum fe_status - enumerates the possible frontend status
@@ -133,8 +126,7 @@ typedef enum fe_sec_mini_cmd {
  * @FE_REINIT:          frontend was reinitialized, application is recommended
  *                      to reset DiSEqC, tone and parameters
  */
-
-typedef enum fe_status {
+enum fe_status {
         FE_HAS_SIGNAL           = 0x01,
         FE_HAS_CARRIER          = 0x02,
         FE_HAS_VITERBI          = 0x04,
@@ -142,16 +134,15 @@ typedef enum fe_status {
         FE_HAS_LOCK             = 0x10,
         FE_TIMEDOUT             = 0x20,
         FE_REINIT               = 0x40,
-} fe_status_t;
+};
 
-typedef enum fe_spectral_inversion {
+enum fe_spectral_inversion {
         INVERSION_OFF,
         INVERSION_ON,
         INVERSION_AUTO
-} fe_spectral_inversion_t;
-
+};
 
-typedef enum fe_code_rate {
+enum fe_code_rate {
         FEC_NONE = 0,
         FEC_1_2,
         FEC_2_3,
@@ -165,10 +156,9 @@ typedef enum fe_code_rate {
         FEC_3_5,
         FEC_9_10,
         FEC_2_5,
-} fe_code_rate_t;
-
+};
 
-typedef enum fe_modulation {
+enum fe_modulation {
         QPSK,
         QAM_16,
         QAM_32,
@@ -183,9 +173,9 @@ typedef enum fe_modulation {
         APSK_32,
         DQPSK,
         QAM_4_NR,
-} fe_modulation_t;
+};
 
-typedef enum fe_transmit_mode {
+enum fe_transmit_mode {
         TRANSMISSION_MODE_2K,
         TRANSMISSION_MODE_8K,
         TRANSMISSION_MODE_AUTO,
@@ -195,21 +185,9 @@ typedef enum fe_transmit_mode {
         TRANSMISSION_MODE_32K,
         TRANSMISSION_MODE_C1,
         TRANSMISSION_MODE_C3780,
-} fe_transmit_mode_t;
-
-#if defined(__DVB_CORE__) || !defined (__KERNEL__)
-typedef enum fe_bandwidth {
-        BANDWIDTH_8_MHZ,
-        BANDWIDTH_7_MHZ,
-        BANDWIDTH_6_MHZ,
-        BANDWIDTH_AUTO,
-        BANDWIDTH_5_MHZ,
-        BANDWIDTH_10_MHZ,
-        BANDWIDTH_1_712_MHZ,
-} fe_bandwidth_t;
-#endif
+};
 
-typedef enum fe_guard_interval {
+enum fe_guard_interval {
         GUARD_INTERVAL_1_32,
         GUARD_INTERVAL_1_16,
         GUARD_INTERVAL_1_8,
@@ -221,16 +199,15 @@ typedef enum fe_guard_interval {
         GUARD_INTERVAL_PN420,
         GUARD_INTERVAL_PN595,
         GUARD_INTERVAL_PN945,
-} fe_guard_interval_t;
-
+};
 
-typedef enum fe_hierarchy {
+enum fe_hierarchy {
         HIERARCHY_NONE,
         HIERARCHY_1,
         HIERARCHY_2,
         HIERARCHY_4,
         HIERARCHY_AUTO
-} fe_hierarchy_t;
+};
 
 enum fe_interleaving {
         INTERLEAVING_NONE,
@@ -239,51 +216,6 @@ enum fe_interleaving {
         INTERLEAVING_720,
 };
 
-#if defined(__DVB_CORE__) || !defined (__KERNEL__)
-struct dvb_qpsk_parameters {
-        __u32           symbol_rate;  /* symbol rate in Symbols per second */
-        fe_code_rate_t  fec_inner;    /* forward error correction (see above) */
-};
-
-struct dvb_qam_parameters {
-        __u32           symbol_rate; /* symbol rate in Symbols per second */
-        fe_code_rate_t  fec_inner;   /* forward error correction (see above) */
-        fe_modulation_t modulation;  /* modulation type (see above) */
-};
-
-struct dvb_vsb_parameters {
-        fe_modulation_t modulation;  /* modulation type (see above) */
-};
-
-struct dvb_ofdm_parameters {
-        fe_bandwidth_t      bandwidth;
-        fe_code_rate_t      code_rate_HP;  /* high priority stream code rate */
-        fe_code_rate_t      code_rate_LP;  /* low priority stream code rate */
-        fe_modulation_t     constellation; /* modulation type (see above) */
-        fe_transmit_mode_t  transmission_mode;
-        fe_guard_interval_t guard_interval;
-        fe_hierarchy_t      hierarchy_information;
-};
-
-
-struct dvb_frontend_parameters {
-        __u32 frequency;     /* (absolute) frequency in Hz for QAM/OFDM/ATSC */
-                             /* intermediate frequency in kHz for QPSK */
-        fe_spectral_inversion_t inversion;
-        union {
-                struct dvb_qpsk_parameters qpsk;
-                struct dvb_qam_parameters  qam;
-                struct dvb_ofdm_parameters ofdm;
-                struct dvb_vsb_parameters vsb;
-        } u;
-};
-
-struct dvb_frontend_event {
-        fe_status_t status;
-        struct dvb_frontend_parameters parameters;
-};
-#endif
-
 /* S2API Commands */
 #define DTV_UNDEFINED           0
 #define DTV_TUNE                1
@@ -377,20 +309,20 @@ struct dvb_frontend_event {
 
 #define DTV_MAX_COMMAND         DTV_STAT_TOTAL_BLOCK_COUNT
 
-typedef enum fe_pilot {
+enum fe_pilot {
         PILOT_ON,
         PILOT_OFF,
         PILOT_AUTO,
-} fe_pilot_t;
+};
 
-typedef enum fe_rolloff {
+enum fe_rolloff {
         ROLLOFF_35, /* Implied value in DVB-S, default for DVB-S2 */
         ROLLOFF_20,
         ROLLOFF_25,
         ROLLOFF_AUTO,
-} fe_rolloff_t;
+};
 
-typedef enum fe_delivery_system {
+enum fe_delivery_system {
         SYS_UNDEFINED,
         SYS_DVBC_ANNEX_A,
         SYS_DVBC_ANNEX_B,
@@ -410,7 +342,7 @@ typedef enum fe_delivery_system {
         SYS_DVBT2,
         SYS_TURBO,
         SYS_DVBC_ANNEX_C,
-} fe_delivery_system_t;
+};
 
 /* backward compatibility */
 #define SYS_DVBC_ANNEX_AC       SYS_DVBC_ANNEX_A
@@ -467,7 +399,7 @@ struct dtv_cmds_h {
  * @FE_SCALE_NOT_AVAILABLE: That QoS measure is not available. That
  *                          could indicate a temporary or a permanent
  *                          condition.
- * @FE_SCALE_DECIBEL: The scale is measured in 0.0001 dB steps, typically
+ * @FE_SCALE_DECIBEL: The scale is measured in 0.001 dB steps, typically
  *                used on signal measures.
  * @FE_SCALE_RELATIVE: The scale is a relative percentual measure,
  *                      ranging from 0 (0%) to 0xffff (100%).
@@ -503,20 +435,20 @@ enum fecap_scale_params {
  *
  * In other words, for ISDB, those values should be filled like:
  *      u.st.stat.svalue[0] = global statistics;
- *      u.st.stat.scale[0] = FE_SCALE_DECIBELS;
+ *      u.st.stat.scale[0] = FE_SCALE_DECIBEL;
  *      u.st.stat.value[1] = layer A statistics;
  *      u.st.stat.scale[1] = FE_SCALE_NOT_AVAILABLE (if not available);
  *      u.st.stat.svalue[2] = layer B statistics;
- *      u.st.stat.scale[2] = FE_SCALE_DECIBELS;
+ *      u.st.stat.scale[2] = FE_SCALE_DECIBEL;
  *      u.st.stat.svalue[3] = layer C statistics;
- *      u.st.stat.scale[3] = FE_SCALE_DECIBELS;
+ *      u.st.stat.scale[3] = FE_SCALE_DECIBEL;
  *      u.st.len = 4;
  */
 struct dtv_stats {
         __u8 scale;     /* enum fecap_scale_params type */
         union {
                 __u64 uvalue;   /* for counters and relative scales */
-                __s64 svalue;   /* for 0.0001 dB measures */
+                __s64 svalue;   /* for 0.001 dB measures */
         };
 } __attribute__ ((packed));
 
@@ -552,10 +484,88 @@ struct dtv_properties {
         struct dtv_property *props;
 };
 
+#if defined(__DVB_CORE__) || !defined (__KERNEL__)
+
+/*
+ * DEPRECATED: The DVBv3 ioctls, structs and enums should not be used on
+ * newer programs, as it doesn't support the second generation of digital
+ * TV standards, nor supports newer delivery systems.
+ */
+
+enum fe_bandwidth {
+        BANDWIDTH_8_MHZ,
+        BANDWIDTH_7_MHZ,
+        BANDWIDTH_6_MHZ,
+        BANDWIDTH_AUTO,
+        BANDWIDTH_5_MHZ,
+        BANDWIDTH_10_MHZ,
+        BANDWIDTH_1_712_MHZ,
+};
+
+/* This is needed for legacy userspace support */
+typedef enum fe_sec_voltage fe_sec_voltage_t;
+typedef enum fe_caps fe_caps_t;
+typedef enum fe_type fe_type_t;
+typedef enum fe_sec_tone_mode fe_sec_tone_mode_t;
+typedef enum fe_sec_mini_cmd fe_sec_mini_cmd_t;
+typedef enum fe_status fe_status_t;
+typedef enum fe_spectral_inversion fe_spectral_inversion_t;
+typedef enum fe_code_rate fe_code_rate_t;
+typedef enum fe_modulation fe_modulation_t;
+typedef enum fe_transmit_mode fe_transmit_mode_t;
+typedef enum fe_bandwidth fe_bandwidth_t;
+typedef enum fe_guard_interval fe_guard_interval_t;
+typedef enum fe_hierarchy fe_hierarchy_t;
+typedef enum fe_pilot fe_pilot_t;
+typedef enum fe_rolloff fe_rolloff_t;
+typedef enum fe_delivery_system fe_delivery_system_t;
+
+struct dvb_qpsk_parameters {
+        __u32           symbol_rate;  /* symbol rate in Symbols per second */
+        fe_code_rate_t  fec_inner;    /* forward error correction (see above) */
+};
+
+struct dvb_qam_parameters {
+        __u32           symbol_rate; /* symbol rate in Symbols per second */
+        fe_code_rate_t  fec_inner;   /* forward error correction (see above) */
+        fe_modulation_t modulation;  /* modulation type (see above) */
+};
+
+struct dvb_vsb_parameters {
+        fe_modulation_t modulation;  /* modulation type (see above) */
+};
+
+struct dvb_ofdm_parameters {
+        fe_bandwidth_t      bandwidth;
+        fe_code_rate_t      code_rate_HP;  /* high priority stream code rate */
+        fe_code_rate_t      code_rate_LP;  /* low priority stream code rate */
+        fe_modulation_t     constellation; /* modulation type (see above) */
+        fe_transmit_mode_t  transmission_mode;
+        fe_guard_interval_t guard_interval;
+        fe_hierarchy_t      hierarchy_information;
+};
+
+struct dvb_frontend_parameters {
+        __u32 frequency;     /* (absolute) frequency in Hz for DVB-C/DVB-T/ATSC */
+                             /* intermediate frequency in kHz for DVB-S */
+        fe_spectral_inversion_t inversion;
+        union {
+                struct dvb_qpsk_parameters qpsk;        /* DVB-S */
+                struct dvb_qam_parameters  qam;         /* DVB-C */
+                struct dvb_ofdm_parameters ofdm;        /* DVB-T */
+                struct dvb_vsb_parameters vsb;          /* ATSC */
+        } u;
+};
+
+struct dvb_frontend_event {
+        fe_status_t status;
+        struct dvb_frontend_parameters parameters;
+};
+#endif
+
 #define FE_SET_PROPERTY            _IOW('o', 82, struct dtv_properties)
 #define FE_GET_PROPERTY            _IOR('o', 83, struct dtv_properties)
 
-
 /**
  * When set, this flag will disable any zigzagging or other "normal" tuning
  * behaviour. Additionally, there will be no automatic monitoring of the lock
@@ -565,7 +575,6 @@ struct dtv_properties {
  */
 #define FE_TUNE_MODE_ONESHOT 0x01
 
-
 #define FE_GET_INFO                _IOR('o', 61, struct dvb_frontend_info)
 
 #define FE_DISEQC_RESET_OVERLOAD   _IO('o', 62)
diff --git a/include/uapi/linux/elf-em.h b/include/uapi/linux/elf-em.h
index ae99f7743cf4..b08829667ed7 100644
--- a/include/uapi/linux/elf-em.h
+++ b/include/uapi/linux/elf-em.h
@@ -25,6 +25,7 @@
 #define EM_ARM          40      /* ARM 32 bit */
 #define EM_SH           42      /* SuperH */
 #define EM_SPARCV9      43      /* SPARC v9 64-bit */
+#define EM_H8_300       46      /* Renesas H8/300 */
 #define EM_IA_64        50      /* HP/Intel IA-64 */
 #define EM_X86_64       62      /* AMD x86-64 */
 #define EM_S390         22      /* IBM S/390 */
diff --git a/include/uapi/linux/ethtool.h b/include/uapi/linux/ethtool.h
index 2e49fc880d29..cd67aec187d9 100644
--- a/include/uapi/linux/ethtool.h
+++ b/include/uapi/linux/ethtool.h
@@ -215,6 +215,11 @@ enum tunable_id {
         ETHTOOL_ID_UNSPEC,
         ETHTOOL_RX_COPYBREAK,
         ETHTOOL_TX_COPYBREAK,
+        /*
+         * Add your fresh new tubale attribute above and remember to update
+         * tunable_strings[] in net/core/ethtool.c
+         */
+        __ETHTOOL_TUNABLE_COUNT,
 };
 
 enum tunable_type_id {
@@ -545,6 +550,7 @@ enum ethtool_stringset {
         ETH_SS_NTUPLE_FILTERS,
         ETH_SS_FEATURES,
         ETH_SS_RSS_HASH_FUNCS,
+        ETH_SS_TUNABLES,
 };
 
 /**
@@ -796,6 +802,31 @@ struct ethtool_rx_flow_spec {
         __u32           location;
 };
 
+/* How rings are layed out when accessing virtual functions or
+ * offloaded queues is device specific. To allow users to do flow
+ * steering and specify these queues the ring cookie is partitioned
+ * into a 32bit queue index with an 8 bit virtual function id.
+ * This also leaves the 3bytes for further specifiers. It is possible
+ * future devices may support more than 256 virtual functions if
+ * devices start supporting PCIe w/ARI. However at the moment I
+ * do not know of any devices that support this so I do not reserve
+ * space for this at this time. If a future patch consumes the next
+ * byte it should be aware of this possiblity.
+ */
+#define ETHTOOL_RX_FLOW_SPEC_RING       0x00000000FFFFFFFFLL
+#define ETHTOOL_RX_FLOW_SPEC_RING_VF    0x000000FF00000000LL
+#define ETHTOOL_RX_FLOW_SPEC_RING_VF_OFF 32
+static inline __u64 ethtool_get_flow_spec_ring(__u64 ring_cookie)
+{
+        return ETHTOOL_RX_FLOW_SPEC_RING & ring_cookie;
+};
+
+static inline __u64 ethtool_get_flow_spec_ring_vf(__u64 ring_cookie)
+{
+        return (ETHTOOL_RX_FLOW_SPEC_RING_VF & ring_cookie) >>
+                                ETHTOOL_RX_FLOW_SPEC_RING_VF_OFF;
+};
+
 /**
  * struct ethtool_rxnfc - command to get or set RX flow classification rules
  * @cmd: Specific command number - %ETHTOOL_GRXFH, %ETHTOOL_SRXFH,
@@ -1264,15 +1295,19 @@ enum ethtool_sfeatures_retval_bits {
  * it was forced up into this mode or autonegotiated.
  */
 
-/* The forced speed, 10Mb, 100Mb, gigabit, [2.5|10|20|40|56]GbE. */
+/* The forced speed, 10Mb, 100Mb, gigabit, [2.5|5|10|20|25|40|50|56|100]GbE. */
 #define SPEED_10                10
 #define SPEED_100               100
 #define SPEED_1000              1000
 #define SPEED_2500              2500
+#define SPEED_5000              5000
 #define SPEED_10000             10000
 #define SPEED_20000             20000
+#define SPEED_25000             25000
 #define SPEED_40000             40000
+#define SPEED_50000             50000
 #define SPEED_56000             56000
+#define SPEED_100000            100000
 
 #define SPEED_UNKNOWN           -1
 
diff --git a/include/uapi/linux/fuse.h b/include/uapi/linux/fuse.h
index 25084a052a1e..c9aca042e61d 100644
--- a/include/uapi/linux/fuse.h
+++ b/include/uapi/linux/fuse.h
@@ -755,4 +755,7 @@ struct fuse_notify_retrieve_in {
         uint64_t        dummy4;
 };
 
+/* Device ioctls: */
+#define FUSE_DEV_IOC_CLONE      _IOR(229, 0, uint32_t)
+
 #endif /* _LINUX_FUSE_H */
diff --git a/include/linux/gsmmux.h b/include/uapi/linux/gsmmux.h
index c25e9477f7c3..c06742d52856 100644
--- a/include/linux/gsmmux.h
+++ b/include/uapi/linux/gsmmux.h
@@ -1,6 +1,9 @@
 #ifndef _LINUX_GSMMUX_H
 #define _LINUX_GSMMUX_H
 
+#include <linux/if.h>
+#include <linux/ioctl.h>
+
 struct gsm_config
 {
         unsigned int adaption;
diff --git a/include/uapi/linux/hsi/cs-protocol.h b/include/uapi/linux/hsi/cs-protocol.h
index 4957bba57cbe..f153d6ea7c62 100644
--- a/include/uapi/linux/hsi/cs-protocol.h
+++ b/include/uapi/linux/hsi/cs-protocol.h
@@ -76,6 +76,15 @@ struct cs_buffer_config {
 };
 
 /*
+ * struct for monotonic timestamp taken when the
+ * last control command was received
+ */
+struct cs_timestamp {
+        __u32 tv_sec;  /* seconds */
+        __u32 tv_nsec; /* nanoseconds */
+};
+
+/*
  * Struct describing the layout and contents of the driver mmap area.
  * This information is meant as read-only information for the application.
  */
@@ -91,11 +100,8 @@ struct cs_mmap_config_block {
         __u32 rx_ptr;
         __u32 rx_ptr_boundary;
         __u32 reserved3[2];
-        /*
-         * if enabled with CS_FEAT_TSTAMP_RX_CTRL, monotonic
-         * timestamp taken when the last control command was received
-         */
-        struct timespec tstamp_rx_ctrl;
+        /* enabled with CS_FEAT_TSTAMP_RX_CTRL */
+        struct cs_timestamp tstamp_rx_ctrl;
 };
 
 #define CS_IO_MAGIC             'C'
diff --git a/include/uapi/linux/hyperv.h b/include/uapi/linux/hyperv.h
index bb1cb73c927a..e4c0a35d6417 100644
--- a/include/uapi/linux/hyperv.h
+++ b/include/uapi/linux/hyperv.h
@@ -45,6 +45,11 @@
 
 #define VSS_OP_REGISTER 128
 
+/*
+  Daemon code with full handshake support.
+ */
+#define VSS_OP_REGISTER1 129
+
 enum hv_vss_op {
         VSS_OP_CREATE = 0,
         VSS_OP_DELETE,
@@ -100,7 +105,8 @@ struct hv_vss_msg {
  */
 
 #define FCOPY_VERSION_0 0
-#define FCOPY_CURRENT_VERSION FCOPY_VERSION_0
+#define FCOPY_VERSION_1 1
+#define FCOPY_CURRENT_VERSION FCOPY_VERSION_1
 #define W_MAX_PATH 260
 
 enum hv_fcopy_op {
diff --git a/include/uapi/linux/i2c.h b/include/uapi/linux/i2c.h
index 0e949cbfd333..b0a7dd61eb35 100644
--- a/include/uapi/linux/i2c.h
+++ b/include/uapi/linux/i2c.h
@@ -87,6 +87,7 @@ struct i2c_msg {
 #define I2C_FUNC_PROTOCOL_MANGLING      0x00000004 /* I2C_M_IGNORE_NAK etc. */
 #define I2C_FUNC_SMBUS_PEC              0x00000008
 #define I2C_FUNC_NOSTART                0x00000010 /* I2C_M_NOSTART */
+#define I2C_FUNC_SLAVE                  0x00000020
 #define I2C_FUNC_SMBUS_BLOCK_PROC_CALL  0x00008000 /* SMBus 2.0 */
 #define I2C_FUNC_SMBUS_QUICK            0x00010000
 #define I2C_FUNC_SMBUS_READ_BYTE        0x00020000
diff --git a/include/uapi/linux/if_link.h b/include/uapi/linux/if_link.h
index d9cd19214b98..2c7e8e3d3981 100644
--- a/include/uapi/linux/if_link.h
+++ b/include/uapi/linux/if_link.h
@@ -390,6 +390,17 @@ struct ifla_vxlan_port_range {
         __be16  high;
 };
 
+/* GENEVE section */
+enum {
+        IFLA_GENEVE_UNSPEC,
+        IFLA_GENEVE_ID,
+        IFLA_GENEVE_REMOTE,
+        IFLA_GENEVE_TTL,
+        IFLA_GENEVE_TOS,
+        __IFLA_GENEVE_MAX
+};
+#define IFLA_GENEVE_MAX (__IFLA_GENEVE_MAX - 1)
+
 /* Bonding section */
 
 enum {
@@ -417,6 +428,9 @@ enum {
         IFLA_BOND_AD_LACP_RATE,
         IFLA_BOND_AD_SELECT,
         IFLA_BOND_AD_INFO,
+        IFLA_BOND_AD_ACTOR_SYS_PRIO,
+        IFLA_BOND_AD_USER_PORT_KEY,
+        IFLA_BOND_AD_ACTOR_SYSTEM,
         __IFLA_BOND_MAX,
 };
 
@@ -442,6 +456,8 @@ enum {
         IFLA_BOND_SLAVE_PERM_HWADDR,
         IFLA_BOND_SLAVE_QUEUE_ID,
         IFLA_BOND_SLAVE_AD_AGGREGATOR_ID,
+        IFLA_BOND_SLAVE_AD_ACTOR_OPER_PORT_STATE,
+        IFLA_BOND_SLAVE_AD_PARTNER_OPER_PORT_STATE,
         __IFLA_BOND_SLAVE_MAX,
 };
 
@@ -468,6 +484,7 @@ enum {
         IFLA_VF_RSS_QUERY_EN,   /* RSS Redirection Table and Hash Key query
                                  * on/off switch
                                  */
+        IFLA_VF_STATS,          /* network device statistics */
         __IFLA_VF_MAX,
 };
 
@@ -517,6 +534,18 @@ struct ifla_vf_rss_query_en {
         __u32 setting;
 };
 
+enum {
+        IFLA_VF_STATS_RX_PACKETS,
+        IFLA_VF_STATS_TX_PACKETS,
+        IFLA_VF_STATS_RX_BYTES,
+        IFLA_VF_STATS_TX_BYTES,
+        IFLA_VF_STATS_BROADCAST,
+        IFLA_VF_STATS_MULTICAST,
+        __IFLA_VF_STATS_MAX,
+};
+
+#define IFLA_VF_STATS_MAX (__IFLA_VF_STATS_MAX - 1)
+
 /* VF ports management section
  *
  *      Nested layout of set/get msg is:
diff --git a/include/uapi/linux/if_packet.h b/include/uapi/linux/if_packet.h
index 053bd102fbe0..d3d715f8c88f 100644
--- a/include/uapi/linux/if_packet.h
+++ b/include/uapi/linux/if_packet.h
@@ -54,6 +54,7 @@ struct sockaddr_ll {
 #define PACKET_FANOUT                   18
 #define PACKET_TX_HAS_OFF               19
 #define PACKET_QDISC_BYPASS             20
+#define PACKET_ROLLOVER_STATS           21
 
 #define PACKET_FANOUT_HASH              0
 #define PACKET_FANOUT_LB                1
@@ -75,6 +76,12 @@ struct tpacket_stats_v3 {
         unsigned int    tp_freeze_q_cnt;
 };
 
+struct tpacket_rollover_stats {
+        __aligned_u64   tp_all;
+        __aligned_u64   tp_huge;
+        __aligned_u64   tp_failed;
+};
+
 union tpacket_stats_u {
         struct tpacket_stats stats1;
         struct tpacket_stats_v3 stats3;
diff --git a/include/uapi/linux/if_tun.h b/include/uapi/linux/if_tun.h
index 50ae24335444..3cb5e1d85ddd 100644
--- a/include/uapi/linux/if_tun.h
+++ b/include/uapi/linux/if_tun.h
@@ -50,6 +50,12 @@
 #define TUNGETFILTER _IOR('T', 219, struct sock_fprog)
 #define TUNSETVNETLE _IOW('T', 220, int)
 #define TUNGETVNETLE _IOR('T', 221, int)
+/* The TUNSETVNETBE and TUNGETVNETBE ioctls are for cross-endian support on
+ * little-endian hosts. Not all kernel configurations support them, but all
+ * configurations that support SET also support GET.
+ */
+#define TUNSETVNETBE _IOW('T', 222, int)
+#define TUNGETVNETBE _IOR('T', 223, int)
 
 /* TUNSETIFF ifr flags */
 #define IFF_TUN         0x0001
diff --git a/include/uapi/linux/iio/types.h b/include/uapi/linux/iio/types.h
index 5c4601935005..2f8b11722204 100644
--- a/include/uapi/linux/iio/types.h
+++ b/include/uapi/linux/iio/types.h
@@ -70,6 +70,8 @@ enum iio_modifier {
         IIO_MOD_WALKING,
         IIO_MOD_STILL,
         IIO_MOD_ROOT_SUM_SQUARED_X_Y_Z,
+        IIO_MOD_I,
+        IIO_MOD_Q,
 };
 
 enum iio_event_type {
diff --git a/include/uapi/linux/in.h b/include/uapi/linux/in.h
index 589ced069e8a..eaf94919291a 100644
--- a/include/uapi/linux/in.h
+++ b/include/uapi/linux/in.h
@@ -19,8 +19,10 @@
 #define _UAPI_LINUX_IN_H
 
 #include <linux/types.h>
+#include <linux/libc-compat.h>
 #include <linux/socket.h>
 
+#if __UAPI_DEF_IN_IPPROTO
 /* Standard well-defined IP protocols.  */
 enum {
   IPPROTO_IP = 0,               /* Dummy protocol for TCP               */
@@ -69,16 +71,20 @@ enum {
 #define IPPROTO_SCTP            IPPROTO_SCTP
   IPPROTO_UDPLITE = 136,        /* UDP-Lite (RFC 3828)                  */
 #define IPPROTO_UDPLITE         IPPROTO_UDPLITE
+  IPPROTO_MPLS = 137,           /* MPLS in IP (RFC 4023)                */
+#define IPPROTO_MPLS            IPPROTO_MPLS
   IPPROTO_RAW = 255,            /* Raw IP packets                       */
 #define IPPROTO_RAW             IPPROTO_RAW
   IPPROTO_MAX
 };
+#endif
 
-
+#if __UAPI_DEF_IN_ADDR
 /* Internet address. */
 struct in_addr {
         __be32  s_addr;
 };
+#endif
 
 #define IP_TOS          1
 #define IP_TTL          2
@@ -110,6 +116,7 @@ struct in_addr {
 #define IP_MINTTL       21
 #define IP_NODEFRAG     22
 #define IP_CHECKSUM     23
+#define IP_BIND_ADDRESS_NO_PORT 24
 
 /* IP_MTU_DISCOVER values */
 #define IP_PMTUDISC_DONT                0       /* Never send DF frames */
@@ -155,6 +162,7 @@ struct in_addr {
 
 /* Request struct for multicast socket ops */
 
+#if __UAPI_DEF_IP_MREQ
 struct ip_mreq  {
         struct in_addr imr_multiaddr;   /* IP multicast address of group */
         struct in_addr imr_interface;   /* local IP address of interface */
@@ -206,14 +214,18 @@ struct group_filter {
 #define GROUP_FILTER_SIZE(numsrc) \
         (sizeof(struct group_filter) - sizeof(struct __kernel_sockaddr_storage) \
         + (numsrc) * sizeof(struct __kernel_sockaddr_storage))
+#endif
 
+#if __UAPI_DEF_IN_PKTINFO
 struct in_pktinfo {
         int             ipi_ifindex;
         struct in_addr  ipi_spec_dst;
         struct in_addr  ipi_addr;
 };
+#endif
 
 /* Structure describing an Internet (IP) socket address. */
+#if  __UAPI_DEF_SOCKADDR_IN
 #define __SOCK_SIZE__   16              /* sizeof(struct sockaddr)      */
 struct sockaddr_in {
   __kernel_sa_family_t  sin_family;     /* Address family               */
@@ -225,8 +237,9 @@ struct sockaddr_in {
                         sizeof(unsigned short int) - sizeof(struct in_addr)];
 };
 #define sin_zero        __pad           /* for BSD UNIX comp. -FvK      */
+#endif
 
-
+#if __UAPI_DEF_IN_CLASS
 /*
  * Definitions of the bits in an Internet address integer.
  * On subnets, host and network parts are found according
@@ -277,7 +290,7 @@ struct sockaddr_in {
 #define INADDR_ALLHOSTS_GROUP   0xe0000001U     /* 224.0.0.1   */
 #define INADDR_ALLRTRS_GROUP    0xe0000002U     /* 224.0.0.2 */
 #define INADDR_MAX_LOCAL_GROUP  0xe00000ffU     /* 224.0.0.255 */
-
+#endif
 
 /* <asm/byteorder.h> contains the htonl type stuff.. */
 #include <asm/byteorder.h> 
diff --git a/include/uapi/linux/inet_diag.h b/include/uapi/linux/inet_diag.h
index c7093c75bdd6..68a1f71fde9f 100644
--- a/include/uapi/linux/inet_diag.h
+++ b/include/uapi/linux/inet_diag.h
@@ -111,9 +111,11 @@ enum {
         INET_DIAG_SKMEMINFO,
         INET_DIAG_SHUTDOWN,
         INET_DIAG_DCTCPINFO,
+        INET_DIAG_PROTOCOL,  /* response attribute only */
+        INET_DIAG_SKV6ONLY,
 };
 
-#define INET_DIAG_MAX INET_DIAG_DCTCPINFO
+#define INET_DIAG_MAX INET_DIAG_SKV6ONLY
 
 /* INET_DIAG_MEM */
 
diff --git a/include/uapi/linux/ip.h b/include/uapi/linux/ip.h
index 411959405ab6..08f894d2ddbd 100644
--- a/include/uapi/linux/ip.h
+++ b/include/uapi/linux/ip.h
@@ -164,6 +164,7 @@ enum
         IPV4_DEVCONF_ROUTE_LOCALNET,
         IPV4_DEVCONF_IGMPV2_UNSOLICITED_REPORT_INTERVAL,
         IPV4_DEVCONF_IGMPV3_UNSOLICITED_REPORT_INTERVAL,
+        IPV4_DEVCONF_IGNORE_ROUTES_WITH_LINKDOWN,
         __IPV4_DEVCONF_MAX
 };
 
diff --git a/include/uapi/linux/ipv6_route.h b/include/uapi/linux/ipv6_route.h
index 2be7bd174751..f6598d1c886e 100644
--- a/include/uapi/linux/ipv6_route.h
+++ b/include/uapi/linux/ipv6_route.h
@@ -34,6 +34,7 @@
 #define RTF_PREF(pref)  ((pref) << 27)
 #define RTF_PREF_MASK   0x18000000
 
+#define RTF_PCPU        0x40000000
 #define RTF_LOCAL       0x80000000
 
 
diff --git a/include/uapi/linux/kfd_ioctl.h b/include/uapi/linux/kfd_ioctl.h
index af94f31e33ac..d6833426fdef 100644
--- a/include/uapi/linux/kfd_ioctl.h
+++ b/include/uapi/linux/kfd_ioctl.h
@@ -27,7 +27,7 @@
 #include <linux/ioctl.h>
 
 #define KFD_IOCTL_MAJOR_VERSION 1
-#define KFD_IOCTL_MINOR_VERSION 0
+#define KFD_IOCTL_MINOR_VERSION 1
 
 struct kfd_ioctl_get_version_args {
         uint32_t major_version; /* from KFD */
@@ -128,6 +128,110 @@ struct kfd_ioctl_get_process_apertures_args {
         uint32_t pad;
 };
 
+#define MAX_ALLOWED_NUM_POINTS    100
+#define MAX_ALLOWED_AW_BUFF_SIZE 4096
+#define MAX_ALLOWED_WAC_BUFF_SIZE  128
+
+struct kfd_ioctl_dbg_register_args {
+        uint32_t gpu_id;                /* to KFD */
+        uint32_t pad;
+};
+
+struct kfd_ioctl_dbg_unregister_args {
+        uint32_t gpu_id;                /* to KFD */
+        uint32_t pad;
+};
+
+struct kfd_ioctl_dbg_address_watch_args {
+        uint64_t content_ptr;           /* a pointer to the actual content */
+        uint32_t gpu_id;                /* to KFD */
+        uint32_t buf_size_in_bytes;     /*including gpu_id and buf_size */
+};
+
+struct kfd_ioctl_dbg_wave_control_args {
+        uint64_t content_ptr;           /* a pointer to the actual content */
+        uint32_t gpu_id;                /* to KFD */
+        uint32_t buf_size_in_bytes;     /*including gpu_id and buf_size */
+};
+
+/* Matching HSA_EVENTTYPE */
+#define KFD_IOC_EVENT_SIGNAL                    0
+#define KFD_IOC_EVENT_NODECHANGE                1
+#define KFD_IOC_EVENT_DEVICESTATECHANGE         2
+#define KFD_IOC_EVENT_HW_EXCEPTION              3
+#define KFD_IOC_EVENT_SYSTEM_EVENT              4
+#define KFD_IOC_EVENT_DEBUG_EVENT               5
+#define KFD_IOC_EVENT_PROFILE_EVENT             6
+#define KFD_IOC_EVENT_QUEUE_EVENT               7
+#define KFD_IOC_EVENT_MEMORY                    8
+
+#define KFD_IOC_WAIT_RESULT_COMPLETE            0
+#define KFD_IOC_WAIT_RESULT_TIMEOUT             1
+#define KFD_IOC_WAIT_RESULT_FAIL                2
+
+#define KFD_SIGNAL_EVENT_LIMIT                  256
+
+struct kfd_ioctl_create_event_args {
+        uint64_t event_page_offset;     /* from KFD */
+        uint32_t event_trigger_data;    /* from KFD - signal events only */
+        uint32_t event_type;            /* to KFD */
+        uint32_t auto_reset;            /* to KFD */
+        uint32_t node_id;               /* to KFD - only valid for certain
+                                                        event types */
+        uint32_t event_id;              /* from KFD */
+        uint32_t event_slot_index;      /* from KFD */
+};
+
+struct kfd_ioctl_destroy_event_args {
+        uint32_t event_id;              /* to KFD */
+        uint32_t pad;
+};
+
+struct kfd_ioctl_set_event_args {
+        uint32_t event_id;              /* to KFD */
+        uint32_t pad;
+};
+
+struct kfd_ioctl_reset_event_args {
+        uint32_t event_id;              /* to KFD */
+        uint32_t pad;
+};
+
+struct kfd_memory_exception_failure {
+        uint32_t NotPresent;    /* Page not present or supervisor privilege */
+        uint32_t ReadOnly;      /* Write access to a read-only page */
+        uint32_t NoExecute;     /* Execute access to a page marked NX */
+        uint32_t pad;
+};
+
+/* memory exception data*/
+struct kfd_hsa_memory_exception_data {
+        struct kfd_memory_exception_failure failure;
+        uint64_t va;
+        uint32_t gpu_id;
+        uint32_t pad;
+};
+
+/* Event data*/
+struct kfd_event_data {
+        union {
+                struct kfd_hsa_memory_exception_data memory_exception_data;
+        };                              /* From KFD */
+        uint64_t kfd_event_data_ext;    /* pointer to an extension structure
+                                           for future exception types */
+        uint32_t event_id;              /* to KFD */
+        uint32_t pad;
+};
+
+struct kfd_ioctl_wait_events_args {
+        uint64_t events_ptr;            /* pointed to struct
+                                           kfd_event_data array, to KFD */
+        uint32_t num_events;            /* to KFD */
+        uint32_t wait_for_all;          /* to KFD */
+        uint32_t timeout;               /* to KFD */
+        uint32_t wait_result;           /* from KFD */
+};
+
 #define AMDKFD_IOCTL_BASE 'K'
 #define AMDKFD_IO(nr)                   _IO(AMDKFD_IOCTL_BASE, nr)
 #define AMDKFD_IOR(nr, type)            _IOR(AMDKFD_IOCTL_BASE, nr, type)
@@ -155,7 +259,34 @@ struct kfd_ioctl_get_process_apertures_args {
 #define AMDKFD_IOC_UPDATE_QUEUE                 \
                 AMDKFD_IOW(0x07, struct kfd_ioctl_update_queue_args)
 
+#define AMDKFD_IOC_CREATE_EVENT                 \
+                AMDKFD_IOWR(0x08, struct kfd_ioctl_create_event_args)
+
+#define AMDKFD_IOC_DESTROY_EVENT                \
+                AMDKFD_IOW(0x09, struct kfd_ioctl_destroy_event_args)
+
+#define AMDKFD_IOC_SET_EVENT                    \
+                AMDKFD_IOW(0x0A, struct kfd_ioctl_set_event_args)
+
+#define AMDKFD_IOC_RESET_EVENT                  \
+                AMDKFD_IOW(0x0B, struct kfd_ioctl_reset_event_args)
+
+#define AMDKFD_IOC_WAIT_EVENTS                  \
+                AMDKFD_IOWR(0x0C, struct kfd_ioctl_wait_events_args)
+
+#define AMDKFD_IOC_DBG_REGISTER                 \
+                AMDKFD_IOW(0x0D, struct kfd_ioctl_dbg_register_args)
+
+#define AMDKFD_IOC_DBG_UNREGISTER               \
+                AMDKFD_IOW(0x0E, struct kfd_ioctl_dbg_unregister_args)
+
+#define AMDKFD_IOC_DBG_ADDRESS_WATCH            \
+                AMDKFD_IOW(0x0F, struct kfd_ioctl_dbg_address_watch_args)
+
+#define AMDKFD_IOC_DBG_WAVE_CONTROL             \
+                AMDKFD_IOW(0x10, struct kfd_ioctl_dbg_wave_control_args)
+
 #define AMDKFD_COMMAND_START            0x01
-#define AMDKFD_COMMAND_END              0x08
+#define AMDKFD_COMMAND_END              0x11
 
 #endif
diff --git a/include/uapi/linux/kvm.h b/include/uapi/linux/kvm.h
index 4b60056776d1..716ad4ae4d4b 100644
--- a/include/uapi/linux/kvm.h
+++ b/include/uapi/linux/kvm.h
@@ -202,7 +202,7 @@ struct kvm_run {
         __u32 exit_reason;
         __u8 ready_for_interrupt_injection;
         __u8 if_flag;
-        __u8 padding2[2];
+        __u16 flags;
 
         /* in (pre_kvm_run), out (post_kvm_run) */
         __u64 cr8;
@@ -814,6 +814,9 @@ struct kvm_ppc_smmu_info {
 #define KVM_CAP_S390_INJECT_IRQ 113
 #define KVM_CAP_S390_IRQ_STATE 114
 #define KVM_CAP_PPC_HWRNG 115
+#define KVM_CAP_DISABLE_QUIRKS 116
+#define KVM_CAP_X86_SMM 117
+#define KVM_CAP_MULTI_ADDRESS_SPACE 118
 
 #ifdef KVM_CAP_IRQ_ROUTING
 
@@ -894,7 +897,7 @@ struct kvm_xen_hvm_config {
  *
  * KVM_IRQFD_FLAG_RESAMPLE indicates resamplefd is valid and specifies
  * the irqfd to operate in resampling mode for level triggered interrupt
- * emlation.  See Documentation/virtual/kvm/api.txt.
+ * emulation.  See Documentation/virtual/kvm/api.txt.
  */
 #define KVM_IRQFD_FLAG_RESAMPLE (1 << 1)
 
@@ -1199,6 +1202,8 @@ struct kvm_s390_ucas_mapping {
 /* Available with KVM_CAP_S390_IRQ_STATE */
 #define KVM_S390_SET_IRQ_STATE    _IOW(KVMIO, 0xb5, struct kvm_s390_irq_state)
 #define KVM_S390_GET_IRQ_STATE    _IOW(KVMIO, 0xb6, struct kvm_s390_irq_state)
+/* Available with KVM_CAP_X86_SMM */
+#define KVM_SMI                   _IO(KVMIO,   0xb7)
 
 #define KVM_DEV_ASSIGN_ENABLE_IOMMU     (1 << 0)
 #define KVM_DEV_ASSIGN_PCI_2_3          (1 << 1)
diff --git a/include/uapi/linux/libc-compat.h b/include/uapi/linux/libc-compat.h
index fa673e9cc040..7d024ceb075d 100644
--- a/include/uapi/linux/libc-compat.h
+++ b/include/uapi/linux/libc-compat.h
@@ -56,6 +56,13 @@
 
 /* GLIBC headers included first so don't define anything
  * that would already be defined. */
+#define __UAPI_DEF_IN_ADDR              0
+#define __UAPI_DEF_IN_IPPROTO           0
+#define __UAPI_DEF_IN_PKTINFO           0
+#define __UAPI_DEF_IP_MREQ              0
+#define __UAPI_DEF_SOCKADDR_IN          0
+#define __UAPI_DEF_IN_CLASS             0
+
 #define __UAPI_DEF_IN6_ADDR             0
 /* The exception is the in6_addr macros which must be defined
  * if the glibc code didn't define them. This guard matches
@@ -78,6 +85,13 @@
 /* Linux headers included first, and we must define everything
  * we need. The expectation is that glibc will check the
  * __UAPI_DEF_* defines and adjust appropriately. */
+#define __UAPI_DEF_IN_ADDR              1
+#define __UAPI_DEF_IN_IPPROTO           1
+#define __UAPI_DEF_IN_PKTINFO           1
+#define __UAPI_DEF_IP_MREQ              1
+#define __UAPI_DEF_SOCKADDR_IN          1
+#define __UAPI_DEF_IN_CLASS             1
+
 #define __UAPI_DEF_IN6_ADDR             1
 /* We unconditionally define the in6_addr macros and glibc must
  * coordinate. */
@@ -103,6 +117,14 @@
  * that we need. */
 #else /* !defined(__GLIBC__) */
 
+/* Definitions for in.h */
+#define __UAPI_DEF_IN_ADDR              1
+#define __UAPI_DEF_IN_IPPROTO           1
+#define __UAPI_DEF_IN_PKTINFO           1
+#define __UAPI_DEF_IP_MREQ              1
+#define __UAPI_DEF_SOCKADDR_IN          1
+#define __UAPI_DEF_IN_CLASS             1
+
 /* Definitions for in6.h */
 #define __UAPI_DEF_IN6_ADDR             1
 #define __UAPI_DEF_IN6_ADDR_ALT         1
diff --git a/include/uapi/linux/mic_common.h b/include/uapi/linux/mic_common.h
index 6eb40244e019..302a2ced373c 100644
--- a/include/uapi/linux/mic_common.h
+++ b/include/uapi/linux/mic_common.h
@@ -80,6 +80,12 @@ struct mic_device_ctrl {
  * @h2c_config_db: Host to Card Virtio config doorbell set by card
  * @shutdown_status: Card shutdown status set by card
  * @shutdown_card: Set to 1 by the host when a card shutdown is initiated
+ * @tot_nodes: Total number of nodes in the SCIF network
+ * @node_id: Unique id of the node
+ * @h2c_scif_db - Host to card SCIF doorbell set by card
+ * @c2h_scif_db - Card to host SCIF doorbell set by host
+ * @scif_host_dma_addr - SCIF host queue pair DMA address
+ * @scif_card_dma_addr - SCIF card queue pair DMA address
  */
 struct mic_bootparam {
         __le32 magic;
@@ -88,6 +94,12 @@ struct mic_bootparam {
         __s8 h2c_config_db;
         __u8 shutdown_status;
         __u8 shutdown_card;
+        __u8 tot_nodes;
+        __u8 node_id;
+        __u8 h2c_scif_db;
+        __u8 c2h_scif_db;
+        __u64 scif_host_dma_addr;
+        __u64 scif_card_dma_addr;
 } __attribute__ ((aligned(8)));
 
 /**
diff --git a/include/uapi/linux/nbd.h b/include/uapi/linux/nbd.h
index 4f52549b23ff..e08e413d5f71 100644
--- a/include/uapi/linux/nbd.h
+++ b/include/uapi/linux/nbd.h
@@ -44,8 +44,6 @@ enum {
 /* there is a gap here to match userspace */
 #define NBD_FLAG_SEND_TRIM    (1 << 5) /* send trim/discard */
 
-#define nbd_cmd(req) ((req)->cmd[0])
-
 /* userspace doesn't need the nbd_device structure */
 
 /* These are sent over the network in the request/reply magic fields */
diff --git a/include/uapi/linux/ndctl.h b/include/uapi/linux/ndctl.h
new file mode 100644
index 000000000000..2b94ea2287bb
--- /dev/null
+++ b/include/uapi/linux/ndctl.h
@@ -0,0 +1,197 @@
+/*
+ * Copyright (c) 2014-2015, Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU Lesser General Public License,
+ * version 2.1, 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 Lesser General Public License for
+ * more details.
+ */
+#ifndef __NDCTL_H__
+#define __NDCTL_H__
+
+#include <linux/types.h>
+
+struct nd_cmd_smart {
+        __u32 status;
+        __u8 data[128];
+} __packed;
+
+struct nd_cmd_smart_threshold {
+        __u32 status;
+        __u8 data[8];
+} __packed;
+
+struct nd_cmd_dimm_flags {
+        __u32 status;
+        __u32 flags;
+} __packed;
+
+struct nd_cmd_get_config_size {
+        __u32 status;
+        __u32 config_size;
+        __u32 max_xfer;
+} __packed;
+
+struct nd_cmd_get_config_data_hdr {
+        __u32 in_offset;
+        __u32 in_length;
+        __u32 status;
+        __u8 out_buf[0];
+} __packed;
+
+struct nd_cmd_set_config_hdr {
+        __u32 in_offset;
+        __u32 in_length;
+        __u8 in_buf[0];
+} __packed;
+
+struct nd_cmd_vendor_hdr {
+        __u32 opcode;
+        __u32 in_length;
+        __u8 in_buf[0];
+} __packed;
+
+struct nd_cmd_vendor_tail {
+        __u32 status;
+        __u32 out_length;
+        __u8 out_buf[0];
+} __packed;
+
+struct nd_cmd_ars_cap {
+        __u64 address;
+        __u64 length;
+        __u32 status;
+        __u32 max_ars_out;
+} __packed;
+
+struct nd_cmd_ars_start {
+        __u64 address;
+        __u64 length;
+        __u16 type;
+        __u8 reserved[6];
+        __u32 status;
+} __packed;
+
+struct nd_cmd_ars_status {
+        __u32 status;
+        __u32 out_length;
+        __u64 address;
+        __u64 length;
+        __u16 type;
+        __u32 num_records;
+        struct nd_ars_record {
+                __u32 handle;
+                __u32 flags;
+                __u64 err_address;
+                __u64 mask;
+        } __packed records[0];
+} __packed;
+
+enum {
+        ND_CMD_IMPLEMENTED = 0,
+
+        /* bus commands */
+        ND_CMD_ARS_CAP = 1,
+        ND_CMD_ARS_START = 2,
+        ND_CMD_ARS_STATUS = 3,
+
+        /* per-dimm commands */
+        ND_CMD_SMART = 1,
+        ND_CMD_SMART_THRESHOLD = 2,
+        ND_CMD_DIMM_FLAGS = 3,
+        ND_CMD_GET_CONFIG_SIZE = 4,
+        ND_CMD_GET_CONFIG_DATA = 5,
+        ND_CMD_SET_CONFIG_DATA = 6,
+        ND_CMD_VENDOR_EFFECT_LOG_SIZE = 7,
+        ND_CMD_VENDOR_EFFECT_LOG = 8,
+        ND_CMD_VENDOR = 9,
+};
+
+static inline const char *nvdimm_bus_cmd_name(unsigned cmd)
+{
+        static const char * const names[] = {
+                [ND_CMD_ARS_CAP] = "ars_cap",
+                [ND_CMD_ARS_START] = "ars_start",
+                [ND_CMD_ARS_STATUS] = "ars_status",
+        };
+
+        if (cmd < ARRAY_SIZE(names) && names[cmd])
+                return names[cmd];
+        return "unknown";
+}
+
+static inline const char *nvdimm_cmd_name(unsigned cmd)
+{
+        static const char * const names[] = {
+                [ND_CMD_SMART] = "smart",
+                [ND_CMD_SMART_THRESHOLD] = "smart_thresh",
+                [ND_CMD_DIMM_FLAGS] = "flags",
+                [ND_CMD_GET_CONFIG_SIZE] = "get_size",
+                [ND_CMD_GET_CONFIG_DATA] = "get_data",
+                [ND_CMD_SET_CONFIG_DATA] = "set_data",
+                [ND_CMD_VENDOR_EFFECT_LOG_SIZE] = "effect_size",
+                [ND_CMD_VENDOR_EFFECT_LOG] = "effect_log",
+                [ND_CMD_VENDOR] = "vendor",
+        };
+
+        if (cmd < ARRAY_SIZE(names) && names[cmd])
+                return names[cmd];
+        return "unknown";
+}
+
+#define ND_IOCTL 'N'
+
+#define ND_IOCTL_SMART                  _IOWR(ND_IOCTL, ND_CMD_SMART,\
+                                        struct nd_cmd_smart)
+
+#define ND_IOCTL_SMART_THRESHOLD        _IOWR(ND_IOCTL, ND_CMD_SMART_THRESHOLD,\
+                                        struct nd_cmd_smart_threshold)
+
+#define ND_IOCTL_DIMM_FLAGS             _IOWR(ND_IOCTL, ND_CMD_DIMM_FLAGS,\
+                                        struct nd_cmd_dimm_flags)
+
+#define ND_IOCTL_GET_CONFIG_SIZE        _IOWR(ND_IOCTL, ND_CMD_GET_CONFIG_SIZE,\
+                                        struct nd_cmd_get_config_size)
+
+#define ND_IOCTL_GET_CONFIG_DATA        _IOWR(ND_IOCTL, ND_CMD_GET_CONFIG_DATA,\
+                                        struct nd_cmd_get_config_data_hdr)
+
+#define ND_IOCTL_SET_CONFIG_DATA        _IOWR(ND_IOCTL, ND_CMD_SET_CONFIG_DATA,\
+                                        struct nd_cmd_set_config_hdr)
+
+#define ND_IOCTL_VENDOR                 _IOWR(ND_IOCTL, ND_CMD_VENDOR,\
+                                        struct nd_cmd_vendor_hdr)
+
+#define ND_IOCTL_ARS_CAP                _IOWR(ND_IOCTL, ND_CMD_ARS_CAP,\
+                                        struct nd_cmd_ars_cap)
+
+#define ND_IOCTL_ARS_START              _IOWR(ND_IOCTL, ND_CMD_ARS_START,\
+                                        struct nd_cmd_ars_start)
+
+#define ND_IOCTL_ARS_STATUS             _IOWR(ND_IOCTL, ND_CMD_ARS_STATUS,\
+                                        struct nd_cmd_ars_status)
+
+#define ND_DEVICE_DIMM 1            /* nd_dimm: container for "config data" */
+#define ND_DEVICE_REGION_PMEM 2     /* nd_region: (parent of PMEM namespaces) */
+#define ND_DEVICE_REGION_BLK 3      /* nd_region: (parent of BLK namespaces) */
+#define ND_DEVICE_NAMESPACE_IO 4    /* legacy persistent memory */
+#define ND_DEVICE_NAMESPACE_PMEM 5  /* PMEM namespace (may alias with BLK) */
+#define ND_DEVICE_NAMESPACE_BLK 6   /* BLK namespace (may alias with PMEM) */
+
+enum nd_driver_flags {
+        ND_DRIVER_DIMM            = 1 << ND_DEVICE_DIMM,
+        ND_DRIVER_REGION_PMEM     = 1 << ND_DEVICE_REGION_PMEM,
+        ND_DRIVER_REGION_BLK      = 1 << ND_DEVICE_REGION_BLK,
+        ND_DRIVER_NAMESPACE_IO    = 1 << ND_DEVICE_NAMESPACE_IO,
+        ND_DRIVER_NAMESPACE_PMEM  = 1 << ND_DEVICE_NAMESPACE_PMEM,
+        ND_DRIVER_NAMESPACE_BLK   = 1 << ND_DEVICE_NAMESPACE_BLK,
+};
+
+enum {
+        ND_MIN_NAMESPACE_SIZE = 0x00400000,
+};
+#endif /* __NDCTL_H__ */
diff --git a/include/uapi/linux/netconf.h b/include/uapi/linux/netconf.h
index 669a1f0b1d97..23cbd34e4ac7 100644
--- a/include/uapi/linux/netconf.h
+++ b/include/uapi/linux/netconf.h
@@ -15,6 +15,7 @@ enum {
         NETCONFA_RP_FILTER,
         NETCONFA_MC_FORWARDING,
         NETCONFA_PROXY_NEIGH,
+        NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
         __NETCONFA_MAX
 };
 #define NETCONFA_MAX    (__NETCONFA_MAX - 1)
diff --git a/include/uapi/linux/netfilter.h b/include/uapi/linux/netfilter.h
index ef1b1f88ca18..d93f949d1d9a 100644
--- a/include/uapi/linux/netfilter.h
+++ b/include/uapi/linux/netfilter.h
@@ -4,7 +4,8 @@
 #include <linux/types.h>
 #include <linux/compiler.h>
 #include <linux/sysctl.h>
-
+#include <linux/in.h>
+#include <linux/in6.h>
 
 /* Responses from hook functions. */
 #define NF_DROP 0
@@ -51,11 +52,17 @@ enum nf_inet_hooks {
         NF_INET_NUMHOOKS
 };
 
+enum nf_dev_hooks {
+        NF_NETDEV_INGRESS,
+        NF_NETDEV_NUMHOOKS
+};
+
 enum {
         NFPROTO_UNSPEC =  0,
         NFPROTO_INET   =  1,
         NFPROTO_IPV4   =  2,
         NFPROTO_ARP    =  3,
+        NFPROTO_NETDEV =  5,
         NFPROTO_BRIDGE =  7,
         NFPROTO_IPV6   = 10,
         NFPROTO_DECNET = 12,
diff --git a/include/uapi/linux/netfilter/ipset/ip_set.h b/include/uapi/linux/netfilter/ipset/ip_set.h
index 5ab4e60894cf..63b2e34f1b60 100644
--- a/include/uapi/linux/netfilter/ipset/ip_set.h
+++ b/include/uapi/linux/netfilter/ipset/ip_set.h
@@ -15,12 +15,12 @@
 /* The protocol version */
 #define IPSET_PROTOCOL          6
 
-/* The maximum permissible comment length we will accept over netlink */
-#define IPSET_MAX_COMMENT_SIZE  255
-
 /* The max length of strings including NUL: set and type identifiers */
 #define IPSET_MAXNAMELEN        32
 
+/* The maximum permissible comment length we will accept over netlink */
+#define IPSET_MAX_COMMENT_SIZE  255
+
 /* Message types and commands */
 enum ipset_cmd {
         IPSET_CMD_NONE,
diff --git a/include/uapi/linux/netfilter/nf_tables.h b/include/uapi/linux/netfilter/nf_tables.h
index 5fa1cd04762e..a99e6a997140 100644
--- a/include/uapi/linux/netfilter/nf_tables.h
+++ b/include/uapi/linux/netfilter/nf_tables.h
@@ -122,11 +122,13 @@ enum nft_list_attributes {
  *
  * @NFTA_HOOK_HOOKNUM: netfilter hook number (NLA_U32)
  * @NFTA_HOOK_PRIORITY: netfilter hook priority (NLA_U32)
+ * @NFTA_HOOK_DEV: netdevice name (NLA_STRING)
  */
 enum nft_hook_attributes {
         NFTA_HOOK_UNSPEC,
         NFTA_HOOK_HOOKNUM,
         NFTA_HOOK_PRIORITY,
+        NFTA_HOOK_DEV,
         __NFTA_HOOK_MAX
 };
 #define NFTA_HOOK_MAX           (__NFTA_HOOK_MAX - 1)
diff --git a/include/uapi/linux/netfilter/nfnetlink_queue.h b/include/uapi/linux/netfilter/nfnetlink_queue.h
index 8dd819e2b5fe..b67a853638ff 100644
--- a/include/uapi/linux/netfilter/nfnetlink_queue.h
+++ b/include/uapi/linux/netfilter/nfnetlink_queue.h
@@ -49,6 +49,7 @@ enum nfqnl_attr_type {
         NFQA_EXP,                       /* nf_conntrack_netlink.h */
         NFQA_UID,                       /* __u32 sk uid */
         NFQA_GID,                       /* __u32 sk gid */
+        NFQA_SECCTX,                    /* security context string */
 
         __NFQA_MAX
 };
@@ -102,7 +103,8 @@ enum nfqnl_attr_config {
 #define NFQA_CFG_F_CONNTRACK                    (1 << 1)
 #define NFQA_CFG_F_GSO                          (1 << 2)
 #define NFQA_CFG_F_UID_GID                      (1 << 3)
-#define NFQA_CFG_F_MAX                          (1 << 4)
+#define NFQA_CFG_F_SECCTX                       (1 << 4)
+#define NFQA_CFG_F_MAX                          (1 << 5)
 
 /* flags for NFQA_SKB_INFO */
 /* packet appears to have wrong checksums, but they are ok */
diff --git a/include/uapi/linux/netfilter/xt_socket.h b/include/uapi/linux/netfilter/xt_socket.h
index 6315e2ac3474..87644f832494 100644
--- a/include/uapi/linux/netfilter/xt_socket.h
+++ b/include/uapi/linux/netfilter/xt_socket.h
@@ -6,6 +6,7 @@
 enum {
         XT_SOCKET_TRANSPARENT = 1 << 0,
         XT_SOCKET_NOWILDCARD = 1 << 1,
+        XT_SOCKET_RESTORESKMARK = 1 << 2,
 };
 
 struct xt_socket_mtinfo1 {
@@ -18,4 +19,11 @@ struct xt_socket_mtinfo2 {
 };
 #define XT_SOCKET_FLAGS_V2 (XT_SOCKET_TRANSPARENT | XT_SOCKET_NOWILDCARD)
 
+struct xt_socket_mtinfo3 {
+        __u8 flags;
+};
+#define XT_SOCKET_FLAGS_V3 (XT_SOCKET_TRANSPARENT \
+                           | XT_SOCKET_NOWILDCARD \
+                           | XT_SOCKET_RESTORESKMARK)
+
 #endif /* _XT_SOCKET_H */
diff --git a/include/uapi/linux/netfilter_bridge/ebtables.h b/include/uapi/linux/netfilter_bridge/ebtables.h
index 773dfe8924c7..fd2ee501726d 100644
--- a/include/uapi/linux/netfilter_bridge/ebtables.h
+++ b/include/uapi/linux/netfilter_bridge/ebtables.h
@@ -6,7 +6,7 @@
  *
  *  ebtables.c,v 2.0, April, 2002
  *
- *  This code is stongly inspired on the iptables code which is
+ *  This code is strongly inspired by the iptables code which is
  *  Copyright (C) 1999 Paul `Rusty' Russell & Michael J. Neuling
  */
 
diff --git a/include/uapi/linux/netlink.h b/include/uapi/linux/netlink.h
index 1a85940f8ab7..cf6a65cccbdf 100644
--- a/include/uapi/linux/netlink.h
+++ b/include/uapi/linux/netlink.h
@@ -101,13 +101,15 @@ struct nlmsgerr {
         struct nlmsghdr msg;
 };
 
-#define NETLINK_ADD_MEMBERSHIP  1
-#define NETLINK_DROP_MEMBERSHIP 2
-#define NETLINK_PKTINFO         3
-#define NETLINK_BROADCAST_ERROR 4
-#define NETLINK_NO_ENOBUFS      5
-#define NETLINK_RX_RING         6
-#define NETLINK_TX_RING         7
+#define NETLINK_ADD_MEMBERSHIP          1
+#define NETLINK_DROP_MEMBERSHIP         2
+#define NETLINK_PKTINFO                 3
+#define NETLINK_BROADCAST_ERROR         4
+#define NETLINK_NO_ENOBUFS              5
+#define NETLINK_RX_RING                 6
+#define NETLINK_TX_RING                 7
+#define NETLINK_LISTEN_ALL_NSID         8
+#define NETLINK_LIST_MEMBERSHIPS        9
 
 struct nl_pktinfo {
         __u32   group;
diff --git a/include/uapi/linux/nfc.h b/include/uapi/linux/nfc.h
index c1e2e63cf9b5..dd3f75389076 100644
--- a/include/uapi/linux/nfc.h
+++ b/include/uapi/linux/nfc.h
@@ -86,6 +86,8 @@
  *      for this event is the application ID (AID).
  * @NFC_CMD_GET_SE: Dump all discovered secure elements from an NFC controller.
  * @NFC_CMD_SE_IO: Send/Receive APDUs to/from the selected secure element.
+ * @NFC_CMD_VENDOR: Vendor specific command, to be implemented directly
+ *      from the driver in order to support hardware specific operations.
  */
 enum nfc_commands {
         NFC_CMD_UNSPEC,
@@ -117,6 +119,7 @@ enum nfc_commands {
         NFC_CMD_GET_SE,
         NFC_CMD_SE_IO,
         NFC_CMD_ACTIVATE_TARGET,
+        NFC_CMD_VENDOR,
 /* private: internal use only */
         __NFC_CMD_AFTER_LAST
 };
@@ -153,6 +156,10 @@ enum nfc_commands {
  * @NFC_ATTR_APDU: Secure element APDU
  * @NFC_ATTR_TARGET_ISO15693_DSFID: ISO 15693 Data Storage Format Identifier
  * @NFC_ATTR_TARGET_ISO15693_UID: ISO 15693 Unique Identifier
+ * @NFC_ATTR_VENDOR_ID: NFC manufacturer unique ID, typically an OUI
+ * @NFC_ATTR_VENDOR_SUBCMD: Vendor specific sub command
+ * @NFC_ATTR_VENDOR_DATA: Vendor specific data, to be optionally passed
+ *      to a vendor specific command implementation
  */
 enum nfc_attrs {
         NFC_ATTR_UNSPEC,
@@ -184,6 +191,9 @@ enum nfc_attrs {
         NFC_ATTR_TARGET_ISO15693_DSFID,
         NFC_ATTR_TARGET_ISO15693_UID,
         NFC_ATTR_SE_PARAMS,
+        NFC_ATTR_VENDOR_ID,
+        NFC_ATTR_VENDOR_SUBCMD,
+        NFC_ATTR_VENDOR_DATA,
 /* private: internal use only */
         __NFC_ATTR_AFTER_LAST
 };
diff --git a/include/uapi/linux/nfs4.h b/include/uapi/linux/nfs4.h
index adc0aff83fbb..2119c7c274d7 100644
--- a/include/uapi/linux/nfs4.h
+++ b/include/uapi/linux/nfs4.h
@@ -86,6 +86,10 @@
 #define ACL4_SUPPORT_AUDIT_ACL 0x04
 #define ACL4_SUPPORT_ALARM_ACL 0x08
 
+#define NFS4_ACL_AUTO_INHERIT 0x00000001
+#define NFS4_ACL_PROTECTED    0x00000002
+#define NFS4_ACL_DEFAULTED    0x00000004
+
 #define NFS4_ACE_FILE_INHERIT_ACE             0x00000001
 #define NFS4_ACE_DIRECTORY_INHERIT_ACE        0x00000002
 #define NFS4_ACE_NO_PROPAGATE_INHERIT_ACE     0x00000004
@@ -93,6 +97,7 @@
 #define NFS4_ACE_SUCCESSFUL_ACCESS_ACE_FLAG   0x00000010
 #define NFS4_ACE_FAILED_ACCESS_ACE_FLAG       0x00000020
 #define NFS4_ACE_IDENTIFIER_GROUP             0x00000040
+#define NFS4_ACE_INHERITED_ACE                0x00000080
 
 #define NFS4_ACE_READ_DATA                    0x00000001
 #define NFS4_ACE_LIST_DIRECTORY               0x00000001
@@ -106,6 +111,8 @@
 #define NFS4_ACE_DELETE_CHILD                 0x00000040
 #define NFS4_ACE_READ_ATTRIBUTES              0x00000080
 #define NFS4_ACE_WRITE_ATTRIBUTES             0x00000100
+#define NFS4_ACE_WRITE_RETENTION              0x00000200
+#define NFS4_ACE_WRITE_RETENTION_HOLD         0x00000400
 #define NFS4_ACE_DELETE                       0x00010000
 #define NFS4_ACE_READ_ACL                     0x00020000
 #define NFS4_ACE_WRITE_ACL                    0x00040000
diff --git a/include/uapi/linux/nl80211.h b/include/uapi/linux/nl80211.h
index 241220c43e86..c0ab6b0a3919 100644
--- a/include/uapi/linux/nl80211.h
+++ b/include/uapi/linux/nl80211.h
@@ -2620,16 +2620,17 @@ enum nl80211_band_attr {
  *      an indoor surroundings, i.e., it is connected to AC power (and not
  *      through portable DC inverters) or is under the control of a master
  *      that is acting as an AP and is connected to AC power.
- * @NL80211_FREQUENCY_ATTR_GO_CONCURRENT: GO operation is allowed on this
+ * @NL80211_FREQUENCY_ATTR_IR_CONCURRENT: IR operation is allowed on this
  *      channel if it's connected concurrently to a BSS on the same channel on
  *      the 2 GHz band or to a channel in the same UNII band (on the 5 GHz
- *      band), and IEEE80211_CHAN_RADAR is not set. Instantiating a GO on a
- *      channel that has the GO_CONCURRENT attribute set can be done when there
- *      is a clear assessment that the device is operating under the guidance of
- *      an authorized master, i.e., setting up a GO while the device is also
- *      connected to an AP with DFS and radar detection on the UNII band (it is
- *      up to user-space, i.e., wpa_supplicant to perform the required
- *      verifications)
+ *      band), and IEEE80211_CHAN_RADAR is not set. Instantiating a GO or TDLS
+ *      off-channel on a channel that has the IR_CONCURRENT attribute set can be
+ *      done when there is a clear assessment that the device is operating under
+ *      the guidance of an authorized master, i.e., setting up a GO or TDLS
+ *      off-channel while the device is also connected to an AP with DFS and
+ *      radar detection on the UNII band (it is up to user-space, i.e.,
+ *      wpa_supplicant to perform the required verifications). Using this
+ *      attribute for IR is disallowed for master interfaces (IBSS, AP).
  * @NL80211_FREQUENCY_ATTR_NO_20MHZ: 20 MHz operation is not allowed
  *      on this channel in current regulatory domain.
  * @NL80211_FREQUENCY_ATTR_NO_10MHZ: 10 MHz operation is not allowed
@@ -2641,7 +2642,7 @@ enum nl80211_band_attr {
  * See https://apps.fcc.gov/eas/comments/GetPublishedDocument.html?id=327&tn=528122
  * for more information on the FCC description of the relaxations allowed
  * by NL80211_FREQUENCY_ATTR_INDOOR_ONLY and
- * NL80211_FREQUENCY_ATTR_GO_CONCURRENT.
+ * NL80211_FREQUENCY_ATTR_IR_CONCURRENT.
  */
 enum nl80211_frequency_attr {
         __NL80211_FREQUENCY_ATTR_INVALID,
@@ -2659,7 +2660,7 @@ enum nl80211_frequency_attr {
         NL80211_FREQUENCY_ATTR_NO_160MHZ,
         NL80211_FREQUENCY_ATTR_DFS_CAC_TIME,
         NL80211_FREQUENCY_ATTR_INDOOR_ONLY,
-        NL80211_FREQUENCY_ATTR_GO_CONCURRENT,
+        NL80211_FREQUENCY_ATTR_IR_CONCURRENT,
         NL80211_FREQUENCY_ATTR_NO_20MHZ,
         NL80211_FREQUENCY_ATTR_NO_10MHZ,
 
@@ -2672,6 +2673,8 @@ enum nl80211_frequency_attr {
 #define NL80211_FREQUENCY_ATTR_PASSIVE_SCAN     NL80211_FREQUENCY_ATTR_NO_IR
 #define NL80211_FREQUENCY_ATTR_NO_IBSS          NL80211_FREQUENCY_ATTR_NO_IR
 #define NL80211_FREQUENCY_ATTR_NO_IR            NL80211_FREQUENCY_ATTR_NO_IR
+#define NL80211_FREQUENCY_ATTR_GO_CONCURRENT \
+                                        NL80211_FREQUENCY_ATTR_IR_CONCURRENT
 
 /**
  * enum nl80211_bitrate_attr - bitrate attributes
@@ -2830,7 +2833,7 @@ enum nl80211_sched_scan_match_attr {
  * @NL80211_RRF_AUTO_BW: maximum available bandwidth should be calculated
  *      base on contiguous rules and wider channels will be allowed to cross
  *      multiple contiguous/overlapping frequency ranges.
- * @NL80211_RRF_GO_CONCURRENT: See &NL80211_FREQUENCY_ATTR_GO_CONCURRENT
+ * @NL80211_RRF_IR_CONCURRENT: See &NL80211_FREQUENCY_ATTR_IR_CONCURRENT
  * @NL80211_RRF_NO_HT40MINUS: channels can't be used in HT40- operation
  * @NL80211_RRF_NO_HT40PLUS: channels can't be used in HT40+ operation
  * @NL80211_RRF_NO_80MHZ: 80MHz operation not allowed
@@ -2847,7 +2850,7 @@ enum nl80211_reg_rule_flags {
         NL80211_RRF_NO_IR               = 1<<7,
         __NL80211_RRF_NO_IBSS           = 1<<8,
         NL80211_RRF_AUTO_BW             = 1<<11,
-        NL80211_RRF_GO_CONCURRENT       = 1<<12,
+        NL80211_RRF_IR_CONCURRENT       = 1<<12,
         NL80211_RRF_NO_HT40MINUS        = 1<<13,
         NL80211_RRF_NO_HT40PLUS         = 1<<14,
         NL80211_RRF_NO_80MHZ            = 1<<15,
@@ -2859,6 +2862,7 @@ enum nl80211_reg_rule_flags {
 #define NL80211_RRF_NO_IR               NL80211_RRF_NO_IR
 #define NL80211_RRF_NO_HT40             (NL80211_RRF_NO_HT40MINUS |\
                                          NL80211_RRF_NO_HT40PLUS)
+#define NL80211_RRF_GO_CONCURRENT       NL80211_RRF_IR_CONCURRENT
 
 /* For backport compatibility with older userspace */
 #define NL80211_RRF_NO_IR_ALL           (NL80211_RRF_NO_IR | __NL80211_RRF_NO_IBSS)
diff --git a/include/uapi/linux/nvme.h b/include/uapi/linux/nvme.h
index aef9a81b2d75..732b32e92b02 100644
--- a/include/uapi/linux/nvme.h
+++ b/include/uapi/linux/nvme.h
@@ -179,6 +179,10 @@ enum {
         NVME_SMART_CRIT_VOLATILE_MEMORY = 1 << 4,
 };
 
+enum {
+        NVME_AER_NOTICE_NS_CHANGED      = 0x0002,
+};
+
 struct nvme_lba_range_type {
         __u8                    type;
         __u8                    attributes;
@@ -579,5 +583,6 @@ struct nvme_passthru_cmd {
 #define NVME_IOCTL_ADMIN_CMD    _IOWR('N', 0x41, struct nvme_admin_cmd)
 #define NVME_IOCTL_SUBMIT_IO    _IOW('N', 0x42, struct nvme_user_io)
 #define NVME_IOCTL_IO_CMD       _IOWR('N', 0x43, struct nvme_passthru_cmd)
+#define NVME_IOCTL_RESET        _IO('N', 0x44)
 
 #endif /* _UAPI_LINUX_NVME_H */
diff --git a/include/uapi/linux/openvswitch.h b/include/uapi/linux/openvswitch.h
index bbd49a0c46c7..1dab77601c21 100644
--- a/include/uapi/linux/openvswitch.h
+++ b/include/uapi/linux/openvswitch.h
@@ -153,6 +153,8 @@ enum ovs_packet_cmd {
  * flow key against the kernel's.
  * @OVS_PACKET_ATTR_ACTIONS: Contains actions for the packet.  Used
  * for %OVS_PACKET_CMD_EXECUTE.  It has nested %OVS_ACTION_ATTR_* attributes.
+ * Also used in upcall when %OVS_ACTION_ATTR_USERSPACE has optional
+ * %OVS_USERSPACE_ATTR_ACTIONS attribute.
  * @OVS_PACKET_ATTR_USERDATA: Present for an %OVS_PACKET_CMD_ACTION
  * notification if the %OVS_ACTION_ATTR_USERSPACE action specified an
  * %OVS_USERSPACE_ATTR_USERDATA attribute, with the same length and content
@@ -528,6 +530,7 @@ enum ovs_sample_attr {
  * copied to the %OVS_PACKET_CMD_ACTION message as %OVS_PACKET_ATTR_USERDATA.
  * @OVS_USERSPACE_ATTR_EGRESS_TUN_PORT: If present, u32 output port to get
  * tunnel info.
+ * @OVS_USERSPACE_ATTR_ACTIONS: If present, send actions with upcall.
  */
 enum ovs_userspace_attr {
         OVS_USERSPACE_ATTR_UNSPEC,
@@ -535,6 +538,7 @@ enum ovs_userspace_attr {
         OVS_USERSPACE_ATTR_USERDATA,  /* Optional user-specified cookie. */
         OVS_USERSPACE_ATTR_EGRESS_TUN_PORT,  /* Optional, u32 output port
                                               * to get tunnel info. */
+        OVS_USERSPACE_ATTR_ACTIONS,   /* Optional flag to get actions. */
         __OVS_USERSPACE_ATTR_MAX
 };
 
diff --git a/include/uapi/linux/pci_regs.h b/include/uapi/linux/pci_regs.h
index efe3443572ba..413417f3707b 100644
--- a/include/uapi/linux/pci_regs.h
+++ b/include/uapi/linux/pci_regs.h
@@ -319,6 +319,7 @@
 #define PCI_MSIX_PBA            8       /* Pending Bit Array offset */
 #define  PCI_MSIX_PBA_BIR       0x00000007 /* BAR index */
 #define  PCI_MSIX_PBA_OFFSET    0xfffffff8 /* Offset into specified BAR */
+#define PCI_MSIX_FLAGS_BIRMASK  PCI_MSIX_PBA_BIR /* deprecated */
 #define PCI_CAP_MSIX_SIZEOF     12      /* size of MSIX registers */
 
 /* MSI-X Table entry format */
diff --git a/include/uapi/linux/pkt_cls.h b/include/uapi/linux/pkt_cls.h
index bf08e76bf505..4f0d1bc3647d 100644
--- a/include/uapi/linux/pkt_cls.h
+++ b/include/uapi/linux/pkt_cls.h
@@ -4,6 +4,7 @@
 #include <linux/types.h>
 #include <linux/pkt_sched.h>
 
+#ifdef __KERNEL__
 /* I think i could have done better macros ; for now this is stolen from
  * some arch/mips code - jhs
 */
@@ -35,20 +36,6 @@ bits 9,10,11: redirect counter -  redirect TTL. Loop avoidance
  *
  * */
 
-#define TC_MUNGED          _TC_MAKEMASK1(0)
-#define SET_TC_MUNGED(v)   ( TC_MUNGED | (v & ~TC_MUNGED))
-#define CLR_TC_MUNGED(v)   ( v & ~TC_MUNGED)
-
-#define TC_OK2MUNGE        _TC_MAKEMASK1(1)
-#define SET_TC_OK2MUNGE(v)   ( TC_OK2MUNGE | (v & ~TC_OK2MUNGE))
-#define CLR_TC_OK2MUNGE(v)   ( v & ~TC_OK2MUNGE)
-
-#define S_TC_VERD          _TC_MAKE32(2)
-#define M_TC_VERD          _TC_MAKEMASK(4,S_TC_VERD)
-#define G_TC_VERD(x)       _TC_GETVALUE(x,S_TC_VERD,M_TC_VERD)
-#define V_TC_VERD(x)       _TC_MAKEVALUE(x,S_TC_VERD)
-#define SET_TC_VERD(v,n)   ((V_TC_VERD(n)) | (v & ~M_TC_VERD))
-
 #define S_TC_FROM          _TC_MAKE32(6)
 #define M_TC_FROM          _TC_MAKEMASK(2,S_TC_FROM)
 #define G_TC_FROM(x)       _TC_GETVALUE(x,S_TC_FROM,M_TC_FROM)
@@ -62,18 +49,16 @@ bits 9,10,11: redirect counter -  redirect TTL. Loop avoidance
 #define SET_TC_NCLS(v)   ( TC_NCLS | (v & ~TC_NCLS))
 #define CLR_TC_NCLS(v)   ( v & ~TC_NCLS)
 
-#define S_TC_RTTL          _TC_MAKE32(9)
-#define M_TC_RTTL          _TC_MAKEMASK(3,S_TC_RTTL)
-#define G_TC_RTTL(x)       _TC_GETVALUE(x,S_TC_RTTL,M_TC_RTTL)
-#define V_TC_RTTL(x)       _TC_MAKEVALUE(x,S_TC_RTTL)
-#define SET_TC_RTTL(v,n)   ((V_TC_RTTL(n)) | (v & ~M_TC_RTTL))
-
 #define S_TC_AT          _TC_MAKE32(12)
 #define M_TC_AT          _TC_MAKEMASK(2,S_TC_AT)
 #define G_TC_AT(x)       _TC_GETVALUE(x,S_TC_AT,M_TC_AT)
 #define V_TC_AT(x)       _TC_MAKEVALUE(x,S_TC_AT)
 #define SET_TC_AT(v,n)   ((V_TC_AT(n)) | (v & ~M_TC_AT))
 
+#define MAX_REC_LOOP 4
+#define MAX_RED_LOOP 4
+#endif
+
 /* Action attributes */
 enum {
         TCA_ACT_UNSPEC,
@@ -93,8 +78,6 @@ enum {
 #define TCA_ACT_NOUNBIND        0
 #define TCA_ACT_REPLACE         1
 #define TCA_ACT_NOREPLACE       0
-#define MAX_REC_LOOP 4
-#define MAX_RED_LOOP 4
 
 #define TC_ACT_UNSPEC   (-1)
 #define TC_ACT_OK               0
@@ -404,6 +387,36 @@ enum {
 
 #define TCA_BPF_MAX (__TCA_BPF_MAX - 1)
 
+/* Flower classifier */
+
+enum {
+        TCA_FLOWER_UNSPEC,
+        TCA_FLOWER_CLASSID,
+        TCA_FLOWER_INDEV,
+        TCA_FLOWER_ACT,
+        TCA_FLOWER_KEY_ETH_DST,         /* ETH_ALEN */
+        TCA_FLOWER_KEY_ETH_DST_MASK,    /* ETH_ALEN */
+        TCA_FLOWER_KEY_ETH_SRC,         /* ETH_ALEN */
+        TCA_FLOWER_KEY_ETH_SRC_MASK,    /* ETH_ALEN */
+        TCA_FLOWER_KEY_ETH_TYPE,        /* be16 */
+        TCA_FLOWER_KEY_IP_PROTO,        /* u8 */
+        TCA_FLOWER_KEY_IPV4_SRC,        /* be32 */
+        TCA_FLOWER_KEY_IPV4_SRC_MASK,   /* be32 */
+        TCA_FLOWER_KEY_IPV4_DST,        /* be32 */
+        TCA_FLOWER_KEY_IPV4_DST_MASK,   /* be32 */
+        TCA_FLOWER_KEY_IPV6_SRC,        /* struct in6_addr */
+        TCA_FLOWER_KEY_IPV6_SRC_MASK,   /* struct in6_addr */
+        TCA_FLOWER_KEY_IPV6_DST,        /* struct in6_addr */
+        TCA_FLOWER_KEY_IPV6_DST_MASK,   /* struct in6_addr */
+        TCA_FLOWER_KEY_TCP_SRC,         /* be16 */
+        TCA_FLOWER_KEY_TCP_DST,         /* be16 */
+        TCA_FLOWER_KEY_UDP_SRC,         /* be16 */
+        TCA_FLOWER_KEY_UDP_DST,         /* be16 */
+        __TCA_FLOWER_MAX,
+};
+
+#define TCA_FLOWER_MAX (__TCA_FLOWER_MAX - 1)
+
 /* Extended Matches */
 
 struct tcf_ematch_tree_hdr {
diff --git a/include/uapi/linux/pkt_sched.h b/include/uapi/linux/pkt_sched.h
index 534b84710745..8d2530daca9f 100644
--- a/include/uapi/linux/pkt_sched.h
+++ b/include/uapi/linux/pkt_sched.h
@@ -268,7 +268,8 @@ enum {
        TCA_GRED_STAB,
        TCA_GRED_DPS,
        TCA_GRED_MAX_P,
-           __TCA_GRED_MAX,
+       TCA_GRED_LIMIT,
+       __TCA_GRED_MAX,
 };
 
 #define TCA_GRED_MAX (__TCA_GRED_MAX - 1)
@@ -679,6 +680,7 @@ enum {
         TCA_CODEL_LIMIT,
         TCA_CODEL_INTERVAL,
         TCA_CODEL_ECN,
+        TCA_CODEL_CE_THRESHOLD,
         __TCA_CODEL_MAX
 };
 
@@ -695,6 +697,7 @@ struct tc_codel_xstats {
         __u32   drop_overlimit; /* number of time max qdisc packet limit was hit */
         __u32   ecn_mark;  /* number of packets we ECN marked instead of dropped */
         __u32   dropping;  /* are we in dropping state ? */
+        __u32   ce_mark;   /* number of CE marked packets because of ce_threshold */
 };
 
 /* FQ_CODEL */
@@ -707,6 +710,7 @@ enum {
         TCA_FQ_CODEL_ECN,
         TCA_FQ_CODEL_FLOWS,
         TCA_FQ_CODEL_QUANTUM,
+        TCA_FQ_CODEL_CE_THRESHOLD,
         __TCA_FQ_CODEL_MAX
 };
 
@@ -730,6 +734,7 @@ struct tc_fq_codel_qd_stats {
                                  */
         __u32   new_flows_len;  /* count of flows in new list */
         __u32   old_flows_len;  /* count of flows in old list */
+        __u32   ce_mark;        /* packets above ce_threshold */
 };
 
 struct tc_fq_codel_cl_stats {
diff --git a/include/uapi/linux/rds.h b/include/uapi/linux/rds.h
index 91950950aa59..0f9265cb2a96 100644
--- a/include/uapi/linux/rds.h
+++ b/include/uapi/linux/rds.h
@@ -38,6 +38,8 @@
 
 #define RDS_IB_ABI_VERSION              0x301
 
+#define SOL_RDS         276
+
 /*
  * setsockopt/getsockopt for SOL_RDS
  */
@@ -48,6 +50,14 @@
 #define RDS_RECVERR                     5
 #define RDS_CONG_MONITOR                6
 #define RDS_GET_MR_FOR_DEST             7
+#define SO_RDS_TRANSPORT                8
+
+/* supported values for SO_RDS_TRANSPORT */
+#define RDS_TRANS_IB    0
+#define RDS_TRANS_IWARP 1
+#define RDS_TRANS_TCP   2
+#define RDS_TRANS_COUNT 3
+#define RDS_TRANS_NONE  (~0)
 
 /*
  * Control message types for SOL_RDS.
diff --git a/include/uapi/linux/rtnetlink.h b/include/uapi/linux/rtnetlink.h
index 17fb02f488da..fdd8f07f1d34 100644
--- a/include/uapi/linux/rtnetlink.h
+++ b/include/uapi/linux/rtnetlink.h
@@ -338,6 +338,9 @@ struct rtnexthop {
 #define RTNH_F_PERVASIVE        2       /* Do recursive gateway lookup  */
 #define RTNH_F_ONLINK           4       /* Gateway is forced on link    */
 #define RTNH_F_OFFLOAD          8       /* offloaded route */
+#define RTNH_F_LINKDOWN         16      /* carrier-down on nexthop */
+
+#define RTNH_COMPARE_MASK       (RTNH_F_DEAD | RTNH_F_LINKDOWN)
 
 /* Macros to handle hexthops */
 
diff --git a/include/uapi/linux/scif_ioctl.h b/include/uapi/linux/scif_ioctl.h
new file mode 100644
index 000000000000..4a94d917cf99
--- /dev/null
+++ b/include/uapi/linux/scif_ioctl.h
@@ -0,0 +1,130 @@
+/*
+ * Intel MIC Platform Software Stack (MPSS)
+ *
+ * This file is provided under a dual BSD/GPLv2 license.  When using or
+ * redistributing this file, you may do so under either license.
+ *
+ * GPL LICENSE SUMMARY
+ *
+ * Copyright(c) 2014 Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * BSD LICENSE
+ *
+ * Copyright(c) 2014 Intel Corporation.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in
+ *   the documentation and/or other materials provided with the
+ *   distribution.
+ * * Neither the name of Intel Corporation nor the names of its
+ *   contributors may be used to endorse or promote products derived
+ *   from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Intel SCIF driver.
+ *
+ */
+/*
+ * -----------------------------------------
+ * SCIF IOCTL interface information
+ * -----------------------------------------
+ */
+#ifndef SCIF_IOCTL_H
+#define SCIF_IOCTL_H
+
+#include <linux/types.h>
+
+/**
+ * struct scif_port_id - SCIF port information
+ * @node:       node on which port resides
+ * @port:       local port number
+ */
+struct scif_port_id {
+        __u16 node;
+        __u16 port;
+};
+
+/**
+ * struct scifioctl_connect - used for SCIF_CONNECT IOCTL
+ * @self:       used to read back the assigned port_id
+ * @peer:       destination node and port to connect to
+ */
+struct scifioctl_connect {
+        struct scif_port_id     self;
+        struct scif_port_id     peer;
+};
+
+/**
+ * struct scifioctl_accept - used for SCIF_ACCEPTREQ IOCTL
+ * @flags:      flags
+ * @peer:       global id of peer endpoint
+ * @endpt:      new connected endpoint descriptor
+ */
+struct scifioctl_accept {
+        __s32                   flags;
+        struct scif_port_id     peer;
+        __u64                   endpt;
+};
+
+/**
+ * struct scifioctl_msg - used for SCIF_SEND/SCIF_RECV IOCTL
+ * @msg:        message buffer address
+ * @len:        message length
+ * @flags:      flags
+ * @out_len:    number of bytes sent/received
+ */
+struct scifioctl_msg {
+        __u64   msg;
+        __s32   len;
+        __s32   flags;
+        __s32   out_len;
+};
+
+/**
+ * struct scifioctl_node_ids - used for SCIF_GET_NODEIDS IOCTL
+ * @nodes:      pointer to an array of node_ids
+ * @self:       ID of the current node
+ * @len:        length of array
+ */
+struct scifioctl_node_ids {
+        __u64   nodes;
+        __u64   self;
+        __s32   len;
+};
+
+#define SCIF_BIND               _IOWR('s', 1, __u64)
+#define SCIF_LISTEN             _IOW('s', 2, __s32)
+#define SCIF_CONNECT            _IOWR('s', 3, struct scifioctl_connect)
+#define SCIF_ACCEPTREQ          _IOWR('s', 4, struct scifioctl_accept)
+#define SCIF_ACCEPTREG          _IOWR('s', 5, __u64)
+#define SCIF_SEND               _IOWR('s', 6, struct scifioctl_msg)
+#define SCIF_RECV               _IOWR('s', 7, struct scifioctl_msg)
+#define SCIF_GET_NODEIDS        _IOWR('s', 14, struct scifioctl_node_ids)
+
+#endif /* SCIF_IOCTL_H */
diff --git a/include/uapi/linux/serial_core.h b/include/uapi/linux/serial_core.h
index b2122813f18a..93ba148f923e 100644
--- a/include/uapi/linux/serial_core.h
+++ b/include/uapi/linux/serial_core.h
@@ -258,4 +258,7 @@
 /* Cris v10 / v32 SoC */
 #define PORT_CRIS       112
 
+/* STM32 USART */
+#define PORT_STM32      113
+
 #endif /* _UAPILINUX_SERIAL_CORE_H */
diff --git a/include/uapi/linux/serial_reg.h b/include/uapi/linux/serial_reg.h
index e9b4cb0cd7ed..1e5ac4e776da 100644
--- a/include/uapi/linux/serial_reg.h
+++ b/include/uapi/linux/serial_reg.h
@@ -331,6 +331,9 @@
  * Extra serial register definitions for the internal UARTs
  * in TI OMAP processors.
  */
+#define OMAP1_UART1_BASE        0xfffb0000
+#define OMAP1_UART2_BASE        0xfffb0800
+#define OMAP1_UART3_BASE        0xfffb9800
 #define UART_OMAP_MDR1          0x08    /* Mode definition register */
 #define UART_OMAP_MDR2          0x09    /* Mode definition register 2 */
 #define UART_OMAP_SCR           0x10    /* Supplementary control register */
diff --git a/include/uapi/linux/snmp.h b/include/uapi/linux/snmp.h
index 6a6fb747c78d..eee8968407f0 100644
--- a/include/uapi/linux/snmp.h
+++ b/include/uapi/linux/snmp.h
@@ -276,6 +276,8 @@ enum
         LINUX_MIB_TCPACKSKIPPEDFINWAIT2,        /* TCPACKSkippedFinWait2 */
         LINUX_MIB_TCPACKSKIPPEDTIMEWAIT,        /* TCPACKSkippedTimeWait */
         LINUX_MIB_TCPACKSKIPPEDCHALLENGE,       /* TCPACKSkippedChallenge */
+        LINUX_MIB_TCPWINPROBE,                  /* TCPWinProbe */
+        LINUX_MIB_TCPKEEPALIVE,                 /* TCPKeepAlive */
         __LINUX_MIB_MAX
 };
 
diff --git a/include/uapi/linux/sock_diag.h b/include/uapi/linux/sock_diag.h
index b00e29efb161..49230d36f9ce 100644
--- a/include/uapi/linux/sock_diag.h
+++ b/include/uapi/linux/sock_diag.h
@@ -23,4 +23,14 @@ enum {
         SK_MEMINFO_VARS,
 };
 
+enum sknetlink_groups {
+        SKNLGRP_NONE,
+        SKNLGRP_INET_TCP_DESTROY,
+        SKNLGRP_INET_UDP_DESTROY,
+        SKNLGRP_INET6_TCP_DESTROY,
+        SKNLGRP_INET6_UDP_DESTROY,
+        __SKNLGRP_MAX,
+};
+#define SKNLGRP_MAX     (__SKNLGRP_MAX - 1)
+
 #endif /* _UAPI__SOCK_DIAG_H__ */
diff --git a/include/uapi/linux/tcp.h b/include/uapi/linux/tcp.h
index faa72f4fa547..65a77b071e22 100644
--- a/include/uapi/linux/tcp.h
+++ b/include/uapi/linux/tcp.h
@@ -113,6 +113,8 @@ enum {
 #define TCP_TIMESTAMP           24
 #define TCP_NOTSENT_LOWAT       25      /* limit number of unsent bytes in write queue */
 #define TCP_CC_INFO             26      /* Get Congestion Control (optional) info */
+#define TCP_SAVE_SYN            27      /* Record SYN headers for new connections */
+#define TCP_SAVED_SYN           28      /* Get SYN headers recorded for connection */
 
 struct tcp_repair_opt {
         __u32   opt_code;
@@ -190,8 +192,10 @@ struct tcp_info {
 
         __u64   tcpi_pacing_rate;
         __u64   tcpi_max_pacing_rate;
-        __u64   tcpi_bytes_acked; /* RFC4898 tcpEStatsAppHCThruOctetsAcked */
+        __u64   tcpi_bytes_acked;    /* RFC4898 tcpEStatsAppHCThruOctetsAcked */
         __u64   tcpi_bytes_received; /* RFC4898 tcpEStatsAppHCThruOctetsReceived */
+        __u32   tcpi_segs_out;       /* RFC4898 tcpEStatsPerfSegsOut */
+        __u32   tcpi_segs_in;        /* RFC4898 tcpEStatsPerfSegsIn */
 };
 
 /* for TCP_MD5SIG socket option */
diff --git a/include/uapi/linux/tty.h b/include/uapi/linux/tty.h
index dac199a2dba5..01c4410352ff 100644
--- a/include/uapi/linux/tty.h
+++ b/include/uapi/linux/tty.h
@@ -34,5 +34,6 @@
 #define N_TI_WL         22      /* for TI's WL BT, FM, GPS combo chips */
 #define N_TRACESINK     23      /* Trace data routing for MIPI P1149.7 */
 #define N_TRACEROUTER   24      /* Trace data routing for MIPI P1149.7 */
+#define N_NCI           25      /* NFC NCI UART */
 
 #endif /* _UAPI_LINUX_TTY_H */
diff --git a/include/uapi/linux/tty_flags.h b/include/uapi/linux/tty_flags.h
index fae4864737fa..072e41e45ee2 100644
--- a/include/uapi/linux/tty_flags.h
+++ b/include/uapi/linux/tty_flags.h
@@ -15,7 +15,7 @@
 #define ASYNCB_FOURPORT          1 /* Set OU1, OUT2 per AST Fourport settings */
 #define ASYNCB_SAK               2 /* Secure Attention Key (Orange book) */
 #define ASYNCB_SPLIT_TERMIOS     3 /* [x] Separate termios for dialin/callout */
-#define ASYNCB_SPD_HI            4 /* Use 56000 instead of 38400 bps */
+#define ASYNCB_SPD_HI            4 /* Use 57600 instead of 38400 bps */
 #define ASYNCB_SPD_VHI           5 /* Use 115200 instead of 38400 bps */
 #define ASYNCB_SKIP_TEST         6 /* Skip UART test during autoconfiguration */
 #define ASYNCB_AUTO_IRQ          7 /* Do automatic IRQ during
diff --git a/include/uapi/linux/v4l2-mediabus.h b/include/uapi/linux/v4l2-mediabus.h
index 26db20647e6f..9cac6325cc7e 100644
--- a/include/uapi/linux/v4l2-mediabus.h
+++ b/include/uapi/linux/v4l2-mediabus.h
@@ -24,6 +24,7 @@
  * @colorspace: colorspace of the data (from enum v4l2_colorspace)
  * @ycbcr_enc:  YCbCr encoding of the data (from enum v4l2_ycbcr_encoding)
  * @quantization: quantization of the data (from enum v4l2_quantization)
+ * @xfer_func:  transfer function of the data (from enum v4l2_xfer_func)
  */
 struct v4l2_mbus_framefmt {
         __u32                   width;
@@ -33,7 +34,8 @@ struct v4l2_mbus_framefmt {
         __u32                   colorspace;
         __u16                   ycbcr_enc;
         __u16                   quantization;
-        __u32                   reserved[6];
+        __u16                   xfer_func;
+        __u16                   reserved[11];
 };
 
 #ifndef __KERNEL__
diff --git a/include/uapi/linux/vfio.h b/include/uapi/linux/vfio.h
index b57b750c222f..9fd7b5d8df2f 100644
--- a/include/uapi/linux/vfio.h
+++ b/include/uapi/linux/vfio.h
@@ -36,6 +36,8 @@
 /* Two-stage IOMMU */
 #define VFIO_TYPE1_NESTING_IOMMU        6       /* Implies v2 */
 
+#define VFIO_SPAPR_TCE_v2_IOMMU         7
+
 /*
  * The IOCTL interface is designed for extensibility by embedding the
  * structure length (argsz) and flags into structures passed between
@@ -443,6 +445,23 @@ struct vfio_iommu_type1_dma_unmap {
 /* -------- Additional API for SPAPR TCE (Server POWERPC) IOMMU -------- */
 
 /*
+ * The SPAPR TCE DDW info struct provides the information about
+ * the details of Dynamic DMA window capability.
+ *
+ * @pgsizes contains a page size bitmask, 4K/64K/16M are supported.
+ * @max_dynamic_windows_supported tells the maximum number of windows
+ * which the platform can create.
+ * @levels tells the maximum number of levels in multi-level IOMMU tables;
+ * this allows splitting a table into smaller chunks which reduces
+ * the amount of physically contiguous memory required for the table.
+ */
+struct vfio_iommu_spapr_tce_ddw_info {
+        __u64 pgsizes;                  /* Bitmap of supported page sizes */
+        __u32 max_dynamic_windows_supported;
+        __u32 levels;
+};
+
+/*
  * The SPAPR TCE info struct provides the information about the PCI bus
  * address ranges available for DMA, these values are programmed into
  * the hardware so the guest has to know that information.
@@ -452,14 +471,17 @@ struct vfio_iommu_type1_dma_unmap {
  * addresses too so the window works as a filter rather than an offset
  * for IOVA addresses.
  *
- * A flag will need to be added if other page sizes are supported,
- * so as defined here, it is always 4k.
+ * Flags supported:
+ * - VFIO_IOMMU_SPAPR_INFO_DDW: informs the userspace that dynamic DMA windows
+ *   (DDW) support is present. @ddw is only supported when DDW is present.
  */
 struct vfio_iommu_spapr_tce_info {
         __u32 argsz;
-        __u32 flags;                    /* reserved for future use */
+        __u32 flags;
+#define VFIO_IOMMU_SPAPR_INFO_DDW       (1 << 0)        /* DDW supported */
         __u32 dma32_window_start;       /* 32 bit window start (bytes) */
         __u32 dma32_window_size;        /* 32 bit window size (bytes) */
+        struct vfio_iommu_spapr_tce_ddw_info ddw;
 };
 
 #define VFIO_IOMMU_SPAPR_TCE_GET_INFO   _IO(VFIO_TYPE, VFIO_BASE + 12)
@@ -470,12 +492,23 @@ struct vfio_iommu_spapr_tce_info {
  * - unfreeze IO/DMA for frozen PE;
  * - read PE state;
  * - reset PE;
- * - configure PE.
+ * - configure PE;
+ * - inject EEH error.
  */
+struct vfio_eeh_pe_err {
+        __u32 type;
+        __u32 func;
+        __u64 addr;
+        __u64 mask;
+};
+
 struct vfio_eeh_pe_op {
         __u32 argsz;
         __u32 flags;
         __u32 op;
+        union {
+                struct vfio_eeh_pe_err err;
+        };
 };
 
 #define VFIO_EEH_PE_DISABLE             0       /* Disable EEH functionality */
@@ -492,9 +525,70 @@ struct vfio_eeh_pe_op {
 #define VFIO_EEH_PE_RESET_HOT           6       /* Assert hot reset          */
 #define VFIO_EEH_PE_RESET_FUNDAMENTAL   7       /* Assert fundamental reset  */
 #define VFIO_EEH_PE_CONFIGURE           8       /* PE configuration          */
+#define VFIO_EEH_PE_INJECT_ERR          9       /* Inject EEH error          */
 
 #define VFIO_EEH_PE_OP                  _IO(VFIO_TYPE, VFIO_BASE + 21)
 
+/**
+ * VFIO_IOMMU_SPAPR_REGISTER_MEMORY - _IOW(VFIO_TYPE, VFIO_BASE + 17, struct vfio_iommu_spapr_register_memory)
+ *
+ * Registers user space memory where DMA is allowed. It pins
+ * user pages and does the locked memory accounting so
+ * subsequent VFIO_IOMMU_MAP_DMA/VFIO_IOMMU_UNMAP_DMA calls
+ * get faster.
+ */
+struct vfio_iommu_spapr_register_memory {
+        __u32   argsz;
+        __u32   flags;
+        __u64   vaddr;                          /* Process virtual address */
+        __u64   size;                           /* Size of mapping (bytes) */
+};
+#define VFIO_IOMMU_SPAPR_REGISTER_MEMORY        _IO(VFIO_TYPE, VFIO_BASE + 17)
+
+/**
+ * VFIO_IOMMU_SPAPR_UNREGISTER_MEMORY - _IOW(VFIO_TYPE, VFIO_BASE + 18, struct vfio_iommu_spapr_register_memory)
+ *
+ * Unregisters user space memory registered with
+ * VFIO_IOMMU_SPAPR_REGISTER_MEMORY.
+ * Uses vfio_iommu_spapr_register_memory for parameters.
+ */
+#define VFIO_IOMMU_SPAPR_UNREGISTER_MEMORY      _IO(VFIO_TYPE, VFIO_BASE + 18)
+
+/**
+ * VFIO_IOMMU_SPAPR_TCE_CREATE - _IOWR(VFIO_TYPE, VFIO_BASE + 19, struct vfio_iommu_spapr_tce_create)
+ *
+ * Creates an additional TCE table and programs it (sets a new DMA window)
+ * to every IOMMU group in the container. It receives page shift, window
+ * size and number of levels in the TCE table being created.
+ *
+ * It allocates and returns an offset on a PCI bus of the new DMA window.
+ */
+struct vfio_iommu_spapr_tce_create {
+        __u32 argsz;
+        __u32 flags;
+        /* in */
+        __u32 page_shift;
+        __u64 window_size;
+        __u32 levels;
+        /* out */
+        __u64 start_addr;
+};
+#define VFIO_IOMMU_SPAPR_TCE_CREATE     _IO(VFIO_TYPE, VFIO_BASE + 19)
+
+/**
+ * VFIO_IOMMU_SPAPR_TCE_REMOVE - _IOW(VFIO_TYPE, VFIO_BASE + 20, struct vfio_iommu_spapr_tce_remove)
+ *
+ * Unprograms a TCE table from all groups in the container and destroys it.
+ * It receives a PCI bus offset as a window id.
+ */
+struct vfio_iommu_spapr_tce_remove {
+        __u32 argsz;
+        __u32 flags;
+        /* in */
+        __u64 start_addr;
+};
+#define VFIO_IOMMU_SPAPR_TCE_REMOVE     _IO(VFIO_TYPE, VFIO_BASE + 20)
+
 /* ***************************************************************** */
 
 #endif /* _UAPIVFIO_H */
diff --git a/include/uapi/linux/vhost.h b/include/uapi/linux/vhost.h
index bb6a5b4cb3c5..ab3731917bac 100644
--- a/include/uapi/linux/vhost.h
+++ b/include/uapi/linux/vhost.h
@@ -103,6 +103,20 @@ struct vhost_memory {
 /* Get accessor: reads index, writes value in num */
 #define VHOST_GET_VRING_BASE _IOWR(VHOST_VIRTIO, 0x12, struct vhost_vring_state)
 
+/* Set the vring byte order in num. Valid values are VHOST_VRING_LITTLE_ENDIAN
+ * or VHOST_VRING_BIG_ENDIAN (other values return -EINVAL).
+ * The byte order cannot be changed while the device is active: trying to do so
+ * returns -EBUSY.
+ * This is a legacy only API that is simply ignored when VIRTIO_F_VERSION_1 is
+ * set.
+ * Not all kernel configurations support this ioctl, but all configurations that
+ * support SET also support GET.
+ */
+#define VHOST_VRING_LITTLE_ENDIAN 0
+#define VHOST_VRING_BIG_ENDIAN 1
+#define VHOST_SET_VRING_ENDIAN _IOW(VHOST_VIRTIO, 0x13, struct vhost_vring_state)
+#define VHOST_GET_VRING_ENDIAN _IOW(VHOST_VIRTIO, 0x14, struct vhost_vring_state)
+
 /* The following ioctls use eventfd file descriptors to signal and poll
  * for events. */
 
diff --git a/include/uapi/linux/videodev2.h b/include/uapi/linux/videodev2.h
index fa376f7666ba..3228fbebcd63 100644
--- a/include/uapi/linux/videodev2.h
+++ b/include/uapi/linux/videodev2.h
@@ -178,6 +178,12 @@ enum v4l2_memory {
 
 /* see also http://vektor.theorem.ca/graphics/ycbcr/ */
 enum v4l2_colorspace {
+        /*
+         * Default colorspace, i.e. let the driver figure it out.
+         * Can only be used with video capture.
+         */
+        V4L2_COLORSPACE_DEFAULT       = 0,
+
         /* SMPTE 170M: used for broadcast NTSC/PAL SDTV */
         V4L2_COLORSPACE_SMPTE170M     = 1,
 
@@ -220,8 +226,56 @@ enum v4l2_colorspace {
 
         /* BT.2020 colorspace, used for UHDTV. */
         V4L2_COLORSPACE_BT2020        = 10,
+
+        /* Raw colorspace: for RAW unprocessed images */
+        V4L2_COLORSPACE_RAW           = 11,
+};
+
+/*
+ * Determine how COLORSPACE_DEFAULT should map to a proper colorspace.
+ * This depends on whether this is a SDTV image (use SMPTE 170M), an
+ * HDTV image (use Rec. 709), or something else (use sRGB).
+ */
+#define V4L2_MAP_COLORSPACE_DEFAULT(is_sdtv, is_hdtv) \
+        ((is_sdtv) ? V4L2_COLORSPACE_SMPTE170M : \
+         ((is_hdtv) ? V4L2_COLORSPACE_REC709 : V4L2_COLORSPACE_SRGB))
+
+enum v4l2_xfer_func {
+        /*
+         * Mapping of V4L2_XFER_FUNC_DEFAULT to actual transfer functions
+         * for the various colorspaces:
+         *
+         * V4L2_COLORSPACE_SMPTE170M, V4L2_COLORSPACE_470_SYSTEM_M,
+         * V4L2_COLORSPACE_470_SYSTEM_BG, V4L2_COLORSPACE_REC709 and
+         * V4L2_COLORSPACE_BT2020: V4L2_XFER_FUNC_709
+         *
+         * V4L2_COLORSPACE_SRGB, V4L2_COLORSPACE_JPEG: V4L2_XFER_FUNC_SRGB
+         *
+         * V4L2_COLORSPACE_ADOBERGB: V4L2_XFER_FUNC_ADOBERGB
+         *
+         * V4L2_COLORSPACE_SMPTE240M: V4L2_XFER_FUNC_SMPTE240M
+         *
+         * V4L2_COLORSPACE_RAW: V4L2_XFER_FUNC_NONE
+         */
+        V4L2_XFER_FUNC_DEFAULT     = 0,
+        V4L2_XFER_FUNC_709         = 1,
+        V4L2_XFER_FUNC_SRGB        = 2,
+        V4L2_XFER_FUNC_ADOBERGB    = 3,
+        V4L2_XFER_FUNC_SMPTE240M   = 4,
+        V4L2_XFER_FUNC_NONE        = 5,
 };
 
+/*
+ * Determine how XFER_FUNC_DEFAULT should map to a proper transfer function.
+ * This depends on the colorspace.
+ */
+#define V4L2_MAP_XFER_FUNC_DEFAULT(colsp) \
+        ((colsp) == V4L2_COLORSPACE_ADOBERGB ? V4L2_XFER_FUNC_ADOBERGB : \
+         ((colsp) == V4L2_COLORSPACE_SMPTE240M ? V4L2_XFER_FUNC_SMPTE240M : \
+          ((colsp) == V4L2_COLORSPACE_RAW ? V4L2_XFER_FUNC_NONE : \
+           ((colsp) == V4L2_COLORSPACE_SRGB || (colsp) == V4L2_COLORSPACE_JPEG ? \
+            V4L2_XFER_FUNC_SRGB : V4L2_XFER_FUNC_709))))
+
 enum v4l2_ycbcr_encoding {
         /*
          * Mapping of V4L2_YCBCR_ENC_DEFAULT to actual encodings for the
@@ -266,6 +320,16 @@ enum v4l2_ycbcr_encoding {
         V4L2_YCBCR_ENC_SMPTE240M      = 8,
 };
 
+/*
+ * Determine how YCBCR_ENC_DEFAULT should map to a proper Y'CbCr encoding.
+ * This depends on the colorspace.
+ */
+#define V4L2_MAP_YCBCR_ENC_DEFAULT(colsp) \
+        ((colsp) == V4L2_COLORSPACE_REC709 ? V4L2_YCBCR_ENC_709 : \
+         ((colsp) == V4L2_COLORSPACE_BT2020 ? V4L2_YCBCR_ENC_BT2020 : \
+          ((colsp) == V4L2_COLORSPACE_SMPTE240M ? V4L2_YCBCR_ENC_SMPTE240M : \
+           V4L2_YCBCR_ENC_601)))
+
 enum v4l2_quantization {
         /*
          * The default for R'G'B' quantization is always full range, except
@@ -278,6 +342,17 @@ enum v4l2_quantization {
         V4L2_QUANTIZATION_LIM_RANGE   = 2,
 };
 
+/*
+ * Determine how QUANTIZATION_DEFAULT should map to a proper quantization.
+ * This depends on whether the image is RGB or not, the colorspace and the
+ * Y'CbCr encoding.
+ */
+#define V4L2_MAP_QUANTIZATION_DEFAULT(is_rgb, colsp, ycbcr_enc) \
+        (((is_rgb) && (colsp) == V4L2_COLORSPACE_BT2020) ? V4L2_QUANTIZATION_LIM_RANGE : \
+         (((is_rgb) || (ycbcr_enc) == V4L2_YCBCR_ENC_XV601 || \
+          (ycbcr_enc) == V4L2_YCBCR_ENC_XV709 || (colsp) == V4L2_COLORSPACE_JPEG) ? \
+         V4L2_QUANTIZATION_FULL_RANGE : V4L2_QUANTIZATION_LIM_RANGE))
+
 enum v4l2_priority {
         V4L2_PRIORITY_UNSET       = 0,  /* not initialized */
         V4L2_PRIORITY_BACKGROUND  = 1,
@@ -370,6 +445,7 @@ struct v4l2_pix_format {
         __u32                   flags;          /* format flags (V4L2_PIX_FMT_FLAG_*) */
         __u32                   ycbcr_enc;      /* enum v4l2_ycbcr_encoding */
         __u32                   quantization;   /* enum v4l2_quantization */
+        __u32                   xfer_func;      /* enum v4l2_xfer_func */
 };
 
 /*      Pixel format         FOURCC                          depth  Description  */
@@ -404,6 +480,7 @@ struct v4l2_pix_format {
 #define V4L2_PIX_FMT_Y10     v4l2_fourcc('Y', '1', '0', ' ') /* 10  Greyscale     */
 #define V4L2_PIX_FMT_Y12     v4l2_fourcc('Y', '1', '2', ' ') /* 12  Greyscale     */
 #define V4L2_PIX_FMT_Y16     v4l2_fourcc('Y', '1', '6', ' ') /* 16  Greyscale     */
+#define V4L2_PIX_FMT_Y16_BE  v4l2_fourcc_be('Y', '1', '6', ' ') /* 16  Greyscale BE  */
 
 /* Grey bit-packed formats */
 #define V4L2_PIX_FMT_Y10BPACK    v4l2_fourcc('Y', '1', '0', 'B') /* 10  Greyscale bit-packed */
@@ -810,6 +887,8 @@ struct v4l2_buffer {
 #define V4L2_BUF_FLAG_TSTAMP_SRC_MASK           0x00070000
 #define V4L2_BUF_FLAG_TSTAMP_SRC_EOF            0x00000000
 #define V4L2_BUF_FLAG_TSTAMP_SRC_SOE            0x00010000
+/* mem2mem encoder/decoder */
+#define V4L2_BUF_FLAG_LAST                      0x00100000
 
 /**
  * struct v4l2_exportbuffer - export of video buffer as DMABUF file descriptor
@@ -1865,6 +1944,7 @@ struct v4l2_plane_pix_format {
  * @flags:              format flags (V4L2_PIX_FMT_FLAG_*)
  * @ycbcr_enc:          enum v4l2_ycbcr_encoding, Y'CbCr encoding
  * @quantization:       enum v4l2_quantization, colorspace quantization
+ * @xfer_func:          enum v4l2_xfer_func, colorspace transfer function
  */
 struct v4l2_pix_format_mplane {
         __u32                           width;
@@ -1878,7 +1958,8 @@ struct v4l2_pix_format_mplane {
         __u8                            flags;
         __u8                            ycbcr_enc;
         __u8                            quantization;
-        __u8                            reserved[8];
+        __u8                            xfer_func;
+        __u8                            reserved[7];
 } __attribute__ ((packed));
 
 /**
diff --git a/include/uapi/linux/virtio_gpu.h b/include/uapi/linux/virtio_gpu.h
new file mode 100644
index 000000000000..478be5270e26
--- /dev/null
+++ b/include/uapi/linux/virtio_gpu.h
@@ -0,0 +1,206 @@
+/*
+ * Virtio GPU Device
+ *
+ * Copyright Red Hat, Inc. 2013-2014
+ *
+ * Authors:
+ *     Dave Airlie <airlied@redhat.com>
+ *     Gerd Hoffmann <kraxel@redhat.com>
+ *
+ * This header is BSD licensed so anyone can use the definitions
+ * to implement compatible drivers/servers:
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of IBM nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL IBM OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef VIRTIO_GPU_HW_H
+#define VIRTIO_GPU_HW_H
+
+#include <linux/types.h>
+
+enum virtio_gpu_ctrl_type {
+        VIRTIO_GPU_UNDEFINED = 0,
+
+        /* 2d commands */
+        VIRTIO_GPU_CMD_GET_DISPLAY_INFO = 0x0100,
+        VIRTIO_GPU_CMD_RESOURCE_CREATE_2D,
+        VIRTIO_GPU_CMD_RESOURCE_UNREF,
+        VIRTIO_GPU_CMD_SET_SCANOUT,
+        VIRTIO_GPU_CMD_RESOURCE_FLUSH,
+        VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D,
+        VIRTIO_GPU_CMD_RESOURCE_ATTACH_BACKING,
+        VIRTIO_GPU_CMD_RESOURCE_DETACH_BACKING,
+
+        /* cursor commands */
+        VIRTIO_GPU_CMD_UPDATE_CURSOR = 0x0300,
+        VIRTIO_GPU_CMD_MOVE_CURSOR,
+
+        /* success responses */
+        VIRTIO_GPU_RESP_OK_NODATA = 0x1100,
+        VIRTIO_GPU_RESP_OK_DISPLAY_INFO,
+
+        /* error responses */
+        VIRTIO_GPU_RESP_ERR_UNSPEC = 0x1200,
+        VIRTIO_GPU_RESP_ERR_OUT_OF_MEMORY,
+        VIRTIO_GPU_RESP_ERR_INVALID_SCANOUT_ID,
+        VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID,
+        VIRTIO_GPU_RESP_ERR_INVALID_CONTEXT_ID,
+        VIRTIO_GPU_RESP_ERR_INVALID_PARAMETER,
+};
+
+#define VIRTIO_GPU_FLAG_FENCE (1 << 0)
+
+struct virtio_gpu_ctrl_hdr {
+        __le32 type;
+        __le32 flags;
+        __le64 fence_id;
+        __le32 ctx_id;
+        __le32 padding;
+};
+
+/* data passed in the cursor vq */
+
+struct virtio_gpu_cursor_pos {
+        __le32 scanout_id;
+        __le32 x;
+        __le32 y;
+        __le32 padding;
+};
+
+/* VIRTIO_GPU_CMD_UPDATE_CURSOR, VIRTIO_GPU_CMD_MOVE_CURSOR */
+struct virtio_gpu_update_cursor {
+        struct virtio_gpu_ctrl_hdr hdr;
+        struct virtio_gpu_cursor_pos pos;  /* update & move */
+        __le32 resource_id;           /* update only */
+        __le32 hot_x;                 /* update only */
+        __le32 hot_y;                 /* update only */
+        __le32 padding;
+};
+
+/* data passed in the control vq, 2d related */
+
+struct virtio_gpu_rect {
+        __le32 x;
+        __le32 y;
+        __le32 width;
+        __le32 height;
+};
+
+/* VIRTIO_GPU_CMD_RESOURCE_UNREF */
+struct virtio_gpu_resource_unref {
+        struct virtio_gpu_ctrl_hdr hdr;
+        __le32 resource_id;
+        __le32 padding;
+};
+
+/* VIRTIO_GPU_CMD_RESOURCE_CREATE_2D: create a 2d resource with a format */
+struct virtio_gpu_resource_create_2d {
+        struct virtio_gpu_ctrl_hdr hdr;
+        __le32 resource_id;
+        __le32 format;
+        __le32 width;
+        __le32 height;
+};
+
+/* VIRTIO_GPU_CMD_SET_SCANOUT */
+struct virtio_gpu_set_scanout {
+        struct virtio_gpu_ctrl_hdr hdr;
+        struct virtio_gpu_rect r;
+        __le32 scanout_id;
+        __le32 resource_id;
+};
+
+/* VIRTIO_GPU_CMD_RESOURCE_FLUSH */
+struct virtio_gpu_resource_flush {
+        struct virtio_gpu_ctrl_hdr hdr;
+        struct virtio_gpu_rect r;
+        __le32 resource_id;
+        __le32 padding;
+};
+
+/* VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D: simple transfer to_host */
+struct virtio_gpu_transfer_to_host_2d {
+        struct virtio_gpu_ctrl_hdr hdr;
+        struct virtio_gpu_rect r;
+        __le64 offset;
+        __le32 resource_id;
+        __le32 padding;
+};
+
+struct virtio_gpu_mem_entry {
+        __le64 addr;
+        __le32 length;
+        __le32 padding;
+};
+
+/* VIRTIO_GPU_CMD_RESOURCE_ATTACH_BACKING */
+struct virtio_gpu_resource_attach_backing {
+        struct virtio_gpu_ctrl_hdr hdr;
+        __le32 resource_id;
+        __le32 nr_entries;
+};
+
+/* VIRTIO_GPU_CMD_RESOURCE_DETACH_BACKING */
+struct virtio_gpu_resource_detach_backing {
+        struct virtio_gpu_ctrl_hdr hdr;
+        __le32 resource_id;
+        __le32 padding;
+};
+
+/* VIRTIO_GPU_RESP_OK_DISPLAY_INFO */
+#define VIRTIO_GPU_MAX_SCANOUTS 16
+struct virtio_gpu_resp_display_info {
+        struct virtio_gpu_ctrl_hdr hdr;
+        struct virtio_gpu_display_one {
+                struct virtio_gpu_rect r;
+                __le32 enabled;
+                __le32 flags;
+        } pmodes[VIRTIO_GPU_MAX_SCANOUTS];
+};
+
+#define VIRTIO_GPU_EVENT_DISPLAY (1 << 0)
+
+struct virtio_gpu_config {
+        __u32 events_read;
+        __u32 events_clear;
+        __u32 num_scanouts;
+        __u32 reserved;
+};
+
+/* simple formats for fbcon/X use */
+enum virtio_gpu_formats {
+        VIRTIO_GPU_FORMAT_B8G8R8A8_UNORM  = 1,
+        VIRTIO_GPU_FORMAT_B8G8R8X8_UNORM  = 2,
+        VIRTIO_GPU_FORMAT_A8R8G8B8_UNORM  = 3,
+        VIRTIO_GPU_FORMAT_X8R8G8B8_UNORM  = 4,
+
+        VIRTIO_GPU_FORMAT_R8G8B8A8_UNORM  = 67,
+        VIRTIO_GPU_FORMAT_X8B8G8R8_UNORM  = 68,
+
+        VIRTIO_GPU_FORMAT_A8B8G8R8_UNORM  = 121,
+        VIRTIO_GPU_FORMAT_R8G8B8X8_UNORM  = 134,
+};
+
+#endif
diff --git a/include/uapi/linux/virtio_ids.h b/include/uapi/linux/virtio_ids.h
index 5f60aa4be50a..77925f587b15 100644
--- a/include/uapi/linux/virtio_ids.h
+++ b/include/uapi/linux/virtio_ids.h
@@ -39,6 +39,7 @@
 #define VIRTIO_ID_9P            9 /* 9p virtio console */
 #define VIRTIO_ID_RPROC_SERIAL 11 /* virtio remoteproc serial link */
 #define VIRTIO_ID_CAIF         12 /* Virtio caif */
+#define VIRTIO_ID_GPU          16 /* virtio GPU */
 #define VIRTIO_ID_INPUT        18 /* virtio input */
 
 #endif /* _LINUX_VIRTIO_IDS_H */
diff --git a/include/uapi/linux/virtio_net.h b/include/uapi/linux/virtio_net.h
index 7bbee79ca293..ec32293a00db 100644
--- a/include/uapi/linux/virtio_net.h
+++ b/include/uapi/linux/virtio_net.h
@@ -34,6 +34,7 @@
 /* The feature bitmap for virtio net */
 #define VIRTIO_NET_F_CSUM       0       /* Host handles pkts w/ partial csum */
 #define VIRTIO_NET_F_GUEST_CSUM 1       /* Guest handles pkts w/ partial csum */
+#define VIRTIO_NET_F_CTRL_GUEST_OFFLOADS 2 /* Dynamic offload configuration. */
 #define VIRTIO_NET_F_MAC        5       /* Host has given MAC address. */
 #define VIRTIO_NET_F_GUEST_TSO4 7       /* Guest can handle TSOv4 in. */
 #define VIRTIO_NET_F_GUEST_TSO6 8       /* Guest can handle TSOv6 in. */
@@ -226,4 +227,19 @@ struct virtio_net_ctrl_mq {
  #define VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MIN        1
  #define VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MAX        0x8000
 
+/*
+ * Control network offloads
+ *
+ * Reconfigures the network offloads that Guest can handle.
+ *
+ * Available with the VIRTIO_NET_F_CTRL_GUEST_OFFLOADS feature bit.
+ *
+ * Command data format matches the feature bit mask exactly.
+ *
+ * See VIRTIO_NET_F_GUEST_* for the list of offloads
+ * that can be enabled/disabled.
+ */
+#define VIRTIO_NET_CTRL_GUEST_OFFLOADS   5
+#define VIRTIO_NET_CTRL_GUEST_OFFLOADS_SET        0
+
 #endif /* _LINUX_VIRTIO_NET_H */
diff --git a/include/uapi/linux/virtio_pci.h b/include/uapi/linux/virtio_pci.h
index 75301468359f..90007a1abcab 100644
--- a/include/uapi/linux/virtio_pci.h
+++ b/include/uapi/linux/virtio_pci.h
@@ -157,6 +157,12 @@ struct virtio_pci_common_cfg {
         __le32 queue_used_hi;           /* read-write */
 };
 
+/* Fields in VIRTIO_PCI_CAP_PCI_CFG: */
+struct virtio_pci_cfg_cap {
+        struct virtio_pci_cap cap;
+        __u8 pci_cfg_data[4]; /* Data for BAR access. */
+};
+
 /* Macro versions of offsets for the Old Timers! */
 #define VIRTIO_PCI_CAP_VNDR             0
 #define VIRTIO_PCI_CAP_NEXT             1
diff --git a/include/uapi/linux/virtio_ring.h b/include/uapi/linux/virtio_ring.h
index 915980ac68df..c07295969b7e 100644
--- a/include/uapi/linux/virtio_ring.h
+++ b/include/uapi/linux/virtio_ring.h
@@ -31,6 +31,9 @@
  * SUCH DAMAGE.
  *
  * Copyright Rusty Russell IBM Corporation 2007. */
+#ifndef __KERNEL__
+#include <stdint.h>
+#endif
 #include <linux/types.h>
 #include <linux/virtio_types.h>
 
@@ -143,7 +146,7 @@ static inline void vring_init(struct vring *vr, unsigned int num, void *p,
         vr->num = num;
         vr->desc = p;
         vr->avail = p + num*sizeof(struct vring_desc);
-        vr->used = (void *)(((unsigned long)&vr->avail->ring[num] + sizeof(__virtio16)
+        vr->used = (void *)(((uintptr_t)&vr->avail->ring[num] + sizeof(__virtio16)
                 + align-1) & ~(align - 1));
 }
 
diff --git a/include/uapi/misc/cxl.h b/include/uapi/misc/cxl.h
index cd6d789b73ec..99a8ca15fe64 100644
--- a/include/uapi/misc/cxl.h
+++ b/include/uapi/misc/cxl.h
@@ -32,10 +32,32 @@ struct cxl_ioctl_start_work {
 #define CXL_START_WORK_ALL              (CXL_START_WORK_AMR |\
                                          CXL_START_WORK_NUM_IRQS)
 
+
+/* Possible modes that an afu can be in */
+#define CXL_MODE_DEDICATED   0x1
+#define CXL_MODE_DIRECTED    0x2
+
+/* possible flags for the cxl_afu_id flags field */
+#define CXL_AFUID_FLAG_SLAVE    0x1  /* In directed-mode afu is in slave mode */
+
+struct cxl_afu_id {
+        __u64 flags;     /* One of CXL_AFUID_FLAG_X */
+        __u32 card_id;
+        __u32 afu_offset;
+        __u32 afu_mode;  /* one of the CXL_MODE_X */
+        __u32 reserved1;
+        __u64 reserved2;
+        __u64 reserved3;
+        __u64 reserved4;
+        __u64 reserved5;
+        __u64 reserved6;
+};
+
 /* ioctl numbers */
 #define CXL_MAGIC 0xCA
 #define CXL_IOCTL_START_WORK            _IOW(CXL_MAGIC, 0x00, struct cxl_ioctl_start_work)
 #define CXL_IOCTL_GET_PROCESS_ELEMENT   _IOR(CXL_MAGIC, 0x01, __u32)
+#define CXL_IOCTL_GET_AFU_ID            _IOR(CXL_MAGIC, 0x02, struct cxl_afu_id)
 
 #define CXL_READ_MIN_SIZE 0x1000 /* 4K */
 
diff --git a/include/uapi/rdma/ib_user_verbs.h b/include/uapi/rdma/ib_user_verbs.h
index b513e662d8e4..978841eeaff1 100644
--- a/include/uapi/rdma/ib_user_verbs.h
+++ b/include/uapi/rdma/ib_user_verbs.h
@@ -91,6 +91,7 @@ enum {
 
 enum {
         IB_USER_VERBS_EX_CMD_QUERY_DEVICE = IB_USER_VERBS_CMD_QUERY_DEVICE,
+        IB_USER_VERBS_EX_CMD_CREATE_CQ = IB_USER_VERBS_CMD_CREATE_CQ,
         IB_USER_VERBS_EX_CMD_CREATE_FLOW = IB_USER_VERBS_CMD_THRESHOLD,
         IB_USER_VERBS_EX_CMD_DESTROY_FLOW,
 };
@@ -222,6 +223,8 @@ struct ib_uverbs_ex_query_device_resp {
         __u32 comp_mask;
         __u32 response_length;
         struct ib_uverbs_odp_caps odp_caps;
+        __u64 timestamp_mask;
+        __u64 hca_core_clock; /* in KHZ */
 };
 
 struct ib_uverbs_query_port {
@@ -353,11 +356,27 @@ struct ib_uverbs_create_cq {
         __u64 driver_data[0];
 };
 
+struct ib_uverbs_ex_create_cq {
+        __u64 user_handle;
+        __u32 cqe;
+        __u32 comp_vector;
+        __s32 comp_channel;
+        __u32 comp_mask;
+        __u32 flags;
+        __u32 reserved;
+};
+
 struct ib_uverbs_create_cq_resp {
         __u32 cq_handle;
         __u32 cqe;
 };
 
+struct ib_uverbs_ex_create_cq_resp {
+        struct ib_uverbs_create_cq_resp base;
+        __u32 comp_mask;
+        __u32 response_length;
+};
+
 struct ib_uverbs_resize_cq {
         __u64 response;
         __u32 cq_handle;
diff --git a/include/uapi/sound/asoc.h b/include/uapi/sound/asoc.h
new file mode 100644
index 000000000000..51b8066a223b
--- /dev/null
+++ b/include/uapi/sound/asoc.h
@@ -0,0 +1,401 @@
+/*
+ * uapi/sound/asoc.h -- ALSA SoC Firmware Controls and DAPM
+ *
+ * Copyright (C) 2012 Texas Instruments Inc.
+ * Copyright (C) 2015 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.
+ *
+ * Simple file API to load FW that includes mixers, coefficients, DAPM graphs,
+ * algorithms, equalisers, DAIs, widgets etc.
+*/
+
+#ifndef __LINUX_UAPI_SND_ASOC_H
+#define __LINUX_UAPI_SND_ASOC_H
+
+#include <linux/types.h>
+#include <sound/asound.h>
+
+/*
+ * Maximum number of channels topology kcontrol can represent.
+ */
+#define SND_SOC_TPLG_MAX_CHAN           8
+
+/*
+ * Maximum number of PCM formats capability
+ */
+#define SND_SOC_TPLG_MAX_FORMATS        16
+
+/*
+ * Maximum number of PCM stream configs
+ */
+#define SND_SOC_TPLG_STREAM_CONFIG_MAX  8
+
+/* individual kcontrol info types - can be mixed with other types */
+#define SND_SOC_TPLG_CTL_VOLSW          1
+#define SND_SOC_TPLG_CTL_VOLSW_SX       2
+#define SND_SOC_TPLG_CTL_VOLSW_XR_SX    3
+#define SND_SOC_TPLG_CTL_ENUM           4
+#define SND_SOC_TPLG_CTL_BYTES          5
+#define SND_SOC_TPLG_CTL_ENUM_VALUE     6
+#define SND_SOC_TPLG_CTL_RANGE          7
+#define SND_SOC_TPLG_CTL_STROBE         8
+
+
+/* individual widget kcontrol info types - can be mixed with other types */
+#define SND_SOC_TPLG_DAPM_CTL_VOLSW             64
+#define SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE       65
+#define SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT         66
+#define SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE        67
+#define SND_SOC_TPLG_DAPM_CTL_PIN               68
+
+/* DAPM widget types - add new items to the end */
+#define SND_SOC_TPLG_DAPM_INPUT         0
+#define SND_SOC_TPLG_DAPM_OUTPUT        1
+#define SND_SOC_TPLG_DAPM_MUX           2
+#define SND_SOC_TPLG_DAPM_MIXER         3
+#define SND_SOC_TPLG_DAPM_PGA           4
+#define SND_SOC_TPLG_DAPM_OUT_DRV       5
+#define SND_SOC_TPLG_DAPM_ADC           6
+#define SND_SOC_TPLG_DAPM_DAC           7
+#define SND_SOC_TPLG_DAPM_SWITCH        8
+#define SND_SOC_TPLG_DAPM_PRE           9
+#define SND_SOC_TPLG_DAPM_POST          10
+#define SND_SOC_TPLG_DAPM_AIF_IN        11
+#define SND_SOC_TPLG_DAPM_AIF_OUT       12
+#define SND_SOC_TPLG_DAPM_DAI_IN        13
+#define SND_SOC_TPLG_DAPM_DAI_OUT       14
+#define SND_SOC_TPLG_DAPM_DAI_LINK      15
+#define SND_SOC_TPLG_DAPM_LAST          SND_SOC_TPLG_DAPM_DAI_LINK
+
+/* Header magic number and string sizes */
+#define SND_SOC_TPLG_MAGIC              0x41536F43 /* ASoC */
+
+/* string sizes */
+#define SND_SOC_TPLG_NUM_TEXTS          16
+
+/* ABI version */
+#define SND_SOC_TPLG_ABI_VERSION        0x3
+
+/* Max size of TLV data */
+#define SND_SOC_TPLG_TLV_SIZE           32
+
+/*
+ * File and Block header data types.
+ * Add new generic and vendor types to end of list.
+ * Generic types are handled by the core whilst vendors types are passed
+ * to the component drivers for handling.
+ */
+#define SND_SOC_TPLG_TYPE_MIXER         1
+#define SND_SOC_TPLG_TYPE_BYTES         2
+#define SND_SOC_TPLG_TYPE_ENUM          3
+#define SND_SOC_TPLG_TYPE_DAPM_GRAPH    4
+#define SND_SOC_TPLG_TYPE_DAPM_WIDGET   5
+#define SND_SOC_TPLG_TYPE_DAI_LINK      6
+#define SND_SOC_TPLG_TYPE_PCM           7
+#define SND_SOC_TPLG_TYPE_MANIFEST      8
+#define SND_SOC_TPLG_TYPE_CODEC_LINK    9
+#define SND_SOC_TPLG_TYPE_PDATA         10
+#define SND_SOC_TPLG_TYPE_MAX   SND_SOC_TPLG_TYPE_PDATA
+
+/* vendor block IDs - please add new vendor types to end */
+#define SND_SOC_TPLG_TYPE_VENDOR_FW     1000
+#define SND_SOC_TPLG_TYPE_VENDOR_CONFIG 1001
+#define SND_SOC_TPLG_TYPE_VENDOR_COEFF  1002
+#define SND_SOC_TPLG_TYPEVENDOR_CODEC   1003
+
+#define SND_SOC_TPLG_STREAM_PLAYBACK    0
+#define SND_SOC_TPLG_STREAM_CAPTURE     1
+
+/*
+ * Block Header.
+ * This header precedes all object and object arrays below.
+ */
+struct snd_soc_tplg_hdr {
+        __le32 magic;           /* magic number */
+        __le32 abi;             /* ABI version */
+        __le32 version;         /* optional vendor specific version details */
+        __le32 type;            /* SND_SOC_TPLG_TYPE_ */
+        __le32 size;            /* size of this structure */
+        __le32 vendor_type;     /* optional vendor specific type info */
+        __le32 payload_size;    /* data bytes, excluding this header */
+        __le32 index;           /* identifier for block */
+        __le32 count;           /* number of elements in block */
+} __attribute__((packed));
+
+/*
+ * Private data.
+ * All topology objects may have private data that can be used by the driver or
+ * firmware. Core will ignore this data.
+ */
+struct snd_soc_tplg_private {
+        __le32 size;    /* in bytes of private data */
+        char data[0];
+} __attribute__((packed));
+
+/*
+ * Kcontrol TLV data.
+ */
+struct snd_soc_tplg_tlv_dbscale {
+        __le32 min;
+        __le32 step;
+        __le32 mute;
+} __attribute__((packed));
+
+struct snd_soc_tplg_ctl_tlv {
+        __le32 size;    /* in bytes of this structure */
+        __le32 type;    /* SNDRV_CTL_TLVT_*, type of TLV */
+        union {
+                __le32 data[SND_SOC_TPLG_TLV_SIZE];
+                struct snd_soc_tplg_tlv_dbscale scale;
+        };
+} __attribute__((packed));
+
+/*
+ * Kcontrol channel data
+ */
+struct snd_soc_tplg_channel {
+        __le32 size;    /* in bytes of this structure */
+        __le32 reg;
+        __le32 shift;
+        __le32 id;      /* ID maps to Left, Right, LFE etc */
+} __attribute__((packed));
+
+/*
+ * Genericl Operations IDs, for binding Kcontrol or Bytes ext ops
+ * Kcontrol ops need get/put/info.
+ * Bytes ext ops need get/put.
+ */
+struct snd_soc_tplg_io_ops {
+        __le32 get;
+        __le32 put;
+        __le32 info;
+} __attribute__((packed));
+
+/*
+ * kcontrol header
+ */
+struct snd_soc_tplg_ctl_hdr {
+        __le32 size;    /* in bytes of this structure */
+        __le32 type;
+        char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
+        __le32 access;
+        struct snd_soc_tplg_io_ops ops;
+        struct snd_soc_tplg_ctl_tlv tlv;
+} __attribute__((packed));
+
+/*
+ * Stream Capabilities
+ */
+struct snd_soc_tplg_stream_caps {
+        __le32 size;            /* in bytes of this structure */
+        char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
+        __le64 formats[SND_SOC_TPLG_MAX_FORMATS];       /* supported formats SNDRV_PCM_FMTBIT_* */
+        __le32 rates;           /* supported rates SNDRV_PCM_RATE_* */
+        __le32 rate_min;        /* min rate */
+        __le32 rate_max;        /* max rate */
+        __le32 channels_min;    /* min channels */
+        __le32 channels_max;    /* max channels */
+        __le32 periods_min;     /* min number of periods */
+        __le32 periods_max;     /* max number of periods */
+        __le32 period_size_min; /* min period size bytes */
+        __le32 period_size_max; /* max period size bytes */
+        __le32 buffer_size_min; /* min buffer size bytes */
+        __le32 buffer_size_max; /* max buffer size bytes */
+} __attribute__((packed));
+
+/*
+ * FE or BE Stream configuration supported by SW/FW
+ */
+struct snd_soc_tplg_stream {
+        __le32 size;            /* in bytes of this structure */
+        __le64 format;          /* SNDRV_PCM_FMTBIT_* */
+        __le32 rate;            /* SNDRV_PCM_RATE_* */
+        __le32 period_bytes;    /* size of period in bytes */
+        __le32 buffer_bytes;    /* size of buffer in bytes */
+        __le32 channels;        /* channels */
+        __le32 tdm_slot;        /* optional BE bitmask of supported TDM slots */
+        __le32 dai_fmt;         /* SND_SOC_DAIFMT_  */
+} __attribute__((packed));
+
+/*
+ * Duplex stream configuration supported by SW/FW.
+ */
+struct snd_soc_tplg_stream_config {
+        __le32 size;            /* in bytes of this structure */
+        char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
+        struct snd_soc_tplg_stream playback;
+        struct snd_soc_tplg_stream capture;
+} __attribute__((packed));
+
+/*
+ * Manifest. List totals for each payload type. Not used in parsing, but will
+ * be passed to the component driver before any other objects in order for any
+ * global component resource allocations.
+ *
+ * File block representation for manifest :-
+ * +-----------------------------------+----+
+ * | struct snd_soc_tplg_hdr           |  1 |
+ * +-----------------------------------+----+
+ * | struct snd_soc_tplg_manifest      |  1 |
+ * +-----------------------------------+----+
+ */
+struct snd_soc_tplg_manifest {
+        __le32 size;            /* in bytes of this structure */
+        __le32 control_elems;   /* number of control elements */
+        __le32 widget_elems;    /* number of widget elements */
+        __le32 graph_elems;     /* number of graph elements */
+        __le32 dai_elems;       /* number of DAI elements */
+        __le32 dai_link_elems;  /* number of DAI link elements */
+        struct snd_soc_tplg_private priv;
+} __attribute__((packed));
+
+/*
+ * Mixer kcontrol.
+ *
+ * File block representation for mixer kcontrol :-
+ * +-----------------------------------+----+
+ * | struct snd_soc_tplg_hdr           |  1 |
+ * +-----------------------------------+----+
+ * | struct snd_soc_tplg_mixer_control |  N |
+ * +-----------------------------------+----+
+ */
+struct snd_soc_tplg_mixer_control {
+        struct snd_soc_tplg_ctl_hdr hdr;
+        __le32 size;    /* in bytes of this structure */
+        __le32 min;
+        __le32 max;
+        __le32 platform_max;
+        __le32 invert;
+        __le32 num_channels;
+        struct snd_soc_tplg_channel channel[SND_SOC_TPLG_MAX_CHAN];
+        struct snd_soc_tplg_private priv;
+} __attribute__((packed));
+
+/*
+ * Enumerated kcontrol
+ *
+ * File block representation for enum kcontrol :-
+ * +-----------------------------------+----+
+ * | struct snd_soc_tplg_hdr           |  1 |
+ * +-----------------------------------+----+
+ * | struct snd_soc_tplg_enum_control  |  N |
+ * +-----------------------------------+----+
+ */
+struct snd_soc_tplg_enum_control {
+        struct snd_soc_tplg_ctl_hdr hdr;
+        __le32 size;    /* in bytes of this structure */
+        __le32 num_channels;
+        struct snd_soc_tplg_channel channel[SND_SOC_TPLG_MAX_CHAN];
+        __le32 items;
+        __le32 mask;
+        __le32 count;
+        char texts[SND_SOC_TPLG_NUM_TEXTS][SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
+        __le32 values[SND_SOC_TPLG_NUM_TEXTS * SNDRV_CTL_ELEM_ID_NAME_MAXLEN / 4];
+        struct snd_soc_tplg_private priv;
+} __attribute__((packed));
+
+/*
+ * Bytes kcontrol
+ *
+ * File block representation for bytes kcontrol :-
+ * +-----------------------------------+----+
+ * | struct snd_soc_tplg_hdr           |  1 |
+ * +-----------------------------------+----+
+ * | struct snd_soc_tplg_bytes_control |  N |
+ * +-----------------------------------+----+
+ */
+struct snd_soc_tplg_bytes_control {
+        struct snd_soc_tplg_ctl_hdr hdr;
+        __le32 size;    /* in bytes of this structure */
+        __le32 max;
+        __le32 mask;
+        __le32 base;
+        __le32 num_regs;
+        struct snd_soc_tplg_io_ops ext_ops;
+        struct snd_soc_tplg_private priv;
+} __attribute__((packed));
+
+/*
+ * DAPM Graph Element
+ *
+ * File block representation for DAPM graph elements :-
+ * +-------------------------------------+----+
+ * | struct snd_soc_tplg_hdr             |  1 |
+ * +-------------------------------------+----+
+ * | struct snd_soc_tplg_dapm_graph_elem |  N |
+ * +-------------------------------------+----+
+ */
+struct snd_soc_tplg_dapm_graph_elem {
+        char sink[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
+        char control[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
+        char source[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
+} __attribute__((packed));
+
+/*
+ * DAPM Widget.
+ *
+ * File block representation for DAPM widget :-
+ * +-------------------------------------+-----+
+ * | struct snd_soc_tplg_hdr             |  1  |
+ * +-------------------------------------+-----+
+ * | struct snd_soc_tplg_dapm_widget     |  N  |
+ * +-------------------------------------+-----+
+ * |   struct snd_soc_tplg_enum_control  | 0|1 |
+ * |   struct snd_soc_tplg_mixer_control | 0|N |
+ * +-------------------------------------+-----+
+ *
+ * Optional enum or mixer control can be appended to the end of each widget
+ * in the block.
+ */
+struct snd_soc_tplg_dapm_widget {
+        __le32 size;            /* in bytes of this structure */
+        __le32 id;              /* SND_SOC_DAPM_CTL */
+        char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
+        char sname[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
+
+        __le32 reg;             /* negative reg = no direct dapm */
+        __le32 shift;           /* bits to shift */
+        __le32 mask;            /* non-shifted mask */
+        __le32 subseq;          /* sort within widget type */
+        __u32 invert;           /* invert the power bit */
+        __u32 ignore_suspend;   /* kept enabled over suspend */
+        __u16 event_flags;
+        __u16 event_type;
+        __u16 num_kcontrols;
+        struct snd_soc_tplg_private priv;
+        /*
+         * kcontrols that relate to this widget
+         * follow here after widget private data
+         */
+} __attribute__((packed));
+
+struct snd_soc_tplg_pcm_cfg_caps {
+        struct snd_soc_tplg_stream_caps caps;
+        struct snd_soc_tplg_stream_config configs[SND_SOC_TPLG_STREAM_CONFIG_MAX];
+        __le32 num_configs;     /* number of configs */
+} __attribute__((packed));
+
+/*
+ * Describes SW/FW specific features of PCM or DAI link.
+ *
+ * File block representation for PCM/DAI-Link :-
+ * +-----------------------------------+-----+
+ * | struct snd_soc_tplg_hdr           |  1  |
+ * +-----------------------------------+-----+
+ * | struct snd_soc_tplg_dapm_pcm_dai  |  N  |
+ * +-----------------------------------+-----+
+ */
+struct snd_soc_tplg_pcm_dai {
+        __le32 size;            /* in bytes of this structure */
+        char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
+        __le32 id;                      /* unique ID - used to match */
+        __le32 playback;                /* supports playback mode */
+        __le32 capture;                 /* supports capture mode */
+        __le32 compress;                /* 1 = compressed; 0 = PCM */
+        struct snd_soc_tplg_pcm_cfg_caps capconf[2];    /* capabilities and configs */
+} __attribute__((packed));
+
+#endif
diff --git a/include/uapi/sound/tlv.h b/include/uapi/sound/tlv.h
new file mode 100644
index 000000000000..ffc4f203146c
--- /dev/null
+++ b/include/uapi/sound/tlv.h
@@ -0,0 +1,31 @@
+/*
+ *   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.
+ */
+
+#ifndef __UAPI_SOUND_TLV_H
+#define __UAPI_SOUND_TLV_H
+
+#define SNDRV_CTL_TLVT_CONTAINER 0      /* one level down - group of TLVs */
+#define SNDRV_CTL_TLVT_DB_SCALE 1       /* dB scale */
+#define SNDRV_CTL_TLVT_DB_LINEAR 2      /* linear volume */
+#define SNDRV_CTL_TLVT_DB_RANGE 3       /* dB range container */
+#define SNDRV_CTL_TLVT_DB_MINMAX 4      /* dB scale with min/max */
+#define SNDRV_CTL_TLVT_DB_MINMAX_MUTE 5 /* dB scale with min/max with mute */
+
+/*
+ * channel-mapping TLV items
+ *  TLV length must match with num_channels
+ */
+#define SNDRV_CTL_TLVT_CHMAP_FIXED      0x101   /* fixed channel position */
+#define SNDRV_CTL_TLVT_CHMAP_VAR        0x102   /* channels freely swappable */
+#define SNDRV_CTL_TLVT_CHMAP_PAIRED     0x103   /* pair-wise swappable */
+
+#endif
diff --git a/include/video/exynos5433_decon.h b/include/video/exynos5433_decon.h
new file mode 100644
index 000000000000..3696575b02f2
--- /dev/null
+++ b/include/video/exynos5433_decon.h
@@ -0,0 +1,165 @@
+/*
+ * Copyright (C) 2014 Samsung Electronics Co.Ltd
+ *
+ * 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 Foundationr
+ */
+
+#ifndef EXYNOS_REGS_DECON_H
+#define EXYNOS_REGS_DECON_H
+
+/* Exynos543X DECON */
+#define DECON_VIDCON0                   0x0000
+#define DECON_VIDOUTCON0                0x0010
+#define DECON_WINCONx(n)                (0x0020 + ((n) * 4))
+#define DECON_VIDOSDxH(n)               (0x0080 + ((n) * 4))
+#define DECON_SHADOWCON                 0x00A0
+#define DECON_VIDOSDxA(n)               (0x00B0 + ((n) * 0x20))
+#define DECON_VIDOSDxB(n)               (0x00B4 + ((n) * 0x20))
+#define DECON_VIDOSDxC(n)               (0x00B8 + ((n) * 0x20))
+#define DECON_VIDOSDxD(n)               (0x00BC + ((n) * 0x20))
+#define DECON_VIDOSDxE(n)               (0x00C0 + ((n) * 0x20))
+#define DECON_VIDW0xADD0B0(n)           (0x0150 + ((n) * 0x10))
+#define DECON_VIDW0xADD0B1(n)           (0x0154 + ((n) * 0x10))
+#define DECON_VIDW0xADD0B2(n)           (0x0158 + ((n) * 0x10))
+#define DECON_VIDW0xADD1B0(n)           (0x01A0 + ((n) * 0x10))
+#define DECON_VIDW0xADD1B1(n)           (0x01A4 + ((n) * 0x10))
+#define DECON_VIDW0xADD1B2(n)           (0x01A8 + ((n) * 0x10))
+#define DECON_VIDW0xADD2(n)             (0x0200 + ((n) * 4))
+#define DECON_LOCALxSIZE(n)             (0x0214 + ((n) * 4))
+#define DECON_VIDINTCON0                0x0220
+#define DECON_VIDINTCON1                0x0224
+#define DECON_WxKEYCON0(n)              (0x0230 + ((n - 1) * 8))
+#define DECON_WxKEYCON1(n)              (0x0234 + ((n - 1) * 8))
+#define DECON_WxKEYALPHA(n)             (0x0250 + ((n - 1) * 4))
+#define DECON_WINxMAP(n)                (0x0270 + ((n) * 4))
+#define DECON_QOSLUT07_00               0x02C0
+#define DECON_QOSLUT15_08               0x02C4
+#define DECON_QOSCTRL                   0x02C8
+#define DECON_BLENDERQx(n)              (0x0300 + ((n - 1) * 4))
+#define DECON_BLENDCON                  0x0310
+#define DECON_OPE_VIDW0xADD0(n)         (0x0400 + ((n) * 4))
+#define DECON_OPE_VIDW0xADD1(n)         (0x0414 + ((n) * 4))
+#define DECON_FRAMEFIFO_REG7            0x051C
+#define DECON_FRAMEFIFO_REG8            0x0520
+#define DECON_FRAMEFIFO_STATUS          0x0524
+#define DECON_CMU                       0x1404
+#define DECON_UPDATE                    0x1410
+#define DECON_UPDATE_SCHEME             0x1438
+#define DECON_VIDCON1                   0x2000
+#define DECON_VIDCON2                   0x2004
+#define DECON_VIDCON3                   0x2008
+#define DECON_VIDCON4                   0x200C
+#define DECON_VIDTCON2                  0x2028
+#define DECON_FRAME_SIZE                0x2038
+#define DECON_LINECNT_OP_THRESHOLD      0x203C
+#define DECON_TRIGCON                   0x2040
+#define DECON_TRIGSKIP                  0x2050
+#define DECON_CRCRDATA                  0x20B0
+#define DECON_CRCCTRL                   0x20B4
+
+/* Exynos5430 DECON */
+#define DECON_VIDTCON0                  0x2020
+#define DECON_VIDTCON1                  0x2024
+
+/* Exynos5433 DECON */
+#define DECON_VIDTCON00                 0x2010
+#define DECON_VIDTCON01                 0x2014
+#define DECON_VIDTCON10                 0x2018
+#define DECON_VIDTCON11                 0x201C
+
+/* Exynos543X DECON Internal */
+#define DECON_W013DSTREOCON             0x0320
+#define DECON_W233DSTREOCON             0x0324
+#define DECON_FRAMEFIFO_REG0            0x0500
+#define DECON_ENHANCER_CTRL             0x2100
+
+/* Exynos543X DECON TV */
+#define DECON_VCLKCON0                  0x0014
+#define DECON_VIDINTCON2                0x0228
+#define DECON_VIDINTCON3                0x022C
+
+/* VIDCON0 */
+#define VIDCON0_SWRESET                 (1 << 28)
+#define VIDCON0_STOP_STATUS             (1 << 2)
+#define VIDCON0_ENVID                   (1 << 1)
+#define VIDCON0_ENVID_F                 (1 << 0)
+
+/* VIDOUTCON0 */
+#define VIDOUT_LCD_ON                   (1 << 24)
+#define VIDOUT_IF_F_MASK                (0x3 << 20)
+#define VIDOUT_RGB_IF                   (0x0 << 20)
+#define VIDOUT_COMMAND_IF               (0x2 << 20)
+
+/* WINCONx */
+#define WINCONx_HAWSWP_F                (1 << 16)
+#define WINCONx_WSWP_F                  (1 << 15)
+#define WINCONx_BURSTLEN_MASK           (0x3 << 10)
+#define WINCONx_BURSTLEN_16WORD         (0x0 << 10)
+#define WINCONx_BURSTLEN_8WORD          (0x1 << 10)
+#define WINCONx_BURSTLEN_4WORD          (0x2 << 10)
+#define WINCONx_BLD_PIX_F               (1 << 6)
+#define WINCONx_BPPMODE_MASK            (0xf << 2)
+#define WINCONx_BPPMODE_16BPP_565       (0x5 << 2)
+#define WINCONx_BPPMODE_16BPP_A1555     (0x6 << 2)
+#define WINCONx_BPPMODE_16BPP_I1555     (0x7 << 2)
+#define WINCONx_BPPMODE_24BPP_888       (0xb << 2)
+#define WINCONx_BPPMODE_24BPP_A1887     (0xc << 2)
+#define WINCONx_BPPMODE_25BPP_A1888     (0xd << 2)
+#define WINCONx_BPPMODE_32BPP_A8888     (0xd << 2)
+#define WINCONx_BPPMODE_16BPP_A4444     (0xe << 2)
+#define WINCONx_ALPHA_SEL_F             (1 << 1)
+#define WINCONx_ENWIN_F                 (1 << 0)
+
+/* SHADOWCON */
+#define SHADOWCON_Wx_PROTECT(n)         (1 << (10 + (n)))
+
+/* VIDOSDxD */
+#define VIDOSD_Wx_ALPHA_R_F(n)          (((n) & 0xff) << 16)
+#define VIDOSD_Wx_ALPHA_G_F(n)          (((n) & 0xff) << 8)
+#define VIDOSD_Wx_ALPHA_B_F(n)          (((n) & 0xff) << 0)
+
+/* VIDINTCON0 */
+#define VIDINTCON0_FRAMEDONE            (1 << 17)
+#define VIDINTCON0_INTFRMEN             (1 << 12)
+#define VIDINTCON0_INTEN                (1 << 0)
+
+/* VIDINTCON1 */
+#define VIDINTCON1_INTFRMDONEPEND       (1 << 2)
+#define VIDINTCON1_INTFRMPEND           (1 << 1)
+#define VIDINTCON1_INTFIFOPEND          (1 << 0)
+
+/* DECON_CMU */
+#define CMU_CLKGAGE_MODE_SFR_F          (1 << 1)
+#define CMU_CLKGAGE_MODE_MEM_F          (1 << 0)
+
+/* DECON_UPDATE */
+#define STANDALONE_UPDATE_F             (1 << 0)
+
+/* DECON_VIDTCON00 */
+#define VIDTCON00_VBPD_F(x)             (((x) & 0xfff) << 16)
+#define VIDTCON00_VFPD_F(x)             ((x) & 0xfff)
+
+/* DECON_VIDTCON01 */
+#define VIDTCON01_VSPW_F(x)             (((x) & 0xfff) << 16)
+
+/* DECON_VIDTCON10 */
+#define VIDTCON10_HBPD_F(x)             (((x) & 0xfff) << 16)
+#define VIDTCON10_HFPD_F(x)             ((x) & 0xfff)
+
+/* DECON_VIDTCON11 */
+#define VIDTCON11_HSPW_F(x)             (((x) & 0xfff) << 16)
+
+/* DECON_VIDTCON2 */
+#define VIDTCON2_LINEVAL(x)             (((x) & 0xfff) << 16)
+#define VIDTCON2_HOZVAL(x)              ((x) & 0xfff)
+
+/* TRIGCON */
+#define TRIGCON_TRIGEN_PER_F            (1 << 31)
+#define TRIGCON_TRIGEN_F                (1 << 30)
+#define TRIGCON_TE_AUTO_MASK            (1 << 29)
+#define TRIGCON_SWTRIGCMD               (1 << 1)
+#define TRIGCON_SWTRIGEN                (1 << 0)
+
+#endif /* EXYNOS_REGS_DECON_H */
diff --git a/include/video/neomagic.h b/include/video/neomagic.h
index bc5013e8059d..91e225a6107d 100644
--- a/include/video/neomagic.h
+++ b/include/video/neomagic.h
@@ -159,10 +159,7 @@ struct neofb_par {
         unsigned char VCLK3NumeratorHigh;
         unsigned char VCLK3Denominator;
         unsigned char VerticalExt;
-
-#ifdef CONFIG_MTRR
-        int mtrr;
-#endif
+        int wc_cookie;
         u8 __iomem *mmio_vbase;
         u8 cursorOff;
         u8 *cursorPad;          /* Must die !! */
diff --git a/include/video/tdfx.h b/include/video/tdfx.h
index befbaf0a92d8..69674b94bb68 100644
--- a/include/video/tdfx.h
+++ b/include/video/tdfx.h
@@ -196,7 +196,7 @@ struct tdfx_par {
         u32 palette[16];
         void __iomem *regbase_virt;
         unsigned long iobase;
-        int mtrr_handle;
+        int wc_cookie;
 #ifdef CONFIG_FB_3DFX_I2C
         struct tdfxfb_i2c_chan chan[2];
 #endif