Merge tag 'v3.18-rc2' into asoc-sgtl5000

Linux 3.18-rc2

158 files changed, 7011 insertions, 1298 deletions

diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig
index d0f3265fb85d..b23fe37f67c0 100644
--- a/drivers/acpi/Kconfig
+++ b/drivers/acpi/Kconfig
@@ -144,7 +144,7 @@ config ACPI_VIDEO
 
 config ACPI_FAN
         tristate "Fan"
-        select THERMAL
+        depends on THERMAL
         default y
         help
           This driver supports ACPI fan devices, allowing user-mode
diff --git a/drivers/acpi/Makefile b/drivers/acpi/Makefile
index 505d4d79fe3e..c3b2fcb729f3 100644
--- a/drivers/acpi/Makefile
+++ b/drivers/acpi/Makefile
@@ -43,6 +43,7 @@ acpi-y				+= pci_root.o pci_link.o pci_irq.o
 acpi-y                          += acpi_lpss.o
 acpi-y                          += acpi_platform.o
 acpi-y                          += acpi_pnp.o
+acpi-y                          += int340x_thermal.o
 acpi-y                          += power.o
 acpi-y                          += event.o
 acpi-y                          += sysfs.o
diff --git a/drivers/acpi/acpi_platform.c b/drivers/acpi/acpi_platform.c
index 2bf9082f7523..6ba8beb6b9d2 100644
--- a/drivers/acpi/acpi_platform.c
+++ b/drivers/acpi/acpi_platform.c
@@ -16,6 +16,7 @@
 #include <linux/err.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
+#include <linux/dma-mapping.h>
 #include <linux/platform_device.h>
 
 #include "internal.h"
@@ -102,6 +103,7 @@ struct platform_device *acpi_create_platform_device(struct acpi_device *adev)
         pdevinfo.res = resources;
         pdevinfo.num_res = count;
         pdevinfo.acpi_node.companion = adev;
+        pdevinfo.dma_mask = DMA_BIT_MASK(32);
         pdev = platform_device_register_full(&pdevinfo);
         if (IS_ERR(pdev))
                 dev_err(&adev->dev, "platform device creation failed: %ld\n",
@@ -113,3 +115,4 @@ struct platform_device *acpi_create_platform_device(struct acpi_device *adev)
         kfree(resources);
         return pdev;
 }
+EXPORT_SYMBOL_GPL(acpi_create_platform_device);
diff --git a/drivers/acpi/acpica/achware.h b/drivers/acpi/acpica/achware.h
index 2ad2351a9833..c318d3e27893 100644
--- a/drivers/acpi/acpica/achware.h
+++ b/drivers/acpi/acpica/achware.h
@@ -127,7 +127,7 @@ acpi_hw_clear_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
 
 acpi_status
 acpi_hw_get_gpe_status(struct acpi_gpe_event_info *gpe_event_info,
-                       acpi_event_status * event_status);
+                       acpi_event_status *event_status);
 
 acpi_status acpi_hw_disable_all_gpes(void);
 
diff --git a/drivers/acpi/acpica/aclocal.h b/drivers/acpi/acpica/aclocal.h
index 2747279fbe3c..c00e7e41ad75 100644
--- a/drivers/acpi/acpica/aclocal.h
+++ b/drivers/acpi/acpica/aclocal.h
@@ -413,8 +413,8 @@ struct acpi_gpe_handler_info {
         acpi_gpe_handler address;       /* Address of handler, if any */
         void *context;          /* Context to be passed to handler */
         struct acpi_namespace_node *method_node;        /* Method node for this GPE level (saved) */
-        u8 original_flags;      /* Original (pre-handler) GPE info */
-        u8 originally_enabled;  /* True if GPE was originally enabled */
+        u8 original_flags;      /* Original (pre-handler) GPE info */
+        u8 originally_enabled;  /* True if GPE was originally enabled */
 };
 
 /* Notify info for implicit notify, multiple device objects */
diff --git a/drivers/acpi/acpica/actables.h b/drivers/acpi/acpica/actables.h
index f14882788eee..1afe46e44dac 100644
--- a/drivers/acpi/acpica/actables.h
+++ b/drivers/acpi/acpica/actables.h
@@ -49,6 +49,8 @@ acpi_status acpi_allocate_root_table(u32 initial_table_count);
 /*
  * tbxfroot - Root pointer utilities
  */
+u32 acpi_tb_get_rsdp_length(struct acpi_table_rsdp *rsdp);
+
 acpi_status acpi_tb_validate_rsdp(struct acpi_table_rsdp *rsdp);
 
 u8 *acpi_tb_scan_memory_for_rsdp(u8 *start_address, u32 length);
diff --git a/drivers/acpi/acpica/amlresrc.h b/drivers/acpi/acpica/amlresrc.h
index f3f834408441..3a0beeb86ba5 100644
--- a/drivers/acpi/acpica/amlresrc.h
+++ b/drivers/acpi/acpica/amlresrc.h
@@ -117,6 +117,12 @@ struct asl_resource_node {
         struct asl_resource_node *next;
 };
 
+struct asl_resource_info {
+        union acpi_parse_object *descriptor_type_op;    /* Resource descriptor parse node */
+        union acpi_parse_object *mapping_op;    /* Used for mapfile support */
+        u32 current_byte_offset;        /* Offset in resource template */
+};
+
 /* Macros used to generate AML resource length fields */
 
 #define ACPI_AML_SIZE_LARGE(r)      (sizeof (r) - sizeof (struct aml_resource_large_header))
@@ -449,4 +455,32 @@ union aml_resource {
         u8 byte_item;
 };
 
+/* Interfaces used by both the disassembler and compiler */
+
+void
+mp_save_gpio_info(union acpi_parse_object *op,
+                  union aml_resource *resource,
+                  u32 pin_count, u16 *pin_list, char *device_name);
+
+void
+mp_save_serial_info(union acpi_parse_object *op,
+                    union aml_resource *resource, char *device_name);
+
+char *mp_get_hid_from_parse_tree(struct acpi_namespace_node *hid_node);
+
+char *mp_get_hid_via_namestring(char *device_name);
+
+char *mp_get_connection_info(union acpi_parse_object *op,
+                             u32 pin_index,
+                             struct acpi_namespace_node **target_node,
+                             char **target_name);
+
+char *mp_get_parent_device_hid(union acpi_parse_object *op,
+                               struct acpi_namespace_node **target_node,
+                               char **parent_device_name);
+
+char *mp_get_ddn_value(char *device_name);
+
+char *mp_get_hid_value(struct acpi_namespace_node *device_node);
+
 #endif
diff --git a/drivers/acpi/acpica/evgpe.c b/drivers/acpi/acpica/evgpe.c
index e4ba4dec86af..2095dfb72bcb 100644
--- a/drivers/acpi/acpica/evgpe.c
+++ b/drivers/acpi/acpica/evgpe.c
@@ -100,13 +100,14 @@ acpi_ev_update_gpe_enable_mask(struct acpi_gpe_event_info *gpe_event_info)
  *
  * FUNCTION:    acpi_ev_enable_gpe
  *
- * PARAMETERS:  gpe_event_info  - GPE to enable
+ * PARAMETERS:  gpe_event_info          - GPE to enable
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Clear a GPE of stale events and enable it.
  *
  ******************************************************************************/
+
 acpi_status acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info)
 {
         acpi_status status;
@@ -125,6 +126,7 @@ acpi_status acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info)
         }
 
         /* Clear the GPE (of stale events) */
+
         status = acpi_hw_clear_gpe(gpe_event_info);
         if (ACPI_FAILURE(status)) {
                 return_ACPI_STATUS(status);
@@ -136,7 +138,6 @@ acpi_status acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info)
         return_ACPI_STATUS(status);
 }
 
-
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ev_add_gpe_reference
@@ -212,7 +213,7 @@ acpi_ev_remove_gpe_reference(struct acpi_gpe_event_info *gpe_event_info)
                 if (ACPI_SUCCESS(status)) {
                         status =
                             acpi_hw_low_set_gpe(gpe_event_info,
-                                                     ACPI_GPE_DISABLE);
+                                                ACPI_GPE_DISABLE);
                 }
 
                 if (ACPI_FAILURE(status)) {
@@ -334,7 +335,7 @@ struct acpi_gpe_event_info *acpi_ev_get_gpe_event_info(acpi_handle gpe_device,
  *
  ******************************************************************************/
 
-u32 acpi_ev_gpe_detect(struct acpi_gpe_xrupt_info * gpe_xrupt_list)
+u32 acpi_ev_gpe_detect(struct acpi_gpe_xrupt_info *gpe_xrupt_list)
 {
         acpi_status status;
         struct acpi_gpe_block_info *gpe_block;
@@ -427,7 +428,7 @@ u32 acpi_ev_gpe_detect(struct acpi_gpe_xrupt_info * gpe_xrupt_list)
 
                         /* Check if there is anything active at all in this register */
 
-                        enabled_status_byte = (u8) (status_reg & enable_reg);
+                        enabled_status_byte = (u8)(status_reg & enable_reg);
                         if (!enabled_status_byte) {
 
                                 /* No active GPEs in this register, move on */
@@ -450,7 +451,7 @@ u32 acpi_ev_gpe_detect(struct acpi_gpe_xrupt_info * gpe_xrupt_list)
                                             acpi_ev_gpe_dispatch(gpe_block->
                                                                  node,
                                                                  &gpe_block->
-                                                event_info[((acpi_size) i * ACPI_GPE_REGISTER_WIDTH) + j], j + gpe_register_info->base_gpe_number);
+                                                                 event_info[((acpi_size) i * ACPI_GPE_REGISTER_WIDTH) + j], j + gpe_register_info->base_gpe_number);
                                 }
                         }
                 }
@@ -636,7 +637,7 @@ static void ACPI_SYSTEM_XFACE acpi_ev_asynch_enable_gpe(void *context)
  *
  ******************************************************************************/
 
-acpi_status acpi_ev_finish_gpe(struct acpi_gpe_event_info *gpe_event_info)
+acpi_status acpi_ev_finish_gpe(struct acpi_gpe_event_info * gpe_event_info)
 {
         acpi_status status;
 
@@ -666,9 +667,9 @@ acpi_status acpi_ev_finish_gpe(struct acpi_gpe_event_info *gpe_event_info)
  *
  * FUNCTION:    acpi_ev_gpe_dispatch
  *
- * PARAMETERS:  gpe_device      - Device node. NULL for GPE0/GPE1
- *              gpe_event_info  - Info for this GPE
- *              gpe_number      - Number relative to the parent GPE block
+ * PARAMETERS:  gpe_device          - Device node. NULL for GPE0/GPE1
+ *              gpe_event_info      - Info for this GPE
+ *              gpe_number          - Number relative to the parent GPE block
  *
  * RETURN:      INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED
  *
@@ -681,7 +682,7 @@ acpi_status acpi_ev_finish_gpe(struct acpi_gpe_event_info *gpe_event_info)
 
 u32
 acpi_ev_gpe_dispatch(struct acpi_namespace_node *gpe_device,
-                    struct acpi_gpe_event_info *gpe_event_info, u32 gpe_number)
+                     struct acpi_gpe_event_info *gpe_event_info, u32 gpe_number)
 {
         acpi_status status;
         u32 return_value;
diff --git a/drivers/acpi/acpica/evgpeinit.c b/drivers/acpi/acpica/evgpeinit.c
index 49fc7effd961..7be928379879 100644
--- a/drivers/acpi/acpica/evgpeinit.c
+++ b/drivers/acpi/acpica/evgpeinit.c
@@ -424,6 +424,7 @@ acpi_ev_match_gpe_method(acpi_handle obj_handle,
         }
 
         /* Disable the GPE in case it's been enabled already. */
+
         (void)acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_DISABLE);
 
         /*
diff --git a/drivers/acpi/acpica/evxface.c b/drivers/acpi/acpica/evxface.c
index 11e5803b8b41..55a58f3ec8df 100644
--- a/drivers/acpi/acpica/evxface.c
+++ b/drivers/acpi/acpica/evxface.c
@@ -786,18 +786,26 @@ acpi_install_gpe_handler(acpi_handle gpe_device,
         handler->method_node = gpe_event_info->dispatch.method_node;
         handler->original_flags = (u8)(gpe_event_info->flags &
                                        (ACPI_GPE_XRUPT_TYPE_MASK |
-                                        ACPI_GPE_DISPATCH_MASK));
+                                        ACPI_GPE_DISPATCH_MASK));
 
         /*
          * If the GPE is associated with a method, it may have been enabled
          * automatically during initialization, in which case it has to be
          * disabled now to avoid spurious execution of the handler.
          */
-
-        if ((handler->original_flags & ACPI_GPE_DISPATCH_METHOD)
-            && gpe_event_info->runtime_count) {
-                handler->originally_enabled = 1;
+        if (((handler->original_flags & ACPI_GPE_DISPATCH_METHOD) ||
+             (handler->original_flags & ACPI_GPE_DISPATCH_NOTIFY)) &&
+            gpe_event_info->runtime_count) {
+                handler->originally_enabled = TRUE;
                 (void)acpi_ev_remove_gpe_reference(gpe_event_info);
+
+                /* Sanity check of original type against new type */
+
+                if (type !=
+                    (u32)(gpe_event_info->flags & ACPI_GPE_XRUPT_TYPE_MASK)) {
+                        ACPI_WARNING((AE_INFO,
+                                      "GPE type mismatch (level/edge)"));
+                }
         }
 
         /* Install the handler */
@@ -808,7 +816,7 @@ acpi_install_gpe_handler(acpi_handle gpe_device,
 
         gpe_event_info->flags &=
             ~(ACPI_GPE_XRUPT_TYPE_MASK | ACPI_GPE_DISPATCH_MASK);
-        gpe_event_info->flags |= (u8) (type | ACPI_GPE_DISPATCH_HANDLER);
+        gpe_event_info->flags |= (u8)(type | ACPI_GPE_DISPATCH_HANDLER);
 
         acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
 
@@ -893,7 +901,7 @@ acpi_remove_gpe_handler(acpi_handle gpe_device,
 
         gpe_event_info->dispatch.method_node = handler->method_node;
         gpe_event_info->flags &=
-                ~(ACPI_GPE_XRUPT_TYPE_MASK | ACPI_GPE_DISPATCH_MASK);
+            ~(ACPI_GPE_XRUPT_TYPE_MASK | ACPI_GPE_DISPATCH_MASK);
         gpe_event_info->flags |= handler->original_flags;
 
         /*
@@ -901,7 +909,8 @@ acpi_remove_gpe_handler(acpi_handle gpe_device,
          * enabled, it should be enabled at this point to restore the
          * post-initialization configuration.
          */
-        if ((handler->original_flags & ACPI_GPE_DISPATCH_METHOD) &&
+        if (((handler->original_flags & ACPI_GPE_DISPATCH_METHOD) ||
+             (handler->original_flags & ACPI_GPE_DISPATCH_NOTIFY)) &&
             handler->originally_enabled) {
                 (void)acpi_ev_add_gpe_reference(gpe_event_info);
         }
@@ -946,7 +955,7 @@ ACPI_EXPORT_SYMBOL(acpi_remove_gpe_handler)
  * handle is returned.
  *
  ******************************************************************************/
-acpi_status acpi_acquire_global_lock(u16 timeout, u32 * handle)
+acpi_status acpi_acquire_global_lock(u16 timeout, u32 *handle)
 {
         acpi_status status;
 
diff --git a/drivers/acpi/acpica/evxfevnt.c b/drivers/acpi/acpica/evxfevnt.c
index e286640ad4ff..bb8cbf5961bf 100644
--- a/drivers/acpi/acpica/evxfevnt.c
+++ b/drivers/acpi/acpica/evxfevnt.c
@@ -324,8 +324,9 @@ ACPI_EXPORT_SYMBOL(acpi_clear_event)
  ******************************************************************************/
 acpi_status acpi_get_event_status(u32 event, acpi_event_status * event_status)
 {
-        acpi_status status = AE_OK;
-        u32 value;
+        acpi_status status;
+        acpi_event_status local_event_status = 0;
+        u32 in_byte;
 
         ACPI_FUNCTION_TRACE(acpi_get_event_status);
 
@@ -339,29 +340,40 @@ acpi_status acpi_get_event_status(u32 event, acpi_event_status * event_status)
                 return_ACPI_STATUS(AE_BAD_PARAMETER);
         }
 
-        /* Get the status of the requested fixed event */
+        /* Fixed event currently can be dispatched? */
+
+        if (acpi_gbl_fixed_event_handlers[event].handler) {
+                local_event_status |= ACPI_EVENT_FLAG_HAS_HANDLER;
+        }
+
+        /* Fixed event currently enabled? */
 
         status =
             acpi_read_bit_register(acpi_gbl_fixed_event_info[event].
-                              enable_register_id, &value);
-        if (ACPI_FAILURE(status))
+                                   enable_register_id, &in_byte);
+        if (ACPI_FAILURE(status)) {
                 return_ACPI_STATUS(status);
+        }
 
-        *event_status = value;
+        if (in_byte) {
+                local_event_status |= ACPI_EVENT_FLAG_ENABLED;
+        }
+
+        /* Fixed event currently active? */
 
         status =
             acpi_read_bit_register(acpi_gbl_fixed_event_info[event].
-                              status_register_id, &value);
-        if (ACPI_FAILURE(status))
+                                   status_register_id, &in_byte);
+        if (ACPI_FAILURE(status)) {
                 return_ACPI_STATUS(status);
+        }
 
-        if (value)
-                *event_status |= ACPI_EVENT_FLAG_SET;
-
-        if (acpi_gbl_fixed_event_handlers[event].handler)
-                *event_status |= ACPI_EVENT_FLAG_HANDLE;
+        if (in_byte) {
+                local_event_status |= ACPI_EVENT_FLAG_SET;
+        }
 
-        return_ACPI_STATUS(status);
+        (*event_status) = local_event_status;
+        return_ACPI_STATUS(AE_OK);
 }
 
 ACPI_EXPORT_SYMBOL(acpi_get_event_status)
diff --git a/drivers/acpi/acpica/evxfgpe.c b/drivers/acpi/acpica/evxfgpe.c
index 56710a03c9b0..e889a5304abd 100644
--- a/drivers/acpi/acpica/evxfgpe.c
+++ b/drivers/acpi/acpica/evxfgpe.c
@@ -106,8 +106,8 @@ ACPI_EXPORT_SYMBOL(acpi_update_all_gpes)
  *
  * FUNCTION:    acpi_enable_gpe
  *
- * PARAMETERS:  gpe_device      - Parent GPE Device. NULL for GPE0/GPE1
- *              gpe_number      - GPE level within the GPE block
+ * PARAMETERS:  gpe_device          - Parent GPE Device. NULL for GPE0/GPE1
+ *              gpe_number          - GPE level within the GPE block
  *
  * RETURN:      Status
  *
@@ -115,7 +115,6 @@ ACPI_EXPORT_SYMBOL(acpi_update_all_gpes)
  *              hardware-enabled.
  *
  ******************************************************************************/
-
 acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number)
 {
         acpi_status status = AE_BAD_PARAMETER;
@@ -490,8 +489,8 @@ ACPI_EXPORT_SYMBOL(acpi_clear_gpe)
  *
  * FUNCTION:    acpi_get_gpe_status
  *
- * PARAMETERS:  gpe_device      - Parent GPE Device. NULL for GPE0/GPE1
- *              gpe_number      - GPE level within the GPE block
+ * PARAMETERS:  gpe_device          - Parent GPE Device. NULL for GPE0/GPE1
+ *              gpe_number          - GPE level within the GPE block
  *              event_status        - Where the current status of the event
  *                                    will be returned
  *
@@ -524,9 +523,6 @@ acpi_get_gpe_status(acpi_handle gpe_device,
 
         status = acpi_hw_get_gpe_status(gpe_event_info, event_status);
 
-        if (gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK)
-                *event_status |= ACPI_EVENT_FLAG_HANDLE;
-
 unlock_and_exit:
         acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
         return_ACPI_STATUS(status);
diff --git a/drivers/acpi/acpica/hwgpe.c b/drivers/acpi/acpica/hwgpe.c
index ea62d40fd161..48ac7b7b59cd 100644
--- a/drivers/acpi/acpica/hwgpe.c
+++ b/drivers/acpi/acpica/hwgpe.c
@@ -202,7 +202,7 @@ acpi_status acpi_hw_clear_gpe(struct acpi_gpe_event_info * gpe_event_info)
 
 acpi_status
 acpi_hw_get_gpe_status(struct acpi_gpe_event_info * gpe_event_info,
-                       acpi_event_status * event_status)
+                       acpi_event_status *event_status)
 {
         u32 in_byte;
         u32 register_bit;
@@ -216,6 +216,13 @@ acpi_hw_get_gpe_status(struct acpi_gpe_event_info * gpe_event_info,
                 return (AE_BAD_PARAMETER);
         }
 
+        /* GPE currently handled? */
+
+        if ((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) !=
+            ACPI_GPE_DISPATCH_NONE) {
+                local_event_status |= ACPI_EVENT_FLAG_HAS_HANDLER;
+        }
+
         /* Get the info block for the entire GPE register */
 
         gpe_register_info = gpe_event_info->register_info;
diff --git a/drivers/acpi/acpica/tbxfroot.c b/drivers/acpi/acpica/tbxfroot.c
index 65ab8fed3d5e..43a54af2b548 100644
--- a/drivers/acpi/acpica/tbxfroot.c
+++ b/drivers/acpi/acpica/tbxfroot.c
@@ -50,6 +50,36 @@ ACPI_MODULE_NAME("tbxfroot")
 
 /*******************************************************************************
  *
+ * FUNCTION:    acpi_tb_get_rsdp_length
+ *
+ * PARAMETERS:  rsdp                - Pointer to RSDP
+ *
+ * RETURN:      Table length
+ *
+ * DESCRIPTION: Get the length of the RSDP
+ *
+ ******************************************************************************/
+u32 acpi_tb_get_rsdp_length(struct acpi_table_rsdp *rsdp)
+{
+
+        if (!ACPI_VALIDATE_RSDP_SIG(rsdp->signature)) {
+
+                /* BAD Signature */
+
+                return (0);
+        }
+
+        /* "Length" field is available if table version >= 2 */
+
+        if (rsdp->revision >= 2) {
+                return (rsdp->length);
+        } else {
+                return (ACPI_RSDP_CHECKSUM_LENGTH);
+        }
+}
+
+/*******************************************************************************
+ *
  * FUNCTION:    acpi_tb_validate_rsdp
  *
  * PARAMETERS:  rsdp                - Pointer to unvalidated RSDP
@@ -59,7 +89,8 @@ ACPI_MODULE_NAME("tbxfroot")
  * DESCRIPTION: Validate the RSDP (ptr)
  *
  ******************************************************************************/
-acpi_status acpi_tb_validate_rsdp(struct acpi_table_rsdp *rsdp)
+
+acpi_status acpi_tb_validate_rsdp(struct acpi_table_rsdp * rsdp)
 {
 
         /*
diff --git a/drivers/acpi/device_pm.c b/drivers/acpi/device_pm.c
index bea6896be122..143ec6ea1468 100644
--- a/drivers/acpi/device_pm.c
+++ b/drivers/acpi/device_pm.c
@@ -343,6 +343,7 @@ int acpi_device_update_power(struct acpi_device *device, int *state_p)
 
         return 0;
 }
+EXPORT_SYMBOL_GPL(acpi_device_update_power);
 
 int acpi_bus_update_power(acpi_handle handle, int *state_p)
 {
@@ -710,7 +711,7 @@ int acpi_pm_device_run_wake(struct device *phys_dev, bool enable)
                 return -ENODEV;
         }
 
-        return acpi_device_wakeup(adev, enable, ACPI_STATE_S0);
+        return acpi_device_wakeup(adev, ACPI_STATE_S0, enable);
 }
 EXPORT_SYMBOL(acpi_pm_device_run_wake);
 #endif /* CONFIG_PM_RUNTIME */
diff --git a/drivers/acpi/ec.c b/drivers/acpi/ec.c
index cb6066c809ea..3d304ff7f095 100644
--- a/drivers/acpi/ec.c
+++ b/drivers/acpi/ec.c
@@ -128,12 +128,13 @@ static int EC_FLAGS_SKIP_DSDT_SCAN; /* Not all BIOS survive early DSDT scan */
 static int EC_FLAGS_CLEAR_ON_RESUME; /* Needs acpi_ec_clear() on boot/resume */
 
 /* --------------------------------------------------------------------------
-                             Transaction Management
-   -------------------------------------------------------------------------- */
+ *                           Transaction Management
+ * -------------------------------------------------------------------------- */
 
 static inline u8 acpi_ec_read_status(struct acpi_ec *ec)
 {
         u8 x = inb(ec->command_addr);
+
         pr_debug("EC_SC(R) = 0x%2.2x "
                  "SCI_EVT=%d BURST=%d CMD=%d IBF=%d OBF=%d\n",
                  x,
@@ -148,6 +149,7 @@ static inline u8 acpi_ec_read_status(struct acpi_ec *ec)
 static inline u8 acpi_ec_read_data(struct acpi_ec *ec)
 {
         u8 x = inb(ec->data_addr);
+
         pr_debug("EC_DATA(R) = 0x%2.2x\n", x);
         return x;
 }
@@ -164,10 +166,32 @@ static inline void acpi_ec_write_data(struct acpi_ec *ec, u8 data)
         outb(data, ec->data_addr);
 }
 
+#ifdef DEBUG
+static const char *acpi_ec_cmd_string(u8 cmd)
+{
+        switch (cmd) {
+        case 0x80:
+                return "RD_EC";
+        case 0x81:
+                return "WR_EC";
+        case 0x82:
+                return "BE_EC";
+        case 0x83:
+                return "BD_EC";
+        case 0x84:
+                return "QR_EC";
+        }
+        return "UNKNOWN";
+}
+#else
+#define acpi_ec_cmd_string(cmd)         "UNDEF"
+#endif
+
 static int ec_transaction_completed(struct acpi_ec *ec)
 {
         unsigned long flags;
         int ret = 0;
+
         spin_lock_irqsave(&ec->lock, flags);
         if (ec->curr && (ec->curr->flags & ACPI_EC_COMMAND_COMPLETE))
                 ret = 1;
@@ -181,7 +205,8 @@ static bool advance_transaction(struct acpi_ec *ec)
         u8 status;
         bool wakeup = false;
 
-        pr_debug("===== %s =====\n", in_interrupt() ? "IRQ" : "TASK");
+        pr_debug("===== %s (%d) =====\n",
+                 in_interrupt() ? "IRQ" : "TASK", smp_processor_id());
         status = acpi_ec_read_status(ec);
         t = ec->curr;
         if (!t)
@@ -198,7 +223,8 @@ static bool advance_transaction(struct acpi_ec *ec)
                                 if (t->rlen == t->ri) {
                                         t->flags |= ACPI_EC_COMMAND_COMPLETE;
                                         if (t->command == ACPI_EC_COMMAND_QUERY)
-                                                pr_debug("hardware QR_EC completion\n");
+                                                pr_debug("***** Command(%s) hardware completion *****\n",
+                                                         acpi_ec_cmd_string(t->command));
                                         wakeup = true;
                                 }
                         } else
@@ -221,7 +247,8 @@ static bool advance_transaction(struct acpi_ec *ec)
                         t->flags |= ACPI_EC_COMMAND_POLL;
                         t->rdata[t->ri++] = 0x00;
                         t->flags |= ACPI_EC_COMMAND_COMPLETE;
-                        pr_debug("software QR_EC completion\n");
+                        pr_debug("***** Command(%s) software completion *****\n",
+                                 acpi_ec_cmd_string(t->command));
                         wakeup = true;
                 } else if ((status & ACPI_EC_FLAG_IBF) == 0) {
                         acpi_ec_write_cmd(ec, t->command);
@@ -264,6 +291,7 @@ static int ec_poll(struct acpi_ec *ec)
 {
         unsigned long flags;
         int repeat = 5; /* number of command restarts */
+
         while (repeat--) {
                 unsigned long delay = jiffies +
                         msecs_to_jiffies(ec_delay);
@@ -296,18 +324,25 @@ static int acpi_ec_transaction_unlocked(struct acpi_ec *ec,
 {
         unsigned long tmp;
         int ret = 0;
+
         if (EC_FLAGS_MSI)
                 udelay(ACPI_EC_MSI_UDELAY);
         /* start transaction */
         spin_lock_irqsave(&ec->lock, tmp);
         /* following two actions should be kept atomic */
         ec->curr = t;
+        pr_debug("***** Command(%s) started *****\n",
+                 acpi_ec_cmd_string(t->command));
         start_transaction(ec);
         spin_unlock_irqrestore(&ec->lock, tmp);
         ret = ec_poll(ec);
         spin_lock_irqsave(&ec->lock, tmp);
-        if (ec->curr->command == ACPI_EC_COMMAND_QUERY)
+        if (ec->curr->command == ACPI_EC_COMMAND_QUERY) {
                 clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags);
+                pr_debug("***** Event stopped *****\n");
+        }
+        pr_debug("***** Command(%s) stopped *****\n",
+                 acpi_ec_cmd_string(t->command));
         ec->curr = NULL;
         spin_unlock_irqrestore(&ec->lock, tmp);
         return ret;
@@ -317,6 +352,7 @@ static int acpi_ec_transaction(struct acpi_ec *ec, struct transaction *t)
 {
         int status;
         u32 glk;
+
         if (!ec || (!t) || (t->wlen && !t->wdata) || (t->rlen && !t->rdata))
                 return -EINVAL;
         if (t->rdata)
@@ -333,8 +369,6 @@ static int acpi_ec_transaction(struct acpi_ec *ec, struct transaction *t)
                         goto unlock;
                 }
         }
-        pr_debug("transaction start (cmd=0x%02x, addr=0x%02x)\n",
-                        t->command, t->wdata ? t->wdata[0] : 0);
         /* disable GPE during transaction if storm is detected */
         if (test_bit(EC_FLAGS_GPE_STORM, &ec->flags)) {
                 /* It has to be disabled, so that it doesn't trigger. */
@@ -355,7 +389,6 @@ static int acpi_ec_transaction(struct acpi_ec *ec, struct transaction *t)
                         t->irq_count);
                 set_bit(EC_FLAGS_GPE_STORM, &ec->flags);
         }
-        pr_debug("transaction end\n");
         if (ec->global_lock)
                 acpi_release_global_lock(glk);
 unlock:
@@ -383,7 +416,7 @@ static int acpi_ec_burst_disable(struct acpi_ec *ec)
                                 acpi_ec_transaction(ec, &t) : 0;
 }
 
-static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 * data)
+static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 *data)
 {
         int result;
         u8 d;
@@ -419,10 +452,9 @@ int ec_read(u8 addr, u8 *val)
         if (!err) {
                 *val = temp_data;
                 return 0;
-        } else
-                return err;
+        }
+        return err;
 }
-
 EXPORT_SYMBOL(ec_read);
 
 int ec_write(u8 addr, u8 val)
@@ -436,22 +468,21 @@ int ec_write(u8 addr, u8 val)
 
         return err;
 }
-
 EXPORT_SYMBOL(ec_write);
 
 int ec_transaction(u8 command,
-                   const u8 * wdata, unsigned wdata_len,
-                   u8 * rdata, unsigned rdata_len)
+                   const u8 *wdata, unsigned wdata_len,
+                   u8 *rdata, unsigned rdata_len)
 {
         struct transaction t = {.command = command,
                                 .wdata = wdata, .rdata = rdata,
                                 .wlen = wdata_len, .rlen = rdata_len};
+
         if (!first_ec)
                 return -ENODEV;
 
         return acpi_ec_transaction(first_ec, &t);
 }
-
 EXPORT_SYMBOL(ec_transaction);
 
 /* Get the handle to the EC device */
@@ -461,7 +492,6 @@ acpi_handle ec_get_handle(void)
                 return NULL;
         return first_ec->handle;
 }
-
 EXPORT_SYMBOL(ec_get_handle);
 
 /*
@@ -525,13 +555,14 @@ void acpi_ec_unblock_transactions_early(void)
                 clear_bit(EC_FLAGS_BLOCKED, &first_ec->flags);
 }
 
-static int acpi_ec_query_unlocked(struct acpi_ec *ec, u8 * data)
+static int acpi_ec_query_unlocked(struct acpi_ec *ec, u8 *data)
 {
         int result;
         u8 d;
         struct transaction t = {.command = ACPI_EC_COMMAND_QUERY,
                                 .wdata = NULL, .rdata = &d,
                                 .wlen = 0, .rlen = 1};
+
         if (!ec || !data)
                 return -EINVAL;
         /*
@@ -557,6 +588,7 @@ int acpi_ec_add_query_handler(struct acpi_ec *ec, u8 query_bit,
 {
         struct acpi_ec_query_handler *handler =
             kzalloc(sizeof(struct acpi_ec_query_handler), GFP_KERNEL);
+
         if (!handler)
                 return -ENOMEM;
 
@@ -569,12 +601,12 @@ int acpi_ec_add_query_handler(struct acpi_ec *ec, u8 query_bit,
         mutex_unlock(&ec->mutex);
         return 0;
 }
-
 EXPORT_SYMBOL_GPL(acpi_ec_add_query_handler);
 
 void acpi_ec_remove_query_handler(struct acpi_ec *ec, u8 query_bit)
 {
         struct acpi_ec_query_handler *handler, *tmp;
+
         mutex_lock(&ec->mutex);
         list_for_each_entry_safe(handler, tmp, &ec->list, node) {
                 if (query_bit == handler->query_bit) {
@@ -584,20 +616,20 @@ void acpi_ec_remove_query_handler(struct acpi_ec *ec, u8 query_bit)
         }
         mutex_unlock(&ec->mutex);
 }
-
 EXPORT_SYMBOL_GPL(acpi_ec_remove_query_handler);
 
 static void acpi_ec_run(void *cxt)
 {
         struct acpi_ec_query_handler *handler = cxt;
+
         if (!handler)
                 return;
-        pr_debug("start query execution\n");
+        pr_debug("##### Query(0x%02x) started #####\n", handler->query_bit);
         if (handler->func)
                 handler->func(handler->data);
         else if (handler->handle)
                 acpi_evaluate_object(handler->handle, NULL, NULL, NULL);
-        pr_debug("stop query execution\n");
+        pr_debug("##### Query(0x%02x) stopped #####\n", handler->query_bit);
         kfree(handler);
 }
 
@@ -620,8 +652,8 @@ static int acpi_ec_sync_query(struct acpi_ec *ec, u8 *data)
                         if (!copy)
                                 return -ENOMEM;
                         memcpy(copy, handler, sizeof(*copy));
-                        pr_debug("push query execution (0x%2x) on queue\n",
-                                value);
+                        pr_debug("##### Query(0x%02x) scheduled #####\n",
+                                 handler->query_bit);
                         return acpi_os_execute((copy->func) ?
                                 OSL_NOTIFY_HANDLER : OSL_GPE_HANDLER,
                                 acpi_ec_run, copy);
@@ -633,6 +665,7 @@ static int acpi_ec_sync_query(struct acpi_ec *ec, u8 *data)
 static void acpi_ec_gpe_query(void *ec_cxt)
 {
         struct acpi_ec *ec = ec_cxt;
+
         if (!ec)
                 return;
         mutex_lock(&ec->mutex);
@@ -644,7 +677,7 @@ static int ec_check_sci(struct acpi_ec *ec, u8 state)
 {
         if (state & ACPI_EC_FLAG_SCI) {
                 if (!test_and_set_bit(EC_FLAGS_QUERY_PENDING, &ec->flags)) {
-                        pr_debug("push gpe query to the queue\n");
+                        pr_debug("***** Event started *****\n");
                         return acpi_os_execute(OSL_NOTIFY_HANDLER,
                                 acpi_ec_gpe_query, ec);
                 }
@@ -667,8 +700,8 @@ static u32 acpi_ec_gpe_handler(acpi_handle gpe_device,
 }
 
 /* --------------------------------------------------------------------------
-                             Address Space Management
-   -------------------------------------------------------------------------- */
+ *                           Address Space Management
+ * -------------------------------------------------------------------------- */
 
 static acpi_status
 acpi_ec_space_handler(u32 function, acpi_physical_address address,
@@ -699,27 +732,26 @@ acpi_ec_space_handler(u32 function, acpi_physical_address address,
         switch (result) {
         case -EINVAL:
                 return AE_BAD_PARAMETER;
-                break;
         case -ENODEV:
                 return AE_NOT_FOUND;
-                break;
         case -ETIME:
                 return AE_TIME;
-                break;
         default:
                 return AE_OK;
         }
 }
 
 /* --------------------------------------------------------------------------
-                               Driver Interface
-   -------------------------------------------------------------------------- */
+ *                             Driver Interface
+ * -------------------------------------------------------------------------- */
+
 static acpi_status
 ec_parse_io_ports(struct acpi_resource *resource, void *context);
 
 static struct acpi_ec *make_acpi_ec(void)
 {
         struct acpi_ec *ec = kzalloc(sizeof(struct acpi_ec), GFP_KERNEL);
+
         if (!ec)
                 return NULL;
         ec->flags = 1 << EC_FLAGS_QUERY_PENDING;
@@ -742,9 +774,8 @@ acpi_ec_register_query_methods(acpi_handle handle, u32 level,
 
         status = acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer);
 
-        if (ACPI_SUCCESS(status) && sscanf(node_name, "_Q%x", &value) == 1) {
+        if (ACPI_SUCCESS(status) && sscanf(node_name, "_Q%x", &value) == 1)
                 acpi_ec_add_query_handler(ec, value, handle, NULL, NULL);
-        }
         return AE_OK;
 }
 
@@ -753,7 +784,6 @@ ec_parse_device(acpi_handle handle, u32 Level, void *context, void **retval)
 {
         acpi_status status;
         unsigned long long tmp = 0;
-
         struct acpi_ec *ec = context;
 
         /* clear addr values, ec_parse_io_ports depend on it */
@@ -781,6 +811,7 @@ ec_parse_device(acpi_handle handle, u32 Level, void *context, void **retval)
 static int ec_install_handlers(struct acpi_ec *ec)
 {
         acpi_status status;
+
         if (test_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags))
                 return 0;
         status = acpi_install_gpe_handler(NULL, ec->gpe,
@@ -1078,7 +1109,8 @@ int __init acpi_ec_ecdt_probe(void)
                 boot_ec->data_addr = ecdt_ptr->data.address;
                 boot_ec->gpe = ecdt_ptr->gpe;
                 boot_ec->handle = ACPI_ROOT_OBJECT;
-                acpi_get_handle(ACPI_ROOT_OBJECT, ecdt_ptr->id, &boot_ec->handle);
+                acpi_get_handle(ACPI_ROOT_OBJECT, ecdt_ptr->id,
+                                &boot_ec->handle);
                 /* Don't trust ECDT, which comes from ASUSTek */
                 if (!EC_FLAGS_VALIDATE_ECDT)
                         goto install;
@@ -1162,6 +1194,5 @@ static void __exit acpi_ec_exit(void)
 {
 
         acpi_bus_unregister_driver(&acpi_ec_driver);
-        return;
 }
 #endif  /* 0 */
diff --git a/drivers/acpi/fan.c b/drivers/acpi/fan.c
index 5328b1090e08..caf9b76b7ef8 100644
--- a/drivers/acpi/fan.c
+++ b/drivers/acpi/fan.c
@@ -30,22 +30,19 @@
 #include <linux/uaccess.h>
 #include <linux/thermal.h>
 #include <linux/acpi.h>
-
-#define ACPI_FAN_CLASS                  "fan"
-#define ACPI_FAN_FILE_STATE             "state"
-
-#define _COMPONENT              ACPI_FAN_COMPONENT
-ACPI_MODULE_NAME("fan");
+#include <linux/platform_device.h>
+#include <linux/sort.h>
 
 MODULE_AUTHOR("Paul Diefenbaugh");
 MODULE_DESCRIPTION("ACPI Fan Driver");
 MODULE_LICENSE("GPL");
 
-static int acpi_fan_add(struct acpi_device *device);
-static int acpi_fan_remove(struct acpi_device *device);
+static int acpi_fan_probe(struct platform_device *pdev);
+static int acpi_fan_remove(struct platform_device *pdev);
 
 static const struct acpi_device_id fan_device_ids[] = {
         {"PNP0C0B", 0},
+        {"INT3404", 0},
         {"", 0},
 };
 MODULE_DEVICE_TABLE(acpi, fan_device_ids);
@@ -64,37 +61,100 @@ static struct dev_pm_ops acpi_fan_pm = {
 #define FAN_PM_OPS_PTR NULL
 #endif
 
-static struct acpi_driver acpi_fan_driver = {
-        .name = "fan",
-        .class = ACPI_FAN_CLASS,
-        .ids = fan_device_ids,
-        .ops = {
-                .add = acpi_fan_add,
-                .remove = acpi_fan_remove,
-                },
-        .drv.pm = FAN_PM_OPS_PTR,
+struct acpi_fan_fps {
+        u64 control;
+        u64 trip_point;
+        u64 speed;
+        u64 noise_level;
+        u64 power;
+};
+
+struct acpi_fan_fif {
+        u64 revision;
+        u64 fine_grain_ctrl;
+        u64 step_size;
+        u64 low_speed_notification;
+};
+
+struct acpi_fan {
+        bool acpi4;
+        struct acpi_fan_fif fif;
+        struct acpi_fan_fps *fps;
+        int fps_count;
+        struct thermal_cooling_device *cdev;
+};
+
+static struct platform_driver acpi_fan_driver = {
+        .probe = acpi_fan_probe,
+        .remove = acpi_fan_remove,
+        .driver = {
+                .name = "acpi-fan",
+                .acpi_match_table = fan_device_ids,
+                .pm = FAN_PM_OPS_PTR,
+        },
 };
 
 /* thermal cooling device callbacks */
 static int fan_get_max_state(struct thermal_cooling_device *cdev, unsigned long
                              *state)
 {
-        /* ACPI fan device only support two states: ON/OFF */
-        *state = 1;
+        struct acpi_device *device = cdev->devdata;
+        struct acpi_fan *fan = acpi_driver_data(device);
+
+        if (fan->acpi4)
+                *state = fan->fps_count - 1;
+        else
+                *state = 1;
         return 0;
 }
 
-static int fan_get_cur_state(struct thermal_cooling_device *cdev, unsigned long
-                             *state)
+static int fan_get_state_acpi4(struct acpi_device *device, unsigned long *state)
+{
+        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
+        struct acpi_fan *fan = acpi_driver_data(device);
+        union acpi_object *obj;
+        acpi_status status;
+        int control, i;
+
+        status = acpi_evaluate_object(device->handle, "_FST", NULL, &buffer);
+        if (ACPI_FAILURE(status)) {
+                dev_err(&device->dev, "Get fan state failed\n");
+                return status;
+        }
+
+        obj = buffer.pointer;
+        if (!obj || obj->type != ACPI_TYPE_PACKAGE ||
+            obj->package.count != 3 ||
+            obj->package.elements[1].type != ACPI_TYPE_INTEGER) {
+                dev_err(&device->dev, "Invalid _FST data\n");
+                status = -EINVAL;
+                goto err;
+        }
+
+        control = obj->package.elements[1].integer.value;
+        for (i = 0; i < fan->fps_count; i++) {
+                if (control == fan->fps[i].control)
+                        break;
+        }
+        if (i == fan->fps_count) {
+                dev_dbg(&device->dev, "Invalid control value returned\n");
+                status = -EINVAL;
+                goto err;
+        }
+
+        *state = i;
+
+err:
+        kfree(obj);
+        return status;
+}
+
+static int fan_get_state(struct acpi_device *device, unsigned long *state)
 {
-        struct acpi_device *device = cdev->devdata;
         int result;
         int acpi_state = ACPI_STATE_D0;
 
-        if (!device)
-                return -EINVAL;
-
-        result = acpi_bus_update_power(device->handle, &acpi_state);
+        result = acpi_device_update_power(device, &acpi_state);
         if (result)
                 return result;
 
@@ -103,21 +163,57 @@ static int fan_get_cur_state(struct thermal_cooling_device *cdev, unsigned long
         return 0;
 }
 
-static int
-fan_set_cur_state(struct thermal_cooling_device *cdev, unsigned long state)
+static int fan_get_cur_state(struct thermal_cooling_device *cdev, unsigned long
+                             *state)
 {
         struct acpi_device *device = cdev->devdata;
-        int result;
+        struct acpi_fan *fan = acpi_driver_data(device);
 
-        if (!device || (state != 0 && state != 1))
+        if (fan->acpi4)
+                return fan_get_state_acpi4(device, state);
+        else
+                return fan_get_state(device, state);
+}
+
+static int fan_set_state(struct acpi_device *device, unsigned long state)
+{
+        if (state != 0 && state != 1)
                 return -EINVAL;
 
-        result = acpi_bus_set_power(device->handle,
-                                state ? ACPI_STATE_D0 : ACPI_STATE_D3_COLD);
+        return acpi_device_set_power(device,
+                                     state ? ACPI_STATE_D0 : ACPI_STATE_D3_COLD);
+}
 
-        return result;
+static int fan_set_state_acpi4(struct acpi_device *device, unsigned long state)
+{
+        struct acpi_fan *fan = acpi_driver_data(device);
+        acpi_status status;
+
+        if (state >= fan->fps_count)
+                return -EINVAL;
+
+        status = acpi_execute_simple_method(device->handle, "_FSL",
+                                            fan->fps[state].control);
+        if (ACPI_FAILURE(status)) {
+                dev_dbg(&device->dev, "Failed to set state by _FSL\n");
+                return status;
+        }
+
+        return 0;
 }
 
+static int
+fan_set_cur_state(struct thermal_cooling_device *cdev, unsigned long state)
+{
+        struct acpi_device *device = cdev->devdata;
+        struct acpi_fan *fan = acpi_driver_data(device);
+
+        if (fan->acpi4)
+                return fan_set_state_acpi4(device, state);
+        else
+                return fan_set_state(device, state);
+ }
+
 static const struct thermal_cooling_device_ops fan_cooling_ops = {
         .get_max_state = fan_get_max_state,
         .get_cur_state = fan_get_cur_state,
@@ -129,21 +225,125 @@ static const struct thermal_cooling_device_ops fan_cooling_ops = {
  * --------------------------------------------------------------------------
 */
 
-static int acpi_fan_add(struct acpi_device *device)
+static bool acpi_fan_is_acpi4(struct acpi_device *device)
 {
-        int result = 0;
-        struct thermal_cooling_device *cdev;
+        return acpi_has_method(device->handle, "_FIF") &&
+               acpi_has_method(device->handle, "_FPS") &&
+               acpi_has_method(device->handle, "_FSL") &&
+               acpi_has_method(device->handle, "_FST");
+}
 
-        if (!device)
-                return -EINVAL;
+static int acpi_fan_get_fif(struct acpi_device *device)
+{
+        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
+        struct acpi_fan *fan = acpi_driver_data(device);
+        struct acpi_buffer format = { sizeof("NNNN"), "NNNN" };
+        struct acpi_buffer fif = { sizeof(fan->fif), &fan->fif };
+        union acpi_object *obj;
+        acpi_status status;
+
+        status = acpi_evaluate_object(device->handle, "_FIF", NULL, &buffer);
+        if (ACPI_FAILURE(status))
+                return status;
+
+        obj = buffer.pointer;
+        if (!obj || obj->type != ACPI_TYPE_PACKAGE) {
+                dev_err(&device->dev, "Invalid _FIF data\n");
+                status = -EINVAL;
+                goto err;
+        }
 
-        strcpy(acpi_device_name(device), "Fan");
-        strcpy(acpi_device_class(device), ACPI_FAN_CLASS);
+        status = acpi_extract_package(obj, &format, &fif);
+        if (ACPI_FAILURE(status)) {
+                dev_err(&device->dev, "Invalid _FIF element\n");
+                status = -EINVAL;
+        }
 
-        result = acpi_bus_update_power(device->handle, NULL);
-        if (result) {
-                dev_err(&device->dev, "Setting initial power state\n");
-                goto end;
+err:
+        kfree(obj);
+        return status;
+}
+
+static int acpi_fan_speed_cmp(const void *a, const void *b)
+{
+        const struct acpi_fan_fps *fps1 = a;
+        const struct acpi_fan_fps *fps2 = b;
+        return fps1->speed - fps2->speed;
+}
+
+static int acpi_fan_get_fps(struct acpi_device *device)
+{
+        struct acpi_fan *fan = acpi_driver_data(device);
+        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
+        union acpi_object *obj;
+        acpi_status status;
+        int i;
+
+        status = acpi_evaluate_object(device->handle, "_FPS", NULL, &buffer);
+        if (ACPI_FAILURE(status))
+                return status;
+
+        obj = buffer.pointer;
+        if (!obj || obj->type != ACPI_TYPE_PACKAGE || obj->package.count < 2) {
+                dev_err(&device->dev, "Invalid _FPS data\n");
+                status = -EINVAL;
+                goto err;
+        }
+
+        fan->fps_count = obj->package.count - 1; /* minus revision field */
+        fan->fps = devm_kzalloc(&device->dev,
+                                fan->fps_count * sizeof(struct acpi_fan_fps),
+                                GFP_KERNEL);
+        if (!fan->fps) {
+                dev_err(&device->dev, "Not enough memory\n");
+                status = -ENOMEM;
+                goto err;
+        }
+        for (i = 0; i < fan->fps_count; i++) {
+                struct acpi_buffer format = { sizeof("NNNNN"), "NNNNN" };
+                struct acpi_buffer fps = { sizeof(fan->fps[i]), &fan->fps[i] };
+                status = acpi_extract_package(&obj->package.elements[i + 1],
+                                              &format, &fps);
+                if (ACPI_FAILURE(status)) {
+                        dev_err(&device->dev, "Invalid _FPS element\n");
+                        break;
+                }
+        }
+
+        /* sort the state array according to fan speed in increase order */
+        sort(fan->fps, fan->fps_count, sizeof(*fan->fps),
+             acpi_fan_speed_cmp, NULL);
+
+err:
+        kfree(obj);
+        return status;
+}
+
+static int acpi_fan_probe(struct platform_device *pdev)
+{
+        int result = 0;
+        struct thermal_cooling_device *cdev;
+        struct acpi_fan *fan;
+        struct acpi_device *device = ACPI_COMPANION(&pdev->dev);
+
+        fan = devm_kzalloc(&pdev->dev, sizeof(*fan), GFP_KERNEL);
+        if (!fan) {
+                dev_err(&device->dev, "No memory for fan\n");
+                return -ENOMEM;
+        }
+        device->driver_data = fan;
+        platform_set_drvdata(pdev, fan);
+
+        if (acpi_fan_is_acpi4(device)) {
+                if (acpi_fan_get_fif(device) || acpi_fan_get_fps(device))
+                        goto end;
+                fan->acpi4 = true;
+        } else {
+                result = acpi_device_update_power(device, NULL);
+                if (result) {
+                        dev_err(&device->dev, "Setting initial power state\n");
+                        goto end;
+                }
         }
 
         cdev = thermal_cooling_device_register("Fan", device,
@@ -153,44 +353,32 @@ static int acpi_fan_add(struct acpi_device *device)
                 goto end;
         }
 
-        dev_dbg(&device->dev, "registered as cooling_device%d\n", cdev->id);
+        dev_dbg(&pdev->dev, "registered as cooling_device%d\n", cdev->id);
 
-        device->driver_data = cdev;
-        result = sysfs_create_link(&device->dev.kobj,
+        fan->cdev = cdev;
+        result = sysfs_create_link(&pdev->dev.kobj,
                                    &cdev->device.kobj,
                                    "thermal_cooling");
         if (result)
-                dev_err(&device->dev, "Failed to create sysfs link "
-                        "'thermal_cooling'\n");
+                dev_err(&pdev->dev, "Failed to create sysfs link 'thermal_cooling'\n");
 
         result = sysfs_create_link(&cdev->device.kobj,
-                                   &device->dev.kobj,
+                                   &pdev->dev.kobj,
                                    "device");
         if (result)
-                dev_err(&device->dev, "Failed to create sysfs link 'device'\n");
-
-        dev_info(&device->dev, "ACPI: %s [%s] (%s)\n",
-               acpi_device_name(device), acpi_device_bid(device),
-               !device->power.state ? "on" : "off");
+                dev_err(&pdev->dev, "Failed to create sysfs link 'device'\n");
 
 end:
         return result;
 }
 
-static int acpi_fan_remove(struct acpi_device *device)
+static int acpi_fan_remove(struct platform_device *pdev)
 {
-        struct thermal_cooling_device *cdev;
-
-        if (!device)
-                return -EINVAL;
-
-        cdev =  acpi_driver_data(device);
-        if (!cdev)
-                return -EINVAL;
+        struct acpi_fan *fan = platform_get_drvdata(pdev);
 
-        sysfs_remove_link(&device->dev.kobj, "thermal_cooling");
-        sysfs_remove_link(&cdev->device.kobj, "device");
-        thermal_cooling_device_unregister(cdev);
+        sysfs_remove_link(&pdev->dev.kobj, "thermal_cooling");
+        sysfs_remove_link(&fan->cdev->device.kobj, "device");
+        thermal_cooling_device_unregister(fan->cdev);
 
         return 0;
 }
@@ -198,10 +386,11 @@ static int acpi_fan_remove(struct acpi_device *device)
 #ifdef CONFIG_PM_SLEEP
 static int acpi_fan_suspend(struct device *dev)
 {
-        if (!dev)
-                return -EINVAL;
+        struct acpi_fan *fan = dev_get_drvdata(dev);
+        if (fan->acpi4)
+                return 0;
 
-        acpi_bus_set_power(to_acpi_device(dev)->handle, ACPI_STATE_D0);
+        acpi_device_set_power(ACPI_COMPANION(dev), ACPI_STATE_D0);
 
         return AE_OK;
 }
@@ -209,11 +398,12 @@ static int acpi_fan_suspend(struct device *dev)
 static int acpi_fan_resume(struct device *dev)
 {
         int result;
+        struct acpi_fan *fan = dev_get_drvdata(dev);
 
-        if (!dev)
-                return -EINVAL;
+        if (fan->acpi4)
+                return 0;
 
-        result = acpi_bus_update_power(to_acpi_device(dev)->handle, NULL);
+        result = acpi_device_update_power(ACPI_COMPANION(dev), NULL);
         if (result)
                 dev_err(dev, "Error updating fan power state\n");
 
@@ -221,4 +411,4 @@ static int acpi_fan_resume(struct device *dev)
 }
 #endif
 
-module_acpi_driver(acpi_fan_driver);
+module_platform_driver(acpi_fan_driver);
diff --git a/drivers/acpi/int340x_thermal.c b/drivers/acpi/int340x_thermal.c
new file mode 100644
index 000000000000..a27d31d1ba24
--- /dev/null
+++ b/drivers/acpi/int340x_thermal.c
@@ -0,0 +1,51 @@
+/*
+ * ACPI support for int340x thermal drivers
+ *
+ * Copyright (C) 2014, Intel Corporation
+ * Authors: Zhang Rui <rui.zhang@intel.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/acpi.h>
+#include <linux/module.h>
+
+#include "internal.h"
+
+#define DO_ENUMERATION 0x01
+static const struct acpi_device_id int340x_thermal_device_ids[] = {
+        {"INT3400", DO_ENUMERATION },
+        {"INT3401"},
+        {"INT3402"},
+        {"INT3403"},
+        {"INT3404"},
+        {"INT3406"},
+        {"INT3407"},
+        {"INT3408"},
+        {"INT3409"},
+        {"INT340A"},
+        {"INT340B"},
+        {""},
+};
+
+static int int340x_thermal_handler_attach(struct acpi_device *adev,
+                                        const struct acpi_device_id *id)
+{
+#if defined(CONFIG_INT340X_THERMAL) || defined(CONFIG_INT340X_THERMAL_MODULE)
+        if (id->driver_data == DO_ENUMERATION)
+                acpi_create_platform_device(adev);
+#endif
+        return 1;
+}
+
+static struct acpi_scan_handler int340x_thermal_handler = {
+        .ids = int340x_thermal_device_ids,
+        .attach = int340x_thermal_handler_attach,
+};
+
+void __init acpi_int340x_thermal_init(void)
+{
+        acpi_scan_add_handler(&int340x_thermal_handler);
+}
diff --git a/drivers/acpi/internal.h b/drivers/acpi/internal.h
index 4c5cf77e7576..447f6d679b29 100644
--- a/drivers/acpi/internal.h
+++ b/drivers/acpi/internal.h
@@ -31,6 +31,7 @@ void acpi_pci_link_init(void);
 void acpi_processor_init(void);
 void acpi_platform_init(void);
 void acpi_pnp_init(void);
+void acpi_int340x_thermal_init(void);
 int acpi_sysfs_init(void);
 void acpi_container_init(void);
 void acpi_memory_hotplug_init(void);
@@ -103,8 +104,6 @@ int acpi_power_get_inferred_state(struct acpi_device *device, int *state);
 int acpi_power_on_resources(struct acpi_device *device, int state);
 int acpi_power_transition(struct acpi_device *device, int state);
 
-int acpi_device_update_power(struct acpi_device *device, int *state_p);
-
 int acpi_wakeup_device_init(void);
 
 #ifdef CONFIG_ARCH_MIGHT_HAVE_ACPI_PDC
@@ -168,13 +167,6 @@ static inline void suspend_nvs_restore(void) {}
 #endif
 
 /*--------------------------------------------------------------------------
-                                Platform bus support
-  -------------------------------------------------------------------------- */
-struct platform_device;
-
-struct platform_device *acpi_create_platform_device(struct acpi_device *adev);
-
-/*--------------------------------------------------------------------------
                                         Video
   -------------------------------------------------------------------------- */
 #if defined(CONFIG_ACPI_VIDEO) || defined(CONFIG_ACPI_VIDEO_MODULE)
diff --git a/drivers/acpi/scan.c b/drivers/acpi/scan.c
index ae44d8654c82..d670158a26c5 100644
--- a/drivers/acpi/scan.c
+++ b/drivers/acpi/scan.c
@@ -1470,7 +1470,7 @@ static void acpi_wakeup_gpe_init(struct acpi_device *device)
         if (ACPI_FAILURE(status))
                 return;
 
-        wakeup->flags.run_wake = !!(event_status & ACPI_EVENT_FLAG_HANDLE);
+        wakeup->flags.run_wake = !!(event_status & ACPI_EVENT_FLAG_HAS_HANDLER);
 }
 
 static void acpi_bus_get_wakeup_device_flags(struct acpi_device *device)
@@ -2315,6 +2315,7 @@ int __init acpi_scan_init(void)
         acpi_container_init();
         acpi_memory_hotplug_init();
         acpi_pnp_init();
+        acpi_int340x_thermal_init();
 
         mutex_lock(&acpi_scan_lock);
         /*
diff --git a/drivers/acpi/sysfs.c b/drivers/acpi/sysfs.c
index 38cb9782d4b8..13e577c80201 100644
--- a/drivers/acpi/sysfs.c
+++ b/drivers/acpi/sysfs.c
@@ -537,7 +537,7 @@ static ssize_t counter_show(struct kobject *kobj,
         if (result)
                 goto end;
 
-        if (!(status & ACPI_EVENT_FLAG_HANDLE))
+        if (!(status & ACPI_EVENT_FLAG_HAS_HANDLER))
                 size += sprintf(buf + size, "   invalid");
         else if (status & ACPI_EVENT_FLAG_ENABLED)
                 size += sprintf(buf + size, "   enabled");
@@ -581,7 +581,7 @@ static ssize_t counter_set(struct kobject *kobj,
         if (result)
                 goto end;
 
-        if (!(status & ACPI_EVENT_FLAG_HANDLE)) {
+        if (!(status & ACPI_EVENT_FLAG_HAS_HANDLER)) {
                 printk(KERN_WARNING PREFIX
                        "Can not change Invalid GPE/Fixed Event status\n");
                 return -EINVAL;
diff --git a/drivers/acpi/thermal.c b/drivers/acpi/thermal.c
index 112817e963e0..d24fa1964eb8 100644
--- a/drivers/acpi/thermal.c
+++ b/drivers/acpi/thermal.c
@@ -528,7 +528,6 @@ static void acpi_thermal_check(void *data)
 }
 
 /* sys I/F for generic thermal sysfs support */
-#define KELVIN_TO_MILLICELSIUS(t, off) (((t) - (off)) * 100)
 
 static int thermal_get_temp(struct thermal_zone_device *thermal,
                             unsigned long *temp)
@@ -543,7 +542,8 @@ static int thermal_get_temp(struct thermal_zone_device *thermal,
         if (result)
                 return result;
 
-        *temp = KELVIN_TO_MILLICELSIUS(tz->temperature, tz->kelvin_offset);
+        *temp = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(tz->temperature,
+                                                        tz->kelvin_offset);
         return 0;
 }
 
@@ -647,7 +647,7 @@ static int thermal_get_trip_temp(struct thermal_zone_device *thermal,
 
         if (tz->trips.critical.flags.valid) {
                 if (!trip) {
-                        *temp = KELVIN_TO_MILLICELSIUS(
+                        *temp = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(
                                 tz->trips.critical.temperature,
                                 tz->kelvin_offset);
                         return 0;
@@ -657,7 +657,7 @@ static int thermal_get_trip_temp(struct thermal_zone_device *thermal,
 
         if (tz->trips.hot.flags.valid) {
                 if (!trip) {
-                        *temp = KELVIN_TO_MILLICELSIUS(
+                        *temp = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(
                                 tz->trips.hot.temperature,
                                 tz->kelvin_offset);
                         return 0;
@@ -667,7 +667,7 @@ static int thermal_get_trip_temp(struct thermal_zone_device *thermal,
 
         if (tz->trips.passive.flags.valid) {
                 if (!trip) {
-                        *temp = KELVIN_TO_MILLICELSIUS(
+                        *temp = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(
                                 tz->trips.passive.temperature,
                                 tz->kelvin_offset);
                         return 0;
@@ -678,7 +678,7 @@ static int thermal_get_trip_temp(struct thermal_zone_device *thermal,
         for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE &&
                 tz->trips.active[i].flags.valid; i++) {
                 if (!trip) {
-                        *temp = KELVIN_TO_MILLICELSIUS(
+                        *temp = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(
                                 tz->trips.active[i].temperature,
                                 tz->kelvin_offset);
                         return 0;
@@ -694,7 +694,7 @@ static int thermal_get_crit_temp(struct thermal_zone_device *thermal,
         struct acpi_thermal *tz = thermal->devdata;
 
         if (tz->trips.critical.flags.valid) {
-                *temperature = KELVIN_TO_MILLICELSIUS(
+                *temperature = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(
                                 tz->trips.critical.temperature,
                                 tz->kelvin_offset);
                 return 0;
@@ -714,8 +714,8 @@ static int thermal_get_trend(struct thermal_zone_device *thermal,
 
         if (type == THERMAL_TRIP_ACTIVE) {
                 unsigned long trip_temp;
-                unsigned long temp = KELVIN_TO_MILLICELSIUS(tz->temperature,
-                                                        tz->kelvin_offset);
+                unsigned long temp = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(
+                                        tz->temperature, tz->kelvin_offset);
                 if (thermal_get_trip_temp(thermal, trip, &trip_temp))
                         return -EINVAL;
 
diff --git a/drivers/acpi/utils.c b/drivers/acpi/utils.c
index 834f35c4bf8d..371ac12d25b1 100644
--- a/drivers/acpi/utils.c
+++ b/drivers/acpi/utils.c
@@ -149,6 +149,21 @@ acpi_extract_package(union acpi_object *package,
                                 break;
                         }
                         break;
+                case ACPI_TYPE_LOCAL_REFERENCE:
+                        switch (format_string[i]) {
+                        case 'R':
+                                size_required += sizeof(void *);
+                                tail_offset += sizeof(void *);
+                                break;
+                        default:
+                                printk(KERN_WARNING PREFIX "Invalid package element"
+                                              " [%d] got reference,"
+                                              " expecting [%c]\n",
+                                              i, format_string[i]);
+                                return AE_BAD_DATA;
+                                break;
+                        }
+                        break;
 
                 case ACPI_TYPE_PACKAGE:
                 default:
@@ -247,7 +262,18 @@ acpi_extract_package(union acpi_object *package,
                                 break;
                         }
                         break;
-
+                case ACPI_TYPE_LOCAL_REFERENCE:
+                        switch (format_string[i]) {
+                        case 'R':
+                                *(void **)head =
+                                    (void *)element->reference.handle;
+                                head += sizeof(void *);
+                                break;
+                        default:
+                                /* Should never get here */
+                                break;
+                        }
+                        break;
                 case ACPI_TYPE_PACKAGE:
                         /* TBD: handle nested packages... */
                 default:
diff --git a/drivers/char/random.c b/drivers/char/random.c
index 82759cef9043..04645c09fe5e 100644
--- a/drivers/char/random.c
+++ b/drivers/char/random.c
@@ -1106,7 +1106,7 @@ static void extract_buf(struct entropy_store *r, __u8 *out)
         __mix_pool_bytes(r, hash.w, sizeof(hash.w));
         spin_unlock_irqrestore(&r->lock, flags);
 
-        memset(workspace, 0, sizeof(workspace));
+        memzero_explicit(workspace, sizeof(workspace));
 
         /*
          * In case the hash function has some recognizable output
@@ -1118,7 +1118,7 @@ static void extract_buf(struct entropy_store *r, __u8 *out)
         hash.w[2] ^= rol32(hash.w[2], 16);
 
         memcpy(out, &hash, EXTRACT_SIZE);
-        memset(&hash, 0, sizeof(hash));
+        memzero_explicit(&hash, sizeof(hash));
 }
 
 /*
@@ -1175,7 +1175,7 @@ static ssize_t extract_entropy(struct entropy_store *r, void *buf,
         }
 
         /* Wipe data just returned from memory */
-        memset(tmp, 0, sizeof(tmp));
+        memzero_explicit(tmp, sizeof(tmp));
 
         return ret;
 }
@@ -1218,7 +1218,7 @@ static ssize_t extract_entropy_user(struct entropy_store *r, void __user *buf,
         }
 
         /* Wipe data just returned from memory */
-        memset(tmp, 0, sizeof(tmp));
+        memzero_explicit(tmp, sizeof(tmp));
 
         return ret;
 }
diff --git a/drivers/cpufreq/cpufreq-dt.c b/drivers/cpufreq/cpufreq-dt.c
index 6bbb8b913446..92c162af5045 100644
--- a/drivers/cpufreq/cpufreq-dt.c
+++ b/drivers/cpufreq/cpufreq-dt.c
@@ -18,6 +18,7 @@
 #include <linux/cpu.h>
 #include <linux/cpu_cooling.h>
 #include <linux/cpufreq.h>
+#include <linux/cpufreq-dt.h>
 #include <linux/cpumask.h>
 #include <linux/err.h>
 #include <linux/module.h>
@@ -146,8 +147,8 @@ try_again:
                         goto try_again;
                 }
 
-                dev_warn(cpu_dev, "failed to get cpu%d regulator: %ld\n",
-                         cpu, PTR_ERR(cpu_reg));
+                dev_dbg(cpu_dev, "no regulator for cpu%d: %ld\n",
+                        cpu, PTR_ERR(cpu_reg));
         }
 
         cpu_clk = clk_get(cpu_dev, NULL);
@@ -178,6 +179,7 @@ try_again:
 
 static int cpufreq_init(struct cpufreq_policy *policy)
 {
+        struct cpufreq_dt_platform_data *pd;
         struct cpufreq_frequency_table *freq_table;
         struct thermal_cooling_device *cdev;
         struct device_node *np;
@@ -265,9 +267,18 @@ static int cpufreq_init(struct cpufreq_policy *policy)
         policy->driver_data = priv;
 
         policy->clk = cpu_clk;
-        ret = cpufreq_generic_init(policy, freq_table, transition_latency);
-        if (ret)
+        ret = cpufreq_table_validate_and_show(policy, freq_table);
+        if (ret) {
+                dev_err(cpu_dev, "%s: invalid frequency table: %d\n", __func__,
+                        ret);
                 goto out_cooling_unregister;
+        }
+
+        policy->cpuinfo.transition_latency = transition_latency;
+
+        pd = cpufreq_get_driver_data();
+        if (pd && !pd->independent_clocks)
+                cpumask_setall(policy->cpus);
 
         of_node_put(np);
 
@@ -335,6 +346,8 @@ static int dt_cpufreq_probe(struct platform_device *pdev)
         if (!IS_ERR(cpu_reg))
                 regulator_put(cpu_reg);
 
+        dt_cpufreq_driver.driver_data = dev_get_platdata(&pdev->dev);
+
         ret = cpufreq_register_driver(&dt_cpufreq_driver);
         if (ret)
                 dev_err(cpu_dev, "failed register driver: %d\n", ret);
diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index 24bf76fba141..644b54e1e7d1 100644
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -512,7 +512,18 @@ show_one(cpuinfo_max_freq, cpuinfo.max_freq);
 show_one(cpuinfo_transition_latency, cpuinfo.transition_latency);
 show_one(scaling_min_freq, min);
 show_one(scaling_max_freq, max);
-show_one(scaling_cur_freq, cur);
+
+static ssize_t show_scaling_cur_freq(
+        struct cpufreq_policy *policy, char *buf)
+{
+        ssize_t ret;
+
+        if (cpufreq_driver && cpufreq_driver->setpolicy && cpufreq_driver->get)
+                ret = sprintf(buf, "%u\n", cpufreq_driver->get(policy->cpu));
+        else
+                ret = sprintf(buf, "%u\n", policy->cur);
+        return ret;
+}
 
 static int cpufreq_set_policy(struct cpufreq_policy *policy,
                                 struct cpufreq_policy *new_policy);
@@ -906,11 +917,11 @@ static int cpufreq_add_dev_interface(struct cpufreq_policy *policy,
                 if (ret)
                         goto err_out_kobj_put;
         }
-        if (has_target()) {
-                ret = sysfs_create_file(&policy->kobj, &scaling_cur_freq.attr);
-                if (ret)
-                        goto err_out_kobj_put;
-        }
+
+        ret = sysfs_create_file(&policy->kobj, &scaling_cur_freq.attr);
+        if (ret)
+                goto err_out_kobj_put;
+
         if (cpufreq_driver->bios_limit) {
                 ret = sysfs_create_file(&policy->kobj, &bios_limit.attr);
                 if (ret)
@@ -1731,6 +1742,21 @@ const char *cpufreq_get_current_driver(void)
 }
 EXPORT_SYMBOL_GPL(cpufreq_get_current_driver);
 
+/**
+ *      cpufreq_get_driver_data - return current driver data
+ *
+ *      Return the private data of the currently loaded cpufreq
+ *      driver, or NULL if no cpufreq driver is loaded.
+ */
+void *cpufreq_get_driver_data(void)
+{
+        if (cpufreq_driver)
+                return cpufreq_driver->driver_data;
+
+        return NULL;
+}
+EXPORT_SYMBOL_GPL(cpufreq_get_driver_data);
+
 /*********************************************************************
  *                     NOTIFIER LISTS INTERFACE                      *
  *********************************************************************/
diff --git a/drivers/cpufreq/highbank-cpufreq.c b/drivers/cpufreq/highbank-cpufreq.c
index ec399ad2f059..1608f7105c9f 100644
--- a/drivers/cpufreq/highbank-cpufreq.c
+++ b/drivers/cpufreq/highbank-cpufreq.c
@@ -19,7 +19,7 @@
 #include <linux/cpu.h>
 #include <linux/err.h>
 #include <linux/of.h>
-#include <linux/mailbox.h>
+#include <linux/pl320-ipc.h>
 #include <linux/platform_device.h>
 
 #define HB_CPUFREQ_CHANGE_NOTE  0x80000001
diff --git a/drivers/cpufreq/intel_pstate.c b/drivers/cpufreq/intel_pstate.c
index 0668b389c516..27bb6d3877ed 100644
--- a/drivers/cpufreq/intel_pstate.c
+++ b/drivers/cpufreq/intel_pstate.c
@@ -52,6 +52,17 @@ static inline int32_t div_fp(int32_t x, int32_t y)
         return div_s64((int64_t)x << FRAC_BITS, y);
 }
 
+static inline int ceiling_fp(int32_t x)
+{
+        int mask, ret;
+
+        ret = fp_toint(x);
+        mask = (1 << FRAC_BITS) - 1;
+        if (x & mask)
+                ret += 1;
+        return ret;
+}
+
 struct sample {
         int32_t core_pct_busy;
         u64 aperf;
@@ -64,6 +75,7 @@ struct pstate_data {
         int     current_pstate;
         int     min_pstate;
         int     max_pstate;
+        int     scaling;
         int     turbo_pstate;
 };
 
@@ -113,6 +125,7 @@ struct pstate_funcs {
         int (*get_max)(void);
         int (*get_min)(void);
         int (*get_turbo)(void);
+        int (*get_scaling)(void);
         void (*set)(struct cpudata*, int pstate);
         void (*get_vid)(struct cpudata *);
 };
@@ -138,6 +151,7 @@ struct perf_limits {
 
 static struct perf_limits limits = {
         .no_turbo = 0,
+        .turbo_disabled = 0,
         .max_perf_pct = 100,
         .max_perf = int_tofp(1),
         .min_perf_pct = 0,
@@ -218,6 +232,18 @@ static inline void intel_pstate_reset_all_pid(void)
         }
 }
 
+static inline void update_turbo_state(void)
+{
+        u64 misc_en;
+        struct cpudata *cpu;
+
+        cpu = all_cpu_data[0];
+        rdmsrl(MSR_IA32_MISC_ENABLE, misc_en);
+        limits.turbo_disabled =
+                (misc_en & MSR_IA32_MISC_ENABLE_TURBO_DISABLE ||
+                 cpu->pstate.max_pstate == cpu->pstate.turbo_pstate);
+}
+
 /************************** debugfs begin ************************/
 static int pid_param_set(void *data, u64 val)
 {
@@ -274,6 +300,20 @@ static void __init intel_pstate_debug_expose_params(void)
                 return sprintf(buf, "%u\n", limits.object);             \
         }
 
+static ssize_t show_no_turbo(struct kobject *kobj,
+                             struct attribute *attr, char *buf)
+{
+        ssize_t ret;
+
+        update_turbo_state();
+        if (limits.turbo_disabled)
+                ret = sprintf(buf, "%u\n", limits.turbo_disabled);
+        else
+                ret = sprintf(buf, "%u\n", limits.no_turbo);
+
+        return ret;
+}
+
 static ssize_t store_no_turbo(struct kobject *a, struct attribute *b,
                               const char *buf, size_t count)
 {
@@ -283,11 +323,14 @@ static ssize_t store_no_turbo(struct kobject *a, struct attribute *b,
         ret = sscanf(buf, "%u", &input);
         if (ret != 1)
                 return -EINVAL;
-        limits.no_turbo = clamp_t(int, input, 0 , 1);
+
+        update_turbo_state();
         if (limits.turbo_disabled) {
                 pr_warn("Turbo disabled by BIOS or unavailable on processor\n");
-                limits.no_turbo = limits.turbo_disabled;
+                return -EPERM;
         }
+        limits.no_turbo = clamp_t(int, input, 0, 1);
+
         return count;
 }
 
@@ -323,7 +366,6 @@ static ssize_t store_min_perf_pct(struct kobject *a, struct attribute *b,
         return count;
 }
 
-show_one(no_turbo, no_turbo);
 show_one(max_perf_pct, max_perf_pct);
 show_one(min_perf_pct, min_perf_pct);
 
@@ -394,7 +436,7 @@ static void byt_set_pstate(struct cpudata *cpudata, int pstate)
                 cpudata->vid.ratio);
 
         vid_fp = clamp_t(int32_t, vid_fp, cpudata->vid.min, cpudata->vid.max);
-        vid = fp_toint(vid_fp);
+        vid = ceiling_fp(vid_fp);
 
         if (pstate > cpudata->pstate.max_pstate)
                 vid = cpudata->vid.turbo;
@@ -404,6 +446,22 @@ static void byt_set_pstate(struct cpudata *cpudata, int pstate)
         wrmsrl(MSR_IA32_PERF_CTL, val);
 }
 
+#define BYT_BCLK_FREQS 5
+static int byt_freq_table[BYT_BCLK_FREQS] = { 833, 1000, 1333, 1167, 800};
+
+static int byt_get_scaling(void)
+{
+        u64 value;
+        int i;
+
+        rdmsrl(MSR_FSB_FREQ, value);
+        i = value & 0x3;
+
+        BUG_ON(i > BYT_BCLK_FREQS);
+
+        return byt_freq_table[i] * 100;
+}
+
 static void byt_get_vid(struct cpudata *cpudata)
 {
         u64 value;
@@ -449,6 +507,11 @@ static int core_get_turbo_pstate(void)
         return ret;
 }
 
+static inline int core_get_scaling(void)
+{
+        return 100000;
+}
+
 static void core_set_pstate(struct cpudata *cpudata, int pstate)
 {
         u64 val;
@@ -473,6 +536,7 @@ static struct cpu_defaults core_params = {
                 .get_max = core_get_max_pstate,
                 .get_min = core_get_min_pstate,
                 .get_turbo = core_get_turbo_pstate,
+                .get_scaling = core_get_scaling,
                 .set = core_set_pstate,
         },
 };
@@ -491,6 +555,7 @@ static struct cpu_defaults byt_params = {
                 .get_min = byt_get_min_pstate,
                 .get_turbo = byt_get_turbo_pstate,
                 .set = byt_set_pstate,
+                .get_scaling = byt_get_scaling,
                 .get_vid = byt_get_vid,
         },
 };
@@ -501,7 +566,7 @@ static void intel_pstate_get_min_max(struct cpudata *cpu, int *min, int *max)
         int max_perf_adj;
         int min_perf;
 
-        if (limits.no_turbo)
+        if (limits.no_turbo || limits.turbo_disabled)
                 max_perf = cpu->pstate.max_pstate;
 
         max_perf_adj = fp_toint(mul_fp(int_tofp(max_perf), limits.max_perf));
@@ -516,6 +581,8 @@ static void intel_pstate_set_pstate(struct cpudata *cpu, int pstate)
 {
         int max_perf, min_perf;
 
+        update_turbo_state();
+
         intel_pstate_get_min_max(cpu, &min_perf, &max_perf);
 
         pstate = clamp_t(int, pstate, min_perf, max_perf);
@@ -523,7 +590,7 @@ static void intel_pstate_set_pstate(struct cpudata *cpu, int pstate)
         if (pstate == cpu->pstate.current_pstate)
                 return;
 
-        trace_cpu_frequency(pstate * 100000, cpu->cpu);
+        trace_cpu_frequency(pstate * cpu->pstate.scaling, cpu->cpu);
 
         cpu->pstate.current_pstate = pstate;
 
@@ -535,6 +602,7 @@ static void intel_pstate_get_cpu_pstates(struct cpudata *cpu)
         cpu->pstate.min_pstate = pstate_funcs.get_min();
         cpu->pstate.max_pstate = pstate_funcs.get_max();
         cpu->pstate.turbo_pstate = pstate_funcs.get_turbo();
+        cpu->pstate.scaling = pstate_funcs.get_scaling();
 
         if (pstate_funcs.get_vid)
                 pstate_funcs.get_vid(cpu);
@@ -550,7 +618,9 @@ static inline void intel_pstate_calc_busy(struct cpudata *cpu)
         core_pct = div64_u64(core_pct, int_tofp(sample->mperf));
 
         sample->freq = fp_toint(
-                mul_fp(int_tofp(cpu->pstate.max_pstate * 1000), core_pct));
+                mul_fp(int_tofp(
+                        cpu->pstate.max_pstate * cpu->pstate.scaling / 100),
+                        core_pct));
 
         sample->core_pct_busy = (int32_t)core_pct;
 }
@@ -671,7 +741,9 @@ static int intel_pstate_init_cpu(unsigned int cpunum)
 {
         struct cpudata *cpu;
 
-        all_cpu_data[cpunum] = kzalloc(sizeof(struct cpudata), GFP_KERNEL);
+        if (!all_cpu_data[cpunum])
+                all_cpu_data[cpunum] = kzalloc(sizeof(struct cpudata),
+                                               GFP_KERNEL);
         if (!all_cpu_data[cpunum])
                 return -ENOMEM;
 
@@ -714,9 +786,10 @@ static int intel_pstate_set_policy(struct cpufreq_policy *policy)
         if (policy->policy == CPUFREQ_POLICY_PERFORMANCE) {
                 limits.min_perf_pct = 100;
                 limits.min_perf = int_tofp(1);
+                limits.max_policy_pct = 100;
                 limits.max_perf_pct = 100;
                 limits.max_perf = int_tofp(1);
-                limits.no_turbo = limits.turbo_disabled;
+                limits.no_turbo = 0;
                 return 0;
         }
         limits.min_perf_pct = (policy->min * 100) / policy->cpuinfo.max_freq;
@@ -751,15 +824,12 @@ static void intel_pstate_stop_cpu(struct cpufreq_policy *policy)
 
         del_timer_sync(&all_cpu_data[cpu_num]->timer);
         intel_pstate_set_pstate(cpu, cpu->pstate.min_pstate);
-        kfree(all_cpu_data[cpu_num]);
-        all_cpu_data[cpu_num] = NULL;
 }
 
 static int intel_pstate_cpu_init(struct cpufreq_policy *policy)
 {
         struct cpudata *cpu;
         int rc;
-        u64 misc_en;
 
         rc = intel_pstate_init_cpu(policy->cpu);
         if (rc)
@@ -767,23 +837,18 @@ static int intel_pstate_cpu_init(struct cpufreq_policy *policy)
 
         cpu = all_cpu_data[policy->cpu];
 
-        rdmsrl(MSR_IA32_MISC_ENABLE, misc_en);
-        if (misc_en & MSR_IA32_MISC_ENABLE_TURBO_DISABLE ||
-            cpu->pstate.max_pstate == cpu->pstate.turbo_pstate) {
-                limits.turbo_disabled = 1;
-                limits.no_turbo = 1;
-        }
         if (limits.min_perf_pct == 100 && limits.max_perf_pct == 100)
                 policy->policy = CPUFREQ_POLICY_PERFORMANCE;
         else
                 policy->policy = CPUFREQ_POLICY_POWERSAVE;
 
-        policy->min = cpu->pstate.min_pstate * 100000;
-        policy->max = cpu->pstate.turbo_pstate * 100000;
+        policy->min = cpu->pstate.min_pstate * cpu->pstate.scaling;
+        policy->max = cpu->pstate.turbo_pstate * cpu->pstate.scaling;
 
         /* cpuinfo and default policy values */
-        policy->cpuinfo.min_freq = cpu->pstate.min_pstate * 100000;
-        policy->cpuinfo.max_freq = cpu->pstate.turbo_pstate * 100000;
+        policy->cpuinfo.min_freq = cpu->pstate.min_pstate * cpu->pstate.scaling;
+        policy->cpuinfo.max_freq =
+                cpu->pstate.turbo_pstate * cpu->pstate.scaling;
         policy->cpuinfo.transition_latency = CPUFREQ_ETERNAL;
         cpumask_set_cpu(policy->cpu, policy->cpus);
 
@@ -841,6 +906,7 @@ static void copy_cpu_funcs(struct pstate_funcs *funcs)
         pstate_funcs.get_max   = funcs->get_max;
         pstate_funcs.get_min   = funcs->get_min;
         pstate_funcs.get_turbo = funcs->get_turbo;
+        pstate_funcs.get_scaling = funcs->get_scaling;
         pstate_funcs.set       = funcs->set;
         pstate_funcs.get_vid   = funcs->get_vid;
 }
diff --git a/drivers/cpuidle/Kconfig.mips b/drivers/cpuidle/Kconfig.mips
index 0e70ee28a5ca..4102be01d06a 100644
--- a/drivers/cpuidle/Kconfig.mips
+++ b/drivers/cpuidle/Kconfig.mips
@@ -3,7 +3,7 @@
 #
 config MIPS_CPS_CPUIDLE
         bool "CPU Idle driver for MIPS CPS platforms"
-        depends on CPU_IDLE
+        depends on CPU_IDLE && MIPS_CPS
         depends on SYS_SUPPORTS_MIPS_CPS
         select ARCH_NEEDS_CPU_IDLE_COUPLED if MIPS_MT
         select GENERIC_CLOCKEVENTS_BROADCAST if SMP
diff --git a/drivers/cpuidle/cpuidle-powernv.c b/drivers/cpuidle/cpuidle-powernv.c
index a64be578dab2..7d3a3497dd4c 100644
--- a/drivers/cpuidle/cpuidle-powernv.c
+++ b/drivers/cpuidle/cpuidle-powernv.c
@@ -163,7 +163,8 @@ static int powernv_add_idle_states(void)
         int nr_idle_states = 1; /* Snooze */
         int dt_idle_states;
         const __be32 *idle_state_flags;
-        u32 len_flags, flags;
+        const __be32 *idle_state_latency;
+        u32 len_flags, flags, latency_ns;
         int i;
 
         /* Currently we have snooze statically defined */
@@ -180,18 +181,32 @@ static int powernv_add_idle_states(void)
                 return nr_idle_states;
         }
 
+        idle_state_latency = of_get_property(power_mgt,
+                        "ibm,cpu-idle-state-latencies-ns", NULL);
+        if (!idle_state_latency) {
+                pr_warn("DT-PowerMgmt: missing ibm,cpu-idle-state-latencies-ns\n");
+                return nr_idle_states;
+        }
+
         dt_idle_states = len_flags / sizeof(u32);
 
         for (i = 0; i < dt_idle_states; i++) {
 
                 flags = be32_to_cpu(idle_state_flags[i]);
+
+                /* Cpuidle accepts exit_latency in us and we estimate
+                 * target residency to be 10x exit_latency
+                 */
+                latency_ns = be32_to_cpu(idle_state_latency[i]);
                 if (flags & IDLE_USE_INST_NAP) {
                         /* Add NAP state */
                         strcpy(powernv_states[nr_idle_states].name, "Nap");
                         strcpy(powernv_states[nr_idle_states].desc, "Nap");
                         powernv_states[nr_idle_states].flags = CPUIDLE_FLAG_TIME_VALID;
-                        powernv_states[nr_idle_states].exit_latency = 10;
-                        powernv_states[nr_idle_states].target_residency = 100;
+                        powernv_states[nr_idle_states].exit_latency =
+                                        ((unsigned int)latency_ns) / 1000;
+                        powernv_states[nr_idle_states].target_residency =
+                                        ((unsigned int)latency_ns / 100);
                         powernv_states[nr_idle_states].enter = &nap_loop;
                         nr_idle_states++;
                 }
@@ -202,8 +217,10 @@ static int powernv_add_idle_states(void)
                         strcpy(powernv_states[nr_idle_states].desc, "FastSleep");
                         powernv_states[nr_idle_states].flags =
                                 CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TIMER_STOP;
-                        powernv_states[nr_idle_states].exit_latency = 300;
-                        powernv_states[nr_idle_states].target_residency = 1000000;
+                        powernv_states[nr_idle_states].exit_latency =
+                                        ((unsigned int)latency_ns) / 1000;
+                        powernv_states[nr_idle_states].target_residency =
+                                        ((unsigned int)latency_ns / 100);
                         powernv_states[nr_idle_states].enter = &fastsleep_loop;
                         nr_idle_states++;
                 }
diff --git a/drivers/firmware/efi/efi.c b/drivers/firmware/efi/efi.c
index 64ecbb501c50..8590099ac148 100644
--- a/drivers/firmware/efi/efi.c
+++ b/drivers/firmware/efi/efi.c
@@ -41,6 +41,28 @@ struct efi __read_mostly efi = {
 };
 EXPORT_SYMBOL(efi);
 
+static bool disable_runtime;
+static int __init setup_noefi(char *arg)
+{
+        disable_runtime = true;
+        return 0;
+}
+early_param("noefi", setup_noefi);
+
+bool efi_runtime_disabled(void)
+{
+        return disable_runtime;
+}
+
+static int __init parse_efi_cmdline(char *str)
+{
+        if (parse_option_str(str, "noruntime"))
+                disable_runtime = true;
+
+        return 0;
+}
+early_param("efi", parse_efi_cmdline);
+
 static struct kobject *efi_kobj;
 static struct kobject *efivars_kobj;
 
@@ -423,3 +445,60 @@ int __init efi_get_fdt_params(struct efi_fdt_params *params, int verbose)
         return ret;
 }
 #endif /* CONFIG_EFI_PARAMS_FROM_FDT */
+
+static __initdata char memory_type_name[][20] = {
+        "Reserved",
+        "Loader Code",
+        "Loader Data",
+        "Boot Code",
+        "Boot Data",
+        "Runtime Code",
+        "Runtime Data",
+        "Conventional Memory",
+        "Unusable Memory",
+        "ACPI Reclaim Memory",
+        "ACPI Memory NVS",
+        "Memory Mapped I/O",
+        "MMIO Port Space",
+        "PAL Code"
+};
+
+char * __init efi_md_typeattr_format(char *buf, size_t size,
+                                     const efi_memory_desc_t *md)
+{
+        char *pos;
+        int type_len;
+        u64 attr;
+
+        pos = buf;
+        if (md->type >= ARRAY_SIZE(memory_type_name))
+                type_len = snprintf(pos, size, "[type=%u", md->type);
+        else
+                type_len = snprintf(pos, size, "[%-*s",
+                                    (int)(sizeof(memory_type_name[0]) - 1),
+                                    memory_type_name[md->type]);
+        if (type_len >= size)
+                return buf;
+
+        pos += type_len;
+        size -= type_len;
+
+        attr = md->attribute;
+        if (attr & ~(EFI_MEMORY_UC | EFI_MEMORY_WC | EFI_MEMORY_WT |
+                     EFI_MEMORY_WB | EFI_MEMORY_UCE | EFI_MEMORY_WP |
+                     EFI_MEMORY_RP | EFI_MEMORY_XP | EFI_MEMORY_RUNTIME))
+                snprintf(pos, size, "|attr=0x%016llx]",
+                         (unsigned long long)attr);
+        else
+                snprintf(pos, size, "|%3s|%2s|%2s|%2s|%3s|%2s|%2s|%2s|%2s]",
+                         attr & EFI_MEMORY_RUNTIME ? "RUN" : "",
+                         attr & EFI_MEMORY_XP      ? "XP"  : "",
+                         attr & EFI_MEMORY_RP      ? "RP"  : "",
+                         attr & EFI_MEMORY_WP      ? "WP"  : "",
+                         attr & EFI_MEMORY_UCE     ? "UCE" : "",
+                         attr & EFI_MEMORY_WB      ? "WB"  : "",
+                         attr & EFI_MEMORY_WT      ? "WT"  : "",
+                         attr & EFI_MEMORY_WC      ? "WC"  : "",
+                         attr & EFI_MEMORY_UC      ? "UC"  : "");
+        return buf;
+}
diff --git a/drivers/firmware/efi/libstub/arm-stub.c b/drivers/firmware/efi/libstub/arm-stub.c
index 480339b6b110..75ee05964cbc 100644
--- a/drivers/firmware/efi/libstub/arm-stub.c
+++ b/drivers/firmware/efi/libstub/arm-stub.c
@@ -226,6 +226,10 @@ unsigned long __init efi_entry(void *handle, efi_system_table_t *sys_table,
                 goto fail_free_image;
         }
 
+        status = efi_parse_options(cmdline_ptr);
+        if (status != EFI_SUCCESS)
+                pr_efi_err(sys_table, "Failed to parse EFI cmdline options\n");
+
         /*
          * Unauthenticated device tree data is a security hazard, so
          * ignore 'dtb=' unless UEFI Secure Boot is disabled.
diff --git a/drivers/firmware/efi/libstub/efi-stub-helper.c b/drivers/firmware/efi/libstub/efi-stub-helper.c
index 32d5cca30f49..a920fec8fe88 100644
--- a/drivers/firmware/efi/libstub/efi-stub-helper.c
+++ b/drivers/firmware/efi/libstub/efi-stub-helper.c
@@ -15,8 +15,23 @@
 
 #include "efistub.h"
 
+/*
+ * Some firmware implementations have problems reading files in one go.
+ * A read chunk size of 1MB seems to work for most platforms.
+ *
+ * Unfortunately, reading files in chunks triggers *other* bugs on some
+ * platforms, so we provide a way to disable this workaround, which can
+ * be done by passing "efi=nochunk" on the EFI boot stub command line.
+ *
+ * If you experience issues with initrd images being corrupt it's worth
+ * trying efi=nochunk, but chunking is enabled by default because there
+ * are far more machines that require the workaround than those that
+ * break with it enabled.
+ */
 #define EFI_READ_CHUNK_SIZE     (1024 * 1024)
 
+static unsigned long __chunk_size = EFI_READ_CHUNK_SIZE;
+
 struct file_info {
         efi_file_handle_t *handle;
         u64 size;
@@ -281,6 +296,49 @@ void efi_free(efi_system_table_t *sys_table_arg, unsigned long size,
         efi_call_early(free_pages, addr, nr_pages);
 }
 
+/*
+ * Parse the ASCII string 'cmdline' for EFI options, denoted by the efi=
+ * option, e.g. efi=nochunk.
+ *
+ * It should be noted that efi= is parsed in two very different
+ * environments, first in the early boot environment of the EFI boot
+ * stub, and subsequently during the kernel boot.
+ */
+efi_status_t efi_parse_options(char *cmdline)
+{
+        char *str;
+
+        /*
+         * If no EFI parameters were specified on the cmdline we've got
+         * nothing to do.
+         */
+        str = strstr(cmdline, "efi=");
+        if (!str)
+                return EFI_SUCCESS;
+
+        /* Skip ahead to first argument */
+        str += strlen("efi=");
+
+        /*
+         * Remember, because efi= is also used by the kernel we need to
+         * skip over arguments we don't understand.
+         */
+        while (*str) {
+                if (!strncmp(str, "nochunk", 7)) {
+                        str += strlen("nochunk");
+                        __chunk_size = -1UL;
+                }
+
+                /* Group words together, delimited by "," */
+                while (*str && *str != ',')
+                        str++;
+
+                if (*str == ',')
+                        str++;
+        }
+
+        return EFI_SUCCESS;
+}
 
 /*
  * Check the cmdline for a LILO-style file= arguments.
@@ -423,8 +481,8 @@ efi_status_t handle_cmdline_files(efi_system_table_t *sys_table_arg,
                         size = files[j].size;
                         while (size) {
                                 unsigned long chunksize;
-                                if (size > EFI_READ_CHUNK_SIZE)
-                                        chunksize = EFI_READ_CHUNK_SIZE;
+                                if (size > __chunk_size)
+                                        chunksize = __chunk_size;
                                 else
                                         chunksize = size;
 
diff --git a/drivers/firmware/efi/runtime-wrappers.c b/drivers/firmware/efi/runtime-wrappers.c
index 10daa4bbb258..228bbf910461 100644
--- a/drivers/firmware/efi/runtime-wrappers.c
+++ b/drivers/firmware/efi/runtime-wrappers.c
@@ -14,11 +14,80 @@
  * This file is released under the GPLv2.
  */
 
+#include <linux/bug.h>
 #include <linux/efi.h>
-#include <linux/spinlock.h>             /* spinlock_t */
+#include <linux/mutex.h>
+#include <linux/spinlock.h>
 #include <asm/efi.h>
 
 /*
+ * According to section 7.1 of the UEFI spec, Runtime Services are not fully
+ * reentrant, and there are particular combinations of calls that need to be
+ * serialized. (source: UEFI Specification v2.4A)
+ *
+ * Table 31. Rules for Reentry Into Runtime Services
+ * +------------------------------------+-------------------------------+
+ * | If previous call is busy in        | Forbidden to call             |
+ * +------------------------------------+-------------------------------+
+ * | Any                                | SetVirtualAddressMap()        |
+ * +------------------------------------+-------------------------------+
+ * | ConvertPointer()                   | ConvertPointer()              |
+ * +------------------------------------+-------------------------------+
+ * | SetVariable()                      | ResetSystem()                 |
+ * | UpdateCapsule()                    |                               |
+ * | SetTime()                          |                               |
+ * | SetWakeupTime()                    |                               |
+ * | GetNextHighMonotonicCount()        |                               |
+ * +------------------------------------+-------------------------------+
+ * | GetVariable()                      | GetVariable()                 |
+ * | GetNextVariableName()              | GetNextVariableName()         |
+ * | SetVariable()                      | SetVariable()                 |
+ * | QueryVariableInfo()                | QueryVariableInfo()           |
+ * | UpdateCapsule()                    | UpdateCapsule()               |
+ * | QueryCapsuleCapabilities()         | QueryCapsuleCapabilities()    |
+ * | GetNextHighMonotonicCount()        | GetNextHighMonotonicCount()   |
+ * +------------------------------------+-------------------------------+
+ * | GetTime()                          | GetTime()                     |
+ * | SetTime()                          | SetTime()                     |
+ * | GetWakeupTime()                    | GetWakeupTime()               |
+ * | SetWakeupTime()                    | SetWakeupTime()               |
+ * +------------------------------------+-------------------------------+
+ *
+ * Due to the fact that the EFI pstore may write to the variable store in
+ * interrupt context, we need to use a spinlock for at least the groups that
+ * contain SetVariable() and QueryVariableInfo(). That leaves little else, as
+ * none of the remaining functions are actually ever called at runtime.
+ * So let's just use a single spinlock to serialize all Runtime Services calls.
+ */
+static DEFINE_SPINLOCK(efi_runtime_lock);
+
+/*
+ * Some runtime services calls can be reentrant under NMI, even if the table
+ * above says they are not. (source: UEFI Specification v2.4A)
+ *
+ * Table 32. Functions that may be called after Machine Check, INIT and NMI
+ * +----------------------------+------------------------------------------+
+ * | Function                   | Called after Machine Check, INIT and NMI |
+ * +----------------------------+------------------------------------------+
+ * | GetTime()                  | Yes, even if previously busy.            |
+ * | GetVariable()              | Yes, even if previously busy             |
+ * | GetNextVariableName()      | Yes, even if previously busy             |
+ * | QueryVariableInfo()        | Yes, even if previously busy             |
+ * | SetVariable()              | Yes, even if previously busy             |
+ * | UpdateCapsule()            | Yes, even if previously busy             |
+ * | QueryCapsuleCapabilities() | Yes, even if previously busy             |
+ * | ResetSystem()              | Yes, even if previously busy             |
+ * +----------------------------+------------------------------------------+
+ *
+ * In order to prevent deadlocks under NMI, the wrappers for these functions
+ * may only grab the efi_runtime_lock or rtc_lock spinlocks if !efi_in_nmi().
+ * However, not all of the services listed are reachable through NMI code paths,
+ * so the the special handling as suggested by the UEFI spec is only implemented
+ * for QueryVariableInfo() and SetVariable(), as these can be reached in NMI
+ * context through efi_pstore_write().
+ */
+
+/*
  * As per commit ef68c8f87ed1 ("x86: Serialize EFI time accesses on rtc_lock"),
  * the EFI specification requires that callers of the time related runtime
  * functions serialize with other CMOS accesses in the kernel, as the EFI time
@@ -32,7 +101,9 @@ static efi_status_t virt_efi_get_time(efi_time_t *tm, efi_time_cap_t *tc)
         efi_status_t status;
 
         spin_lock_irqsave(&rtc_lock, flags);
+        spin_lock(&efi_runtime_lock);
         status = efi_call_virt(get_time, tm, tc);
+        spin_unlock(&efi_runtime_lock);
         spin_unlock_irqrestore(&rtc_lock, flags);
         return status;
 }
@@ -43,7 +114,9 @@ static efi_status_t virt_efi_set_time(efi_time_t *tm)
         efi_status_t status;
 
         spin_lock_irqsave(&rtc_lock, flags);
+        spin_lock(&efi_runtime_lock);
         status = efi_call_virt(set_time, tm);
+        spin_unlock(&efi_runtime_lock);
         spin_unlock_irqrestore(&rtc_lock, flags);
         return status;
 }
@@ -56,7 +129,9 @@ static efi_status_t virt_efi_get_wakeup_time(efi_bool_t *enabled,
         efi_status_t status;
 
         spin_lock_irqsave(&rtc_lock, flags);
+        spin_lock(&efi_runtime_lock);
         status = efi_call_virt(get_wakeup_time, enabled, pending, tm);
+        spin_unlock(&efi_runtime_lock);
         spin_unlock_irqrestore(&rtc_lock, flags);
         return status;
 }
@@ -67,7 +142,9 @@ static efi_status_t virt_efi_set_wakeup_time(efi_bool_t enabled, efi_time_t *tm)
         efi_status_t status;
 
         spin_lock_irqsave(&rtc_lock, flags);
+        spin_lock(&efi_runtime_lock);
         status = efi_call_virt(set_wakeup_time, enabled, tm);
+        spin_unlock(&efi_runtime_lock);
         spin_unlock_irqrestore(&rtc_lock, flags);
         return status;
 }
@@ -78,14 +155,27 @@ static efi_status_t virt_efi_get_variable(efi_char16_t *name,
                                           unsigned long *data_size,
                                           void *data)
 {
-        return efi_call_virt(get_variable, name, vendor, attr, data_size, data);
+        unsigned long flags;
+        efi_status_t status;
+
+        spin_lock_irqsave(&efi_runtime_lock, flags);
+        status = efi_call_virt(get_variable, name, vendor, attr, data_size,
+                               data);
+        spin_unlock_irqrestore(&efi_runtime_lock, flags);
+        return status;
 }
 
 static efi_status_t virt_efi_get_next_variable(unsigned long *name_size,
                                                efi_char16_t *name,
                                                efi_guid_t *vendor)
 {
-        return efi_call_virt(get_next_variable, name_size, name, vendor);
+        unsigned long flags;
+        efi_status_t status;
+
+        spin_lock_irqsave(&efi_runtime_lock, flags);
+        status = efi_call_virt(get_next_variable, name_size, name, vendor);
+        spin_unlock_irqrestore(&efi_runtime_lock, flags);
+        return status;
 }
 
 static efi_status_t virt_efi_set_variable(efi_char16_t *name,
@@ -94,24 +184,61 @@ static efi_status_t virt_efi_set_variable(efi_char16_t *name,
                                           unsigned long data_size,
                                           void *data)
 {
-        return efi_call_virt(set_variable, name, vendor, attr, data_size, data);
+        unsigned long flags;
+        efi_status_t status;
+
+        spin_lock_irqsave(&efi_runtime_lock, flags);
+        status = efi_call_virt(set_variable, name, vendor, attr, data_size,
+                               data);
+        spin_unlock_irqrestore(&efi_runtime_lock, flags);
+        return status;
 }
 
+static efi_status_t
+virt_efi_set_variable_nonblocking(efi_char16_t *name, efi_guid_t *vendor,
+                                  u32 attr, unsigned long data_size,
+                                  void *data)
+{
+        unsigned long flags;
+        efi_status_t status;
+
+        if (!spin_trylock_irqsave(&efi_runtime_lock, flags))
+                return EFI_NOT_READY;
+
+        status = efi_call_virt(set_variable, name, vendor, attr, data_size,
+                               data);
+        spin_unlock_irqrestore(&efi_runtime_lock, flags);
+        return status;
+}
+
+
 static efi_status_t virt_efi_query_variable_info(u32 attr,
                                                  u64 *storage_space,
                                                  u64 *remaining_space,
                                                  u64 *max_variable_size)
 {
+        unsigned long flags;
+        efi_status_t status;
+
         if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
                 return EFI_UNSUPPORTED;
 
-        return efi_call_virt(query_variable_info, attr, storage_space,
-                             remaining_space, max_variable_size);
+        spin_lock_irqsave(&efi_runtime_lock, flags);
+        status = efi_call_virt(query_variable_info, attr, storage_space,
+                               remaining_space, max_variable_size);
+        spin_unlock_irqrestore(&efi_runtime_lock, flags);
+        return status;
 }
 
 static efi_status_t virt_efi_get_next_high_mono_count(u32 *count)
 {
-        return efi_call_virt(get_next_high_mono_count, count);
+        unsigned long flags;
+        efi_status_t status;
+
+        spin_lock_irqsave(&efi_runtime_lock, flags);
+        status = efi_call_virt(get_next_high_mono_count, count);
+        spin_unlock_irqrestore(&efi_runtime_lock, flags);
+        return status;
 }
 
 static void virt_efi_reset_system(int reset_type,
@@ -119,17 +246,27 @@ static void virt_efi_reset_system(int reset_type,
                                   unsigned long data_size,
                                   efi_char16_t *data)
 {
+        unsigned long flags;
+
+        spin_lock_irqsave(&efi_runtime_lock, flags);
         __efi_call_virt(reset_system, reset_type, status, data_size, data);
+        spin_unlock_irqrestore(&efi_runtime_lock, flags);
 }
 
 static efi_status_t virt_efi_update_capsule(efi_capsule_header_t **capsules,
                                             unsigned long count,
                                             unsigned long sg_list)
 {
+        unsigned long flags;
+        efi_status_t status;
+
         if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
                 return EFI_UNSUPPORTED;
 
-        return efi_call_virt(update_capsule, capsules, count, sg_list);
+        spin_lock_irqsave(&efi_runtime_lock, flags);
+        status = efi_call_virt(update_capsule, capsules, count, sg_list);
+        spin_unlock_irqrestore(&efi_runtime_lock, flags);
+        return status;
 }
 
 static efi_status_t virt_efi_query_capsule_caps(efi_capsule_header_t **capsules,
@@ -137,11 +274,17 @@ static efi_status_t virt_efi_query_capsule_caps(efi_capsule_header_t **capsules,
                                                 u64 *max_size,
                                                 int *reset_type)
 {
+        unsigned long flags;
+        efi_status_t status;
+
         if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
                 return EFI_UNSUPPORTED;
 
-        return efi_call_virt(query_capsule_caps, capsules, count, max_size,
-                             reset_type);
+        spin_lock_irqsave(&efi_runtime_lock, flags);
+        status = efi_call_virt(query_capsule_caps, capsules, count, max_size,
+                               reset_type);
+        spin_unlock_irqrestore(&efi_runtime_lock, flags);
+        return status;
 }
 
 void efi_native_runtime_setup(void)
@@ -153,6 +296,7 @@ void efi_native_runtime_setup(void)
         efi.get_variable = virt_efi_get_variable;
         efi.get_next_variable = virt_efi_get_next_variable;
         efi.set_variable = virt_efi_set_variable;
+        efi.set_variable_nonblocking = virt_efi_set_variable_nonblocking;
         efi.get_next_high_mono_count = virt_efi_get_next_high_mono_count;
         efi.reset_system = virt_efi_reset_system;
         efi.query_variable_info = virt_efi_query_variable_info;
diff --git a/drivers/firmware/efi/vars.c b/drivers/firmware/efi/vars.c
index 5abe943e3404..70a0fb10517f 100644
--- a/drivers/firmware/efi/vars.c
+++ b/drivers/firmware/efi/vars.c
@@ -321,11 +321,11 @@ static unsigned long var_name_strnsize(efi_char16_t *variable_name,
  * Print a warning when duplicate EFI variables are encountered and
  * disable the sysfs workqueue since the firmware is buggy.
  */
-static void dup_variable_bug(efi_char16_t *s16, efi_guid_t *vendor_guid,
+static void dup_variable_bug(efi_char16_t *str16, efi_guid_t *vendor_guid,
                              unsigned long len16)
 {
         size_t i, len8 = len16 / sizeof(efi_char16_t);
-        char *s8;
+        char *str8;
 
         /*
          * Disable the workqueue since the algorithm it uses for
@@ -334,16 +334,16 @@ static void dup_variable_bug(efi_char16_t *s16, efi_guid_t *vendor_guid,
          */
         efivar_wq_enabled = false;
 
-        s8 = kzalloc(len8, GFP_KERNEL);
-        if (!s8)
+        str8 = kzalloc(len8, GFP_KERNEL);
+        if (!str8)
                 return;
 
         for (i = 0; i < len8; i++)
-                s8[i] = s16[i];
+                str8[i] = str16[i];
 
         printk(KERN_WARNING "efivars: duplicate variable: %s-%pUl\n",
-               s8, vendor_guid);
-        kfree(s8);
+               str8, vendor_guid);
+        kfree(str8);
 }
 
 /**
@@ -595,6 +595,39 @@ int efivar_entry_set(struct efivar_entry *entry, u32 attributes,
 }
 EXPORT_SYMBOL_GPL(efivar_entry_set);
 
+/*
+ * efivar_entry_set_nonblocking - call set_variable_nonblocking()
+ *
+ * This function is guaranteed to not block and is suitable for calling
+ * from crash/panic handlers.
+ *
+ * Crucially, this function will not block if it cannot acquire
+ * __efivars->lock. Instead, it returns -EBUSY.
+ */
+static int
+efivar_entry_set_nonblocking(efi_char16_t *name, efi_guid_t vendor,
+                             u32 attributes, unsigned long size, void *data)
+{
+        const struct efivar_operations *ops = __efivars->ops;
+        unsigned long flags;
+        efi_status_t status;
+
+        if (!spin_trylock_irqsave(&__efivars->lock, flags))
+                return -EBUSY;
+
+        status = check_var_size(attributes, size + ucs2_strsize(name, 1024));
+        if (status != EFI_SUCCESS) {
+                spin_unlock_irqrestore(&__efivars->lock, flags);
+                return -ENOSPC;
+        }
+
+        status = ops->set_variable_nonblocking(name, &vendor, attributes,
+                                               size, data);
+
+        spin_unlock_irqrestore(&__efivars->lock, flags);
+        return efi_status_to_err(status);
+}
+
 /**
  * efivar_entry_set_safe - call set_variable() if enough space in firmware
  * @name: buffer containing the variable name
@@ -622,6 +655,20 @@ int efivar_entry_set_safe(efi_char16_t *name, efi_guid_t vendor, u32 attributes,
         if (!ops->query_variable_store)
                 return -ENOSYS;
 
+        /*
+         * If the EFI variable backend provides a non-blocking
+         * ->set_variable() operation and we're in a context where we
+         * cannot block, then we need to use it to avoid live-locks,
+         * since the implication is that the regular ->set_variable()
+         * will block.
+         *
+         * If no ->set_variable_nonblocking() is provided then
+         * ->set_variable() is assumed to be non-blocking.
+         */
+        if (!block && ops->set_variable_nonblocking)
+                return efivar_entry_set_nonblocking(name, vendor, attributes,
+                                                    size, data);
+
         if (!block) {
                 if (!spin_trylock_irqsave(&__efivars->lock, flags))
                         return -EBUSY;
diff --git a/drivers/gpu/drm/cirrus/cirrus_drv.c b/drivers/gpu/drm/cirrus/cirrus_drv.c
index e705335101a5..c2a1cba1e984 100644
--- a/drivers/gpu/drm/cirrus/cirrus_drv.c
+++ b/drivers/gpu/drm/cirrus/cirrus_drv.c
@@ -32,6 +32,8 @@ static struct drm_driver driver;
 static const struct pci_device_id pciidlist[] = {
         { PCI_VENDOR_ID_CIRRUS, PCI_DEVICE_ID_CIRRUS_5446, 0x1af4, 0x1100, 0,
           0, 0 },
+        { PCI_VENDOR_ID_CIRRUS, PCI_DEVICE_ID_CIRRUS_5446, PCI_VENDOR_ID_XEN,
+          0x0001, 0, 0, 0 },
         {0,}
 };
 
diff --git a/drivers/gpu/drm/i915/i915_irq.c b/drivers/gpu/drm/i915/i915_irq.c
index 3201986bf25e..f66392b6e287 100644
--- a/drivers/gpu/drm/i915/i915_irq.c
+++ b/drivers/gpu/drm/i915/i915_irq.c
@@ -1711,7 +1711,7 @@ static irqreturn_t gen8_gt_irq_handler(struct drm_device *dev,
 #define HPD_STORM_DETECT_PERIOD 1000
 #define HPD_STORM_THRESHOLD 5
 
-static int ilk_port_to_hotplug_shift(enum port port)
+static int pch_port_to_hotplug_shift(enum port port)
 {
         switch (port) {
         case PORT_A:
@@ -1727,7 +1727,7 @@ static int ilk_port_to_hotplug_shift(enum port port)
         }
 }
 
-static int g4x_port_to_hotplug_shift(enum port port)
+static int i915_port_to_hotplug_shift(enum port port)
 {
         switch (port) {
         case PORT_A:
@@ -1785,12 +1785,12 @@ static inline void intel_hpd_irq_handler(struct drm_device *dev,
                 if (port && dev_priv->hpd_irq_port[port]) {
                         bool long_hpd;
 
-                        if (IS_G4X(dev)) {
-                                dig_shift = g4x_port_to_hotplug_shift(port);
-                                long_hpd = (hotplug_trigger >> dig_shift) & PORTB_HOTPLUG_LONG_DETECT;
-                        } else {
-                                dig_shift = ilk_port_to_hotplug_shift(port);
+                        if (HAS_PCH_SPLIT(dev)) {
+                                dig_shift = pch_port_to_hotplug_shift(port);
                                 long_hpd = (dig_hotplug_reg >> dig_shift) & PORTB_HOTPLUG_LONG_DETECT;
+                        } else {
+                                dig_shift = i915_port_to_hotplug_shift(port);
+                                long_hpd = (hotplug_trigger >> dig_shift) & PORTB_HOTPLUG_LONG_DETECT;
                         }
 
                         DRM_DEBUG_DRIVER("digital hpd port %c - %s\n",
@@ -3458,12 +3458,13 @@ static void gen8_irq_reset(struct drm_device *dev)
 void gen8_irq_power_well_post_enable(struct drm_i915_private *dev_priv)
 {
         unsigned long irqflags;
+        uint32_t extra_ier = GEN8_PIPE_VBLANK | GEN8_PIPE_FIFO_UNDERRUN;
 
         spin_lock_irqsave(&dev_priv->irq_lock, irqflags);
         GEN8_IRQ_INIT_NDX(DE_PIPE, PIPE_B, dev_priv->de_irq_mask[PIPE_B],
-                          ~dev_priv->de_irq_mask[PIPE_B]);
+                          ~dev_priv->de_irq_mask[PIPE_B] | extra_ier);
         GEN8_IRQ_INIT_NDX(DE_PIPE, PIPE_C, dev_priv->de_irq_mask[PIPE_C],
-                          ~dev_priv->de_irq_mask[PIPE_C]);
+                          ~dev_priv->de_irq_mask[PIPE_C] | extra_ier);
         spin_unlock_irqrestore(&dev_priv->irq_lock, irqflags);
 }
 
diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c
index 507370513f3d..c9e220963a78 100644
--- a/drivers/gpu/drm/i915/intel_display.c
+++ b/drivers/gpu/drm/i915/intel_display.c
@@ -73,9 +73,6 @@ static const uint32_t intel_cursor_formats[] = {
         DRM_FORMAT_ARGB8888,
 };
 
-#define DIV_ROUND_CLOSEST_ULL(ll, d)    \
-({ unsigned long long _tmp = (ll)+(d)/2; do_div(_tmp, d); _tmp; })
-
 static void intel_increase_pllclock(struct drm_device *dev,
                                     enum pipe pipe);
 static void intel_crtc_update_cursor(struct drm_crtc *crtc, bool on);
@@ -12357,27 +12354,36 @@ static void intel_setup_outputs(struct drm_device *dev)
                 if (I915_READ(PCH_DP_D) & DP_DETECTED)
                         intel_dp_init(dev, PCH_DP_D, PORT_D);
         } else if (IS_VALLEYVIEW(dev)) {
-                if (I915_READ(VLV_DISPLAY_BASE + GEN4_HDMIB) & SDVO_DETECTED) {
+                /*
+                 * The DP_DETECTED bit is the latched state of the DDC
+                 * SDA pin at boot. However since eDP doesn't require DDC
+                 * (no way to plug in a DP->HDMI dongle) the DDC pins for
+                 * eDP ports may have been muxed to an alternate function.
+                 * Thus we can't rely on the DP_DETECTED bit alone to detect
+                 * eDP ports. Consult the VBT as well as DP_DETECTED to
+                 * detect eDP ports.
+                 */
+                if (I915_READ(VLV_DISPLAY_BASE + GEN4_HDMIB) & SDVO_DETECTED)
                         intel_hdmi_init(dev, VLV_DISPLAY_BASE + GEN4_HDMIB,
                                         PORT_B);
-                        if (I915_READ(VLV_DISPLAY_BASE + DP_B) & DP_DETECTED)
-                                intel_dp_init(dev, VLV_DISPLAY_BASE + DP_B, PORT_B);
-                }
+                if (I915_READ(VLV_DISPLAY_BASE + DP_B) & DP_DETECTED ||
+                    intel_dp_is_edp(dev, PORT_B))
+                        intel_dp_init(dev, VLV_DISPLAY_BASE + DP_B, PORT_B);
 
-                if (I915_READ(VLV_DISPLAY_BASE + GEN4_HDMIC) & SDVO_DETECTED) {
+                if (I915_READ(VLV_DISPLAY_BASE + GEN4_HDMIC) & SDVO_DETECTED)
                         intel_hdmi_init(dev, VLV_DISPLAY_BASE + GEN4_HDMIC,
                                         PORT_C);
-                        if (I915_READ(VLV_DISPLAY_BASE + DP_C) & DP_DETECTED)
-                                intel_dp_init(dev, VLV_DISPLAY_BASE + DP_C, PORT_C);
-                }
+                if (I915_READ(VLV_DISPLAY_BASE + DP_C) & DP_DETECTED ||
+                    intel_dp_is_edp(dev, PORT_C))
+                        intel_dp_init(dev, VLV_DISPLAY_BASE + DP_C, PORT_C);
 
                 if (IS_CHERRYVIEW(dev)) {
-                        if (I915_READ(VLV_DISPLAY_BASE + CHV_HDMID) & SDVO_DETECTED) {
+                        if (I915_READ(VLV_DISPLAY_BASE + CHV_HDMID) & SDVO_DETECTED)
                                 intel_hdmi_init(dev, VLV_DISPLAY_BASE + CHV_HDMID,
                                                 PORT_D);
-                                if (I915_READ(VLV_DISPLAY_BASE + DP_D) & DP_DETECTED)
-                                        intel_dp_init(dev, VLV_DISPLAY_BASE + DP_D, PORT_D);
-                        }
+                        /* eDP not supported on port D, so don't check VBT */
+                        if (I915_READ(VLV_DISPLAY_BASE + DP_D) & DP_DETECTED)
+                                intel_dp_init(dev, VLV_DISPLAY_BASE + DP_D, PORT_D);
                 }
 
                 intel_dsi_init(dev);
diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h
index 07ce04683c30..ba715229a540 100644
--- a/drivers/gpu/drm/i915/intel_drv.h
+++ b/drivers/gpu/drm/i915/intel_drv.h
@@ -35,6 +35,9 @@
 #include <drm/drm_fb_helper.h>
 #include <drm/drm_dp_mst_helper.h>
 
+#define DIV_ROUND_CLOSEST_ULL(ll, d)    \
+({ unsigned long long _tmp = (ll)+(d)/2; do_div(_tmp, d); _tmp; })
+
 /**
  * _wait_for - magic (register) wait macro
  *
diff --git a/drivers/gpu/drm/i915/intel_panel.c b/drivers/gpu/drm/i915/intel_panel.c
index 18784470a760..0e018cb49147 100644
--- a/drivers/gpu/drm/i915/intel_panel.c
+++ b/drivers/gpu/drm/i915/intel_panel.c
@@ -419,9 +419,8 @@ static uint32_t scale(uint32_t source_val,
         source_val = clamp(source_val, source_min, source_max);
 
         /* avoid overflows */
-        target_val = (uint64_t)(source_val - source_min) *
-                (target_max - target_min);
-        do_div(target_val, source_max - source_min);
+        target_val = DIV_ROUND_CLOSEST_ULL((uint64_t)(source_val - source_min) *
+                        (target_max - target_min), source_max - source_min);
         target_val += target_min;
 
         return target_val;
diff --git a/drivers/gpu/drm/nouveau/core/engine/graph/ctxnv50.c b/drivers/gpu/drm/nouveau/core/engine/graph/ctxnv50.c
index 552fdbd45ebe..1d0e33fb5f61 100644
--- a/drivers/gpu/drm/nouveau/core/engine/graph/ctxnv50.c
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/ctxnv50.c
@@ -113,6 +113,8 @@
 #define IS_NVA3F(x) (((x) > 0xa0 && (x) < 0xaa) || (x) == 0xaf)
 #define IS_NVAAF(x) ((x) >= 0xaa && (x) <= 0xac)
 
+#include <subdev/fb.h>
+
 /*
  * This code deals with PGRAPH contexts on NV50 family cards. Like NV40, it's
  * the GPU itself that does context-switching, but it needs a special
@@ -569,8 +571,12 @@ nv50_graph_construct_mmio(struct nouveau_grctx *ctx)
                         gr_def(ctx, 0x407d08, 0x00010040);
                 else if (device->chipset < 0xa0)
                         gr_def(ctx, 0x407d08, 0x00390040);
-                else
-                        gr_def(ctx, 0x407d08, 0x003d0040);
+                else {
+                        if (nouveau_fb(device)->ram->type != NV_MEM_TYPE_GDDR5)
+                                gr_def(ctx, 0x407d08, 0x003d0040);
+                        else
+                                gr_def(ctx, 0x407d08, 0x003c0040);
+                }
                 gr_def(ctx, 0x407d0c, 0x00000022);
         }
 
diff --git a/drivers/gpu/drm/nouveau/nouveau_chan.c b/drivers/gpu/drm/nouveau/nouveau_chan.c
index 589dbb582da2..fd3dbd59d73e 100644
--- a/drivers/gpu/drm/nouveau/nouveau_chan.c
+++ b/drivers/gpu/drm/nouveau/nouveau_chan.c
@@ -400,15 +400,20 @@ nouveau_channel_new(struct nouveau_drm *drm, struct nvif_device *device,
                     struct nouveau_channel **pchan)
 {
         struct nouveau_cli *cli = (void *)nvif_client(&device->base);
+        bool super;
         int ret;
 
+        /* hack until fencenv50 is fixed, and agp access relaxed */
+        super = cli->base.super;
+        cli->base.super = true;
+
         ret = nouveau_channel_ind(drm, device, handle, arg0, pchan);
         if (ret) {
                 NV_PRINTK(debug, cli, "ib channel create, %d\n", ret);
                 ret = nouveau_channel_dma(drm, device, handle, pchan);
                 if (ret) {
                         NV_PRINTK(debug, cli, "dma channel create, %d\n", ret);
-                        return ret;
+                        goto done;
                 }
         }
 
@@ -416,8 +421,9 @@ nouveau_channel_new(struct nouveau_drm *drm, struct nvif_device *device,
         if (ret) {
                 NV_PRINTK(error, cli, "channel failed to initialise, %d\n", ret);
                 nouveau_channel_del(pchan);
-                return ret;
         }
 
-        return 0;
+done:
+        cli->base.super = super;
+        return ret;
 }
diff --git a/drivers/gpu/drm/qxl/qxl_display.c b/drivers/gpu/drm/qxl/qxl_display.c
index af9e78546688..0d1396266857 100644
--- a/drivers/gpu/drm/qxl/qxl_display.c
+++ b/drivers/gpu/drm/qxl/qxl_display.c
@@ -572,7 +572,6 @@ static int qxl_crtc_mode_set(struct drm_crtc *crtc,
         struct qxl_framebuffer *qfb;
         struct qxl_bo *bo, *old_bo = NULL;
         struct qxl_crtc *qcrtc = to_qxl_crtc(crtc);
-        uint32_t width, height, base_offset;
         bool recreate_primary = false;
         int ret;
         int surf_id;
@@ -602,9 +601,10 @@ static int qxl_crtc_mode_set(struct drm_crtc *crtc,
         if (qcrtc->index == 0)
                 recreate_primary = true;
 
-        width = mode->hdisplay;
-        height = mode->vdisplay;
-        base_offset = 0;
+        if (bo->surf.stride * bo->surf.height > qdev->vram_size) {
+                DRM_ERROR("Mode doesn't fit in vram size (vgamem)");
+                return -EINVAL;
+        }
 
         ret = qxl_bo_reserve(bo, false);
         if (ret != 0)
@@ -618,10 +618,10 @@ static int qxl_crtc_mode_set(struct drm_crtc *crtc,
         if (recreate_primary) {
                 qxl_io_destroy_primary(qdev);
                 qxl_io_log(qdev,
-                           "recreate primary: %dx%d (was %dx%d,%d,%d)\n",
-                           width, height, bo->surf.width,
-                           bo->surf.height, bo->surf.stride, bo->surf.format);
-                qxl_io_create_primary(qdev, base_offset, bo);
+                           "recreate primary: %dx%d,%d,%d\n",
+                           bo->surf.width, bo->surf.height,
+                           bo->surf.stride, bo->surf.format);
+                qxl_io_create_primary(qdev, 0, bo);
                 bo->is_primary = true;
         }
 
diff --git a/drivers/gpu/drm/radeon/btc_dpm.c b/drivers/gpu/drm/radeon/btc_dpm.c
index 300d971187c4..0b2929de9f41 100644
--- a/drivers/gpu/drm/radeon/btc_dpm.c
+++ b/drivers/gpu/drm/radeon/btc_dpm.c
@@ -24,6 +24,7 @@
 
 #include "drmP.h"
 #include "radeon.h"
+#include "radeon_asic.h"
 #include "btcd.h"
 #include "r600_dpm.h"
 #include "cypress_dpm.h"
@@ -1170,6 +1171,23 @@ static const struct radeon_blacklist_clocks btc_blacklist_clocks[] =
         { 25000, 30000, RADEON_SCLK_UP }
 };
 
+void btc_get_max_clock_from_voltage_dependency_table(struct radeon_clock_voltage_dependency_table *table,
+                                                     u32 *max_clock)
+{
+        u32 i, clock = 0;
+
+        if ((table == NULL) || (table->count == 0)) {
+                *max_clock = clock;
+                return;
+        }
+
+        for (i = 0; i < table->count; i++) {
+                if (clock < table->entries[i].clk)
+                        clock = table->entries[i].clk;
+        }
+        *max_clock = clock;
+}
+
 void btc_apply_voltage_dependency_rules(struct radeon_clock_voltage_dependency_table *table,
                                         u32 clock, u16 max_voltage, u16 *voltage)
 {
diff --git a/drivers/gpu/drm/radeon/btc_dpm.h b/drivers/gpu/drm/radeon/btc_dpm.h
index 1a15e0e41950..3b6f12b7760b 100644
--- a/drivers/gpu/drm/radeon/btc_dpm.h
+++ b/drivers/gpu/drm/radeon/btc_dpm.h
@@ -46,6 +46,8 @@ void btc_adjust_clock_combinations(struct radeon_device *rdev,
                                    struct rv7xx_pl *pl);
 void btc_apply_voltage_dependency_rules(struct radeon_clock_voltage_dependency_table *table,
                                         u32 clock, u16 max_voltage, u16 *voltage);
+void btc_get_max_clock_from_voltage_dependency_table(struct radeon_clock_voltage_dependency_table *table,
+                                                     u32 *max_clock);
 void btc_apply_voltage_delta_rules(struct radeon_device *rdev,
                                    u16 max_vddc, u16 max_vddci,
                                    u16 *vddc, u16 *vddci);
diff --git a/drivers/gpu/drm/radeon/ci_dpm.c b/drivers/gpu/drm/radeon/ci_dpm.c
index f5c8c0445a94..11a55e9dad7f 100644
--- a/drivers/gpu/drm/radeon/ci_dpm.c
+++ b/drivers/gpu/drm/radeon/ci_dpm.c
@@ -24,6 +24,7 @@
 #include <linux/firmware.h>
 #include "drmP.h"
 #include "radeon.h"
+#include "radeon_asic.h"
 #include "radeon_ucode.h"
 #include "cikd.h"
 #include "r600_dpm.h"
diff --git a/drivers/gpu/drm/radeon/cik_sdma.c b/drivers/gpu/drm/radeon/cik_sdma.c
index c77dad1a4576..4e8432d07f15 100644
--- a/drivers/gpu/drm/radeon/cik_sdma.c
+++ b/drivers/gpu/drm/radeon/cik_sdma.c
@@ -611,16 +611,19 @@ int cik_sdma_ring_test(struct radeon_device *rdev,
 {
         unsigned i;
         int r;
-        void __iomem *ptr = (void *)rdev->vram_scratch.ptr;
+        unsigned index;
         u32 tmp;
+        u64 gpu_addr;
 
-        if (!ptr) {
-                DRM_ERROR("invalid vram scratch pointer\n");
-                return -EINVAL;
-        }
+        if (ring->idx == R600_RING_TYPE_DMA_INDEX)
+                index = R600_WB_DMA_RING_TEST_OFFSET;
+        else
+                index = CAYMAN_WB_DMA1_RING_TEST_OFFSET;
+
+        gpu_addr = rdev->wb.gpu_addr + index;
 
         tmp = 0xCAFEDEAD;
-        writel(tmp, ptr);
+        rdev->wb.wb[index/4] = cpu_to_le32(tmp);
 
         r = radeon_ring_lock(rdev, ring, 5);
         if (r) {
@@ -628,14 +631,14 @@ int cik_sdma_ring_test(struct radeon_device *rdev,
                 return r;
         }
         radeon_ring_write(ring, SDMA_PACKET(SDMA_OPCODE_WRITE, SDMA_WRITE_SUB_OPCODE_LINEAR, 0));
-        radeon_ring_write(ring, rdev->vram_scratch.gpu_addr & 0xfffffffc);
-        radeon_ring_write(ring, upper_32_bits(rdev->vram_scratch.gpu_addr));
+        radeon_ring_write(ring, lower_32_bits(gpu_addr));
+        radeon_ring_write(ring, upper_32_bits(gpu_addr));
         radeon_ring_write(ring, 1); /* number of DWs to follow */
         radeon_ring_write(ring, 0xDEADBEEF);
         radeon_ring_unlock_commit(rdev, ring, false);
 
         for (i = 0; i < rdev->usec_timeout; i++) {
-                tmp = readl(ptr);
+                tmp = le32_to_cpu(rdev->wb.wb[index/4]);
                 if (tmp == 0xDEADBEEF)
                         break;
                 DRM_UDELAY(1);
diff --git a/drivers/gpu/drm/radeon/cypress_dpm.c b/drivers/gpu/drm/radeon/cypress_dpm.c
index 47d31e915758..9aad0327e4d1 100644
--- a/drivers/gpu/drm/radeon/cypress_dpm.c
+++ b/drivers/gpu/drm/radeon/cypress_dpm.c
@@ -24,6 +24,7 @@
 
 #include "drmP.h"
 #include "radeon.h"
+#include "radeon_asic.h"
 #include "evergreend.h"
 #include "r600_dpm.h"
 #include "cypress_dpm.h"
diff --git a/drivers/gpu/drm/radeon/dce3_1_afmt.c b/drivers/gpu/drm/radeon/dce3_1_afmt.c
index 950af153f30e..2fe8cfc966d9 100644
--- a/drivers/gpu/drm/radeon/dce3_1_afmt.c
+++ b/drivers/gpu/drm/radeon/dce3_1_afmt.c
@@ -32,7 +32,7 @@ static void dce3_2_afmt_write_speaker_allocation(struct drm_encoder *encoder)
         struct drm_connector *connector;
         struct radeon_connector *radeon_connector = NULL;
         u32 tmp;
-        u8 *sadb;
+        u8 *sadb = NULL;
         int sad_count;
 
         list_for_each_entry(connector, &encoder->dev->mode_config.connector_list, head) {
@@ -49,8 +49,8 @@ static void dce3_2_afmt_write_speaker_allocation(struct drm_encoder *encoder)
 
         sad_count = drm_edid_to_speaker_allocation(radeon_connector->edid, &sadb);
         if (sad_count < 0) {
-                DRM_ERROR("Couldn't read Speaker Allocation Data Block: %d\n", sad_count);
-                return;
+                DRM_DEBUG("Couldn't read Speaker Allocation Data Block: %d\n", sad_count);
+                sad_count = 0;
         }
 
         /* program the speaker allocation */
diff --git a/drivers/gpu/drm/radeon/dce6_afmt.c b/drivers/gpu/drm/radeon/dce6_afmt.c
index c0bbf68dbc27..f312edf4d50e 100644
--- a/drivers/gpu/drm/radeon/dce6_afmt.c
+++ b/drivers/gpu/drm/radeon/dce6_afmt.c
@@ -155,7 +155,7 @@ void dce6_afmt_write_speaker_allocation(struct drm_encoder *encoder)
         struct drm_connector *connector;
         struct radeon_connector *radeon_connector = NULL;
         u32 offset, tmp;
-        u8 *sadb;
+        u8 *sadb = NULL;
         int sad_count;
 
         if (!dig || !dig->afmt || !dig->afmt->pin)
@@ -176,9 +176,9 @@ void dce6_afmt_write_speaker_allocation(struct drm_encoder *encoder)
         }
 
         sad_count = drm_edid_to_speaker_allocation(radeon_connector_edid(connector), &sadb);
-        if (sad_count <= 0) {
-                DRM_ERROR("Couldn't read Speaker Allocation Data Block: %d\n", sad_count);
-                return;
+        if (sad_count < 0) {
+                DRM_DEBUG("Couldn't read Speaker Allocation Data Block: %d\n", sad_count);
+                sad_count = 0;
         }
 
         /* program the speaker allocation */
diff --git a/drivers/gpu/drm/radeon/evergreen_hdmi.c b/drivers/gpu/drm/radeon/evergreen_hdmi.c
index 2514d659b1ba..53abd9b17a50 100644
--- a/drivers/gpu/drm/radeon/evergreen_hdmi.c
+++ b/drivers/gpu/drm/radeon/evergreen_hdmi.c
@@ -133,7 +133,7 @@ static void dce4_afmt_write_speaker_allocation(struct drm_encoder *encoder)
         struct drm_connector *connector;
         struct radeon_connector *radeon_connector = NULL;
         u32 tmp;
-        u8 *sadb;
+        u8 *sadb = NULL;
         int sad_count;
 
         list_for_each_entry(connector, &encoder->dev->mode_config.connector_list, head) {
@@ -149,9 +149,9 @@ static void dce4_afmt_write_speaker_allocation(struct drm_encoder *encoder)
         }
 
         sad_count = drm_edid_to_speaker_allocation(radeon_connector_edid(connector), &sadb);
-        if (sad_count <= 0) {
-                DRM_ERROR("Couldn't read Speaker Allocation Data Block: %d\n", sad_count);
-                return;
+        if (sad_count < 0) {
+                DRM_DEBUG("Couldn't read Speaker Allocation Data Block: %d\n", sad_count);
+                sad_count = 0;
         }
 
         /* program the speaker allocation */
diff --git a/drivers/gpu/drm/radeon/ni_dpm.c b/drivers/gpu/drm/radeon/ni_dpm.c
index 715b181c6243..6d2f16cf2c1c 100644
--- a/drivers/gpu/drm/radeon/ni_dpm.c
+++ b/drivers/gpu/drm/radeon/ni_dpm.c
@@ -23,6 +23,7 @@
 
 #include "drmP.h"
 #include "radeon.h"
+#include "radeon_asic.h"
 #include "nid.h"
 #include "r600_dpm.h"
 #include "ni_dpm.h"
diff --git a/drivers/gpu/drm/radeon/r600_dma.c b/drivers/gpu/drm/radeon/r600_dma.c
index 100189ec5fa8..aabc343b9a8f 100644
--- a/drivers/gpu/drm/radeon/r600_dma.c
+++ b/drivers/gpu/drm/radeon/r600_dma.c
@@ -232,16 +232,19 @@ int r600_dma_ring_test(struct radeon_device *rdev,
 {
         unsigned i;
         int r;
-        void __iomem *ptr = (void *)rdev->vram_scratch.ptr;
+        unsigned index;
         u32 tmp;
+        u64 gpu_addr;
 
-        if (!ptr) {
-                DRM_ERROR("invalid vram scratch pointer\n");
-                return -EINVAL;
-        }
+        if (ring->idx == R600_RING_TYPE_DMA_INDEX)
+                index = R600_WB_DMA_RING_TEST_OFFSET;
+        else
+                index = CAYMAN_WB_DMA1_RING_TEST_OFFSET;
+
+        gpu_addr = rdev->wb.gpu_addr + index;
 
         tmp = 0xCAFEDEAD;
-        writel(tmp, ptr);
+        rdev->wb.wb[index/4] = cpu_to_le32(tmp);
 
         r = radeon_ring_lock(rdev, ring, 4);
         if (r) {
@@ -249,13 +252,13 @@ int r600_dma_ring_test(struct radeon_device *rdev,
                 return r;
         }
         radeon_ring_write(ring, DMA_PACKET(DMA_PACKET_WRITE, 0, 0, 1));
-        radeon_ring_write(ring, rdev->vram_scratch.gpu_addr & 0xfffffffc);
-        radeon_ring_write(ring, upper_32_bits(rdev->vram_scratch.gpu_addr) & 0xff);
+        radeon_ring_write(ring, lower_32_bits(gpu_addr));
+        radeon_ring_write(ring, upper_32_bits(gpu_addr) & 0xff);
         radeon_ring_write(ring, 0xDEADBEEF);
         radeon_ring_unlock_commit(rdev, ring, false);
 
         for (i = 0; i < rdev->usec_timeout; i++) {
-                tmp = readl(ptr);
+                tmp = le32_to_cpu(rdev->wb.wb[index/4]);
                 if (tmp == 0xDEADBEEF)
                         break;
                 DRM_UDELAY(1);
diff --git a/drivers/gpu/drm/radeon/r600_dpm.c b/drivers/gpu/drm/radeon/r600_dpm.c
index 9c61b74ef441..f6309bd23e01 100644
--- a/drivers/gpu/drm/radeon/r600_dpm.c
+++ b/drivers/gpu/drm/radeon/r600_dpm.c
@@ -24,6 +24,7 @@
 
 #include "drmP.h"
 #include "radeon.h"
+#include "radeon_asic.h"
 #include "r600d.h"
 #include "r600_dpm.h"
 #include "atom.h"
diff --git a/drivers/gpu/drm/radeon/radeon.h b/drivers/gpu/drm/radeon/radeon.h
index f7c4b226a284..a9717b3fbf1b 100644
--- a/drivers/gpu/drm/radeon/radeon.h
+++ b/drivers/gpu/drm/radeon/radeon.h
@@ -1133,6 +1133,8 @@ struct radeon_wb {
 #define R600_WB_EVENT_OFFSET     3072
 #define CIK_WB_CP1_WPTR_OFFSET     3328
 #define CIK_WB_CP2_WPTR_OFFSET     3584
+#define R600_WB_DMA_RING_TEST_OFFSET 3588
+#define CAYMAN_WB_DMA1_RING_TEST_OFFSET 3592
 
 /**
  * struct radeon_pm - power management datas
diff --git a/drivers/gpu/drm/radeon/radeon_device.c b/drivers/gpu/drm/radeon/radeon_device.c
index f41cc1538e48..ea2676954dde 100644
--- a/drivers/gpu/drm/radeon/radeon_device.c
+++ b/drivers/gpu/drm/radeon/radeon_device.c
@@ -1130,7 +1130,7 @@ static void radeon_check_arguments(struct radeon_device *rdev)
         if (radeon_vm_block_size == -1) {
 
                 /* Total bits covered by PD + PTs */
-                unsigned bits = ilog2(radeon_vm_size) + 17;
+                unsigned bits = ilog2(radeon_vm_size) + 18;
 
                 /* Make sure the PD is 4K in size up to 8GB address space.
                    Above that split equal between PD and PTs */
diff --git a/drivers/gpu/drm/radeon/rs780_dpm.c b/drivers/gpu/drm/radeon/rs780_dpm.c
index 02f7710de470..9031f4b69824 100644
--- a/drivers/gpu/drm/radeon/rs780_dpm.c
+++ b/drivers/gpu/drm/radeon/rs780_dpm.c
@@ -24,6 +24,7 @@
 
 #include "drmP.h"
 #include "radeon.h"
+#include "radeon_asic.h"
 #include "rs780d.h"
 #include "r600_dpm.h"
 #include "rs780_dpm.h"
diff --git a/drivers/gpu/drm/radeon/rv6xx_dpm.c b/drivers/gpu/drm/radeon/rv6xx_dpm.c
index e7045b085715..6a5c233361e9 100644
--- a/drivers/gpu/drm/radeon/rv6xx_dpm.c
+++ b/drivers/gpu/drm/radeon/rv6xx_dpm.c
@@ -24,6 +24,7 @@
 
 #include "drmP.h"
 #include "radeon.h"
+#include "radeon_asic.h"
 #include "rv6xxd.h"
 #include "r600_dpm.h"
 #include "rv6xx_dpm.h"
diff --git a/drivers/gpu/drm/radeon/rv770_dpm.c b/drivers/gpu/drm/radeon/rv770_dpm.c
index 3c76e1dcdf04..755a8f96fe46 100644
--- a/drivers/gpu/drm/radeon/rv770_dpm.c
+++ b/drivers/gpu/drm/radeon/rv770_dpm.c
@@ -24,6 +24,7 @@
 
 #include "drmP.h"
 #include "radeon.h"
+#include "radeon_asic.h"
 #include "rv770d.h"
 #include "r600_dpm.h"
 #include "rv770_dpm.h"
diff --git a/drivers/gpu/drm/radeon/si_dpm.c b/drivers/gpu/drm/radeon/si_dpm.c
index 9e4d5d7d348f..a53c2e79d9cb 100644
--- a/drivers/gpu/drm/radeon/si_dpm.c
+++ b/drivers/gpu/drm/radeon/si_dpm.c
@@ -23,6 +23,7 @@
 
 #include "drmP.h"
 #include "radeon.h"
+#include "radeon_asic.h"
 #include "sid.h"
 #include "r600_dpm.h"
 #include "si_dpm.h"
@@ -2916,6 +2917,7 @@ static void si_apply_state_adjust_rules(struct radeon_device *rdev,
         bool disable_sclk_switching = false;
         u32 mclk, sclk;
         u16 vddc, vddci;
+        u32 max_sclk_vddc, max_mclk_vddci, max_mclk_vddc;
         int i;
 
         if ((rdev->pm.dpm.new_active_crtc_count > 1) ||
@@ -2949,6 +2951,29 @@ static void si_apply_state_adjust_rules(struct radeon_device *rdev,
                 }
         }
 
+        /* limit clocks to max supported clocks based on voltage dependency tables */
+        btc_get_max_clock_from_voltage_dependency_table(&rdev->pm.dpm.dyn_state.vddc_dependency_on_sclk,
+                                                        &max_sclk_vddc);
+        btc_get_max_clock_from_voltage_dependency_table(&rdev->pm.dpm.dyn_state.vddci_dependency_on_mclk,
+                                                        &max_mclk_vddci);
+        btc_get_max_clock_from_voltage_dependency_table(&rdev->pm.dpm.dyn_state.vddc_dependency_on_mclk,
+                                                        &max_mclk_vddc);
+
+        for (i = 0; i < ps->performance_level_count; i++) {
+                if (max_sclk_vddc) {
+                        if (ps->performance_levels[i].sclk > max_sclk_vddc)
+                                ps->performance_levels[i].sclk = max_sclk_vddc;
+                }
+                if (max_mclk_vddci) {
+                        if (ps->performance_levels[i].mclk > max_mclk_vddci)
+                                ps->performance_levels[i].mclk = max_mclk_vddci;
+                }
+                if (max_mclk_vddc) {
+                        if (ps->performance_levels[i].mclk > max_mclk_vddc)
+                                ps->performance_levels[i].mclk = max_mclk_vddc;
+                }
+        }
+
         /* XXX validate the min clocks required for display */
 
         if (disable_mclk_switching) {
diff --git a/drivers/gpu/drm/radeon/sumo_dpm.c b/drivers/gpu/drm/radeon/sumo_dpm.c
index 3f0e8d7b8dbe..1f8a8833e1be 100644
--- a/drivers/gpu/drm/radeon/sumo_dpm.c
+++ b/drivers/gpu/drm/radeon/sumo_dpm.c
@@ -23,6 +23,7 @@
 
 #include "drmP.h"
 #include "radeon.h"
+#include "radeon_asic.h"
 #include "sumod.h"
 #include "r600_dpm.h"
 #include "cypress_dpm.h"
diff --git a/drivers/gpu/drm/radeon/trinity_dpm.c b/drivers/gpu/drm/radeon/trinity_dpm.c
index 57f780053b3e..b4ec5c4e7969 100644
--- a/drivers/gpu/drm/radeon/trinity_dpm.c
+++ b/drivers/gpu/drm/radeon/trinity_dpm.c
@@ -23,6 +23,7 @@
 
 #include "drmP.h"
 #include "radeon.h"
+#include "radeon_asic.h"
 #include "trinityd.h"
 #include "r600_dpm.h"
 #include "trinity_dpm.h"
diff --git a/drivers/gpu/drm/ttm/ttm_bo.c b/drivers/gpu/drm/ttm/ttm_bo.c
index 8f5cec67c47d..d395b0bef73b 100644
--- a/drivers/gpu/drm/ttm/ttm_bo.c
+++ b/drivers/gpu/drm/ttm/ttm_bo.c
@@ -709,6 +709,7 @@ out:
 
 static int ttm_mem_evict_first(struct ttm_bo_device *bdev,
                                 uint32_t mem_type,
+                                const struct ttm_place *place,
                                 bool interruptible,
                                 bool no_wait_gpu)
 {
@@ -720,8 +721,21 @@ static int ttm_mem_evict_first(struct ttm_bo_device *bdev,
         spin_lock(&glob->lru_lock);
         list_for_each_entry(bo, &man->lru, lru) {
                 ret = __ttm_bo_reserve(bo, false, true, false, NULL);
-                if (!ret)
+                if (!ret) {
+                        if (place && (place->fpfn || place->lpfn)) {
+                                /* Don't evict this BO if it's outside of the
+                                 * requested placement range
+                                 */
+                                if (place->fpfn >= (bo->mem.start + bo->mem.size) ||
+                                    (place->lpfn && place->lpfn <= bo->mem.start)) {
+                                        __ttm_bo_unreserve(bo);
+                                        ret = -EBUSY;
+                                        continue;
+                                }
+                        }
+
                         break;
+                }
         }
 
         if (ret) {
@@ -782,7 +796,7 @@ static int ttm_bo_mem_force_space(struct ttm_buffer_object *bo,
                         return ret;
                 if (mem->mm_node)
                         break;
-                ret = ttm_mem_evict_first(bdev, mem_type,
+                ret = ttm_mem_evict_first(bdev, mem_type, place,
                                           interruptible, no_wait_gpu);
                 if (unlikely(ret != 0))
                         return ret;
@@ -994,9 +1008,9 @@ static bool ttm_bo_mem_compat(struct ttm_placement *placement,
 
         for (i = 0; i < placement->num_placement; i++) {
                 const struct ttm_place *heap = &placement->placement[i];
-                if (mem->mm_node && heap->lpfn != 0 &&
+                if (mem->mm_node &&
                     (mem->start < heap->fpfn ||
-                     mem->start + mem->num_pages > heap->lpfn))
+                     (heap->lpfn != 0 && (mem->start + mem->num_pages) > heap->lpfn)))
                         continue;
 
                 *new_flags = heap->flags;
@@ -1007,9 +1021,9 @@ static bool ttm_bo_mem_compat(struct ttm_placement *placement,
 
         for (i = 0; i < placement->num_busy_placement; i++) {
                 const struct ttm_place *heap = &placement->busy_placement[i];
-                if (mem->mm_node && heap->lpfn != 0 &&
+                if (mem->mm_node &&
                     (mem->start < heap->fpfn ||
-                     mem->start + mem->num_pages > heap->lpfn))
+                     (heap->lpfn != 0 && (mem->start + mem->num_pages) > heap->lpfn)))
                         continue;
 
                 *new_flags = heap->flags;
@@ -1233,7 +1247,7 @@ static int ttm_bo_force_list_clean(struct ttm_bo_device *bdev,
         spin_lock(&glob->lru_lock);
         while (!list_empty(&man->lru)) {
                 spin_unlock(&glob->lru_lock);
-                ret = ttm_mem_evict_first(bdev, mem_type, false, false);
+                ret = ttm_mem_evict_first(bdev, mem_type, NULL, false, false);
                 if (ret) {
                         if (allow_errors) {
                                 return ret;
diff --git a/drivers/hwmon/menf21bmc_hwmon.c b/drivers/hwmon/menf21bmc_hwmon.c
index c92229d321c9..afc6b58eaa62 100644
--- a/drivers/hwmon/menf21bmc_hwmon.c
+++ b/drivers/hwmon/menf21bmc_hwmon.c
@@ -21,6 +21,7 @@
 #include <linux/jiffies.h>
 #include <linux/slab.h>
 #include <linux/i2c.h>
+#include <linux/err.h>
 
 #define DRV_NAME  "menf21bmc_hwmon"
 
diff --git a/drivers/infiniband/ulp/isert/ib_isert.c b/drivers/infiniband/ulp/isert/ib_isert.c
index 0bea5776bcbc..3effa931fce2 100644
--- a/drivers/infiniband/ulp/isert/ib_isert.c
+++ b/drivers/infiniband/ulp/isert/ib_isert.c
@@ -2185,7 +2185,7 @@ isert_put_response(struct iscsi_conn *conn, struct iscsi_cmd *cmd)
                 isert_cmd->tx_desc.num_sge = 2;
         }
 
-        isert_init_send_wr(isert_conn, isert_cmd, send_wr, true);
+        isert_init_send_wr(isert_conn, isert_cmd, send_wr, false);
 
         pr_debug("Posting SCSI Response IB_WR_SEND >>>>>>>>>>>>>>>>>>>>>>\n");
 
@@ -2871,7 +2871,7 @@ isert_put_datain(struct iscsi_conn *conn, struct iscsi_cmd *cmd)
                                      &isert_cmd->tx_desc.iscsi_header);
                 isert_init_tx_hdrs(isert_conn, &isert_cmd->tx_desc);
                 isert_init_send_wr(isert_conn, isert_cmd,
-                                   &isert_cmd->tx_desc.send_wr, true);
+                                   &isert_cmd->tx_desc.send_wr, false);
                 isert_cmd->rdma_wr.s_send_wr.next = &isert_cmd->tx_desc.send_wr;
                 wr->send_wr_num += 1;
         }
@@ -3140,7 +3140,7 @@ isert_accept_np(struct iscsi_np *np, struct iscsi_conn *conn)
 
 accept_wait:
         ret = down_interruptible(&isert_np->np_sem);
-        if (max_accept > 5)
+        if (ret || max_accept > 5)
                 return -ENODEV;
 
         spin_lock_bh(&np->np_thread_lock);
diff --git a/drivers/leds/led-class.c b/drivers/leds/led-class.c
index aa29198fca3e..7440c58b8e6f 100644
--- a/drivers/leds/led-class.c
+++ b/drivers/leds/led-class.c
@@ -9,26 +9,21 @@
  * published by the Free Software Foundation.
  */
 
-#include <linux/module.h>
-#include <linux/kernel.h>
+#include <linux/ctype.h>
+#include <linux/device.h>
+#include <linux/err.h>
 #include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/leds.h>
 #include <linux/list.h>
+#include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/spinlock.h>
-#include <linux/device.h>
 #include <linux/timer.h>
-#include <linux/err.h>
-#include <linux/ctype.h>
-#include <linux/leds.h>
 #include "leds.h"
 
 static struct class *leds_class;
 
-static void led_update_brightness(struct led_classdev *led_cdev)
-{
-        if (led_cdev->brightness_get)
-                led_cdev->brightness = led_cdev->brightness_get(led_cdev);
-}
-
 static ssize_t brightness_show(struct device *dev,
                 struct device_attribute *attr, char *buf)
 {
@@ -59,14 +54,14 @@ static ssize_t brightness_store(struct device *dev,
 }
 static DEVICE_ATTR_RW(brightness);
 
-static ssize_t led_max_brightness_show(struct device *dev,
+static ssize_t max_brightness_show(struct device *dev,
                 struct device_attribute *attr, char *buf)
 {
         struct led_classdev *led_cdev = dev_get_drvdata(dev);
 
         return sprintf(buf, "%u\n", led_cdev->max_brightness);
 }
-static DEVICE_ATTR(max_brightness, 0444, led_max_brightness_show, NULL);
+static DEVICE_ATTR_RO(max_brightness);
 
 #ifdef CONFIG_LEDS_TRIGGERS
 static DEVICE_ATTR(trigger, 0644, led_trigger_show, led_trigger_store);
diff --git a/drivers/leds/led-core.c b/drivers/leds/led-core.c
index 71b40d3bf776..aaa8eba9099f 100644
--- a/drivers/leds/led-core.c
+++ b/drivers/leds/led-core.c
@@ -12,10 +12,11 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/leds.h>
 #include <linux/list.h>
 #include <linux/module.h>
+#include <linux/mutex.h>
 #include <linux/rwsem.h>
-#include <linux/leds.h>
 #include "leds.h"
 
 DECLARE_RWSEM(leds_list_lock);
@@ -126,3 +127,19 @@ void led_set_brightness(struct led_classdev *led_cdev,
         __led_set_brightness(led_cdev, brightness);
 }
 EXPORT_SYMBOL(led_set_brightness);
+
+int led_update_brightness(struct led_classdev *led_cdev)
+{
+        int ret = 0;
+
+        if (led_cdev->brightness_get) {
+                ret = led_cdev->brightness_get(led_cdev);
+                if (ret >= 0) {
+                        led_cdev->brightness = ret;
+                        return 0;
+                }
+        }
+
+        return ret;
+}
+EXPORT_SYMBOL(led_update_brightness);
diff --git a/drivers/leds/leds-gpio-register.c b/drivers/leds/leds-gpio-register.c
index 1c4ed5510f35..75717ba68ae0 100644
--- a/drivers/leds/leds-gpio-register.c
+++ b/drivers/leds/leds-gpio-register.c
@@ -7,9 +7,9 @@
  * Free Software Foundation.
  */
 #include <linux/err.h>
+#include <linux/leds.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>
-#include <linux/leds.h>
 
 /**
  * gpio_led_register_device - register a gpio-led device
@@ -28,6 +28,9 @@ struct platform_device *__init gpio_led_register_device(
         struct platform_device *ret;
         struct gpio_led_platform_data _pdata = *pdata;
 
+        if (!pdata->num_leds)
+                return ERR_PTR(-EINVAL);
+
         _pdata.leds = kmemdup(pdata->leds,
                         pdata->num_leds * sizeof(*pdata->leds), GFP_KERNEL);
         if (!_pdata.leds)
diff --git a/drivers/leds/leds-gpio.c b/drivers/leds/leds-gpio.c
index 57ff20fecf57..b4518c8751c8 100644
--- a/drivers/leds/leds-gpio.c
+++ b/drivers/leds/leds-gpio.c
@@ -10,17 +10,17 @@
  * published by the Free Software Foundation.
  *
  */
-#include <linux/kernel.h>
-#include <linux/platform_device.h>
+#include <linux/err.h>
 #include <linux/gpio.h>
+#include <linux/kernel.h>
 #include <linux/leds.h>
+#include <linux/module.h>
 #include <linux/of.h>
-#include <linux/of_platform.h>
 #include <linux/of_gpio.h>
+#include <linux/of_platform.h>
+#include <linux/platform_device.h>
 #include <linux/slab.h>
 #include <linux/workqueue.h>
-#include <linux/module.h>
-#include <linux/err.h>
 
 struct gpio_led_data {
         struct led_classdev cdev;
@@ -36,7 +36,7 @@ struct gpio_led_data {
 
 static void gpio_led_work(struct work_struct *work)
 {
-        struct gpio_led_data    *led_dat =
+        struct gpio_led_data *led_dat =
                 container_of(work, struct gpio_led_data, work);
 
         if (led_dat->blinking) {
@@ -235,14 +235,12 @@ static struct gpio_leds_priv *gpio_leds_create_of(struct platform_device *pdev)
 }
 #endif /* CONFIG_OF_GPIO */
 
-
 static int gpio_led_probe(struct platform_device *pdev)
 {
         struct gpio_led_platform_data *pdata = dev_get_platdata(&pdev->dev);
         struct gpio_leds_priv *priv;
         int i, ret = 0;
 
-
         if (pdata && pdata->num_leds) {
                 priv = devm_kzalloc(&pdev->dev,
                                 sizeof_gpio_leds_priv(pdata->num_leds),
diff --git a/drivers/leds/leds-lp3944.c b/drivers/leds/leds-lp3944.c
index 8e1abdcd4c9d..53144fb96167 100644
--- a/drivers/leds/leds-lp3944.c
+++ b/drivers/leds/leds-lp3944.c
@@ -335,7 +335,8 @@ static int lp3944_configure(struct i2c_client *client,
                         }
 
                         /* to expose the default value to userspace */
-                        led->ldev.brightness = led->status;
+                        led->ldev.brightness =
+                                        (enum led_brightness) led->status;
 
                         /* Set the default led status */
                         err = lp3944_led_set(led, led->status);
diff --git a/drivers/leds/trigger/ledtrig-gpio.c b/drivers/leds/trigger/ledtrig-gpio.c
index 35812e3a37f2..c86c41826476 100644
--- a/drivers/leds/trigger/ledtrig-gpio.c
+++ b/drivers/leds/trigger/ledtrig-gpio.c
@@ -48,7 +48,7 @@ static void gpio_trig_work(struct work_struct *work)
         if (!gpio_data->gpio)
                 return;
 
-        tmp = gpio_get_value(gpio_data->gpio);
+        tmp = gpio_get_value_cansleep(gpio_data->gpio);
         if (gpio_data->inverted)
                 tmp = !tmp;
 
diff --git a/drivers/mailbox/Makefile b/drivers/mailbox/Makefile
index 6d184dbcaca8..94ed7cefb14d 100644
--- a/drivers/mailbox/Makefile
+++ b/drivers/mailbox/Makefile
@@ -1,3 +1,7 @@
+# Generic MAILBOX API
+
+obj-$(CONFIG_MAILBOX)           += mailbox.o
+
 obj-$(CONFIG_PL320_MBOX)        += pl320-ipc.o
 
 obj-$(CONFIG_OMAP2PLUS_MBOX)    += omap-mailbox.o
diff --git a/drivers/mailbox/mailbox.c b/drivers/mailbox/mailbox.c
new file mode 100644
index 000000000000..afcb430508ec
--- /dev/null
+++ b/drivers/mailbox/mailbox.c
@@ -0,0 +1,465 @@
+/*
+ * Mailbox: Common code for Mailbox controllers and users
+ *
+ * Copyright (C) 2013-2014 Linaro Ltd.
+ * Author: Jassi Brar <jassisinghbrar@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/interrupt.h>
+#include <linux/spinlock.h>
+#include <linux/mutex.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
+#include <linux/err.h>
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/bitops.h>
+#include <linux/mailbox_client.h>
+#include <linux/mailbox_controller.h>
+
+#define TXDONE_BY_IRQ   BIT(0) /* controller has remote RTR irq */
+#define TXDONE_BY_POLL  BIT(1) /* controller can read status of last TX */
+#define TXDONE_BY_ACK   BIT(2) /* S/W ACK recevied by Client ticks the TX */
+
+static LIST_HEAD(mbox_cons);
+static DEFINE_MUTEX(con_mutex);
+
+static int add_to_rbuf(struct mbox_chan *chan, void *mssg)
+{
+        int idx;
+        unsigned long flags;
+
+        spin_lock_irqsave(&chan->lock, flags);
+
+        /* See if there is any space left */
+        if (chan->msg_count == MBOX_TX_QUEUE_LEN) {
+                spin_unlock_irqrestore(&chan->lock, flags);
+                return -ENOBUFS;
+        }
+
+        idx = chan->msg_free;
+        chan->msg_data[idx] = mssg;
+        chan->msg_count++;
+
+        if (idx == MBOX_TX_QUEUE_LEN - 1)
+                chan->msg_free = 0;
+        else
+                chan->msg_free++;
+
+        spin_unlock_irqrestore(&chan->lock, flags);
+
+        return idx;
+}
+
+static void msg_submit(struct mbox_chan *chan)
+{
+        unsigned count, idx;
+        unsigned long flags;
+        void *data;
+        int err;
+
+        spin_lock_irqsave(&chan->lock, flags);
+
+        if (!chan->msg_count || chan->active_req)
+                goto exit;
+
+        count = chan->msg_count;
+        idx = chan->msg_free;
+        if (idx >= count)
+                idx -= count;
+        else
+                idx += MBOX_TX_QUEUE_LEN - count;
+
+        data = chan->msg_data[idx];
+
+        /* Try to submit a message to the MBOX controller */
+        err = chan->mbox->ops->send_data(chan, data);
+        if (!err) {
+                chan->active_req = data;
+                chan->msg_count--;
+        }
+exit:
+        spin_unlock_irqrestore(&chan->lock, flags);
+}
+
+static void tx_tick(struct mbox_chan *chan, int r)
+{
+        unsigned long flags;
+        void *mssg;
+
+        spin_lock_irqsave(&chan->lock, flags);
+        mssg = chan->active_req;
+        chan->active_req = NULL;
+        spin_unlock_irqrestore(&chan->lock, flags);
+
+        /* Submit next message */
+        msg_submit(chan);
+
+        /* Notify the client */
+        if (mssg && chan->cl->tx_done)
+                chan->cl->tx_done(chan->cl, mssg, r);
+
+        if (chan->cl->tx_block)
+                complete(&chan->tx_complete);
+}
+
+static void poll_txdone(unsigned long data)
+{
+        struct mbox_controller *mbox = (struct mbox_controller *)data;
+        bool txdone, resched = false;
+        int i;
+
+        for (i = 0; i < mbox->num_chans; i++) {
+                struct mbox_chan *chan = &mbox->chans[i];
+
+                if (chan->active_req && chan->cl) {
+                        resched = true;
+                        txdone = chan->mbox->ops->last_tx_done(chan);
+                        if (txdone)
+                                tx_tick(chan, 0);
+                }
+        }
+
+        if (resched)
+                mod_timer(&mbox->poll, jiffies +
+                                msecs_to_jiffies(mbox->txpoll_period));
+}
+
+/**
+ * mbox_chan_received_data - A way for controller driver to push data
+ *                              received from remote to the upper layer.
+ * @chan: Pointer to the mailbox channel on which RX happened.
+ * @mssg: Client specific message typecasted as void *
+ *
+ * After startup and before shutdown any data received on the chan
+ * is passed on to the API via atomic mbox_chan_received_data().
+ * The controller should ACK the RX only after this call returns.
+ */
+void mbox_chan_received_data(struct mbox_chan *chan, void *mssg)
+{
+        /* No buffering the received data */
+        if (chan->cl->rx_callback)
+                chan->cl->rx_callback(chan->cl, mssg);
+}
+EXPORT_SYMBOL_GPL(mbox_chan_received_data);
+
+/**
+ * mbox_chan_txdone - A way for controller driver to notify the
+ *                      framework that the last TX has completed.
+ * @chan: Pointer to the mailbox chan on which TX happened.
+ * @r: Status of last TX - OK or ERROR
+ *
+ * The controller that has IRQ for TX ACK calls this atomic API
+ * to tick the TX state machine. It works only if txdone_irq
+ * is set by the controller.
+ */
+void mbox_chan_txdone(struct mbox_chan *chan, int r)
+{
+        if (unlikely(!(chan->txdone_method & TXDONE_BY_IRQ))) {
+                dev_err(chan->mbox->dev,
+                       "Controller can't run the TX ticker\n");
+                return;
+        }
+
+        tx_tick(chan, r);
+}
+EXPORT_SYMBOL_GPL(mbox_chan_txdone);
+
+/**
+ * mbox_client_txdone - The way for a client to run the TX state machine.
+ * @chan: Mailbox channel assigned to this client.
+ * @r: Success status of last transmission.
+ *
+ * The client/protocol had received some 'ACK' packet and it notifies
+ * the API that the last packet was sent successfully. This only works
+ * if the controller can't sense TX-Done.
+ */
+void mbox_client_txdone(struct mbox_chan *chan, int r)
+{
+        if (unlikely(!(chan->txdone_method & TXDONE_BY_ACK))) {
+                dev_err(chan->mbox->dev, "Client can't run the TX ticker\n");
+                return;
+        }
+
+        tx_tick(chan, r);
+}
+EXPORT_SYMBOL_GPL(mbox_client_txdone);
+
+/**
+ * mbox_client_peek_data - A way for client driver to pull data
+ *                      received from remote by the controller.
+ * @chan: Mailbox channel assigned to this client.
+ *
+ * A poke to controller driver for any received data.
+ * The data is actually passed onto client via the
+ * mbox_chan_received_data()
+ * The call can be made from atomic context, so the controller's
+ * implementation of peek_data() must not sleep.
+ *
+ * Return: True, if controller has, and is going to push after this,
+ *          some data.
+ *         False, if controller doesn't have any data to be read.
+ */
+bool mbox_client_peek_data(struct mbox_chan *chan)
+{
+        if (chan->mbox->ops->peek_data)
+                return chan->mbox->ops->peek_data(chan);
+
+        return false;
+}
+EXPORT_SYMBOL_GPL(mbox_client_peek_data);
+
+/**
+ * mbox_send_message -  For client to submit a message to be
+ *                              sent to the remote.
+ * @chan: Mailbox channel assigned to this client.
+ * @mssg: Client specific message typecasted.
+ *
+ * For client to submit data to the controller destined for a remote
+ * processor. If the client had set 'tx_block', the call will return
+ * either when the remote receives the data or when 'tx_tout' millisecs
+ * run out.
+ *  In non-blocking mode, the requests are buffered by the API and a
+ * non-negative token is returned for each queued request. If the request
+ * is not queued, a negative token is returned. Upon failure or successful
+ * TX, the API calls 'tx_done' from atomic context, from which the client
+ * could submit yet another request.
+ * The pointer to message should be preserved until it is sent
+ * over the chan, i.e, tx_done() is made.
+ * This function could be called from atomic context as it simply
+ * queues the data and returns a token against the request.
+ *
+ * Return: Non-negative integer for successful submission (non-blocking mode)
+ *      or transmission over chan (blocking mode).
+ *      Negative value denotes failure.
+ */
+int mbox_send_message(struct mbox_chan *chan, void *mssg)
+{
+        int t;
+
+        if (!chan || !chan->cl)
+                return -EINVAL;
+
+        t = add_to_rbuf(chan, mssg);
+        if (t < 0) {
+                dev_err(chan->mbox->dev, "Try increasing MBOX_TX_QUEUE_LEN\n");
+                return t;
+        }
+
+        msg_submit(chan);
+
+        if (chan->txdone_method == TXDONE_BY_POLL)
+                poll_txdone((unsigned long)chan->mbox);
+
+        if (chan->cl->tx_block && chan->active_req) {
+                unsigned long wait;
+                int ret;
+
+                if (!chan->cl->tx_tout) /* wait forever */
+                        wait = msecs_to_jiffies(3600000);
+                else
+                        wait = msecs_to_jiffies(chan->cl->tx_tout);
+
+                ret = wait_for_completion_timeout(&chan->tx_complete, wait);
+                if (ret == 0) {
+                        t = -EIO;
+                        tx_tick(chan, -EIO);
+                }
+        }
+
+        return t;
+}
+EXPORT_SYMBOL_GPL(mbox_send_message);
+
+/**
+ * mbox_request_channel - Request a mailbox channel.
+ * @cl: Identity of the client requesting the channel.
+ * @index: Index of mailbox specifier in 'mboxes' property.
+ *
+ * The Client specifies its requirements and capabilities while asking for
+ * a mailbox channel. It can't be called from atomic context.
+ * The channel is exclusively allocated and can't be used by another
+ * client before the owner calls mbox_free_channel.
+ * After assignment, any packet received on this channel will be
+ * handed over to the client via the 'rx_callback'.
+ * The framework holds reference to the client, so the mbox_client
+ * structure shouldn't be modified until the mbox_free_channel returns.
+ *
+ * Return: Pointer to the channel assigned to the client if successful.
+ *              ERR_PTR for request failure.
+ */
+struct mbox_chan *mbox_request_channel(struct mbox_client *cl, int index)
+{
+        struct device *dev = cl->dev;
+        struct mbox_controller *mbox;
+        struct of_phandle_args spec;
+        struct mbox_chan *chan;
+        unsigned long flags;
+        int ret;
+
+        if (!dev || !dev->of_node) {
+                pr_debug("%s: No owner device node\n", __func__);
+                return ERR_PTR(-ENODEV);
+        }
+
+        mutex_lock(&con_mutex);
+
+        if (of_parse_phandle_with_args(dev->of_node, "mboxes",
+                                       "#mbox-cells", index, &spec)) {
+                dev_dbg(dev, "%s: can't parse \"mboxes\" property\n", __func__);
+                mutex_unlock(&con_mutex);
+                return ERR_PTR(-ENODEV);
+        }
+
+        chan = NULL;
+        list_for_each_entry(mbox, &mbox_cons, node)
+                if (mbox->dev->of_node == spec.np) {
+                        chan = mbox->of_xlate(mbox, &spec);
+                        break;
+                }
+
+        of_node_put(spec.np);
+
+        if (!chan || chan->cl || !try_module_get(mbox->dev->driver->owner)) {
+                dev_dbg(dev, "%s: mailbox not free\n", __func__);
+                mutex_unlock(&con_mutex);
+                return ERR_PTR(-EBUSY);
+        }
+
+        spin_lock_irqsave(&chan->lock, flags);
+        chan->msg_free = 0;
+        chan->msg_count = 0;
+        chan->active_req = NULL;
+        chan->cl = cl;
+        init_completion(&chan->tx_complete);
+
+        if (chan->txdone_method == TXDONE_BY_POLL && cl->knows_txdone)
+                chan->txdone_method |= TXDONE_BY_ACK;
+
+        spin_unlock_irqrestore(&chan->lock, flags);
+
+        ret = chan->mbox->ops->startup(chan);
+        if (ret) {
+                dev_err(dev, "Unable to startup the chan (%d)\n", ret);
+                mbox_free_channel(chan);
+                chan = ERR_PTR(ret);
+        }
+
+        mutex_unlock(&con_mutex);
+        return chan;
+}
+EXPORT_SYMBOL_GPL(mbox_request_channel);
+
+/**
+ * mbox_free_channel - The client relinquishes control of a mailbox
+ *                      channel by this call.
+ * @chan: The mailbox channel to be freed.
+ */
+void mbox_free_channel(struct mbox_chan *chan)
+{
+        unsigned long flags;
+
+        if (!chan || !chan->cl)
+                return;
+
+        chan->mbox->ops->shutdown(chan);
+
+        /* The queued TX requests are simply aborted, no callbacks are made */
+        spin_lock_irqsave(&chan->lock, flags);
+        chan->cl = NULL;
+        chan->active_req = NULL;
+        if (chan->txdone_method == (TXDONE_BY_POLL | TXDONE_BY_ACK))
+                chan->txdone_method = TXDONE_BY_POLL;
+
+        module_put(chan->mbox->dev->driver->owner);
+        spin_unlock_irqrestore(&chan->lock, flags);
+}
+EXPORT_SYMBOL_GPL(mbox_free_channel);
+
+static struct mbox_chan *
+of_mbox_index_xlate(struct mbox_controller *mbox,
+                    const struct of_phandle_args *sp)
+{
+        int ind = sp->args[0];
+
+        if (ind >= mbox->num_chans)
+                return NULL;
+
+        return &mbox->chans[ind];
+}
+
+/**
+ * mbox_controller_register - Register the mailbox controller
+ * @mbox:       Pointer to the mailbox controller.
+ *
+ * The controller driver registers its communication channels
+ */
+int mbox_controller_register(struct mbox_controller *mbox)
+{
+        int i, txdone;
+
+        /* Sanity check */
+        if (!mbox || !mbox->dev || !mbox->ops || !mbox->num_chans)
+                return -EINVAL;
+
+        if (mbox->txdone_irq)
+                txdone = TXDONE_BY_IRQ;
+        else if (mbox->txdone_poll)
+                txdone = TXDONE_BY_POLL;
+        else /* It has to be ACK then */
+                txdone = TXDONE_BY_ACK;
+
+        if (txdone == TXDONE_BY_POLL) {
+                mbox->poll.function = &poll_txdone;
+                mbox->poll.data = (unsigned long)mbox;
+                init_timer(&mbox->poll);
+        }
+
+        for (i = 0; i < mbox->num_chans; i++) {
+                struct mbox_chan *chan = &mbox->chans[i];
+
+                chan->cl = NULL;
+                chan->mbox = mbox;
+                chan->txdone_method = txdone;
+                spin_lock_init(&chan->lock);
+        }
+
+        if (!mbox->of_xlate)
+                mbox->of_xlate = of_mbox_index_xlate;
+
+        mutex_lock(&con_mutex);
+        list_add_tail(&mbox->node, &mbox_cons);
+        mutex_unlock(&con_mutex);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(mbox_controller_register);
+
+/**
+ * mbox_controller_unregister - Unregister the mailbox controller
+ * @mbox:       Pointer to the mailbox controller.
+ */
+void mbox_controller_unregister(struct mbox_controller *mbox)
+{
+        int i;
+
+        if (!mbox)
+                return;
+
+        mutex_lock(&con_mutex);
+
+        list_del(&mbox->node);
+
+        for (i = 0; i < mbox->num_chans; i++)
+                mbox_free_channel(&mbox->chans[i]);
+
+        if (mbox->txdone_poll)
+                del_timer_sync(&mbox->poll);
+
+        mutex_unlock(&con_mutex);
+}
+EXPORT_SYMBOL_GPL(mbox_controller_unregister);
diff --git a/drivers/mailbox/pl320-ipc.c b/drivers/mailbox/pl320-ipc.c
index d873cbae2fbb..f3755e0aa935 100644
--- a/drivers/mailbox/pl320-ipc.c
+++ b/drivers/mailbox/pl320-ipc.c
@@ -26,7 +26,7 @@
 #include <linux/device.h>
 #include <linux/amba/bus.h>
 
-#include <linux/mailbox.h>
+#include <linux/pl320-ipc.h>
 
 #define IPCMxSOURCE(m)          ((m) * 0x40)
 #define IPCMxDSET(m)            (((m) * 0x40) + 0x004)
diff --git a/drivers/pci/pcie/pme.c b/drivers/pci/pcie/pme.c
index a9f9c46e5022..63fc63911295 100644
--- a/drivers/pci/pcie/pme.c
+++ b/drivers/pci/pcie/pme.c
@@ -397,6 +397,7 @@ static int pcie_pme_suspend(struct pcie_device *srv)
         struct pcie_pme_service_data *data = get_service_data(srv);
         struct pci_dev *port = srv->port;
         bool wakeup;
+        int ret;
 
         if (device_may_wakeup(&port->dev)) {
                 wakeup = true;
@@ -407,9 +408,10 @@ static int pcie_pme_suspend(struct pcie_device *srv)
         }
         spin_lock_irq(&data->lock);
         if (wakeup) {
-                enable_irq_wake(srv->irq);
+                ret = enable_irq_wake(srv->irq);
                 data->suspend_level = PME_SUSPEND_WAKEUP;
-        } else {
+        }
+        if (!wakeup || ret) {
                 struct pci_dev *port = srv->port;
 
                 pcie_pme_interrupt_enable(port, false);
diff --git a/drivers/power/reset/at91-reset.c b/drivers/power/reset/at91-reset.c
index 3611806c9cfd..3cb36693343a 100644
--- a/drivers/power/reset/at91-reset.c
+++ b/drivers/power/reset/at91-reset.c
@@ -100,11 +100,11 @@ static void at91sam9g45_restart(enum reboot_mode mode, const char *cmd)
                 /* Disable SDRAM0 accesses */
                 "1:     str     %3, [%0, #" __stringify(AT91_DDRSDRC_RTR) "]\n\t"
                 /* Power down SDRAM0 */
-                "       str     %4, [%0, #" __stringify(AT91_DDRSDRC_RTR) "]\n\t"
+                "       str     %4, [%0, #" __stringify(AT91_DDRSDRC_LPR) "]\n\t"
                 /* Disable SDRAM1 accesses */
                 "       strne   %3, [%1, #" __stringify(AT91_DDRSDRC_RTR) "]\n\t"
                 /* Power down SDRAM1 */
-                "       strne   %4, [%1, #" __stringify(AT91_DDRSDRC_RTR) "]\n\t"
+                "       strne   %4, [%1, #" __stringify(AT91_DDRSDRC_LPR) "]\n\t"
                 /* Reset CPU */
                 "       str     %5, [%2, #" __stringify(AT91_RSTC_CR) "]\n\t"
 
diff --git a/drivers/pwm/Kconfig b/drivers/pwm/Kconfig
index b800783800a3..ef2dd2e4754b 100644
--- a/drivers/pwm/Kconfig
+++ b/drivers/pwm/Kconfig
@@ -83,6 +83,7 @@ config PWM_BFIN
 config PWM_CLPS711X
         tristate "CLPS711X PWM support"
         depends on ARCH_CLPS711X || COMPILE_TEST
+        depends on HAS_IOMEM
         help
           Generic PWM framework driver for Cirrus Logic CLPS711X.
 
@@ -101,6 +102,7 @@ config PWM_EP93XX
 config PWM_FSL_FTM
         tristate "Freescale FlexTimer Module (FTM) PWM support"
         depends on OF
+        select REGMAP_MMIO
         help
           Generic FTM PWM framework driver for Freescale VF610 and
           Layerscape LS-1 SoCs.
@@ -149,7 +151,7 @@ config PWM_LPC32XX
 
 config PWM_LPSS
         tristate "Intel LPSS PWM support"
-        depends on ACPI
+        depends on X86
         help
           Generic PWM framework driver for Intel Low Power Subsystem PWM
           controller.
@@ -157,6 +159,24 @@ config PWM_LPSS
           To compile this driver as a module, choose M here: the module
           will be called pwm-lpss.
 
+config PWM_LPSS_PCI
+        tristate "Intel LPSS PWM PCI driver"
+        depends on PWM_LPSS && PCI
+        help
+          The PCI driver for Intel Low Power Subsystem PWM controller.
+
+          To compile this driver as a module, choose M here: the module
+          will be called pwm-lpss-pci.
+
+config PWM_LPSS_PLATFORM
+        tristate "Intel LPSS PWM platform driver"
+        depends on PWM_LPSS && ACPI
+        help
+          The platform driver for Intel Low Power Subsystem PWM controller.
+
+          To compile this driver as a module, choose M here: the module
+          will be called pwm-lpss-platform.
+
 config PWM_MXS
         tristate "Freescale MXS PWM support"
         depends on ARCH_MXS && OF
diff --git a/drivers/pwm/Makefile b/drivers/pwm/Makefile
index f8c577d41091..c458606c3755 100644
--- a/drivers/pwm/Makefile
+++ b/drivers/pwm/Makefile
@@ -13,6 +13,8 @@ obj-$(CONFIG_PWM_JZ4740)	+= pwm-jz4740.o
 obj-$(CONFIG_PWM_LP3943)        += pwm-lp3943.o
 obj-$(CONFIG_PWM_LPC32XX)       += pwm-lpc32xx.o
 obj-$(CONFIG_PWM_LPSS)          += pwm-lpss.o
+obj-$(CONFIG_PWM_LPSS_PCI)      += pwm-lpss-pci.o
+obj-$(CONFIG_PWM_LPSS_PLATFORM) += pwm-lpss-platform.o
 obj-$(CONFIG_PWM_MXS)           += pwm-mxs.o
 obj-$(CONFIG_PWM_PCA9685)       += pwm-pca9685.o
 obj-$(CONFIG_PWM_PUV3)          += pwm-puv3.o
diff --git a/drivers/pwm/core.c b/drivers/pwm/core.c
index d2c35920ff08..966497d10c6e 100644
--- a/drivers/pwm/core.c
+++ b/drivers/pwm/core.c
@@ -236,7 +236,7 @@ int pwmchip_add(struct pwm_chip *chip)
         int ret;
 
         if (!chip || !chip->dev || !chip->ops || !chip->ops->config ||
-            !chip->ops->enable || !chip->ops->disable)
+            !chip->ops->enable || !chip->ops->disable || !chip->npwm)
                 return -EINVAL;
 
         mutex_lock(&pwm_lock);
@@ -602,12 +602,9 @@ struct pwm_device *pwm_get(struct device *dev, const char *con_id)
         struct pwm_device *pwm = ERR_PTR(-EPROBE_DEFER);
         const char *dev_id = dev ? dev_name(dev) : NULL;
         struct pwm_chip *chip = NULL;
-        unsigned int index = 0;
         unsigned int best = 0;
-        struct pwm_lookup *p;
+        struct pwm_lookup *p, *chosen = NULL;
         unsigned int match;
-        unsigned int period;
-        enum pwm_polarity polarity;
 
         /* look up via DT first */
         if (IS_ENABLED(CONFIG_OF) && dev && dev->of_node)
@@ -653,10 +650,7 @@ struct pwm_device *pwm_get(struct device *dev, const char *con_id)
                 }
 
                 if (match > best) {
-                        chip = pwmchip_find_by_name(p->provider);
-                        index = p->index;
-                        period = p->period;
-                        polarity = p->polarity;
+                        chosen = p;
 
                         if (match != 3)
                                 best = match;
@@ -665,17 +659,22 @@ struct pwm_device *pwm_get(struct device *dev, const char *con_id)
                 }
         }
 
-        mutex_unlock(&pwm_lookup_lock);
+        if (!chosen)
+                goto out;
 
-        if (chip)
-                pwm = pwm_request_from_chip(chip, index, con_id ?: dev_id);
-        if (IS_ERR(pwm))
-                return pwm;
+        chip = pwmchip_find_by_name(chosen->provider);
+        if (!chip)
+                goto out;
 
-        pwm_set_period(pwm, period);
-        pwm_set_polarity(pwm, polarity);
+        pwm = pwm_request_from_chip(chip, chosen->index, con_id ?: dev_id);
+        if (IS_ERR(pwm))
+                goto out;
 
+        pwm_set_period(pwm, chosen->period);
+        pwm_set_polarity(pwm, chosen->polarity);
 
+out:
+        mutex_unlock(&pwm_lookup_lock);
         return pwm;
 }
 EXPORT_SYMBOL_GPL(pwm_get);
diff --git a/drivers/pwm/pwm-atmel.c b/drivers/pwm/pwm-atmel.c
index 6e700a541ca3..d3c22de9ee47 100644
--- a/drivers/pwm/pwm-atmel.c
+++ b/drivers/pwm/pwm-atmel.c
@@ -102,7 +102,7 @@ static int atmel_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
                             int duty_ns, int period_ns)
 {
         struct atmel_pwm_chip *atmel_pwm = to_atmel_pwm_chip(chip);
-        unsigned long clk_rate, prd, dty;
+        unsigned long prd, dty;
         unsigned long long div;
         unsigned int pres = 0;
         u32 val;
@@ -113,20 +113,18 @@ static int atmel_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
                 return -EBUSY;
         }
 
-        clk_rate = clk_get_rate(atmel_pwm->clk);
-        div = clk_rate;
+        /* Calculate the period cycles and prescale value */
+        div = (unsigned long long)clk_get_rate(atmel_pwm->clk) * period_ns;
+        do_div(div, NSEC_PER_SEC);
 
-        /* Calculate the period cycles */
         while (div > PWM_MAX_PRD) {
-                div = clk_rate / (1 << pres);
-                div = div * period_ns;
-                /* 1/Hz = 100000000 ns */
-                do_div(div, 1000000000);
-
-                if (pres++ > PRD_MAX_PRES) {
-                        dev_err(chip->dev, "pres exceeds the maximum value\n");
-                        return -EINVAL;
-                }
+                div >>= 1;
+                pres++;
+        }
+
+        if (pres > PRD_MAX_PRES) {
+                dev_err(chip->dev, "pres exceeds the maximum value\n");
+                return -EINVAL;
         }
 
         /* Calculate the duty cycles */
diff --git a/drivers/pwm/pwm-fsl-ftm.c b/drivers/pwm/pwm-fsl-ftm.c
index a18bc8fea385..0f2cc7ef7784 100644
--- a/drivers/pwm/pwm-fsl-ftm.c
+++ b/drivers/pwm/pwm-fsl-ftm.c
@@ -18,14 +18,14 @@
 #include <linux/of_address.h>
 #include <linux/platform_device.h>
 #include <linux/pwm.h>
+#include <linux/regmap.h>
 #include <linux/slab.h>
 
 #define FTM_SC          0x00
-#define FTM_SC_CLK_MASK 0x3
-#define FTM_SC_CLK_SHIFT        3
-#define FTM_SC_CLK(c)   (((c) + 1) << FTM_SC_CLK_SHIFT)
+#define FTM_SC_CLK_MASK_SHIFT   3
+#define FTM_SC_CLK_MASK (3 << FTM_SC_CLK_MASK_SHIFT)
+#define FTM_SC_CLK(c)   (((c) + 1) << FTM_SC_CLK_MASK_SHIFT)
 #define FTM_SC_PS_MASK  0x7
-#define FTM_SC_PS_SHIFT 0
 
 #define FTM_CNT         0x04
 #define FTM_MOD         0x08
@@ -83,7 +83,7 @@ struct fsl_pwm_chip {
         unsigned int cnt_select;
         unsigned int clk_ps;
 
-        void __iomem *base;
+        struct regmap *regmap;
 
         int period_ns;
 
@@ -219,10 +219,11 @@ static unsigned long fsl_pwm_calculate_duty(struct fsl_pwm_chip *fpc,
                                             unsigned long period_ns,
                                             unsigned long duty_ns)
 {
-        unsigned long long val, duty;
+        unsigned long long duty;
+        u32 val;
 
-        val = readl(fpc->base + FTM_MOD);
-        duty = duty_ns * (val + 1);
+        regmap_read(fpc->regmap, FTM_MOD, &val);
+        duty = (unsigned long long)duty_ns * (val + 1);
         do_div(duty, period_ns);
 
         return (unsigned long)duty;
@@ -232,7 +233,7 @@ static int fsl_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
                           int duty_ns, int period_ns)
 {
         struct fsl_pwm_chip *fpc = to_fsl_chip(chip);
-        u32 val, period, duty;
+        u32 period, duty;
 
         mutex_lock(&fpc->lock);
 
@@ -257,11 +258,9 @@ static int fsl_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
                         return -EINVAL;
                 }
 
-                val = readl(fpc->base + FTM_SC);
-                val &= ~(FTM_SC_PS_MASK << FTM_SC_PS_SHIFT);
-                val |= fpc->clk_ps;
-                writel(val, fpc->base + FTM_SC);
-                writel(period - 1, fpc->base + FTM_MOD);
+                regmap_update_bits(fpc->regmap, FTM_SC, FTM_SC_PS_MASK,
+                                   fpc->clk_ps);
+                regmap_write(fpc->regmap, FTM_MOD, period - 1);
 
                 fpc->period_ns = period_ns;
         }
@@ -270,8 +269,9 @@ static int fsl_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
 
         duty = fsl_pwm_calculate_duty(fpc, period_ns, duty_ns);
 
-        writel(FTM_CSC_MSB | FTM_CSC_ELSB, fpc->base + FTM_CSC(pwm->hwpwm));
-        writel(duty, fpc->base + FTM_CV(pwm->hwpwm));
+        regmap_write(fpc->regmap, FTM_CSC(pwm->hwpwm),
+                     FTM_CSC_MSB | FTM_CSC_ELSB);
+        regmap_write(fpc->regmap, FTM_CV(pwm->hwpwm), duty);
 
         return 0;
 }
@@ -283,31 +283,28 @@ static int fsl_pwm_set_polarity(struct pwm_chip *chip,
         struct fsl_pwm_chip *fpc = to_fsl_chip(chip);
         u32 val;
 
-        val = readl(fpc->base + FTM_POL);
+        regmap_read(fpc->regmap, FTM_POL, &val);
 
         if (polarity == PWM_POLARITY_INVERSED)
                 val |= BIT(pwm->hwpwm);
         else
                 val &= ~BIT(pwm->hwpwm);
 
-        writel(val, fpc->base + FTM_POL);
+        regmap_write(fpc->regmap, FTM_POL, val);
 
         return 0;
 }
 
 static int fsl_counter_clock_enable(struct fsl_pwm_chip *fpc)
 {
-        u32 val;
         int ret;
 
         if (fpc->use_count != 0)
                 return 0;
 
         /* select counter clock source */
-        val = readl(fpc->base + FTM_SC);
-        val &= ~(FTM_SC_CLK_MASK << FTM_SC_CLK_SHIFT);
-        val |= FTM_SC_CLK(fpc->cnt_select);
-        writel(val, fpc->base + FTM_SC);
+        regmap_update_bits(fpc->regmap, FTM_SC, FTM_SC_CLK_MASK,
+                           FTM_SC_CLK(fpc->cnt_select));
 
         ret = clk_prepare_enable(fpc->clk[fpc->cnt_select]);
         if (ret)
@@ -327,13 +324,10 @@ static int fsl_counter_clock_enable(struct fsl_pwm_chip *fpc)
 static int fsl_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)
 {
         struct fsl_pwm_chip *fpc = to_fsl_chip(chip);
-        u32 val;
         int ret;
 
         mutex_lock(&fpc->lock);
-        val = readl(fpc->base + FTM_OUTMASK);
-        val &= ~BIT(pwm->hwpwm);
-        writel(val, fpc->base + FTM_OUTMASK);
+        regmap_update_bits(fpc->regmap, FTM_OUTMASK, BIT(pwm->hwpwm), 0);
 
         ret = fsl_counter_clock_enable(fpc);
         mutex_unlock(&fpc->lock);
@@ -343,8 +337,6 @@ static int fsl_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)
 
 static void fsl_counter_clock_disable(struct fsl_pwm_chip *fpc)
 {
-        u32 val;
-
         /*
          * already disabled, do nothing
          */
@@ -356,9 +348,7 @@ static void fsl_counter_clock_disable(struct fsl_pwm_chip *fpc)
                 return;
 
         /* no users left, disable PWM counter clock */
-        val = readl(fpc->base + FTM_SC);
-        val &= ~(FTM_SC_CLK_MASK << FTM_SC_CLK_SHIFT);
-        writel(val, fpc->base + FTM_SC);
+        regmap_update_bits(fpc->regmap, FTM_SC, FTM_SC_CLK_MASK, 0);
 
         clk_disable_unprepare(fpc->clk[FSL_PWM_CLK_CNTEN]);
         clk_disable_unprepare(fpc->clk[fpc->cnt_select]);
@@ -370,14 +360,12 @@ static void fsl_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)
         u32 val;
 
         mutex_lock(&fpc->lock);
-        val = readl(fpc->base + FTM_OUTMASK);
-        val |= BIT(pwm->hwpwm);
-        writel(val, fpc->base + FTM_OUTMASK);
+        regmap_update_bits(fpc->regmap, FTM_OUTMASK, BIT(pwm->hwpwm),
+                           BIT(pwm->hwpwm));
 
         fsl_counter_clock_disable(fpc);
 
-        val = readl(fpc->base + FTM_OUTMASK);
-
+        regmap_read(fpc->regmap, FTM_OUTMASK, &val);
         if ((val & 0xFF) == 0xFF)
                 fpc->period_ns = 0;
 
@@ -402,19 +390,28 @@ static int fsl_pwm_init(struct fsl_pwm_chip *fpc)
         if (ret)
                 return ret;
 
-        writel(0x00, fpc->base + FTM_CNTIN);
-        writel(0x00, fpc->base + FTM_OUTINIT);
-        writel(0xFF, fpc->base + FTM_OUTMASK);
+        regmap_write(fpc->regmap, FTM_CNTIN, 0x00);
+        regmap_write(fpc->regmap, FTM_OUTINIT, 0x00);
+        regmap_write(fpc->regmap, FTM_OUTMASK, 0xFF);
 
         clk_disable_unprepare(fpc->clk[FSL_PWM_CLK_SYS]);
 
         return 0;
 }
 
+static const struct regmap_config fsl_pwm_regmap_config = {
+        .reg_bits = 32,
+        .reg_stride = 4,
+        .val_bits = 32,
+
+        .max_register = FTM_PWMLOAD,
+};
+
 static int fsl_pwm_probe(struct platform_device *pdev)
 {
         struct fsl_pwm_chip *fpc;
         struct resource *res;
+        void __iomem *base;
         int ret;
 
         fpc = devm_kzalloc(&pdev->dev, sizeof(*fpc), GFP_KERNEL);
@@ -426,9 +423,16 @@ static int fsl_pwm_probe(struct platform_device *pdev)
         fpc->chip.dev = &pdev->dev;
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        fpc->base = devm_ioremap_resource(&pdev->dev, res);
-        if (IS_ERR(fpc->base))
-                return PTR_ERR(fpc->base);
+        base = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(base))
+                return PTR_ERR(base);
+
+        fpc->regmap = devm_regmap_init_mmio_clk(&pdev->dev, NULL, base,
+                                                &fsl_pwm_regmap_config);
+        if (IS_ERR(fpc->regmap)) {
+                dev_err(&pdev->dev, "regmap init failed\n");
+                return PTR_ERR(fpc->regmap);
+        }
 
         fpc->clk[FSL_PWM_CLK_SYS] = devm_clk_get(&pdev->dev, "ftm_sys");
         if (IS_ERR(fpc->clk[FSL_PWM_CLK_SYS])) {
diff --git a/drivers/pwm/pwm-imx.c b/drivers/pwm/pwm-imx.c
index 5449d9150d40..f8b5f109c1ab 100644
--- a/drivers/pwm/pwm-imx.c
+++ b/drivers/pwm/pwm-imx.c
@@ -14,6 +14,7 @@
 #include <linux/slab.h>
 #include <linux/err.h>
 #include <linux/clk.h>
+#include <linux/delay.h>
 #include <linux/io.h>
 #include <linux/pwm.h>
 #include <linux/of.h>
@@ -21,24 +22,30 @@
 
 /* i.MX1 and i.MX21 share the same PWM function block: */
 
-#define MX1_PWMC    0x00   /* PWM Control Register */
-#define MX1_PWMS    0x04   /* PWM Sample Register */
-#define MX1_PWMP    0x08   /* PWM Period Register */
+#define MX1_PWMC                        0x00   /* PWM Control Register */
+#define MX1_PWMS                        0x04   /* PWM Sample Register */
+#define MX1_PWMP                        0x08   /* PWM Period Register */
 
-#define MX1_PWMC_EN             (1 << 4)
+#define MX1_PWMC_EN                     (1 << 4)
 
 /* i.MX27, i.MX31, i.MX35 share the same PWM function block: */
 
-#define MX3_PWMCR                 0x00    /* PWM Control Register */
-#define MX3_PWMSAR                0x0C    /* PWM Sample Register */
-#define MX3_PWMPR                 0x10    /* PWM Period Register */
-#define MX3_PWMCR_PRESCALER(x)    (((x - 1) & 0xFFF) << 4)
-#define MX3_PWMCR_DOZEEN                (1 << 24)
-#define MX3_PWMCR_WAITEN                (1 << 23)
+#define MX3_PWMCR                       0x00    /* PWM Control Register */
+#define MX3_PWMSR                       0x04    /* PWM Status Register */
+#define MX3_PWMSAR                      0x0C    /* PWM Sample Register */
+#define MX3_PWMPR                       0x10    /* PWM Period Register */
+#define MX3_PWMCR_PRESCALER(x)          ((((x) - 1) & 0xFFF) << 4)
+#define MX3_PWMCR_DOZEEN                (1 << 24)
+#define MX3_PWMCR_WAITEN                (1 << 23)
 #define MX3_PWMCR_DBGEN                 (1 << 22)
-#define MX3_PWMCR_CLKSRC_IPG_HIGH (2 << 16)
-#define MX3_PWMCR_CLKSRC_IPG      (1 << 16)
-#define MX3_PWMCR_EN              (1 << 0)
+#define MX3_PWMCR_CLKSRC_IPG_HIGH       (2 << 16)
+#define MX3_PWMCR_CLKSRC_IPG            (1 << 16)
+#define MX3_PWMCR_SWR                   (1 << 3)
+#define MX3_PWMCR_EN                    (1 << 0)
+#define MX3_PWMSR_FIFOAV_4WORDS         0x4
+#define MX3_PWMSR_FIFOAV_MASK           0x7
+
+#define MX3_PWM_SWR_LOOP                5
 
 struct imx_chip {
         struct clk      *clk_per;
@@ -103,9 +110,43 @@ static int imx_pwm_config_v2(struct pwm_chip *chip,
                 struct pwm_device *pwm, int duty_ns, int period_ns)
 {
         struct imx_chip *imx = to_imx_chip(chip);
+        struct device *dev = chip->dev;
         unsigned long long c;
         unsigned long period_cycles, duty_cycles, prescale;
-        u32 cr;
+        unsigned int period_ms;
+        bool enable = test_bit(PWMF_ENABLED, &pwm->flags);
+        int wait_count = 0, fifoav;
+        u32 cr, sr;
+
+        /*
+         * i.MX PWMv2 has a 4-word sample FIFO.
+         * In order to avoid FIFO overflow issue, we do software reset
+         * to clear all sample FIFO if the controller is disabled or
+         * wait for a full PWM cycle to get a relinquished FIFO slot
+         * when the controller is enabled and the FIFO is fully loaded.
+         */
+        if (enable) {
+                sr = readl(imx->mmio_base + MX3_PWMSR);
+                fifoav = sr & MX3_PWMSR_FIFOAV_MASK;
+                if (fifoav == MX3_PWMSR_FIFOAV_4WORDS) {
+                        period_ms = DIV_ROUND_UP(pwm->period, NSEC_PER_MSEC);
+                        msleep(period_ms);
+
+                        sr = readl(imx->mmio_base + MX3_PWMSR);
+                        if (fifoav == (sr & MX3_PWMSR_FIFOAV_MASK))
+                                dev_warn(dev, "there is no free FIFO slot\n");
+                }
+        } else {
+                writel(MX3_PWMCR_SWR, imx->mmio_base + MX3_PWMCR);
+                do {
+                        usleep_range(200, 1000);
+                        cr = readl(imx->mmio_base + MX3_PWMCR);
+                } while ((cr & MX3_PWMCR_SWR) &&
+                         (wait_count++ < MX3_PWM_SWR_LOOP));
+
+                if (cr & MX3_PWMCR_SWR)
+                        dev_warn(dev, "software reset timeout\n");
+        }
 
         c = clk_get_rate(imx->clk_per);
         c = c * period_ns;
@@ -135,7 +176,7 @@ static int imx_pwm_config_v2(struct pwm_chip *chip,
                 MX3_PWMCR_DOZEEN | MX3_PWMCR_WAITEN |
                 MX3_PWMCR_DBGEN | MX3_PWMCR_CLKSRC_IPG_HIGH;
 
-        if (test_bit(PWMF_ENABLED, &pwm->flags))
+        if (enable)
                 cr |= MX3_PWMCR_EN;
 
         writel(cr, imx->mmio_base + MX3_PWMCR);
diff --git a/drivers/pwm/pwm-lpss-pci.c b/drivers/pwm/pwm-lpss-pci.c
new file mode 100644
index 000000000000..cf20d2beacdd
--- /dev/null
+++ b/drivers/pwm/pwm-lpss-pci.c
@@ -0,0 +1,64 @@
+/*
+ * Intel Low Power Subsystem PWM controller PCI driver
+ *
+ * Copyright (C) 2014, Intel Corporation
+ *
+ * Derived from the original pwm-lpss.c
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+
+#include "pwm-lpss.h"
+
+static int pwm_lpss_probe_pci(struct pci_dev *pdev,
+                              const struct pci_device_id *id)
+{
+        const struct pwm_lpss_boardinfo *info;
+        struct pwm_lpss_chip *lpwm;
+        int err;
+
+        err = pcim_enable_device(pdev);
+        if (err < 0)
+                return err;
+
+        info = (struct pwm_lpss_boardinfo *)id->driver_data;
+        lpwm = pwm_lpss_probe(&pdev->dev, &pdev->resource[0], info);
+        if (IS_ERR(lpwm))
+                return PTR_ERR(lpwm);
+
+        pci_set_drvdata(pdev, lpwm);
+        return 0;
+}
+
+static void pwm_lpss_remove_pci(struct pci_dev *pdev)
+{
+        struct pwm_lpss_chip *lpwm = pci_get_drvdata(pdev);
+
+        pwm_lpss_remove(lpwm);
+}
+
+static const struct pci_device_id pwm_lpss_pci_ids[] = {
+        { PCI_VDEVICE(INTEL, 0x0f08), (unsigned long)&pwm_lpss_byt_info},
+        { PCI_VDEVICE(INTEL, 0x0f09), (unsigned long)&pwm_lpss_byt_info},
+        { PCI_VDEVICE(INTEL, 0x2288), (unsigned long)&pwm_lpss_bsw_info},
+        { PCI_VDEVICE(INTEL, 0x2289), (unsigned long)&pwm_lpss_bsw_info},
+        { },
+};
+MODULE_DEVICE_TABLE(pci, pwm_lpss_pci_ids);
+
+static struct pci_driver pwm_lpss_driver_pci = {
+        .name = "pwm-lpss",
+        .id_table = pwm_lpss_pci_ids,
+        .probe = pwm_lpss_probe_pci,
+        .remove = pwm_lpss_remove_pci,
+};
+module_pci_driver(pwm_lpss_driver_pci);
+
+MODULE_DESCRIPTION("PWM PCI driver for Intel LPSS");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/pwm/pwm-lpss-platform.c b/drivers/pwm/pwm-lpss-platform.c
new file mode 100644
index 000000000000..18a9c880a76d
--- /dev/null
+++ b/drivers/pwm/pwm-lpss-platform.c
@@ -0,0 +1,68 @@
+/*
+ * Intel Low Power Subsystem PWM controller driver
+ *
+ * Copyright (C) 2014, Intel Corporation
+ *
+ * Derived from the original pwm-lpss.c
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/acpi.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+
+#include "pwm-lpss.h"
+
+static int pwm_lpss_probe_platform(struct platform_device *pdev)
+{
+        const struct pwm_lpss_boardinfo *info;
+        const struct acpi_device_id *id;
+        struct pwm_lpss_chip *lpwm;
+        struct resource *r;
+
+        id = acpi_match_device(pdev->dev.driver->acpi_match_table, &pdev->dev);
+        if (!id)
+                return -ENODEV;
+
+        info = (const struct pwm_lpss_boardinfo *)id->driver_data;
+        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+
+        lpwm = pwm_lpss_probe(&pdev->dev, r, info);
+        if (IS_ERR(lpwm))
+                return PTR_ERR(lpwm);
+
+        platform_set_drvdata(pdev, lpwm);
+        return 0;
+}
+
+static int pwm_lpss_remove_platform(struct platform_device *pdev)
+{
+        struct pwm_lpss_chip *lpwm = platform_get_drvdata(pdev);
+
+        return pwm_lpss_remove(lpwm);
+}
+
+static const struct acpi_device_id pwm_lpss_acpi_match[] = {
+        { "80860F09", (unsigned long)&pwm_lpss_byt_info },
+        { "80862288", (unsigned long)&pwm_lpss_bsw_info },
+        { },
+};
+MODULE_DEVICE_TABLE(acpi, pwm_lpss_acpi_match);
+
+static struct platform_driver pwm_lpss_driver_platform = {
+        .driver = {
+                .name = "pwm-lpss",
+                .acpi_match_table = pwm_lpss_acpi_match,
+        },
+        .probe = pwm_lpss_probe_platform,
+        .remove = pwm_lpss_remove_platform,
+};
+module_platform_driver(pwm_lpss_driver_platform);
+
+MODULE_DESCRIPTION("PWM platform driver for Intel LPSS");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:pwm-lpss");
diff --git a/drivers/pwm/pwm-lpss.c b/drivers/pwm/pwm-lpss.c
index 4df994f72d96..e9798253a16f 100644
--- a/drivers/pwm/pwm-lpss.c
+++ b/drivers/pwm/pwm-lpss.c
@@ -13,15 +13,11 @@
  * published by the Free Software Foundation.
  */
 
-#include <linux/acpi.h>
-#include <linux/device.h>
+#include <linux/io.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
-#include <linux/pwm.h>
-#include <linux/platform_device.h>
-#include <linux/pci.h>
 
-static int pci_drv, plat_drv;   /* So we know which drivers registered */
+#include "pwm-lpss.h"
 
 #define PWM                             0x00000000
 #define PWM_ENABLE                      BIT(31)
@@ -39,14 +35,17 @@ struct pwm_lpss_chip {
         unsigned long clk_rate;
 };
 
-struct pwm_lpss_boardinfo {
-        unsigned long clk_rate;
+/* BayTrail */
+const struct pwm_lpss_boardinfo pwm_lpss_byt_info = {
+        .clk_rate = 25000000
 };
+EXPORT_SYMBOL_GPL(pwm_lpss_byt_info);
 
-/* BayTrail */
-static const struct pwm_lpss_boardinfo byt_info = {
-        25000000
+/* Braswell */
+const struct pwm_lpss_boardinfo pwm_lpss_bsw_info = {
+        .clk_rate = 19200000
 };
+EXPORT_SYMBOL_GPL(pwm_lpss_bsw_info);
 
 static inline struct pwm_lpss_chip *to_lpwm(struct pwm_chip *chip)
 {
@@ -118,9 +117,8 @@ static const struct pwm_ops pwm_lpss_ops = {
         .owner = THIS_MODULE,
 };
 
-static struct pwm_lpss_chip *pwm_lpss_probe(struct device *dev,
-                                            struct resource *r,
-                                            const struct pwm_lpss_boardinfo *info)
+struct pwm_lpss_chip *pwm_lpss_probe(struct device *dev, struct resource *r,
+                                     const struct pwm_lpss_boardinfo *info)
 {
         struct pwm_lpss_chip *lpwm;
         int ret;
@@ -147,8 +145,9 @@ static struct pwm_lpss_chip *pwm_lpss_probe(struct device *dev,
 
         return lpwm;
 }
+EXPORT_SYMBOL_GPL(pwm_lpss_probe);
 
-static int pwm_lpss_remove(struct pwm_lpss_chip *lpwm)
+int pwm_lpss_remove(struct pwm_lpss_chip *lpwm)
 {
         u32 ctrl;
 
@@ -157,114 +156,8 @@ static int pwm_lpss_remove(struct pwm_lpss_chip *lpwm)
 
         return pwmchip_remove(&lpwm->chip);
 }
-
-static int pwm_lpss_probe_pci(struct pci_dev *pdev,
-                              const struct pci_device_id *id)
-{
-        const struct pwm_lpss_boardinfo *info;
-        struct pwm_lpss_chip *lpwm;
-        int err;
-
-        err = pci_enable_device(pdev);
-        if (err < 0)
-                return err;
-
-        info = (struct pwm_lpss_boardinfo *)id->driver_data;
-        lpwm = pwm_lpss_probe(&pdev->dev, &pdev->resource[0], info);
-        if (IS_ERR(lpwm))
-                return PTR_ERR(lpwm);
-
-        pci_set_drvdata(pdev, lpwm);
-        return 0;
-}
-
-static void pwm_lpss_remove_pci(struct pci_dev *pdev)
-{
-        struct pwm_lpss_chip *lpwm = pci_get_drvdata(pdev);
-
-        pwm_lpss_remove(lpwm);
-        pci_disable_device(pdev);
-}
-
-static struct pci_device_id pwm_lpss_pci_ids[] = {
-        { PCI_VDEVICE(INTEL, 0x0f08), (unsigned long)&byt_info},
-        { PCI_VDEVICE(INTEL, 0x0f09), (unsigned long)&byt_info},
-        { },
-};
-MODULE_DEVICE_TABLE(pci, pwm_lpss_pci_ids);
-
-static struct pci_driver pwm_lpss_driver_pci = {
-        .name = "pwm-lpss",
-        .id_table = pwm_lpss_pci_ids,
-        .probe = pwm_lpss_probe_pci,
-        .remove = pwm_lpss_remove_pci,
-};
-
-static int pwm_lpss_probe_platform(struct platform_device *pdev)
-{
-        const struct pwm_lpss_boardinfo *info;
-        const struct acpi_device_id *id;
-        struct pwm_lpss_chip *lpwm;
-        struct resource *r;
-
-        id = acpi_match_device(pdev->dev.driver->acpi_match_table, &pdev->dev);
-        if (!id)
-                return -ENODEV;
-
-        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-
-        info = (struct pwm_lpss_boardinfo *)id->driver_data;
-        lpwm = pwm_lpss_probe(&pdev->dev, r, info);
-        if (IS_ERR(lpwm))
-                return PTR_ERR(lpwm);
-
-        platform_set_drvdata(pdev, lpwm);
-        return 0;
-}
-
-static int pwm_lpss_remove_platform(struct platform_device *pdev)
-{
-        struct pwm_lpss_chip *lpwm = platform_get_drvdata(pdev);
-
-        return pwm_lpss_remove(lpwm);
-}
-
-static const struct acpi_device_id pwm_lpss_acpi_match[] = {
-        { "80860F09", (unsigned long)&byt_info },
-        { },
-};
-MODULE_DEVICE_TABLE(acpi, pwm_lpss_acpi_match);
-
-static struct platform_driver pwm_lpss_driver_platform = {
-        .driver = {
-                .name = "pwm-lpss",
-                .acpi_match_table = pwm_lpss_acpi_match,
-        },
-        .probe = pwm_lpss_probe_platform,
-        .remove = pwm_lpss_remove_platform,
-};
-
-static int __init pwm_init(void)
-{
-        pci_drv = pci_register_driver(&pwm_lpss_driver_pci);
-        plat_drv = platform_driver_register(&pwm_lpss_driver_platform);
-        if (pci_drv && plat_drv)
-                return pci_drv;
-
-        return 0;
-}
-module_init(pwm_init);
-
-static void __exit pwm_exit(void)
-{
-        if (!pci_drv)
-                pci_unregister_driver(&pwm_lpss_driver_pci);
-        if (!plat_drv)
-                platform_driver_unregister(&pwm_lpss_driver_platform);
-}
-module_exit(pwm_exit);
+EXPORT_SYMBOL_GPL(pwm_lpss_remove);
 
 MODULE_DESCRIPTION("PWM driver for Intel LPSS");
 MODULE_AUTHOR("Mika Westerberg <mika.westerberg@linux.intel.com>");
 MODULE_LICENSE("GPL v2");
-MODULE_ALIAS("platform:pwm-lpss");
diff --git a/drivers/pwm/pwm-lpss.h b/drivers/pwm/pwm-lpss.h
new file mode 100644
index 000000000000..aa041bb1b67d
--- /dev/null
+++ b/drivers/pwm/pwm-lpss.h
@@ -0,0 +1,32 @@
+/*
+ * Intel Low Power Subsystem PWM controller driver
+ *
+ * Copyright (C) 2014, Intel Corporation
+ *
+ * Derived from the original pwm-lpss.c
+ *
+ * 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 __PWM_LPSS_H
+#define __PWM_LPSS_H
+
+#include <linux/device.h>
+#include <linux/pwm.h>
+
+struct pwm_lpss_chip;
+
+struct pwm_lpss_boardinfo {
+        unsigned long clk_rate;
+};
+
+extern const struct pwm_lpss_boardinfo pwm_lpss_byt_info;
+extern const struct pwm_lpss_boardinfo pwm_lpss_bsw_info;
+
+struct pwm_lpss_chip *pwm_lpss_probe(struct device *dev, struct resource *r,
+                                     const struct pwm_lpss_boardinfo *info);
+int pwm_lpss_remove(struct pwm_lpss_chip *lpwm);
+
+#endif  /* __PWM_LPSS_H */
diff --git a/drivers/pwm/pwm-rockchip.c b/drivers/pwm/pwm-rockchip.c
index bdd8644c01cf..9442df244101 100644
--- a/drivers/pwm/pwm-rockchip.c
+++ b/drivers/pwm/pwm-rockchip.c
@@ -24,7 +24,9 @@
 #define PWM_ENABLE              (1 << 0)
 #define PWM_CONTINUOUS          (1 << 1)
 #define PWM_DUTY_POSITIVE       (1 << 3)
+#define PWM_DUTY_NEGATIVE       (0 << 3)
 #define PWM_INACTIVE_NEGATIVE   (0 << 4)
+#define PWM_INACTIVE_POSITIVE   (1 << 4)
 #define PWM_OUTPUT_LEFT         (0 << 5)
 #define PWM_LP_DISABLE          (0 << 8)
 
@@ -45,8 +47,10 @@ struct rockchip_pwm_regs {
 struct rockchip_pwm_data {
         struct rockchip_pwm_regs regs;
         unsigned int prescaler;
+        const struct pwm_ops *ops;
 
-        void (*set_enable)(struct pwm_chip *chip, bool enable);
+        void (*set_enable)(struct pwm_chip *chip,
+                           struct pwm_device *pwm, bool enable);
 };
 
 static inline struct rockchip_pwm_chip *to_rockchip_pwm_chip(struct pwm_chip *c)
@@ -54,7 +58,8 @@ static inline struct rockchip_pwm_chip *to_rockchip_pwm_chip(struct pwm_chip *c)
         return container_of(c, struct rockchip_pwm_chip, chip);
 }
 
-static void rockchip_pwm_set_enable_v1(struct pwm_chip *chip, bool enable)
+static void rockchip_pwm_set_enable_v1(struct pwm_chip *chip,
+                                       struct pwm_device *pwm, bool enable)
 {
         struct rockchip_pwm_chip *pc = to_rockchip_pwm_chip(chip);
         u32 enable_conf = PWM_CTRL_OUTPUT_EN | PWM_CTRL_TIMER_EN;
@@ -70,14 +75,19 @@ static void rockchip_pwm_set_enable_v1(struct pwm_chip *chip, bool enable)
         writel_relaxed(val, pc->base + pc->data->regs.ctrl);
 }
 
-static void rockchip_pwm_set_enable_v2(struct pwm_chip *chip, bool enable)
+static void rockchip_pwm_set_enable_v2(struct pwm_chip *chip,
+                                       struct pwm_device *pwm, bool enable)
 {
         struct rockchip_pwm_chip *pc = to_rockchip_pwm_chip(chip);
         u32 enable_conf = PWM_OUTPUT_LEFT | PWM_LP_DISABLE | PWM_ENABLE |
-                          PWM_CONTINUOUS | PWM_DUTY_POSITIVE |
-                          PWM_INACTIVE_NEGATIVE;
+                          PWM_CONTINUOUS;
         u32 val;
 
+        if (pwm->polarity == PWM_POLARITY_INVERSED)
+                enable_conf |= PWM_DUTY_NEGATIVE | PWM_INACTIVE_POSITIVE;
+        else
+                enable_conf |= PWM_DUTY_POSITIVE | PWM_INACTIVE_NEGATIVE;
+
         val = readl_relaxed(pc->base + pc->data->regs.ctrl);
 
         if (enable)
@@ -124,6 +134,19 @@ static int rockchip_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
         return 0;
 }
 
+static int rockchip_pwm_set_polarity(struct pwm_chip *chip,
+                                     struct pwm_device *pwm,
+                                     enum pwm_polarity polarity)
+{
+        /*
+         * No action needed here because pwm->polarity will be set by the core
+         * and the core will only change polarity when the PWM is not enabled.
+         * We'll handle things in set_enable().
+         */
+
+        return 0;
+}
+
 static int rockchip_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)
 {
         struct rockchip_pwm_chip *pc = to_rockchip_pwm_chip(chip);
@@ -133,7 +156,7 @@ static int rockchip_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)
         if (ret)
                 return ret;
 
-        pc->data->set_enable(chip, true);
+        pc->data->set_enable(chip, pwm, true);
 
         return 0;
 }
@@ -142,18 +165,26 @@ static void rockchip_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)
 {
         struct rockchip_pwm_chip *pc = to_rockchip_pwm_chip(chip);
 
-        pc->data->set_enable(chip, false);
+        pc->data->set_enable(chip, pwm, false);
 
         clk_disable(pc->clk);
 }
 
-static const struct pwm_ops rockchip_pwm_ops = {
+static const struct pwm_ops rockchip_pwm_ops_v1 = {
         .config = rockchip_pwm_config,
         .enable = rockchip_pwm_enable,
         .disable = rockchip_pwm_disable,
         .owner = THIS_MODULE,
 };
 
+static const struct pwm_ops rockchip_pwm_ops_v2 = {
+        .config = rockchip_pwm_config,
+        .set_polarity = rockchip_pwm_set_polarity,
+        .enable = rockchip_pwm_enable,
+        .disable = rockchip_pwm_disable,
+        .owner = THIS_MODULE,
+};
+
 static const struct rockchip_pwm_data pwm_data_v1 = {
         .regs = {
                 .duty = 0x04,
@@ -162,6 +193,7 @@ static const struct rockchip_pwm_data pwm_data_v1 = {
                 .ctrl = 0x0c,
         },
         .prescaler = 2,
+        .ops = &rockchip_pwm_ops_v1,
         .set_enable = rockchip_pwm_set_enable_v1,
 };
 
@@ -173,6 +205,7 @@ static const struct rockchip_pwm_data pwm_data_v2 = {
                 .ctrl = 0x0c,
         },
         .prescaler = 1,
+        .ops = &rockchip_pwm_ops_v2,
         .set_enable = rockchip_pwm_set_enable_v2,
 };
 
@@ -184,6 +217,7 @@ static const struct rockchip_pwm_data pwm_data_vop = {
                 .ctrl = 0x00,
         },
         .prescaler = 1,
+        .ops = &rockchip_pwm_ops_v2,
         .set_enable = rockchip_pwm_set_enable_v2,
 };
 
@@ -227,10 +261,15 @@ static int rockchip_pwm_probe(struct platform_device *pdev)
 
         pc->data = id->data;
         pc->chip.dev = &pdev->dev;
-        pc->chip.ops = &rockchip_pwm_ops;
+        pc->chip.ops = pc->data->ops;
         pc->chip.base = -1;
         pc->chip.npwm = 1;
 
+        if (pc->data->ops->set_polarity) {
+                pc->chip.of_xlate = of_pwm_xlate_with_flags;
+                pc->chip.of_pwm_n_cells = 3;
+        }
+
         ret = pwmchip_add(&pc->chip);
         if (ret < 0) {
                 clk_unprepare(pc->clk);
diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index 8cd0beebdc3f..94ae1798d48a 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -830,7 +830,7 @@ config RTC_DRV_DA9063
 
 config RTC_DRV_EFI
         tristate "EFI RTC"
-        depends on EFI
+        depends on EFI && !X86
         help
           If you say yes here you will get support for the EFI
           Real Time Clock.
diff --git a/drivers/rtc/rtc-efi.c b/drivers/rtc/rtc-efi.c
index c384fec6d173..53b589dc34eb 100644
--- a/drivers/rtc/rtc-efi.c
+++ b/drivers/rtc/rtc-efi.c
@@ -236,3 +236,4 @@ MODULE_ALIAS("platform:rtc-efi");
 MODULE_AUTHOR("dann frazier <dannf@hp.com>");
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("EFI RTC driver");
+MODULE_ALIAS("platform:rtc-efi");
diff --git a/drivers/s390/char/Kconfig b/drivers/s390/char/Kconfig
index dc24ecfac2d1..db2cb1f8a1b5 100644
--- a/drivers/s390/char/Kconfig
+++ b/drivers/s390/char/Kconfig
@@ -105,7 +105,7 @@ config SCLP_ASYNC
 config HMC_DRV
         def_tristate m
         prompt "Support for file transfers from HMC drive CD/DVD-ROM"
-        depends on 64BIT
+        depends on S390 && 64BIT
         select CRC16
         help
           This option enables support for file transfers from a Hardware
diff --git a/drivers/scsi/osd/Kbuild b/drivers/scsi/osd/Kbuild
index 5fd73d77c3af..58cecd45b0f5 100644
--- a/drivers/scsi/osd/Kbuild
+++ b/drivers/scsi/osd/Kbuild
@@ -4,7 +4,7 @@
 # Copyright (C) 2008 Panasas Inc.  All rights reserved.
 #
 # Authors:
-#   Boaz Harrosh <bharrosh@panasas.com>
+#   Boaz Harrosh <ooo@electrozaur.com>
 #   Benny Halevy <bhalevy@panasas.com>
 #
 # This program is free software; you can redistribute it and/or modify
diff --git a/drivers/scsi/osd/Kconfig b/drivers/scsi/osd/Kconfig
index a0703514eb0f..347cc5e33749 100644
--- a/drivers/scsi/osd/Kconfig
+++ b/drivers/scsi/osd/Kconfig
@@ -4,7 +4,7 @@
 # Copyright (C) 2008 Panasas Inc.  All rights reserved.
 #
 # Authors:
-#   Boaz Harrosh <bharrosh@panasas.com>
+#   Boaz Harrosh <ooo@electrozaur.com>
 #   Benny Halevy <bhalevy@panasas.com>
 #
 # This program is free software; you can redistribute it and/or modify
diff --git a/drivers/scsi/osd/osd_debug.h b/drivers/scsi/osd/osd_debug.h
index 579e491f11df..26341261bb5c 100644
--- a/drivers/scsi/osd/osd_debug.h
+++ b/drivers/scsi/osd/osd_debug.h
@@ -4,7 +4,7 @@
  * Copyright (C) 2008 Panasas Inc.  All rights reserved.
  *
  * Authors:
- *   Boaz Harrosh <bharrosh@panasas.com>
+ *   Boaz Harrosh <ooo@electrozaur.com>
  *   Benny Halevy <bhalevy@panasas.com>
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/drivers/scsi/osd/osd_initiator.c b/drivers/scsi/osd/osd_initiator.c
index fd19fd8468ac..488c3929f19a 100644
--- a/drivers/scsi/osd/osd_initiator.c
+++ b/drivers/scsi/osd/osd_initiator.c
@@ -7,7 +7,7 @@
  * Copyright (C) 2008 Panasas Inc.  All rights reserved.
  *
  * Authors:
- *   Boaz Harrosh <bharrosh@panasas.com>
+ *   Boaz Harrosh <ooo@electrozaur.com>
  *   Benny Halevy <bhalevy@panasas.com>
  *
  * This program is free software; you can redistribute it and/or modify
@@ -57,7 +57,7 @@
 
 enum { OSD_REQ_RETRIES = 1 };
 
-MODULE_AUTHOR("Boaz Harrosh <bharrosh@panasas.com>");
+MODULE_AUTHOR("Boaz Harrosh <ooo@electrozaur.com>");
 MODULE_DESCRIPTION("open-osd initiator library libosd.ko");
 MODULE_LICENSE("GPL");
 
diff --git a/drivers/scsi/osd/osd_uld.c b/drivers/scsi/osd/osd_uld.c
index e1d9a4c4c4b3..92cdd4b06526 100644
--- a/drivers/scsi/osd/osd_uld.c
+++ b/drivers/scsi/osd/osd_uld.c
@@ -10,7 +10,7 @@
  * Copyright (C) 2008 Panasas Inc.  All rights reserved.
  *
  * Authors:
- *   Boaz Harrosh <bharrosh@panasas.com>
+ *   Boaz Harrosh <ooo@electrozaur.com>
  *   Benny Halevy <bhalevy@panasas.com>
  *
  * This program is free software; you can redistribute it and/or modify
@@ -74,7 +74,7 @@
 static const char osd_name[] = "osd";
 static const char *osd_version_string = "open-osd 0.2.1";
 
-MODULE_AUTHOR("Boaz Harrosh <bharrosh@panasas.com>");
+MODULE_AUTHOR("Boaz Harrosh <ooo@electrozaur.com>");
 MODULE_DESCRIPTION("open-osd Upper-Layer-Driver osd.ko");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS_CHARDEV_MAJOR(SCSI_OSD_MAJOR);
diff --git a/drivers/scsi/qla2xxx/qla_target.c b/drivers/scsi/qla2xxx/qla_target.c
index 829752cfd73f..a902fa1db7af 100644
--- a/drivers/scsi/qla2xxx/qla_target.c
+++ b/drivers/scsi/qla2xxx/qla_target.c
@@ -112,6 +112,7 @@ static void qlt_abort_cmd_on_host_reset(struct scsi_qla_host *vha,
         struct qla_tgt_cmd *cmd);
 static void qlt_alloc_qfull_cmd(struct scsi_qla_host *vha,
         struct atio_from_isp *atio, uint16_t status, int qfull);
+static void qlt_disable_vha(struct scsi_qla_host *vha);
 /*
  * Global Variables
  */
@@ -210,7 +211,7 @@ static inline void qlt_decr_num_pend_cmds(struct scsi_qla_host *vha)
         spin_unlock_irqrestore(&vha->hw->tgt.q_full_lock, flags);
 }
 
-void qlt_24xx_atio_pkt_all_vps(struct scsi_qla_host *vha,
+static void qlt_24xx_atio_pkt_all_vps(struct scsi_qla_host *vha,
         struct atio_from_isp *atio)
 {
         ql_dbg(ql_dbg_tgt, vha, 0xe072,
@@ -433,7 +434,7 @@ static int qlt_reset(struct scsi_qla_host *vha, void *iocb, int mcmd)
 #if 0 /* FIXME: Re-enable Global event handling.. */
                 /* Global event */
                 atomic_inc(&ha->tgt.qla_tgt->tgt_global_resets_count);
-                qlt_clear_tgt_db(ha->tgt.qla_tgt, 1);
+                qlt_clear_tgt_db(ha->tgt.qla_tgt);
                 if (!list_empty(&ha->tgt.qla_tgt->sess_list)) {
                         sess = list_entry(ha->tgt.qla_tgt->sess_list.next,
                             typeof(*sess), sess_list_entry);
@@ -515,7 +516,7 @@ static void qlt_schedule_sess_for_deletion(struct qla_tgt_sess *sess,
 }
 
 /* ha->hardware_lock supposed to be held on entry */
-static void qlt_clear_tgt_db(struct qla_tgt *tgt, bool local_only)
+static void qlt_clear_tgt_db(struct qla_tgt *tgt)
 {
         struct qla_tgt_sess *sess;
 
@@ -867,7 +868,7 @@ int qlt_stop_phase1(struct qla_tgt *tgt)
         mutex_lock(&vha->vha_tgt.tgt_mutex);
         spin_lock_irqsave(&ha->hardware_lock, flags);
         tgt->tgt_stop = 1;
-        qlt_clear_tgt_db(tgt, true);
+        qlt_clear_tgt_db(tgt);
         spin_unlock_irqrestore(&ha->hardware_lock, flags);
         mutex_unlock(&vha->vha_tgt.tgt_mutex);
         mutex_unlock(&qla_tgt_mutex);
@@ -1462,12 +1463,13 @@ out_err:
         return -1;
 }
 
-static inline void qlt_unmap_sg(struct scsi_qla_host *vha,
-        struct qla_tgt_cmd *cmd)
+static void qlt_unmap_sg(struct scsi_qla_host *vha, struct qla_tgt_cmd *cmd)
 {
         struct qla_hw_data *ha = vha->hw;
 
-        BUG_ON(!cmd->sg_mapped);
+        if (!cmd->sg_mapped)
+                return;
+
         pci_unmap_sg(ha->pdev, cmd->sg, cmd->sg_cnt, cmd->dma_data_direction);
         cmd->sg_mapped = 0;
 
@@ -2428,8 +2430,7 @@ int qlt_xmit_response(struct qla_tgt_cmd *cmd, int xmit_type,
         return 0;
 
 out_unmap_unlock:
-        if (cmd->sg_mapped)
-                qlt_unmap_sg(vha, cmd);
+        qlt_unmap_sg(vha, cmd);
         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 
         return res;
@@ -2506,8 +2507,7 @@ int qlt_rdy_to_xfer(struct qla_tgt_cmd *cmd)
         return res;
 
 out_unlock_free_unmap:
-        if (cmd->sg_mapped)
-                qlt_unmap_sg(vha, cmd);
+        qlt_unmap_sg(vha, cmd);
         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 
         return res;
@@ -2741,8 +2741,7 @@ done:
                 if (!ha_locked && !in_interrupt())
                         msleep(250); /* just in case */
 
-                if (cmd->sg_mapped)
-                        qlt_unmap_sg(vha, cmd);
+                qlt_unmap_sg(vha, cmd);
                 vha->hw->tgt.tgt_ops->free_cmd(cmd);
         }
         return;
@@ -3087,8 +3086,7 @@ static void qlt_do_ctio_completion(struct scsi_qla_host *vha, uint32_t handle,
         tfo = se_cmd->se_tfo;
         cmd->cmd_sent_to_fw = 0;
 
-        if (cmd->sg_mapped)
-                qlt_unmap_sg(vha, cmd);
+        qlt_unmap_sg(vha, cmd);
 
         if (unlikely(status != CTIO_SUCCESS)) {
                 switch (status & 0xFFFF) {
@@ -5343,7 +5341,7 @@ void qlt_lport_deregister(struct scsi_qla_host *vha)
 EXPORT_SYMBOL(qlt_lport_deregister);
 
 /* Must be called under HW lock */
-void qlt_set_mode(struct scsi_qla_host *vha)
+static void qlt_set_mode(struct scsi_qla_host *vha)
 {
         struct qla_hw_data *ha = vha->hw;
 
@@ -5364,7 +5362,7 @@ void qlt_set_mode(struct scsi_qla_host *vha)
 }
 
 /* Must be called under HW lock */
-void qlt_clear_mode(struct scsi_qla_host *vha)
+static void qlt_clear_mode(struct scsi_qla_host *vha)
 {
         struct qla_hw_data *ha = vha->hw;
 
@@ -5428,8 +5426,7 @@ EXPORT_SYMBOL(qlt_enable_vha);
  *
  * Disable Target Mode and reset the adapter
  */
-void
-qlt_disable_vha(struct scsi_qla_host *vha)
+static void qlt_disable_vha(struct scsi_qla_host *vha)
 {
         struct qla_hw_data *ha = vha->hw;
         struct qla_tgt *tgt = vha->vha_tgt.qla_tgt;
diff --git a/drivers/scsi/qla2xxx/qla_target.h b/drivers/scsi/qla2xxx/qla_target.h
index 8ff330f7d6f5..332086776dfe 100644
--- a/drivers/scsi/qla2xxx/qla_target.h
+++ b/drivers/scsi/qla2xxx/qla_target.h
@@ -1001,11 +1001,11 @@ struct qla_tgt_prm {
         struct qla_tgt *tgt;
         void *pkt;
         struct scatterlist *sg; /* cmd data buffer SG vector */
+        unsigned char *sense_buffer;
         int seg_cnt;
         int req_cnt;
         uint16_t rq_result;
         uint16_t scsi_status;
-        unsigned char *sense_buffer;
         int sense_buffer_len;
         int residual;
         int add_status_pkt;
@@ -1033,10 +1033,6 @@ struct qla_tgt_srr_ctio {
 
 
 extern struct qla_tgt_data qla_target;
-/*
- * Internal function prototypes
- */
-void qlt_disable_vha(struct scsi_qla_host *);
 
 /*
  * Function prototypes for qla_target.c logic used by qla2xxx LLD code.
@@ -1049,8 +1045,6 @@ extern void qlt_lport_deregister(struct scsi_qla_host *);
 extern void qlt_unreg_sess(struct qla_tgt_sess *);
 extern void qlt_fc_port_added(struct scsi_qla_host *, fc_port_t *);
 extern void qlt_fc_port_deleted(struct scsi_qla_host *, fc_port_t *);
-extern void qlt_set_mode(struct scsi_qla_host *ha);
-extern void qlt_clear_mode(struct scsi_qla_host *ha);
 extern int __init qlt_init(void);
 extern void qlt_exit(void);
 extern void qlt_update_vp_map(struct scsi_qla_host *, int);
@@ -1083,13 +1077,9 @@ static inline void qla_reverse_ini_mode(struct scsi_qla_host *ha)
 /*
  * Exported symbols from qla_target.c LLD logic used by qla2xxx code..
  */
-extern void qlt_24xx_atio_pkt_all_vps(struct scsi_qla_host *,
-        struct atio_from_isp *);
 extern void qlt_response_pkt_all_vps(struct scsi_qla_host *, response_t *);
 extern int qlt_rdy_to_xfer(struct qla_tgt_cmd *);
 extern int qlt_xmit_response(struct qla_tgt_cmd *, int, uint8_t);
-extern int qlt_rdy_to_xfer_dif(struct qla_tgt_cmd *);
-extern int qlt_xmit_response_dif(struct qla_tgt_cmd *, int, uint8_t);
 extern void qlt_xmit_tm_rsp(struct qla_tgt_mgmt_cmd *);
 extern void qlt_free_mcmd(struct qla_tgt_mgmt_cmd *);
 extern void qlt_free_cmd(struct qla_tgt_cmd *cmd);
diff --git a/drivers/scsi/qla2xxx/tcm_qla2xxx.c b/drivers/scsi/qla2xxx/tcm_qla2xxx.c
index 031b2961c6b7..73f9feecda72 100644
--- a/drivers/scsi/qla2xxx/tcm_qla2xxx.c
+++ b/drivers/scsi/qla2xxx/tcm_qla2xxx.c
@@ -786,7 +786,16 @@ static void tcm_qla2xxx_clear_nacl_from_fcport_map(struct qla_tgt_sess *sess)
         pr_debug("fc_rport domain: port_id 0x%06x\n", nacl->nport_id);
 
         node = btree_remove32(&lport->lport_fcport_map, nacl->nport_id);
-        WARN_ON(node && (node != se_nacl));
+        if (WARN_ON(node && (node != se_nacl))) {
+                /*
+                 * The nacl no longer matches what we think it should be.
+                 * Most likely a new dynamic acl has been added while
+                 * someone dropped the hardware lock.  It clearly is a
+                 * bug elsewhere, but this bit can't make things worse.
+                 */
+                btree_insert32(&lport->lport_fcport_map, nacl->nport_id,
+                               node, GFP_ATOMIC);
+        }
 
         pr_debug("Removed from fcport_map: %p for WWNN: 0x%016LX, port_id: 0x%06x\n",
             se_nacl, nacl->nport_wwnn, nacl->nport_id);
diff --git a/drivers/target/Kconfig b/drivers/target/Kconfig
index dc2d84ac5a0e..81d44c477a5b 100644
--- a/drivers/target/Kconfig
+++ b/drivers/target/Kconfig
@@ -31,6 +31,13 @@ config TCM_PSCSI
         Say Y here to enable the TCM/pSCSI subsystem plugin for non-buffered
         passthrough access to Linux/SCSI device
 
+config TCM_USER
+        tristate "TCM/USER Subsystem Plugin for Linux"
+        depends on UIO && NET
+        help
+        Say Y here to enable the TCM/USER subsystem plugin for a userspace
+        process to handle requests
+
 source "drivers/target/loopback/Kconfig"
 source "drivers/target/tcm_fc/Kconfig"
 source "drivers/target/iscsi/Kconfig"
diff --git a/drivers/target/Makefile b/drivers/target/Makefile
index 85b012d2f89b..bbb4a7d638ef 100644
--- a/drivers/target/Makefile
+++ b/drivers/target/Makefile
@@ -22,6 +22,7 @@ obj-$(CONFIG_TARGET_CORE)	+= target_core_mod.o
 obj-$(CONFIG_TCM_IBLOCK)        += target_core_iblock.o
 obj-$(CONFIG_TCM_FILEIO)        += target_core_file.o
 obj-$(CONFIG_TCM_PSCSI)         += target_core_pscsi.o
+obj-$(CONFIG_TCM_USER)          += target_core_user.o
 
 # Fabric modules
 obj-$(CONFIG_LOOPBACK_TARGET)   += loopback/
diff --git a/drivers/target/iscsi/iscsi_target.c b/drivers/target/iscsi/iscsi_target.c
index 260c3e1e312c..b19e4329ba00 100644
--- a/drivers/target/iscsi/iscsi_target.c
+++ b/drivers/target/iscsi/iscsi_target.c
@@ -3709,7 +3709,6 @@ static inline void iscsit_thread_check_cpumask(
         struct task_struct *p,
         int mode)
 {
-        char buf[128];
         /*
          * mode == 1 signals iscsi_target_tx_thread() usage.
          * mode == 0 signals iscsi_target_rx_thread() usage.
@@ -3728,8 +3727,6 @@ static inline void iscsit_thread_check_cpumask(
          * both TX and RX kthreads are scheduled to run on the
          * same CPU.
          */
-        memset(buf, 0, 128);
-        cpumask_scnprintf(buf, 128, conn->conn_cpumask);
         set_cpus_allowed_ptr(p, conn->conn_cpumask);
 }
 
@@ -4326,8 +4323,7 @@ int iscsit_close_connection(
         if (conn->conn_tx_hash.tfm)
                 crypto_free_hash(conn->conn_tx_hash.tfm);
 
-        if (conn->conn_cpumask)
-                free_cpumask_var(conn->conn_cpumask);
+        free_cpumask_var(conn->conn_cpumask);
 
         kfree(conn->conn_ops);
         conn->conn_ops = NULL;
diff --git a/drivers/target/iscsi/iscsi_target_configfs.c b/drivers/target/iscsi/iscsi_target_configfs.c
index ae03f3e5de1e..9059c1e0b26e 100644
--- a/drivers/target/iscsi/iscsi_target_configfs.c
+++ b/drivers/target/iscsi/iscsi_target_configfs.c
@@ -669,12 +669,10 @@ static ssize_t lio_target_nacl_show_info(
         } else {
                 sess = se_sess->fabric_sess_ptr;
 
-                if (sess->sess_ops->InitiatorName)
-                        rb += sprintf(page+rb, "InitiatorName: %s\n",
-                                sess->sess_ops->InitiatorName);
-                if (sess->sess_ops->InitiatorAlias)
-                        rb += sprintf(page+rb, "InitiatorAlias: %s\n",
-                                sess->sess_ops->InitiatorAlias);
+                rb += sprintf(page+rb, "InitiatorName: %s\n",
+                        sess->sess_ops->InitiatorName);
+                rb += sprintf(page+rb, "InitiatorAlias: %s\n",
+                        sess->sess_ops->InitiatorAlias);
 
                 rb += sprintf(page+rb, "LIO Session ID: %u   "
                         "ISID: 0x%02x %02x %02x %02x %02x %02x  "
diff --git a/drivers/target/iscsi/iscsi_target_erl0.c b/drivers/target/iscsi/iscsi_target_erl0.c
index 0d1e6ee3e992..a0ae5fc0ad75 100644
--- a/drivers/target/iscsi/iscsi_target_erl0.c
+++ b/drivers/target/iscsi/iscsi_target_erl0.c
@@ -345,7 +345,6 @@ static int iscsit_dataout_check_datasn(
         struct iscsi_cmd *cmd,
         unsigned char *buf)
 {
-        int dump = 0, recovery = 0;
         u32 data_sn = 0;
         struct iscsi_conn *conn = cmd->conn;
         struct iscsi_data *hdr = (struct iscsi_data *) buf;
@@ -370,13 +369,11 @@ static int iscsit_dataout_check_datasn(
                 pr_err("Command ITT: 0x%08x, received DataSN: 0x%08x"
                         " higher than expected 0x%08x.\n", cmd->init_task_tag,
                                 be32_to_cpu(hdr->datasn), data_sn);
-                recovery = 1;
                 goto recover;
         } else if (be32_to_cpu(hdr->datasn) < data_sn) {
                 pr_err("Command ITT: 0x%08x, received DataSN: 0x%08x"
                         " lower than expected 0x%08x, discarding payload.\n",
                         cmd->init_task_tag, be32_to_cpu(hdr->datasn), data_sn);
-                dump = 1;
                 goto dump;
         }
 
@@ -392,8 +389,7 @@ dump:
         if (iscsit_dump_data_payload(conn, payload_length, 1) < 0)
                 return DATAOUT_CANNOT_RECOVER;
 
-        return (recovery || dump) ? DATAOUT_WITHIN_COMMAND_RECOVERY :
-                                DATAOUT_NORMAL;
+        return DATAOUT_WITHIN_COMMAND_RECOVERY;
 }
 
 static int iscsit_dataout_pre_datapduinorder_yes(
diff --git a/drivers/target/iscsi/iscsi_target_login.c b/drivers/target/iscsi/iscsi_target_login.c
index 5e71ac609418..480f2e0ecc11 100644
--- a/drivers/target/iscsi/iscsi_target_login.c
+++ b/drivers/target/iscsi/iscsi_target_login.c
@@ -978,8 +978,7 @@ int iscsit_setup_np(
         return 0;
 fail:
         np->np_socket = NULL;
-        if (sock)
-                sock_release(sock);
+        sock_release(sock);
         return ret;
 }
 
@@ -1190,8 +1189,7 @@ old_sess_out:
         if (!IS_ERR(conn->conn_tx_hash.tfm))
                 crypto_free_hash(conn->conn_tx_hash.tfm);
 
-        if (conn->conn_cpumask)
-                free_cpumask_var(conn->conn_cpumask);
+        free_cpumask_var(conn->conn_cpumask);
 
         kfree(conn->conn_ops);
 
@@ -1268,8 +1266,6 @@ static int __iscsi_target_login_thread(struct iscsi_np *np)
                         iscsit_put_transport(conn->conn_transport);
                         kfree(conn);
                         conn = NULL;
-                        if (ret == -ENODEV)
-                                goto out;
                         /* Get another socket */
                         return 1;
                 }
diff --git a/drivers/target/iscsi/iscsi_target_util.c b/drivers/target/iscsi/iscsi_target_util.c
index 73355f4fca74..ce87ce9bdb9c 100644
--- a/drivers/target/iscsi/iscsi_target_util.c
+++ b/drivers/target/iscsi/iscsi_target_util.c
@@ -1481,8 +1481,9 @@ void iscsit_collect_login_stats(
                 if (conn->param_list)
                         intrname = iscsi_find_param_from_key(INITIATORNAME,
                                                              conn->param_list);
-                strcpy(ls->last_intr_fail_name,
-                       (intrname ? intrname->value : "Unknown"));
+                strlcpy(ls->last_intr_fail_name,
+                       (intrname ? intrname->value : "Unknown"),
+                       sizeof(ls->last_intr_fail_name));
 
                 ls->last_intr_fail_ip_family = conn->login_family;
 
diff --git a/drivers/target/loopback/tcm_loop.c b/drivers/target/loopback/tcm_loop.c
index 340de9d92b15..ab3ab27d49b7 100644
--- a/drivers/target/loopback/tcm_loop.c
+++ b/drivers/target/loopback/tcm_loop.c
@@ -153,18 +153,11 @@ static int tcm_loop_change_queue_type(struct scsi_device *sdev, int tag)
 /*
  * Locate the SAM Task Attr from struct scsi_cmnd *
  */
-static int tcm_loop_sam_attr(struct scsi_cmnd *sc)
-{
-        if (sc->device->tagged_supported) {
-                switch (sc->tag) {
-                case HEAD_OF_QUEUE_TAG:
-                        return MSG_HEAD_TAG;
-                case ORDERED_QUEUE_TAG:
-                        return MSG_ORDERED_TAG;
-                default:
-                        break;
-                }
-        }
+static int tcm_loop_sam_attr(struct scsi_cmnd *sc, int tag)
+{
+        if (sc->device->tagged_supported &&
+            sc->device->ordered_tags && tag >= 0)
+                return MSG_ORDERED_TAG;
 
         return MSG_SIMPLE_TAG;
 }
@@ -227,7 +220,7 @@ static void tcm_loop_submission_work(struct work_struct *work)
 
         rc = target_submit_cmd_map_sgls(se_cmd, tl_nexus->se_sess, sc->cmnd,
                         &tl_cmd->tl_sense_buf[0], tl_cmd->sc->device->lun,
-                        transfer_length, tcm_loop_sam_attr(sc),
+                        transfer_length, tcm_loop_sam_attr(sc, tl_cmd->sc_cmd_tag),
                         sc->sc_data_direction, 0,
                         scsi_sglist(sc), scsi_sg_count(sc),
                         sgl_bidi, sgl_bidi_count,
@@ -266,7 +259,7 @@ static int tcm_loop_queuecommand(struct Scsi_Host *sh, struct scsi_cmnd *sc)
         }
 
         tl_cmd->sc = sc;
-        tl_cmd->sc_cmd_tag = sc->tag;
+        tl_cmd->sc_cmd_tag = sc->request->tag;
         INIT_WORK(&tl_cmd->work, tcm_loop_submission_work);
         queue_work(tcm_loop_workqueue, &tl_cmd->work);
         return 0;
@@ -370,7 +363,7 @@ static int tcm_loop_abort_task(struct scsi_cmnd *sc)
          */
         tl_tpg = &tl_hba->tl_hba_tpgs[sc->device->id];
         ret = tcm_loop_issue_tmr(tl_tpg, tl_nexus, sc->device->lun,
-                                 sc->tag, TMR_ABORT_TASK);
+                                 sc->request->tag, TMR_ABORT_TASK);
         return (ret == TMR_FUNCTION_COMPLETE) ? SUCCESS : FAILED;
 }
 
@@ -960,8 +953,7 @@ static int tcm_loop_port_link(
                                 struct tcm_loop_tpg, tl_se_tpg);
         struct tcm_loop_hba *tl_hba = tl_tpg->tl_hba;
 
-        atomic_inc(&tl_tpg->tl_tpg_port_count);
-        smp_mb__after_atomic();
+        atomic_inc_mb(&tl_tpg->tl_tpg_port_count);
         /*
          * Add Linux/SCSI struct scsi_device by HCTL
          */
@@ -995,8 +987,7 @@ static void tcm_loop_port_unlink(
         scsi_remove_device(sd);
         scsi_device_put(sd);
 
-        atomic_dec(&tl_tpg->tl_tpg_port_count);
-        smp_mb__after_atomic();
+        atomic_dec_mb(&tl_tpg->tl_tpg_port_count);
 
         pr_debug("TCM_Loop_ConfigFS: Port Unlink Successful\n");
 }
diff --git a/drivers/target/target_core_alua.c b/drivers/target/target_core_alua.c
index fbc5ebb5f761..fb87780929d2 100644
--- a/drivers/target/target_core_alua.c
+++ b/drivers/target/target_core_alua.c
@@ -392,8 +392,7 @@ target_emulate_set_target_port_groups(struct se_cmd *cmd)
                                 if (tg_pt_id != tg_pt_gp->tg_pt_gp_id)
                                         continue;
 
-                                atomic_inc(&tg_pt_gp->tg_pt_gp_ref_cnt);
-                                smp_mb__after_atomic();
+                                atomic_inc_mb(&tg_pt_gp->tg_pt_gp_ref_cnt);
 
                                 spin_unlock(&dev->t10_alua.tg_pt_gps_lock);
 
@@ -403,8 +402,7 @@ target_emulate_set_target_port_groups(struct se_cmd *cmd)
                                         found = true;
 
                                 spin_lock(&dev->t10_alua.tg_pt_gps_lock);
-                                atomic_dec(&tg_pt_gp->tg_pt_gp_ref_cnt);
-                                smp_mb__after_atomic();
+                                atomic_dec_mb(&tg_pt_gp->tg_pt_gp_ref_cnt);
                                 break;
                         }
                         spin_unlock(&dev->t10_alua.tg_pt_gps_lock);
@@ -998,8 +996,7 @@ static void core_alua_do_transition_tg_pt_work(struct work_struct *work)
                  * every I_T nexus other than the I_T nexus on which the SET
                  * TARGET PORT GROUPS command
                  */
-                atomic_inc(&mem->tg_pt_gp_mem_ref_cnt);
-                smp_mb__after_atomic();
+                atomic_inc_mb(&mem->tg_pt_gp_mem_ref_cnt);
                 spin_unlock(&tg_pt_gp->tg_pt_gp_lock);
 
                 spin_lock_bh(&port->sep_alua_lock);
@@ -1028,8 +1025,7 @@ static void core_alua_do_transition_tg_pt_work(struct work_struct *work)
                 spin_unlock_bh(&port->sep_alua_lock);
 
                 spin_lock(&tg_pt_gp->tg_pt_gp_lock);
-                atomic_dec(&mem->tg_pt_gp_mem_ref_cnt);
-                smp_mb__after_atomic();
+                atomic_dec_mb(&mem->tg_pt_gp_mem_ref_cnt);
         }
         spin_unlock(&tg_pt_gp->tg_pt_gp_lock);
         /*
@@ -1063,7 +1059,6 @@ static void core_alua_do_transition_tg_pt_work(struct work_struct *work)
                 core_alua_dump_state(tg_pt_gp->tg_pt_gp_alua_pending_state));
         spin_lock(&dev->t10_alua.tg_pt_gps_lock);
         atomic_dec(&tg_pt_gp->tg_pt_gp_ref_cnt);
-        smp_mb__after_atomic();
         spin_unlock(&dev->t10_alua.tg_pt_gps_lock);
 
         if (tg_pt_gp->tg_pt_gp_transition_complete)
@@ -1125,7 +1120,6 @@ static int core_alua_do_transition_tg_pt(
          */
         spin_lock(&dev->t10_alua.tg_pt_gps_lock);
         atomic_inc(&tg_pt_gp->tg_pt_gp_ref_cnt);
-        smp_mb__after_atomic();
         spin_unlock(&dev->t10_alua.tg_pt_gps_lock);
 
         if (!explicit && tg_pt_gp->tg_pt_gp_implicit_trans_secs) {
@@ -1168,7 +1162,6 @@ int core_alua_do_port_transition(
         spin_lock(&local_lu_gp_mem->lu_gp_mem_lock);
         lu_gp = local_lu_gp_mem->lu_gp;
         atomic_inc(&lu_gp->lu_gp_ref_cnt);
-        smp_mb__after_atomic();
         spin_unlock(&local_lu_gp_mem->lu_gp_mem_lock);
         /*
          * For storage objects that are members of the 'default_lu_gp',
@@ -1184,8 +1177,7 @@ int core_alua_do_port_transition(
                 l_tg_pt_gp->tg_pt_gp_alua_nacl = l_nacl;
                 rc = core_alua_do_transition_tg_pt(l_tg_pt_gp,
                                                    new_state, explicit);
-                atomic_dec(&lu_gp->lu_gp_ref_cnt);
-                smp_mb__after_atomic();
+                atomic_dec_mb(&lu_gp->lu_gp_ref_cnt);
                 return rc;
         }
         /*
@@ -1198,8 +1190,7 @@ int core_alua_do_port_transition(
                                 lu_gp_mem_list) {
 
                 dev = lu_gp_mem->lu_gp_mem_dev;
-                atomic_inc(&lu_gp_mem->lu_gp_mem_ref_cnt);
-                smp_mb__after_atomic();
+                atomic_inc_mb(&lu_gp_mem->lu_gp_mem_ref_cnt);
                 spin_unlock(&lu_gp->lu_gp_lock);
 
                 spin_lock(&dev->t10_alua.tg_pt_gps_lock);
@@ -1227,8 +1218,7 @@ int core_alua_do_port_transition(
                                 tg_pt_gp->tg_pt_gp_alua_port = NULL;
                                 tg_pt_gp->tg_pt_gp_alua_nacl = NULL;
                         }
-                        atomic_inc(&tg_pt_gp->tg_pt_gp_ref_cnt);
-                        smp_mb__after_atomic();
+                        atomic_inc_mb(&tg_pt_gp->tg_pt_gp_ref_cnt);
                         spin_unlock(&dev->t10_alua.tg_pt_gps_lock);
                         /*
                          * core_alua_do_transition_tg_pt() will always return
@@ -1238,16 +1228,14 @@ int core_alua_do_port_transition(
                                         new_state, explicit);
 
                         spin_lock(&dev->t10_alua.tg_pt_gps_lock);
-                        atomic_dec(&tg_pt_gp->tg_pt_gp_ref_cnt);
-                        smp_mb__after_atomic();
+                        atomic_dec_mb(&tg_pt_gp->tg_pt_gp_ref_cnt);
                         if (rc)
                                 break;
                 }
                 spin_unlock(&dev->t10_alua.tg_pt_gps_lock);
 
                 spin_lock(&lu_gp->lu_gp_lock);
-                atomic_dec(&lu_gp_mem->lu_gp_mem_ref_cnt);
-                smp_mb__after_atomic();
+                atomic_dec_mb(&lu_gp_mem->lu_gp_mem_ref_cnt);
         }
         spin_unlock(&lu_gp->lu_gp_lock);
 
@@ -1260,8 +1248,7 @@ int core_alua_do_port_transition(
                          core_alua_dump_state(new_state));
         }
 
-        atomic_dec(&lu_gp->lu_gp_ref_cnt);
-        smp_mb__after_atomic();
+        atomic_dec_mb(&lu_gp->lu_gp_ref_cnt);
         return rc;
 }
 
diff --git a/drivers/target/target_core_configfs.c b/drivers/target/target_core_configfs.c
index 756def38c77a..79f9296a08ae 100644
--- a/drivers/target/target_core_configfs.c
+++ b/drivers/target/target_core_configfs.c
@@ -665,6 +665,9 @@ SE_DEV_ATTR(is_nonrot, S_IRUGO | S_IWUSR);
 DEF_DEV_ATTRIB(emulate_rest_reord);
 SE_DEV_ATTR(emulate_rest_reord, S_IRUGO | S_IWUSR);
 
+DEF_DEV_ATTRIB(force_pr_aptpl);
+SE_DEV_ATTR(force_pr_aptpl, S_IRUGO | S_IWUSR);
+
 DEF_DEV_ATTRIB_RO(hw_block_size);
 SE_DEV_ATTR_RO(hw_block_size);
 
@@ -719,6 +722,7 @@ static struct configfs_attribute *target_core_dev_attrib_attrs[] = {
         &target_core_dev_attrib_hw_pi_prot_type.attr,
         &target_core_dev_attrib_pi_prot_format.attr,
         &target_core_dev_attrib_enforce_pr_isids.attr,
+        &target_core_dev_attrib_force_pr_aptpl.attr,
         &target_core_dev_attrib_is_nonrot.attr,
         &target_core_dev_attrib_emulate_rest_reord.attr,
         &target_core_dev_attrib_hw_block_size.attr,
@@ -1263,7 +1267,7 @@ static ssize_t target_core_dev_pr_store_attr_res_aptpl_metadata(
 {
         unsigned char *i_fabric = NULL, *i_port = NULL, *isid = NULL;
         unsigned char *t_fabric = NULL, *t_port = NULL;
-        char *orig, *ptr, *arg_p, *opts;
+        char *orig, *ptr, *opts;
         substring_t args[MAX_OPT_ARGS];
         unsigned long long tmp_ll;
         u64 sa_res_key = 0;
@@ -1295,14 +1299,14 @@ static ssize_t target_core_dev_pr_store_attr_res_aptpl_metadata(
                 token = match_token(ptr, tokens, args);
                 switch (token) {
                 case Opt_initiator_fabric:
-                        i_fabric = match_strdup(&args[0]);
+                        i_fabric = match_strdup(args);
                         if (!i_fabric) {
                                 ret = -ENOMEM;
                                 goto out;
                         }
                         break;
                 case Opt_initiator_node:
-                        i_port = match_strdup(&args[0]);
+                        i_port = match_strdup(args);
                         if (!i_port) {
                                 ret = -ENOMEM;
                                 goto out;
@@ -1316,7 +1320,7 @@ static ssize_t target_core_dev_pr_store_attr_res_aptpl_metadata(
                         }
                         break;
                 case Opt_initiator_sid:
-                        isid = match_strdup(&args[0]);
+                        isid = match_strdup(args);
                         if (!isid) {
                                 ret = -ENOMEM;
                                 goto out;
@@ -1330,15 +1334,9 @@ static ssize_t target_core_dev_pr_store_attr_res_aptpl_metadata(
                         }
                         break;
                 case Opt_sa_res_key:
-                        arg_p = match_strdup(&args[0]);
-                        if (!arg_p) {
-                                ret = -ENOMEM;
-                                goto out;
-                        }
-                        ret = kstrtoull(arg_p, 0, &tmp_ll);
+                        ret = kstrtoull(args->from, 0, &tmp_ll);
                         if (ret < 0) {
-                                pr_err("kstrtoull() failed for"
-                                        " sa_res_key=\n");
+                                pr_err("kstrtoull() failed for sa_res_key=\n");
                                 goto out;
                         }
                         sa_res_key = (u64)tmp_ll;
@@ -1370,14 +1368,14 @@ static ssize_t target_core_dev_pr_store_attr_res_aptpl_metadata(
                  * PR APTPL Metadata for Target Port
                  */
                 case Opt_target_fabric:
-                        t_fabric = match_strdup(&args[0]);
+                        t_fabric = match_strdup(args);
                         if (!t_fabric) {
                                 ret = -ENOMEM;
                                 goto out;
                         }
                         break;
                 case Opt_target_node:
-                        t_port = match_strdup(&args[0]);
+                        t_port = match_strdup(args);
                         if (!t_port) {
                                 ret = -ENOMEM;
                                 goto out;
diff --git a/drivers/target/target_core_device.c b/drivers/target/target_core_device.c
index 98da90167159..c45f9e907e44 100644
--- a/drivers/target/target_core_device.c
+++ b/drivers/target/target_core_device.c
@@ -224,8 +224,7 @@ struct se_dev_entry *core_get_se_deve_from_rtpi(
                 if (port->sep_rtpi != rtpi)
                         continue;
 
-                atomic_inc(&deve->pr_ref_count);
-                smp_mb__after_atomic();
+                atomic_inc_mb(&deve->pr_ref_count);
                 spin_unlock_irq(&nacl->device_list_lock);
 
                 return deve;
@@ -1019,6 +1018,23 @@ int se_dev_set_enforce_pr_isids(struct se_device *dev, int flag)
         return 0;
 }
 
+int se_dev_set_force_pr_aptpl(struct se_device *dev, int flag)
+{
+        if ((flag != 0) && (flag != 1)) {
+                printk(KERN_ERR "Illegal value %d\n", flag);
+                return -EINVAL;
+        }
+        if (dev->export_count) {
+                pr_err("dev[%p]: Unable to set force_pr_aptpl while"
+                       " export_count is %d\n", dev, dev->export_count);
+                return -EINVAL;
+        }
+
+        dev->dev_attrib.force_pr_aptpl = flag;
+        pr_debug("dev[%p]: SE Device force_pr_aptpl: %d\n", dev, flag);
+        return 0;
+}
+
 int se_dev_set_is_nonrot(struct se_device *dev, int flag)
 {
         if ((flag != 0) && (flag != 1)) {
@@ -1250,24 +1266,16 @@ struct se_lun *core_dev_add_lun(
  *
  *
  */
-int core_dev_del_lun(
+void core_dev_del_lun(
         struct se_portal_group *tpg,
-        u32 unpacked_lun)
+        struct se_lun *lun)
 {
-        struct se_lun *lun;
-
-        lun = core_tpg_pre_dellun(tpg, unpacked_lun);
-        if (IS_ERR(lun))
-                return PTR_ERR(lun);
-
-        core_tpg_post_dellun(tpg, lun);
-
-        pr_debug("%s_TPG[%u]_LUN[%u] - Deactivated %s Logical Unit from"
+        pr_debug("%s_TPG[%u]_LUN[%u] - Deactivating %s Logical Unit from"
                 " device object\n", tpg->se_tpg_tfo->get_fabric_name(),
-                tpg->se_tpg_tfo->tpg_get_tag(tpg), unpacked_lun,
+                tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun,
                 tpg->se_tpg_tfo->get_fabric_name());
 
-        return 0;
+        core_tpg_remove_lun(tpg, lun);
 }
 
 struct se_lun *core_get_lun_from_tpg(struct se_portal_group *tpg, u32 unpacked_lun)
@@ -1396,8 +1404,7 @@ int core_dev_add_initiator_node_lun_acl(
 
         spin_lock(&lun->lun_acl_lock);
         list_add_tail(&lacl->lacl_list, &lun->lun_acl_list);
-        atomic_inc(&lun->lun_acl_count);
-        smp_mb__after_atomic();
+        atomic_inc_mb(&lun->lun_acl_count);
         spin_unlock(&lun->lun_acl_lock);
 
         pr_debug("%s_TPG[%hu]_LUN[%u->%u] - Added %s ACL for "
@@ -1409,7 +1416,8 @@ int core_dev_add_initiator_node_lun_acl(
          * Check to see if there are any existing persistent reservation APTPL
          * pre-registrations that need to be enabled for this LUN ACL..
          */
-        core_scsi3_check_aptpl_registration(lun->lun_se_dev, tpg, lun, lacl);
+        core_scsi3_check_aptpl_registration(lun->lun_se_dev, tpg, lun, nacl,
+                                            lacl->mapped_lun);
         return 0;
 }
 
@@ -1430,8 +1438,7 @@ int core_dev_del_initiator_node_lun_acl(
 
         spin_lock(&lun->lun_acl_lock);
         list_del(&lacl->lacl_list);
-        atomic_dec(&lun->lun_acl_count);
-        smp_mb__after_atomic();
+        atomic_dec_mb(&lun->lun_acl_count);
         spin_unlock(&lun->lun_acl_lock);
 
         core_disable_device_list_for_node(lun, NULL, lacl->mapped_lun,
@@ -1554,6 +1561,7 @@ struct se_device *target_alloc_device(struct se_hba *hba, const char *name)
         dev->dev_attrib.emulate_3pc = DA_EMULATE_3PC;
         dev->dev_attrib.pi_prot_type = TARGET_DIF_TYPE0_PROT;
         dev->dev_attrib.enforce_pr_isids = DA_ENFORCE_PR_ISIDS;
+        dev->dev_attrib.force_pr_aptpl = DA_FORCE_PR_APTPL;
         dev->dev_attrib.is_nonrot = DA_IS_NONROT;
         dev->dev_attrib.emulate_rest_reord = DA_EMULATE_REST_REORD;
         dev->dev_attrib.max_unmap_lba_count = DA_MAX_UNMAP_LBA_COUNT;
diff --git a/drivers/target/target_core_fabric_configfs.c b/drivers/target/target_core_fabric_configfs.c
index 7de9f0475d05..0c3f90130b7d 100644
--- a/drivers/target/target_core_fabric_configfs.c
+++ b/drivers/target/target_core_fabric_configfs.c
@@ -320,7 +320,7 @@ static struct config_group *target_fabric_make_mappedlun(
                         struct se_node_acl, acl_group);
         struct se_portal_group *se_tpg = se_nacl->se_tpg;
         struct target_fabric_configfs *tf = se_tpg->se_tpg_wwn->wwn_tf;
-        struct se_lun_acl *lacl;
+        struct se_lun_acl *lacl = NULL;
         struct config_item *acl_ci;
         struct config_group *lacl_cg = NULL, *ml_stat_grp = NULL;
         char *buf;
@@ -406,6 +406,7 @@ static struct config_group *target_fabric_make_mappedlun(
 out:
         if (lacl_cg)
                 kfree(lacl_cg->default_groups);
+        kfree(lacl);
         kfree(buf);
         return ERR_PTR(ret);
 }
@@ -821,7 +822,7 @@ static int target_fabric_port_unlink(
                 tf->tf_ops.fabric_pre_unlink(se_tpg, lun);
         }
 
-        core_dev_del_lun(se_tpg, lun->unpacked_lun);
+        core_dev_del_lun(se_tpg, lun);
         return 0;
 }
 
@@ -910,16 +911,12 @@ static struct config_group *target_fabric_make_lun(
                                 GFP_KERNEL);
         if (!port_stat_grp->default_groups) {
                 pr_err("Unable to allocate port_stat_grp->default_groups\n");
-                errno = -ENOMEM;
-                goto out;
+                kfree(lun_cg->default_groups);
+                return ERR_PTR(-ENOMEM);
         }
         target_stat_setup_port_default_groups(lun);
 
         return &lun->lun_group;
-out:
-        if (lun_cg)
-                kfree(lun_cg->default_groups);
-        return ERR_PTR(errno);
 }
 
 static void target_fabric_drop_lun(
diff --git a/drivers/target/target_core_fabric_lib.c b/drivers/target/target_core_fabric_lib.c
index 0d1cf8b4f49f..35bfe77160d8 100644
--- a/drivers/target/target_core_fabric_lib.c
+++ b/drivers/target/target_core_fabric_lib.c
@@ -394,9 +394,9 @@ char *iscsi_parse_pr_out_transport_id(
          * If the caller wants the TransportID Length, we set that value for the
          * entire iSCSI Tarnsport ID now.
          */
-         if (out_tid_len != NULL) {
-                add_len = ((buf[2] >> 8) & 0xff);
-                add_len |= (buf[3] & 0xff);
+        if (out_tid_len) {
+                /* The shift works thanks to integer promotion rules */
+                add_len = (buf[2] << 8) | buf[3];
 
                 tid_len = strlen(&buf[4]);
                 tid_len += 4; /* Add four bytes for iSCSI Transport ID header */
diff --git a/drivers/target/target_core_file.c b/drivers/target/target_core_file.c
index 7d6cddaec525..72c83d98662b 100644
--- a/drivers/target/target_core_file.c
+++ b/drivers/target/target_core_file.c
@@ -415,7 +415,7 @@ fd_execute_sync_cache(struct se_cmd *cmd)
         } else {
                 start = cmd->t_task_lba * dev->dev_attrib.block_size;
                 if (cmd->data_length)
-                        end = start + cmd->data_length;
+                        end = start + cmd->data_length - 1;
                 else
                         end = LLONG_MAX;
         }
@@ -680,7 +680,12 @@ fd_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
                         struct fd_dev *fd_dev = FD_DEV(dev);
                         loff_t start = cmd->t_task_lba *
                                 dev->dev_attrib.block_size;
-                        loff_t end = start + cmd->data_length;
+                        loff_t end;
+
+                        if (cmd->data_length)
+                                end = start + cmd->data_length - 1;
+                        else
+                                end = LLONG_MAX;
 
                         vfs_fsync_range(fd_dev->fd_file, start, end, 1);
                 }
@@ -762,7 +767,9 @@ static ssize_t fd_set_configfs_dev_params(struct se_device *dev,
                         fd_dev->fbd_flags |= FBDF_HAS_SIZE;
                         break;
                 case Opt_fd_buffered_io:
-                        match_int(args, &arg);
+                        ret = match_int(args, &arg);
+                        if (ret)
+                                goto out;
                         if (arg != 1) {
                                 pr_err("bogus fd_buffered_io=%d value\n", arg);
                                 ret = -EINVAL;
diff --git a/drivers/target/target_core_internal.h b/drivers/target/target_core_internal.h
index de9cab708f45..e31f42f369ff 100644
--- a/drivers/target/target_core_internal.h
+++ b/drivers/target/target_core_internal.h
@@ -38,6 +38,7 @@ 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);
@@ -46,7 +47,7 @@ int	se_dev_set_fabric_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);
 struct se_lun *core_dev_add_lun(struct se_portal_group *, struct se_device *, u32);
-int     core_dev_del_lun(struct se_portal_group *, u32);
+void    core_dev_del_lun(struct se_portal_group *, struct se_lun *);
 struct se_lun *core_get_lun_from_tpg(struct se_portal_group *, u32);
 struct se_lun_acl *core_dev_init_initiator_node_lun_acl(struct se_portal_group *,
                 struct se_node_acl *, u32, int *);
@@ -82,8 +83,7 @@ void	core_tpg_wait_for_nacl_pr_ref(struct se_node_acl *);
 struct se_lun *core_tpg_alloc_lun(struct se_portal_group *, u32);
 int     core_tpg_add_lun(struct se_portal_group *, struct se_lun *,
                 u32, struct se_device *);
-struct se_lun *core_tpg_pre_dellun(struct se_portal_group *, u32 unpacked_lun);
-int     core_tpg_post_dellun(struct se_portal_group *, struct se_lun *);
+void core_tpg_remove_lun(struct se_portal_group *, struct se_lun *);
 
 /* target_core_transport.c */
 extern struct kmem_cache *se_tmr_req_cache;
diff --git a/drivers/target/target_core_pr.c b/drivers/target/target_core_pr.c
index df357862286e..8c60a1a1ae8d 100644
--- a/drivers/target/target_core_pr.c
+++ b/drivers/target/target_core_pr.c
@@ -674,8 +674,7 @@ static struct t10_pr_registration *__core_scsi3_alloc_registration(
          */
         spin_lock(&dev->se_port_lock);
         list_for_each_entry_safe(port, port_tmp, &dev->dev_sep_list, sep_list) {
-                atomic_inc(&port->sep_tg_pt_ref_cnt);
-                smp_mb__after_atomic();
+                atomic_inc_mb(&port->sep_tg_pt_ref_cnt);
                 spin_unlock(&dev->se_port_lock);
 
                 spin_lock_bh(&port->sep_alua_lock);
@@ -709,8 +708,7 @@ static struct t10_pr_registration *__core_scsi3_alloc_registration(
                         if (strcmp(nacl->initiatorname, nacl_tmp->initiatorname))
                                 continue;
 
-                        atomic_inc(&deve_tmp->pr_ref_count);
-                        smp_mb__after_atomic();
+                        atomic_inc_mb(&deve_tmp->pr_ref_count);
                         spin_unlock_bh(&port->sep_alua_lock);
                         /*
                          * Grab a configfs group dependency that is released
@@ -722,10 +720,8 @@ static struct t10_pr_registration *__core_scsi3_alloc_registration(
                         if (ret < 0) {
                                 pr_err("core_scsi3_lunacl_depend"
                                                 "_item() failed\n");
-                                atomic_dec(&port->sep_tg_pt_ref_cnt);
-                                smp_mb__after_atomic();
-                                atomic_dec(&deve_tmp->pr_ref_count);
-                                smp_mb__after_atomic();
+                                atomic_dec_mb(&port->sep_tg_pt_ref_cnt);
+                                atomic_dec_mb(&deve_tmp->pr_ref_count);
                                 goto out;
                         }
                         /*
@@ -739,10 +735,8 @@ static struct t10_pr_registration *__core_scsi3_alloc_registration(
                                                 nacl_tmp, deve_tmp, NULL,
                                                 sa_res_key, all_tg_pt, aptpl);
                         if (!pr_reg_atp) {
-                                atomic_dec(&port->sep_tg_pt_ref_cnt);
-                                smp_mb__after_atomic();
-                                atomic_dec(&deve_tmp->pr_ref_count);
-                                smp_mb__after_atomic();
+                                atomic_dec_mb(&port->sep_tg_pt_ref_cnt);
+                                atomic_dec_mb(&deve_tmp->pr_ref_count);
                                 core_scsi3_lunacl_undepend_item(deve_tmp);
                                 goto out;
                         }
@@ -754,8 +748,7 @@ static struct t10_pr_registration *__core_scsi3_alloc_registration(
                 spin_unlock_bh(&port->sep_alua_lock);
 
                 spin_lock(&dev->se_port_lock);
-                atomic_dec(&port->sep_tg_pt_ref_cnt);
-                smp_mb__after_atomic();
+                atomic_dec_mb(&port->sep_tg_pt_ref_cnt);
         }
         spin_unlock(&dev->se_port_lock);
 
@@ -902,6 +895,7 @@ static int __core_scsi3_check_aptpl_registration(
         spin_lock(&pr_tmpl->aptpl_reg_lock);
         list_for_each_entry_safe(pr_reg, pr_reg_tmp, &pr_tmpl->aptpl_reg_list,
                                 pr_reg_aptpl_list) {
+
                 if (!strcmp(pr_reg->pr_iport, i_port) &&
                      (pr_reg->pr_res_mapped_lun == deve->mapped_lun) &&
                     !(strcmp(pr_reg->pr_tport, t_port)) &&
@@ -944,10 +938,10 @@ int core_scsi3_check_aptpl_registration(
         struct se_device *dev,
         struct se_portal_group *tpg,
         struct se_lun *lun,
-        struct se_lun_acl *lun_acl)
+        struct se_node_acl *nacl,
+        u32 mapped_lun)
 {
-        struct se_node_acl *nacl = lun_acl->se_lun_nacl;
-        struct se_dev_entry *deve = nacl->device_list[lun_acl->mapped_lun];
+        struct se_dev_entry *deve = nacl->device_list[mapped_lun];
 
         if (dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS)
                 return 0;
@@ -1109,8 +1103,7 @@ static struct t10_pr_registration *__core_scsi3_locate_pr_reg(
                                 if (dev->dev_attrib.enforce_pr_isids)
                                         continue;
                         }
-                        atomic_inc(&pr_reg->pr_res_holders);
-                        smp_mb__after_atomic();
+                        atomic_inc_mb(&pr_reg->pr_res_holders);
                         spin_unlock(&pr_tmpl->registration_lock);
                         return pr_reg;
                 }
@@ -1124,8 +1117,7 @@ static struct t10_pr_registration *__core_scsi3_locate_pr_reg(
                 if (strcmp(isid, pr_reg->pr_reg_isid))
                         continue;
 
-                atomic_inc(&pr_reg->pr_res_holders);
-                smp_mb__after_atomic();
+                atomic_inc_mb(&pr_reg->pr_res_holders);
                 spin_unlock(&pr_tmpl->registration_lock);
                 return pr_reg;
         }
@@ -1154,8 +1146,7 @@ static struct t10_pr_registration *core_scsi3_locate_pr_reg(
 
 static void core_scsi3_put_pr_reg(struct t10_pr_registration *pr_reg)
 {
-        atomic_dec(&pr_reg->pr_res_holders);
-        smp_mb__after_atomic();
+        atomic_dec_mb(&pr_reg->pr_res_holders);
 }
 
 static int core_scsi3_check_implicit_release(
@@ -1348,8 +1339,7 @@ static void core_scsi3_tpg_undepend_item(struct se_portal_group *tpg)
         configfs_undepend_item(tpg->se_tpg_tfo->tf_subsys,
                         &tpg->tpg_group.cg_item);
 
-        atomic_dec(&tpg->tpg_pr_ref_count);
-        smp_mb__after_atomic();
+        atomic_dec_mb(&tpg->tpg_pr_ref_count);
 }
 
 static int core_scsi3_nodeacl_depend_item(struct se_node_acl *nacl)
@@ -1368,16 +1358,14 @@ static void core_scsi3_nodeacl_undepend_item(struct se_node_acl *nacl)
         struct se_portal_group *tpg = nacl->se_tpg;
 
         if (nacl->dynamic_node_acl) {
-                atomic_dec(&nacl->acl_pr_ref_count);
-                smp_mb__after_atomic();
+                atomic_dec_mb(&nacl->acl_pr_ref_count);
                 return;
         }
 
         configfs_undepend_item(tpg->se_tpg_tfo->tf_subsys,
                         &nacl->acl_group.cg_item);
 
-        atomic_dec(&nacl->acl_pr_ref_count);
-        smp_mb__after_atomic();
+        atomic_dec_mb(&nacl->acl_pr_ref_count);
 }
 
 static int core_scsi3_lunacl_depend_item(struct se_dev_entry *se_deve)
@@ -1407,8 +1395,7 @@ static void core_scsi3_lunacl_undepend_item(struct se_dev_entry *se_deve)
          * For nacl->dynamic_node_acl=1
          */
         if (!lun_acl) {
-                atomic_dec(&se_deve->pr_ref_count);
-                smp_mb__after_atomic();
+                atomic_dec_mb(&se_deve->pr_ref_count);
                 return;
         }
         nacl = lun_acl->se_lun_nacl;
@@ -1417,8 +1404,7 @@ static void core_scsi3_lunacl_undepend_item(struct se_dev_entry *se_deve)
         configfs_undepend_item(tpg->se_tpg_tfo->tf_subsys,
                         &lun_acl->se_lun_group.cg_item);
 
-        atomic_dec(&se_deve->pr_ref_count);
-        smp_mb__after_atomic();
+        atomic_dec_mb(&se_deve->pr_ref_count);
 }
 
 static sense_reason_t
@@ -1551,15 +1537,13 @@ core_scsi3_decode_spec_i_port(
                         if (!i_str)
                                 continue;
 
-                        atomic_inc(&tmp_tpg->tpg_pr_ref_count);
-                        smp_mb__after_atomic();
+                        atomic_inc_mb(&tmp_tpg->tpg_pr_ref_count);
                         spin_unlock(&dev->se_port_lock);
 
                         if (core_scsi3_tpg_depend_item(tmp_tpg)) {
                                 pr_err(" core_scsi3_tpg_depend_item()"
                                         " for tmp_tpg\n");
-                                atomic_dec(&tmp_tpg->tpg_pr_ref_count);
-                                smp_mb__after_atomic();
+                                atomic_dec_mb(&tmp_tpg->tpg_pr_ref_count);
                                 ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
                                 goto out_unmap;
                         }
@@ -1571,10 +1555,8 @@ core_scsi3_decode_spec_i_port(
                         spin_lock_irq(&tmp_tpg->acl_node_lock);
                         dest_node_acl = __core_tpg_get_initiator_node_acl(
                                                 tmp_tpg, i_str);
-                        if (dest_node_acl) {
-                                atomic_inc(&dest_node_acl->acl_pr_ref_count);
-                                smp_mb__after_atomic();
-                        }
+                        if (dest_node_acl)
+                                atomic_inc_mb(&dest_node_acl->acl_pr_ref_count);
                         spin_unlock_irq(&tmp_tpg->acl_node_lock);
 
                         if (!dest_node_acl) {
@@ -1586,8 +1568,7 @@ core_scsi3_decode_spec_i_port(
                         if (core_scsi3_nodeacl_depend_item(dest_node_acl)) {
                                 pr_err("configfs_depend_item() failed"
                                         " for dest_node_acl->acl_group\n");
-                                atomic_dec(&dest_node_acl->acl_pr_ref_count);
-                                smp_mb__after_atomic();
+                                atomic_dec_mb(&dest_node_acl->acl_pr_ref_count);
                                 core_scsi3_tpg_undepend_item(tmp_tpg);
                                 ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
                                 goto out_unmap;
@@ -1646,8 +1627,7 @@ core_scsi3_decode_spec_i_port(
                 if (core_scsi3_lunacl_depend_item(dest_se_deve)) {
                         pr_err("core_scsi3_lunacl_depend_item()"
                                         " failed\n");
-                        atomic_dec(&dest_se_deve->pr_ref_count);
-                        smp_mb__after_atomic();
+                        atomic_dec_mb(&dest_se_deve->pr_ref_count);
                         core_scsi3_nodeacl_undepend_item(dest_node_acl);
                         core_scsi3_tpg_undepend_item(dest_tpg);
                         ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
@@ -3167,15 +3147,13 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
                 if (!dest_tf_ops)
                         continue;
 
-                atomic_inc(&dest_se_tpg->tpg_pr_ref_count);
-                smp_mb__after_atomic();
+                atomic_inc_mb(&dest_se_tpg->tpg_pr_ref_count);
                 spin_unlock(&dev->se_port_lock);
 
                 if (core_scsi3_tpg_depend_item(dest_se_tpg)) {
                         pr_err("core_scsi3_tpg_depend_item() failed"
                                 " for dest_se_tpg\n");
-                        atomic_dec(&dest_se_tpg->tpg_pr_ref_count);
-                        smp_mb__after_atomic();
+                        atomic_dec_mb(&dest_se_tpg->tpg_pr_ref_count);
                         ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
                         goto out_put_pr_reg;
                 }
@@ -3271,10 +3249,8 @@ after_iport_check:
         spin_lock_irq(&dest_se_tpg->acl_node_lock);
         dest_node_acl = __core_tpg_get_initiator_node_acl(dest_se_tpg,
                                 initiator_str);
-        if (dest_node_acl) {
-                atomic_inc(&dest_node_acl->acl_pr_ref_count);
-                smp_mb__after_atomic();
-        }
+        if (dest_node_acl)
+                atomic_inc_mb(&dest_node_acl->acl_pr_ref_count);
         spin_unlock_irq(&dest_se_tpg->acl_node_lock);
 
         if (!dest_node_acl) {
@@ -3288,8 +3264,7 @@ after_iport_check:
         if (core_scsi3_nodeacl_depend_item(dest_node_acl)) {
                 pr_err("core_scsi3_nodeacl_depend_item() for"
                         " dest_node_acl\n");
-                atomic_dec(&dest_node_acl->acl_pr_ref_count);
-                smp_mb__after_atomic();
+                atomic_dec_mb(&dest_node_acl->acl_pr_ref_count);
                 dest_node_acl = NULL;
                 ret = TCM_INVALID_PARAMETER_LIST;
                 goto out;
@@ -3313,8 +3288,7 @@ after_iport_check:
 
         if (core_scsi3_lunacl_depend_item(dest_se_deve)) {
                 pr_err("core_scsi3_lunacl_depend_item() failed\n");
-                atomic_dec(&dest_se_deve->pr_ref_count);
-                smp_mb__after_atomic();
+                atomic_dec_mb(&dest_se_deve->pr_ref_count);
                 dest_se_deve = NULL;
                 ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
                 goto out;
@@ -3497,6 +3471,7 @@ static unsigned long long core_scsi3_extract_reservation_key(unsigned char *cdb)
 sense_reason_t
 target_scsi3_emulate_pr_out(struct se_cmd *cmd)
 {
+        struct se_device *dev = cmd->se_dev;
         unsigned char *cdb = &cmd->t_task_cdb[0];
         unsigned char *buf;
         u64 res_key, sa_res_key;
@@ -3561,6 +3536,13 @@ target_scsi3_emulate_pr_out(struct se_cmd *cmd)
                 aptpl = (buf[17] & 0x01);
                 unreg = (buf[17] & 0x02);
         }
+        /*
+         * If the backend device has been configured to force APTPL metadata
+         * write-out, go ahead and propigate aptpl=1 down now.
+         */
+        if (dev->dev_attrib.force_pr_aptpl)
+                aptpl = 1;
+
         transport_kunmap_data_sg(cmd);
         buf = NULL;
 
@@ -3803,7 +3785,7 @@ core_scsi3_pri_report_capabilities(struct se_cmd *cmd)
         if (!buf)
                 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 
-        buf[0] = ((add_len << 8) & 0xff);
+        buf[0] = ((add_len >> 8) & 0xff);
         buf[1] = (add_len & 0xff);
         buf[2] |= 0x10; /* CRH: Compatible Reservation Hanlding bit. */
         buf[2] |= 0x08; /* SIP_C: Specify Initiator Ports Capable bit */
@@ -3879,8 +3861,7 @@ core_scsi3_pri_read_full_status(struct se_cmd *cmd)
                 se_tpg = pr_reg->pr_reg_nacl->se_tpg;
                 add_desc_len = 0;
 
-                atomic_inc(&pr_reg->pr_res_holders);
-                smp_mb__after_atomic();
+                atomic_inc_mb(&pr_reg->pr_res_holders);
                 spin_unlock(&pr_tmpl->registration_lock);
                 /*
                  * Determine expected length of $FABRIC_MOD specific
@@ -3893,8 +3874,7 @@ core_scsi3_pri_read_full_status(struct se_cmd *cmd)
                         pr_warn("SPC-3 PRIN READ_FULL_STATUS ran"
                                 " out of buffer: %d\n", cmd->data_length);
                         spin_lock(&pr_tmpl->registration_lock);
-                        atomic_dec(&pr_reg->pr_res_holders);
-                        smp_mb__after_atomic();
+                        atomic_dec_mb(&pr_reg->pr_res_holders);
                         break;
                 }
                 /*
@@ -3955,8 +3935,7 @@ core_scsi3_pri_read_full_status(struct se_cmd *cmd)
                                 se_nacl, pr_reg, &format_code, &buf[off+4]);
 
                 spin_lock(&pr_tmpl->registration_lock);
-                atomic_dec(&pr_reg->pr_res_holders);
-                smp_mb__after_atomic();
+                atomic_dec_mb(&pr_reg->pr_res_holders);
                 /*
                  * Set the ADDITIONAL DESCRIPTOR LENGTH
                  */
diff --git a/drivers/target/target_core_pr.h b/drivers/target/target_core_pr.h
index 2ee2936fa0bd..749fd7bb7510 100644
--- a/drivers/target/target_core_pr.h
+++ b/drivers/target/target_core_pr.h
@@ -60,7 +60,7 @@ extern int core_scsi3_alloc_aptpl_registration(
                         unsigned char *, u16, u32, int, int, u8);
 extern int core_scsi3_check_aptpl_registration(struct se_device *,
                         struct se_portal_group *, struct se_lun *,
-                        struct se_lun_acl *);
+                        struct se_node_acl *, u32);
 extern void core_scsi3_free_pr_reg_from_nacl(struct se_device *,
                                              struct se_node_acl *);
 extern void core_scsi3_free_all_registrations(struct se_device *);
diff --git a/drivers/target/target_core_pscsi.c b/drivers/target/target_core_pscsi.c
index 70d9f6dabba0..7c8291f0bbbc 100644
--- a/drivers/target/target_core_pscsi.c
+++ b/drivers/target/target_core_pscsi.c
@@ -749,14 +749,18 @@ static ssize_t pscsi_set_configfs_dev_params(struct se_device *dev,
                                 ret = -EINVAL;
                                 goto out;
                         }
-                        match_int(args, &arg);
+                        ret = match_int(args, &arg);
+                        if (ret)
+                                goto out;
                         pdv->pdv_host_id = arg;
                         pr_debug("PSCSI[%d]: Referencing SCSI Host ID:"
                                 " %d\n", phv->phv_host_id, pdv->pdv_host_id);
                         pdv->pdv_flags |= PDF_HAS_VIRT_HOST_ID;
                         break;
                 case Opt_scsi_channel_id:
-                        match_int(args, &arg);
+                        ret = match_int(args, &arg);
+                        if (ret)
+                                goto out;
                         pdv->pdv_channel_id = arg;
                         pr_debug("PSCSI[%d]: Referencing SCSI Channel"
                                 " ID: %d\n",  phv->phv_host_id,
@@ -764,7 +768,9 @@ static ssize_t pscsi_set_configfs_dev_params(struct se_device *dev,
                         pdv->pdv_flags |= PDF_HAS_CHANNEL_ID;
                         break;
                 case Opt_scsi_target_id:
-                        match_int(args, &arg);
+                        ret = match_int(args, &arg);
+                        if (ret)
+                                goto out;
                         pdv->pdv_target_id = arg;
                         pr_debug("PSCSI[%d]: Referencing SCSI Target"
                                 " ID: %d\n", phv->phv_host_id,
@@ -772,7 +778,9 @@ static ssize_t pscsi_set_configfs_dev_params(struct se_device *dev,
                         pdv->pdv_flags |= PDF_HAS_TARGET_ID;
                         break;
                 case Opt_scsi_lun_id:
-                        match_int(args, &arg);
+                        ret = match_int(args, &arg);
+                        if (ret)
+                                goto out;
                         pdv->pdv_lun_id = arg;
                         pr_debug("PSCSI[%d]: Referencing SCSI LUN ID:"
                                 " %d\n", phv->phv_host_id, pdv->pdv_lun_id);
diff --git a/drivers/target/target_core_sbc.c b/drivers/target/target_core_sbc.c
index bd78d9235ac6..ebe62afb957d 100644
--- a/drivers/target/target_core_sbc.c
+++ b/drivers/target/target_core_sbc.c
@@ -948,7 +948,7 @@ sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
         }
 
         /* reject any command that we don't have a handler for */
-        if (!(cmd->se_cmd_flags & SCF_SCSI_DATA_CDB) && !cmd->execute_cmd)
+        if (!cmd->execute_cmd)
                 return TCM_UNSUPPORTED_SCSI_OPCODE;
 
         if (cmd->se_cmd_flags & SCF_SCSI_DATA_CDB) {
diff --git a/drivers/target/target_core_tmr.c b/drivers/target/target_core_tmr.c
index f7cd95e8111a..fa5e157db47b 100644
--- a/drivers/target/target_core_tmr.c
+++ b/drivers/target/target_core_tmr.c
@@ -64,21 +64,17 @@ int core_tmr_alloc_req(
 }
 EXPORT_SYMBOL(core_tmr_alloc_req);
 
-void core_tmr_release_req(
-        struct se_tmr_req *tmr)
+void core_tmr_release_req(struct se_tmr_req *tmr)
 {
         struct se_device *dev = tmr->tmr_dev;
         unsigned long flags;
 
-        if (!dev) {
-                kfree(tmr);
-                return;
+        if (dev) {
+                spin_lock_irqsave(&dev->se_tmr_lock, flags);
+                list_del(&tmr->tmr_list);
+                spin_unlock_irqrestore(&dev->se_tmr_lock, flags);
         }
 
-        spin_lock_irqsave(&dev->se_tmr_lock, flags);
-        list_del(&tmr->tmr_list);
-        spin_unlock_irqrestore(&dev->se_tmr_lock, flags);
-
         kfree(tmr);
 }
 
@@ -90,9 +86,8 @@ static void core_tmr_handle_tas_abort(
         bool remove = true;
         /*
          * TASK ABORTED status (TAS) bit support
-        */
-        if ((tmr_nacl &&
-             (tmr_nacl != cmd->se_sess->se_node_acl)) && tas) {
+         */
+        if ((tmr_nacl && (tmr_nacl != cmd->se_sess->se_node_acl)) && tas) {
                 remove = false;
                 transport_send_task_abort(cmd);
         }
@@ -120,13 +115,12 @@ void core_tmr_abort_task(
         struct se_tmr_req *tmr,
         struct se_session *se_sess)
 {
-        struct se_cmd *se_cmd, *tmp_cmd;
+        struct se_cmd *se_cmd;
         unsigned long flags;
         int ref_tag;
 
         spin_lock_irqsave(&se_sess->sess_cmd_lock, flags);
-        list_for_each_entry_safe(se_cmd, tmp_cmd,
-                        &se_sess->sess_cmd_list, se_cmd_list) {
+        list_for_each_entry(se_cmd, &se_sess->sess_cmd_list, se_cmd_list) {
 
                 if (dev != se_cmd->se_dev)
                         continue;
diff --git a/drivers/target/target_core_tpg.c b/drivers/target/target_core_tpg.c
index be783f717f19..0696de9553d3 100644
--- a/drivers/target/target_core_tpg.c
+++ b/drivers/target/target_core_tpg.c
@@ -40,6 +40,7 @@
 #include <target/target_core_fabric.h>
 
 #include "target_core_internal.h"
+#include "target_core_pr.h"
 
 extern struct se_device *g_lun0_dev;
 
@@ -166,6 +167,13 @@ void core_tpg_add_node_to_devs(
 
                 core_enable_device_list_for_node(lun, NULL, lun->unpacked_lun,
                                 lun_access, acl, tpg);
+                /*
+                 * Check to see if there are any existing persistent reservation
+                 * APTPL pre-registrations that need to be enabled for this dynamic
+                 * LUN ACL now..
+                 */
+                core_scsi3_check_aptpl_registration(dev, tpg, lun, acl,
+                                                    lun->unpacked_lun);
                 spin_lock(&tpg->tpg_lun_lock);
         }
         spin_unlock(&tpg->tpg_lun_lock);
@@ -335,7 +343,7 @@ void core_tpg_clear_object_luns(struct se_portal_group *tpg)
                         continue;
 
                 spin_unlock(&tpg->tpg_lun_lock);
-                core_dev_del_lun(tpg, lun->unpacked_lun);
+                core_dev_del_lun(tpg, lun);
                 spin_lock(&tpg->tpg_lun_lock);
         }
         spin_unlock(&tpg->tpg_lun_lock);
@@ -663,13 +671,6 @@ static int core_tpg_setup_virtual_lun0(struct se_portal_group *se_tpg)
         return 0;
 }
 
-static void core_tpg_release_virtual_lun0(struct se_portal_group *se_tpg)
-{
-        struct se_lun *lun = &se_tpg->tpg_virt_lun0;
-
-        core_tpg_post_dellun(se_tpg, lun);
-}
-
 int core_tpg_register(
         struct target_core_fabric_ops *tfo,
         struct se_wwn *se_wwn,
@@ -773,7 +774,7 @@ int core_tpg_deregister(struct se_portal_group *se_tpg)
         spin_unlock_irq(&se_tpg->acl_node_lock);
 
         if (se_tpg->se_tpg_type == TRANSPORT_TPG_TYPE_NORMAL)
-                core_tpg_release_virtual_lun0(se_tpg);
+                core_tpg_remove_lun(se_tpg, &se_tpg->tpg_virt_lun0);
 
         se_tpg->se_tpg_fabric_ptr = NULL;
         array_free(se_tpg->tpg_lun_list, TRANSPORT_MAX_LUNS_PER_TPG);
@@ -838,37 +839,7 @@ int core_tpg_add_lun(
         return 0;
 }
 
-struct se_lun *core_tpg_pre_dellun(
-        struct se_portal_group *tpg,
-        u32 unpacked_lun)
-{
-        struct se_lun *lun;
-
-        if (unpacked_lun > (TRANSPORT_MAX_LUNS_PER_TPG-1)) {
-                pr_err("%s LUN: %u exceeds TRANSPORT_MAX_LUNS_PER_TPG"
-                        "-1: %u for Target Portal Group: %u\n",
-                        tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,
-                        TRANSPORT_MAX_LUNS_PER_TPG-1,
-                        tpg->se_tpg_tfo->tpg_get_tag(tpg));
-                return ERR_PTR(-EOVERFLOW);
-        }
-
-        spin_lock(&tpg->tpg_lun_lock);
-        lun = tpg->tpg_lun_list[unpacked_lun];
-        if (lun->lun_status != TRANSPORT_LUN_STATUS_ACTIVE) {
-                pr_err("%s Logical Unit Number: %u is not active on"
-                        " Target Portal Group: %u, ignoring request.\n",
-                        tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,
-                        tpg->se_tpg_tfo->tpg_get_tag(tpg));
-                spin_unlock(&tpg->tpg_lun_lock);
-                return ERR_PTR(-ENODEV);
-        }
-        spin_unlock(&tpg->tpg_lun_lock);
-
-        return lun;
-}
-
-int core_tpg_post_dellun(
+void core_tpg_remove_lun(
         struct se_portal_group *tpg,
         struct se_lun *lun)
 {
@@ -882,6 +853,4 @@ int core_tpg_post_dellun(
         spin_unlock(&tpg->tpg_lun_lock);
 
         percpu_ref_exit(&lun->lun_ref);
-
-        return 0;
 }
diff --git a/drivers/target/target_core_transport.c b/drivers/target/target_core_transport.c
index 7fa62fc93e0b..9ea0d5f03f7a 100644
--- a/drivers/target/target_core_transport.c
+++ b/drivers/target/target_core_transport.c
@@ -232,6 +232,10 @@ void transport_subsystem_check_init(void)
         if (ret != 0)
                 pr_err("Unable to load target_core_pscsi\n");
 
+        ret = request_module("target_core_user");
+        if (ret != 0)
+                pr_err("Unable to load target_core_user\n");
+
         sub_api_initialized = 1;
 }
 
@@ -752,8 +756,7 @@ void target_qf_do_work(struct work_struct *work)
 
         list_for_each_entry_safe(cmd, cmd_tmp, &qf_cmd_list, se_qf_node) {
                 list_del(&cmd->se_qf_node);
-                atomic_dec(&dev->dev_qf_count);
-                smp_mb__after_atomic();
+                atomic_dec_mb(&dev->dev_qf_count);
 
                 pr_debug("Processing %s cmd: %p QUEUE_FULL in work queue"
                         " context: %s\n", cmd->se_tfo->get_fabric_name(), cmd,
@@ -1166,7 +1169,6 @@ transport_check_alloc_task_attr(struct se_cmd *cmd)
          * Dormant to Active status.
          */
         cmd->se_ordered_id = atomic_inc_return(&dev->dev_ordered_id);
-        smp_mb__after_atomic();
         pr_debug("Allocated se_ordered_id: %u for Task Attr: 0x%02x on %s\n",
                         cmd->se_ordered_id, cmd->sam_task_attr,
                         dev->transport->name);
@@ -1722,8 +1724,7 @@ static bool target_handle_task_attr(struct se_cmd *cmd)
                          cmd->t_task_cdb[0], cmd->se_ordered_id);
                 return false;
         case MSG_ORDERED_TAG:
-                atomic_inc(&dev->dev_ordered_sync);
-                smp_mb__after_atomic();
+                atomic_inc_mb(&dev->dev_ordered_sync);
 
                 pr_debug("Added ORDERED for CDB: 0x%02x to ordered list, "
                          " se_ordered_id: %u\n",
@@ -1740,8 +1741,7 @@ static bool target_handle_task_attr(struct se_cmd *cmd)
                 /*
                  * For SIMPLE and UNTAGGED Task Attribute commands
                  */
-                atomic_inc(&dev->simple_cmds);
-                smp_mb__after_atomic();
+                atomic_inc_mb(&dev->simple_cmds);
                 break;
         }
 
@@ -1845,8 +1845,7 @@ static void transport_complete_task_attr(struct se_cmd *cmd)
                 return;
 
         if (cmd->sam_task_attr == MSG_SIMPLE_TAG) {
-                atomic_dec(&dev->simple_cmds);
-                smp_mb__after_atomic();
+                atomic_dec_mb(&dev->simple_cmds);
                 dev->dev_cur_ordered_id++;
                 pr_debug("Incremented dev->dev_cur_ordered_id: %u for"
                         " SIMPLE: %u\n", dev->dev_cur_ordered_id,
@@ -1857,8 +1856,7 @@ static void transport_complete_task_attr(struct se_cmd *cmd)
                         " HEAD_OF_QUEUE: %u\n", dev->dev_cur_ordered_id,
                         cmd->se_ordered_id);
         } else if (cmd->sam_task_attr == MSG_ORDERED_TAG) {
-                atomic_dec(&dev->dev_ordered_sync);
-                smp_mb__after_atomic();
+                atomic_dec_mb(&dev->dev_ordered_sync);
 
                 dev->dev_cur_ordered_id++;
                 pr_debug("Incremented dev_cur_ordered_id: %u for ORDERED:"
@@ -1877,8 +1875,7 @@ static void transport_complete_qf(struct se_cmd *cmd)
         if (cmd->se_cmd_flags & SCF_TRANSPORT_TASK_SENSE) {
                 trace_target_cmd_complete(cmd);
                 ret = cmd->se_tfo->queue_status(cmd);
-                if (ret)
-                        goto out;
+                goto out;
         }
 
         switch (cmd->data_direction) {
@@ -1916,8 +1913,7 @@ static void transport_handle_queue_full(
 {
         spin_lock_irq(&dev->qf_cmd_lock);
         list_add_tail(&cmd->se_qf_node, &cmd->se_dev->qf_cmd_list);
-        atomic_inc(&dev->dev_qf_count);
-        smp_mb__after_atomic();
+        atomic_inc_mb(&dev->dev_qf_count);
         spin_unlock_irq(&cmd->se_dev->qf_cmd_lock);
 
         schedule_work(&cmd->se_dev->qf_work_queue);
@@ -2896,7 +2892,6 @@ void transport_send_task_abort(struct se_cmd *cmd)
                 if (cmd->se_tfo->write_pending_status(cmd) != 0) {
                         cmd->transport_state |= CMD_T_ABORTED;
                         cmd->se_cmd_flags |= SCF_SEND_DELAYED_TAS;
-                        smp_mb__after_atomic();
                         return;
                 }
         }
diff --git a/drivers/target/target_core_ua.c b/drivers/target/target_core_ua.c
index 101858e245b3..1738b1646988 100644
--- a/drivers/target/target_core_ua.c
+++ b/drivers/target/target_core_ua.c
@@ -161,8 +161,7 @@ int core_scsi3_ua_allocate(
                 spin_unlock(&deve->ua_lock);
                 spin_unlock_irq(&nacl->device_list_lock);
 
-                atomic_inc(&deve->ua_count);
-                smp_mb__after_atomic();
+                atomic_inc_mb(&deve->ua_count);
                 return 0;
         }
         list_add_tail(&ua->ua_nacl_list, &deve->ua_list);
@@ -174,8 +173,7 @@ int core_scsi3_ua_allocate(
                 nacl->se_tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,
                 asc, ascq);
 
-        atomic_inc(&deve->ua_count);
-        smp_mb__after_atomic();
+        atomic_inc_mb(&deve->ua_count);
         return 0;
 }
 
@@ -189,8 +187,7 @@ void core_scsi3_ua_release_all(
                 list_del(&ua->ua_nacl_list);
                 kmem_cache_free(se_ua_cache, ua);
 
-                atomic_dec(&deve->ua_count);
-                smp_mb__after_atomic();
+                atomic_dec_mb(&deve->ua_count);
         }
         spin_unlock(&deve->ua_lock);
 }
@@ -250,8 +247,7 @@ void core_scsi3_ua_for_check_condition(
                 list_del(&ua->ua_nacl_list);
                 kmem_cache_free(se_ua_cache, ua);
 
-                atomic_dec(&deve->ua_count);
-                smp_mb__after_atomic();
+                atomic_dec_mb(&deve->ua_count);
         }
         spin_unlock(&deve->ua_lock);
         spin_unlock_irq(&nacl->device_list_lock);
@@ -309,8 +305,7 @@ int core_scsi3_ua_clear_for_request_sense(
                 list_del(&ua->ua_nacl_list);
                 kmem_cache_free(se_ua_cache, ua);
 
-                atomic_dec(&deve->ua_count);
-                smp_mb__after_atomic();
+                atomic_dec_mb(&deve->ua_count);
         }
         spin_unlock(&deve->ua_lock);
         spin_unlock_irq(&nacl->device_list_lock);
diff --git a/drivers/target/target_core_ua.h b/drivers/target/target_core_ua.h
index be912b36daae..a6b56b364e7a 100644
--- a/drivers/target/target_core_ua.h
+++ b/drivers/target/target_core_ua.h
@@ -1,4 +1,5 @@
 #ifndef TARGET_CORE_UA_H
+#define TARGET_CORE_UA_H
 
 /*
  * From spc4r17, Table D.1: ASC and ASCQ Assignement
diff --git a/drivers/target/target_core_user.c b/drivers/target/target_core_user.c
new file mode 100644
index 000000000000..9a1b314f6482
--- /dev/null
+++ b/drivers/target/target_core_user.c
@@ -0,0 +1,1167 @@
+/*
+ * Copyright (C) 2013 Shaohua Li <shli@kernel.org>
+ * Copyright (C) 2014 Red Hat, 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.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include <linux/spinlock.h>
+#include <linux/module.h>
+#include <linux/idr.h>
+#include <linux/timer.h>
+#include <linux/parser.h>
+#include <scsi/scsi.h>
+#include <scsi/scsi_host.h>
+#include <linux/uio_driver.h>
+#include <net/genetlink.h>
+#include <target/target_core_base.h>
+#include <target/target_core_fabric.h>
+#include <target/target_core_backend.h>
+#include <linux/target_core_user.h>
+
+/*
+ * Define a shared-memory interface for LIO to pass SCSI commands and
+ * data to userspace for processing. This is to allow backends that
+ * are too complex for in-kernel support to be possible.
+ *
+ * It uses the UIO framework to do a lot of the device-creation and
+ * introspection work for us.
+ *
+ * See the .h file for how the ring is laid out. Note that while the
+ * command ring is defined, the particulars of the data area are
+ * not. Offset values in the command entry point to other locations
+ * internal to the mmap()ed area. There is separate space outside the
+ * command ring for data buffers. This leaves maximum flexibility for
+ * moving buffer allocations, or even page flipping or other
+ * allocation techniques, without altering the command ring layout.
+ *
+ * SECURITY:
+ * The user process must be assumed to be malicious. There's no way to
+ * prevent it breaking the command ring protocol if it wants, but in
+ * order to prevent other issues we must only ever read *data* from
+ * the shared memory area, not offsets or sizes. This applies to
+ * command ring entries as well as the mailbox. Extra code needed for
+ * this may have a 'UAM' comment.
+ */
+
+
+#define TCMU_TIME_OUT (30 * MSEC_PER_SEC)
+
+#define CMDR_SIZE (16 * 4096)
+#define DATA_SIZE (257 * 4096)
+
+#define TCMU_RING_SIZE (CMDR_SIZE + DATA_SIZE)
+
+static struct device *tcmu_root_device;
+
+struct tcmu_hba {
+        u32 host_id;
+};
+
+/* User wants all cmds or just some */
+enum passthru_level {
+        TCMU_PASS_ALL = 0,
+        TCMU_PASS_IO,
+        TCMU_PASS_INVALID,
+};
+
+#define TCMU_CONFIG_LEN 256
+
+struct tcmu_dev {
+        struct se_device se_dev;
+
+        char *name;
+        struct se_hba *hba;
+
+#define TCMU_DEV_BIT_OPEN 0
+#define TCMU_DEV_BIT_BROKEN 1
+        unsigned long flags;
+        enum passthru_level pass_level;
+
+        struct uio_info uio_info;
+
+        struct tcmu_mailbox *mb_addr;
+        size_t dev_size;
+        u32 cmdr_size;
+        u32 cmdr_last_cleaned;
+        /* Offset of data ring from start of mb */
+        size_t data_off;
+        size_t data_size;
+        /* Ring head + tail values. */
+        /* Must add data_off and mb_addr to get the address */
+        size_t data_head;
+        size_t data_tail;
+
+        wait_queue_head_t wait_cmdr;
+        /* TODO should this be a mutex? */
+        spinlock_t cmdr_lock;
+
+        struct idr commands;
+        spinlock_t commands_lock;
+
+        struct timer_list timeout;
+
+        char dev_config[TCMU_CONFIG_LEN];
+};
+
+#define TCMU_DEV(_se_dev) container_of(_se_dev, struct tcmu_dev, se_dev)
+
+#define CMDR_OFF sizeof(struct tcmu_mailbox)
+
+struct tcmu_cmd {
+        struct se_cmd *se_cmd;
+        struct tcmu_dev *tcmu_dev;
+
+        uint16_t cmd_id;
+
+        /* Can't use se_cmd->data_length when cleaning up expired cmds, because if
+           cmd has been completed then accessing se_cmd is off limits */
+        size_t data_length;
+
+        unsigned long deadline;
+
+#define TCMU_CMD_BIT_EXPIRED 0
+        unsigned long flags;
+};
+
+static struct kmem_cache *tcmu_cmd_cache;
+
+/* multicast group */
+enum tcmu_multicast_groups {
+        TCMU_MCGRP_CONFIG,
+};
+
+static const struct genl_multicast_group tcmu_mcgrps[] = {
+        [TCMU_MCGRP_CONFIG] = { .name = "config", },
+};
+
+/* Our generic netlink family */
+static struct genl_family tcmu_genl_family = {
+        .id = GENL_ID_GENERATE,
+        .hdrsize = 0,
+        .name = "TCM-USER",
+        .version = 1,
+        .maxattr = TCMU_ATTR_MAX,
+        .mcgrps = tcmu_mcgrps,
+        .n_mcgrps = ARRAY_SIZE(tcmu_mcgrps),
+};
+
+static struct tcmu_cmd *tcmu_alloc_cmd(struct se_cmd *se_cmd)
+{
+        struct se_device *se_dev = se_cmd->se_dev;
+        struct tcmu_dev *udev = TCMU_DEV(se_dev);
+        struct tcmu_cmd *tcmu_cmd;
+        int cmd_id;
+
+        tcmu_cmd = kmem_cache_zalloc(tcmu_cmd_cache, GFP_KERNEL);
+        if (!tcmu_cmd)
+                return NULL;
+
+        tcmu_cmd->se_cmd = se_cmd;
+        tcmu_cmd->tcmu_dev = udev;
+        tcmu_cmd->data_length = se_cmd->data_length;
+
+        tcmu_cmd->deadline = jiffies + msecs_to_jiffies(TCMU_TIME_OUT);
+
+        idr_preload(GFP_KERNEL);
+        spin_lock_irq(&udev->commands_lock);
+        cmd_id = idr_alloc(&udev->commands, tcmu_cmd, 0,
+                USHRT_MAX, GFP_NOWAIT);
+        spin_unlock_irq(&udev->commands_lock);
+        idr_preload_end();
+
+        if (cmd_id < 0) {
+                kmem_cache_free(tcmu_cmd_cache, tcmu_cmd);
+                return NULL;
+        }
+        tcmu_cmd->cmd_id = cmd_id;
+
+        return tcmu_cmd;
+}
+
+static inline void tcmu_flush_dcache_range(void *vaddr, size_t size)
+{
+        unsigned long offset = (unsigned long) vaddr & ~PAGE_MASK;
+
+        size = round_up(size+offset, PAGE_SIZE);
+        vaddr -= offset;
+
+        while (size) {
+                flush_dcache_page(virt_to_page(vaddr));
+                size -= PAGE_SIZE;
+        }
+}
+
+/*
+ * Some ring helper functions. We don't assume size is a power of 2 so
+ * we can't use circ_buf.h.
+ */
+static inline size_t spc_used(size_t head, size_t tail, size_t size)
+{
+        int diff = head - tail;
+
+        if (diff >= 0)
+                return diff;
+        else
+                return size + diff;
+}
+
+static inline size_t spc_free(size_t head, size_t tail, size_t size)
+{
+        /* Keep 1 byte unused or we can't tell full from empty */
+        return (size - spc_used(head, tail, size) - 1);
+}
+
+static inline size_t head_to_end(size_t head, size_t size)
+{
+        return size - head;
+}
+
+#define UPDATE_HEAD(head, used, size) smp_store_release(&head, ((head % size) + used) % size)
+
+/*
+ * We can't queue a command until we have space available on the cmd ring *and* space
+ * space avail on the data ring.
+ *
+ * Called with ring lock held.
+ */
+static bool is_ring_space_avail(struct tcmu_dev *udev, size_t cmd_size, size_t data_needed)
+{
+        struct tcmu_mailbox *mb = udev->mb_addr;
+        size_t space;
+        u32 cmd_head;
+        size_t cmd_needed;
+
+        tcmu_flush_dcache_range(mb, sizeof(*mb));
+
+        cmd_head = mb->cmd_head % udev->cmdr_size; /* UAM */
+
+        /*
+         * If cmd end-of-ring space is too small then we need space for a NOP plus
+         * original cmd - cmds are internally contiguous.
+         */
+        if (head_to_end(cmd_head, udev->cmdr_size) >= cmd_size)
+                cmd_needed = cmd_size;
+        else
+                cmd_needed = cmd_size + head_to_end(cmd_head, udev->cmdr_size);
+
+        space = spc_free(cmd_head, udev->cmdr_last_cleaned, udev->cmdr_size);
+        if (space < cmd_needed) {
+                pr_debug("no cmd space: %u %u %u\n", cmd_head,
+                       udev->cmdr_last_cleaned, udev->cmdr_size);
+                return false;
+        }
+
+        space = spc_free(udev->data_head, udev->data_tail, udev->data_size);
+        if (space < data_needed) {
+                pr_debug("no data space: %zu %zu %zu\n", udev->data_head,
+                       udev->data_tail, udev->data_size);
+                return false;
+        }
+
+        return true;
+}
+
+static int tcmu_queue_cmd_ring(struct tcmu_cmd *tcmu_cmd)
+{
+        struct tcmu_dev *udev = tcmu_cmd->tcmu_dev;
+        struct se_cmd *se_cmd = tcmu_cmd->se_cmd;
+        size_t base_command_size, command_size;
+        struct tcmu_mailbox *mb;
+        struct tcmu_cmd_entry *entry;
+        int i;
+        struct scatterlist *sg;
+        struct iovec *iov;
+        int iov_cnt = 0;
+        uint32_t cmd_head;
+        uint64_t cdb_off;
+
+        if (test_bit(TCMU_DEV_BIT_BROKEN, &udev->flags))
+                return -EINVAL;
+
+        /*
+         * Must be a certain minimum size for response sense info, but
+         * also may be larger if the iov array is large.
+         *
+         * iovs = sgl_nents+1, for end-of-ring case, plus another 1
+         * b/c size == offsetof one-past-element.
+        */
+        base_command_size = max(offsetof(struct tcmu_cmd_entry,
+                                         req.iov[se_cmd->t_data_nents + 2]),
+                                sizeof(struct tcmu_cmd_entry));
+        command_size = base_command_size
+                + round_up(scsi_command_size(se_cmd->t_task_cdb), TCMU_OP_ALIGN_SIZE);
+
+        WARN_ON(command_size & (TCMU_OP_ALIGN_SIZE-1));
+
+        spin_lock_irq(&udev->cmdr_lock);
+
+        mb = udev->mb_addr;
+        cmd_head = mb->cmd_head % udev->cmdr_size; /* UAM */
+        if ((command_size > (udev->cmdr_size / 2))
+            || tcmu_cmd->data_length > (udev->data_size - 1))
+                pr_warn("TCMU: Request of size %zu/%zu may be too big for %u/%zu "
+                        "cmd/data ring buffers\n", command_size, tcmu_cmd->data_length,
+                        udev->cmdr_size, udev->data_size);
+
+        while (!is_ring_space_avail(udev, command_size, tcmu_cmd->data_length)) {
+                int ret;
+                DEFINE_WAIT(__wait);
+
+                prepare_to_wait(&udev->wait_cmdr, &__wait, TASK_INTERRUPTIBLE);
+
+                pr_debug("sleeping for ring space\n");
+                spin_unlock_irq(&udev->cmdr_lock);
+                ret = schedule_timeout(msecs_to_jiffies(TCMU_TIME_OUT));
+                finish_wait(&udev->wait_cmdr, &__wait);
+                if (!ret) {
+                        pr_warn("tcmu: command timed out\n");
+                        return -ETIMEDOUT;
+                }
+
+                spin_lock_irq(&udev->cmdr_lock);
+
+                /* We dropped cmdr_lock, cmd_head is stale */
+                cmd_head = mb->cmd_head % udev->cmdr_size; /* UAM */
+        }
+
+        /* Insert a PAD if end-of-ring space is too small */
+        if (head_to_end(cmd_head, udev->cmdr_size) < command_size) {
+                size_t pad_size = head_to_end(cmd_head, udev->cmdr_size);
+
+                entry = (void *) mb + CMDR_OFF + cmd_head;
+                tcmu_flush_dcache_range(entry, sizeof(*entry));
+                tcmu_hdr_set_op(&entry->hdr, TCMU_OP_PAD);
+                tcmu_hdr_set_len(&entry->hdr, pad_size);
+
+                UPDATE_HEAD(mb->cmd_head, pad_size, udev->cmdr_size);
+
+                cmd_head = mb->cmd_head % udev->cmdr_size; /* UAM */
+                WARN_ON(cmd_head != 0);
+        }
+
+        entry = (void *) mb + CMDR_OFF + cmd_head;
+        tcmu_flush_dcache_range(entry, sizeof(*entry));
+        tcmu_hdr_set_op(&entry->hdr, TCMU_OP_CMD);
+        tcmu_hdr_set_len(&entry->hdr, command_size);
+        entry->cmd_id = tcmu_cmd->cmd_id;
+
+        /*
+         * Fix up iovecs, and handle if allocation in data ring wrapped.
+         */
+        iov = &entry->req.iov[0];
+        for_each_sg(se_cmd->t_data_sg, sg, se_cmd->t_data_nents, i) {
+                size_t copy_bytes = min((size_t)sg->length,
+                                     head_to_end(udev->data_head, udev->data_size));
+                void *from = kmap_atomic(sg_page(sg)) + sg->offset;
+                void *to = (void *) mb + udev->data_off + udev->data_head;
+
+                if (tcmu_cmd->se_cmd->data_direction == DMA_TO_DEVICE) {
+                        memcpy(to, from, copy_bytes);
+                        tcmu_flush_dcache_range(to, copy_bytes);
+                }
+
+                /* Even iov_base is relative to mb_addr */
+                iov->iov_len = copy_bytes;
+                iov->iov_base = (void *) udev->data_off + udev->data_head;
+                iov_cnt++;
+                iov++;
+
+                UPDATE_HEAD(udev->data_head, copy_bytes, udev->data_size);
+
+                /* Uh oh, we wrapped the buffer. Must split sg across 2 iovs. */
+                if (sg->length != copy_bytes) {
+                        from += copy_bytes;
+                        copy_bytes = sg->length - copy_bytes;
+
+                        iov->iov_len = copy_bytes;
+                        iov->iov_base = (void *) udev->data_off + udev->data_head;
+
+                        if (se_cmd->data_direction == DMA_TO_DEVICE) {
+                                to = (void *) mb + udev->data_off + udev->data_head;
+                                memcpy(to, from, copy_bytes);
+                                tcmu_flush_dcache_range(to, copy_bytes);
+                        }
+
+                        iov_cnt++;
+                        iov++;
+
+                        UPDATE_HEAD(udev->data_head, copy_bytes, udev->data_size);
+                }
+
+                kunmap_atomic(from);
+        }
+        entry->req.iov_cnt = iov_cnt;
+
+        /* All offsets relative to mb_addr, not start of entry! */
+        cdb_off = CMDR_OFF + cmd_head + base_command_size;
+        memcpy((void *) mb + cdb_off, se_cmd->t_task_cdb, scsi_command_size(se_cmd->t_task_cdb));
+        entry->req.cdb_off = cdb_off;
+        tcmu_flush_dcache_range(entry, sizeof(*entry));
+
+        UPDATE_HEAD(mb->cmd_head, command_size, udev->cmdr_size);
+        tcmu_flush_dcache_range(mb, sizeof(*mb));
+
+        spin_unlock_irq(&udev->cmdr_lock);
+
+        /* TODO: only if FLUSH and FUA? */
+        uio_event_notify(&udev->uio_info);
+
+        mod_timer(&udev->timeout,
+                round_jiffies_up(jiffies + msecs_to_jiffies(TCMU_TIME_OUT)));
+
+        return 0;
+}
+
+static int tcmu_queue_cmd(struct se_cmd *se_cmd)
+{
+        struct se_device *se_dev = se_cmd->se_dev;
+        struct tcmu_dev *udev = TCMU_DEV(se_dev);
+        struct tcmu_cmd *tcmu_cmd;
+        int ret;
+
+        tcmu_cmd = tcmu_alloc_cmd(se_cmd);
+        if (!tcmu_cmd)
+                return -ENOMEM;
+
+        ret = tcmu_queue_cmd_ring(tcmu_cmd);
+        if (ret < 0) {
+                pr_err("TCMU: Could not queue command\n");
+                spin_lock_irq(&udev->commands_lock);
+                idr_remove(&udev->commands, tcmu_cmd->cmd_id);
+                spin_unlock_irq(&udev->commands_lock);
+
+                kmem_cache_free(tcmu_cmd_cache, tcmu_cmd);
+        }
+
+        return ret;
+}
+
+static void tcmu_handle_completion(struct tcmu_cmd *cmd, struct tcmu_cmd_entry *entry)
+{
+        struct se_cmd *se_cmd = cmd->se_cmd;
+        struct tcmu_dev *udev = cmd->tcmu_dev;
+
+        if (test_bit(TCMU_CMD_BIT_EXPIRED, &cmd->flags)) {
+                /* cmd has been completed already from timeout, just reclaim data
+                   ring space */
+                UPDATE_HEAD(udev->data_tail, cmd->data_length, udev->data_size);
+                return;
+        }
+
+        if (entry->rsp.scsi_status == SAM_STAT_CHECK_CONDITION) {
+                memcpy(se_cmd->sense_buffer, entry->rsp.sense_buffer,
+                               se_cmd->scsi_sense_length);
+
+                UPDATE_HEAD(udev->data_tail, cmd->data_length, udev->data_size);
+        }
+        else if (se_cmd->data_direction == DMA_FROM_DEVICE) {
+                struct scatterlist *sg;
+                int i;
+
+                /* It'd be easier to look at entry's iovec again, but UAM */
+                for_each_sg(se_cmd->t_data_sg, sg, se_cmd->t_data_nents, i) {
+                        size_t copy_bytes;
+                        void *to;
+                        void *from;
+
+                        copy_bytes = min((size_t)sg->length,
+                                         head_to_end(udev->data_tail, udev->data_size));
+
+                        to = kmap_atomic(sg_page(sg)) + sg->offset;
+                        WARN_ON(sg->length + sg->offset > PAGE_SIZE);
+                        from = (void *) udev->mb_addr + udev->data_off + udev->data_tail;
+                        tcmu_flush_dcache_range(from, copy_bytes);
+                        memcpy(to, from, copy_bytes);
+
+                        UPDATE_HEAD(udev->data_tail, copy_bytes, udev->data_size);
+
+                        /* Uh oh, wrapped the data buffer for this sg's data */
+                        if (sg->length != copy_bytes) {
+                                from = (void *) udev->mb_addr + udev->data_off + udev->data_tail;
+                                WARN_ON(udev->data_tail);
+                                to += copy_bytes;
+                                copy_bytes = sg->length - copy_bytes;
+                                tcmu_flush_dcache_range(from, copy_bytes);
+                                memcpy(to, from, copy_bytes);
+
+                                UPDATE_HEAD(udev->data_tail, copy_bytes, udev->data_size);
+                        }
+
+                        kunmap_atomic(to);
+                }
+
+        } else if (se_cmd->data_direction == DMA_TO_DEVICE) {
+                UPDATE_HEAD(udev->data_tail, cmd->data_length, udev->data_size);
+        } else {
+                pr_warn("TCMU: data direction was %d!\n", se_cmd->data_direction);
+        }
+
+        target_complete_cmd(cmd->se_cmd, entry->rsp.scsi_status);
+        cmd->se_cmd = NULL;
+
+        kmem_cache_free(tcmu_cmd_cache, cmd);
+}
+
+static unsigned int tcmu_handle_completions(struct tcmu_dev *udev)
+{
+        struct tcmu_mailbox *mb;
+        LIST_HEAD(cpl_cmds);
+        unsigned long flags;
+        int handled = 0;
+
+        if (test_bit(TCMU_DEV_BIT_BROKEN, &udev->flags)) {
+                pr_err("ring broken, not handling completions\n");
+                return 0;
+        }
+
+        spin_lock_irqsave(&udev->cmdr_lock, flags);
+
+        mb = udev->mb_addr;
+        tcmu_flush_dcache_range(mb, sizeof(*mb));
+
+        while (udev->cmdr_last_cleaned != ACCESS_ONCE(mb->cmd_tail)) {
+
+                struct tcmu_cmd_entry *entry = (void *) mb + CMDR_OFF + udev->cmdr_last_cleaned;
+                struct tcmu_cmd *cmd;
+
+                tcmu_flush_dcache_range(entry, sizeof(*entry));
+
+                if (tcmu_hdr_get_op(&entry->hdr) == TCMU_OP_PAD) {
+                        UPDATE_HEAD(udev->cmdr_last_cleaned, tcmu_hdr_get_len(&entry->hdr), udev->cmdr_size);
+                        continue;
+                }
+                WARN_ON(tcmu_hdr_get_op(&entry->hdr) != TCMU_OP_CMD);
+
+                spin_lock(&udev->commands_lock);
+                cmd = idr_find(&udev->commands, entry->cmd_id);
+                if (cmd)
+                        idr_remove(&udev->commands, cmd->cmd_id);
+                spin_unlock(&udev->commands_lock);
+
+                if (!cmd) {
+                        pr_err("cmd_id not found, ring is broken\n");
+                        set_bit(TCMU_DEV_BIT_BROKEN, &udev->flags);
+                        break;
+                }
+
+                tcmu_handle_completion(cmd, entry);
+
+                UPDATE_HEAD(udev->cmdr_last_cleaned, tcmu_hdr_get_len(&entry->hdr), udev->cmdr_size);
+
+                handled++;
+        }
+
+        if (mb->cmd_tail == mb->cmd_head)
+                del_timer(&udev->timeout); /* no more pending cmds */
+
+        spin_unlock_irqrestore(&udev->cmdr_lock, flags);
+
+        wake_up(&udev->wait_cmdr);
+
+        return handled;
+}
+
+static int tcmu_check_expired_cmd(int id, void *p, void *data)
+{
+        struct tcmu_cmd *cmd = p;
+
+        if (test_bit(TCMU_CMD_BIT_EXPIRED, &cmd->flags))
+                return 0;
+
+        if (!time_after(cmd->deadline, jiffies))
+                return 0;
+
+        set_bit(TCMU_CMD_BIT_EXPIRED, &cmd->flags);
+        target_complete_cmd(cmd->se_cmd, SAM_STAT_CHECK_CONDITION);
+        cmd->se_cmd = NULL;
+
+        kmem_cache_free(tcmu_cmd_cache, cmd);
+
+        return 0;
+}
+
+static void tcmu_device_timedout(unsigned long data)
+{
+        struct tcmu_dev *udev = (struct tcmu_dev *)data;
+        unsigned long flags;
+        int handled;
+
+        handled = tcmu_handle_completions(udev);
+
+        pr_warn("%d completions handled from timeout\n", handled);
+
+        spin_lock_irqsave(&udev->commands_lock, flags);
+        idr_for_each(&udev->commands, tcmu_check_expired_cmd, NULL);
+        spin_unlock_irqrestore(&udev->commands_lock, flags);
+
+        /*
+         * We don't need to wakeup threads on wait_cmdr since they have their
+         * own timeout.
+         */
+}
+
+static int tcmu_attach_hba(struct se_hba *hba, u32 host_id)
+{
+        struct tcmu_hba *tcmu_hba;
+
+        tcmu_hba = kzalloc(sizeof(struct tcmu_hba), GFP_KERNEL);
+        if (!tcmu_hba)
+                return -ENOMEM;
+
+        tcmu_hba->host_id = host_id;
+        hba->hba_ptr = tcmu_hba;
+
+        return 0;
+}
+
+static void tcmu_detach_hba(struct se_hba *hba)
+{
+        kfree(hba->hba_ptr);
+        hba->hba_ptr = NULL;
+}
+
+static struct se_device *tcmu_alloc_device(struct se_hba *hba, const char *name)
+{
+        struct tcmu_dev *udev;
+
+        udev = kzalloc(sizeof(struct tcmu_dev), GFP_KERNEL);
+        if (!udev)
+                return NULL;
+
+        udev->name = kstrdup(name, GFP_KERNEL);
+        if (!udev->name) {
+                kfree(udev);
+                return NULL;
+        }
+
+        udev->hba = hba;
+
+        init_waitqueue_head(&udev->wait_cmdr);
+        spin_lock_init(&udev->cmdr_lock);
+
+        idr_init(&udev->commands);
+        spin_lock_init(&udev->commands_lock);
+
+        setup_timer(&udev->timeout, tcmu_device_timedout,
+                (unsigned long)udev);
+
+        udev->pass_level = TCMU_PASS_ALL;
+
+        return &udev->se_dev;
+}
+
+static int tcmu_irqcontrol(struct uio_info *info, s32 irq_on)
+{
+        struct tcmu_dev *tcmu_dev = container_of(info, struct tcmu_dev, uio_info);
+
+        tcmu_handle_completions(tcmu_dev);
+
+        return 0;
+}
+
+/*
+ * mmap code from uio.c. Copied here because we want to hook mmap()
+ * and this stuff must come along.
+ */
+static int tcmu_find_mem_index(struct vm_area_struct *vma)
+{
+        struct tcmu_dev *udev = vma->vm_private_data;
+        struct uio_info *info = &udev->uio_info;
+
+        if (vma->vm_pgoff < MAX_UIO_MAPS) {
+                if (info->mem[vma->vm_pgoff].size == 0)
+                        return -1;
+                return (int)vma->vm_pgoff;
+        }
+        return -1;
+}
+
+static int tcmu_vma_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
+{
+        struct tcmu_dev *udev = vma->vm_private_data;
+        struct uio_info *info = &udev->uio_info;
+        struct page *page;
+        unsigned long offset;
+        void *addr;
+
+        int mi = tcmu_find_mem_index(vma);
+        if (mi < 0)
+                return VM_FAULT_SIGBUS;
+
+        /*
+         * We need to subtract mi because userspace uses offset = N*PAGE_SIZE
+         * to use mem[N].
+         */
+        offset = (vmf->pgoff - mi) << PAGE_SHIFT;
+
+        addr = (void *)(unsigned long)info->mem[mi].addr + offset;
+        if (info->mem[mi].memtype == UIO_MEM_LOGICAL)
+                page = virt_to_page(addr);
+        else
+                page = vmalloc_to_page(addr);
+        get_page(page);
+        vmf->page = page;
+        return 0;
+}
+
+static const struct vm_operations_struct tcmu_vm_ops = {
+        .fault = tcmu_vma_fault,
+};
+
+static int tcmu_mmap(struct uio_info *info, struct vm_area_struct *vma)
+{
+        struct tcmu_dev *udev = container_of(info, struct tcmu_dev, uio_info);
+
+        vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
+        vma->vm_ops = &tcmu_vm_ops;
+
+        vma->vm_private_data = udev;
+
+        /* Ensure the mmap is exactly the right size */
+        if (vma_pages(vma) != (TCMU_RING_SIZE >> PAGE_SHIFT))
+                return -EINVAL;
+
+        return 0;
+}
+
+static int tcmu_open(struct uio_info *info, struct inode *inode)
+{
+        struct tcmu_dev *udev = container_of(info, struct tcmu_dev, uio_info);
+
+        /* O_EXCL not supported for char devs, so fake it? */
+        if (test_and_set_bit(TCMU_DEV_BIT_OPEN, &udev->flags))
+                return -EBUSY;
+
+        pr_debug("open\n");
+
+        return 0;
+}
+
+static int tcmu_release(struct uio_info *info, struct inode *inode)
+{
+        struct tcmu_dev *udev = container_of(info, struct tcmu_dev, uio_info);
+
+        clear_bit(TCMU_DEV_BIT_OPEN, &udev->flags);
+
+        pr_debug("close\n");
+
+        return 0;
+}
+
+static int tcmu_netlink_event(enum tcmu_genl_cmd cmd, const char *name, int minor)
+{
+        struct sk_buff *skb;
+        void *msg_header;
+        int ret = -ENOMEM;
+
+        skb = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+        if (!skb)
+                return ret;
+
+        msg_header = genlmsg_put(skb, 0, 0, &tcmu_genl_family, 0, cmd);
+        if (!msg_header)
+                goto free_skb;
+
+        ret = nla_put_string(skb, TCMU_ATTR_DEVICE, name);
+        if (ret < 0)
+                goto free_skb;
+
+        ret = nla_put_u32(skb, TCMU_ATTR_MINOR, minor);
+        if (ret < 0)
+                goto free_skb;
+
+        ret = genlmsg_end(skb, msg_header);
+        if (ret < 0)
+                goto free_skb;
+
+        ret = genlmsg_multicast(&tcmu_genl_family, skb, 0,
+                                TCMU_MCGRP_CONFIG, GFP_KERNEL);
+
+        /* We don't care if no one is listening */
+        if (ret == -ESRCH)
+                ret = 0;
+
+        return ret;
+free_skb:
+        nlmsg_free(skb);
+        return ret;
+}
+
+static int tcmu_configure_device(struct se_device *dev)
+{
+        struct tcmu_dev *udev = TCMU_DEV(dev);
+        struct tcmu_hba *hba = udev->hba->hba_ptr;
+        struct uio_info *info;
+        struct tcmu_mailbox *mb;
+        size_t size;
+        size_t used;
+        int ret = 0;
+        char *str;
+
+        info = &udev->uio_info;
+
+        size = snprintf(NULL, 0, "tcm-user/%u/%s/%s", hba->host_id, udev->name,
+                        udev->dev_config);
+        size += 1; /* for \0 */
+        str = kmalloc(size, GFP_KERNEL);
+        if (!str)
+                return -ENOMEM;
+
+        used = snprintf(str, size, "tcm-user/%u/%s", hba->host_id, udev->name);
+
+        if (udev->dev_config[0])
+                snprintf(str + used, size - used, "/%s", udev->dev_config);
+
+        info->name = str;
+
+        udev->mb_addr = vzalloc(TCMU_RING_SIZE);
+        if (!udev->mb_addr) {
+                ret = -ENOMEM;
+                goto err_vzalloc;
+        }
+
+        /* mailbox fits in first part of CMDR space */
+        udev->cmdr_size = CMDR_SIZE - CMDR_OFF;
+        udev->data_off = CMDR_SIZE;
+        udev->data_size = TCMU_RING_SIZE - CMDR_SIZE;
+
+        mb = udev->mb_addr;
+        mb->version = 1;
+        mb->cmdr_off = CMDR_OFF;
+        mb->cmdr_size = udev->cmdr_size;
+
+        WARN_ON(!PAGE_ALIGNED(udev->data_off));
+        WARN_ON(udev->data_size % PAGE_SIZE);
+
+        info->version = "1";
+
+        info->mem[0].name = "tcm-user command & data buffer";
+        info->mem[0].addr = (phys_addr_t) udev->mb_addr;
+        info->mem[0].size = TCMU_RING_SIZE;
+        info->mem[0].memtype = UIO_MEM_VIRTUAL;
+
+        info->irqcontrol = tcmu_irqcontrol;
+        info->irq = UIO_IRQ_CUSTOM;
+
+        info->mmap = tcmu_mmap;
+        info->open = tcmu_open;
+        info->release = tcmu_release;
+
+        ret = uio_register_device(tcmu_root_device, info);
+        if (ret)
+                goto err_register;
+
+        /* Other attributes can be configured in userspace */
+        dev->dev_attrib.hw_block_size = 512;
+        dev->dev_attrib.hw_max_sectors = 128;
+        dev->dev_attrib.hw_queue_depth = 128;
+
+        ret = tcmu_netlink_event(TCMU_CMD_ADDED_DEVICE, udev->uio_info.name,
+                                 udev->uio_info.uio_dev->minor);
+        if (ret)
+                goto err_netlink;
+
+        return 0;
+
+err_netlink:
+        uio_unregister_device(&udev->uio_info);
+err_register:
+        vfree(udev->mb_addr);
+err_vzalloc:
+        kfree(info->name);
+
+        return ret;
+}
+
+static int tcmu_check_pending_cmd(int id, void *p, void *data)
+{
+        struct tcmu_cmd *cmd = p;
+
+        if (test_bit(TCMU_CMD_BIT_EXPIRED, &cmd->flags))
+                return 0;
+        return -EINVAL;
+}
+
+static void tcmu_free_device(struct se_device *dev)
+{
+        struct tcmu_dev *udev = TCMU_DEV(dev);
+        int i;
+
+        del_timer_sync(&udev->timeout);
+
+        vfree(udev->mb_addr);
+
+        /* Upper layer should drain all requests before calling this */
+        spin_lock_irq(&udev->commands_lock);
+        i = idr_for_each(&udev->commands, tcmu_check_pending_cmd, NULL);
+        idr_destroy(&udev->commands);
+        spin_unlock_irq(&udev->commands_lock);
+        WARN_ON(i);
+
+        /* Device was configured */
+        if (udev->uio_info.uio_dev) {
+                tcmu_netlink_event(TCMU_CMD_REMOVED_DEVICE, udev->uio_info.name,
+                                   udev->uio_info.uio_dev->minor);
+
+                uio_unregister_device(&udev->uio_info);
+                kfree(udev->uio_info.name);
+                kfree(udev->name);
+        }
+
+        kfree(udev);
+}
+
+enum {
+        Opt_dev_config, Opt_dev_size, Opt_err, Opt_pass_level,
+};
+
+static match_table_t tokens = {
+        {Opt_dev_config, "dev_config=%s"},
+        {Opt_dev_size, "dev_size=%u"},
+        {Opt_pass_level, "pass_level=%u"},
+        {Opt_err, NULL}
+};
+
+static ssize_t tcmu_set_configfs_dev_params(struct se_device *dev,
+                const char *page, ssize_t count)
+{
+        struct tcmu_dev *udev = TCMU_DEV(dev);
+        char *orig, *ptr, *opts, *arg_p;
+        substring_t args[MAX_OPT_ARGS];
+        int ret = 0, token;
+        int arg;
+
+        opts = kstrdup(page, GFP_KERNEL);
+        if (!opts)
+                return -ENOMEM;
+
+        orig = opts;
+
+        while ((ptr = strsep(&opts, ",\n")) != NULL) {
+                if (!*ptr)
+                        continue;
+
+                token = match_token(ptr, tokens, args);
+                switch (token) {
+                case Opt_dev_config:
+                        if (match_strlcpy(udev->dev_config, &args[0],
+                                          TCMU_CONFIG_LEN) == 0) {
+                                ret = -EINVAL;
+                                break;
+                        }
+                        pr_debug("TCMU: Referencing Path: %s\n", udev->dev_config);
+                        break;
+                case Opt_dev_size:
+                        arg_p = match_strdup(&args[0]);
+                        if (!arg_p) {
+                                ret = -ENOMEM;
+                                break;
+                        }
+                        ret = kstrtoul(arg_p, 0, (unsigned long *) &udev->dev_size);
+                        kfree(arg_p);
+                        if (ret < 0)
+                                pr_err("kstrtoul() failed for dev_size=\n");
+                        break;
+                case Opt_pass_level:
+                        match_int(args, &arg);
+                        if (arg >= TCMU_PASS_INVALID) {
+                                pr_warn("TCMU: Invalid pass_level: %d\n", arg);
+                                break;
+                        }
+
+                        pr_debug("TCMU: Setting pass_level to %d\n", arg);
+                        udev->pass_level = arg;
+                        break;
+                default:
+                        break;
+                }
+        }
+
+        kfree(orig);
+        return (!ret) ? count : ret;
+}
+
+static ssize_t tcmu_show_configfs_dev_params(struct se_device *dev, char *b)
+{
+        struct tcmu_dev *udev = TCMU_DEV(dev);
+        ssize_t bl = 0;
+
+        bl = sprintf(b + bl, "Config: %s ",
+                     udev->dev_config[0] ? udev->dev_config : "NULL");
+        bl += sprintf(b + bl, "Size: %zu PassLevel: %u\n",
+                      udev->dev_size, udev->pass_level);
+
+        return bl;
+}
+
+static sector_t tcmu_get_blocks(struct se_device *dev)
+{
+        struct tcmu_dev *udev = TCMU_DEV(dev);
+
+        return div_u64(udev->dev_size - dev->dev_attrib.block_size,
+                       dev->dev_attrib.block_size);
+}
+
+static sense_reason_t
+tcmu_execute_rw(struct se_cmd *se_cmd, struct scatterlist *sgl, u32 sgl_nents,
+                enum dma_data_direction data_direction)
+{
+        int ret;
+
+        ret = tcmu_queue_cmd(se_cmd);
+
+        if (ret != 0)
+                return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
+        else
+                return TCM_NO_SENSE;
+}
+
+static sense_reason_t
+tcmu_pass_op(struct se_cmd *se_cmd)
+{
+        int ret = tcmu_queue_cmd(se_cmd);
+
+        if (ret != 0)
+                return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
+        else
+                return TCM_NO_SENSE;
+}
+
+static struct sbc_ops tcmu_sbc_ops = {
+        .execute_rw = tcmu_execute_rw,
+        .execute_sync_cache     = tcmu_pass_op,
+        .execute_write_same     = tcmu_pass_op,
+        .execute_write_same_unmap = tcmu_pass_op,
+        .execute_unmap          = tcmu_pass_op,
+};
+
+static sense_reason_t
+tcmu_parse_cdb(struct se_cmd *cmd)
+{
+        unsigned char *cdb = cmd->t_task_cdb;
+        struct tcmu_dev *udev = TCMU_DEV(cmd->se_dev);
+        sense_reason_t ret;
+
+        switch (udev->pass_level) {
+        case TCMU_PASS_ALL:
+                /* We're just like pscsi, then */
+                /*
+                 * For REPORT LUNS we always need to emulate the response, for everything
+                 * else, pass it up.
+                 */
+                switch (cdb[0]) {
+                case REPORT_LUNS:
+                        cmd->execute_cmd = spc_emulate_report_luns;
+                        break;
+                case READ_6:
+                case READ_10:
+                case READ_12:
+                case READ_16:
+                case WRITE_6:
+                case WRITE_10:
+                case WRITE_12:
+                case WRITE_16:
+                case WRITE_VERIFY:
+                        cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
+                        /* FALLTHROUGH */
+                default:
+                        cmd->execute_cmd = tcmu_pass_op;
+                }
+                ret = TCM_NO_SENSE;
+                break;
+        case TCMU_PASS_IO:
+                ret = sbc_parse_cdb(cmd, &tcmu_sbc_ops);
+                break;
+        default:
+                pr_err("Unknown tcm-user pass level %d\n", udev->pass_level);
+                ret = TCM_CHECK_CONDITION_ABORT_CMD;
+        }
+
+        return ret;
+}
+
+static struct se_subsystem_api tcmu_template = {
+        .name                   = "user",
+        .inquiry_prod           = "USER",
+        .inquiry_rev            = TCMU_VERSION,
+        .owner                  = THIS_MODULE,
+        .transport_type         = TRANSPORT_PLUGIN_VHBA_PDEV,
+        .attach_hba             = tcmu_attach_hba,
+        .detach_hba             = tcmu_detach_hba,
+        .alloc_device           = tcmu_alloc_device,
+        .configure_device       = tcmu_configure_device,
+        .free_device            = tcmu_free_device,
+        .parse_cdb              = tcmu_parse_cdb,
+        .set_configfs_dev_params = tcmu_set_configfs_dev_params,
+        .show_configfs_dev_params = tcmu_show_configfs_dev_params,
+        .get_device_type        = sbc_get_device_type,
+        .get_blocks             = tcmu_get_blocks,
+};
+
+static int __init tcmu_module_init(void)
+{
+        int ret;
+
+        BUILD_BUG_ON((sizeof(struct tcmu_cmd_entry) % TCMU_OP_ALIGN_SIZE) != 0);
+
+        tcmu_cmd_cache = kmem_cache_create("tcmu_cmd_cache",
+                                sizeof(struct tcmu_cmd),
+                                __alignof__(struct tcmu_cmd),
+                                0, NULL);
+        if (!tcmu_cmd_cache)
+                return -ENOMEM;
+
+        tcmu_root_device = root_device_register("tcm_user");
+        if (IS_ERR(tcmu_root_device)) {
+                ret = PTR_ERR(tcmu_root_device);
+                goto out_free_cache;
+        }
+
+        ret = genl_register_family(&tcmu_genl_family);
+        if (ret < 0) {
+                goto out_unreg_device;
+        }
+
+        ret = transport_subsystem_register(&tcmu_template);
+        if (ret)
+                goto out_unreg_genl;
+
+        return 0;
+
+out_unreg_genl:
+        genl_unregister_family(&tcmu_genl_family);
+out_unreg_device:
+        root_device_unregister(tcmu_root_device);
+out_free_cache:
+        kmem_cache_destroy(tcmu_cmd_cache);
+
+        return ret;
+}
+
+static void __exit tcmu_module_exit(void)
+{
+        transport_subsystem_release(&tcmu_template);
+        genl_unregister_family(&tcmu_genl_family);
+        root_device_unregister(tcmu_root_device);
+        kmem_cache_destroy(tcmu_cmd_cache);
+}
+
+MODULE_DESCRIPTION("TCM USER subsystem plugin");
+MODULE_AUTHOR("Shaohua Li <shli@kernel.org>");
+MODULE_AUTHOR("Andy Grover <agrover@redhat.com>");
+MODULE_LICENSE("GPL");
+
+module_init(tcmu_module_init);
+module_exit(tcmu_module_exit);
diff --git a/drivers/target/tcm_fc/tfc_sess.c b/drivers/target/tcm_fc/tfc_sess.c
index 21ce50880c79..ccee7e332a4d 100644
--- a/drivers/target/tcm_fc/tfc_sess.c
+++ b/drivers/target/tcm_fc/tfc_sess.c
@@ -98,7 +98,7 @@ static void ft_tport_delete(struct ft_tport *tport)
         ft_sess_delete_all(tport);
         lport = tport->lport;
         BUG_ON(tport != lport->prov[FC_TYPE_FCP]);
-        rcu_assign_pointer(lport->prov[FC_TYPE_FCP], NULL);
+        RCU_INIT_POINTER(lport->prov[FC_TYPE_FCP], NULL);
 
         tpg = tport->tpg;
         if (tpg) {
diff --git a/drivers/thermal/Kconfig b/drivers/thermal/Kconfig
index ef5587fe2c69..f554d25b4399 100644
--- a/drivers/thermal/Kconfig
+++ b/drivers/thermal/Kconfig
@@ -84,6 +84,16 @@ config THERMAL_GOV_STEP_WISE
           Enable this to manage platform thermals using a simple linear
           governor.
 
+config THERMAL_GOV_BANG_BANG
+        bool "Bang Bang thermal governor"
+        default n
+        help
+          Enable this to manage platform thermals using bang bang governor.
+
+          Say 'Y' here if you want to use two point temperature regulation
+          used for fans without throttling.  Some fan drivers depend on this
+          governor to be enabled (e.g. acerhdf).
+
 config THERMAL_GOV_USER_SPACE
         bool "User_space thermal governor"
         help
@@ -207,21 +217,6 @@ config X86_PKG_TEMP_THERMAL
           two trip points which can be set by user to get notifications via thermal
           notification methods.
 
-config ACPI_INT3403_THERMAL
-        tristate "ACPI INT3403 thermal driver"
-        depends on X86 && ACPI
-        help
-          Newer laptops and tablets that use ACPI may have thermal sensors
-          outside the core CPU/SOC for thermal safety reasons. These
-          temperature sensors are also exposed for the OS to use via the so
-          called INT3403 ACPI object. This driver will, on devices that have
-          such sensors, expose the temperature information from these sensors
-          to userspace via the normal thermal framework. This means that a wide
-          range of applications and GUI widgets can show this information to
-          the user or use this information for making decisions. For example,
-          the Intel Thermal Daemon can use this information to allow the user
-          to select his laptop to run without turning on the fans.
-
 config INTEL_SOC_DTS_THERMAL
         tristate "Intel SoCs DTS thermal driver"
         depends on X86 && IOSF_MBI
@@ -234,6 +229,30 @@ config INTEL_SOC_DTS_THERMAL
           notification methods.The other trip is a critical trip point, which
           was set by the driver based on the TJ MAX temperature.
 
+config INT340X_THERMAL
+        tristate "ACPI INT340X thermal drivers"
+        depends on X86 && ACPI
+        select THERMAL_GOV_USER_SPACE
+        select ACPI_THERMAL_REL
+        select ACPI_FAN
+        help
+          Newer laptops and tablets that use ACPI may have thermal sensors and
+          other devices with thermal control capabilities outside the core
+          CPU/SOC, for thermal safety reasons.
+          They are exposed for the OS to use via the INT3400 ACPI device object
+          as the master, and INT3401~INT340B ACPI device objects as the slaves.
+          Enable this to expose the temperature information and cooling ability
+          from these objects to userspace via the normal thermal framework.
+          This means that a wide range of applications and GUI widgets can show
+          the information to the user or use this information for making
+          decisions. For example, the Intel Thermal Daemon can use this
+          information to allow the user to select his laptop to run without
+          turning on the fans.
+
+config ACPI_THERMAL_REL
+        tristate
+        depends on ACPI
+
 menu "Texas Instruments thermal drivers"
 source "drivers/thermal/ti-soc-thermal/Kconfig"
 endmenu
diff --git a/drivers/thermal/Makefile b/drivers/thermal/Makefile
index 31e232f84b6b..39c4fe87da2f 100644
--- a/drivers/thermal/Makefile
+++ b/drivers/thermal/Makefile
@@ -11,6 +11,7 @@ thermal_sys-$(CONFIG_THERMAL_OF)		+= of-thermal.o
 
 # governors
 thermal_sys-$(CONFIG_THERMAL_GOV_FAIR_SHARE)    += fair_share.o
+thermal_sys-$(CONFIG_THERMAL_GOV_BANG_BANG)     += gov_bang_bang.o
 thermal_sys-$(CONFIG_THERMAL_GOV_STEP_WISE)     += step_wise.o
 thermal_sys-$(CONFIG_THERMAL_GOV_USER_SPACE)    += user_space.o
 
@@ -31,5 +32,5 @@ obj-$(CONFIG_INTEL_POWERCLAMP)	+= intel_powerclamp.o
 obj-$(CONFIG_X86_PKG_TEMP_THERMAL)      += x86_pkg_temp_thermal.o
 obj-$(CONFIG_INTEL_SOC_DTS_THERMAL)     += intel_soc_dts_thermal.o
 obj-$(CONFIG_TI_SOC_THERMAL)    += ti-soc-thermal/
-obj-$(CONFIG_ACPI_INT3403_THERMAL)      += int3403_thermal.o
+obj-$(CONFIG_INT340X_THERMAL)  += int340x_thermal/
 obj-$(CONFIG_ST_THERMAL)        += st/
diff --git a/drivers/thermal/fair_share.c b/drivers/thermal/fair_share.c
index 944ba2f340c8..6e0a3fbfae86 100644
--- a/drivers/thermal/fair_share.c
+++ b/drivers/thermal/fair_share.c
@@ -23,6 +23,7 @@
  */
 
 #include <linux/thermal.h>
+#include <trace/events/thermal.h>
 
 #include "thermal_core.h"
 
@@ -34,6 +35,7 @@ static int get_trip_level(struct thermal_zone_device *tz)
 {
         int count = 0;
         unsigned long trip_temp;
+        enum thermal_trip_type trip_type;
 
         if (tz->trips == 0 || !tz->ops->get_trip_temp)
                 return 0;
@@ -43,6 +45,16 @@ static int get_trip_level(struct thermal_zone_device *tz)
                 if (tz->temperature < trip_temp)
                         break;
         }
+
+        /*
+         * count > 0 only if temperature is greater than first trip
+         * point, in which case, trip_point = count - 1
+         */
+        if (count > 0) {
+                tz->ops->get_trip_type(tz, count - 1, &trip_type);
+                trace_thermal_zone_trip(tz, count - 1, trip_type);
+        }
+
         return count;
 }
 
diff --git a/drivers/thermal/gov_bang_bang.c b/drivers/thermal/gov_bang_bang.c
new file mode 100644
index 000000000000..c5dd76b2ee74
--- /dev/null
+++ b/drivers/thermal/gov_bang_bang.c
@@ -0,0 +1,131 @@
+/*
+ *  gov_bang_bang.c - A simple thermal throttling governor using hysteresis
+ *
+ *  Copyright (C) 2014 Peter Feuerer <peter@piie.net>
+ *
+ *  Based on step_wise.c with following Copyrights:
+ *  Copyright (C) 2012 Intel Corp
+ *  Copyright (C) 2012 Durgadoss R <durgadoss.r@intel.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 in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ */
+
+#include <linux/thermal.h>
+
+#include "thermal_core.h"
+
+static void thermal_zone_trip_update(struct thermal_zone_device *tz, int trip)
+{
+        long trip_temp;
+        unsigned long trip_hyst;
+        struct thermal_instance *instance;
+
+        tz->ops->get_trip_temp(tz, trip, &trip_temp);
+        tz->ops->get_trip_hyst(tz, trip, &trip_hyst);
+
+        dev_dbg(&tz->device, "Trip%d[temp=%ld]:temp=%d:hyst=%ld\n",
+                                trip, trip_temp, tz->temperature,
+                                trip_hyst);
+
+        mutex_lock(&tz->lock);
+
+        list_for_each_entry(instance, &tz->thermal_instances, tz_node) {
+                if (instance->trip != trip)
+                        continue;
+
+                /* in case fan is in initial state, switch the fan off */
+                if (instance->target == THERMAL_NO_TARGET)
+                        instance->target = 0;
+
+                /* in case fan is neither on nor off set the fan to active */
+                if (instance->target != 0 && instance->target != 1) {
+                        pr_warn("Thermal instance %s controlled by bang-bang has unexpected state: %ld\n",
+                                        instance->name, instance->target);
+                        instance->target = 1;
+                }
+
+                /*
+                 * enable fan when temperature exceeds trip_temp and disable
+                 * the fan in case it falls below trip_temp minus hysteresis
+                 */
+                if (instance->target == 0 && tz->temperature >= trip_temp)
+                        instance->target = 1;
+                else if (instance->target == 1 &&
+                                tz->temperature < trip_temp - trip_hyst)
+                        instance->target = 0;
+
+                dev_dbg(&instance->cdev->device, "target=%d\n",
+                                        (int)instance->target);
+
+                instance->cdev->updated = false; /* cdev needs update */
+        }
+
+        mutex_unlock(&tz->lock);
+}
+
+/**
+ * bang_bang_control - controls devices associated with the given zone
+ * @tz - thermal_zone_device
+ * @trip - the trip point
+ *
+ * Regulation Logic: a two point regulation, deliver cooling state depending
+ * on the previous state shown in this diagram:
+ *
+ *                Fan:   OFF    ON
+ *
+ *                              |
+ *                              |
+ *          trip_temp:    +---->+
+ *                        |     |        ^
+ *                        |     |        |
+ *                        |     |   Temperature
+ * (trip_temp - hyst):    +<----+
+ *                        |
+ *                        |
+ *                        |
+ *
+ *   * If the fan is not running and temperature exceeds trip_temp, the fan
+ *     gets turned on.
+ *   * In case the fan is running, temperature must fall below
+ *     (trip_temp - hyst) so that the fan gets turned off again.
+ *
+ */
+static int bang_bang_control(struct thermal_zone_device *tz, int trip)
+{
+        struct thermal_instance *instance;
+
+        thermal_zone_trip_update(tz, trip);
+
+        mutex_lock(&tz->lock);
+
+        list_for_each_entry(instance, &tz->thermal_instances, tz_node)
+                thermal_cdev_update(instance->cdev);
+
+        mutex_unlock(&tz->lock);
+
+        return 0;
+}
+
+static struct thermal_governor thermal_gov_bang_bang = {
+        .name           = "bang_bang",
+        .throttle       = bang_bang_control,
+};
+
+int thermal_gov_bang_bang_register(void)
+{
+        return thermal_register_governor(&thermal_gov_bang_bang);
+}
+
+void thermal_gov_bang_bang_unregister(void)
+{
+        thermal_unregister_governor(&thermal_gov_bang_bang);
+}
diff --git a/drivers/thermal/imx_thermal.c b/drivers/thermal/imx_thermal.c
index 2c516f2eebed..461bf3d033a0 100644
--- a/drivers/thermal/imx_thermal.c
+++ b/drivers/thermal/imx_thermal.c
@@ -19,6 +19,7 @@
 #include <linux/mfd/syscon.h>
 #include <linux/module.h>
 #include <linux/of.h>
+#include <linux/of_device.h>
 #include <linux/platform_device.h>
 #include <linux/regmap.h>
 #include <linux/slab.h>
@@ -31,6 +32,11 @@
 
 #define MISC0                           0x0150
 #define MISC0_REFTOP_SELBIASOFF         (1 << 3)
+#define MISC1                           0x0160
+#define MISC1_IRQ_TEMPHIGH              (1 << 29)
+/* Below LOW and PANIC bits are only for TEMPMON_IMX6SX */
+#define MISC1_IRQ_TEMPLOW               (1 << 28)
+#define MISC1_IRQ_TEMPPANIC             (1 << 27)
 
 #define TEMPSENSE0                      0x0180
 #define TEMPSENSE0_ALARM_VALUE_SHIFT    20
@@ -43,6 +49,12 @@
 
 #define TEMPSENSE1                      0x0190
 #define TEMPSENSE1_MEASURE_FREQ         0xffff
+/* Below TEMPSENSE2 is only for TEMPMON_IMX6SX */
+#define TEMPSENSE2                      0x0290
+#define TEMPSENSE2_LOW_VALUE_SHIFT      0
+#define TEMPSENSE2_LOW_VALUE_MASK       0xfff
+#define TEMPSENSE2_PANIC_VALUE_SHIFT    16
+#define TEMPSENSE2_PANIC_VALUE_MASK     0xfff0000
 
 #define OCOTP_ANA1                      0x04e0
 
@@ -66,6 +78,21 @@ enum imx_thermal_trip {
 #define FACTOR1                         15976
 #define FACTOR2                         4297157
 
+#define TEMPMON_IMX6Q                   1
+#define TEMPMON_IMX6SX                  2
+
+struct thermal_soc_data {
+        u32 version;
+};
+
+static struct thermal_soc_data thermal_imx6q_data = {
+        .version = TEMPMON_IMX6Q,
+};
+
+static struct thermal_soc_data thermal_imx6sx_data = {
+        .version = TEMPMON_IMX6SX,
+};
+
 struct imx_thermal_data {
         struct thermal_zone_device *tz;
         struct thermal_cooling_device *cdev;
@@ -79,8 +106,21 @@ struct imx_thermal_data {
         bool irq_enabled;
         int irq;
         struct clk *thermal_clk;
+        const struct thermal_soc_data *socdata;
 };
 
+static void imx_set_panic_temp(struct imx_thermal_data *data,
+                               signed long panic_temp)
+{
+        struct regmap *map = data->tempmon;
+        int critical_value;
+
+        critical_value = (data->c2 - panic_temp) / data->c1;
+        regmap_write(map, TEMPSENSE2 + REG_CLR, TEMPSENSE2_PANIC_VALUE_MASK);
+        regmap_write(map, TEMPSENSE2 + REG_SET, critical_value <<
+                        TEMPSENSE2_PANIC_VALUE_SHIFT);
+}
+
 static void imx_set_alarm_temp(struct imx_thermal_data *data,
                                signed long alarm_temp)
 {
@@ -142,13 +182,17 @@ static int imx_get_temp(struct thermal_zone_device *tz, unsigned long *temp)
         /* See imx_get_sensor_data() for formula derivation */
         *temp = data->c2 - n_meas * data->c1;
 
-        /* Update alarm value to next higher trip point */
-        if (data->alarm_temp == data->temp_passive && *temp >= data->temp_passive)
-                imx_set_alarm_temp(data, data->temp_critical);
-        if (data->alarm_temp == data->temp_critical && *temp < data->temp_passive) {
-                imx_set_alarm_temp(data, data->temp_passive);
-                dev_dbg(&tz->device, "thermal alarm off: T < %lu\n",
-                        data->alarm_temp / 1000);
+        /* Update alarm value to next higher trip point for TEMPMON_IMX6Q */
+        if (data->socdata->version == TEMPMON_IMX6Q) {
+                if (data->alarm_temp == data->temp_passive &&
+                        *temp >= data->temp_passive)
+                        imx_set_alarm_temp(data, data->temp_critical);
+                if (data->alarm_temp == data->temp_critical &&
+                        *temp < data->temp_passive) {
+                        imx_set_alarm_temp(data, data->temp_passive);
+                        dev_dbg(&tz->device, "thermal alarm off: T < %lu\n",
+                                data->alarm_temp / 1000);
+                }
         }
 
         if (*temp != data->last_temp) {
@@ -398,8 +442,17 @@ static irqreturn_t imx_thermal_alarm_irq_thread(int irq, void *dev)
         return IRQ_HANDLED;
 }
 
+static const struct of_device_id of_imx_thermal_match[] = {
+        { .compatible = "fsl,imx6q-tempmon", .data = &thermal_imx6q_data, },
+        { .compatible = "fsl,imx6sx-tempmon", .data = &thermal_imx6sx_data, },
+        { /* end */ }
+};
+MODULE_DEVICE_TABLE(of, of_imx_thermal_match);
+
 static int imx_thermal_probe(struct platform_device *pdev)
 {
+        const struct of_device_id *of_id =
+                of_match_device(of_imx_thermal_match, &pdev->dev);
         struct imx_thermal_data *data;
         struct cpumask clip_cpus;
         struct regmap *map;
@@ -418,6 +471,20 @@ static int imx_thermal_probe(struct platform_device *pdev)
         }
         data->tempmon = map;
 
+        data->socdata = of_id->data;
+
+        /* make sure the IRQ flag is clear before enabling irq on i.MX6SX */
+        if (data->socdata->version == TEMPMON_IMX6SX) {
+                regmap_write(map, MISC1 + REG_CLR, MISC1_IRQ_TEMPHIGH |
+                        MISC1_IRQ_TEMPLOW | MISC1_IRQ_TEMPPANIC);
+                /*
+                 * reset value of LOW ALARM is incorrect, set it to lowest
+                 * value to avoid false trigger of low alarm.
+                 */
+                regmap_write(map, TEMPSENSE2 + REG_SET,
+                        TEMPSENSE2_LOW_VALUE_MASK);
+        }
+
         data->irq = platform_get_irq(pdev, 0);
         if (data->irq < 0)
                 return data->irq;
@@ -489,6 +556,10 @@ static int imx_thermal_probe(struct platform_device *pdev)
         measure_freq = DIV_ROUND_UP(32768, 10); /* 10 Hz */
         regmap_write(map, TEMPSENSE1 + REG_SET, measure_freq);
         imx_set_alarm_temp(data, data->temp_passive);
+
+        if (data->socdata->version == TEMPMON_IMX6SX)
+                imx_set_panic_temp(data, data->temp_critical);
+
         regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN);
         regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_MEASURE_TEMP);
 
@@ -550,12 +621,6 @@ static int imx_thermal_resume(struct device *dev)
 static SIMPLE_DEV_PM_OPS(imx_thermal_pm_ops,
                          imx_thermal_suspend, imx_thermal_resume);
 
-static const struct of_device_id of_imx_thermal_match[] = {
-        { .compatible = "fsl,imx6q-tempmon", },
-        { /* end */ }
-};
-MODULE_DEVICE_TABLE(of, of_imx_thermal_match);
-
 static struct platform_driver imx_thermal = {
         .driver = {
                 .name   = "imx_thermal",
diff --git a/drivers/thermal/int3403_thermal.c b/drivers/thermal/int3403_thermal.c
deleted file mode 100644
index 17554eeb3953..000000000000
--- a/drivers/thermal/int3403_thermal.c
+++ /dev/null
@@ -1,296 +0,0 @@
-/*
- * ACPI INT3403 thermal driver
- * Copyright (c) 2013, Intel Corporation.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License,
- * version 2, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/types.h>
-#include <linux/acpi.h>
-#include <linux/thermal.h>
-
-#define INT3403_TYPE_SENSOR             0x03
-#define INT3403_PERF_CHANGED_EVENT      0x80
-#define INT3403_THERMAL_EVENT           0x90
-
-#define DECI_KELVIN_TO_MILLI_CELSIUS(t, off) (((t) - (off)) * 100)
-#define KELVIN_OFFSET   2732
-#define MILLI_CELSIUS_TO_DECI_KELVIN(t, off) (((t) / 100) + (off))
-
-#define ACPI_INT3403_CLASS              "int3403"
-#define ACPI_INT3403_FILE_STATE         "state"
-
-struct int3403_sensor {
-        struct thermal_zone_device *tzone;
-        unsigned long *thresholds;
-        unsigned long   crit_temp;
-        int             crit_trip_id;
-        unsigned long   psv_temp;
-        int             psv_trip_id;
-};
-
-static int sys_get_curr_temp(struct thermal_zone_device *tzone,
-                                unsigned long *temp)
-{
-        struct acpi_device *device = tzone->devdata;
-        unsigned long long tmp;
-        acpi_status status;
-
-        status = acpi_evaluate_integer(device->handle, "_TMP", NULL, &tmp);
-        if (ACPI_FAILURE(status))
-                return -EIO;
-
-        *temp = DECI_KELVIN_TO_MILLI_CELSIUS(tmp, KELVIN_OFFSET);
-
-        return 0;
-}
-
-static int sys_get_trip_hyst(struct thermal_zone_device *tzone,
-                int trip, unsigned long *temp)
-{
-        struct acpi_device *device = tzone->devdata;
-        unsigned long long hyst;
-        acpi_status status;
-
-        status = acpi_evaluate_integer(device->handle, "GTSH", NULL, &hyst);
-        if (ACPI_FAILURE(status))
-                return -EIO;
-
-        /*
-         * Thermal hysteresis represents a temperature difference.
-         * Kelvin and Celsius have same degree size. So the
-         * conversion here between tenths of degree Kelvin unit
-         * and Milli-Celsius unit is just to multiply 100.
-         */
-        *temp = hyst * 100;
-
-        return 0;
-}
-
-static int sys_get_trip_temp(struct thermal_zone_device *tzone,
-                int trip, unsigned long *temp)
-{
-        struct acpi_device *device = tzone->devdata;
-        struct int3403_sensor *obj = acpi_driver_data(device);
-
-        if (trip == obj->crit_trip_id)
-                *temp = obj->crit_temp;
-        else if (trip == obj->psv_trip_id)
-                *temp = obj->psv_temp;
-        else {
-                /*
-                 * get_trip_temp is a mandatory callback but
-                 * PATx method doesn't return any value, so return
-                 * cached value, which was last set from user space.
-                 */
-                *temp = obj->thresholds[trip];
-        }
-
-        return 0;
-}
-
-static int sys_get_trip_type(struct thermal_zone_device *thermal,
-                int trip, enum thermal_trip_type *type)
-{
-        struct acpi_device *device = thermal->devdata;
-        struct int3403_sensor *obj = acpi_driver_data(device);
-
-        /* Mandatory callback, may not mean much here */
-        if (trip == obj->crit_trip_id)
-                *type = THERMAL_TRIP_CRITICAL;
-        else
-                *type = THERMAL_TRIP_PASSIVE;
-
-        return 0;
-}
-
-int sys_set_trip_temp(struct thermal_zone_device *tzone, int trip,
-                                                        unsigned long temp)
-{
-        struct acpi_device *device = tzone->devdata;
-        acpi_status status;
-        char name[10];
-        int ret = 0;
-        struct int3403_sensor *obj = acpi_driver_data(device);
-
-        snprintf(name, sizeof(name), "PAT%d", trip);
-        if (acpi_has_method(device->handle, name)) {
-                status = acpi_execute_simple_method(device->handle, name,
-                                MILLI_CELSIUS_TO_DECI_KELVIN(temp,
-                                                        KELVIN_OFFSET));
-                if (ACPI_FAILURE(status))
-                        ret = -EIO;
-                else
-                        obj->thresholds[trip] = temp;
-        } else {
-                ret = -EIO;
-                dev_err(&device->dev, "sys_set_trip_temp: method not found\n");
-        }
-
-        return ret;
-}
-
-static struct thermal_zone_device_ops tzone_ops = {
-        .get_temp = sys_get_curr_temp,
-        .get_trip_temp = sys_get_trip_temp,
-        .get_trip_type = sys_get_trip_type,
-        .set_trip_temp = sys_set_trip_temp,
-        .get_trip_hyst =  sys_get_trip_hyst,
-};
-
-static void acpi_thermal_notify(struct acpi_device *device, u32 event)
-{
-        struct int3403_sensor *obj;
-
-        if (!device)
-                return;
-
-        obj = acpi_driver_data(device);
-        if (!obj)
-                return;
-
-        switch (event) {
-        case INT3403_PERF_CHANGED_EVENT:
-                break;
-        case INT3403_THERMAL_EVENT:
-                thermal_zone_device_update(obj->tzone);
-                break;
-        default:
-                dev_err(&device->dev, "Unsupported event [0x%x]\n", event);
-                break;
-        }
-}
-
-static int sys_get_trip_crt(struct acpi_device *device, unsigned long *temp)
-{
-        unsigned long long crt;
-        acpi_status status;
-
-        status = acpi_evaluate_integer(device->handle, "_CRT", NULL, &crt);
-        if (ACPI_FAILURE(status))
-                return -EIO;
-
-        *temp = DECI_KELVIN_TO_MILLI_CELSIUS(crt, KELVIN_OFFSET);
-
-        return 0;
-}
-
-static int sys_get_trip_psv(struct acpi_device *device, unsigned long *temp)
-{
-        unsigned long long psv;
-        acpi_status status;
-
-        status = acpi_evaluate_integer(device->handle, "_PSV", NULL, &psv);
-        if (ACPI_FAILURE(status))
-                return -EIO;
-
-        *temp = DECI_KELVIN_TO_MILLI_CELSIUS(psv, KELVIN_OFFSET);
-
-        return 0;
-}
-
-static int acpi_int3403_add(struct acpi_device *device)
-{
-        int result = 0;
-        unsigned long long ptyp;
-        acpi_status status;
-        struct int3403_sensor *obj;
-        unsigned long long trip_cnt;
-        int trip_mask = 0;
-
-        if (!device)
-                return -EINVAL;
-
-        status = acpi_evaluate_integer(device->handle, "PTYP", NULL, &ptyp);
-        if (ACPI_FAILURE(status))
-                return -EINVAL;
-
-        if (ptyp != INT3403_TYPE_SENSOR)
-                return -EINVAL;
-
-        obj = devm_kzalloc(&device->dev, sizeof(*obj), GFP_KERNEL);
-        if (!obj)
-                return -ENOMEM;
-
-        device->driver_data = obj;
-
-        status = acpi_evaluate_integer(device->handle, "PATC", NULL,
-                                                &trip_cnt);
-        if (ACPI_FAILURE(status))
-                trip_cnt = 0;
-
-        if (trip_cnt) {
-                /* We have to cache, thresholds can't be readback */
-                obj->thresholds = devm_kzalloc(&device->dev,
-                                        sizeof(*obj->thresholds) * trip_cnt,
-                                        GFP_KERNEL);
-                if (!obj->thresholds)
-                        return -ENOMEM;
-                trip_mask = BIT(trip_cnt) - 1;
-        }
-
-        obj->psv_trip_id = -1;
-        if (!sys_get_trip_psv(device, &obj->psv_temp))
-                obj->psv_trip_id = trip_cnt++;
-
-        obj->crit_trip_id = -1;
-        if (!sys_get_trip_crt(device, &obj->crit_temp))
-                obj->crit_trip_id = trip_cnt++;
-
-        obj->tzone = thermal_zone_device_register(acpi_device_bid(device),
-                                trip_cnt, trip_mask, device, &tzone_ops,
-                                NULL, 0, 0);
-        if (IS_ERR(obj->tzone)) {
-                result = PTR_ERR(obj->tzone);
-                return result;
-        }
-
-        strcpy(acpi_device_name(device), "INT3403");
-        strcpy(acpi_device_class(device), ACPI_INT3403_CLASS);
-
-        return 0;
-}
-
-static int acpi_int3403_remove(struct acpi_device *device)
-{
-        struct int3403_sensor *obj;
-
-        obj = acpi_driver_data(device);
-        thermal_zone_device_unregister(obj->tzone);
-
-        return 0;
-}
-
-ACPI_MODULE_NAME("int3403");
-static const struct acpi_device_id int3403_device_ids[] = {
-        {"INT3403", 0},
-        {"", 0},
-};
-MODULE_DEVICE_TABLE(acpi, int3403_device_ids);
-
-static struct acpi_driver acpi_int3403_driver = {
-        .name = "INT3403",
-        .class = ACPI_INT3403_CLASS,
-        .ids = int3403_device_ids,
-        .ops = {
-                .add = acpi_int3403_add,
-                .remove = acpi_int3403_remove,
-                .notify = acpi_thermal_notify,
-                },
-};
-
-module_acpi_driver(acpi_int3403_driver);
-
-MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
-MODULE_LICENSE("GPL v2");
-MODULE_DESCRIPTION("ACPI INT3403 thermal driver");
diff --git a/drivers/thermal/int340x_thermal/Makefile b/drivers/thermal/int340x_thermal/Makefile
new file mode 100644
index 000000000000..ffe40bffaf1a
--- /dev/null
+++ b/drivers/thermal/int340x_thermal/Makefile
@@ -0,0 +1,4 @@
+obj-$(CONFIG_INT340X_THERMAL)   += int3400_thermal.o
+obj-$(CONFIG_INT340X_THERMAL)   += int3402_thermal.o
+obj-$(CONFIG_INT340X_THERMAL)   += int3403_thermal.o
+obj-$(CONFIG_ACPI_THERMAL_REL)  += acpi_thermal_rel.o
diff --git a/drivers/thermal/int340x_thermal/acpi_thermal_rel.c b/drivers/thermal/int340x_thermal/acpi_thermal_rel.c
new file mode 100644
index 000000000000..0d8db808f0ae
--- /dev/null
+++ b/drivers/thermal/int340x_thermal/acpi_thermal_rel.c
@@ -0,0 +1,400 @@
+/* acpi_thermal_rel.c driver for exporting ACPI thermal relationship
+ *
+ * Copyright (c) 2014 Intel Corp
+ *
+ * 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.
+ *
+ */
+
+/*
+ * Two functionalities included:
+ * 1. Export _TRT, _ART, via misc device interface to the userspace.
+ * 2. Provide parsing result to kernel drivers
+ *
+ */
+#include <linux/init.h>
+#include <linux/export.h>
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/io.h>
+#include <linux/acpi.h>
+#include <linux/uaccess.h>
+#include <linux/miscdevice.h>
+#include "acpi_thermal_rel.h"
+
+static acpi_handle acpi_thermal_rel_handle;
+static DEFINE_SPINLOCK(acpi_thermal_rel_chrdev_lock);
+static int acpi_thermal_rel_chrdev_count;       /* #times opened */
+static int acpi_thermal_rel_chrdev_exclu;       /* already open exclusive? */
+
+static int acpi_thermal_rel_open(struct inode *inode, struct file *file)
+{
+        spin_lock(&acpi_thermal_rel_chrdev_lock);
+        if (acpi_thermal_rel_chrdev_exclu ||
+            (acpi_thermal_rel_chrdev_count && (file->f_flags & O_EXCL))) {
+                spin_unlock(&acpi_thermal_rel_chrdev_lock);
+                return -EBUSY;
+        }
+
+        if (file->f_flags & O_EXCL)
+                acpi_thermal_rel_chrdev_exclu = 1;
+        acpi_thermal_rel_chrdev_count++;
+
+        spin_unlock(&acpi_thermal_rel_chrdev_lock);
+
+        return nonseekable_open(inode, file);
+}
+
+static int acpi_thermal_rel_release(struct inode *inode, struct file *file)
+{
+        spin_lock(&acpi_thermal_rel_chrdev_lock);
+        acpi_thermal_rel_chrdev_count--;
+        acpi_thermal_rel_chrdev_exclu = 0;
+        spin_unlock(&acpi_thermal_rel_chrdev_lock);
+
+        return 0;
+}
+
+/**
+ * acpi_parse_trt - Thermal Relationship Table _TRT for passive cooling
+ *
+ * @handle: ACPI handle of the device contains _TRT
+ * @art_count: the number of valid entries resulted from parsing _TRT
+ * @artp: pointer to pointer of array of art entries in parsing result
+ * @create_dev: whether to create platform devices for target and source
+ *
+ */
+int acpi_parse_trt(acpi_handle handle, int *trt_count, struct trt **trtp,
+                bool create_dev)
+{
+        acpi_status status;
+        int result = 0;
+        int i;
+        int nr_bad_entries = 0;
+        struct trt *trts;
+        struct acpi_device *adev;
+        union acpi_object *p;
+        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
+        struct acpi_buffer element = { 0, NULL };
+        struct acpi_buffer trt_format = { sizeof("RRNNNNNN"), "RRNNNNNN" };
+
+        if (!acpi_has_method(handle, "_TRT"))
+                return 0;
+
+        status = acpi_evaluate_object(handle, "_TRT", NULL, &buffer);
+        if (ACPI_FAILURE(status))
+                return -ENODEV;
+
+        p = buffer.pointer;
+        if (!p || (p->type != ACPI_TYPE_PACKAGE)) {
+                pr_err("Invalid _TRT data\n");
+                result = -EFAULT;
+                goto end;
+        }
+
+        *trt_count = p->package.count;
+        trts = kzalloc(*trt_count * sizeof(struct trt), GFP_KERNEL);
+        if (!trts) {
+                result = -ENOMEM;
+                goto end;
+        }
+
+        for (i = 0; i < *trt_count; i++) {
+                struct trt *trt = &trts[i - nr_bad_entries];
+
+                element.length = sizeof(struct trt);
+                element.pointer = trt;
+
+                status = acpi_extract_package(&(p->package.elements[i]),
+                                              &trt_format, &element);
+                if (ACPI_FAILURE(status)) {
+                        nr_bad_entries++;
+                        pr_warn("_TRT package %d is invalid, ignored\n", i);
+                        continue;
+                }
+                if (!create_dev)
+                        continue;
+
+                result = acpi_bus_get_device(trt->source, &adev);
+                if (!result)
+                        acpi_create_platform_device(adev);
+                else
+                        pr_warn("Failed to get source ACPI device\n");
+
+                result = acpi_bus_get_device(trt->target, &adev);
+                if (!result)
+                        acpi_create_platform_device(adev);
+                else
+                        pr_warn("Failed to get target ACPI device\n");
+        }
+
+        *trtp = trts;
+        /* don't count bad entries */
+        *trt_count -= nr_bad_entries;
+end:
+        kfree(buffer.pointer);
+        return result;
+}
+EXPORT_SYMBOL(acpi_parse_trt);
+
+/**
+ * acpi_parse_art - Parse Active Relationship Table _ART
+ *
+ * @handle: ACPI handle of the device contains _ART
+ * @art_count: the number of valid entries resulted from parsing _ART
+ * @artp: pointer to pointer of array of art entries in parsing result
+ * @create_dev: whether to create platform devices for target and source
+ *
+ */
+int acpi_parse_art(acpi_handle handle, int *art_count, struct art **artp,
+                bool create_dev)
+{
+        acpi_status status;
+        int result = 0;
+        int i;
+        int nr_bad_entries = 0;
+        struct art *arts;
+        struct acpi_device *adev;
+        union acpi_object *p;
+        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
+        struct acpi_buffer element = { 0, NULL };
+        struct acpi_buffer art_format = {
+                sizeof("RRNNNNNNNNNNN"), "RRNNNNNNNNNNN" };
+
+        if (!acpi_has_method(handle, "_ART"))
+                return 0;
+
+        status = acpi_evaluate_object(handle, "_ART", NULL, &buffer);
+        if (ACPI_FAILURE(status))
+                return -ENODEV;
+
+        p = buffer.pointer;
+        if (!p || (p->type != ACPI_TYPE_PACKAGE)) {
+                pr_err("Invalid _ART data\n");
+                result = -EFAULT;
+                goto end;
+        }
+
+        /* ignore p->package.elements[0], as this is _ART Revision field */
+        *art_count = p->package.count - 1;
+        arts = kzalloc(*art_count * sizeof(struct art), GFP_KERNEL);
+        if (!arts) {
+                result = -ENOMEM;
+                goto end;
+        }
+
+        for (i = 0; i < *art_count; i++) {
+                struct art *art = &arts[i - nr_bad_entries];
+
+                element.length = sizeof(struct art);
+                element.pointer = art;
+
+                status = acpi_extract_package(&(p->package.elements[i + 1]),
+                                              &art_format, &element);
+                if (ACPI_FAILURE(status)) {
+                        pr_warn("_ART package %d is invalid, ignored", i);
+                        nr_bad_entries++;
+                        continue;
+                }
+                if (!create_dev)
+                        continue;
+
+                if (art->source) {
+                        result = acpi_bus_get_device(art->source, &adev);
+                        if (!result)
+                                acpi_create_platform_device(adev);
+                        else
+                                pr_warn("Failed to get source ACPI device\n");
+                }
+                if (art->target) {
+                        result = acpi_bus_get_device(art->target, &adev);
+                        if (!result)
+                                acpi_create_platform_device(adev);
+                        else
+                                pr_warn("Failed to get source ACPI device\n");
+                }
+        }
+
+        *artp = arts;
+        /* don't count bad entries */
+        *art_count -= nr_bad_entries;
+end:
+        kfree(buffer.pointer);
+        return result;
+}
+EXPORT_SYMBOL(acpi_parse_art);
+
+
+/* get device name from acpi handle */
+static void get_single_name(acpi_handle handle, char *name)
+{
+        struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER};
+
+        if (ACPI_FAILURE(acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer)))
+                pr_warn("Failed get name from handle\n");
+        else {
+                memcpy(name, buffer.pointer, ACPI_NAME_SIZE);
+                kfree(buffer.pointer);
+        }
+}
+
+static int fill_art(char __user *ubuf)
+{
+        int i;
+        int ret;
+        int count;
+        int art_len;
+        struct art *arts = NULL;
+        union art_object *art_user;
+
+        ret = acpi_parse_art(acpi_thermal_rel_handle, &count, &arts, false);
+        if (ret)
+                goto free_art;
+        art_len = count * sizeof(union art_object);
+        art_user = kzalloc(art_len, GFP_KERNEL);
+        if (!art_user) {
+                ret = -ENOMEM;
+                goto free_art;
+        }
+        /* now fill in user art data */
+        for (i = 0; i < count; i++) {
+                /* userspace art needs device name instead of acpi reference */
+                get_single_name(arts[i].source, art_user[i].source_device);
+                get_single_name(arts[i].target, art_user[i].target_device);
+                /* copy the rest int data in addition to source and target */
+                memcpy(&art_user[i].weight, &arts[i].weight,
+                        sizeof(u64) * (ACPI_NR_ART_ELEMENTS - 2));
+        }
+
+        if (copy_to_user(ubuf, art_user, art_len))
+                ret = -EFAULT;
+        kfree(art_user);
+free_art:
+        kfree(arts);
+        return ret;
+}
+
+static int fill_trt(char __user *ubuf)
+{
+        int i;
+        int ret;
+        int count;
+        int trt_len;
+        struct trt *trts = NULL;
+        union trt_object *trt_user;
+
+        ret = acpi_parse_trt(acpi_thermal_rel_handle, &count, &trts, false);
+        if (ret)
+                goto free_trt;
+        trt_len = count * sizeof(union trt_object);
+        trt_user = kzalloc(trt_len, GFP_KERNEL);
+        if (!trt_user) {
+                ret = -ENOMEM;
+                goto free_trt;
+        }
+        /* now fill in user trt data */
+        for (i = 0; i < count; i++) {
+                /* userspace trt needs device name instead of acpi reference */
+                get_single_name(trts[i].source, trt_user[i].source_device);
+                get_single_name(trts[i].target, trt_user[i].target_device);
+                trt_user[i].sample_period = trts[i].sample_period;
+                trt_user[i].influence = trts[i].influence;
+        }
+
+        if (copy_to_user(ubuf, trt_user, trt_len))
+                ret = -EFAULT;
+        kfree(trt_user);
+free_trt:
+        kfree(trts);
+        return ret;
+}
+
+static long acpi_thermal_rel_ioctl(struct file *f, unsigned int cmd,
+                                   unsigned long __arg)
+{
+        int ret = 0;
+        unsigned long length = 0;
+        unsigned long count = 0;
+        char __user *arg = (void __user *)__arg;
+        struct trt *trts;
+        struct art *arts;
+
+        switch (cmd) {
+        case ACPI_THERMAL_GET_TRT_COUNT:
+                ret = acpi_parse_trt(acpi_thermal_rel_handle, (int *)&count,
+                                &trts, false);
+                kfree(trts);
+                if (!ret)
+                        return put_user(count, (unsigned long __user *)__arg);
+                return ret;
+        case ACPI_THERMAL_GET_TRT_LEN:
+                ret = acpi_parse_trt(acpi_thermal_rel_handle, (int *)&count,
+                                &trts, false);
+                kfree(trts);
+                length = count * sizeof(union trt_object);
+                if (!ret)
+                        return put_user(length, (unsigned long __user *)__arg);
+                return ret;
+        case ACPI_THERMAL_GET_TRT:
+                return fill_trt(arg);
+        case ACPI_THERMAL_GET_ART_COUNT:
+                ret = acpi_parse_art(acpi_thermal_rel_handle, (int *)&count,
+                                &arts, false);
+                kfree(arts);
+                if (!ret)
+                        return put_user(count, (unsigned long __user *)__arg);
+                return ret;
+        case ACPI_THERMAL_GET_ART_LEN:
+                ret = acpi_parse_art(acpi_thermal_rel_handle, (int *)&count,
+                                &arts, false);
+                kfree(arts);
+                length = count * sizeof(union art_object);
+                if (!ret)
+                        return put_user(length, (unsigned long __user *)__arg);
+                return ret;
+
+        case ACPI_THERMAL_GET_ART:
+                return fill_art(arg);
+
+        default:
+                return -ENOTTY;
+        }
+}
+
+static const struct file_operations acpi_thermal_rel_fops = {
+        .owner          = THIS_MODULE,
+        .open           = acpi_thermal_rel_open,
+        .release        = acpi_thermal_rel_release,
+        .unlocked_ioctl = acpi_thermal_rel_ioctl,
+        .llseek         = no_llseek,
+};
+
+static struct miscdevice acpi_thermal_rel_misc_device = {
+        .minor  = MISC_DYNAMIC_MINOR,
+        "acpi_thermal_rel",
+        &acpi_thermal_rel_fops
+};
+
+int acpi_thermal_rel_misc_device_add(acpi_handle handle)
+{
+        acpi_thermal_rel_handle = handle;
+
+        return misc_register(&acpi_thermal_rel_misc_device);
+}
+EXPORT_SYMBOL(acpi_thermal_rel_misc_device_add);
+
+int acpi_thermal_rel_misc_device_remove(acpi_handle handle)
+{
+        misc_deregister(&acpi_thermal_rel_misc_device);
+
+        return 0;
+}
+EXPORT_SYMBOL(acpi_thermal_rel_misc_device_remove);
+
+MODULE_AUTHOR("Zhang Rui <rui.zhang@intel.com>");
+MODULE_AUTHOR("Jacob Pan <jacob.jun.pan@intel.com");
+MODULE_DESCRIPTION("Intel acpi thermal rel misc dev driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/thermal/int340x_thermal/acpi_thermal_rel.h b/drivers/thermal/int340x_thermal/acpi_thermal_rel.h
new file mode 100644
index 000000000000..f00700bc9d79
--- /dev/null
+++ b/drivers/thermal/int340x_thermal/acpi_thermal_rel.h
@@ -0,0 +1,84 @@
+#ifndef __ACPI_ACPI_THERMAL_H
+#define __ACPI_ACPI_THERMAL_H
+
+#include <asm/ioctl.h>
+
+#define ACPI_THERMAL_MAGIC 's'
+
+#define ACPI_THERMAL_GET_TRT_LEN _IOR(ACPI_THERMAL_MAGIC, 1, unsigned long)
+#define ACPI_THERMAL_GET_ART_LEN _IOR(ACPI_THERMAL_MAGIC, 2, unsigned long)
+#define ACPI_THERMAL_GET_TRT_COUNT _IOR(ACPI_THERMAL_MAGIC, 3, unsigned long)
+#define ACPI_THERMAL_GET_ART_COUNT _IOR(ACPI_THERMAL_MAGIC, 4, unsigned long)
+
+#define ACPI_THERMAL_GET_TRT    _IOR(ACPI_THERMAL_MAGIC, 5, unsigned long)
+#define ACPI_THERMAL_GET_ART    _IOR(ACPI_THERMAL_MAGIC, 6, unsigned long)
+
+struct art {
+        acpi_handle source;
+        acpi_handle target;
+        u64 weight;
+        u64 ac0_max;
+        u64 ac1_max;
+        u64 ac2_max;
+        u64 ac3_max;
+        u64 ac4_max;
+        u64 ac5_max;
+        u64 ac6_max;
+        u64 ac7_max;
+        u64 ac8_max;
+        u64 ac9_max;
+} __packed;
+
+struct trt {
+        acpi_handle source;
+        acpi_handle target;
+        u64 influence;
+        u64 sample_period;
+        u64 reverved1;
+        u64 reverved2;
+        u64 reverved3;
+        u64 reverved4;
+} __packed;
+
+#define ACPI_NR_ART_ELEMENTS 13
+/* for usrspace */
+union art_object {
+        struct {
+                char source_device[8]; /* ACPI single name */
+                char target_device[8]; /* ACPI single name */
+                u64 weight;
+                u64 ac0_max_level;
+                u64 ac1_max_level;
+                u64 ac2_max_level;
+                u64 ac3_max_level;
+                u64 ac4_max_level;
+                u64 ac5_max_level;
+                u64 ac6_max_level;
+                u64 ac7_max_level;
+                u64 ac8_max_level;
+                u64 ac9_max_level;
+        };
+        u64 __data[ACPI_NR_ART_ELEMENTS];
+};
+
+union trt_object {
+        struct {
+                char source_device[8]; /* ACPI single name */
+                char target_device[8]; /* ACPI single name */
+                u64 influence;
+                u64 sample_period;
+                u64 reserved[4];
+        };
+        u64 __data[8];
+};
+
+#ifdef __KERNEL__
+int acpi_thermal_rel_misc_device_add(acpi_handle handle);
+int acpi_thermal_rel_misc_device_remove(acpi_handle handle);
+int acpi_parse_art(acpi_handle handle, int *art_count, struct art **arts,
+                bool create_dev);
+int acpi_parse_trt(acpi_handle handle, int *trt_count, struct trt **trts,
+                bool create_dev);
+#endif
+
+#endif /* __ACPI_ACPI_THERMAL_H */
diff --git a/drivers/thermal/int340x_thermal/int3400_thermal.c b/drivers/thermal/int340x_thermal/int3400_thermal.c
new file mode 100644
index 000000000000..edc1cce117ba
--- /dev/null
+++ b/drivers/thermal/int340x_thermal/int3400_thermal.c
@@ -0,0 +1,271 @@
+/*
+ * INT3400 thermal driver
+ *
+ * Copyright (C) 2014, Intel Corporation
+ * Authors: Zhang Rui <rui.zhang@intel.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/acpi.h>
+#include <linux/thermal.h>
+#include "acpi_thermal_rel.h"
+
+enum int3400_thermal_uuid {
+        INT3400_THERMAL_PASSIVE_1,
+        INT3400_THERMAL_PASSIVE_2,
+        INT3400_THERMAL_ACTIVE,
+        INT3400_THERMAL_CRITICAL,
+        INT3400_THERMAL_COOLING_MODE,
+        INT3400_THERMAL_MAXIMUM_UUID,
+};
+
+static u8 *int3400_thermal_uuids[INT3400_THERMAL_MAXIMUM_UUID] = {
+        "42A441D6-AE6A-462b-A84B-4A8CE79027D3",
+        "9E04115A-AE87-4D1C-9500-0F3E340BFE75",
+        "3A95C389-E4B8-4629-A526-C52C88626BAE",
+        "97C68AE7-15FA-499c-B8C9-5DA81D606E0A",
+        "16CAF1B7-DD38-40ed-B1C1-1B8A1913D531",
+};
+
+struct int3400_thermal_priv {
+        struct acpi_device *adev;
+        struct thermal_zone_device *thermal;
+        int mode;
+        int art_count;
+        struct art *arts;
+        int trt_count;
+        struct trt *trts;
+        u8 uuid_bitmap;
+        int rel_misc_dev_res;
+};
+
+static int int3400_thermal_get_uuids(struct int3400_thermal_priv *priv)
+{
+        struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER, NULL};
+        union acpi_object *obja, *objb;
+        int i, j;
+        int result = 0;
+        acpi_status status;
+
+        status = acpi_evaluate_object(priv->adev->handle, "IDSP", NULL, &buf);
+        if (ACPI_FAILURE(status))
+                return -ENODEV;
+
+        obja = (union acpi_object *)buf.pointer;
+        if (obja->type != ACPI_TYPE_PACKAGE) {
+                result = -EINVAL;
+                goto end;
+        }
+
+        for (i = 0; i < obja->package.count; i++) {
+                objb = &obja->package.elements[i];
+                if (objb->type != ACPI_TYPE_BUFFER) {
+                        result = -EINVAL;
+                        goto end;
+                }
+
+                /* UUID must be 16 bytes */
+                if (objb->buffer.length != 16) {
+                        result = -EINVAL;
+                        goto end;
+                }
+
+                for (j = 0; j < INT3400_THERMAL_MAXIMUM_UUID; j++) {
+                        u8 uuid[16];
+
+                        acpi_str_to_uuid(int3400_thermal_uuids[j], uuid);
+                        if (!strncmp(uuid, objb->buffer.pointer, 16)) {
+                                priv->uuid_bitmap |= (1 << j);
+                                break;
+                        }
+                }
+        }
+
+end:
+        kfree(buf.pointer);
+        return result;
+}
+
+static int int3400_thermal_run_osc(acpi_handle handle,
+                                enum int3400_thermal_uuid uuid, bool enable)
+{
+        u32 ret, buf[2];
+        acpi_status status;
+        int result = 0;
+        struct acpi_osc_context context = {
+                .uuid_str = int3400_thermal_uuids[uuid],
+                .rev = 1,
+                .cap.length = 8,
+        };
+
+        buf[OSC_QUERY_DWORD] = 0;
+        buf[OSC_SUPPORT_DWORD] = enable;
+
+        context.cap.pointer = buf;
+
+        status = acpi_run_osc(handle, &context);
+        if (ACPI_SUCCESS(status)) {
+                ret = *((u32 *)(context.ret.pointer + 4));
+                if (ret != enable)
+                        result = -EPERM;
+        } else
+                result = -EPERM;
+
+        kfree(context.ret.pointer);
+        return result;
+}
+
+static int int3400_thermal_get_temp(struct thermal_zone_device *thermal,
+                        unsigned long *temp)
+{
+        *temp = 20 * 1000; /* faked temp sensor with 20C */
+        return 0;
+}
+
+static int int3400_thermal_get_mode(struct thermal_zone_device *thermal,
+                                enum thermal_device_mode *mode)
+{
+        struct int3400_thermal_priv *priv = thermal->devdata;
+
+        if (!priv)
+                return -EINVAL;
+
+        *mode = priv->mode;
+
+        return 0;
+}
+
+static int int3400_thermal_set_mode(struct thermal_zone_device *thermal,
+                                enum thermal_device_mode mode)
+{
+        struct int3400_thermal_priv *priv = thermal->devdata;
+        bool enable;
+        int result = 0;
+
+        if (!priv)
+                return -EINVAL;
+
+        if (mode == THERMAL_DEVICE_ENABLED)
+                enable = true;
+        else if (mode == THERMAL_DEVICE_DISABLED)
+                enable = false;
+        else
+                return -EINVAL;
+
+        if (enable != priv->mode) {
+                priv->mode = enable;
+                /* currently, only PASSIVE COOLING is supported */
+                result = int3400_thermal_run_osc(priv->adev->handle,
+                                        INT3400_THERMAL_PASSIVE_1, enable);
+        }
+        return result;
+}
+
+static struct thermal_zone_device_ops int3400_thermal_ops = {
+        .get_temp = int3400_thermal_get_temp,
+};
+
+static struct thermal_zone_params int3400_thermal_params = {
+        .governor_name = "user_space",
+        .no_hwmon = true,
+};
+
+static int int3400_thermal_probe(struct platform_device *pdev)
+{
+        struct acpi_device *adev = ACPI_COMPANION(&pdev->dev);
+        struct int3400_thermal_priv *priv;
+        int result;
+
+        if (!adev)
+                return -ENODEV;
+
+        priv = kzalloc(sizeof(struct int3400_thermal_priv), GFP_KERNEL);
+        if (!priv)
+                return -ENOMEM;
+
+        priv->adev = adev;
+
+        result = int3400_thermal_get_uuids(priv);
+        if (result)
+                goto free_priv;
+
+        result = acpi_parse_art(priv->adev->handle, &priv->art_count,
+                                &priv->arts, true);
+        if (result)
+                goto free_priv;
+
+
+        result = acpi_parse_trt(priv->adev->handle, &priv->trt_count,
+                                &priv->trts, true);
+        if (result)
+                goto free_art;
+
+        platform_set_drvdata(pdev, priv);
+
+        if (priv->uuid_bitmap & 1 << INT3400_THERMAL_PASSIVE_1) {
+                int3400_thermal_ops.get_mode = int3400_thermal_get_mode;
+                int3400_thermal_ops.set_mode = int3400_thermal_set_mode;
+        }
+        priv->thermal = thermal_zone_device_register("INT3400 Thermal", 0, 0,
+                                                priv, &int3400_thermal_ops,
+                                                &int3400_thermal_params, 0, 0);
+        if (IS_ERR(priv->thermal)) {
+                result = PTR_ERR(priv->thermal);
+                goto free_trt;
+        }
+
+        priv->rel_misc_dev_res = acpi_thermal_rel_misc_device_add(
+                                                        priv->adev->handle);
+
+        return 0;
+free_trt:
+        kfree(priv->trts);
+free_art:
+        kfree(priv->arts);
+free_priv:
+        kfree(priv);
+        return result;
+}
+
+static int int3400_thermal_remove(struct platform_device *pdev)
+{
+        struct int3400_thermal_priv *priv = platform_get_drvdata(pdev);
+
+        if (!priv->rel_misc_dev_res)
+                acpi_thermal_rel_misc_device_remove(priv->adev->handle);
+
+        thermal_zone_device_unregister(priv->thermal);
+        kfree(priv->trts);
+        kfree(priv->arts);
+        kfree(priv);
+        return 0;
+}
+
+static const struct acpi_device_id int3400_thermal_match[] = {
+        {"INT3400", 0},
+        {}
+};
+
+MODULE_DEVICE_TABLE(acpi, int3400_thermal_match);
+
+static struct platform_driver int3400_thermal_driver = {
+        .probe = int3400_thermal_probe,
+        .remove = int3400_thermal_remove,
+        .driver = {
+                   .name = "int3400 thermal",
+                   .owner = THIS_MODULE,
+                   .acpi_match_table = ACPI_PTR(int3400_thermal_match),
+                   },
+};
+
+module_platform_driver(int3400_thermal_driver);
+
+MODULE_DESCRIPTION("INT3400 Thermal driver");
+MODULE_AUTHOR("Zhang Rui <rui.zhang@intel.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/thermal/int340x_thermal/int3402_thermal.c b/drivers/thermal/int340x_thermal/int3402_thermal.c
new file mode 100644
index 000000000000..a5d08c14ba24
--- /dev/null
+++ b/drivers/thermal/int340x_thermal/int3402_thermal.c
@@ -0,0 +1,242 @@
+/*
+ * INT3402 thermal driver for memory temperature reporting
+ *
+ * Copyright (C) 2014, Intel Corporation
+ * Authors: Aaron Lu <aaron.lu@intel.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/acpi.h>
+#include <linux/thermal.h>
+
+#define ACPI_ACTIVE_COOLING_MAX_NR 10
+
+struct active_trip {
+        unsigned long temp;
+        int id;
+        bool valid;
+};
+
+struct int3402_thermal_data {
+        unsigned long *aux_trips;
+        int aux_trip_nr;
+        unsigned long psv_temp;
+        int psv_trip_id;
+        unsigned long crt_temp;
+        int crt_trip_id;
+        unsigned long hot_temp;
+        int hot_trip_id;
+        struct active_trip act_trips[ACPI_ACTIVE_COOLING_MAX_NR];
+        acpi_handle *handle;
+};
+
+static int int3402_thermal_get_zone_temp(struct thermal_zone_device *zone,
+                                         unsigned long *temp)
+{
+        struct int3402_thermal_data *d = zone->devdata;
+        unsigned long long tmp;
+        acpi_status status;
+
+        status = acpi_evaluate_integer(d->handle, "_TMP", NULL, &tmp);
+        if (ACPI_FAILURE(status))
+                return -ENODEV;
+
+        /* _TMP returns the temperature in tenths of degrees Kelvin */
+        *temp = DECI_KELVIN_TO_MILLICELSIUS(tmp);
+
+        return 0;
+}
+
+static int int3402_thermal_get_trip_temp(struct thermal_zone_device *zone,
+                                         int trip, unsigned long *temp)
+{
+        struct int3402_thermal_data *d = zone->devdata;
+        int i;
+
+        if (trip < d->aux_trip_nr)
+                *temp = d->aux_trips[trip];
+        else if (trip == d->crt_trip_id)
+                *temp = d->crt_temp;
+        else if (trip == d->psv_trip_id)
+                *temp = d->psv_temp;
+        else if (trip == d->hot_trip_id)
+                *temp = d->hot_temp;
+        else {
+                for (i = 0; i < ACPI_ACTIVE_COOLING_MAX_NR; i++) {
+                        if (d->act_trips[i].valid &&
+                            d->act_trips[i].id == trip) {
+                                *temp = d->act_trips[i].temp;
+                                break;
+                        }
+                }
+                if (i == ACPI_ACTIVE_COOLING_MAX_NR)
+                        return -EINVAL;
+        }
+        return 0;
+}
+
+static int int3402_thermal_get_trip_type(struct thermal_zone_device *zone,
+                                         int trip, enum thermal_trip_type *type)
+{
+        struct int3402_thermal_data *d = zone->devdata;
+        int i;
+
+        if (trip < d->aux_trip_nr)
+                *type = THERMAL_TRIP_PASSIVE;
+        else if (trip == d->crt_trip_id)
+                *type = THERMAL_TRIP_CRITICAL;
+        else if (trip == d->hot_trip_id)
+                *type = THERMAL_TRIP_HOT;
+        else if (trip == d->psv_trip_id)
+                *type = THERMAL_TRIP_PASSIVE;
+        else {
+                for (i = 0; i < ACPI_ACTIVE_COOLING_MAX_NR; i++) {
+                        if (d->act_trips[i].valid &&
+                            d->act_trips[i].id == trip) {
+                                *type = THERMAL_TRIP_ACTIVE;
+                                break;
+                        }
+                }
+                if (i == ACPI_ACTIVE_COOLING_MAX_NR)
+                        return -EINVAL;
+        }
+        return 0;
+}
+
+static int int3402_thermal_set_trip_temp(struct thermal_zone_device *zone, int trip,
+                                  unsigned long temp)
+{
+        struct int3402_thermal_data *d = zone->devdata;
+        acpi_status status;
+        char name[10];
+
+        snprintf(name, sizeof(name), "PAT%d", trip);
+        status = acpi_execute_simple_method(d->handle, name,
+                        MILLICELSIUS_TO_DECI_KELVIN(temp));
+        if (ACPI_FAILURE(status))
+                return -EIO;
+
+        d->aux_trips[trip] = temp;
+        return 0;
+}
+
+static struct thermal_zone_device_ops int3402_thermal_zone_ops = {
+        .get_temp       = int3402_thermal_get_zone_temp,
+        .get_trip_temp  = int3402_thermal_get_trip_temp,
+        .get_trip_type  = int3402_thermal_get_trip_type,
+        .set_trip_temp  = int3402_thermal_set_trip_temp,
+};
+
+static struct thermal_zone_params int3402_thermal_params = {
+        .governor_name = "user_space",
+        .no_hwmon = true,
+};
+
+static int int3402_thermal_get_temp(acpi_handle handle, char *name,
+                                    unsigned long *temp)
+{
+        unsigned long long r;
+        acpi_status status;
+
+        status = acpi_evaluate_integer(handle, name, NULL, &r);
+        if (ACPI_FAILURE(status))
+                return -EIO;
+
+        *temp = DECI_KELVIN_TO_MILLICELSIUS(r);
+        return 0;
+}
+
+static int int3402_thermal_probe(struct platform_device *pdev)
+{
+        struct acpi_device *adev = ACPI_COMPANION(&pdev->dev);
+        struct int3402_thermal_data *d;
+        struct thermal_zone_device *zone;
+        acpi_status status;
+        unsigned long long trip_cnt;
+        int trip_mask = 0, i;
+
+        if (!acpi_has_method(adev->handle, "_TMP"))
+                return -ENODEV;
+
+        d = devm_kzalloc(&pdev->dev, sizeof(*d), GFP_KERNEL);
+        if (!d)
+                return -ENOMEM;
+
+        status = acpi_evaluate_integer(adev->handle, "PATC", NULL, &trip_cnt);
+        if (ACPI_FAILURE(status))
+                trip_cnt = 0;
+        else {
+                d->aux_trips = devm_kzalloc(&pdev->dev,
+                                sizeof(*d->aux_trips) * trip_cnt, GFP_KERNEL);
+                if (!d->aux_trips)
+                        return -ENOMEM;
+                trip_mask = trip_cnt - 1;
+                d->handle = adev->handle;
+                d->aux_trip_nr = trip_cnt;
+        }
+
+        d->crt_trip_id = -1;
+        if (!int3402_thermal_get_temp(adev->handle, "_CRT", &d->crt_temp))
+                d->crt_trip_id = trip_cnt++;
+        d->hot_trip_id = -1;
+        if (!int3402_thermal_get_temp(adev->handle, "_HOT", &d->hot_temp))
+                d->hot_trip_id = trip_cnt++;
+        d->psv_trip_id = -1;
+        if (!int3402_thermal_get_temp(adev->handle, "_PSV", &d->psv_temp))
+                d->psv_trip_id = trip_cnt++;
+        for (i = 0; i < ACPI_ACTIVE_COOLING_MAX_NR; i++) {
+                char name[5] = { '_', 'A', 'C', '0' + i, '\0' };
+                if (int3402_thermal_get_temp(adev->handle, name,
+                                             &d->act_trips[i].temp))
+                        break;
+                d->act_trips[i].id = trip_cnt++;
+                d->act_trips[i].valid = true;
+        }
+
+        zone = thermal_zone_device_register(acpi_device_bid(adev), trip_cnt,
+                                            trip_mask, d,
+                                            &int3402_thermal_zone_ops,
+                                            &int3402_thermal_params,
+                                            0, 0);
+        if (IS_ERR(zone))
+                return PTR_ERR(zone);
+        platform_set_drvdata(pdev, zone);
+
+        return 0;
+}
+
+static int int3402_thermal_remove(struct platform_device *pdev)
+{
+        struct thermal_zone_device *zone = platform_get_drvdata(pdev);
+
+        thermal_zone_device_unregister(zone);
+        return 0;
+}
+
+static const struct acpi_device_id int3402_thermal_match[] = {
+        {"INT3402", 0},
+        {}
+};
+
+MODULE_DEVICE_TABLE(acpi, int3402_thermal_match);
+
+static struct platform_driver int3402_thermal_driver = {
+        .probe = int3402_thermal_probe,
+        .remove = int3402_thermal_remove,
+        .driver = {
+                   .name = "int3402 thermal",
+                   .owner = THIS_MODULE,
+                   .acpi_match_table = int3402_thermal_match,
+                   },
+};
+
+module_platform_driver(int3402_thermal_driver);
+
+MODULE_DESCRIPTION("INT3402 Thermal driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/thermal/int340x_thermal/int3403_thermal.c b/drivers/thermal/int340x_thermal/int3403_thermal.c
new file mode 100644
index 000000000000..d20dba986f0f
--- /dev/null
+++ b/drivers/thermal/int340x_thermal/int3403_thermal.c
@@ -0,0 +1,477 @@
+/*
+ * ACPI INT3403 thermal driver
+ * Copyright (c) 2013, Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/types.h>
+#include <linux/acpi.h>
+#include <linux/thermal.h>
+#include <linux/platform_device.h>
+
+#define INT3403_TYPE_SENSOR             0x03
+#define INT3403_TYPE_CHARGER            0x0B
+#define INT3403_TYPE_BATTERY            0x0C
+#define INT3403_PERF_CHANGED_EVENT      0x80
+#define INT3403_THERMAL_EVENT           0x90
+
+#define DECI_KELVIN_TO_MILLI_CELSIUS(t, off) (((t) - (off)) * 100)
+#define KELVIN_OFFSET   2732
+#define MILLI_CELSIUS_TO_DECI_KELVIN(t, off) (((t) / 100) + (off))
+
+struct int3403_sensor {
+        struct thermal_zone_device *tzone;
+        unsigned long *thresholds;
+        unsigned long   crit_temp;
+        int             crit_trip_id;
+        unsigned long   psv_temp;
+        int             psv_trip_id;
+
+};
+
+struct int3403_performance_state {
+        u64 performance;
+        u64 power;
+        u64 latency;
+        u64 linear;
+        u64 control;
+        u64 raw_performace;
+        char *raw_unit;
+        int reserved;
+};
+
+struct int3403_cdev {
+        struct thermal_cooling_device *cdev;
+        unsigned long max_state;
+};
+
+struct int3403_priv {
+        struct platform_device *pdev;
+        struct acpi_device *adev;
+        unsigned long long type;
+        void *priv;
+};
+
+static int sys_get_curr_temp(struct thermal_zone_device *tzone,
+                                unsigned long *temp)
+{
+        struct int3403_priv *priv = tzone->devdata;
+        struct acpi_device *device = priv->adev;
+        unsigned long long tmp;
+        acpi_status status;
+
+        status = acpi_evaluate_integer(device->handle, "_TMP", NULL, &tmp);
+        if (ACPI_FAILURE(status))
+                return -EIO;
+
+        *temp = DECI_KELVIN_TO_MILLI_CELSIUS(tmp, KELVIN_OFFSET);
+
+        return 0;
+}
+
+static int sys_get_trip_hyst(struct thermal_zone_device *tzone,
+                int trip, unsigned long *temp)
+{
+        struct int3403_priv *priv = tzone->devdata;
+        struct acpi_device *device = priv->adev;
+        unsigned long long hyst;
+        acpi_status status;
+
+        status = acpi_evaluate_integer(device->handle, "GTSH", NULL, &hyst);
+        if (ACPI_FAILURE(status))
+                return -EIO;
+
+        *temp = DECI_KELVIN_TO_MILLI_CELSIUS(hyst, KELVIN_OFFSET);
+
+        return 0;
+}
+
+static int sys_get_trip_temp(struct thermal_zone_device *tzone,
+                int trip, unsigned long *temp)
+{
+        struct int3403_priv *priv = tzone->devdata;
+        struct int3403_sensor *obj = priv->priv;
+
+        if (priv->type != INT3403_TYPE_SENSOR || !obj)
+                return -EINVAL;
+
+        if (trip == obj->crit_trip_id)
+                *temp = obj->crit_temp;
+        else if (trip == obj->psv_trip_id)
+                *temp = obj->psv_temp;
+        else {
+                /*
+                 * get_trip_temp is a mandatory callback but
+                 * PATx method doesn't return any value, so return
+                 * cached value, which was last set from user space
+                 */
+                *temp = obj->thresholds[trip];
+        }
+
+        return 0;
+}
+
+static int sys_get_trip_type(struct thermal_zone_device *thermal,
+                int trip, enum thermal_trip_type *type)
+{
+        struct int3403_priv *priv = thermal->devdata;
+        struct int3403_sensor *obj = priv->priv;
+
+        /* Mandatory callback, may not mean much here */
+        if (trip == obj->crit_trip_id)
+                *type = THERMAL_TRIP_CRITICAL;
+        else
+                *type = THERMAL_TRIP_PASSIVE;
+
+        return 0;
+}
+
+int sys_set_trip_temp(struct thermal_zone_device *tzone, int trip,
+                                                        unsigned long temp)
+{
+        struct int3403_priv *priv = tzone->devdata;
+        struct acpi_device *device = priv->adev;
+        struct int3403_sensor *obj = priv->priv;
+        acpi_status status;
+        char name[10];
+        int ret = 0;
+
+        snprintf(name, sizeof(name), "PAT%d", trip);
+        if (acpi_has_method(device->handle, name)) {
+                status = acpi_execute_simple_method(device->handle, name,
+                                MILLI_CELSIUS_TO_DECI_KELVIN(temp,
+                                                        KELVIN_OFFSET));
+                if (ACPI_FAILURE(status))
+                        ret = -EIO;
+                else
+                        obj->thresholds[trip] = temp;
+        } else {
+                ret = -EIO;
+                dev_err(&device->dev, "sys_set_trip_temp: method not found\n");
+        }
+
+        return ret;
+}
+
+static struct thermal_zone_device_ops tzone_ops = {
+        .get_temp = sys_get_curr_temp,
+        .get_trip_temp = sys_get_trip_temp,
+        .get_trip_type = sys_get_trip_type,
+        .set_trip_temp = sys_set_trip_temp,
+        .get_trip_hyst =  sys_get_trip_hyst,
+};
+
+static struct thermal_zone_params int3403_thermal_params = {
+        .governor_name = "user_space",
+        .no_hwmon = true,
+};
+
+static void int3403_notify(acpi_handle handle,
+                u32 event, void *data)
+{
+        struct int3403_priv *priv = data;
+        struct int3403_sensor *obj;
+
+        if (!priv)
+                return;
+
+        obj = priv->priv;
+        if (priv->type != INT3403_TYPE_SENSOR || !obj)
+                return;
+
+        switch (event) {
+        case INT3403_PERF_CHANGED_EVENT:
+                break;
+        case INT3403_THERMAL_EVENT:
+                thermal_zone_device_update(obj->tzone);
+                break;
+        default:
+                dev_err(&priv->pdev->dev, "Unsupported event [0x%x]\n", event);
+                break;
+        }
+}
+
+static int sys_get_trip_crt(struct acpi_device *device, unsigned long *temp)
+{
+        unsigned long long crt;
+        acpi_status status;
+
+        status = acpi_evaluate_integer(device->handle, "_CRT", NULL, &crt);
+        if (ACPI_FAILURE(status))
+                return -EIO;
+
+        *temp = DECI_KELVIN_TO_MILLI_CELSIUS(crt, KELVIN_OFFSET);
+
+        return 0;
+}
+
+static int sys_get_trip_psv(struct acpi_device *device, unsigned long *temp)
+{
+        unsigned long long psv;
+        acpi_status status;
+
+        status = acpi_evaluate_integer(device->handle, "_PSV", NULL, &psv);
+        if (ACPI_FAILURE(status))
+                return -EIO;
+
+        *temp = DECI_KELVIN_TO_MILLI_CELSIUS(psv, KELVIN_OFFSET);
+
+        return 0;
+}
+
+static int int3403_sensor_add(struct int3403_priv *priv)
+{
+        int result = 0;
+        acpi_status status;
+        struct int3403_sensor *obj;
+        unsigned long long trip_cnt;
+        int trip_mask = 0;
+
+        obj = devm_kzalloc(&priv->pdev->dev, sizeof(*obj), GFP_KERNEL);
+        if (!obj)
+                return -ENOMEM;
+
+        priv->priv = obj;
+
+        status = acpi_evaluate_integer(priv->adev->handle, "PATC", NULL,
+                                                &trip_cnt);
+        if (ACPI_FAILURE(status))
+                trip_cnt = 0;
+
+        if (trip_cnt) {
+                /* We have to cache, thresholds can't be readback */
+                obj->thresholds = devm_kzalloc(&priv->pdev->dev,
+                                        sizeof(*obj->thresholds) * trip_cnt,
+                                        GFP_KERNEL);
+                if (!obj->thresholds) {
+                        result = -ENOMEM;
+                        goto err_free_obj;
+                }
+                trip_mask = BIT(trip_cnt) - 1;
+        }
+
+        obj->psv_trip_id = -1;
+        if (!sys_get_trip_psv(priv->adev, &obj->psv_temp))
+                obj->psv_trip_id = trip_cnt++;
+
+        obj->crit_trip_id = -1;
+        if (!sys_get_trip_crt(priv->adev, &obj->crit_temp))
+                obj->crit_trip_id = trip_cnt++;
+
+        obj->tzone = thermal_zone_device_register(acpi_device_bid(priv->adev),
+                                trip_cnt, trip_mask, priv, &tzone_ops,
+                                &int3403_thermal_params, 0, 0);
+        if (IS_ERR(obj->tzone)) {
+                result = PTR_ERR(obj->tzone);
+                obj->tzone = NULL;
+                goto err_free_obj;
+        }
+
+        result = acpi_install_notify_handler(priv->adev->handle,
+                        ACPI_DEVICE_NOTIFY, int3403_notify,
+                        (void *)priv);
+        if (result)
+                goto err_free_obj;
+
+        return 0;
+
+ err_free_obj:
+        if (obj->tzone)
+                thermal_zone_device_unregister(obj->tzone);
+        return result;
+}
+
+static int int3403_sensor_remove(struct int3403_priv *priv)
+{
+        struct int3403_sensor *obj = priv->priv;
+
+        thermal_zone_device_unregister(obj->tzone);
+        return 0;
+}
+
+/* INT3403 Cooling devices */
+static int int3403_get_max_state(struct thermal_cooling_device *cdev,
+                                 unsigned long *state)
+{
+        struct int3403_priv *priv = cdev->devdata;
+        struct int3403_cdev *obj = priv->priv;
+
+        *state = obj->max_state;
+        return 0;
+}
+
+static int int3403_get_cur_state(struct thermal_cooling_device *cdev,
+                                 unsigned long *state)
+{
+        struct int3403_priv *priv = cdev->devdata;
+        unsigned long long level;
+        acpi_status status;
+
+        status = acpi_evaluate_integer(priv->adev->handle, "PPPC", NULL, &level);
+        if (ACPI_SUCCESS(status)) {
+                *state = level;
+                return 0;
+        } else
+                return -EINVAL;
+}
+
+static int
+int3403_set_cur_state(struct thermal_cooling_device *cdev, unsigned long state)
+{
+        struct int3403_priv *priv = cdev->devdata;
+        acpi_status status;
+
+        status = acpi_execute_simple_method(priv->adev->handle, "SPPC", state);
+        if (ACPI_SUCCESS(status))
+                return 0;
+        else
+                return -EINVAL;
+}
+
+static const struct thermal_cooling_device_ops int3403_cooling_ops = {
+        .get_max_state = int3403_get_max_state,
+        .get_cur_state = int3403_get_cur_state,
+        .set_cur_state = int3403_set_cur_state,
+};
+
+static int int3403_cdev_add(struct int3403_priv *priv)
+{
+        int result = 0;
+        acpi_status status;
+        struct int3403_cdev *obj;
+        struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER, NULL };
+        union acpi_object *p;
+
+        obj = devm_kzalloc(&priv->pdev->dev, sizeof(*obj), GFP_KERNEL);
+        if (!obj)
+                return -ENOMEM;
+
+        status = acpi_evaluate_object(priv->adev->handle, "PPSS", NULL, &buf);
+        if (ACPI_FAILURE(status))
+                return -ENODEV;
+
+        p = buf.pointer;
+        if (!p || (p->type != ACPI_TYPE_PACKAGE)) {
+                printk(KERN_WARNING "Invalid PPSS data\n");
+                return -EFAULT;
+        }
+
+        obj->max_state = p->package.count - 1;
+        obj->cdev =
+                thermal_cooling_device_register(acpi_device_bid(priv->adev),
+                                priv, &int3403_cooling_ops);
+        if (IS_ERR(obj->cdev))
+                result = PTR_ERR(obj->cdev);
+
+        priv->priv = obj;
+
+        /* TODO: add ACPI notification support */
+
+        return result;
+}
+
+static int int3403_cdev_remove(struct int3403_priv *priv)
+{
+        struct int3403_cdev *obj = priv->priv;
+
+        thermal_cooling_device_unregister(obj->cdev);
+        return 0;
+}
+
+static int int3403_add(struct platform_device *pdev)
+{
+        struct int3403_priv *priv;
+        int result = 0;
+        acpi_status status;
+
+        priv = devm_kzalloc(&pdev->dev, sizeof(struct int3403_priv),
+                            GFP_KERNEL);
+        if (!priv)
+                return -ENOMEM;
+
+        priv->pdev = pdev;
+        priv->adev = ACPI_COMPANION(&(pdev->dev));
+        if (!priv->adev) {
+                result = -EINVAL;
+                goto err;
+        }
+
+        status = acpi_evaluate_integer(priv->adev->handle, "PTYP",
+                                       NULL, &priv->type);
+        if (ACPI_FAILURE(status)) {
+                result = -EINVAL;
+                goto err;
+        }
+
+        platform_set_drvdata(pdev, priv);
+        switch (priv->type) {
+        case INT3403_TYPE_SENSOR:
+                result = int3403_sensor_add(priv);
+                break;
+        case INT3403_TYPE_CHARGER:
+        case INT3403_TYPE_BATTERY:
+                result = int3403_cdev_add(priv);
+                break;
+        default:
+                result = -EINVAL;
+        }
+
+        if (result)
+                goto err;
+        return result;
+
+err:
+        return result;
+}
+
+static int int3403_remove(struct platform_device *pdev)
+{
+        struct int3403_priv *priv = platform_get_drvdata(pdev);
+
+        switch (priv->type) {
+        case INT3403_TYPE_SENSOR:
+                int3403_sensor_remove(priv);
+                break;
+        case INT3403_TYPE_CHARGER:
+        case INT3403_TYPE_BATTERY:
+                int3403_cdev_remove(priv);
+                break;
+        default:
+                break;
+        }
+
+        return 0;
+}
+
+static const struct acpi_device_id int3403_device_ids[] = {
+        {"INT3403", 0},
+        {"", 0},
+};
+MODULE_DEVICE_TABLE(acpi, int3403_device_ids);
+
+static struct platform_driver int3403_driver = {
+        .probe = int3403_add,
+        .remove = int3403_remove,
+        .driver = {
+                .name = "int3403 thermal",
+                .owner  = THIS_MODULE,
+                .acpi_match_table = int3403_device_ids,
+        },
+};
+
+module_platform_driver(int3403_driver);
+
+MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("ACPI INT3403 thermal driver");
diff --git a/drivers/thermal/of-thermal.c b/drivers/thermal/of-thermal.c
index 4b2b999b7611..f8eb625b8400 100644
--- a/drivers/thermal/of-thermal.c
+++ b/drivers/thermal/of-thermal.c
@@ -401,6 +401,10 @@ thermal_zone_of_sensor_register(struct device *dev, int sensor_id,
                 struct of_phandle_args sensor_specs;
                 int ret, id;
 
+                /* Check whether child is enabled or not */
+                if (!of_device_is_available(child))
+                        continue;
+
                 /* For now, thermal framework supports only 1 sensor per zone */
                 ret = of_parse_phandle_with_args(child, "thermal-sensors",
                                                  "#thermal-sensor-cells",
@@ -771,6 +775,10 @@ int __init of_parse_thermal_zones(void)
                 struct thermal_zone_device *zone;
                 struct thermal_zone_params *tzp;
 
+                /* Check whether child is enabled or not */
+                if (!of_device_is_available(child))
+                        continue;
+
                 tz = thermal_of_build_thermal_zone(child);
                 if (IS_ERR(tz)) {
                         pr_err("failed to build thermal zone %s: %ld\n",
@@ -838,6 +846,10 @@ void of_thermal_destroy_zones(void)
         for_each_child_of_node(np, child) {
                 struct thermal_zone_device *zone;
 
+                /* Check whether child is enabled or not */
+                if (!of_device_is_available(child))
+                        continue;
+
                 zone = thermal_zone_get_zone_by_name(child->name);
                 if (IS_ERR(zone))
                         continue;
diff --git a/drivers/thermal/step_wise.c b/drivers/thermal/step_wise.c
index f251521baaa2..fdd1f523a1ed 100644
--- a/drivers/thermal/step_wise.c
+++ b/drivers/thermal/step_wise.c
@@ -23,6 +23,7 @@
  */
 
 #include <linux/thermal.h>
+#include <trace/events/thermal.h>
 
 #include "thermal_core.h"
 
@@ -76,7 +77,7 @@ static unsigned long get_target_state(struct thermal_instance *instance,
                         next_target = instance->upper;
                 break;
         case THERMAL_TREND_DROPPING:
-                if (cur_state == instance->lower) {
+                if (cur_state <= instance->lower) {
                         if (!throttle)
                                 next_target = THERMAL_NO_TARGET;
                 } else {
@@ -129,8 +130,10 @@ static void thermal_zone_trip_update(struct thermal_zone_device *tz, int trip)
 
         trend = get_tz_trend(tz, trip);
 
-        if (tz->temperature >= trip_temp)
+        if (tz->temperature >= trip_temp) {
                 throttle = true;
+                trace_thermal_zone_trip(tz, trip, trip_type);
+        }
 
         dev_dbg(&tz->device, "Trip%d[type=%d,temp=%ld]:trend=%d,throttle=%d\n",
                                 trip, trip_type, trip_temp, trend, throttle);
diff --git a/drivers/thermal/thermal_core.c b/drivers/thermal/thermal_core.c
index 1e23f4f8d2c2..9bf10aa6069b 100644
--- a/drivers/thermal/thermal_core.c
+++ b/drivers/thermal/thermal_core.c
@@ -38,6 +38,9 @@
 #include <net/netlink.h>
 #include <net/genetlink.h>
 
+#define CREATE_TRACE_POINTS
+#include <trace/events/thermal.h>
+
 #include "thermal_core.h"
 #include "thermal_hwmon.h"
 
@@ -368,6 +371,8 @@ static void handle_critical_trips(struct thermal_zone_device *tz,
         if (tz->temperature < trip_temp)
                 return;
 
+        trace_thermal_zone_trip(tz, trip, trip_type);
+
         if (tz->ops->notify)
                 tz->ops->notify(tz, trip, trip_type);
 
@@ -463,6 +468,7 @@ static void update_temperature(struct thermal_zone_device *tz)
         tz->temperature = temp;
         mutex_unlock(&tz->lock);
 
+        trace_thermal_temperature(tz);
         dev_dbg(&tz->device, "last_temperature=%d, current_temperature=%d\n",
                                 tz->last_temperature, tz->temperature);
 }
@@ -1287,6 +1293,7 @@ void thermal_cdev_update(struct thermal_cooling_device *cdev)
         mutex_unlock(&cdev->lock);
         cdev->ops->set_cur_state(cdev, target);
         cdev->updated = true;
+        trace_cdev_update(cdev, target);
         dev_dbg(&cdev->device, "set to state %lu\n", target);
 }
 EXPORT_SYMBOL(thermal_cdev_update);
@@ -1790,6 +1797,10 @@ static int __init thermal_register_governors(void)
         if (result)
                 return result;
 
+        result = thermal_gov_bang_bang_register();
+        if (result)
+                return result;
+
         return thermal_gov_user_space_register();
 }
 
@@ -1797,6 +1808,7 @@ static void thermal_unregister_governors(void)
 {
         thermal_gov_step_wise_unregister();
         thermal_gov_fair_share_unregister();
+        thermal_gov_bang_bang_unregister();
         thermal_gov_user_space_unregister();
 }
 
diff --git a/drivers/thermal/thermal_core.h b/drivers/thermal/thermal_core.h
index 3db339fb636f..d15d243de27a 100644
--- a/drivers/thermal/thermal_core.h
+++ b/drivers/thermal/thermal_core.h
@@ -69,6 +69,14 @@ static inline int thermal_gov_fair_share_register(void) { return 0; }
 static inline void thermal_gov_fair_share_unregister(void) {}
 #endif /* CONFIG_THERMAL_GOV_FAIR_SHARE */
 
+#ifdef CONFIG_THERMAL_GOV_BANG_BANG
+int thermal_gov_bang_bang_register(void);
+void thermal_gov_bang_bang_unregister(void);
+#else
+static inline int thermal_gov_bang_bang_register(void) { return 0; }
+static inline void thermal_gov_bang_bang_unregister(void) {}
+#endif /* CONFIG_THERMAL_GOV_BANG_BANG */
+
 #ifdef CONFIG_THERMAL_GOV_USER_SPACE
 int thermal_gov_user_space_register(void);
 void thermal_gov_user_space_unregister(void);
diff --git a/drivers/uio/uio.c b/drivers/uio/uio.c
index a673e5b6a2e0..60fa6278fbce 100644
--- a/drivers/uio/uio.c
+++ b/drivers/uio/uio.c
@@ -28,18 +28,6 @@
 
 #define UIO_MAX_DEVICES         (1U << MINORBITS)
 
-struct uio_device {
-        struct module           *owner;
-        struct device           *dev;
-        int                     minor;
-        atomic_t                event;
-        struct fasync_struct    *async_queue;
-        wait_queue_head_t       wait;
-        struct uio_info         *info;
-        struct kobject          *map_dir;
-        struct kobject          *portio_dir;
-};
-
 static int uio_major;
 static struct cdev *uio_cdev;
 static DEFINE_IDR(uio_idr);
diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig
index e3d5bf0a5021..d0107d424ee4 100644
--- a/drivers/watchdog/Kconfig
+++ b/drivers/watchdog/Kconfig
@@ -87,6 +87,15 @@ config DA9055_WATCHDOG
           This driver can also be built as a module.  If so, the module
           will be called da9055_wdt.
 
+config DA9063_WATCHDOG
+        tristate "Dialog DA9063 Watchdog"
+        depends on MFD_DA9063
+        select WATCHDOG_CORE
+        help
+          Support for the watchdog in the DA9063 PMIC.
+
+          This driver can be built as a module. The module name is da9063_wdt.
+
 config GPIO_WATCHDOG
         tristate "Watchdog device controlled through GPIO-line"
         depends on OF_GPIO
@@ -123,6 +132,7 @@ config WM8350_WATCHDOG
 
 config XILINX_WATCHDOG
         tristate "Xilinx Watchdog timer"
+        depends on HAS_IOMEM
         select WATCHDOG_CORE
         help
           Watchdog driver for the xps_timebase_wdt ip core.
@@ -157,6 +167,14 @@ config AT91SAM9X_WATCHDOG
           Watchdog timer embedded into AT91SAM9X and AT91CAP9 chips. This will
           reboot your system when the timeout is reached.
 
+config CADENCE_WATCHDOG
+        tristate "Cadence Watchdog Timer"
+        depends on ARM
+        select WATCHDOG_CORE
+        help
+          Say Y here if you want to include support for the watchdog
+          timer in the Xilinx Zynq.
+
 config 21285_WATCHDOG
         tristate "DC21285 watchdog"
         depends on FOOTBRIDGE
@@ -319,6 +337,17 @@ config ORION_WATCHDOG
           To compile this driver as a module, choose M here: the
           module will be called orion_wdt.
 
+config RN5T618_WATCHDOG
+        tristate "Ricoh RN5T618 watchdog"
+        depends on MFD_RN5T618
+        select WATCHDOG_CORE
+        help
+          If you say yes here you get support for watchdog on the Ricoh
+          RN5T618 PMIC.
+
+          This driver can also be built as a module.  If so, the module
+          will be called rn5t618_wdt.
+
 config SUNXI_WATCHDOG
         tristate "Allwinner SoCs watchdog support"
         depends on ARCH_SUNXI
@@ -444,7 +473,7 @@ config SIRFSOC_WATCHDOG
 
 config TEGRA_WATCHDOG
         tristate "Tegra watchdog"
-        depends on ARCH_TEGRA || COMPILE_TEST
+        depends on (ARCH_TEGRA || COMPILE_TEST) && HAS_IOMEM
         select WATCHDOG_CORE
         help
           Say Y here to include support for the watchdog timer
@@ -453,6 +482,29 @@ config TEGRA_WATCHDOG
           To compile this driver as a module, choose M here: the
           module will be called tegra_wdt.
 
+config QCOM_WDT
+        tristate "QCOM watchdog"
+        depends on HAS_IOMEM
+        depends on ARCH_QCOM
+        select WATCHDOG_CORE
+        help
+          Say Y here to include Watchdog timer support for the watchdog found
+          on QCOM chipsets.  Currently supported targets are the MSM8960,
+          APQ8064, and IPQ8064.
+
+          To compile this driver as a module, choose M here: the
+          module will be called qcom_wdt.
+
+config MESON_WATCHDOG
+        tristate "Amlogic Meson SoCs watchdog support"
+        depends on ARCH_MESON
+        select WATCHDOG_CORE
+        help
+          Say Y here to include support for the watchdog timer
+          in Amlogic Meson SoCs.
+          To compile this driver as a module, choose M here: the
+          module will be called meson_wdt.
+
 # AVR32 Architecture
 
 config AT32AP700X_WDT
diff --git a/drivers/watchdog/Makefile b/drivers/watchdog/Makefile
index de1701470c14..c569ec8f8a76 100644
--- a/drivers/watchdog/Makefile
+++ b/drivers/watchdog/Makefile
@@ -32,6 +32,7 @@ obj-$(CONFIG_USBPCWATCHDOG) += pcwd_usb.o
 obj-$(CONFIG_ARM_SP805_WATCHDOG) += sp805_wdt.o
 obj-$(CONFIG_AT91RM9200_WATCHDOG) += at91rm9200_wdt.o
 obj-$(CONFIG_AT91SAM9X_WATCHDOG) += at91sam9_wdt.o
+obj-$(CONFIG_CADENCE_WATCHDOG) += cadence_wdt.o
 obj-$(CONFIG_OMAP_WATCHDOG) += omap_wdt.o
 obj-$(CONFIG_TWL4030_WATCHDOG) += twl4030_wdt.o
 obj-$(CONFIG_21285_WATCHDOG) += wdt285.o
@@ -47,6 +48,7 @@ obj-$(CONFIG_IOP_WATCHDOG) += iop_wdt.o
 obj-$(CONFIG_DAVINCI_WATCHDOG) += davinci_wdt.o
 obj-$(CONFIG_ORION_WATCHDOG) += orion_wdt.o
 obj-$(CONFIG_SUNXI_WATCHDOG) += sunxi_wdt.o
+obj-$(CONFIG_RN5T618_WATCHDOG) += rn5t618_wdt.o
 obj-$(CONFIG_COH901327_WATCHDOG) += coh901327_wdt.o
 obj-$(CONFIG_STMP3XXX_RTC_WATCHDOG) += stmp3xxx_rtc_wdt.o
 obj-$(CONFIG_NUC900_WATCHDOG) += nuc900_wdt.o
@@ -57,8 +59,10 @@ obj-$(CONFIG_RETU_WATCHDOG) += retu_wdt.o
 obj-$(CONFIG_BCM2835_WDT) += bcm2835_wdt.o
 obj-$(CONFIG_MOXART_WDT) += moxart_wdt.o
 obj-$(CONFIG_SIRFSOC_WATCHDOG) += sirfsoc_wdt.o
+obj-$(CONFIG_QCOM_WDT) += qcom-wdt.o
 obj-$(CONFIG_BCM_KONA_WDT) += bcm_kona_wdt.o
 obj-$(CONFIG_TEGRA_WATCHDOG) += tegra_wdt.o
+obj-$(CONFIG_MESON_WATCHDOG) += meson_wdt.o
 
 # AVR32 Architecture
 obj-$(CONFIG_AT32AP700X_WDT) += at32ap700x_wdt.o
@@ -173,6 +177,7 @@ obj-$(CONFIG_XEN_WDT) += xen_wdt.o
 # Architecture Independent
 obj-$(CONFIG_DA9052_WATCHDOG) += da9052_wdt.o
 obj-$(CONFIG_DA9055_WATCHDOG) += da9055_wdt.o
+obj-$(CONFIG_DA9063_WATCHDOG) += da9063_wdt.o
 obj-$(CONFIG_GPIO_WATCHDOG)     += gpio_wdt.o
 obj-$(CONFIG_WM831X_WATCHDOG) += wm831x_wdt.o
 obj-$(CONFIG_WM8350_WATCHDOG) += wm8350_wdt.o
diff --git a/drivers/watchdog/booke_wdt.c b/drivers/watchdog/booke_wdt.c
index 08a785398eac..e96b09b135c8 100644
--- a/drivers/watchdog/booke_wdt.c
+++ b/drivers/watchdog/booke_wdt.c
@@ -30,8 +30,6 @@
  * occur, and the final time the board will reset.
  */
 
-u32 booke_wdt_enabled;
-u32 booke_wdt_period = CONFIG_BOOKE_WDT_DEFAULT_TIMEOUT;
 
 #ifdef  CONFIG_PPC_FSL_BOOK3E
 #define WDTP(x)         ((((x)&0x3)<<30)|(((x)&0x3c)<<15))
@@ -41,27 +39,10 @@ u32 booke_wdt_period = CONFIG_BOOKE_WDT_DEFAULT_TIMEOUT;
 #define WDTP_MASK       (TCR_WP_MASK)
 #endif
 
-/* Checks wdt=x and wdt_period=xx command-line option */
-notrace int __init early_parse_wdt(char *p)
-{
-        if (p && strncmp(p, "0", 1) != 0)
-                booke_wdt_enabled = 1;
-
-        return 0;
-}
-early_param("wdt", early_parse_wdt);
-
-int __init early_parse_wdt_period(char *p)
-{
-        unsigned long ret;
-        if (p) {
-                if (!kstrtol(p, 0, &ret))
-                        booke_wdt_period = ret;
-        }
-
-        return 0;
-}
-early_param("wdt_period", early_parse_wdt_period);
+static bool booke_wdt_enabled;
+module_param(booke_wdt_enabled, bool, 0);
+static int  booke_wdt_period = CONFIG_BOOKE_WDT_DEFAULT_TIMEOUT;
+module_param(booke_wdt_period, int, 0);
 
 #ifdef CONFIG_PPC_FSL_BOOK3E
 
@@ -259,5 +240,6 @@ static int __init booke_wdt_init(void)
 module_init(booke_wdt_init);
 module_exit(booke_wdt_exit);
 
+MODULE_ALIAS("booke_wdt");
 MODULE_DESCRIPTION("PowerPC Book-E watchdog driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/watchdog/cadence_wdt.c b/drivers/watchdog/cadence_wdt.c
new file mode 100644
index 000000000000..5927c0a98a74
--- /dev/null
+++ b/drivers/watchdog/cadence_wdt.c
@@ -0,0 +1,516 @@
+/*
+ * Cadence WDT driver - Used by Xilinx Zynq
+ *
+ * Copyright (C) 2010 - 2014 Xilinx, Inc.
+ *
+ * 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.
+ */
+
+#include <linux/clk.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <linux/reboot.h>
+#include <linux/watchdog.h>
+
+#define CDNS_WDT_DEFAULT_TIMEOUT        10
+/* Supports 1 - 516 sec */
+#define CDNS_WDT_MIN_TIMEOUT    1
+#define CDNS_WDT_MAX_TIMEOUT    516
+
+/* Restart key */
+#define CDNS_WDT_RESTART_KEY 0x00001999
+
+/* Counter register access key */
+#define CDNS_WDT_REGISTER_ACCESS_KEY 0x00920000
+
+/* Counter value divisor */
+#define CDNS_WDT_COUNTER_VALUE_DIVISOR 0x1000
+
+/* Clock prescaler value and selection */
+#define CDNS_WDT_PRESCALE_64    64
+#define CDNS_WDT_PRESCALE_512   512
+#define CDNS_WDT_PRESCALE_4096  4096
+#define CDNS_WDT_PRESCALE_SELECT_64     1
+#define CDNS_WDT_PRESCALE_SELECT_512    2
+#define CDNS_WDT_PRESCALE_SELECT_4096   3
+
+/* Input clock frequency */
+#define CDNS_WDT_CLK_10MHZ      10000000
+#define CDNS_WDT_CLK_75MHZ      75000000
+
+/* Counter maximum value */
+#define CDNS_WDT_COUNTER_MAX 0xFFF
+
+static int wdt_timeout = CDNS_WDT_DEFAULT_TIMEOUT;
+static int nowayout = WATCHDOG_NOWAYOUT;
+
+module_param(wdt_timeout, int, 0);
+MODULE_PARM_DESC(wdt_timeout,
+                 "Watchdog time in seconds. (default="
+                 __MODULE_STRING(CDNS_WDT_DEFAULT_TIMEOUT) ")");
+
+module_param(nowayout, int, 0);
+MODULE_PARM_DESC(nowayout,
+                 "Watchdog cannot be stopped once started (default="
+                 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+
+/**
+ * struct cdns_wdt - Watchdog device structure
+ * @regs: baseaddress of device
+ * @rst: reset flag
+ * @clk: struct clk * of a clock source
+ * @prescaler: for saving prescaler value
+ * @ctrl_clksel: counter clock prescaler selection
+ * @io_lock: spinlock for IO register access
+ * @cdns_wdt_device: watchdog device structure
+ * @cdns_wdt_notifier: notifier structure
+ *
+ * Structure containing parameters specific to cadence watchdog.
+ */
+struct cdns_wdt {
+        void __iomem            *regs;
+        bool                    rst;
+        struct clk              *clk;
+        u32                     prescaler;
+        u32                     ctrl_clksel;
+        spinlock_t              io_lock;
+        struct watchdog_device  cdns_wdt_device;
+        struct notifier_block   cdns_wdt_notifier;
+};
+
+/* Write access to Registers */
+static inline void cdns_wdt_writereg(struct cdns_wdt *wdt, u32 offset, u32 val)
+{
+        writel_relaxed(val, wdt->regs + offset);
+}
+
+/*************************Register Map**************************************/
+
+/* Register Offsets for the WDT */
+#define CDNS_WDT_ZMR_OFFSET     0x0     /* Zero Mode Register */
+#define CDNS_WDT_CCR_OFFSET     0x4     /* Counter Control Register */
+#define CDNS_WDT_RESTART_OFFSET 0x8     /* Restart Register */
+#define CDNS_WDT_SR_OFFSET      0xC     /* Status Register */
+
+/*
+ * Zero Mode Register - This register controls how the time out is indicated
+ * and also contains the access code to allow writes to the register (0xABC).
+ */
+#define CDNS_WDT_ZMR_WDEN_MASK  0x00000001 /* Enable the WDT */
+#define CDNS_WDT_ZMR_RSTEN_MASK 0x00000002 /* Enable the reset output */
+#define CDNS_WDT_ZMR_IRQEN_MASK 0x00000004 /* Enable IRQ output */
+#define CDNS_WDT_ZMR_RSTLEN_16  0x00000030 /* Reset pulse of 16 pclk cycles */
+#define CDNS_WDT_ZMR_ZKEY_VAL   0x00ABC000 /* Access key, 0xABC << 12 */
+/*
+ * Counter Control register - This register controls how fast the timer runs
+ * and the reset value and also contains the access code to allow writes to
+ * the register.
+ */
+#define CDNS_WDT_CCR_CRV_MASK   0x00003FFC /* Counter reset value */
+
+/**
+ * cdns_wdt_stop - Stop the watchdog.
+ *
+ * @wdd: watchdog device
+ *
+ * Read the contents of the ZMR register, clear the WDEN bit
+ * in the register and set the access key for successful write.
+ *
+ * Return: always 0
+ */
+static int cdns_wdt_stop(struct watchdog_device *wdd)
+{
+        struct cdns_wdt *wdt = watchdog_get_drvdata(wdd);
+
+        spin_lock(&wdt->io_lock);
+        cdns_wdt_writereg(wdt, CDNS_WDT_ZMR_OFFSET,
+                          CDNS_WDT_ZMR_ZKEY_VAL & (~CDNS_WDT_ZMR_WDEN_MASK));
+        spin_unlock(&wdt->io_lock);
+
+        return 0;
+}
+
+/**
+ * cdns_wdt_reload - Reload the watchdog timer (i.e. pat the watchdog).
+ *
+ * @wdd: watchdog device
+ *
+ * Write the restart key value (0x00001999) to the restart register.
+ *
+ * Return: always 0
+ */
+static int cdns_wdt_reload(struct watchdog_device *wdd)
+{
+        struct cdns_wdt *wdt = watchdog_get_drvdata(wdd);
+
+        spin_lock(&wdt->io_lock);
+        cdns_wdt_writereg(wdt, CDNS_WDT_RESTART_OFFSET,
+                          CDNS_WDT_RESTART_KEY);
+        spin_unlock(&wdt->io_lock);
+
+        return 0;
+}
+
+/**
+ * cdns_wdt_start - Enable and start the watchdog.
+ *
+ * @wdd: watchdog device
+ *
+ * The counter value is calculated according to the formula:
+ *              calculated count = (timeout * clock) / prescaler + 1.
+ * The calculated count is divided by 0x1000 to obtain the field value
+ * to write to counter control register.
+ * Clears the contents of prescaler and counter reset value. Sets the
+ * prescaler to 4096 and the calculated count and access key
+ * to write to CCR Register.
+ * Sets the WDT (WDEN bit) and either the Reset signal(RSTEN bit)
+ * or Interrupt signal(IRQEN) with a specified cycles and the access
+ * key to write to ZMR Register.
+ *
+ * Return: always 0
+ */
+static int cdns_wdt_start(struct watchdog_device *wdd)
+{
+        struct cdns_wdt *wdt = watchdog_get_drvdata(wdd);
+        unsigned int data = 0;
+        unsigned short count;
+        unsigned long clock_f = clk_get_rate(wdt->clk);
+
+        /*
+         * Counter value divisor to obtain the value of
+         * counter reset to be written to control register.
+         */
+        count = (wdd->timeout * (clock_f / wdt->prescaler)) /
+                 CDNS_WDT_COUNTER_VALUE_DIVISOR + 1;
+
+        if (count > CDNS_WDT_COUNTER_MAX)
+                count = CDNS_WDT_COUNTER_MAX;
+
+        spin_lock(&wdt->io_lock);
+        cdns_wdt_writereg(wdt, CDNS_WDT_ZMR_OFFSET,
+                          CDNS_WDT_ZMR_ZKEY_VAL);
+
+        count = (count << 2) & CDNS_WDT_CCR_CRV_MASK;
+
+        /* Write counter access key first to be able write to register */
+        data = count | CDNS_WDT_REGISTER_ACCESS_KEY | wdt->ctrl_clksel;
+        cdns_wdt_writereg(wdt, CDNS_WDT_CCR_OFFSET, data);
+        data = CDNS_WDT_ZMR_WDEN_MASK | CDNS_WDT_ZMR_RSTLEN_16 |
+               CDNS_WDT_ZMR_ZKEY_VAL;
+
+        /* Reset on timeout if specified in device tree. */
+        if (wdt->rst) {
+                data |= CDNS_WDT_ZMR_RSTEN_MASK;
+                data &= ~CDNS_WDT_ZMR_IRQEN_MASK;
+        } else {
+                data &= ~CDNS_WDT_ZMR_RSTEN_MASK;
+                data |= CDNS_WDT_ZMR_IRQEN_MASK;
+        }
+        cdns_wdt_writereg(wdt, CDNS_WDT_ZMR_OFFSET, data);
+        cdns_wdt_writereg(wdt, CDNS_WDT_RESTART_OFFSET,
+                          CDNS_WDT_RESTART_KEY);
+        spin_unlock(&wdt->io_lock);
+
+        return 0;
+}
+
+/**
+ * cdns_wdt_settimeout - Set a new timeout value for the watchdog device.
+ *
+ * @wdd: watchdog device
+ * @new_time: new timeout value that needs to be set
+ * Return: 0 on success
+ *
+ * Update the watchdog_device timeout with new value which is used when
+ * cdns_wdt_start is called.
+ */
+static int cdns_wdt_settimeout(struct watchdog_device *wdd,
+                               unsigned int new_time)
+{
+        wdd->timeout = new_time;
+
+        return cdns_wdt_start(wdd);
+}
+
+/**
+ * cdns_wdt_irq_handler - Notifies of watchdog timeout.
+ *
+ * @irq: interrupt number
+ * @dev_id: pointer to a platform device structure
+ * Return: IRQ_HANDLED
+ *
+ * The handler is invoked when the watchdog times out and a
+ * reset on timeout has not been enabled.
+ */
+static irqreturn_t cdns_wdt_irq_handler(int irq, void *dev_id)
+{
+        struct platform_device *pdev = dev_id;
+
+        dev_info(&pdev->dev,
+                 "Watchdog timed out. Internal reset not enabled\n");
+
+        return IRQ_HANDLED;
+}
+
+/*
+ * Info structure used to indicate the features supported by the device
+ * to the upper layers. This is defined in watchdog.h header file.
+ */
+static struct watchdog_info cdns_wdt_info = {
+        .identity       = "cdns_wdt watchdog",
+        .options        = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING |
+                          WDIOF_MAGICCLOSE,
+};
+
+/* Watchdog Core Ops */
+static struct watchdog_ops cdns_wdt_ops = {
+        .owner = THIS_MODULE,
+        .start = cdns_wdt_start,
+        .stop = cdns_wdt_stop,
+        .ping = cdns_wdt_reload,
+        .set_timeout = cdns_wdt_settimeout,
+};
+
+/**
+ * cdns_wdt_notify_sys - Notifier for reboot or shutdown.
+ *
+ * @this: handle to notifier block
+ * @code: turn off indicator
+ * @unused: unused
+ * Return: NOTIFY_DONE
+ *
+ * This notifier is invoked whenever the system reboot or shutdown occur
+ * because we need to disable the WDT before system goes down as WDT might
+ * reset on the next boot.
+ */
+static int cdns_wdt_notify_sys(struct notifier_block *this, unsigned long code,
+                               void *unused)
+{
+        struct cdns_wdt *wdt = container_of(this, struct cdns_wdt,
+                                            cdns_wdt_notifier);
+        if (code == SYS_DOWN || code == SYS_HALT)
+                cdns_wdt_stop(&wdt->cdns_wdt_device);
+
+        return NOTIFY_DONE;
+}
+
+/************************Platform Operations*****************************/
+/**
+ * cdns_wdt_probe - Probe call for the device.
+ *
+ * @pdev: handle to the platform device structure.
+ * Return: 0 on success, negative error otherwise.
+ *
+ * It does all the memory allocation and registration for the device.
+ */
+static int cdns_wdt_probe(struct platform_device *pdev)
+{
+        struct resource *res;
+        int ret, irq;
+        unsigned long clock_f;
+        struct cdns_wdt *wdt;
+        struct watchdog_device *cdns_wdt_device;
+
+        wdt = devm_kzalloc(&pdev->dev, sizeof(*wdt), GFP_KERNEL);
+        if (!wdt)
+                return -ENOMEM;
+
+        cdns_wdt_device = &wdt->cdns_wdt_device;
+        cdns_wdt_device->info = &cdns_wdt_info;
+        cdns_wdt_device->ops = &cdns_wdt_ops;
+        cdns_wdt_device->timeout = CDNS_WDT_DEFAULT_TIMEOUT;
+        cdns_wdt_device->min_timeout = CDNS_WDT_MIN_TIMEOUT;
+        cdns_wdt_device->max_timeout = CDNS_WDT_MAX_TIMEOUT;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        wdt->regs = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(wdt->regs))
+                return PTR_ERR(wdt->regs);
+
+        /* Register the interrupt */
+        wdt->rst = of_property_read_bool(pdev->dev.of_node, "reset-on-timeout");
+        irq = platform_get_irq(pdev, 0);
+        if (!wdt->rst && irq >= 0) {
+                ret = devm_request_irq(&pdev->dev, irq, cdns_wdt_irq_handler, 0,
+                                       pdev->name, pdev);
+                if (ret) {
+                        dev_err(&pdev->dev,
+                                "cannot register interrupt handler err=%d\n",
+                                ret);
+                        return ret;
+                }
+        }
+
+        /* Initialize the members of cdns_wdt structure */
+        cdns_wdt_device->parent = &pdev->dev;
+
+        ret = watchdog_init_timeout(cdns_wdt_device, wdt_timeout, &pdev->dev);
+        if (ret) {
+                dev_err(&pdev->dev, "unable to set timeout value\n");
+                return ret;
+        }
+
+        watchdog_set_nowayout(cdns_wdt_device, nowayout);
+        watchdog_set_drvdata(cdns_wdt_device, wdt);
+
+        wdt->clk = devm_clk_get(&pdev->dev, NULL);
+        if (IS_ERR(wdt->clk)) {
+                dev_err(&pdev->dev, "input clock not found\n");
+                ret = PTR_ERR(wdt->clk);
+                return ret;
+        }
+
+        ret = clk_prepare_enable(wdt->clk);
+        if (ret) {
+                dev_err(&pdev->dev, "unable to enable clock\n");
+                return ret;
+        }
+
+        clock_f = clk_get_rate(wdt->clk);
+        if (clock_f <= CDNS_WDT_CLK_75MHZ) {
+                wdt->prescaler = CDNS_WDT_PRESCALE_512;
+                wdt->ctrl_clksel = CDNS_WDT_PRESCALE_SELECT_512;
+        } else {
+                wdt->prescaler = CDNS_WDT_PRESCALE_4096;
+                wdt->ctrl_clksel = CDNS_WDT_PRESCALE_SELECT_4096;
+        }
+
+        spin_lock_init(&wdt->io_lock);
+
+        wdt->cdns_wdt_notifier.notifier_call = &cdns_wdt_notify_sys;
+        ret = register_reboot_notifier(&wdt->cdns_wdt_notifier);
+        if (ret != 0) {
+                dev_err(&pdev->dev, "cannot register reboot notifier err=%d)\n",
+                        ret);
+                goto err_clk_disable;
+        }
+
+        ret = watchdog_register_device(cdns_wdt_device);
+        if (ret) {
+                dev_err(&pdev->dev, "Failed to register wdt device\n");
+                goto err_clk_disable;
+        }
+        platform_set_drvdata(pdev, wdt);
+
+        dev_dbg(&pdev->dev, "Xilinx Watchdog Timer at %p with timeout %ds%s\n",
+                 wdt->regs, cdns_wdt_device->timeout,
+                 nowayout ? ", nowayout" : "");
+
+        return 0;
+
+err_clk_disable:
+        clk_disable_unprepare(wdt->clk);
+
+        return ret;
+}
+
+/**
+ * cdns_wdt_remove - Probe call for the device.
+ *
+ * @pdev: handle to the platform device structure.
+ * Return: 0 on success, otherwise negative error.
+ *
+ * Unregister the device after releasing the resources.
+ */
+static int cdns_wdt_remove(struct platform_device *pdev)
+{
+        struct cdns_wdt *wdt = platform_get_drvdata(pdev);
+
+        cdns_wdt_stop(&wdt->cdns_wdt_device);
+        watchdog_unregister_device(&wdt->cdns_wdt_device);
+        unregister_reboot_notifier(&wdt->cdns_wdt_notifier);
+        clk_disable_unprepare(wdt->clk);
+
+        return 0;
+}
+
+/**
+ * cdns_wdt_shutdown - Stop the device.
+ *
+ * @pdev: handle to the platform structure.
+ *
+ */
+static void cdns_wdt_shutdown(struct platform_device *pdev)
+{
+        struct cdns_wdt *wdt = platform_get_drvdata(pdev);
+
+        cdns_wdt_stop(&wdt->cdns_wdt_device);
+        clk_disable_unprepare(wdt->clk);
+}
+
+/**
+ * cdns_wdt_suspend - Stop the device.
+ *
+ * @dev: handle to the device structure.
+ * Return: 0 always.
+ */
+static int __maybe_unused cdns_wdt_suspend(struct device *dev)
+{
+        struct platform_device *pdev = container_of(dev,
+                        struct platform_device, dev);
+        struct cdns_wdt *wdt = platform_get_drvdata(pdev);
+
+        cdns_wdt_stop(&wdt->cdns_wdt_device);
+        clk_disable_unprepare(wdt->clk);
+
+        return 0;
+}
+
+/**
+ * cdns_wdt_resume - Resume the device.
+ *
+ * @dev: handle to the device structure.
+ * Return: 0 on success, errno otherwise.
+ */
+static int __maybe_unused cdns_wdt_resume(struct device *dev)
+{
+        int ret;
+        struct platform_device *pdev = container_of(dev,
+                        struct platform_device, dev);
+        struct cdns_wdt *wdt = platform_get_drvdata(pdev);
+
+        ret = clk_prepare_enable(wdt->clk);
+        if (ret) {
+                dev_err(dev, "unable to enable clock\n");
+                return ret;
+        }
+        cdns_wdt_start(&wdt->cdns_wdt_device);
+
+        return 0;
+}
+
+static SIMPLE_DEV_PM_OPS(cdns_wdt_pm_ops, cdns_wdt_suspend, cdns_wdt_resume);
+
+static struct of_device_id cdns_wdt_of_match[] = {
+        { .compatible = "cdns,wdt-r1p2", },
+        { /* end of table */ }
+};
+MODULE_DEVICE_TABLE(of, cdns_wdt_of_match);
+
+/* Driver Structure */
+static struct platform_driver cdns_wdt_driver = {
+        .probe          = cdns_wdt_probe,
+        .remove         = cdns_wdt_remove,
+        .shutdown       = cdns_wdt_shutdown,
+        .driver         = {
+                .name   = "cdns-wdt",
+                .owner  = THIS_MODULE,
+                .of_match_table = cdns_wdt_of_match,
+                .pm     = &cdns_wdt_pm_ops,
+        },
+};
+
+module_platform_driver(cdns_wdt_driver);
+
+MODULE_AUTHOR("Xilinx, Inc.");
+MODULE_DESCRIPTION("Watchdog driver for Cadence WDT");
+MODULE_LICENSE("GPL");
diff --git a/drivers/watchdog/da9063_wdt.c b/drivers/watchdog/da9063_wdt.c
new file mode 100644
index 000000000000..2cd6b2c2dd2a
--- /dev/null
+++ b/drivers/watchdog/da9063_wdt.c
@@ -0,0 +1,191 @@
+/*
+ * Watchdog driver for DA9063 PMICs.
+ *
+ * Copyright(c) 2012 Dialog Semiconductor Ltd.
+ *
+ * Author: Mariusz Wojtasik <mariusz.wojtasik@diasemi.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.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/watchdog.h>
+#include <linux/platform_device.h>
+#include <linux/uaccess.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include <linux/mfd/da9063/registers.h>
+#include <linux/mfd/da9063/core.h>
+#include <linux/regmap.h>
+
+/*
+ * Watchdog selector to timeout in seconds.
+ *   0: WDT disabled;
+ *   others: timeout = 2048 ms * 2^(TWDSCALE-1).
+ */
+static const unsigned int wdt_timeout[] = { 0, 2, 4, 8, 16, 32, 65, 131 };
+#define DA9063_TWDSCALE_DISABLE         0
+#define DA9063_TWDSCALE_MIN             1
+#define DA9063_TWDSCALE_MAX             (ARRAY_SIZE(wdt_timeout) - 1)
+#define DA9063_WDT_MIN_TIMEOUT          wdt_timeout[DA9063_TWDSCALE_MIN]
+#define DA9063_WDT_MAX_TIMEOUT          wdt_timeout[DA9063_TWDSCALE_MAX]
+#define DA9063_WDG_TIMEOUT              wdt_timeout[3]
+
+struct da9063_watchdog {
+        struct da9063 *da9063;
+        struct watchdog_device wdtdev;
+};
+
+static unsigned int da9063_wdt_timeout_to_sel(unsigned int secs)
+{
+        unsigned int i;
+
+        for (i = DA9063_TWDSCALE_MIN; i <= DA9063_TWDSCALE_MAX; i++) {
+                if (wdt_timeout[i] >= secs)
+                        return i;
+        }
+
+        return DA9063_TWDSCALE_MAX;
+}
+
+static int _da9063_wdt_set_timeout(struct da9063 *da9063, unsigned int regval)
+{
+        return regmap_update_bits(da9063->regmap, DA9063_REG_CONTROL_D,
+                                  DA9063_TWDSCALE_MASK, regval);
+}
+
+static int da9063_wdt_start(struct watchdog_device *wdd)
+{
+        struct da9063_watchdog *wdt = watchdog_get_drvdata(wdd);
+        unsigned int selector;
+        int ret;
+
+        selector = da9063_wdt_timeout_to_sel(wdt->wdtdev.timeout);
+        ret = _da9063_wdt_set_timeout(wdt->da9063, selector);
+        if (ret)
+                dev_err(wdt->da9063->dev, "Watchdog failed to start (err = %d)\n",
+                        ret);
+
+        return ret;
+}
+
+static int da9063_wdt_stop(struct watchdog_device *wdd)
+{
+        struct da9063_watchdog *wdt = watchdog_get_drvdata(wdd);
+        int ret;
+
+        ret = regmap_update_bits(wdt->da9063->regmap, DA9063_REG_CONTROL_D,
+                                 DA9063_TWDSCALE_MASK, DA9063_TWDSCALE_DISABLE);
+        if (ret)
+                dev_alert(wdt->da9063->dev, "Watchdog failed to stop (err = %d)\n",
+                          ret);
+
+        return ret;
+}
+
+static int da9063_wdt_ping(struct watchdog_device *wdd)
+{
+        struct da9063_watchdog *wdt = watchdog_get_drvdata(wdd);
+        int ret;
+
+        ret = regmap_write(wdt->da9063->regmap, DA9063_REG_CONTROL_F,
+                           DA9063_WATCHDOG);
+        if (ret)
+                dev_alert(wdt->da9063->dev, "Failed to ping the watchdog (err = %d)\n",
+                          ret);
+
+        return ret;
+}
+
+static int da9063_wdt_set_timeout(struct watchdog_device *wdd,
+                                  unsigned int timeout)
+{
+        struct da9063_watchdog *wdt = watchdog_get_drvdata(wdd);
+        unsigned int selector;
+        int ret;
+
+        selector = da9063_wdt_timeout_to_sel(timeout);
+        ret = _da9063_wdt_set_timeout(wdt->da9063, selector);
+        if (ret)
+                dev_err(wdt->da9063->dev, "Failed to set watchdog timeout (err = %d)\n",
+                        ret);
+        else
+                wdd->timeout = wdt_timeout[selector];
+
+        return ret;
+}
+
+static const struct watchdog_info da9063_watchdog_info = {
+        .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
+        .identity = "DA9063 Watchdog",
+};
+
+static const struct watchdog_ops da9063_watchdog_ops = {
+        .owner = THIS_MODULE,
+        .start = da9063_wdt_start,
+        .stop = da9063_wdt_stop,
+        .ping = da9063_wdt_ping,
+        .set_timeout = da9063_wdt_set_timeout,
+};
+
+static int da9063_wdt_probe(struct platform_device *pdev)
+{
+        int ret;
+        struct da9063 *da9063;
+        struct da9063_watchdog *wdt;
+
+        if (!pdev->dev.parent)
+                return -EINVAL;
+
+        da9063 = dev_get_drvdata(pdev->dev.parent);
+        if (!da9063)
+                return -EINVAL;
+
+        wdt = devm_kzalloc(&pdev->dev, sizeof(*wdt), GFP_KERNEL);
+        if (!wdt)
+                return -ENOMEM;
+
+        wdt->da9063 = da9063;
+
+        wdt->wdtdev.info = &da9063_watchdog_info;
+        wdt->wdtdev.ops = &da9063_watchdog_ops;
+        wdt->wdtdev.min_timeout = DA9063_WDT_MIN_TIMEOUT;
+        wdt->wdtdev.max_timeout = DA9063_WDT_MAX_TIMEOUT;
+        wdt->wdtdev.timeout = DA9063_WDG_TIMEOUT;
+
+        wdt->wdtdev.status = WATCHDOG_NOWAYOUT_INIT_STATUS;
+
+        watchdog_set_drvdata(&wdt->wdtdev, wdt);
+        dev_set_drvdata(&pdev->dev, wdt);
+
+        ret = watchdog_register_device(&wdt->wdtdev);
+
+        return ret;
+}
+
+static int da9063_wdt_remove(struct platform_device *pdev)
+{
+        struct da9063_watchdog *wdt = dev_get_drvdata(&pdev->dev);
+
+        watchdog_unregister_device(&wdt->wdtdev);
+
+        return 0;
+}
+
+static struct platform_driver da9063_wdt_driver = {
+        .probe = da9063_wdt_probe,
+        .remove = da9063_wdt_remove,
+        .driver = {
+                .name = DA9063_DRVNAME_WATCHDOG,
+        },
+};
+module_platform_driver(da9063_wdt_driver);
+
+MODULE_AUTHOR("Mariusz Wojtasik <mariusz.wojtasik@diasemi.com>");
+MODULE_DESCRIPTION("Watchdog driver for Dialog DA9063");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:" DA9063_DRVNAME_WATCHDOG);
diff --git a/drivers/watchdog/dw_wdt.c b/drivers/watchdog/dw_wdt.c
index 9f210299de24..9e577a64ec9e 100644
--- a/drivers/watchdog/dw_wdt.c
+++ b/drivers/watchdog/dw_wdt.c
@@ -21,6 +21,7 @@
 
 #include <linux/bitops.h>
 #include <linux/clk.h>
+#include <linux/delay.h>
 #include <linux/device.h>
 #include <linux/err.h>
 #include <linux/fs.h>
@@ -29,9 +30,11 @@
 #include <linux/miscdevice.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
+#include <linux/notifier.h>
 #include <linux/of.h>
 #include <linux/pm.h>
 #include <linux/platform_device.h>
+#include <linux/reboot.h>
 #include <linux/spinlock.h>
 #include <linux/timer.h>
 #include <linux/uaccess.h>
@@ -40,6 +43,7 @@
 #define WDOG_CONTROL_REG_OFFSET             0x00
 #define WDOG_CONTROL_REG_WDT_EN_MASK        0x01
 #define WDOG_TIMEOUT_RANGE_REG_OFFSET       0x04
+#define WDOG_TIMEOUT_RANGE_TOPINIT_SHIFT    4
 #define WDOG_CURRENT_COUNT_REG_OFFSET       0x08
 #define WDOG_COUNTER_RESTART_REG_OFFSET     0x0c
 #define WDOG_COUNTER_RESTART_KICK_VALUE     0x76
@@ -62,6 +66,7 @@ static struct {
         unsigned long           next_heartbeat;
         struct timer_list       timer;
         int                     expect_close;
+        struct notifier_block   restart_handler;
 } dw_wdt;
 
 static inline int dw_wdt_is_enabled(void)
@@ -106,7 +111,8 @@ static int dw_wdt_set_top(unsigned top_s)
                 }
 
         /* Set the new value in the watchdog. */
-        writel(top_val, dw_wdt.regs + WDOG_TIMEOUT_RANGE_REG_OFFSET);
+        writel(top_val | top_val << WDOG_TIMEOUT_RANGE_TOPINIT_SHIFT,
+                dw_wdt.regs + WDOG_TIMEOUT_RANGE_REG_OFFSET);
 
         dw_wdt_set_next_heartbeat();
 
@@ -119,6 +125,26 @@ static void dw_wdt_keepalive(void)
                WDOG_COUNTER_RESTART_REG_OFFSET);
 }
 
+static int dw_wdt_restart_handle(struct notifier_block *this,
+                                unsigned long mode, void *cmd)
+{
+        u32 val;
+
+        writel(0, dw_wdt.regs + WDOG_TIMEOUT_RANGE_REG_OFFSET);
+        val = readl(dw_wdt.regs + WDOG_CONTROL_REG_OFFSET);
+        if (val & WDOG_CONTROL_REG_WDT_EN_MASK)
+                writel(WDOG_COUNTER_RESTART_KICK_VALUE, dw_wdt.regs +
+                        WDOG_COUNTER_RESTART_REG_OFFSET);
+        else
+                writel(WDOG_CONTROL_REG_WDT_EN_MASK,
+                       dw_wdt.regs + WDOG_CONTROL_REG_OFFSET);
+
+        /* wait for reset to assert... */
+        mdelay(500);
+
+        return NOTIFY_DONE;
+}
+
 static void dw_wdt_ping(unsigned long data)
 {
         if (time_before(jiffies, dw_wdt.next_heartbeat) ||
@@ -314,6 +340,12 @@ static int dw_wdt_drv_probe(struct platform_device *pdev)
         if (ret)
                 goto out_disable_clk;
 
+        dw_wdt.restart_handler.notifier_call = dw_wdt_restart_handle;
+        dw_wdt.restart_handler.priority = 128;
+        ret = register_restart_handler(&dw_wdt.restart_handler);
+        if (ret)
+                pr_warn("cannot register restart handler\n");
+
         dw_wdt_set_next_heartbeat();
         setup_timer(&dw_wdt.timer, dw_wdt_ping, 0);
         mod_timer(&dw_wdt.timer, jiffies + WDT_TIMEOUT);
@@ -328,6 +360,8 @@ out_disable_clk:
 
 static int dw_wdt_drv_remove(struct platform_device *pdev)
 {
+        unregister_restart_handler(&dw_wdt.restart_handler);
+
         misc_deregister(&dw_wdt_miscdev);
 
         clk_disable_unprepare(dw_wdt.clk);
diff --git a/drivers/watchdog/imx2_wdt.c b/drivers/watchdog/imx2_wdt.c
index 68c3d379ffa8..7e12f88bb4a6 100644
--- a/drivers/watchdog/imx2_wdt.c
+++ b/drivers/watchdog/imx2_wdt.c
@@ -22,14 +22,17 @@
  */
 
 #include <linux/clk.h>
+#include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/io.h>
 #include <linux/jiffies.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
+#include <linux/notifier.h>
 #include <linux/of_address.h>
 #include <linux/platform_device.h>
+#include <linux/reboot.h>
 #include <linux/regmap.h>
 #include <linux/timer.h>
 #include <linux/watchdog.h>
@@ -59,6 +62,7 @@ struct imx2_wdt_device {
         struct regmap *regmap;
         struct timer_list timer;        /* Pings the watchdog when closed */
         struct watchdog_device wdog;
+        struct notifier_block restart_handler;
 };
 
 static bool nowayout = WATCHDOG_NOWAYOUT;
@@ -77,6 +81,31 @@ static const struct watchdog_info imx2_wdt_info = {
         .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE,
 };
 
+static int imx2_restart_handler(struct notifier_block *this, unsigned long mode,
+                                void *cmd)
+{
+        unsigned int wcr_enable = IMX2_WDT_WCR_WDE;
+        struct imx2_wdt_device *wdev = container_of(this,
+                                                    struct imx2_wdt_device,
+                                                    restart_handler);
+        /* Assert SRS signal */
+        regmap_write(wdev->regmap, 0, wcr_enable);
+        /*
+         * Due to imx6q errata ERR004346 (WDOG: WDOG SRS bit requires to be
+         * written twice), we add another two writes to ensure there must be at
+         * least two writes happen in the same one 32kHz clock period.  We save
+         * the target check here, since the writes shouldn't be a huge burden
+         * for other platforms.
+         */
+        regmap_write(wdev->regmap, 0, wcr_enable);
+        regmap_write(wdev->regmap, 0, wcr_enable);
+
+        /* wait for reset to assert... */
+        mdelay(500);
+
+        return NOTIFY_DONE;
+}
+
 static inline void imx2_wdt_setup(struct watchdog_device *wdog)
 {
         struct imx2_wdt_device *wdev = watchdog_get_drvdata(wdog);
@@ -191,12 +220,10 @@ static struct regmap_config imx2_wdt_regmap_config = {
 
 static int __init imx2_wdt_probe(struct platform_device *pdev)
 {
-        struct device_node *np = pdev->dev.of_node;
         struct imx2_wdt_device *wdev;
         struct watchdog_device *wdog;
         struct resource *res;
         void __iomem *base;
-        bool big_endian;
         int ret;
         u32 val;
 
@@ -204,10 +231,6 @@ static int __init imx2_wdt_probe(struct platform_device *pdev)
         if (!wdev)
                 return -ENOMEM;
 
-        big_endian = of_property_read_bool(np, "big-endian");
-        if (big_endian)
-                imx2_wdt_regmap_config.val_format_endian = REGMAP_ENDIAN_BIG;
-
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         base = devm_ioremap_resource(&pdev->dev, res);
         if (IS_ERR(base))
@@ -257,6 +280,12 @@ static int __init imx2_wdt_probe(struct platform_device *pdev)
                 return ret;
         }
 
+        wdev->restart_handler.notifier_call = imx2_restart_handler;
+        wdev->restart_handler.priority = 128;
+        ret = register_restart_handler(&wdev->restart_handler);
+        if (ret)
+                dev_err(&pdev->dev, "cannot register restart handler\n");
+
         dev_info(&pdev->dev, "timeout %d sec (nowayout=%d)\n",
                  wdog->timeout, nowayout);
 
@@ -268,6 +297,8 @@ static int __exit imx2_wdt_remove(struct platform_device *pdev)
         struct watchdog_device *wdog = platform_get_drvdata(pdev);
         struct imx2_wdt_device *wdev = watchdog_get_drvdata(wdog);
 
+        unregister_restart_handler(&wdev->restart_handler);
+
         watchdog_unregister_device(wdog);
 
         if (imx2_wdt_is_running(wdev)) {
diff --git a/drivers/watchdog/meson_wdt.c b/drivers/watchdog/meson_wdt.c
new file mode 100644
index 000000000000..ef6a298e8c45
--- /dev/null
+++ b/drivers/watchdog/meson_wdt.c
@@ -0,0 +1,236 @@
+/*
+ *      Meson Watchdog Driver
+ *
+ *      Copyright (c) 2014 Carlo Caione
+ *
+ *      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.
+ */
+
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/err.h>
+#include <linux/init.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/notifier.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <linux/reboot.h>
+#include <linux/types.h>
+#include <linux/watchdog.h>
+
+#define DRV_NAME                "meson_wdt"
+
+#define MESON_WDT_TC            0x00
+#define MESON_WDT_TC_EN         BIT(22)
+#define MESON_WDT_TC_TM_MASK    0x3fffff
+#define MESON_WDT_DC_RESET      (3 << 24)
+
+#define MESON_WDT_RESET         0x04
+
+#define MESON_WDT_TIMEOUT       30
+#define MESON_WDT_MIN_TIMEOUT   1
+#define MESON_WDT_MAX_TIMEOUT   (MESON_WDT_TC_TM_MASK / 100000)
+
+#define MESON_SEC_TO_TC(s)      ((s) * 100000)
+
+static bool nowayout = WATCHDOG_NOWAYOUT;
+static unsigned int timeout = MESON_WDT_TIMEOUT;
+
+struct meson_wdt_dev {
+        struct watchdog_device wdt_dev;
+        void __iomem *wdt_base;
+        struct notifier_block restart_handler;
+};
+
+static int meson_restart_handle(struct notifier_block *this, unsigned long mode,
+                                void *cmd)
+{
+        u32 tc_reboot = MESON_WDT_DC_RESET | MESON_WDT_TC_EN;
+        struct meson_wdt_dev *meson_wdt = container_of(this,
+                                                       struct meson_wdt_dev,
+                                                       restart_handler);
+
+        while (1) {
+                writel(tc_reboot, meson_wdt->wdt_base + MESON_WDT_TC);
+                mdelay(5);
+        }
+
+        return NOTIFY_DONE;
+}
+
+static int meson_wdt_ping(struct watchdog_device *wdt_dev)
+{
+        struct meson_wdt_dev *meson_wdt = watchdog_get_drvdata(wdt_dev);
+
+        writel(0, meson_wdt->wdt_base + MESON_WDT_RESET);
+
+        return 0;
+}
+
+static void meson_wdt_change_timeout(struct watchdog_device *wdt_dev,
+                                     unsigned int timeout)
+{
+        struct meson_wdt_dev *meson_wdt = watchdog_get_drvdata(wdt_dev);
+        u32 reg;
+
+        reg = readl(meson_wdt->wdt_base + MESON_WDT_TC);
+        reg &= ~MESON_WDT_TC_TM_MASK;
+        reg |= MESON_SEC_TO_TC(timeout);
+        writel(reg, meson_wdt->wdt_base + MESON_WDT_TC);
+}
+
+static int meson_wdt_set_timeout(struct watchdog_device *wdt_dev,
+                                 unsigned int timeout)
+{
+        wdt_dev->timeout = timeout;
+
+        meson_wdt_change_timeout(wdt_dev, timeout);
+        meson_wdt_ping(wdt_dev);
+
+        return 0;
+}
+
+static int meson_wdt_stop(struct watchdog_device *wdt_dev)
+{
+        struct meson_wdt_dev *meson_wdt = watchdog_get_drvdata(wdt_dev);
+        u32 reg;
+
+        reg = readl(meson_wdt->wdt_base + MESON_WDT_TC);
+        reg &= ~MESON_WDT_TC_EN;
+        writel(reg, meson_wdt->wdt_base + MESON_WDT_TC);
+
+        return 0;
+}
+
+static int meson_wdt_start(struct watchdog_device *wdt_dev)
+{
+        struct meson_wdt_dev *meson_wdt = watchdog_get_drvdata(wdt_dev);
+        u32 reg;
+
+        meson_wdt_change_timeout(wdt_dev, meson_wdt->wdt_dev.timeout);
+        meson_wdt_ping(wdt_dev);
+
+        reg = readl(meson_wdt->wdt_base + MESON_WDT_TC);
+        reg |= MESON_WDT_TC_EN;
+        writel(reg, meson_wdt->wdt_base + MESON_WDT_TC);
+
+        return 0;
+}
+
+static const struct watchdog_info meson_wdt_info = {
+        .identity       = DRV_NAME,
+        .options        = WDIOF_SETTIMEOUT |
+                          WDIOF_KEEPALIVEPING |
+                          WDIOF_MAGICCLOSE,
+};
+
+static const struct watchdog_ops meson_wdt_ops = {
+        .owner          = THIS_MODULE,
+        .start          = meson_wdt_start,
+        .stop           = meson_wdt_stop,
+        .ping           = meson_wdt_ping,
+        .set_timeout    = meson_wdt_set_timeout,
+};
+
+static int meson_wdt_probe(struct platform_device *pdev)
+{
+        struct resource *res;
+        struct meson_wdt_dev *meson_wdt;
+        int err;
+
+        meson_wdt = devm_kzalloc(&pdev->dev, sizeof(*meson_wdt), GFP_KERNEL);
+        if (!meson_wdt)
+                return -ENOMEM;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        meson_wdt->wdt_base = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(meson_wdt->wdt_base))
+                return PTR_ERR(meson_wdt->wdt_base);
+
+        meson_wdt->wdt_dev.parent = &pdev->dev;
+        meson_wdt->wdt_dev.info = &meson_wdt_info;
+        meson_wdt->wdt_dev.ops = &meson_wdt_ops;
+        meson_wdt->wdt_dev.timeout = MESON_WDT_TIMEOUT;
+        meson_wdt->wdt_dev.max_timeout = MESON_WDT_MAX_TIMEOUT;
+        meson_wdt->wdt_dev.min_timeout = MESON_WDT_MIN_TIMEOUT;
+
+        watchdog_set_drvdata(&meson_wdt->wdt_dev, meson_wdt);
+
+        watchdog_init_timeout(&meson_wdt->wdt_dev, timeout, &pdev->dev);
+        watchdog_set_nowayout(&meson_wdt->wdt_dev, nowayout);
+
+        meson_wdt_stop(&meson_wdt->wdt_dev);
+
+        err = watchdog_register_device(&meson_wdt->wdt_dev);
+        if (err)
+                return err;
+
+        platform_set_drvdata(pdev, meson_wdt);
+
+        meson_wdt->restart_handler.notifier_call = meson_restart_handle;
+        meson_wdt->restart_handler.priority = 128;
+        err = register_restart_handler(&meson_wdt->restart_handler);
+        if (err)
+                dev_err(&pdev->dev,
+                        "cannot register restart handler (err=%d)\n", err);
+
+        dev_info(&pdev->dev, "Watchdog enabled (timeout=%d sec, nowayout=%d)",
+                 meson_wdt->wdt_dev.timeout, nowayout);
+
+        return 0;
+}
+
+static int meson_wdt_remove(struct platform_device *pdev)
+{
+        struct meson_wdt_dev *meson_wdt = platform_get_drvdata(pdev);
+
+        unregister_restart_handler(&meson_wdt->restart_handler);
+
+        watchdog_unregister_device(&meson_wdt->wdt_dev);
+
+        return 0;
+}
+
+static void meson_wdt_shutdown(struct platform_device *pdev)
+{
+        struct meson_wdt_dev *meson_wdt = platform_get_drvdata(pdev);
+
+        meson_wdt_stop(&meson_wdt->wdt_dev);
+}
+
+static const struct of_device_id meson_wdt_dt_ids[] = {
+        { .compatible = "amlogic,meson6-wdt" },
+        { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, meson_wdt_dt_ids);
+
+static struct platform_driver meson_wdt_driver = {
+        .probe          = meson_wdt_probe,
+        .remove         = meson_wdt_remove,
+        .shutdown       = meson_wdt_shutdown,
+        .driver         = {
+                .owner          = THIS_MODULE,
+                .name           = DRV_NAME,
+                .of_match_table = meson_wdt_dt_ids,
+        },
+};
+
+module_platform_driver(meson_wdt_driver);
+
+module_param(timeout, uint, 0);
+MODULE_PARM_DESC(timeout, "Watchdog heartbeat in seconds");
+
+module_param(nowayout, bool, 0);
+MODULE_PARM_DESC(nowayout,
+                 "Watchdog cannot be stopped once started (default="
+                 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Carlo Caione <carlo@caione.org>");
+MODULE_DESCRIPTION("Meson Watchdog Timer Driver");
diff --git a/drivers/watchdog/of_xilinx_wdt.c b/drivers/watchdog/of_xilinx_wdt.c
index 1e6e28df5d7b..b2e1b4cbbdc1 100644
--- a/drivers/watchdog/of_xilinx_wdt.c
+++ b/drivers/watchdog/of_xilinx_wdt.c
@@ -236,7 +236,6 @@ static struct platform_driver xwdt_driver = {
         .probe       = xwdt_probe,
         .remove      = xwdt_remove,
         .driver = {
-                .owner = THIS_MODULE,
                 .name  = WATCHDOG_NAME,
                 .of_match_table = xwdt_of_match,
         },
diff --git a/drivers/watchdog/qcom-wdt.c b/drivers/watchdog/qcom-wdt.c
new file mode 100644
index 000000000000..aa85618c4d03
--- /dev/null
+++ b/drivers/watchdog/qcom-wdt.c
@@ -0,0 +1,224 @@
+/* Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <linux/reboot.h>
+#include <linux/watchdog.h>
+
+#define WDT_RST         0x0
+#define WDT_EN          0x8
+#define WDT_BITE_TIME   0x24
+
+struct qcom_wdt {
+        struct watchdog_device  wdd;
+        struct clk              *clk;
+        unsigned long           rate;
+        struct notifier_block   restart_nb;
+        void __iomem            *base;
+};
+
+static inline
+struct qcom_wdt *to_qcom_wdt(struct watchdog_device *wdd)
+{
+        return container_of(wdd, struct qcom_wdt, wdd);
+}
+
+static int qcom_wdt_start(struct watchdog_device *wdd)
+{
+        struct qcom_wdt *wdt = to_qcom_wdt(wdd);
+
+        writel(0, wdt->base + WDT_EN);
+        writel(1, wdt->base + WDT_RST);
+        writel(wdd->timeout * wdt->rate, wdt->base + WDT_BITE_TIME);
+        writel(1, wdt->base + WDT_EN);
+        return 0;
+}
+
+static int qcom_wdt_stop(struct watchdog_device *wdd)
+{
+        struct qcom_wdt *wdt = to_qcom_wdt(wdd);
+
+        writel(0, wdt->base + WDT_EN);
+        return 0;
+}
+
+static int qcom_wdt_ping(struct watchdog_device *wdd)
+{
+        struct qcom_wdt *wdt = to_qcom_wdt(wdd);
+
+        writel(1, wdt->base + WDT_RST);
+        return 0;
+}
+
+static int qcom_wdt_set_timeout(struct watchdog_device *wdd,
+                                unsigned int timeout)
+{
+        wdd->timeout = timeout;
+        return qcom_wdt_start(wdd);
+}
+
+static const struct watchdog_ops qcom_wdt_ops = {
+        .start          = qcom_wdt_start,
+        .stop           = qcom_wdt_stop,
+        .ping           = qcom_wdt_ping,
+        .set_timeout    = qcom_wdt_set_timeout,
+        .owner          = THIS_MODULE,
+};
+
+static const struct watchdog_info qcom_wdt_info = {
+        .options        = WDIOF_KEEPALIVEPING
+                        | WDIOF_MAGICCLOSE
+                        | WDIOF_SETTIMEOUT,
+        .identity       = KBUILD_MODNAME,
+};
+
+static int qcom_wdt_restart(struct notifier_block *nb, unsigned long action,
+                            void *data)
+{
+        struct qcom_wdt *wdt = container_of(nb, struct qcom_wdt, restart_nb);
+        u32 timeout;
+
+        /*
+         * Trigger watchdog bite:
+         *    Setup BITE_TIME to be 128ms, and enable WDT.
+         */
+        timeout = 128 * wdt->rate / 1000;
+
+        writel(0, wdt->base + WDT_EN);
+        writel(1, wdt->base + WDT_RST);
+        writel(timeout, wdt->base + WDT_BITE_TIME);
+        writel(1, wdt->base + WDT_EN);
+
+        /*
+         * Actually make sure the above sequence hits hardware before sleeping.
+         */
+        wmb();
+
+        msleep(150);
+        return NOTIFY_DONE;
+}
+
+static int qcom_wdt_probe(struct platform_device *pdev)
+{
+        struct qcom_wdt *wdt;
+        struct resource *res;
+        int ret;
+
+        wdt = devm_kzalloc(&pdev->dev, sizeof(*wdt), GFP_KERNEL);
+        if (!wdt)
+                return -ENOMEM;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        wdt->base = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(wdt->base))
+                return PTR_ERR(wdt->base);
+
+        wdt->clk = devm_clk_get(&pdev->dev, NULL);
+        if (IS_ERR(wdt->clk)) {
+                dev_err(&pdev->dev, "failed to get input clock\n");
+                return PTR_ERR(wdt->clk);
+        }
+
+        ret = clk_prepare_enable(wdt->clk);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to setup clock\n");
+                return ret;
+        }
+
+        /*
+         * We use the clock rate to calculate the max timeout, so ensure it's
+         * not zero to avoid a divide-by-zero exception.
+         *
+         * WATCHDOG_CORE assumes units of seconds, if the WDT is clocked such
+         * that it would bite before a second elapses it's usefulness is
+         * limited.  Bail if this is the case.
+         */
+        wdt->rate = clk_get_rate(wdt->clk);
+        if (wdt->rate == 0 ||
+            wdt->rate > 0x10000000U) {
+                dev_err(&pdev->dev, "invalid clock rate\n");
+                ret = -EINVAL;
+                goto err_clk_unprepare;
+        }
+
+        wdt->wdd.dev = &pdev->dev;
+        wdt->wdd.info = &qcom_wdt_info;
+        wdt->wdd.ops = &qcom_wdt_ops;
+        wdt->wdd.min_timeout = 1;
+        wdt->wdd.max_timeout = 0x10000000U / wdt->rate;
+
+        /*
+         * If 'timeout-sec' unspecified in devicetree, assume a 30 second
+         * default, unless the max timeout is less than 30 seconds, then use
+         * the max instead.
+         */
+        wdt->wdd.timeout = min(wdt->wdd.max_timeout, 30U);
+        watchdog_init_timeout(&wdt->wdd, 0, &pdev->dev);
+
+        ret = watchdog_register_device(&wdt->wdd);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to register watchdog\n");
+                goto err_clk_unprepare;
+        }
+
+        /*
+         * WDT restart notifier has priority 0 (use as a last resort)
+         */
+        wdt->restart_nb.notifier_call = qcom_wdt_restart;
+        ret = register_restart_handler(&wdt->restart_nb);
+        if (ret)
+                dev_err(&pdev->dev, "failed to setup restart handler\n");
+
+        platform_set_drvdata(pdev, wdt);
+        return 0;
+
+err_clk_unprepare:
+        clk_disable_unprepare(wdt->clk);
+        return ret;
+}
+
+static int qcom_wdt_remove(struct platform_device *pdev)
+{
+        struct qcom_wdt *wdt = platform_get_drvdata(pdev);
+
+        unregister_restart_handler(&wdt->restart_nb);
+        watchdog_unregister_device(&wdt->wdd);
+        clk_disable_unprepare(wdt->clk);
+        return 0;
+}
+
+static const struct of_device_id qcom_wdt_of_table[] = {
+        { .compatible = "qcom,kpss-wdt-msm8960", },
+        { .compatible = "qcom,kpss-wdt-apq8064", },
+        { .compatible = "qcom,kpss-wdt-ipq8064", },
+        { },
+};
+MODULE_DEVICE_TABLE(of, qcom_wdt_of_table);
+
+static struct platform_driver qcom_watchdog_driver = {
+        .probe  = qcom_wdt_probe,
+        .remove = qcom_wdt_remove,
+        .driver = {
+                .name           = KBUILD_MODNAME,
+                .of_match_table = qcom_wdt_of_table,
+        },
+};
+module_platform_driver(qcom_watchdog_driver);
+
+MODULE_DESCRIPTION("QCOM KPSS Watchdog Driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/watchdog/rn5t618_wdt.c b/drivers/watchdog/rn5t618_wdt.c
new file mode 100644
index 000000000000..d1c12278cb6a
--- /dev/null
+++ b/drivers/watchdog/rn5t618_wdt.c
@@ -0,0 +1,198 @@
+/*
+ * Watchdog driver for Ricoh RN5T618 PMIC
+ *
+ * Copyright (C) 2014 Beniamino Galvani <b.galvani@gmail.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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/device.h>
+#include <linux/mfd/rn5t618.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/watchdog.h>
+
+#define DRIVER_NAME "rn5t618-wdt"
+
+static bool nowayout = WATCHDOG_NOWAYOUT;
+static unsigned int timeout;
+
+module_param(timeout, uint, 0);
+MODULE_PARM_DESC(timeout, "Initial watchdog timeout in seconds");
+
+module_param(nowayout, bool, 0);
+MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
+                 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+
+struct rn5t618_wdt {
+        struct watchdog_device wdt_dev;
+        struct rn5t618 *rn5t618;
+};
+
+/*
+ * This array encodes the values of WDOGTIM field for the supported
+ * watchdog expiration times. If the watchdog is not accessed before
+ * the timer expiration, the PMU generates an interrupt and if the CPU
+ * doesn't clear it within one second the system is restarted.
+ */
+static const struct {
+        u8 reg_val;
+        unsigned int time;
+} rn5t618_wdt_map[] = {
+        { 0, 1 },
+        { 1, 8 },
+        { 2, 32 },
+        { 3, 128 },
+};
+
+static int rn5t618_wdt_set_timeout(struct watchdog_device *wdt_dev,
+                                   unsigned int t)
+{
+        struct rn5t618_wdt *wdt = watchdog_get_drvdata(wdt_dev);
+        int ret, i;
+
+        for (i = 0; i < ARRAY_SIZE(rn5t618_wdt_map); i++) {
+                if (rn5t618_wdt_map[i].time + 1 >= t)
+                        break;
+        }
+
+        if (i == ARRAY_SIZE(rn5t618_wdt_map))
+                return -EINVAL;
+
+        ret = regmap_update_bits(wdt->rn5t618->regmap, RN5T618_WATCHDOG,
+                                 RN5T618_WATCHDOG_WDOGTIM_M,
+                                 rn5t618_wdt_map[i].reg_val);
+        if (!ret)
+                wdt_dev->timeout = rn5t618_wdt_map[i].time;
+
+        return ret;
+}
+
+static int rn5t618_wdt_start(struct watchdog_device *wdt_dev)
+{
+        struct rn5t618_wdt *wdt = watchdog_get_drvdata(wdt_dev);
+        int ret;
+
+        ret = rn5t618_wdt_set_timeout(wdt_dev, wdt_dev->timeout);
+        if (ret)
+                return ret;
+
+        /* enable repower-on */
+        ret = regmap_update_bits(wdt->rn5t618->regmap, RN5T618_REPCNT,
+                                 RN5T618_REPCNT_REPWRON,
+                                 RN5T618_REPCNT_REPWRON);
+        if (ret)
+                return ret;
+
+        /* enable watchdog */
+        ret = regmap_update_bits(wdt->rn5t618->regmap, RN5T618_WATCHDOG,
+                                 RN5T618_WATCHDOG_WDOGEN,
+                                 RN5T618_WATCHDOG_WDOGEN);
+        if (ret)
+                return ret;
+
+        /* enable watchdog interrupt */
+        return regmap_update_bits(wdt->rn5t618->regmap, RN5T618_PWRIREN,
+                                  RN5T618_PWRIRQ_IR_WDOG,
+                                  RN5T618_PWRIRQ_IR_WDOG);
+}
+
+static int rn5t618_wdt_stop(struct watchdog_device *wdt_dev)
+{
+        struct rn5t618_wdt *wdt = watchdog_get_drvdata(wdt_dev);
+
+        return regmap_update_bits(wdt->rn5t618->regmap, RN5T618_WATCHDOG,
+                                  RN5T618_WATCHDOG_WDOGEN, 0);
+}
+
+static int rn5t618_wdt_ping(struct watchdog_device *wdt_dev)
+{
+        struct rn5t618_wdt *wdt = watchdog_get_drvdata(wdt_dev);
+        unsigned int val;
+        int ret;
+
+        /* The counter is restarted after a R/W access to watchdog register */
+        ret = regmap_read(wdt->rn5t618->regmap, RN5T618_WATCHDOG, &val);
+        if (ret)
+                return ret;
+
+        ret = regmap_write(wdt->rn5t618->regmap, RN5T618_WATCHDOG, val);
+        if (ret)
+                return ret;
+
+        /* Clear pending watchdog interrupt */
+        return regmap_update_bits(wdt->rn5t618->regmap, RN5T618_PWRIRQ,
+                                  RN5T618_PWRIRQ_IR_WDOG, 0);
+}
+
+static struct watchdog_info rn5t618_wdt_info = {
+        .options        = WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE |
+                          WDIOF_KEEPALIVEPING,
+        .identity       = DRIVER_NAME,
+};
+
+static struct watchdog_ops rn5t618_wdt_ops = {
+        .owner          = THIS_MODULE,
+        .start          = rn5t618_wdt_start,
+        .stop           = rn5t618_wdt_stop,
+        .ping           = rn5t618_wdt_ping,
+        .set_timeout    = rn5t618_wdt_set_timeout,
+};
+
+static int rn5t618_wdt_probe(struct platform_device *pdev)
+{
+        struct rn5t618 *rn5t618 = dev_get_drvdata(pdev->dev.parent);
+        struct rn5t618_wdt *wdt;
+        int min_timeout, max_timeout;
+
+        wdt = devm_kzalloc(&pdev->dev, sizeof(struct rn5t618_wdt), GFP_KERNEL);
+        if (!wdt)
+                return -ENOMEM;
+
+        min_timeout = rn5t618_wdt_map[0].time;
+        max_timeout = rn5t618_wdt_map[ARRAY_SIZE(rn5t618_wdt_map) - 1].time;
+
+        wdt->rn5t618 = rn5t618;
+        wdt->wdt_dev.info = &rn5t618_wdt_info;
+        wdt->wdt_dev.ops = &rn5t618_wdt_ops;
+        wdt->wdt_dev.min_timeout = min_timeout;
+        wdt->wdt_dev.max_timeout = max_timeout;
+        wdt->wdt_dev.timeout = max_timeout;
+        wdt->wdt_dev.parent = &pdev->dev;
+
+        watchdog_set_drvdata(&wdt->wdt_dev, wdt);
+        watchdog_init_timeout(&wdt->wdt_dev, timeout, &pdev->dev);
+        watchdog_set_nowayout(&wdt->wdt_dev, nowayout);
+
+        platform_set_drvdata(pdev, wdt);
+
+        return watchdog_register_device(&wdt->wdt_dev);
+}
+
+static int rn5t618_wdt_remove(struct platform_device *pdev)
+{
+        struct rn5t618_wdt *wdt = platform_get_drvdata(pdev);
+
+        watchdog_unregister_device(&wdt->wdt_dev);
+
+        return 0;
+}
+
+static struct platform_driver rn5t618_wdt_driver = {
+        .probe = rn5t618_wdt_probe,
+        .remove = rn5t618_wdt_remove,
+        .driver = {
+                .name   = DRIVER_NAME,
+        },
+};
+
+module_platform_driver(rn5t618_wdt_driver);
+
+MODULE_AUTHOR("Beniamino Galvani <b.galvani@gmail.com>");
+MODULE_DESCRIPTION("RN5T618 watchdog driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/watchdog/s3c2410_wdt.c b/drivers/watchdog/s3c2410_wdt.c
index 7c6ccd071baf..8532c3e2aea7 100644
--- a/drivers/watchdog/s3c2410_wdt.c
+++ b/drivers/watchdog/s3c2410_wdt.c
@@ -41,6 +41,8 @@
 #include <linux/of.h>
 #include <linux/mfd/syscon.h>
 #include <linux/regmap.h>
+#include <linux/reboot.h>
+#include <linux/delay.h>
 
 #define S3C2410_WTCON           0x00
 #define S3C2410_WTDAT           0x04
@@ -128,6 +130,7 @@ struct s3c2410_wdt {
         unsigned long           wtdat_save;
         struct watchdog_device  wdt_device;
         struct notifier_block   freq_transition;
+        struct notifier_block   restart_handler;
         struct s3c2410_wdt_variant *drv_data;
         struct regmap *pmureg;
 };
@@ -155,6 +158,15 @@ static const struct s3c2410_wdt_variant drv_data_exynos5420 = {
         .quirks = QUIRK_HAS_PMU_CONFIG | QUIRK_HAS_RST_STAT,
 };
 
+static const struct s3c2410_wdt_variant drv_data_exynos7 = {
+        .disable_reg = EXYNOS5_WDT_DISABLE_REG_OFFSET,
+        .mask_reset_reg = EXYNOS5_WDT_MASK_RESET_REG_OFFSET,
+        .mask_bit = 0,
+        .rst_stat_reg = EXYNOS5_RST_STAT_REG_OFFSET,
+        .rst_stat_bit = 23,     /* A57 WDTRESET */
+        .quirks = QUIRK_HAS_PMU_CONFIG | QUIRK_HAS_RST_STAT,
+};
+
 static const struct of_device_id s3c2410_wdt_match[] = {
         { .compatible = "samsung,s3c2410-wdt",
           .data = &drv_data_s3c2410 },
@@ -162,6 +174,8 @@ static const struct of_device_id s3c2410_wdt_match[] = {
           .data = &drv_data_exynos5250 },
         { .compatible = "samsung,exynos5420-wdt",
           .data = &drv_data_exynos5420 },
+        { .compatible = "samsung,exynos7-wdt",
+          .data = &drv_data_exynos7 },
         {},
 };
 MODULE_DEVICE_TABLE(of, s3c2410_wdt_match);
@@ -438,6 +452,31 @@ static inline void s3c2410wdt_cpufreq_deregister(struct s3c2410_wdt *wdt)
 }
 #endif
 
+static int s3c2410wdt_restart(struct notifier_block *this,
+                              unsigned long mode, void *cmd)
+{
+        struct s3c2410_wdt *wdt = container_of(this, struct s3c2410_wdt,
+                                               restart_handler);
+        void __iomem *wdt_base = wdt->reg_base;
+
+        /* disable watchdog, to be safe  */
+        writel(0, wdt_base + S3C2410_WTCON);
+
+        /* put initial values into count and data */
+        writel(0x80, wdt_base + S3C2410_WTCNT);
+        writel(0x80, wdt_base + S3C2410_WTDAT);
+
+        /* set the watchdog to go and reset... */
+        writel(S3C2410_WTCON_ENABLE | S3C2410_WTCON_DIV16 |
+                S3C2410_WTCON_RSTEN | S3C2410_WTCON_PRESCALE(0x20),
+                wdt_base + S3C2410_WTCON);
+
+        /* wait for reset to assert... */
+        mdelay(500);
+
+        return NOTIFY_DONE;
+}
+
 static inline unsigned int s3c2410wdt_get_bootstatus(struct s3c2410_wdt *wdt)
 {
         unsigned int rst_stat;
@@ -592,6 +631,12 @@ static int s3c2410wdt_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, wdt);
 
+        wdt->restart_handler.notifier_call = s3c2410wdt_restart;
+        wdt->restart_handler.priority = 128;
+        ret = register_restart_handler(&wdt->restart_handler);
+        if (ret)
+                pr_err("cannot register restart handler, %d\n", ret);
+
         /* print out a statement of readiness */
 
         wtcon = readl(wdt->reg_base + S3C2410_WTCON);
@@ -621,6 +666,8 @@ static int s3c2410wdt_remove(struct platform_device *dev)
         int ret;
         struct s3c2410_wdt *wdt = platform_get_drvdata(dev);
 
+        unregister_restart_handler(&wdt->restart_handler);
+
         ret = s3c2410wdt_mask_and_disable_reset(wdt, true);
         if (ret < 0)
                 return ret;
diff --git a/drivers/watchdog/stmp3xxx_rtc_wdt.c b/drivers/watchdog/stmp3xxx_rtc_wdt.c
index 3804d5e9baea..a62b1b6decf4 100644
--- a/drivers/watchdog/stmp3xxx_rtc_wdt.c
+++ b/drivers/watchdog/stmp3xxx_rtc_wdt.c
@@ -94,9 +94,33 @@ static int stmp3xxx_wdt_remove(struct platform_device *pdev)
         return 0;
 }
 
+static int __maybe_unused stmp3xxx_wdt_suspend(struct device *dev)
+{
+        struct watchdog_device *wdd = &stmp3xxx_wdd;
+
+        if (watchdog_active(wdd))
+                return wdt_stop(wdd);
+
+        return 0;
+}
+
+static int __maybe_unused stmp3xxx_wdt_resume(struct device *dev)
+{
+        struct watchdog_device *wdd = &stmp3xxx_wdd;
+
+        if (watchdog_active(wdd))
+                return wdt_start(wdd);
+
+        return 0;
+}
+
+static SIMPLE_DEV_PM_OPS(stmp3xxx_wdt_pm_ops,
+                         stmp3xxx_wdt_suspend, stmp3xxx_wdt_resume);
+
 static struct platform_driver stmp3xxx_wdt_driver = {
         .driver = {
                 .name = "stmp3xxx_rtc_wdt",
+                .pm = &stmp3xxx_wdt_pm_ops,
         },
         .probe = stmp3xxx_wdt_probe,
         .remove = stmp3xxx_wdt_remove,
diff --git a/drivers/watchdog/sunxi_wdt.c b/drivers/watchdog/sunxi_wdt.c
index 480bb557f353..b62301e74e5f 100644
--- a/drivers/watchdog/sunxi_wdt.c
+++ b/drivers/watchdog/sunxi_wdt.c
@@ -23,6 +23,7 @@
 #include <linux/moduleparam.h>
 #include <linux/notifier.h>
 #include <linux/of.h>
+#include <linux/of_device.h>
 #include <linux/platform_device.h>
 #include <linux/reboot.h>
 #include <linux/types.h>
@@ -30,15 +31,11 @@
 
 #define WDT_MAX_TIMEOUT         16
 #define WDT_MIN_TIMEOUT         1
-#define WDT_MODE_TIMEOUT(n)     ((n) << 3)
-#define WDT_TIMEOUT_MASK        WDT_MODE_TIMEOUT(0x0F)
+#define WDT_TIMEOUT_MASK        0x0F
 
-#define WDT_CTRL                0x00
 #define WDT_CTRL_RELOAD         ((1 << 0) | (0x0a57 << 1))
 
-#define WDT_MODE                0x04
 #define WDT_MODE_EN             (1 << 0)
-#define WDT_MODE_RST_EN         (1 << 1)
 
 #define DRV_NAME                "sunxi-wdt"
 #define DRV_VERSION             "1.0"
@@ -46,15 +43,29 @@
 static bool nowayout = WATCHDOG_NOWAYOUT;
 static unsigned int timeout = WDT_MAX_TIMEOUT;
 
+/*
+ * This structure stores the register offsets for different variants
+ * of Allwinner's watchdog hardware.
+ */
+struct sunxi_wdt_reg {
+        u8 wdt_ctrl;
+        u8 wdt_cfg;
+        u8 wdt_mode;
+        u8 wdt_timeout_shift;
+        u8 wdt_reset_mask;
+        u8 wdt_reset_val;
+};
+
 struct sunxi_wdt_dev {
         struct watchdog_device wdt_dev;
         void __iomem *wdt_base;
+        const struct sunxi_wdt_reg *wdt_regs;
         struct notifier_block restart_handler;
 };
 
 /*
  * wdt_timeout_map maps the watchdog timer interval value in seconds to
- * the value of the register WDT_MODE bit 3:6
+ * the value of the register WDT_MODE at bits .wdt_timeout_shift ~ +3
  *
  * [timeout seconds] = register value
  *
@@ -82,19 +93,32 @@ static int sunxi_restart_handle(struct notifier_block *this, unsigned long mode,
                                                        struct sunxi_wdt_dev,
                                                        restart_handler);
         void __iomem *wdt_base = sunxi_wdt->wdt_base;
+        const struct sunxi_wdt_reg *regs = sunxi_wdt->wdt_regs;
+        u32 val;
+
+        /* Set system reset function */
+        val = readl(wdt_base + regs->wdt_cfg);
+        val &= ~(regs->wdt_reset_mask);
+        val |= regs->wdt_reset_val;
+        writel(val, wdt_base + regs->wdt_cfg);
 
-        /* Enable timer and set reset bit in the watchdog */
-        writel(WDT_MODE_EN | WDT_MODE_RST_EN, wdt_base + WDT_MODE);
+        /* Set lowest timeout and enable watchdog */
+        val = readl(wdt_base + regs->wdt_mode);
+        val &= ~(WDT_TIMEOUT_MASK << regs->wdt_timeout_shift);
+        val |= WDT_MODE_EN;
+        writel(val, wdt_base + regs->wdt_mode);
 
         /*
          * Restart the watchdog. The default (and lowest) interval
          * value for the watchdog is 0.5s.
          */
-        writel(WDT_CTRL_RELOAD, wdt_base + WDT_CTRL);
+        writel(WDT_CTRL_RELOAD, wdt_base + regs->wdt_ctrl);
 
         while (1) {
                 mdelay(5);
-                writel(WDT_MODE_EN | WDT_MODE_RST_EN, wdt_base + WDT_MODE);
+                val = readl(wdt_base + regs->wdt_mode);
+                val |= WDT_MODE_EN;
+                writel(val, wdt_base + regs->wdt_mode);
         }
         return NOTIFY_DONE;
 }
@@ -103,8 +127,9 @@ static int sunxi_wdt_ping(struct watchdog_device *wdt_dev)
 {
         struct sunxi_wdt_dev *sunxi_wdt = watchdog_get_drvdata(wdt_dev);
         void __iomem *wdt_base = sunxi_wdt->wdt_base;
+        const struct sunxi_wdt_reg *regs = sunxi_wdt->wdt_regs;
 
-        iowrite32(WDT_CTRL_RELOAD, wdt_base + WDT_CTRL);
+        writel(WDT_CTRL_RELOAD, wdt_base + regs->wdt_ctrl);
 
         return 0;
 }
@@ -114,6 +139,7 @@ static int sunxi_wdt_set_timeout(struct watchdog_device *wdt_dev,
 {
         struct sunxi_wdt_dev *sunxi_wdt = watchdog_get_drvdata(wdt_dev);
         void __iomem *wdt_base = sunxi_wdt->wdt_base;
+        const struct sunxi_wdt_reg *regs = sunxi_wdt->wdt_regs;
         u32 reg;
 
         if (wdt_timeout_map[timeout] == 0)
@@ -121,10 +147,10 @@ static int sunxi_wdt_set_timeout(struct watchdog_device *wdt_dev,
 
         sunxi_wdt->wdt_dev.timeout = timeout;
 
-        reg = ioread32(wdt_base + WDT_MODE);
-        reg &= ~WDT_TIMEOUT_MASK;
-        reg |= WDT_MODE_TIMEOUT(wdt_timeout_map[timeout]);
-        iowrite32(reg, wdt_base + WDT_MODE);
+        reg = readl(wdt_base + regs->wdt_mode);
+        reg &= ~(WDT_TIMEOUT_MASK << regs->wdt_timeout_shift);
+        reg |= wdt_timeout_map[timeout] << regs->wdt_timeout_shift;
+        writel(reg, wdt_base + regs->wdt_mode);
 
         sunxi_wdt_ping(wdt_dev);
 
@@ -135,8 +161,9 @@ static int sunxi_wdt_stop(struct watchdog_device *wdt_dev)
 {
         struct sunxi_wdt_dev *sunxi_wdt = watchdog_get_drvdata(wdt_dev);
         void __iomem *wdt_base = sunxi_wdt->wdt_base;
+        const struct sunxi_wdt_reg *regs = sunxi_wdt->wdt_regs;
 
-        iowrite32(0, wdt_base + WDT_MODE);
+        writel(0, wdt_base + regs->wdt_mode);
 
         return 0;
 }
@@ -146,6 +173,7 @@ static int sunxi_wdt_start(struct watchdog_device *wdt_dev)
         u32 reg;
         struct sunxi_wdt_dev *sunxi_wdt = watchdog_get_drvdata(wdt_dev);
         void __iomem *wdt_base = sunxi_wdt->wdt_base;
+        const struct sunxi_wdt_reg *regs = sunxi_wdt->wdt_regs;
         int ret;
 
         ret = sunxi_wdt_set_timeout(&sunxi_wdt->wdt_dev,
@@ -153,9 +181,16 @@ static int sunxi_wdt_start(struct watchdog_device *wdt_dev)
         if (ret < 0)
                 return ret;
 
-        reg = ioread32(wdt_base + WDT_MODE);
-        reg |= (WDT_MODE_RST_EN | WDT_MODE_EN);
-        iowrite32(reg, wdt_base + WDT_MODE);
+        /* Set system reset function */
+        reg = readl(wdt_base + regs->wdt_cfg);
+        reg &= ~(regs->wdt_reset_mask);
+        reg |= ~(regs->wdt_reset_val);
+        writel(reg, wdt_base + regs->wdt_cfg);
+
+        /* Enable watchdog */
+        reg = readl(wdt_base + regs->wdt_mode);
+        reg |= WDT_MODE_EN;
+        writel(reg, wdt_base + regs->wdt_mode);
 
         return 0;
 }
@@ -175,9 +210,35 @@ static const struct watchdog_ops sunxi_wdt_ops = {
         .set_timeout    = sunxi_wdt_set_timeout,
 };
 
+static const struct sunxi_wdt_reg sun4i_wdt_reg = {
+        .wdt_ctrl = 0x00,
+        .wdt_cfg = 0x04,
+        .wdt_mode = 0x04,
+        .wdt_timeout_shift = 3,
+        .wdt_reset_mask = 0x02,
+        .wdt_reset_val = 0x02,
+};
+
+static const struct sunxi_wdt_reg sun6i_wdt_reg = {
+        .wdt_ctrl = 0x10,
+        .wdt_cfg = 0x14,
+        .wdt_mode = 0x18,
+        .wdt_timeout_shift = 4,
+        .wdt_reset_mask = 0x03,
+        .wdt_reset_val = 0x01,
+};
+
+static const struct of_device_id sunxi_wdt_dt_ids[] = {
+        { .compatible = "allwinner,sun4i-a10-wdt", .data = &sun4i_wdt_reg },
+        { .compatible = "allwinner,sun6i-a31-wdt", .data = &sun6i_wdt_reg },
+        { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, sunxi_wdt_dt_ids);
+
 static int sunxi_wdt_probe(struct platform_device *pdev)
 {
         struct sunxi_wdt_dev *sunxi_wdt;
+        const struct of_device_id *device;
         struct resource *res;
         int err;
 
@@ -187,6 +248,12 @@ static int sunxi_wdt_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, sunxi_wdt);
 
+        device = of_match_device(sunxi_wdt_dt_ids, &pdev->dev);
+        if (!device)
+                return -ENODEV;
+
+        sunxi_wdt->wdt_regs = device->data;
+
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         sunxi_wdt->wdt_base = devm_ioremap_resource(&pdev->dev, res);
         if (IS_ERR(sunxi_wdt->wdt_base))
@@ -242,12 +309,6 @@ static void sunxi_wdt_shutdown(struct platform_device *pdev)
         sunxi_wdt_stop(&sunxi_wdt->wdt_dev);
 }
 
-static const struct of_device_id sunxi_wdt_dt_ids[] = {
-        { .compatible = "allwinner,sun4i-a10-wdt" },
-        { /* sentinel */ }
-};
-MODULE_DEVICE_TABLE(of, sunxi_wdt_dt_ids);
-
 static struct platform_driver sunxi_wdt_driver = {
         .probe          = sunxi_wdt_probe,
         .remove         = sunxi_wdt_remove,
diff --git a/drivers/watchdog/ts72xx_wdt.c b/drivers/watchdog/ts72xx_wdt.c
index afa9d6ef353a..dee9c6cbe6df 100644
--- a/drivers/watchdog/ts72xx_wdt.c
+++ b/drivers/watchdog/ts72xx_wdt.c
@@ -428,11 +428,7 @@ static int ts72xx_wdt_probe(struct platform_device *pdev)
 
 static int ts72xx_wdt_remove(struct platform_device *pdev)
 {
-        int error;
-
-        error = misc_deregister(&ts72xx_wdt_miscdev);
-
-        return error;
+        return misc_deregister(&ts72xx_wdt_miscdev);
 }
 
 static struct platform_driver ts72xx_wdt_driver = {
diff --git a/drivers/xen/balloon.c b/drivers/xen/balloon.c
index 1e0a317d3dcd..3860d02729dc 100644
--- a/drivers/xen/balloon.c
+++ b/drivers/xen/balloon.c
@@ -167,6 +167,9 @@ static struct page *balloon_next_page(struct page *page)
 
 static enum bp_state update_schedule(enum bp_state state)
 {
+        if (state == BP_ECANCELED)
+                return BP_ECANCELED;
+
         if (state == BP_DONE) {
                 balloon_stats.schedule_delay = 1;
                 balloon_stats.retry_count = 1;
diff --git a/drivers/xen/pci.c b/drivers/xen/pci.c
index dd9c249ea311..95ee4302ffb8 100644
--- a/drivers/xen/pci.c
+++ b/drivers/xen/pci.c
@@ -41,24 +41,29 @@ static int xen_add_device(struct device *dev)
 #endif
 
         if (pci_seg_supported) {
-                struct physdev_pci_device_add add = {
-                        .seg = pci_domain_nr(pci_dev->bus),
-                        .bus = pci_dev->bus->number,
-                        .devfn = pci_dev->devfn
+                struct {
+                        struct physdev_pci_device_add add;
+                        uint32_t pxm;
+                } add_ext = {
+                        .add.seg = pci_domain_nr(pci_dev->bus),
+                        .add.bus = pci_dev->bus->number,
+                        .add.devfn = pci_dev->devfn
                 };
+                struct physdev_pci_device_add *add = &add_ext.add;
+
 #ifdef CONFIG_ACPI
                 acpi_handle handle;
 #endif
 
 #ifdef CONFIG_PCI_IOV
                 if (pci_dev->is_virtfn) {
-                        add.flags = XEN_PCI_DEV_VIRTFN;
-                        add.physfn.bus = physfn->bus->number;
-                        add.physfn.devfn = physfn->devfn;
+                        add->flags = XEN_PCI_DEV_VIRTFN;
+                        add->physfn.bus = physfn->bus->number;
+                        add->physfn.devfn = physfn->devfn;
                 } else
 #endif
                 if (pci_ari_enabled(pci_dev->bus) && PCI_SLOT(pci_dev->devfn))
-                        add.flags = XEN_PCI_DEV_EXTFN;
+                        add->flags = XEN_PCI_DEV_EXTFN;
 
 #ifdef CONFIG_ACPI
                 handle = ACPI_HANDLE(&pci_dev->dev);
@@ -77,8 +82,8 @@ static int xen_add_device(struct device *dev)
                                 status = acpi_evaluate_integer(handle, "_PXM",
                                                                NULL, &pxm);
                                 if (ACPI_SUCCESS(status)) {
-                                        add.optarr[0] = pxm;
-                                        add.flags |= XEN_PCI_DEV_PXM;
+                                        add->optarr[0] = pxm;
+                                        add->flags |= XEN_PCI_DEV_PXM;
                                         break;
                                 }
                                 status = acpi_get_parent(handle, &handle);
@@ -86,7 +91,7 @@ static int xen_add_device(struct device *dev)
                 }
 #endif /* CONFIG_ACPI */
 
-                r = HYPERVISOR_physdev_op(PHYSDEVOP_pci_device_add, &add);
+                r = HYPERVISOR_physdev_op(PHYSDEVOP_pci_device_add, add);
                 if (r != -ENOSYS)
                         return r;
                 pci_seg_supported = false;