Merge branch 'topic/firewire' into for-next

This is a merge of big firewire audio stack updates by Takashi Sakamoto.

99 files changed, 1613 insertions, 535 deletions

diff --git a/drivers/Makefile b/drivers/Makefile
index d05d81b19b50..7183b6af5dac 100644
--- a/drivers/Makefile
+++ b/drivers/Makefile
@@ -119,7 +119,7 @@ obj-$(CONFIG_SGI_SN)		+= sn/
 obj-y                           += firmware/
 obj-$(CONFIG_CRYPTO)            += crypto/
 obj-$(CONFIG_SUPERH)            += sh/
-obj-$(CONFIG_ARCH_SHMOBILE_LEGACY)      += sh/
+obj-$(CONFIG_ARCH_SHMOBILE)     += sh/
 ifndef CONFIG_ARCH_USES_GETTIMEOFFSET
 obj-y                           += clocksource/
 endif
diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig
index ab686b310100..a34a22841002 100644
--- a/drivers/acpi/Kconfig
+++ b/drivers/acpi/Kconfig
@@ -47,6 +47,23 @@ config ACPI_SLEEP
         depends on SUSPEND || HIBERNATION
         default y
 
+config ACPI_PROCFS_POWER
+        bool "Deprecated power /proc/acpi directories"
+        depends on PROC_FS
+        help
+          For backwards compatibility, this option allows
+          deprecated power /proc/acpi/ directories to exist, even when
+          they have been replaced by functions in /sys.
+          The deprecated directories (and their replacements) include:
+          /proc/acpi/battery/* (/sys/class/power_supply/*)
+          /proc/acpi/ac_adapter/* (sys/class/power_supply/*)
+          This option has no effect on /proc/acpi/ directories
+          and functions, which do not yet exist in /sys
+          This option, together with the proc directories, will be
+          deleted in the future.
+
+          Say N to delete power /proc/acpi/ directories that have moved to /sys/
+
 config ACPI_EC_DEBUGFS
         tristate "EC read/write access through /sys/kernel/debug/ec"
         default n
diff --git a/drivers/acpi/Makefile b/drivers/acpi/Makefile
index 0331f91d56e6..bce34afadcd0 100644
--- a/drivers/acpi/Makefile
+++ b/drivers/acpi/Makefile
@@ -47,6 +47,7 @@ acpi-y				+= sysfs.o
 acpi-$(CONFIG_X86)              += acpi_cmos_rtc.o
 acpi-$(CONFIG_DEBUG_FS)         += debugfs.o
 acpi-$(CONFIG_ACPI_NUMA)        += numa.o
+acpi-$(CONFIG_ACPI_PROCFS_POWER) += cm_sbs.o
 ifdef CONFIG_ACPI_VIDEO
 acpi-y                          += video_detect.o
 endif
diff --git a/drivers/acpi/ac.c b/drivers/acpi/ac.c
index 2c01c1da29ce..c67f6f5ad611 100644
--- a/drivers/acpi/ac.c
+++ b/drivers/acpi/ac.c
@@ -52,11 +52,39 @@ MODULE_AUTHOR("Paul Diefenbaugh");
 MODULE_DESCRIPTION("ACPI AC Adapter Driver");
 MODULE_LICENSE("GPL");
 
+static int acpi_ac_add(struct acpi_device *device);
+static int acpi_ac_remove(struct acpi_device *device);
+static void acpi_ac_notify(struct acpi_device *device, u32 event);
+
+static const struct acpi_device_id ac_device_ids[] = {
+        {"ACPI0003", 0},
+        {"", 0},
+};
+MODULE_DEVICE_TABLE(acpi, ac_device_ids);
+
+#ifdef CONFIG_PM_SLEEP
+static int acpi_ac_resume(struct device *dev);
+#endif
+static SIMPLE_DEV_PM_OPS(acpi_ac_pm, NULL, acpi_ac_resume);
+
 static int ac_sleep_before_get_state_ms;
 
+static struct acpi_driver acpi_ac_driver = {
+        .name = "ac",
+        .class = ACPI_AC_CLASS,
+        .ids = ac_device_ids,
+        .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
+        .ops = {
+                .add = acpi_ac_add,
+                .remove = acpi_ac_remove,
+                .notify = acpi_ac_notify,
+                },
+        .drv.pm = &acpi_ac_pm,
+};
+
 struct acpi_ac {
         struct power_supply charger;
-        struct platform_device *pdev;
+        struct acpi_device * device;
         unsigned long long state;
         struct notifier_block battery_nb;
 };
@@ -69,10 +97,12 @@ struct acpi_ac {
 
 static int acpi_ac_get_state(struct acpi_ac *ac)
 {
-        acpi_status status;
-        acpi_handle handle = ACPI_HANDLE(&ac->pdev->dev);
+        acpi_status status = AE_OK;
+
+        if (!ac)
+                return -EINVAL;
 
-        status = acpi_evaluate_integer(handle, "_PSR", NULL,
+        status = acpi_evaluate_integer(ac->device->handle, "_PSR", NULL,
                                        &ac->state);
         if (ACPI_FAILURE(status)) {
                 ACPI_EXCEPTION((AE_INFO, status,
@@ -117,10 +147,9 @@ static enum power_supply_property ac_props[] = {
                                    Driver Model
    -------------------------------------------------------------------------- */
 
-static void acpi_ac_notify_handler(acpi_handle handle, u32 event, void *data)
+static void acpi_ac_notify(struct acpi_device *device, u32 event)
 {
-        struct acpi_ac *ac = data;
-        struct acpi_device *adev;
+        struct acpi_ac *ac = acpi_driver_data(device);
 
         if (!ac)
                 return;
@@ -143,11 +172,10 @@ static void acpi_ac_notify_handler(acpi_handle handle, u32 event, void *data)
                         msleep(ac_sleep_before_get_state_ms);
 
                 acpi_ac_get_state(ac);
-                adev = ACPI_COMPANION(&ac->pdev->dev);
-                acpi_bus_generate_netlink_event(adev->pnp.device_class,
-                                                dev_name(&ac->pdev->dev),
-                                                event, (u32) ac->state);
-                acpi_notifier_call_chain(adev, event, (u32) ac->state);
+                acpi_bus_generate_netlink_event(device->pnp.device_class,
+                                                  dev_name(&device->dev), event,
+                                                  (u32) ac->state);
+                acpi_notifier_call_chain(device, event, (u32) ac->state);
                 kobject_uevent(&ac->charger.dev->kobj, KOBJ_CHANGE);
         }
 
@@ -192,49 +220,39 @@ static struct dmi_system_id ac_dmi_table[] = {
         {},
 };
 
-static int acpi_ac_probe(struct platform_device *pdev)
+static int acpi_ac_add(struct acpi_device *device)
 {
         int result = 0;
         struct acpi_ac *ac = NULL;
-        struct acpi_device *adev;
 
-        if (!pdev)
-                return -EINVAL;
 
-        adev = ACPI_COMPANION(&pdev->dev);
-        if (!adev)
-                return -ENODEV;
+        if (!device)
+                return -EINVAL;
 
         ac = kzalloc(sizeof(struct acpi_ac), GFP_KERNEL);
         if (!ac)
                 return -ENOMEM;
 
-        strcpy(acpi_device_name(adev), ACPI_AC_DEVICE_NAME);
-        strcpy(acpi_device_class(adev), ACPI_AC_CLASS);
-        ac->pdev = pdev;
-        platform_set_drvdata(pdev, ac);
+        ac->device = device;
+        strcpy(acpi_device_name(device), ACPI_AC_DEVICE_NAME);
+        strcpy(acpi_device_class(device), ACPI_AC_CLASS);
+        device->driver_data = ac;
 
         result = acpi_ac_get_state(ac);
         if (result)
                 goto end;
 
-        ac->charger.name = acpi_device_bid(adev);
+        ac->charger.name = acpi_device_bid(device);
         ac->charger.type = POWER_SUPPLY_TYPE_MAINS;
         ac->charger.properties = ac_props;
         ac->charger.num_properties = ARRAY_SIZE(ac_props);
         ac->charger.get_property = get_ac_property;
-        result = power_supply_register(&pdev->dev, &ac->charger);
+        result = power_supply_register(&ac->device->dev, &ac->charger);
         if (result)
                 goto end;
 
-        result = acpi_install_notify_handler(ACPI_HANDLE(&pdev->dev),
-                        ACPI_ALL_NOTIFY, acpi_ac_notify_handler, ac);
-        if (result) {
-                power_supply_unregister(&ac->charger);
-                goto end;
-        }
         printk(KERN_INFO PREFIX "%s [%s] (%s)\n",
-               acpi_device_name(adev), acpi_device_bid(adev),
+               acpi_device_name(device), acpi_device_bid(device),
                ac->state ? "on-line" : "off-line");
 
         ac->battery_nb.notifier_call = acpi_ac_battery_notify;
@@ -256,7 +274,7 @@ static int acpi_ac_resume(struct device *dev)
         if (!dev)
                 return -EINVAL;
 
-        ac = platform_get_drvdata(to_platform_device(dev));
+        ac = acpi_driver_data(to_acpi_device(dev));
         if (!ac)
                 return -EINVAL;
 
@@ -270,19 +288,17 @@ static int acpi_ac_resume(struct device *dev)
 #else
 #define acpi_ac_resume NULL
 #endif
-static SIMPLE_DEV_PM_OPS(acpi_ac_pm_ops, NULL, acpi_ac_resume);
 
-static int acpi_ac_remove(struct platform_device *pdev)
+static int acpi_ac_remove(struct acpi_device *device)
 {
-        struct acpi_ac *ac;
+        struct acpi_ac *ac = NULL;
+
 
-        if (!pdev)
+        if (!device || !acpi_driver_data(device))
                 return -EINVAL;
 
-        acpi_remove_notify_handler(ACPI_HANDLE(&pdev->dev),
-                        ACPI_ALL_NOTIFY, acpi_ac_notify_handler);
+        ac = acpi_driver_data(device);
 
-        ac = platform_get_drvdata(pdev);
         if (ac->charger.dev)
                 power_supply_unregister(&ac->charger);
         unregister_acpi_notifier(&ac->battery_nb);
@@ -292,23 +308,6 @@ static int acpi_ac_remove(struct platform_device *pdev)
         return 0;
 }
 
-static const struct acpi_device_id acpi_ac_match[] = {
-        { "ACPI0003", 0 },
-        { }
-};
-MODULE_DEVICE_TABLE(acpi, acpi_ac_match);
-
-static struct platform_driver acpi_ac_driver = {
-        .probe          = acpi_ac_probe,
-        .remove         = acpi_ac_remove,
-        .driver         = {
-                .name   = "acpi-ac",
-                .owner  = THIS_MODULE,
-                .pm     = &acpi_ac_pm_ops,
-                .acpi_match_table = ACPI_PTR(acpi_ac_match),
-        },
-};
-
 static int __init acpi_ac_init(void)
 {
         int result;
@@ -316,7 +315,7 @@ static int __init acpi_ac_init(void)
         if (acpi_disabled)
                 return -ENODEV;
 
-        result = platform_driver_register(&acpi_ac_driver);
+        result = acpi_bus_register_driver(&acpi_ac_driver);
         if (result < 0)
                 return -ENODEV;
 
@@ -325,7 +324,7 @@ static int __init acpi_ac_init(void)
 
 static void __exit acpi_ac_exit(void)
 {
-        platform_driver_unregister(&acpi_ac_driver);
+        acpi_bus_unregister_driver(&acpi_ac_driver);
 }
 module_init(acpi_ac_init);
 module_exit(acpi_ac_exit);
diff --git a/drivers/acpi/acpi_platform.c b/drivers/acpi/acpi_platform.c
index dbfe49e5fd63..1d4950388fa1 100644
--- a/drivers/acpi/acpi_platform.c
+++ b/drivers/acpi/acpi_platform.c
@@ -29,7 +29,6 @@ ACPI_MODULE_NAME("platform");
 static const struct acpi_device_id acpi_platform_device_ids[] = {
 
         { "PNP0D40" },
-        { "ACPI0003" },
         { "VPC2004" },
         { "BCM4752" },
 
diff --git a/drivers/acpi/acpi_processor.c b/drivers/acpi/acpi_processor.c
index b06f5f55ada9..52c81c49cc7d 100644
--- a/drivers/acpi/acpi_processor.c
+++ b/drivers/acpi/acpi_processor.c
@@ -405,7 +405,6 @@ static int acpi_processor_add(struct acpi_device *device,
                 goto err;
 
         pr->dev = dev;
-        dev->offline = pr->flags.need_hotplug_init;
 
         /* Trigger the processor driver's .probe() if present. */
         if (device_attach(dev) >= 0)
diff --git a/drivers/acpi/acpica/acglobal.h b/drivers/acpi/acpica/acglobal.h
index 49bbc71fad54..a08a448068dd 100644
--- a/drivers/acpi/acpica/acglobal.h
+++ b/drivers/acpi/acpica/acglobal.h
@@ -141,9 +141,9 @@ ACPI_INIT_GLOBAL(u8, acpi_gbl_do_not_use_xsdt, FALSE);
  * address. Although ACPICA adheres to the ACPI specification which
  * requires the use of the corresponding 64-bit address if it is non-zero,
  * some machines have been found to have a corrupted non-zero 64-bit
- * address. Default is FALSE, do not favor the 32-bit addresses.
+ * address. Default is TRUE, favor the 32-bit addresses.
  */
-ACPI_INIT_GLOBAL(u8, acpi_gbl_use32_bit_fadt_addresses, FALSE);
+ACPI_INIT_GLOBAL(u8, acpi_gbl_use32_bit_fadt_addresses, TRUE);
 
 /*
  * Optionally truncate I/O addresses to 16 bits. Provides compatibility
diff --git a/drivers/acpi/acpica/tbutils.c b/drivers/acpi/acpica/tbutils.c
index a4702eee91a8..9fb85f38de90 100644
--- a/drivers/acpi/acpica/tbutils.c
+++ b/drivers/acpi/acpica/tbutils.c
@@ -461,6 +461,7 @@ acpi_status __init acpi_tb_parse_root_table(acpi_physical_address rsdp_address)
         u32 table_count;
         struct acpi_table_header *table;
         acpi_physical_address address;
+        acpi_physical_address rsdt_address;
         u32 length;
         u8 *table_entry;
         acpi_status status;
@@ -488,11 +489,14 @@ acpi_status __init acpi_tb_parse_root_table(acpi_physical_address rsdp_address)
                  * as per the ACPI specification.
                  */
                 address = (acpi_physical_address) rsdp->xsdt_physical_address;
+                rsdt_address =
+                    (acpi_physical_address) rsdp->rsdt_physical_address;
                 table_entry_size = ACPI_XSDT_ENTRY_SIZE;
         } else {
                 /* Root table is an RSDT (32-bit physical addresses) */
 
                 address = (acpi_physical_address) rsdp->rsdt_physical_address;
+                rsdt_address = address;
                 table_entry_size = ACPI_RSDT_ENTRY_SIZE;
         }
 
@@ -515,8 +519,7 @@ acpi_status __init acpi_tb_parse_root_table(acpi_physical_address rsdp_address)
 
                         /* Fall back to the RSDT */
 
-                        address =
-                            (acpi_physical_address) rsdp->rsdt_physical_address;
+                        address = rsdt_address;
                         table_entry_size = ACPI_RSDT_ENTRY_SIZE;
                 }
         }
diff --git a/drivers/acpi/battery.c b/drivers/acpi/battery.c
index 9a2c63b20050..6e7b2a12860d 100644
--- a/drivers/acpi/battery.c
+++ b/drivers/acpi/battery.c
@@ -36,6 +36,12 @@
 #include <linux/suspend.h>
 #include <asm/unaligned.h>
 
+#ifdef CONFIG_ACPI_PROCFS_POWER
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
+#include <asm/uaccess.h>
+#endif
+
 #include <linux/acpi.h>
 #include <linux/power_supply.h>
 
@@ -64,6 +70,19 @@ static unsigned int cache_time = 1000;
 module_param(cache_time, uint, 0644);
 MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
 
+#ifdef CONFIG_ACPI_PROCFS_POWER
+extern struct proc_dir_entry *acpi_lock_battery_dir(void);
+extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);
+
+enum acpi_battery_files {
+        info_tag = 0,
+        state_tag,
+        alarm_tag,
+        ACPI_BATTERY_NUMFILES,
+};
+
+#endif
+
 static const struct acpi_device_id battery_device_ids[] = {
         {"PNP0C0A", 0},
         {"", 0},
@@ -299,6 +318,14 @@ static enum power_supply_property energy_battery_props[] = {
         POWER_SUPPLY_PROP_SERIAL_NUMBER,
 };
 
+#ifdef CONFIG_ACPI_PROCFS_POWER
+inline char *acpi_battery_units(struct acpi_battery *battery)
+{
+        return (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) ?
+                "mA" : "mW";
+}
+#endif
+
 /* --------------------------------------------------------------------------
                                Battery Management
    -------------------------------------------------------------------------- */
@@ -717,6 +744,279 @@ static void acpi_battery_refresh(struct acpi_battery *battery)
 }
 
 /* --------------------------------------------------------------------------
+                              FS Interface (/proc)
+   -------------------------------------------------------------------------- */
+
+#ifdef CONFIG_ACPI_PROCFS_POWER
+static struct proc_dir_entry *acpi_battery_dir;
+
+static int acpi_battery_print_info(struct seq_file *seq, int result)
+{
+        struct acpi_battery *battery = seq->private;
+
+        if (result)
+                goto end;
+
+        seq_printf(seq, "present:                 %s\n",
+                   acpi_battery_present(battery) ? "yes" : "no");
+        if (!acpi_battery_present(battery))
+                goto end;
+        if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
+                seq_printf(seq, "design capacity:         unknown\n");
+        else
+                seq_printf(seq, "design capacity:         %d %sh\n",
+                           battery->design_capacity,
+                           acpi_battery_units(battery));
+
+        if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
+                seq_printf(seq, "last full capacity:      unknown\n");
+        else
+                seq_printf(seq, "last full capacity:      %d %sh\n",
+                           battery->full_charge_capacity,
+                           acpi_battery_units(battery));
+
+        seq_printf(seq, "battery technology:      %srechargeable\n",
+                   (!battery->technology)?"non-":"");
+
+        if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
+                seq_printf(seq, "design voltage:          unknown\n");
+        else
+                seq_printf(seq, "design voltage:          %d mV\n",
+                           battery->design_voltage);
+        seq_printf(seq, "design capacity warning: %d %sh\n",
+                   battery->design_capacity_warning,
+                   acpi_battery_units(battery));
+        seq_printf(seq, "design capacity low:     %d %sh\n",
+                   battery->design_capacity_low,
+                   acpi_battery_units(battery));
+        seq_printf(seq, "cycle count:             %i\n", battery->cycle_count);
+        seq_printf(seq, "capacity granularity 1:  %d %sh\n",
+                   battery->capacity_granularity_1,
+                   acpi_battery_units(battery));
+        seq_printf(seq, "capacity granularity 2:  %d %sh\n",
+                   battery->capacity_granularity_2,
+                   acpi_battery_units(battery));
+        seq_printf(seq, "model number:            %s\n", battery->model_number);
+        seq_printf(seq, "serial number:           %s\n", battery->serial_number);
+        seq_printf(seq, "battery type:            %s\n", battery->type);
+        seq_printf(seq, "OEM info:                %s\n", battery->oem_info);
+      end:
+        if (result)
+                seq_printf(seq, "ERROR: Unable to read battery info\n");
+        return result;
+}
+
+static int acpi_battery_print_state(struct seq_file *seq, int result)
+{
+        struct acpi_battery *battery = seq->private;
+
+        if (result)
+                goto end;
+
+        seq_printf(seq, "present:                 %s\n",
+                   acpi_battery_present(battery) ? "yes" : "no");
+        if (!acpi_battery_present(battery))
+                goto end;
+
+        seq_printf(seq, "capacity state:          %s\n",
+                        (battery->state & 0x04) ? "critical" : "ok");
+        if ((battery->state & 0x01) && (battery->state & 0x02))
+                seq_printf(seq,
+                           "charging state:          charging/discharging\n");
+        else if (battery->state & 0x01)
+                seq_printf(seq, "charging state:          discharging\n");
+        else if (battery->state & 0x02)
+                seq_printf(seq, "charging state:          charging\n");
+        else
+                seq_printf(seq, "charging state:          charged\n");
+
+        if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
+                seq_printf(seq, "present rate:            unknown\n");
+        else
+                seq_printf(seq, "present rate:            %d %s\n",
+                           battery->rate_now, acpi_battery_units(battery));
+
+        if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
+                seq_printf(seq, "remaining capacity:      unknown\n");
+        else
+                seq_printf(seq, "remaining capacity:      %d %sh\n",
+                           battery->capacity_now, acpi_battery_units(battery));
+        if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
+                seq_printf(seq, "present voltage:         unknown\n");
+        else
+                seq_printf(seq, "present voltage:         %d mV\n",
+                           battery->voltage_now);
+      end:
+        if (result)
+                seq_printf(seq, "ERROR: Unable to read battery state\n");
+
+        return result;
+}
+
+static int acpi_battery_print_alarm(struct seq_file *seq, int result)
+{
+        struct acpi_battery *battery = seq->private;
+
+        if (result)
+                goto end;
+
+        if (!acpi_battery_present(battery)) {
+                seq_printf(seq, "present:                 no\n");
+                goto end;
+        }
+        seq_printf(seq, "alarm:                   ");
+        if (!battery->alarm)
+                seq_printf(seq, "unsupported\n");
+        else
+                seq_printf(seq, "%u %sh\n", battery->alarm,
+                                acpi_battery_units(battery));
+      end:
+        if (result)
+                seq_printf(seq, "ERROR: Unable to read battery alarm\n");
+        return result;
+}
+
+static ssize_t acpi_battery_write_alarm(struct file *file,
+                                        const char __user * buffer,
+                                        size_t count, loff_t * ppos)
+{
+        int result = 0;
+        char alarm_string[12] = { '\0' };
+        struct seq_file *m = file->private_data;
+        struct acpi_battery *battery = m->private;
+
+        if (!battery || (count > sizeof(alarm_string) - 1))
+                return -EINVAL;
+        if (!acpi_battery_present(battery)) {
+                result = -ENODEV;
+                goto end;
+        }
+        if (copy_from_user(alarm_string, buffer, count)) {
+                result = -EFAULT;
+                goto end;
+        }
+        alarm_string[count] = '\0';
+        battery->alarm = simple_strtol(alarm_string, NULL, 0);
+        result = acpi_battery_set_alarm(battery);
+      end:
+        if (!result)
+                return count;
+        return result;
+}
+
+typedef int(*print_func)(struct seq_file *seq, int result);
+
+static print_func acpi_print_funcs[ACPI_BATTERY_NUMFILES] = {
+        acpi_battery_print_info,
+        acpi_battery_print_state,
+        acpi_battery_print_alarm,
+};
+
+static int acpi_battery_read(int fid, struct seq_file *seq)
+{
+        struct acpi_battery *battery = seq->private;
+        int result = acpi_battery_update(battery);
+        return acpi_print_funcs[fid](seq, result);
+}
+
+#define DECLARE_FILE_FUNCTIONS(_name) \
+static int acpi_battery_read_##_name(struct seq_file *seq, void *offset) \
+{ \
+        return acpi_battery_read(_name##_tag, seq); \
+} \
+static int acpi_battery_##_name##_open_fs(struct inode *inode, struct file *file) \
+{ \
+        return single_open(file, acpi_battery_read_##_name, PDE_DATA(inode)); \
+}
+
+DECLARE_FILE_FUNCTIONS(info);
+DECLARE_FILE_FUNCTIONS(state);
+DECLARE_FILE_FUNCTIONS(alarm);
+
+#undef DECLARE_FILE_FUNCTIONS
+
+#define FILE_DESCRIPTION_RO(_name) \
+        { \
+        .name = __stringify(_name), \
+        .mode = S_IRUGO, \
+        .ops = { \
+                .open = acpi_battery_##_name##_open_fs, \
+                .read = seq_read, \
+                .llseek = seq_lseek, \
+                .release = single_release, \
+                .owner = THIS_MODULE, \
+                }, \
+        }
+
+#define FILE_DESCRIPTION_RW(_name) \
+        { \
+        .name = __stringify(_name), \
+        .mode = S_IFREG | S_IRUGO | S_IWUSR, \
+        .ops = { \
+                .open = acpi_battery_##_name##_open_fs, \
+                .read = seq_read, \
+                .llseek = seq_lseek, \
+                .write = acpi_battery_write_##_name, \
+                .release = single_release, \
+                .owner = THIS_MODULE, \
+                }, \
+        }
+
+static const struct battery_file {
+        struct file_operations ops;
+        umode_t mode;
+        const char *name;
+} acpi_battery_file[] = {
+        FILE_DESCRIPTION_RO(info),
+        FILE_DESCRIPTION_RO(state),
+        FILE_DESCRIPTION_RW(alarm),
+};
+
+#undef FILE_DESCRIPTION_RO
+#undef FILE_DESCRIPTION_RW
+
+static int acpi_battery_add_fs(struct acpi_device *device)
+{
+        struct proc_dir_entry *entry = NULL;
+        int i;
+
+        printk(KERN_WARNING PREFIX "Deprecated procfs I/F for battery is loaded,"
+                        " please retry with CONFIG_ACPI_PROCFS_POWER cleared\n");
+        if (!acpi_device_dir(device)) {
+                acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
+                                                     acpi_battery_dir);
+                if (!acpi_device_dir(device))
+                        return -ENODEV;
+        }
+
+        for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) {
+                entry = proc_create_data(acpi_battery_file[i].name,
+                                         acpi_battery_file[i].mode,
+                                         acpi_device_dir(device),
+                                         &acpi_battery_file[i].ops,
+                                         acpi_driver_data(device));
+                if (!entry)
+                        return -ENODEV;
+        }
+        return 0;
+}
+
+static void acpi_battery_remove_fs(struct acpi_device *device)
+{
+        int i;
+        if (!acpi_device_dir(device))
+                return;
+        for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i)
+                remove_proc_entry(acpi_battery_file[i].name,
+                                  acpi_device_dir(device));
+
+        remove_proc_entry(acpi_device_bid(device), acpi_battery_dir);
+        acpi_device_dir(device) = NULL;
+}
+
+#endif
+
+/* --------------------------------------------------------------------------
                                  Driver Interface
    -------------------------------------------------------------------------- */
 
@@ -790,6 +1090,15 @@ static int acpi_battery_add(struct acpi_device *device)
         result = acpi_battery_update(battery);
         if (result)
                 goto fail;
+#ifdef CONFIG_ACPI_PROCFS_POWER
+        result = acpi_battery_add_fs(device);
+#endif
+        if (result) {
+#ifdef CONFIG_ACPI_PROCFS_POWER
+                acpi_battery_remove_fs(device);
+#endif
+                goto fail;
+        }
 
         printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
                 ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
@@ -816,6 +1125,9 @@ static int acpi_battery_remove(struct acpi_device *device)
                 return -EINVAL;
         battery = acpi_driver_data(device);
         unregister_pm_notifier(&battery->pm_nb);
+#ifdef CONFIG_ACPI_PROCFS_POWER
+        acpi_battery_remove_fs(device);
+#endif
         sysfs_remove_battery(battery);
         mutex_destroy(&battery->lock);
         mutex_destroy(&battery->sysfs_lock);
@@ -866,7 +1178,19 @@ static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
 
         if (dmi_check_system(bat_dmi_table))
                 battery_bix_broken_package = 1;
-        acpi_bus_register_driver(&acpi_battery_driver);
+        
+#ifdef CONFIG_ACPI_PROCFS_POWER
+        acpi_battery_dir = acpi_lock_battery_dir();
+        if (!acpi_battery_dir)
+                return;
+#endif
+        if (acpi_bus_register_driver(&acpi_battery_driver) < 0) {
+#ifdef CONFIG_ACPI_PROCFS_POWER
+                acpi_unlock_battery_dir(acpi_battery_dir);
+#endif
+                return;
+        }
+        return;
 }
 
 static int __init acpi_battery_init(void)
@@ -878,6 +1202,9 @@ static int __init acpi_battery_init(void)
 static void __exit acpi_battery_exit(void)
 {
         acpi_bus_unregister_driver(&acpi_battery_driver);
+#ifdef CONFIG_ACPI_PROCFS_POWER
+        acpi_unlock_battery_dir(acpi_battery_dir);
+#endif
 }
 
 module_init(acpi_battery_init);
diff --git a/drivers/acpi/blacklist.c b/drivers/acpi/blacklist.c
index afec4526c48a..3d8413d02a97 100644
--- a/drivers/acpi/blacklist.c
+++ b/drivers/acpi/blacklist.c
@@ -314,6 +314,14 @@ static struct dmi_system_id acpi_osi_dmi_table[] __initdata = {
                      DMI_MATCH(DMI_PRODUCT_VERSION, "2349D15"),
                 },
         },
+        {
+        .callback = dmi_disable_osi_win8,
+        .ident = "Dell Inspiron 7737",
+        .matches = {
+                    DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
+                    DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 7737"),
+                },
+        },
 
         /*
          * BIOS invocation of _OSI(Linux) is almost always a BIOS bug.
@@ -374,6 +382,19 @@ static struct dmi_system_id acpi_osi_dmi_table[] __initdata = {
                      DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad T500"),
                 },
         },
+        /*
+         * Without this this EEEpc exports a non working WMI interface, with
+         * this it exports a working "good old" eeepc_laptop interface, fixing
+         * both brightness control, and rfkill not working.
+         */
+        {
+        .callback = dmi_enable_osi_linux,
+        .ident = "Asus EEE PC 1015PX",
+        .matches = {
+                     DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer INC."),
+                     DMI_MATCH(DMI_PRODUCT_NAME, "1015PX"),
+                },
+        },
         {}
 };
 
diff --git a/drivers/acpi/cm_sbs.c b/drivers/acpi/cm_sbs.c
new file mode 100644
index 000000000000..6c9ee68e46fb
--- /dev/null
+++ b/drivers/acpi/cm_sbs.c
@@ -0,0 +1,105 @@
+/*
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or (at
+ *  your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but
+ *  WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/acpi.h>
+#include <linux/types.h>
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
+#include <acpi/acpi_bus.h>
+#include <acpi/acpi_drivers.h>
+
+#define PREFIX "ACPI: "
+
+ACPI_MODULE_NAME("cm_sbs");
+#define ACPI_AC_CLASS           "ac_adapter"
+#define ACPI_BATTERY_CLASS      "battery"
+#define _COMPONENT              ACPI_SBS_COMPONENT
+static struct proc_dir_entry *acpi_ac_dir;
+static struct proc_dir_entry *acpi_battery_dir;
+
+static DEFINE_MUTEX(cm_sbs_mutex);
+
+static int lock_ac_dir_cnt;
+static int lock_battery_dir_cnt;
+
+struct proc_dir_entry *acpi_lock_ac_dir(void)
+{
+        mutex_lock(&cm_sbs_mutex);
+        if (!acpi_ac_dir)
+                acpi_ac_dir = proc_mkdir(ACPI_AC_CLASS, acpi_root_dir);
+        if (acpi_ac_dir) {
+                lock_ac_dir_cnt++;
+        } else {
+                printk(KERN_ERR PREFIX
+                                  "Cannot create %s\n", ACPI_AC_CLASS);
+        }
+        mutex_unlock(&cm_sbs_mutex);
+        return acpi_ac_dir;
+}
+EXPORT_SYMBOL(acpi_lock_ac_dir);
+
+void acpi_unlock_ac_dir(struct proc_dir_entry *acpi_ac_dir_param)
+{
+        mutex_lock(&cm_sbs_mutex);
+        if (acpi_ac_dir_param)
+                lock_ac_dir_cnt--;
+        if (lock_ac_dir_cnt == 0 && acpi_ac_dir_param && acpi_ac_dir) {
+                remove_proc_entry(ACPI_AC_CLASS, acpi_root_dir);
+                acpi_ac_dir = NULL;
+        }
+        mutex_unlock(&cm_sbs_mutex);
+}
+EXPORT_SYMBOL(acpi_unlock_ac_dir);
+
+struct proc_dir_entry *acpi_lock_battery_dir(void)
+{
+        mutex_lock(&cm_sbs_mutex);
+        if (!acpi_battery_dir) {
+                acpi_battery_dir =
+                    proc_mkdir(ACPI_BATTERY_CLASS, acpi_root_dir);
+        }
+        if (acpi_battery_dir) {
+                lock_battery_dir_cnt++;
+        } else {
+                printk(KERN_ERR PREFIX
+                                  "Cannot create %s\n", ACPI_BATTERY_CLASS);
+        }
+        mutex_unlock(&cm_sbs_mutex);
+        return acpi_battery_dir;
+}
+EXPORT_SYMBOL(acpi_lock_battery_dir);
+
+void acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir_param)
+{
+        mutex_lock(&cm_sbs_mutex);
+        if (acpi_battery_dir_param)
+                lock_battery_dir_cnt--;
+        if (lock_battery_dir_cnt == 0 && acpi_battery_dir_param
+            && acpi_battery_dir) {
+                remove_proc_entry(ACPI_BATTERY_CLASS, acpi_root_dir);
+                acpi_battery_dir = NULL;
+        }
+        mutex_unlock(&cm_sbs_mutex);
+        return;
+}
+EXPORT_SYMBOL(acpi_unlock_battery_dir);
diff --git a/drivers/acpi/video.c b/drivers/acpi/video.c
index 8b6990e417ec..f8bc5a755dda 100644
--- a/drivers/acpi/video.c
+++ b/drivers/acpi/video.c
@@ -457,10 +457,10 @@ static struct dmi_system_id video_dmi_table[] __initdata = {
         },
         {
          .callback = video_set_use_native_backlight,
-         .ident = "ThinkPad T430s",
+         .ident = "ThinkPad T430 and T430s",
          .matches = {
                 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
-                DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad T430s"),
+                DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad T430"),
                 },
         },
         {
@@ -472,7 +472,7 @@ static struct dmi_system_id video_dmi_table[] __initdata = {
                 },
         },
         {
-        .callback = video_set_use_native_backlight,
+         .callback = video_set_use_native_backlight,
         .ident = "ThinkPad X1 Carbon",
         .matches = {
                 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
@@ -500,7 +500,7 @@ static struct dmi_system_id video_dmi_table[] __initdata = {
          .ident = "Dell Inspiron 7520",
          .matches = {
                 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
-                DMI_MATCH(DMI_PRODUCT_VERSION, "Inspiron 7520"),
+                DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 7520"),
                 },
         },
         {
@@ -513,6 +513,14 @@ static struct dmi_system_id video_dmi_table[] __initdata = {
         },
         {
          .callback = video_set_use_native_backlight,
+         .ident = "Acer Aspire 5742G",
+         .matches = {
+                DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+                DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5742G"),
+                },
+        },
+        {
+         .callback = video_set_use_native_backlight,
          .ident = "Acer Aspire V5-431",
          .matches = {
                 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
diff --git a/drivers/ata/Kconfig b/drivers/ata/Kconfig
index c2706047337f..0033fafc470b 100644
--- a/drivers/ata/Kconfig
+++ b/drivers/ata/Kconfig
@@ -815,7 +815,7 @@ config PATA_AT32
 
 config PATA_AT91
         tristate "PATA support for AT91SAM9260"
-        depends on ARM && ARCH_AT91
+        depends on ARM && SOC_AT91SAM9
         help
           This option enables support for IDE devices on the Atmel AT91SAM9260 SoC.
 
diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c
index 71e15b73513d..60707814a84b 100644
--- a/drivers/ata/ahci.c
+++ b/drivers/ata/ahci.c
@@ -1115,6 +1115,17 @@ static bool ahci_broken_online(struct pci_dev *pdev)
         return pdev->bus->number == (val >> 8) && pdev->devfn == (val & 0xff);
 }
 
+static bool ahci_broken_devslp(struct pci_dev *pdev)
+{
+        /* device with broken DEVSLP but still showing SDS capability */
+        static const struct pci_device_id ids[] = {
+                { PCI_VDEVICE(INTEL, 0x0f23)}, /* Valleyview SoC */
+                {}
+        };
+
+        return pci_match_id(ids, pdev);
+}
+
 #ifdef CONFIG_ATA_ACPI
 static void ahci_gtf_filter_workaround(struct ata_host *host)
 {
@@ -1364,6 +1375,10 @@ static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 
         hpriv->mmio = pcim_iomap_table(pdev)[ahci_pci_bar];
 
+        /* must set flag prior to save config in order to take effect */
+        if (ahci_broken_devslp(pdev))
+                hpriv->flags |= AHCI_HFLAG_NO_DEVSLP;
+
         /* save initial config */
         ahci_pci_save_initial_config(pdev, hpriv);
 
diff --git a/drivers/ata/ahci.h b/drivers/ata/ahci.h
index b5eb886da226..af63c75c2001 100644
--- a/drivers/ata/ahci.h
+++ b/drivers/ata/ahci.h
@@ -236,6 +236,7 @@ enum {
                                                         port start (wait until
                                                         error-handling stage) */
         AHCI_HFLAG_MULTI_MSI            = (1 << 16), /* multiple PCI MSIs */
+        AHCI_HFLAG_NO_DEVSLP            = (1 << 17), /* no device sleep */
 
         /* ap->flags bits */
 
diff --git a/drivers/ata/ahci_imx.c b/drivers/ata/ahci_imx.c
index 497c7abe1c7d..8befeb69eeb1 100644
--- a/drivers/ata/ahci_imx.c
+++ b/drivers/ata/ahci_imx.c
@@ -29,9 +29,25 @@
 #include "ahci.h"
 
 enum {
-        PORT_PHY_CTL = 0x178,                   /* Port0 PHY Control */
-        PORT_PHY_CTL_PDDQ_LOC = 0x100000,       /* PORT_PHY_CTL bits */
-        HOST_TIMER1MS = 0xe0,                   /* Timer 1-ms */
+        /* Timer 1-ms Register */
+        IMX_TIMER1MS                            = 0x00e0,
+        /* Port0 PHY Control Register */
+        IMX_P0PHYCR                             = 0x0178,
+        IMX_P0PHYCR_TEST_PDDQ                   = 1 << 20,
+        IMX_P0PHYCR_CR_READ                     = 1 << 19,
+        IMX_P0PHYCR_CR_WRITE                    = 1 << 18,
+        IMX_P0PHYCR_CR_CAP_DATA                 = 1 << 17,
+        IMX_P0PHYCR_CR_CAP_ADDR                 = 1 << 16,
+        /* Port0 PHY Status Register */
+        IMX_P0PHYSR                             = 0x017c,
+        IMX_P0PHYSR_CR_ACK                      = 1 << 18,
+        IMX_P0PHYSR_CR_DATA_OUT                 = 0xffff << 0,
+        /* Lane0 Output Status Register */
+        IMX_LANE0_OUT_STAT                      = 0x2003,
+        IMX_LANE0_OUT_STAT_RX_PLL_STATE         = 1 << 1,
+        /* Clock Reset Register */
+        IMX_CLOCK_RESET                         = 0x7f3f,
+        IMX_CLOCK_RESET_RESET                   = 1 << 0,
 };
 
 enum ahci_imx_type {
@@ -54,9 +70,149 @@ MODULE_PARM_DESC(hotplug, "AHCI IMX hot-plug support (0=Don't support, 1=support
 
 static void ahci_imx_host_stop(struct ata_host *host);
 
+static int imx_phy_crbit_assert(void __iomem *mmio, u32 bit, bool assert)
+{
+        int timeout = 10;
+        u32 crval;
+        u32 srval;
+
+        /* Assert or deassert the bit */
+        crval = readl(mmio + IMX_P0PHYCR);
+        if (assert)
+                crval |= bit;
+        else
+                crval &= ~bit;
+        writel(crval, mmio + IMX_P0PHYCR);
+
+        /* Wait for the cr_ack signal */
+        do {
+                srval = readl(mmio + IMX_P0PHYSR);
+                if ((assert ? srval : ~srval) & IMX_P0PHYSR_CR_ACK)
+                        break;
+                usleep_range(100, 200);
+        } while (--timeout);
+
+        return timeout ? 0 : -ETIMEDOUT;
+}
+
+static int imx_phy_reg_addressing(u16 addr, void __iomem *mmio)
+{
+        u32 crval = addr;
+        int ret;
+
+        /* Supply the address on cr_data_in */
+        writel(crval, mmio + IMX_P0PHYCR);
+
+        /* Assert the cr_cap_addr signal */
+        ret = imx_phy_crbit_assert(mmio, IMX_P0PHYCR_CR_CAP_ADDR, true);
+        if (ret)
+                return ret;
+
+        /* Deassert cr_cap_addr */
+        ret = imx_phy_crbit_assert(mmio, IMX_P0PHYCR_CR_CAP_ADDR, false);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static int imx_phy_reg_write(u16 val, void __iomem *mmio)
+{
+        u32 crval = val;
+        int ret;
+
+        /* Supply the data on cr_data_in */
+        writel(crval, mmio + IMX_P0PHYCR);
+
+        /* Assert the cr_cap_data signal */
+        ret = imx_phy_crbit_assert(mmio, IMX_P0PHYCR_CR_CAP_DATA, true);
+        if (ret)
+                return ret;
+
+        /* Deassert cr_cap_data */
+        ret = imx_phy_crbit_assert(mmio, IMX_P0PHYCR_CR_CAP_DATA, false);
+        if (ret)
+                return ret;
+
+        if (val & IMX_CLOCK_RESET_RESET) {
+                /*
+                 * In case we're resetting the phy, it's unable to acknowledge,
+                 * so we return immediately here.
+                 */
+                crval |= IMX_P0PHYCR_CR_WRITE;
+                writel(crval, mmio + IMX_P0PHYCR);
+                goto out;
+        }
+
+        /* Assert the cr_write signal */
+        ret = imx_phy_crbit_assert(mmio, IMX_P0PHYCR_CR_WRITE, true);
+        if (ret)
+                return ret;
+
+        /* Deassert cr_write */
+        ret = imx_phy_crbit_assert(mmio, IMX_P0PHYCR_CR_WRITE, false);
+        if (ret)
+                return ret;
+
+out:
+        return 0;
+}
+
+static int imx_phy_reg_read(u16 *val, void __iomem *mmio)
+{
+        int ret;
+
+        /* Assert the cr_read signal */
+        ret = imx_phy_crbit_assert(mmio, IMX_P0PHYCR_CR_READ, true);
+        if (ret)
+                return ret;
+
+        /* Capture the data from cr_data_out[] */
+        *val = readl(mmio + IMX_P0PHYSR) & IMX_P0PHYSR_CR_DATA_OUT;
+
+        /* Deassert cr_read */
+        ret = imx_phy_crbit_assert(mmio, IMX_P0PHYCR_CR_READ, false);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static int imx_sata_phy_reset(struct ahci_host_priv *hpriv)
+{
+        void __iomem *mmio = hpriv->mmio;
+        int timeout = 10;
+        u16 val;
+        int ret;
+
+        /* Reset SATA PHY by setting RESET bit of PHY register CLOCK_RESET */
+        ret = imx_phy_reg_addressing(IMX_CLOCK_RESET, mmio);
+        if (ret)
+                return ret;
+        ret = imx_phy_reg_write(IMX_CLOCK_RESET_RESET, mmio);
+        if (ret)
+                return ret;
+
+        /* Wait for PHY RX_PLL to be stable */
+        do {
+                usleep_range(100, 200);
+                ret = imx_phy_reg_addressing(IMX_LANE0_OUT_STAT, mmio);
+                if (ret)
+                        return ret;
+                ret = imx_phy_reg_read(&val, mmio);
+                if (ret)
+                        return ret;
+                if (val & IMX_LANE0_OUT_STAT_RX_PLL_STATE)
+                        break;
+        } while (--timeout);
+
+        return timeout ? 0 : -ETIMEDOUT;
+}
+
 static int imx_sata_enable(struct ahci_host_priv *hpriv)
 {
         struct imx_ahci_priv *imxpriv = hpriv->plat_data;
+        struct device *dev = &imxpriv->ahci_pdev->dev;
         int ret;
 
         if (imxpriv->no_device)
@@ -101,6 +257,14 @@ static int imx_sata_enable(struct ahci_host_priv *hpriv)
                 regmap_update_bits(imxpriv->gpr, IOMUXC_GPR13,
                                    IMX6Q_GPR13_SATA_MPLL_CLK_EN,
                                    IMX6Q_GPR13_SATA_MPLL_CLK_EN);
+
+                usleep_range(100, 200);
+
+                ret = imx_sata_phy_reset(hpriv);
+                if (ret) {
+                        dev_err(dev, "failed to reset phy: %d\n", ret);
+                        goto disable_regulator;
+                }
         }
 
         usleep_range(1000, 2000);
@@ -156,8 +320,8 @@ static void ahci_imx_error_handler(struct ata_port *ap)
          * without full reset once the pddq mode is enabled making it
          * impossible to use as part of libata LPM.
          */
-        reg_val = readl(mmio + PORT_PHY_CTL);
-        writel(reg_val | PORT_PHY_CTL_PDDQ_LOC, mmio + PORT_PHY_CTL);
+        reg_val = readl(mmio + IMX_P0PHYCR);
+        writel(reg_val | IMX_P0PHYCR_TEST_PDDQ, mmio + IMX_P0PHYCR);
         imx_sata_disable(hpriv);
         imxpriv->no_device = true;
 }
@@ -217,6 +381,7 @@ static int imx_ahci_probe(struct platform_device *pdev)
         if (!imxpriv)
                 return -ENOMEM;
 
+        imxpriv->ahci_pdev = pdev;
         imxpriv->no_device = false;
         imxpriv->first_time = true;
         imxpriv->type = (enum ahci_imx_type)of_id->data;
@@ -248,7 +413,7 @@ static int imx_ahci_probe(struct platform_device *pdev)
 
         /*
          * Configure the HWINIT bits of the HOST_CAP and HOST_PORTS_IMPL,
-         * and IP vendor specific register HOST_TIMER1MS.
+         * and IP vendor specific register IMX_TIMER1MS.
          * Configure CAP_SSS (support stagered spin up).
          * Implement the port0.
          * Get the ahb clock rate, and configure the TIMER1MS register.
@@ -265,7 +430,7 @@ static int imx_ahci_probe(struct platform_device *pdev)
         }
 
         reg_val = clk_get_rate(imxpriv->ahb_clk) / 1000;
-        writel(reg_val, hpriv->mmio + HOST_TIMER1MS);
+        writel(reg_val, hpriv->mmio + IMX_TIMER1MS);
 
         ret = ahci_platform_init_host(pdev, hpriv, &ahci_imx_port_info, 0, 0);
         if (ret)
diff --git a/drivers/ata/libahci.c b/drivers/ata/libahci.c
index 6bd4f660b4e1..b9861453fc81 100644
--- a/drivers/ata/libahci.c
+++ b/drivers/ata/libahci.c
@@ -452,6 +452,13 @@ void ahci_save_initial_config(struct device *dev,
                 cap &= ~HOST_CAP_SNTF;
         }
 
+        if ((cap2 & HOST_CAP2_SDS) && (hpriv->flags & AHCI_HFLAG_NO_DEVSLP)) {
+                dev_info(dev,
+                         "controller can't do DEVSLP, turning off\n");
+                cap2 &= ~HOST_CAP2_SDS;
+                cap2 &= ~HOST_CAP2_SADM;
+        }
+
         if (!(cap & HOST_CAP_FBS) && (hpriv->flags & AHCI_HFLAG_YES_FBS)) {
                 dev_info(dev, "controller can do FBS, turning on CAP_FBS\n");
                 cap |= HOST_CAP_FBS;
diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index 943cc8b83e59..ea83828bfea9 100644
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -6314,6 +6314,8 @@ int ata_host_activate(struct ata_host *host, int irq,
 static void ata_port_detach(struct ata_port *ap)
 {
         unsigned long flags;
+        struct ata_link *link;
+        struct ata_device *dev;
 
         if (!ap->ops->error_handler)
                 goto skip_eh;
@@ -6333,6 +6335,13 @@ static void ata_port_detach(struct ata_port *ap)
         cancel_delayed_work_sync(&ap->hotplug_task);
 
  skip_eh:
+        /* clean up zpodd on port removal */
+        ata_for_each_link(link, ap, HOST_FIRST) {
+                ata_for_each_dev(dev, link, ALL) {
+                        if (zpodd_dev_enabled(dev))
+                                zpodd_exit(dev);
+                }
+        }
         if (ap->pmp_link) {
                 int i;
                 for (i = 0; i < SATA_PMP_MAX_PORTS; i++)
diff --git a/drivers/bus/mvebu-mbus.c b/drivers/bus/mvebu-mbus.c
index 293e2e0a0a87..00b73448b22e 100644
--- a/drivers/bus/mvebu-mbus.c
+++ b/drivers/bus/mvebu-mbus.c
@@ -56,6 +56,7 @@
 #include <linux/of.h>
 #include <linux/of_address.h>
 #include <linux/debugfs.h>
+#include <linux/log2.h>
 
 /*
  * DDR target is the same on all platforms.
@@ -222,12 +223,6 @@ static int mvebu_mbus_window_conflicts(struct mvebu_mbus_state *mbus,
                  */
                 if ((u64)base < wend && end > wbase)
                         return 0;
-
-                /*
-                 * Check if target/attribute conflicts
-                 */
-                if (target == wtarget && attr == wattr)
-                        return 0;
         }
 
         return 1;
@@ -266,6 +261,17 @@ static int mvebu_mbus_setup_window(struct mvebu_mbus_state *mbus,
                 mbus->soc->win_cfg_offset(win);
         u32 ctrl, remap_addr;
 
+        if (!is_power_of_2(size)) {
+                WARN(true, "Invalid MBus window size: 0x%zx\n", size);
+                return -EINVAL;
+        }
+
+        if ((base & (phys_addr_t)(size - 1)) != 0) {
+                WARN(true, "Invalid MBus base/size: %pa len 0x%zx\n", &base,
+                     size);
+                return -EINVAL;
+        }
+
         ctrl = ((size - 1) & WIN_CTRL_SIZE_MASK) |
                 (attr << WIN_CTRL_ATTR_SHIFT)    |
                 (target << WIN_CTRL_TGT_SHIFT)   |
@@ -413,6 +419,10 @@ static int mvebu_devs_debug_show(struct seq_file *seq, void *v)
                            win, (unsigned long long)wbase,
                            (unsigned long long)(wbase + wsize), wtarget, wattr);
 
+                if (!is_power_of_2(wsize) ||
+                    ((wbase & (u64)(wsize - 1)) != 0))
+                        seq_puts(seq, " (Invalid base/size!!)");
+
                 if (win < mbus->soc->num_remappable_wins) {
                         seq_printf(seq, " (remap %016llx)\n",
                                    (unsigned long long)wremap);
diff --git a/drivers/char/random.c b/drivers/char/random.c
index 6b75713d953a..102c50d38902 100644
--- a/drivers/char/random.c
+++ b/drivers/char/random.c
@@ -995,8 +995,11 @@ retry:
                 ibytes = min_t(size_t, ibytes, have_bytes - reserved);
         if (ibytes < min)
                 ibytes = 0;
-        entropy_count = max_t(int, 0,
-                              entropy_count - (ibytes << (ENTROPY_SHIFT + 3)));
+        if (have_bytes >= ibytes + reserved)
+                entropy_count -= ibytes << (ENTROPY_SHIFT + 3);
+        else
+                entropy_count = reserved << (ENTROPY_SHIFT + 3);
+
         if (cmpxchg(&r->entropy_count, orig, entropy_count) != orig)
                 goto retry;
 
diff --git a/drivers/char/tpm/tpm_ppi.c b/drivers/char/tpm/tpm_ppi.c
index b3ea223585bd..61dcc8011ec7 100644
--- a/drivers/char/tpm/tpm_ppi.c
+++ b/drivers/char/tpm/tpm_ppi.c
@@ -328,13 +328,11 @@ int tpm_add_ppi(struct kobject *parent)
         /* Cache TPM ACPI handle and version string */
         acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX,
                             ppi_callback, NULL, NULL, &tpm_ppi_handle);
-        if (tpm_ppi_handle == NULL)
-                return -ENODEV;
-
-        return sysfs_create_group(parent, &ppi_attr_grp);
+        return tpm_ppi_handle ? sysfs_create_group(parent, &ppi_attr_grp) : 0;
 }
 
 void tpm_remove_ppi(struct kobject *parent)
 {
-        sysfs_remove_group(parent, &ppi_attr_grp);
+        if (tpm_ppi_handle)
+                sysfs_remove_group(parent, &ppi_attr_grp);
 }
diff --git a/drivers/clk/bcm/clk-kona-setup.c b/drivers/clk/bcm/clk-kona-setup.c
index c7607feb18dd..54a06526f64f 100644
--- a/drivers/clk/bcm/clk-kona-setup.c
+++ b/drivers/clk/bcm/clk-kona-setup.c
@@ -27,7 +27,7 @@ LIST_HEAD(ccu_list);	/* The list of set up CCUs */
 
 static bool clk_requires_trigger(struct kona_clk *bcm_clk)
 {
-        struct peri_clk_data *peri = bcm_clk->peri;
+        struct peri_clk_data *peri = bcm_clk->u.peri;
         struct bcm_clk_sel *sel;
         struct bcm_clk_div *div;
 
@@ -63,7 +63,7 @@ static bool peri_clk_data_offsets_valid(struct kona_clk *bcm_clk)
         u32 limit;
 
         BUG_ON(bcm_clk->type != bcm_clk_peri);
-        peri = bcm_clk->peri;
+        peri = bcm_clk->u.peri;
         name = bcm_clk->name;
         range = bcm_clk->ccu->range;
 
@@ -81,19 +81,19 @@ static bool peri_clk_data_offsets_valid(struct kona_clk *bcm_clk)
 
         div = &peri->div;
         if (divider_exists(div)) {
-                if (div->offset > limit) {
+                if (div->u.s.offset > limit) {
                         pr_err("%s: bad divider offset for %s (%u > %u)\n",
-                                __func__, name, div->offset, limit);
+                                __func__, name, div->u.s.offset, limit);
                         return false;
                 }
         }
 
         div = &peri->pre_div;
         if (divider_exists(div)) {
-                if (div->offset > limit) {
+                if (div->u.s.offset > limit) {
                         pr_err("%s: bad pre-divider offset for %s "
                                         "(%u > %u)\n",
-                                __func__, name, div->offset, limit);
+                                __func__, name, div->u.s.offset, limit);
                         return false;
                 }
         }
@@ -249,21 +249,22 @@ static bool div_valid(struct bcm_clk_div *div, const char *field_name,
 {
         if (divider_is_fixed(div)) {
                 /* Any fixed divider value but 0 is OK */
-                if (div->fixed == 0) {
+                if (div->u.fixed == 0) {
                         pr_err("%s: bad %s fixed value 0 for %s\n", __func__,
                                 field_name, clock_name);
                         return false;
                 }
                 return true;
         }
-        if (!bitfield_valid(div->shift, div->width, field_name, clock_name))
+        if (!bitfield_valid(div->u.s.shift, div->u.s.width,
+                                field_name, clock_name))
                 return false;
 
         if (divider_has_fraction(div))
-                if (div->frac_width > div->width) {
+                if (div->u.s.frac_width > div->u.s.width) {
                         pr_warn("%s: bad %s fraction width for %s (%u > %u)\n",
                                 __func__, field_name, clock_name,
-                                div->frac_width, div->width);
+                                div->u.s.frac_width, div->u.s.width);
                         return false;
                 }
 
@@ -278,7 +279,7 @@ static bool div_valid(struct bcm_clk_div *div, const char *field_name,
  */
 static bool kona_dividers_valid(struct kona_clk *bcm_clk)
 {
-        struct peri_clk_data *peri = bcm_clk->peri;
+        struct peri_clk_data *peri = bcm_clk->u.peri;
         struct bcm_clk_div *div;
         struct bcm_clk_div *pre_div;
         u32 limit;
@@ -295,7 +296,7 @@ static bool kona_dividers_valid(struct kona_clk *bcm_clk)
 
         limit = BITS_PER_BYTE * sizeof(u32);
 
-        return div->frac_width + pre_div->frac_width <= limit;
+        return div->u.s.frac_width + pre_div->u.s.frac_width <= limit;
 }
 
 
@@ -328,7 +329,7 @@ peri_clk_data_valid(struct kona_clk *bcm_clk)
         if (!peri_clk_data_offsets_valid(bcm_clk))
                 return false;
 
-        peri = bcm_clk->peri;
+        peri = bcm_clk->u.peri;
         name = bcm_clk->name;
         gate = &peri->gate;
         if (gate_exists(gate) && !gate_valid(gate, "gate", name))
@@ -588,12 +589,12 @@ static void bcm_clk_teardown(struct kona_clk *bcm_clk)
 {
         switch (bcm_clk->type) {
         case bcm_clk_peri:
-                peri_clk_teardown(bcm_clk->data, &bcm_clk->init_data);
+                peri_clk_teardown(bcm_clk->u.data, &bcm_clk->init_data);
                 break;
         default:
                 break;
         }
-        bcm_clk->data = NULL;
+        bcm_clk->u.data = NULL;
         bcm_clk->type = bcm_clk_none;
 }
 
@@ -644,7 +645,7 @@ struct clk *kona_clk_setup(struct ccu_data *ccu, const char *name,
                 break;
         }
         bcm_clk->type = type;
-        bcm_clk->data = data;
+        bcm_clk->u.data = data;
 
         /* Make sure everything makes sense before we set it up */
         if (!kona_clk_valid(bcm_clk)) {
diff --git a/drivers/clk/bcm/clk-kona.c b/drivers/clk/bcm/clk-kona.c
index e3d339e08309..db11a87449f2 100644
--- a/drivers/clk/bcm/clk-kona.c
+++ b/drivers/clk/bcm/clk-kona.c
@@ -61,7 +61,7 @@ u64 do_div_round_closest(u64 dividend, unsigned long divisor)
 /* Convert a divider into the scaled divisor value it represents. */
 static inline u64 scaled_div_value(struct bcm_clk_div *div, u32 reg_div)
 {
-        return (u64)reg_div + ((u64)1 << div->frac_width);
+        return (u64)reg_div + ((u64)1 << div->u.s.frac_width);
 }
 
 /*
@@ -77,7 +77,7 @@ u64 scaled_div_build(struct bcm_clk_div *div, u32 div_value, u32 billionths)
         BUG_ON(billionths >= BILLION);
 
         combined = (u64)div_value * BILLION + billionths;
-        combined <<= div->frac_width;
+        combined <<= div->u.s.frac_width;
 
         return do_div_round_closest(combined, BILLION);
 }
@@ -87,7 +87,7 @@ static inline u64
 scaled_div_min(struct bcm_clk_div *div)
 {
         if (divider_is_fixed(div))
-                return (u64)div->fixed;
+                return (u64)div->u.fixed;
 
         return scaled_div_value(div, 0);
 }
@@ -98,9 +98,9 @@ u64 scaled_div_max(struct bcm_clk_div *div)
         u32 reg_div;
 
         if (divider_is_fixed(div))
-                return (u64)div->fixed;
+                return (u64)div->u.fixed;
 
-        reg_div = ((u32)1 << div->width) - 1;
+        reg_div = ((u32)1 << div->u.s.width) - 1;
 
         return scaled_div_value(div, reg_div);
 }
@@ -115,7 +115,7 @@ divider(struct bcm_clk_div *div, u64 scaled_div)
         BUG_ON(scaled_div < scaled_div_min(div));
         BUG_ON(scaled_div > scaled_div_max(div));
 
-        return (u32)(scaled_div - ((u64)1 << div->frac_width));
+        return (u32)(scaled_div - ((u64)1 << div->u.s.frac_width));
 }
 
 /* Return a rate scaled for use when dividing by a scaled divisor. */
@@ -125,7 +125,7 @@ scale_rate(struct bcm_clk_div *div, u32 rate)
         if (divider_is_fixed(div))
                 return (u64)rate;
 
-        return (u64)rate << div->frac_width;
+        return (u64)rate << div->u.s.frac_width;
 }
 
 /* CCU access */
@@ -398,14 +398,14 @@ static u64 divider_read_scaled(struct ccu_data *ccu, struct bcm_clk_div *div)
         u32 reg_div;
 
         if (divider_is_fixed(div))
-                return (u64)div->fixed;
+                return (u64)div->u.fixed;
 
         flags = ccu_lock(ccu);
-        reg_val = __ccu_read(ccu, div->offset);
+        reg_val = __ccu_read(ccu, div->u.s.offset);
         ccu_unlock(ccu, flags);
 
         /* Extract the full divider field from the register value */
-        reg_div = bitfield_extract(reg_val, div->shift, div->width);
+        reg_div = bitfield_extract(reg_val, div->u.s.shift, div->u.s.width);
 
         /* Return the scaled divisor value it represents */
         return scaled_div_value(div, reg_div);
@@ -433,16 +433,17 @@ static int __div_commit(struct ccu_data *ccu, struct bcm_clk_gate *gate,
          * state was defined in the device tree, we just find out
          * what its current value is rather than updating it.
          */
-        if (div->scaled_div == BAD_SCALED_DIV_VALUE) {
-                reg_val = __ccu_read(ccu, div->offset);
-                reg_div = bitfield_extract(reg_val, div->shift, div->width);
-                div->scaled_div = scaled_div_value(div, reg_div);
+        if (div->u.s.scaled_div == BAD_SCALED_DIV_VALUE) {
+                reg_val = __ccu_read(ccu, div->u.s.offset);
+                reg_div = bitfield_extract(reg_val, div->u.s.shift,
+                                                div->u.s.width);
+                div->u.s.scaled_div = scaled_div_value(div, reg_div);
 
                 return 0;
         }
 
         /* Convert the scaled divisor to the value we need to record */
-        reg_div = divider(div, div->scaled_div);
+        reg_div = divider(div, div->u.s.scaled_div);
 
         /* Clock needs to be enabled before changing the rate */
         enabled = __is_clk_gate_enabled(ccu, gate);
@@ -452,9 +453,10 @@ static int __div_commit(struct ccu_data *ccu, struct bcm_clk_gate *gate,
         }
 
         /* Replace the divider value and record the result */
-        reg_val = __ccu_read(ccu, div->offset);
-        reg_val = bitfield_replace(reg_val, div->shift, div->width, reg_div);
-        __ccu_write(ccu, div->offset, reg_val);
+        reg_val = __ccu_read(ccu, div->u.s.offset);
+        reg_val = bitfield_replace(reg_val, div->u.s.shift, div->u.s.width,
+                                        reg_div);
+        __ccu_write(ccu, div->u.s.offset, reg_val);
 
         /* If the trigger fails we still want to disable the gate */
         if (!__clk_trigger(ccu, trig))
@@ -490,11 +492,11 @@ static int divider_write(struct ccu_data *ccu, struct bcm_clk_gate *gate,
 
         BUG_ON(divider_is_fixed(div));
 
-        previous = div->scaled_div;
+        previous = div->u.s.scaled_div;
         if (previous == scaled_div)
                 return 0;       /* No change */
 
-        div->scaled_div = scaled_div;
+        div->u.s.scaled_div = scaled_div;
 
         flags = ccu_lock(ccu);
         __ccu_write_enable(ccu);
@@ -505,7 +507,7 @@ static int divider_write(struct ccu_data *ccu, struct bcm_clk_gate *gate,
         ccu_unlock(ccu, flags);
 
         if (ret)
-                div->scaled_div = previous;             /* Revert the change */
+                div->u.s.scaled_div = previous;         /* Revert the change */
 
         return ret;
 
@@ -802,7 +804,7 @@ static int selector_write(struct ccu_data *ccu, struct bcm_clk_gate *gate,
 static int kona_peri_clk_enable(struct clk_hw *hw)
 {
         struct kona_clk *bcm_clk = to_kona_clk(hw);
-        struct bcm_clk_gate *gate = &bcm_clk->peri->gate;
+        struct bcm_clk_gate *gate = &bcm_clk->u.peri->gate;
 
         return clk_gate(bcm_clk->ccu, bcm_clk->name, gate, true);
 }
@@ -810,7 +812,7 @@ static int kona_peri_clk_enable(struct clk_hw *hw)
 static void kona_peri_clk_disable(struct clk_hw *hw)
 {
         struct kona_clk *bcm_clk = to_kona_clk(hw);
-        struct bcm_clk_gate *gate = &bcm_clk->peri->gate;
+        struct bcm_clk_gate *gate = &bcm_clk->u.peri->gate;
 
         (void)clk_gate(bcm_clk->ccu, bcm_clk->name, gate, false);
 }
@@ -818,7 +820,7 @@ static void kona_peri_clk_disable(struct clk_hw *hw)
 static int kona_peri_clk_is_enabled(struct clk_hw *hw)
 {
         struct kona_clk *bcm_clk = to_kona_clk(hw);
-        struct bcm_clk_gate *gate = &bcm_clk->peri->gate;
+        struct bcm_clk_gate *gate = &bcm_clk->u.peri->gate;
 
         return is_clk_gate_enabled(bcm_clk->ccu, gate) ? 1 : 0;
 }
@@ -827,7 +829,7 @@ static unsigned long kona_peri_clk_recalc_rate(struct clk_hw *hw,
                         unsigned long parent_rate)
 {
         struct kona_clk *bcm_clk = to_kona_clk(hw);
-        struct peri_clk_data *data = bcm_clk->peri;
+        struct peri_clk_data *data = bcm_clk->u.peri;
 
         return clk_recalc_rate(bcm_clk->ccu, &data->div, &data->pre_div,
                                 parent_rate);
@@ -837,20 +839,20 @@ static long kona_peri_clk_round_rate(struct clk_hw *hw, unsigned long rate,
                         unsigned long *parent_rate)
 {
         struct kona_clk *bcm_clk = to_kona_clk(hw);
-        struct bcm_clk_div *div = &bcm_clk->peri->div;
+        struct bcm_clk_div *div = &bcm_clk->u.peri->div;
 
         if (!divider_exists(div))
                 return __clk_get_rate(hw->clk);
 
         /* Quietly avoid a zero rate */
-        return round_rate(bcm_clk->ccu, div, &bcm_clk->peri->pre_div,
+        return round_rate(bcm_clk->ccu, div, &bcm_clk->u.peri->pre_div,
                                 rate ? rate : 1, *parent_rate, NULL);
 }
 
 static int kona_peri_clk_set_parent(struct clk_hw *hw, u8 index)
 {
         struct kona_clk *bcm_clk = to_kona_clk(hw);
-        struct peri_clk_data *data = bcm_clk->peri;
+        struct peri_clk_data *data = bcm_clk->u.peri;
         struct bcm_clk_sel *sel = &data->sel;
         struct bcm_clk_trig *trig;
         int ret;
@@ -884,7 +886,7 @@ static int kona_peri_clk_set_parent(struct clk_hw *hw, u8 index)
 static u8 kona_peri_clk_get_parent(struct clk_hw *hw)
 {
         struct kona_clk *bcm_clk = to_kona_clk(hw);
-        struct peri_clk_data *data = bcm_clk->peri;
+        struct peri_clk_data *data = bcm_clk->u.peri;
         u8 index;
 
         index = selector_read_index(bcm_clk->ccu, &data->sel);
@@ -897,7 +899,7 @@ static int kona_peri_clk_set_rate(struct clk_hw *hw, unsigned long rate,
                         unsigned long parent_rate)
 {
         struct kona_clk *bcm_clk = to_kona_clk(hw);
-        struct peri_clk_data *data = bcm_clk->peri;
+        struct peri_clk_data *data = bcm_clk->u.peri;
         struct bcm_clk_div *div = &data->div;
         u64 scaled_div = 0;
         int ret;
@@ -958,7 +960,7 @@ struct clk_ops kona_peri_clk_ops = {
 static bool __peri_clk_init(struct kona_clk *bcm_clk)
 {
         struct ccu_data *ccu = bcm_clk->ccu;
-        struct peri_clk_data *peri = bcm_clk->peri;
+        struct peri_clk_data *peri = bcm_clk->u.peri;
         const char *name = bcm_clk->name;
         struct bcm_clk_trig *trig;
 
diff --git a/drivers/clk/bcm/clk-kona.h b/drivers/clk/bcm/clk-kona.h
index 5e139adc3dc5..dee690951bb6 100644
--- a/drivers/clk/bcm/clk-kona.h
+++ b/drivers/clk/bcm/clk-kona.h
@@ -57,7 +57,7 @@
 #define divider_exists(div)             FLAG_TEST(div, DIV, EXISTS)
 #define divider_is_fixed(div)           FLAG_TEST(div, DIV, FIXED)
 #define divider_has_fraction(div)       (!divider_is_fixed(div) && \
-                                                (div)->frac_width > 0)
+                                                (div)->u.s.frac_width > 0)
 
 #define selector_exists(sel)            ((sel)->width != 0)
 #define trigger_exists(trig)            FLAG_TEST(trig, TRIG, EXISTS)
@@ -244,9 +244,9 @@ struct bcm_clk_div {
                         u32 frac_width; /* field fraction width */
 
                         u64 scaled_div; /* scaled divider value */
-                };
+                } s;
                 u32 fixed;      /* non-zero fixed divider value */
-        };
+        } u;
         u32 flags;              /* BCM_CLK_DIV_FLAGS_* below */
 };
 
@@ -263,28 +263,28 @@ struct bcm_clk_div {
 /* A fixed (non-zero) divider */
 #define FIXED_DIVIDER(_value)                                           \
         {                                                               \
-                .fixed = (_value),                                      \
+                .u.fixed = (_value),                                    \
                 .flags = FLAG(DIV, EXISTS)|FLAG(DIV, FIXED),            \
         }
 
 /* A divider with an integral divisor */
 #define DIVIDER(_offset, _shift, _width)                                \
         {                                                               \
-                .offset = (_offset),                                    \
-                .shift = (_shift),                                      \
-                .width = (_width),                                      \
-                .scaled_div = BAD_SCALED_DIV_VALUE,                     \
+                .u.s.offset = (_offset),                                \
+                .u.s.shift = (_shift),                                  \
+                .u.s.width = (_width),                                  \
+                .u.s.scaled_div = BAD_SCALED_DIV_VALUE,                 \
                 .flags = FLAG(DIV, EXISTS),                             \
         }
 
 /* A divider whose divisor has an integer and fractional part */
 #define FRAC_DIVIDER(_offset, _shift, _width, _frac_width)              \
         {                                                               \
-                .offset = (_offset),                                    \
-                .shift = (_shift),                                      \
-                .width = (_width),                                      \
-                .frac_width = (_frac_width),                            \
-                .scaled_div = BAD_SCALED_DIV_VALUE,                     \
+                .u.s.offset = (_offset),                                \
+                .u.s.shift = (_shift),                                  \
+                .u.s.width = (_width),                                  \
+                .u.s.frac_width = (_frac_width),                        \
+                .u.s.scaled_div = BAD_SCALED_DIV_VALUE,                 \
                 .flags = FLAG(DIV, EXISTS),                             \
         }
 
@@ -380,7 +380,7 @@ struct kona_clk {
         union {
                 void *data;
                 struct peri_clk_data *peri;
-        };
+        } u;
 };
 #define to_kona_clk(_hw) \
         container_of(_hw, struct kona_clk, hw)
diff --git a/drivers/clk/clk-divider.c b/drivers/clk/clk-divider.c
index ec22112e569f..4637697c139f 100644
--- a/drivers/clk/clk-divider.c
+++ b/drivers/clk/clk-divider.c
@@ -144,6 +144,37 @@ static bool _is_valid_div(struct clk_divider *divider, unsigned int div)
         return true;
 }
 
+static int _round_up_table(const struct clk_div_table *table, int div)
+{
+        const struct clk_div_table *clkt;
+        int up = _get_table_maxdiv(table);
+
+        for (clkt = table; clkt->div; clkt++) {
+                if (clkt->div == div)
+                        return clkt->div;
+                else if (clkt->div < div)
+                        continue;
+
+                if ((clkt->div - div) < (up - div))
+                        up = clkt->div;
+        }
+
+        return up;
+}
+
+static int _div_round_up(struct clk_divider *divider,
+                unsigned long parent_rate, unsigned long rate)
+{
+        int div = DIV_ROUND_UP(parent_rate, rate);
+
+        if (divider->flags & CLK_DIVIDER_POWER_OF_TWO)
+                div = __roundup_pow_of_two(div);
+        if (divider->table)
+                div = _round_up_table(divider->table, div);
+
+        return div;
+}
+
 static int clk_divider_bestdiv(struct clk_hw *hw, unsigned long rate,
                 unsigned long *best_parent_rate)
 {
@@ -159,7 +190,7 @@ static int clk_divider_bestdiv(struct clk_hw *hw, unsigned long rate,
 
         if (!(__clk_get_flags(hw->clk) & CLK_SET_RATE_PARENT)) {
                 parent_rate = *best_parent_rate;
-                bestdiv = DIV_ROUND_UP(parent_rate, rate);
+                bestdiv = _div_round_up(divider, parent_rate, rate);
                 bestdiv = bestdiv == 0 ? 1 : bestdiv;
                 bestdiv = bestdiv > maxdiv ? maxdiv : bestdiv;
                 return bestdiv;
@@ -219,6 +250,10 @@ static int clk_divider_set_rate(struct clk_hw *hw, unsigned long rate,
         u32 val;
 
         div = DIV_ROUND_UP(parent_rate, rate);
+
+        if (!_is_valid_div(divider, div))
+                return -EINVAL;
+
         value = _get_val(divider, div);
 
         if (value > div_mask(divider))
diff --git a/drivers/clk/clk.c b/drivers/clk/clk.c
index dff0373f53c1..7cf2c093cc54 100644
--- a/drivers/clk/clk.c
+++ b/drivers/clk/clk.c
@@ -1984,9 +1984,28 @@ struct clk *__clk_register(struct device *dev, struct clk_hw *hw)
 }
 EXPORT_SYMBOL_GPL(__clk_register);
 
-static int _clk_register(struct device *dev, struct clk_hw *hw, struct clk *clk)
+/**
+ * clk_register - allocate a new clock, register it and return an opaque cookie
+ * @dev: device that is registering this clock
+ * @hw: link to hardware-specific clock data
+ *
+ * clk_register is the primary interface for populating the clock tree with new
+ * clock nodes.  It returns a pointer to the newly allocated struct clk which
+ * cannot be dereferenced by driver code but may be used in conjuction with the
+ * rest of the clock API.  In the event of an error clk_register will return an
+ * error code; drivers must test for an error code after calling clk_register.
+ */
+struct clk *clk_register(struct device *dev, struct clk_hw *hw)
 {
         int i, ret;
+        struct clk *clk;
+
+        clk = kzalloc(sizeof(*clk), GFP_KERNEL);
+        if (!clk) {
+                pr_err("%s: could not allocate clk\n", __func__);
+                ret = -ENOMEM;
+                goto fail_out;
+        }
 
         clk->name = kstrdup(hw->init->name, GFP_KERNEL);
         if (!clk->name) {
@@ -2026,7 +2045,7 @@ static int _clk_register(struct device *dev, struct clk_hw *hw, struct clk *clk)
 
         ret = __clk_init(dev, clk);
         if (!ret)
-                return 0;
+                return clk;
 
 fail_parent_names_copy:
         while (--i >= 0)
@@ -2035,36 +2054,6 @@ fail_parent_names_copy:
 fail_parent_names:
         kfree(clk->name);
 fail_name:
-        return ret;
-}
-
-/**
- * clk_register - allocate a new clock, register it and return an opaque cookie
- * @dev: device that is registering this clock
- * @hw: link to hardware-specific clock data
- *
- * clk_register is the primary interface for populating the clock tree with new
- * clock nodes.  It returns a pointer to the newly allocated struct clk which
- * cannot be dereferenced by driver code but may be used in conjuction with the
- * rest of the clock API.  In the event of an error clk_register will return an
- * error code; drivers must test for an error code after calling clk_register.
- */
-struct clk *clk_register(struct device *dev, struct clk_hw *hw)
-{
-        int ret;
-        struct clk *clk;
-
-        clk = kzalloc(sizeof(*clk), GFP_KERNEL);
-        if (!clk) {
-                pr_err("%s: could not allocate clk\n", __func__);
-                ret = -ENOMEM;
-                goto fail_out;
-        }
-
-        ret = _clk_register(dev, hw, clk);
-        if (!ret)
-                return clk;
-
         kfree(clk);
 fail_out:
         return ERR_PTR(ret);
@@ -2151,9 +2140,10 @@ void clk_unregister(struct clk *clk)
 
         if (!hlist_empty(&clk->children)) {
                 struct clk *child;
+                struct hlist_node *t;
 
                 /* Reparent all children to the orphan list. */
-                hlist_for_each_entry(child, &clk->children, child_node)
+                hlist_for_each_entry_safe(child, t, &clk->children, child_node)
                         clk_set_parent(child, NULL);
         }
 
@@ -2173,7 +2163,7 @@ EXPORT_SYMBOL_GPL(clk_unregister);
 
 static void devm_clk_release(struct device *dev, void *res)
 {
-        clk_unregister(res);
+        clk_unregister(*(struct clk **)res);
 }
 
 /**
@@ -2188,18 +2178,18 @@ static void devm_clk_release(struct device *dev, void *res)
 struct clk *devm_clk_register(struct device *dev, struct clk_hw *hw)
 {
         struct clk *clk;
-        int ret;
+        struct clk **clkp;
 
-        clk = devres_alloc(devm_clk_release, sizeof(*clk), GFP_KERNEL);
-        if (!clk)
+        clkp = devres_alloc(devm_clk_release, sizeof(*clkp), GFP_KERNEL);
+        if (!clkp)
                 return ERR_PTR(-ENOMEM);
 
-        ret = _clk_register(dev, hw, clk);
-        if (!ret) {
-                devres_add(dev, clk);
+        clk = clk_register(dev, hw);
+        if (!IS_ERR(clk)) {
+                *clkp = clk;
+                devres_add(dev, clkp);
         } else {
-                devres_free(clk);
-                clk = ERR_PTR(ret);
+                devres_free(clkp);
         }
 
         return clk;
diff --git a/drivers/clk/shmobile/clk-mstp.c b/drivers/clk/shmobile/clk-mstp.c
index 2e5810c88d11..1f6324e29a80 100644
--- a/drivers/clk/shmobile/clk-mstp.c
+++ b/drivers/clk/shmobile/clk-mstp.c
@@ -156,6 +156,7 @@ cpg_mstp_clock_register(const char *name, const char *parent_name,
 static void __init cpg_mstp_clocks_init(struct device_node *np)
 {
         struct mstp_clock_group *group;
+        const char *idxname;
         struct clk **clks;
         unsigned int i;
 
@@ -184,6 +185,11 @@ static void __init cpg_mstp_clocks_init(struct device_node *np)
         for (i = 0; i < MSTP_MAX_CLOCKS; ++i)
                 clks[i] = ERR_PTR(-ENOENT);
 
+        if (of_find_property(np, "clock-indices", &i))
+                idxname = "clock-indices";
+        else
+                idxname = "renesas,clock-indices";
+
         for (i = 0; i < MSTP_MAX_CLOCKS; ++i) {
                 const char *parent_name;
                 const char *name;
@@ -197,8 +203,7 @@ static void __init cpg_mstp_clocks_init(struct device_node *np)
                         continue;
 
                 parent_name = of_clk_get_parent_name(np, i);
-                ret = of_property_read_u32_index(np, "renesas,clock-indices", i,
-                                                 &clkidx);
+                ret = of_property_read_u32_index(np, idxname, i, &clkidx);
                 if (parent_name == NULL || ret < 0)
                         break;
 
diff --git a/drivers/clk/socfpga/clk-pll.c b/drivers/clk/socfpga/clk-pll.c
index 88dafb5e9627..de6da957a09d 100644
--- a/drivers/clk/socfpga/clk-pll.c
+++ b/drivers/clk/socfpga/clk-pll.c
@@ -20,6 +20,7 @@
 #include <linux/clk-provider.h>
 #include <linux/io.h>
 #include <linux/of.h>
+#include <linux/of_address.h>
 
 #include "clk.h"
 
@@ -43,6 +44,8 @@
 
 #define to_socfpga_clk(p) container_of(p, struct socfpga_pll, hw.hw)
 
+void __iomem *clk_mgr_base_addr;
+
 static unsigned long clk_pll_recalc_rate(struct clk_hw *hwclk,
                                          unsigned long parent_rate)
 {
@@ -87,6 +90,7 @@ static __init struct clk *__socfpga_pll_init(struct device_node *node,
         const char *clk_name = node->name;
         const char *parent_name[SOCFPGA_MAX_PARENTS];
         struct clk_init_data init;
+        struct device_node *clkmgr_np;
         int rc;
         int i = 0;
 
@@ -96,6 +100,9 @@ static __init struct clk *__socfpga_pll_init(struct device_node *node,
         if (WARN_ON(!pll_clk))
                 return NULL;
 
+        clkmgr_np = of_find_compatible_node(NULL, NULL, "altr,clk-mgr");
+        clk_mgr_base_addr = of_iomap(clkmgr_np, 0);
+        BUG_ON(!clk_mgr_base_addr);
         pll_clk->hw.reg = clk_mgr_base_addr + reg;
 
         of_property_read_string(node, "clock-output-names", &clk_name);
diff --git a/drivers/clk/socfpga/clk.c b/drivers/clk/socfpga/clk.c
index 35a960a993f9..43db947e5f0e 100644
--- a/drivers/clk/socfpga/clk.c
+++ b/drivers/clk/socfpga/clk.c
@@ -17,28 +17,11 @@
  * 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/clk.h>
-#include <linux/clkdev.h>
-#include <linux/clk-provider.h>
-#include <linux/io.h>
 #include <linux/of.h>
-#include <linux/of_address.h>
 
 #include "clk.h"
 
-void __iomem *clk_mgr_base_addr;
-
-static const struct of_device_id socfpga_child_clocks[] __initconst = {
-        { .compatible = "altr,socfpga-pll-clock", socfpga_pll_init, },
-        { .compatible = "altr,socfpga-perip-clk", socfpga_periph_init, },
-        { .compatible = "altr,socfpga-gate-clk", socfpga_gate_init, },
-        {},
-};
-
-static void __init socfpga_clkmgr_init(struct device_node *node)
-{
-        clk_mgr_base_addr = of_iomap(node, 0);
-        of_clk_init(socfpga_child_clocks);
-}
-CLK_OF_DECLARE(socfpga_mgr, "altr,clk-mgr", socfpga_clkmgr_init);
+CLK_OF_DECLARE(socfpga_pll_clk, "altr,socfpga-pll-clock", socfpga_pll_init);
+CLK_OF_DECLARE(socfpga_perip_clk, "altr,socfpga-perip-clk", socfpga_periph_init);
+CLK_OF_DECLARE(socfpga_gate_clk, "altr,socfpga-gate-clk", socfpga_gate_init);
 
diff --git a/drivers/clk/tegra/clk-pll.c b/drivers/clk/tegra/clk-pll.c
index 0d20241e0770..e1769addf435 100644
--- a/drivers/clk/tegra/clk-pll.c
+++ b/drivers/clk/tegra/clk-pll.c
@@ -1718,7 +1718,7 @@ struct clk *tegra_clk_register_plle_tegra114(const char *name,
                                         "pll_re_vco");
         } else {
                 val_aux &= ~(PLLE_AUX_PLLRE_SEL | PLLE_AUX_PLLP_SEL);
-                pll_writel(val, pll_params->aux_reg, pll);
+                pll_writel(val_aux, pll_params->aux_reg, pll);
         }
 
         clk = _tegra_clk_register_pll(pll, name, parent_name, flags,
diff --git a/drivers/cpufreq/intel_pstate.c b/drivers/cpufreq/intel_pstate.c
index 099967302bf2..eab8ccfe6beb 100644
--- a/drivers/cpufreq/intel_pstate.c
+++ b/drivers/cpufreq/intel_pstate.c
@@ -37,6 +37,7 @@
 #define BYT_RATIOS              0x66a
 #define BYT_VIDS                0x66b
 #define BYT_TURBO_RATIOS        0x66c
+#define BYT_TURBO_VIDS          0x66d
 
 
 #define FRAC_BITS 6
@@ -70,8 +71,9 @@ struct pstate_data {
 };
 
 struct vid_data {
-        int32_t min;
-        int32_t max;
+        int min;
+        int max;
+        int turbo;
         int32_t ratio;
 };
 
@@ -359,14 +361,14 @@ static int byt_get_min_pstate(void)
 {
         u64 value;
         rdmsrl(BYT_RATIOS, value);
-        return (value >> 8) & 0xFF;
+        return (value >> 8) & 0x3F;
 }
 
 static int byt_get_max_pstate(void)
 {
         u64 value;
         rdmsrl(BYT_RATIOS, value);
-        return (value >> 16) & 0xFF;
+        return (value >> 16) & 0x3F;
 }
 
 static int byt_get_turbo_pstate(void)
@@ -393,6 +395,9 @@ static void byt_set_pstate(struct cpudata *cpudata, int pstate)
         vid_fp = clamp_t(int32_t, vid_fp, cpudata->vid.min, cpudata->vid.max);
         vid = fp_toint(vid_fp);
 
+        if (pstate > cpudata->pstate.max_pstate)
+                vid = cpudata->vid.turbo;
+
         val |= vid;
 
         wrmsrl(MSR_IA32_PERF_CTL, val);
@@ -402,13 +407,17 @@ static void byt_get_vid(struct cpudata *cpudata)
 {
         u64 value;
 
+
         rdmsrl(BYT_VIDS, value);
-        cpudata->vid.min = int_tofp((value >> 8) & 0x7f);
-        cpudata->vid.max = int_tofp((value >> 16) & 0x7f);
+        cpudata->vid.min = int_tofp((value >> 8) & 0x3f);
+        cpudata->vid.max = int_tofp((value >> 16) & 0x3f);
         cpudata->vid.ratio = div_fp(
                 cpudata->vid.max - cpudata->vid.min,
                 int_tofp(cpudata->pstate.max_pstate -
                         cpudata->pstate.min_pstate));
+
+        rdmsrl(BYT_TURBO_VIDS, value);
+        cpudata->vid.turbo = value & 0x7f;
 }
 
 
@@ -545,12 +554,7 @@ static void intel_pstate_get_cpu_pstates(struct cpudata *cpu)
 
         if (pstate_funcs.get_vid)
                 pstate_funcs.get_vid(cpu);
-
-        /*
-         * goto max pstate so we don't slow up boot if we are built-in if we are
-         * a module we will take care of it during normal operation
-         */
-        intel_pstate_set_pstate(cpu, cpu->pstate.max_pstate);
+        intel_pstate_set_pstate(cpu, cpu->pstate.min_pstate);
 }
 
 static inline void intel_pstate_calc_busy(struct cpudata *cpu,
@@ -695,11 +699,6 @@ static int intel_pstate_init_cpu(unsigned int cpunum)
         cpu = all_cpu_data[cpunum];
 
         intel_pstate_get_cpu_pstates(cpu);
-        if (!cpu->pstate.current_pstate) {
-                all_cpu_data[cpunum] = NULL;
-                kfree(cpu);
-                return -ENODATA;
-        }
 
         cpu->cpu = cpunum;
 
@@ -710,7 +709,6 @@ static int intel_pstate_init_cpu(unsigned int cpunum)
         cpu->timer.expires = jiffies + HZ/100;
         intel_pstate_busy_pid_reset(cpu);
         intel_pstate_sample(cpu);
-        intel_pstate_set_pstate(cpu, cpu->pstate.max_pstate);
 
         add_timer_on(&cpu->timer, cpunum);
 
diff --git a/drivers/cpufreq/loongson2_cpufreq.c b/drivers/cpufreq/loongson2_cpufreq.c
index f0bc31f5db27..d4add8621944 100644
--- a/drivers/cpufreq/loongson2_cpufreq.c
+++ b/drivers/cpufreq/loongson2_cpufreq.c
@@ -62,7 +62,7 @@ static int loongson2_cpufreq_target(struct cpufreq_policy *policy,
         set_cpus_allowed_ptr(current, &cpus_allowed);
 
         /* setting the cpu frequency */
-        clk_set_rate(policy->clk, freq);
+        clk_set_rate(policy->clk, freq * 1000);
 
         return 0;
 }
@@ -92,7 +92,7 @@ static int loongson2_cpufreq_cpu_init(struct cpufreq_policy *policy)
              i++)
                 loongson2_clockmod_table[i].frequency = (rate * i) / 8;
 
-        ret = clk_set_rate(cpuclk, rate);
+        ret = clk_set_rate(cpuclk, rate * 1000);
         if (ret) {
                 clk_put(cpuclk);
                 return ret;
diff --git a/drivers/crypto/caam/error.c b/drivers/crypto/caam/error.c
index 9f25f5296029..0eabd81e1a90 100644
--- a/drivers/crypto/caam/error.c
+++ b/drivers/crypto/caam/error.c
@@ -16,9 +16,13 @@
         char *tmp;                                              \
                                                                 \
         tmp = kmalloc(sizeof(format) + max_alloc, GFP_ATOMIC);  \
-        sprintf(tmp, format, param);                            \
-        strcat(str, tmp);                                       \
-        kfree(tmp);                                             \
+        if (likely(tmp)) {                                      \
+                sprintf(tmp, format, param);                    \
+                strcat(str, tmp);                               \
+                kfree(tmp);                                     \
+        } else {                                                \
+                strcat(str, "kmalloc failure in SPRINTFCAT");   \
+        }                                                       \
 }
 
 static void report_jump_idx(u32 status, char *outstr)
diff --git a/drivers/firewire/core.h b/drivers/firewire/core.h
index c98764aeeec6..870044e82316 100644
--- a/drivers/firewire/core.h
+++ b/drivers/firewire/core.h
@@ -118,7 +118,6 @@ int fw_card_add(struct fw_card *card,
                 u32 max_receive, u32 link_speed, u64 guid);
 void fw_core_remove_card(struct fw_card *card);
 int fw_compute_block_crc(__be32 *block);
-void fw_schedule_bus_reset(struct fw_card *card, bool delayed, bool short_reset);
 void fw_schedule_bm_work(struct fw_card *card, unsigned long delay);
 
 /* -cdev */
diff --git a/drivers/firmware/iscsi_ibft.c b/drivers/firmware/iscsi_ibft.c
index 3ee852c9925b..071c2c969eec 100644
--- a/drivers/firmware/iscsi_ibft.c
+++ b/drivers/firmware/iscsi_ibft.c
@@ -756,6 +756,7 @@ static const struct {
          */
         { ACPI_SIG_IBFT },
         { "iBFT" },
+        { "BIFT" },     /* Broadcom iSCSI Offload */
 };
 
 static void __init acpi_find_ibft_region(void)
diff --git a/drivers/gpio/gpio-ich.c b/drivers/gpio/gpio-ich.c
index e73c6755a5eb..70304220a479 100644
--- a/drivers/gpio/gpio-ich.c
+++ b/drivers/gpio/gpio-ich.c
@@ -305,6 +305,8 @@ static struct ichx_desc ich6_desc = {
 
         .ngpio = 50,
         .have_blink = true,
+        .regs = ichx_regs,
+        .reglen = ichx_reglen,
 };
 
 /* Intel 3100 */
@@ -324,6 +326,8 @@ static struct ichx_desc i3100_desc = {
         .uses_gpe0 = true,
 
         .ngpio = 50,
+        .regs = ichx_regs,
+        .reglen = ichx_reglen,
 };
 
 /* ICH7 and ICH8-based */
diff --git a/drivers/gpio/gpio-mcp23s08.c b/drivers/gpio/gpio-mcp23s08.c
index 99a68310e7c0..3d53fd6880d1 100644
--- a/drivers/gpio/gpio-mcp23s08.c
+++ b/drivers/gpio/gpio-mcp23s08.c
@@ -894,9 +894,11 @@ static int mcp23s08_probe(struct spi_device *spi)
                         dev_err(&spi->dev, "invalid spi-present-mask\n");
                         return -ENODEV;
                 }
-
-                for (addr = 0; addr < ARRAY_SIZE(pdata->chip); addr++)
+                for (addr = 0; addr < ARRAY_SIZE(pdata->chip); addr++) {
+                        if ((spi_present_mask & (1 << addr)))
+                                chips++;
                         pullups[addr] = 0;
+                }
         } else {
                 type = spi_get_device_id(spi)->driver_data;
                 pdata = dev_get_platdata(&spi->dev);
@@ -919,12 +921,12 @@ static int mcp23s08_probe(struct spi_device *spi)
                         pullups[addr] = pdata->chip[addr].pullups;
                 }
 
-                if (!chips)
-                        return -ENODEV;
-
                 base = pdata->base;
         }
 
+        if (!chips)
+                return -ENODEV;
+
         data = kzalloc(sizeof(*data) + chips * sizeof(struct mcp23s08),
                         GFP_KERNEL);
         if (!data)
diff --git a/drivers/gpu/drm/i915/intel_bios.c b/drivers/gpu/drm/i915/intel_bios.c
index fa486c5fbb02..aff4a113cda3 100644
--- a/drivers/gpu/drm/i915/intel_bios.c
+++ b/drivers/gpu/drm/i915/intel_bios.c
@@ -560,47 +560,71 @@ parse_edp(struct drm_i915_private *dev_priv, struct bdb_header *bdb)
 
         dev_priv->vbt.edp_pps = *edp_pps;
 
-        dev_priv->vbt.edp_rate = edp_link_params->rate ? DP_LINK_BW_2_7 :
-                DP_LINK_BW_1_62;
+        switch (edp_link_params->rate) {
+        case EDP_RATE_1_62:
+                dev_priv->vbt.edp_rate = DP_LINK_BW_1_62;
+                break;
+        case EDP_RATE_2_7:
+                dev_priv->vbt.edp_rate = DP_LINK_BW_2_7;
+                break;
+        default:
+                DRM_DEBUG_KMS("VBT has unknown eDP link rate value %u\n",
+                              edp_link_params->rate);
+                break;
+        }
+
         switch (edp_link_params->lanes) {
-        case 0:
+        case EDP_LANE_1:
                 dev_priv->vbt.edp_lanes = 1;
                 break;
-        case 1:
+        case EDP_LANE_2:
                 dev_priv->vbt.edp_lanes = 2;
                 break;
-        case 3:
-        default:
+        case EDP_LANE_4:
                 dev_priv->vbt.edp_lanes = 4;
                 break;
+        default:
+                DRM_DEBUG_KMS("VBT has unknown eDP lane count value %u\n",
+                              edp_link_params->lanes);
+                break;
         }
+
         switch (edp_link_params->preemphasis) {
-        case 0:
+        case EDP_PREEMPHASIS_NONE:
                 dev_priv->vbt.edp_preemphasis = DP_TRAIN_PRE_EMPHASIS_0;
                 break;
-        case 1:
+        case EDP_PREEMPHASIS_3_5dB:
                 dev_priv->vbt.edp_preemphasis = DP_TRAIN_PRE_EMPHASIS_3_5;
                 break;
-        case 2:
+        case EDP_PREEMPHASIS_6dB:
                 dev_priv->vbt.edp_preemphasis = DP_TRAIN_PRE_EMPHASIS_6;
                 break;
-        case 3:
+        case EDP_PREEMPHASIS_9_5dB:
                 dev_priv->vbt.edp_preemphasis = DP_TRAIN_PRE_EMPHASIS_9_5;
                 break;
+        default:
+                DRM_DEBUG_KMS("VBT has unknown eDP pre-emphasis value %u\n",
+                              edp_link_params->preemphasis);
+                break;
         }
+
         switch (edp_link_params->vswing) {
-        case 0:
+        case EDP_VSWING_0_4V:
                 dev_priv->vbt.edp_vswing = DP_TRAIN_VOLTAGE_SWING_400;
                 break;
-        case 1:
+        case EDP_VSWING_0_6V:
                 dev_priv->vbt.edp_vswing = DP_TRAIN_VOLTAGE_SWING_600;
                 break;
-        case 2:
+        case EDP_VSWING_0_8V:
                 dev_priv->vbt.edp_vswing = DP_TRAIN_VOLTAGE_SWING_800;
                 break;
-        case 3:
+        case EDP_VSWING_1_2V:
                 dev_priv->vbt.edp_vswing = DP_TRAIN_VOLTAGE_SWING_1200;
                 break;
+        default:
+                DRM_DEBUG_KMS("VBT has unknown eDP voltage swing value %u\n",
+                              edp_link_params->vswing);
+                break;
         }
 }
 
diff --git a/drivers/gpu/drm/i915/intel_dp.c b/drivers/gpu/drm/i915/intel_dp.c
index 5ca68aa9f237..2a00cb828d20 100644
--- a/drivers/gpu/drm/i915/intel_dp.c
+++ b/drivers/gpu/drm/i915/intel_dp.c
@@ -121,6 +121,22 @@ intel_dp_max_link_bw(struct intel_dp *intel_dp)
         return max_link_bw;
 }
 
+static u8 intel_dp_max_lane_count(struct intel_dp *intel_dp)
+{
+        struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
+        struct drm_device *dev = intel_dig_port->base.base.dev;
+        u8 source_max, sink_max;
+
+        source_max = 4;
+        if (HAS_DDI(dev) && intel_dig_port->port == PORT_A &&
+            (intel_dig_port->saved_port_bits & DDI_A_4_LANES) == 0)
+                source_max = 2;
+
+        sink_max = drm_dp_max_lane_count(intel_dp->dpcd);
+
+        return min(source_max, sink_max);
+}
+
 /*
  * The units on the numbers in the next two are... bizarre.  Examples will
  * make it clearer; this one parallels an example in the eDP spec.
@@ -171,7 +187,7 @@ intel_dp_mode_valid(struct drm_connector *connector,
         }
 
         max_link_clock = drm_dp_bw_code_to_link_rate(intel_dp_max_link_bw(intel_dp));
-        max_lanes = drm_dp_max_lane_count(intel_dp->dpcd);
+        max_lanes = intel_dp_max_lane_count(intel_dp);
 
         max_rate = intel_dp_max_data_rate(max_link_clock, max_lanes);
         mode_rate = intel_dp_link_required(target_clock, 18);
@@ -751,8 +767,10 @@ intel_dp_compute_config(struct intel_encoder *encoder,
         struct intel_crtc *intel_crtc = encoder->new_crtc;
         struct intel_connector *intel_connector = intel_dp->attached_connector;
         int lane_count, clock;
-        int max_lane_count = drm_dp_max_lane_count(intel_dp->dpcd);
+        int min_lane_count = 1;
+        int max_lane_count = intel_dp_max_lane_count(intel_dp);
         /* Conveniently, the link BW constants become indices with a shift...*/
+        int min_clock = 0;
         int max_clock = intel_dp_max_link_bw(intel_dp) >> 3;
         int bpp, mode_rate;
         static int bws[] = { DP_LINK_BW_1_62, DP_LINK_BW_2_7, DP_LINK_BW_5_4 };
@@ -785,19 +803,38 @@ intel_dp_compute_config(struct intel_encoder *encoder,
         /* Walk through all bpp values. Luckily they're all nicely spaced with 2
          * bpc in between. */
         bpp = pipe_config->pipe_bpp;
-        if (is_edp(intel_dp) && dev_priv->vbt.edp_bpp &&
-            dev_priv->vbt.edp_bpp < bpp) {
-                DRM_DEBUG_KMS("clamping bpp for eDP panel to BIOS-provided %i\n",
-                              dev_priv->vbt.edp_bpp);
-                bpp = dev_priv->vbt.edp_bpp;
+        if (is_edp(intel_dp)) {
+                if (dev_priv->vbt.edp_bpp && dev_priv->vbt.edp_bpp < bpp) {
+                        DRM_DEBUG_KMS("clamping bpp for eDP panel to BIOS-provided %i\n",
+                                      dev_priv->vbt.edp_bpp);
+                        bpp = dev_priv->vbt.edp_bpp;
+                }
+
+                if (IS_BROADWELL(dev)) {
+                        /* Yes, it's an ugly hack. */
+                        min_lane_count = max_lane_count;
+                        DRM_DEBUG_KMS("forcing lane count to max (%u) on BDW\n",
+                                      min_lane_count);
+                } else if (dev_priv->vbt.edp_lanes) {
+                        min_lane_count = min(dev_priv->vbt.edp_lanes,
+                                             max_lane_count);
+                        DRM_DEBUG_KMS("using min %u lanes per VBT\n",
+                                      min_lane_count);
+                }
+
+                if (dev_priv->vbt.edp_rate) {
+                        min_clock = min(dev_priv->vbt.edp_rate >> 3, max_clock);
+                        DRM_DEBUG_KMS("using min %02x link bw per VBT\n",
+                                      bws[min_clock]);
+                }
         }
 
         for (; bpp >= 6*3; bpp -= 2*3) {
                 mode_rate = intel_dp_link_required(adjusted_mode->crtc_clock,
                                                    bpp);
 
-                for (lane_count = 1; lane_count <= max_lane_count; lane_count <<= 1) {
-                        for (clock = 0; clock <= max_clock; clock++) {
+                for (lane_count = min_lane_count; lane_count <= max_lane_count; lane_count <<= 1) {
+                        for (clock = min_clock; clock <= max_clock; clock++) {
                                 link_clock = drm_dp_bw_code_to_link_rate(bws[clock]);
                                 link_avail = intel_dp_max_data_rate(link_clock,
                                                                     lane_count);
diff --git a/drivers/gpu/drm/i915/intel_fbdev.c b/drivers/gpu/drm/i915/intel_fbdev.c
index fce4a0d93c0b..f73ba5e6b7a8 100644
--- a/drivers/gpu/drm/i915/intel_fbdev.c
+++ b/drivers/gpu/drm/i915/intel_fbdev.c
@@ -387,6 +387,15 @@ static bool intel_fb_initial_config(struct drm_fb_helper *fb_helper,
                                                           height);
                 }
 
+                /* No preferred mode marked by the EDID? Are there any modes? */
+                if (!modes[i] && !list_empty(&connector->modes)) {
+                        DRM_DEBUG_KMS("using first mode listed on connector %s\n",
+                                      drm_get_connector_name(connector));
+                        modes[i] = list_first_entry(&connector->modes,
+                                                    struct drm_display_mode,
+                                                    head);
+                }
+
                 /* last resort: use current mode */
                 if (!modes[i]) {
                         /*
diff --git a/drivers/gpu/drm/i915/intel_panel.c b/drivers/gpu/drm/i915/intel_panel.c
index 0eead16aeda7..cb8cfb7e0974 100644
--- a/drivers/gpu/drm/i915/intel_panel.c
+++ b/drivers/gpu/drm/i915/intel_panel.c
@@ -492,6 +492,7 @@ void intel_panel_set_backlight(struct intel_connector *connector, u32 level,
         enum pipe pipe = intel_get_pipe_from_connector(connector);
         u32 freq;
         unsigned long flags;
+        u64 n;
 
         if (!panel->backlight.present || pipe == INVALID_PIPE)
                 return;
@@ -502,10 +503,9 @@ void intel_panel_set_backlight(struct intel_connector *connector, u32 level,
 
         /* scale to hardware max, but be careful to not overflow */
         freq = panel->backlight.max;
-        if (freq < max)
-                level = level * freq / max;
-        else
-                level = freq / max * level;
+        n = (u64)level * freq;
+        do_div(n, max);
+        level = n;
 
         panel->backlight.level = level;
         if (panel->backlight.device)
diff --git a/drivers/gpu/drm/i915/intel_pm.c b/drivers/gpu/drm/i915/intel_pm.c
index 19e94c3edc19..d93dcf683e8c 100644
--- a/drivers/gpu/drm/i915/intel_pm.c
+++ b/drivers/gpu/drm/i915/intel_pm.c
@@ -2095,6 +2095,43 @@ static void intel_print_wm_latency(struct drm_device *dev,
         }
 }
 
+static bool ilk_increase_wm_latency(struct drm_i915_private *dev_priv,
+                                    uint16_t wm[5], uint16_t min)
+{
+        int level, max_level = ilk_wm_max_level(dev_priv->dev);
+
+        if (wm[0] >= min)
+                return false;
+
+        wm[0] = max(wm[0], min);
+        for (level = 1; level <= max_level; level++)
+                wm[level] = max_t(uint16_t, wm[level], DIV_ROUND_UP(min, 5));
+
+        return true;
+}
+
+static void snb_wm_latency_quirk(struct drm_device *dev)
+{
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        bool changed;
+
+        /*
+         * The BIOS provided WM memory latency values are often
+         * inadequate for high resolution displays. Adjust them.
+         */
+        changed = ilk_increase_wm_latency(dev_priv, dev_priv->wm.pri_latency, 12) |
+                ilk_increase_wm_latency(dev_priv, dev_priv->wm.spr_latency, 12) |
+                ilk_increase_wm_latency(dev_priv, dev_priv->wm.cur_latency, 12);
+
+        if (!changed)
+                return;
+
+        DRM_DEBUG_KMS("WM latency values increased to avoid potential underruns\n");
+        intel_print_wm_latency(dev, "Primary", dev_priv->wm.pri_latency);
+        intel_print_wm_latency(dev, "Sprite", dev_priv->wm.spr_latency);
+        intel_print_wm_latency(dev, "Cursor", dev_priv->wm.cur_latency);
+}
+
 static void ilk_setup_wm_latency(struct drm_device *dev)
 {
         struct drm_i915_private *dev_priv = dev->dev_private;
@@ -2112,6 +2149,9 @@ static void ilk_setup_wm_latency(struct drm_device *dev)
         intel_print_wm_latency(dev, "Primary", dev_priv->wm.pri_latency);
         intel_print_wm_latency(dev, "Sprite", dev_priv->wm.spr_latency);
         intel_print_wm_latency(dev, "Cursor", dev_priv->wm.cur_latency);
+
+        if (IS_GEN6(dev))
+                snb_wm_latency_quirk(dev);
 }
 
 static void ilk_compute_wm_parameters(struct drm_crtc *crtc,
diff --git a/drivers/gpu/drm/i915/intel_sdvo.c b/drivers/gpu/drm/i915/intel_sdvo.c
index d27155adf5db..46be00d66df3 100644
--- a/drivers/gpu/drm/i915/intel_sdvo.c
+++ b/drivers/gpu/drm/i915/intel_sdvo.c
@@ -2424,8 +2424,8 @@ intel_sdvo_connector_init(struct intel_sdvo_connector *connector,
         if (ret < 0)
                 goto err1;
 
-        ret = sysfs_create_link(&encoder->ddc.dev.kobj,
-                                &drm_connector->kdev->kobj,
+        ret = sysfs_create_link(&drm_connector->kdev->kobj,
+                                &encoder->ddc.dev.kobj,
                                 encoder->ddc.dev.kobj.name);
         if (ret < 0)
                 goto err2;
diff --git a/drivers/gpu/drm/i915/intel_uncore.c b/drivers/gpu/drm/i915/intel_uncore.c
index f729dc71d5be..d0c75779d3f6 100644
--- a/drivers/gpu/drm/i915/intel_uncore.c
+++ b/drivers/gpu/drm/i915/intel_uncore.c
@@ -185,6 +185,8 @@ static void vlv_force_wake_reset(struct drm_i915_private *dev_priv)
 {
         __raw_i915_write32(dev_priv, FORCEWAKE_VLV,
                            _MASKED_BIT_DISABLE(0xffff));
+        __raw_i915_write32(dev_priv, FORCEWAKE_MEDIA_VLV,
+                           _MASKED_BIT_DISABLE(0xffff));
         /* something from same cacheline, but !FORCEWAKE_VLV */
         __raw_posting_read(dev_priv, FORCEWAKE_ACK_VLV);
 }
diff --git a/drivers/hwmon/emc1403.c b/drivers/hwmon/emc1403.c
index 90ec1173b8a1..01723f04fe45 100644
--- a/drivers/hwmon/emc1403.c
+++ b/drivers/hwmon/emc1403.c
@@ -163,7 +163,7 @@ static ssize_t store_hyst(struct device *dev,
         if (retval < 0)
                 goto fail;
 
-        hyst = val - retval * 1000;
+        hyst = retval * 1000 - val;
         hyst = DIV_ROUND_CLOSEST(hyst, 1000);
         if (hyst < 0 || hyst > 255) {
                 retval = -ERANGE;
@@ -330,7 +330,7 @@ static int emc1403_detect(struct i2c_client *client,
         }
 
         id = i2c_smbus_read_byte_data(client, THERMAL_REVISION_REG);
-        if (id != 0x01)
+        if (id < 0x01 || id > 0x04)
                 return -ENODEV;
 
         return 0;
@@ -355,9 +355,9 @@ static int emc1403_probe(struct i2c_client *client,
         if (id->driver_data)
                 data->groups[1] = &emc1404_group;
 
-        hwmon_dev = hwmon_device_register_with_groups(&client->dev,
-                                                      client->name, data,
-                                                      data->groups);
+        hwmon_dev = devm_hwmon_device_register_with_groups(&client->dev,
+                                                           client->name, data,
+                                                           data->groups);
         if (IS_ERR(hwmon_dev))
                 return PTR_ERR(hwmon_dev);
 
diff --git a/drivers/i2c/busses/i2c-designware-core.c b/drivers/i2c/busses/i2c-designware-core.c
index 22e92c3d3d07..3c20e4bd6dd1 100644
--- a/drivers/i2c/busses/i2c-designware-core.c
+++ b/drivers/i2c/busses/i2c-designware-core.c
@@ -422,6 +422,9 @@ static void i2c_dw_xfer_init(struct dw_i2c_dev *dev)
          */
         dw_writel(dev, msgs[dev->msg_write_idx].addr | ic_tar, DW_IC_TAR);
 
+        /* enforce disabled interrupts (due to HW issues) */
+        i2c_dw_disable_int(dev);
+
         /* Enable the adapter */
         __i2c_dw_enable(dev, true);
 
diff --git a/drivers/i2c/busses/i2c-nomadik.c b/drivers/i2c/busses/i2c-nomadik.c
index 28cbe1b2a2ec..32c85e9ecdae 100644
--- a/drivers/i2c/busses/i2c-nomadik.c
+++ b/drivers/i2c/busses/i2c-nomadik.c
@@ -999,7 +999,7 @@ static int nmk_i2c_probe(struct amba_device *adev, const struct amba_id *id)
 
         dev->virtbase = devm_ioremap(&adev->dev, adev->res.start,
                                 resource_size(&adev->res));
-        if (IS_ERR(dev->virtbase)) {
+        if (!dev->virtbase) {
                 ret = -ENOMEM;
                 goto err_no_mem;
         }
diff --git a/drivers/i2c/busses/i2c-qup.c b/drivers/i2c/busses/i2c-qup.c
index 1b4cf14f1106..2a5efb5b487c 100644
--- a/drivers/i2c/busses/i2c-qup.c
+++ b/drivers/i2c/busses/i2c-qup.c
@@ -479,7 +479,7 @@ static int qup_i2c_xfer(struct i2c_adapter *adap,
         int ret, idx;
 
         ret = pm_runtime_get_sync(qup->dev);
-        if (ret)
+        if (ret < 0)
                 goto out;
 
         writel(1, qup->base + QUP_SW_RESET);
diff --git a/drivers/i2c/busses/i2c-rcar.c b/drivers/i2c/busses/i2c-rcar.c
index d4fa8eba6e9d..06d47aafbb79 100644
--- a/drivers/i2c/busses/i2c-rcar.c
+++ b/drivers/i2c/busses/i2c-rcar.c
@@ -561,6 +561,12 @@ static int rcar_i2c_master_xfer(struct i2c_adapter *adap,
 
         ret = -EINVAL;
         for (i = 0; i < num; i++) {
+                /* This HW can't send STOP after address phase */
+                if (msgs[i].len == 0) {
+                        ret = -EOPNOTSUPP;
+                        break;
+                }
+
                 /*-------------- spin lock -----------------*/
                 spin_lock_irqsave(&priv->lock, flags);
 
@@ -625,7 +631,8 @@ static int rcar_i2c_master_xfer(struct i2c_adapter *adap,
 
 static u32 rcar_i2c_func(struct i2c_adapter *adap)
 {
-        return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
+        /* This HW can't do SMBUS_QUICK and NOSTART */
+        return I2C_FUNC_I2C | (I2C_FUNC_SMBUS_EMUL & ~I2C_FUNC_SMBUS_QUICK);
 }
 
 static const struct i2c_algorithm rcar_i2c_algo = {
diff --git a/drivers/i2c/busses/i2c-s3c2410.c b/drivers/i2c/busses/i2c-s3c2410.c
index ae4491062e41..bb3a9964f7e0 100644
--- a/drivers/i2c/busses/i2c-s3c2410.c
+++ b/drivers/i2c/busses/i2c-s3c2410.c
@@ -1276,10 +1276,10 @@ static int s3c24xx_i2c_resume(struct device *dev)
         struct platform_device *pdev = to_platform_device(dev);
         struct s3c24xx_i2c *i2c = platform_get_drvdata(pdev);
 
-        i2c->suspended = 0;
         clk_prepare_enable(i2c->clk);
         s3c24xx_i2c_init(i2c);
         clk_disable_unprepare(i2c->clk);
+        i2c->suspended = 0;
 
         return 0;
 }
diff --git a/drivers/infiniband/ulp/isert/ib_isert.c b/drivers/infiniband/ulp/isert/ib_isert.c
index c98fdb185931..a1710465faaf 100644
--- a/drivers/infiniband/ulp/isert/ib_isert.c
+++ b/drivers/infiniband/ulp/isert/ib_isert.c
@@ -28,6 +28,7 @@
 #include <target/target_core_base.h>
 #include <target/target_core_fabric.h>
 #include <target/iscsi/iscsi_transport.h>
+#include <linux/semaphore.h>
 
 #include "isert_proto.h"
 #include "ib_isert.h"
@@ -561,7 +562,15 @@ isert_connect_request(struct rdma_cm_id *cma_id, struct rdma_cm_event *event)
         struct isert_device *device;
         struct ib_device *ib_dev = cma_id->device;
         int ret = 0;
-        u8 pi_support = np->tpg_np->tpg->tpg_attrib.t10_pi;
+        u8 pi_support;
+
+        spin_lock_bh(&np->np_thread_lock);
+        if (!np->enabled) {
+                spin_unlock_bh(&np->np_thread_lock);
+                pr_debug("iscsi_np is not enabled, reject connect request\n");
+                return rdma_reject(cma_id, NULL, 0);
+        }
+        spin_unlock_bh(&np->np_thread_lock);
 
         pr_debug("Entering isert_connect_request cma_id: %p, context: %p\n",
                  cma_id, cma_id->context);
@@ -652,6 +661,7 @@ isert_connect_request(struct rdma_cm_id *cma_id, struct rdma_cm_event *event)
                 goto out_mr;
         }
 
+        pi_support = np->tpg_np->tpg->tpg_attrib.t10_pi;
         if (pi_support && !device->pi_capable) {
                 pr_err("Protection information requested but not supported\n");
                 ret = -EINVAL;
@@ -663,11 +673,11 @@ isert_connect_request(struct rdma_cm_id *cma_id, struct rdma_cm_event *event)
                 goto out_conn_dev;
 
         mutex_lock(&isert_np->np_accept_mutex);
-        list_add_tail(&isert_np->np_accept_list, &isert_conn->conn_accept_node);
+        list_add_tail(&isert_conn->conn_accept_node, &isert_np->np_accept_list);
         mutex_unlock(&isert_np->np_accept_mutex);
 
-        pr_debug("isert_connect_request() waking up np_accept_wq: %p\n", np);
-        wake_up(&isert_np->np_accept_wq);
+        pr_debug("isert_connect_request() up np_sem np: %p\n", np);
+        up(&isert_np->np_sem);
         return 0;
 
 out_conn_dev:
@@ -2999,7 +3009,7 @@ isert_setup_np(struct iscsi_np *np,
                 pr_err("Unable to allocate struct isert_np\n");
                 return -ENOMEM;
         }
-        init_waitqueue_head(&isert_np->np_accept_wq);
+        sema_init(&isert_np->np_sem, 0);
         mutex_init(&isert_np->np_accept_mutex);
         INIT_LIST_HEAD(&isert_np->np_accept_list);
         init_completion(&isert_np->np_login_comp);
@@ -3048,18 +3058,6 @@ out:
 }
 
 static int
-isert_check_accept_queue(struct isert_np *isert_np)
-{
-        int empty;
-
-        mutex_lock(&isert_np->np_accept_mutex);
-        empty = list_empty(&isert_np->np_accept_list);
-        mutex_unlock(&isert_np->np_accept_mutex);
-
-        return empty;
-}
-
-static int
 isert_rdma_accept(struct isert_conn *isert_conn)
 {
         struct rdma_cm_id *cm_id = isert_conn->conn_cm_id;
@@ -3151,16 +3149,14 @@ isert_accept_np(struct iscsi_np *np, struct iscsi_conn *conn)
         int max_accept = 0, ret;
 
 accept_wait:
-        ret = wait_event_interruptible(isert_np->np_accept_wq,
-                        !isert_check_accept_queue(isert_np) ||
-                        np->np_thread_state == ISCSI_NP_THREAD_RESET);
+        ret = down_interruptible(&isert_np->np_sem);
         if (max_accept > 5)
                 return -ENODEV;
 
         spin_lock_bh(&np->np_thread_lock);
         if (np->np_thread_state == ISCSI_NP_THREAD_RESET) {
                 spin_unlock_bh(&np->np_thread_lock);
-                pr_err("ISCSI_NP_THREAD_RESET for isert_accept_np\n");
+                pr_debug("ISCSI_NP_THREAD_RESET for isert_accept_np\n");
                 return -ENODEV;
         }
         spin_unlock_bh(&np->np_thread_lock);
diff --git a/drivers/infiniband/ulp/isert/ib_isert.h b/drivers/infiniband/ulp/isert/ib_isert.h
index 4c072ae34c01..da6612e68000 100644
--- a/drivers/infiniband/ulp/isert/ib_isert.h
+++ b/drivers/infiniband/ulp/isert/ib_isert.h
@@ -182,7 +182,7 @@ struct isert_device {
 };
 
 struct isert_np {
-        wait_queue_head_t       np_accept_wq;
+        struct semaphore        np_sem;
         struct rdma_cm_id       *np_cm_id;
         struct mutex            np_accept_mutex;
         struct list_head        np_accept_list;
diff --git a/drivers/iommu/amd_iommu.c b/drivers/iommu/amd_iommu.c
index c949520bd196..57068e8035b5 100644
--- a/drivers/iommu/amd_iommu.c
+++ b/drivers/iommu/amd_iommu.c
@@ -3999,7 +3999,7 @@ static struct irq_remap_table *get_irq_table(u16 devid, bool ioapic)
         iommu_flush_dte(iommu, devid);
         if (devid != alias) {
                 irq_lookup_table[alias] = table;
-                set_dte_irq_entry(devid, table);
+                set_dte_irq_entry(alias, table);
                 iommu_flush_dte(iommu, alias);
         }
 
diff --git a/drivers/iommu/amd_iommu_init.c b/drivers/iommu/amd_iommu_init.c
index b76c58dbe30c..0e08545d7298 100644
--- a/drivers/iommu/amd_iommu_init.c
+++ b/drivers/iommu/amd_iommu_init.c
@@ -788,7 +788,7 @@ static void __init set_device_exclusion_range(u16 devid, struct ivmd_header *m)
                  * per device. But we can enable the exclusion range per
                  * device. This is done here
                  */
-                set_dev_entry_bit(m->devid, DEV_ENTRY_EX);
+                set_dev_entry_bit(devid, DEV_ENTRY_EX);
                 iommu->exclusion_start = m->range_start;
                 iommu->exclusion_length = m->range_length;
         }
diff --git a/drivers/iommu/amd_iommu_v2.c b/drivers/iommu/amd_iommu_v2.c
index 5208828792e6..203b2e6a91cf 100644
--- a/drivers/iommu/amd_iommu_v2.c
+++ b/drivers/iommu/amd_iommu_v2.c
@@ -504,8 +504,10 @@ static void do_fault(struct work_struct *work)
 
         write = !!(fault->flags & PPR_FAULT_WRITE);
 
+        down_read(&fault->state->mm->mmap_sem);
         npages = get_user_pages(fault->state->task, fault->state->mm,
                                 fault->address, 1, write, 0, &page, NULL);
+        up_read(&fault->state->mm->mmap_sem);
 
         if (npages == 1) {
                 put_page(page);
diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
index 784695d22fde..53b213226c01 100644
--- a/drivers/md/dm-crypt.c
+++ b/drivers/md/dm-crypt.c
@@ -19,7 +19,6 @@
 #include <linux/crypto.h>
 #include <linux/workqueue.h>
 #include <linux/backing-dev.h>
-#include <linux/percpu.h>
 #include <linux/atomic.h>
 #include <linux/scatterlist.h>
 #include <asm/page.h>
@@ -43,6 +42,7 @@ struct convert_context {
         struct bvec_iter iter_out;
         sector_t cc_sector;
         atomic_t cc_pending;
+        struct ablkcipher_request *req;
 };
 
 /*
@@ -111,15 +111,7 @@ struct iv_tcw_private {
 enum flags { DM_CRYPT_SUSPENDED, DM_CRYPT_KEY_VALID };
 
 /*
- * Duplicated per-CPU state for cipher.
- */
-struct crypt_cpu {
-        struct ablkcipher_request *req;
-};
-
-/*
- * The fields in here must be read only after initialization,
- * changing state should be in crypt_cpu.
+ * The fields in here must be read only after initialization.
  */
 struct crypt_config {
         struct dm_dev *dev;
@@ -150,12 +142,6 @@ struct crypt_config {
         sector_t iv_offset;
         unsigned int iv_size;
 
-        /*
-         * Duplicated per cpu state. Access through
-         * per_cpu_ptr() only.
-         */
-        struct crypt_cpu __percpu *cpu;
-
         /* ESSIV: struct crypto_cipher *essiv_tfm */
         void *iv_private;
         struct crypto_ablkcipher **tfms;
@@ -192,11 +178,6 @@ static void clone_init(struct dm_crypt_io *, struct bio *);
 static void kcryptd_queue_crypt(struct dm_crypt_io *io);
 static u8 *iv_of_dmreq(struct crypt_config *cc, struct dm_crypt_request *dmreq);
 
-static struct crypt_cpu *this_crypt_config(struct crypt_config *cc)
-{
-        return this_cpu_ptr(cc->cpu);
-}
-
 /*
  * Use this to access cipher attributes that are the same for each CPU.
  */
@@ -903,16 +884,15 @@ static void kcryptd_async_done(struct crypto_async_request *async_req,
 static void crypt_alloc_req(struct crypt_config *cc,
                             struct convert_context *ctx)
 {
-        struct crypt_cpu *this_cc = this_crypt_config(cc);
         unsigned key_index = ctx->cc_sector & (cc->tfms_count - 1);
 
-        if (!this_cc->req)
-                this_cc->req = mempool_alloc(cc->req_pool, GFP_NOIO);
+        if (!ctx->req)
+                ctx->req = mempool_alloc(cc->req_pool, GFP_NOIO);
 
-        ablkcipher_request_set_tfm(this_cc->req, cc->tfms[key_index]);
-        ablkcipher_request_set_callback(this_cc->req,
+        ablkcipher_request_set_tfm(ctx->req, cc->tfms[key_index]);
+        ablkcipher_request_set_callback(ctx->req,
             CRYPTO_TFM_REQ_MAY_BACKLOG | CRYPTO_TFM_REQ_MAY_SLEEP,
-            kcryptd_async_done, dmreq_of_req(cc, this_cc->req));
+            kcryptd_async_done, dmreq_of_req(cc, ctx->req));
 }
 
 /*
@@ -921,7 +901,6 @@ static void crypt_alloc_req(struct crypt_config *cc,
 static int crypt_convert(struct crypt_config *cc,
                          struct convert_context *ctx)
 {
-        struct crypt_cpu *this_cc = this_crypt_config(cc);
         int r;
 
         atomic_set(&ctx->cc_pending, 1);
@@ -932,7 +911,7 @@ static int crypt_convert(struct crypt_config *cc,
 
                 atomic_inc(&ctx->cc_pending);
 
-                r = crypt_convert_block(cc, ctx, this_cc->req);
+                r = crypt_convert_block(cc, ctx, ctx->req);
 
                 switch (r) {
                 /* async */
@@ -941,7 +920,7 @@ static int crypt_convert(struct crypt_config *cc,
                         reinit_completion(&ctx->restart);
                         /* fall through*/
                 case -EINPROGRESS:
-                        this_cc->req = NULL;
+                        ctx->req = NULL;
                         ctx->cc_sector++;
                         continue;
 
@@ -1040,6 +1019,7 @@ static struct dm_crypt_io *crypt_io_alloc(struct crypt_config *cc,
         io->sector = sector;
         io->error = 0;
         io->base_io = NULL;
+        io->ctx.req = NULL;
         atomic_set(&io->io_pending, 0);
 
         return io;
@@ -1065,6 +1045,8 @@ static void crypt_dec_pending(struct dm_crypt_io *io)
         if (!atomic_dec_and_test(&io->io_pending))
                 return;
 
+        if (io->ctx.req)
+                mempool_free(io->ctx.req, cc->req_pool);
         mempool_free(io, cc->io_pool);
 
         if (likely(!base_io))
@@ -1492,8 +1474,6 @@ static int crypt_wipe_key(struct crypt_config *cc)
 static void crypt_dtr(struct dm_target *ti)
 {
         struct crypt_config *cc = ti->private;
-        struct crypt_cpu *cpu_cc;
-        int cpu;
 
         ti->private = NULL;
 
@@ -1505,13 +1485,6 @@ static void crypt_dtr(struct dm_target *ti)
         if (cc->crypt_queue)
                 destroy_workqueue(cc->crypt_queue);
 
-        if (cc->cpu)
-                for_each_possible_cpu(cpu) {
-                        cpu_cc = per_cpu_ptr(cc->cpu, cpu);
-                        if (cpu_cc->req)
-                                mempool_free(cpu_cc->req, cc->req_pool);
-                }
-
         crypt_free_tfms(cc);
 
         if (cc->bs)
@@ -1530,9 +1503,6 @@ static void crypt_dtr(struct dm_target *ti)
         if (cc->dev)
                 dm_put_device(ti, cc->dev);
 
-        if (cc->cpu)
-                free_percpu(cc->cpu);
-
         kzfree(cc->cipher);
         kzfree(cc->cipher_string);
 
@@ -1588,13 +1558,6 @@ static int crypt_ctr_cipher(struct dm_target *ti,
         if (tmp)
                 DMWARN("Ignoring unexpected additional cipher options");
 
-        cc->cpu = __alloc_percpu(sizeof(*(cc->cpu)),
-                                 __alignof__(struct crypt_cpu));
-        if (!cc->cpu) {
-                ti->error = "Cannot allocate per cpu state";
-                goto bad_mem;
-        }
-
         /*
          * For compatibility with the original dm-crypt mapping format, if
          * only the cipher name is supplied, use cbc-plain.
diff --git a/drivers/md/dm-mpath.c b/drivers/md/dm-mpath.c
index aa009e865871..fa0f6cbd6a41 100644
--- a/drivers/md/dm-mpath.c
+++ b/drivers/md/dm-mpath.c
@@ -1566,8 +1566,8 @@ static int multipath_ioctl(struct dm_target *ti, unsigned int cmd,
                 }
                 if (m->pg_init_required)
                         __pg_init_all_paths(m);
-                spin_unlock_irqrestore(&m->lock, flags);
                 dm_table_run_md_queue_async(m->ti->table);
+                spin_unlock_irqrestore(&m->lock, flags);
         }
 
         return r ? : __blkdev_driver_ioctl(bdev, mode, cmd, arg);
diff --git a/drivers/md/dm-thin.c b/drivers/md/dm-thin.c
index 13abade76ad9..2e71de8e0048 100644
--- a/drivers/md/dm-thin.c
+++ b/drivers/md/dm-thin.c
@@ -27,6 +27,7 @@
 #define MAPPING_POOL_SIZE 1024
 #define PRISON_CELLS 1024
 #define COMMIT_PERIOD HZ
+#define NO_SPACE_TIMEOUT (HZ * 60)
 
 DECLARE_DM_KCOPYD_THROTTLE_WITH_MODULE_PARM(snapshot_copy_throttle,
                 "A percentage of time allocated for copy on write");
@@ -175,6 +176,7 @@ struct pool {
         struct workqueue_struct *wq;
         struct work_struct worker;
         struct delayed_work waker;
+        struct delayed_work no_space_timeout;
 
         unsigned long last_commit_jiffies;
         unsigned ref_count;
@@ -935,7 +937,7 @@ static int commit(struct pool *pool)
 {
         int r;
 
-        if (get_pool_mode(pool) != PM_WRITE)
+        if (get_pool_mode(pool) >= PM_READ_ONLY)
                 return -EINVAL;
 
         r = dm_pool_commit_metadata(pool->pmd);
@@ -1590,6 +1592,20 @@ static void do_waker(struct work_struct *ws)
         queue_delayed_work(pool->wq, &pool->waker, COMMIT_PERIOD);
 }
 
+/*
+ * We're holding onto IO to allow userland time to react.  After the
+ * timeout either the pool will have been resized (and thus back in
+ * PM_WRITE mode), or we degrade to PM_READ_ONLY and start erroring IO.
+ */
+static void do_no_space_timeout(struct work_struct *ws)
+{
+        struct pool *pool = container_of(to_delayed_work(ws), struct pool,
+                                         no_space_timeout);
+
+        if (get_pool_mode(pool) == PM_OUT_OF_DATA_SPACE && !pool->pf.error_if_no_space)
+                set_pool_mode(pool, PM_READ_ONLY);
+}
+
 /*----------------------------------------------------------------*/
 
 struct noflush_work {
@@ -1715,6 +1731,9 @@ static void set_pool_mode(struct pool *pool, enum pool_mode new_mode)
                 pool->process_discard = process_discard;
                 pool->process_prepared_mapping = process_prepared_mapping;
                 pool->process_prepared_discard = process_prepared_discard_passdown;
+
+                if (!pool->pf.error_if_no_space)
+                        queue_delayed_work(pool->wq, &pool->no_space_timeout, NO_SPACE_TIMEOUT);
                 break;
 
         case PM_WRITE:
@@ -2100,6 +2119,7 @@ static struct pool *pool_create(struct mapped_device *pool_md,
 
         INIT_WORK(&pool->worker, do_worker);
         INIT_DELAYED_WORK(&pool->waker, do_waker);
+        INIT_DELAYED_WORK(&pool->no_space_timeout, do_no_space_timeout);
         spin_lock_init(&pool->lock);
         bio_list_init(&pool->deferred_flush_bios);
         INIT_LIST_HEAD(&pool->prepared_mappings);
@@ -2662,6 +2682,7 @@ static void pool_postsuspend(struct dm_target *ti)
         struct pool *pool = pt->pool;
 
         cancel_delayed_work(&pool->waker);
+        cancel_delayed_work(&pool->no_space_timeout);
         flush_workqueue(pool->wq);
         (void) commit(pool);
 }
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 8fda38d23e38..237b7e0ddc7a 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -8516,7 +8516,8 @@ static int md_notify_reboot(struct notifier_block *this,
                 if (mddev_trylock(mddev)) {
                         if (mddev->pers)
                                 __md_stop_writes(mddev);
-                        mddev->safemode = 2;
+                        if (mddev->persistent)
+                                mddev->safemode = 2;
                         mddev_unlock(mddev);
                 }
                 need_delay = 1;
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 33fc408e5eac..cb882aae9e20 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -1172,6 +1172,13 @@ static void __make_request(struct mddev *mddev, struct bio *bio)
         int max_sectors;
         int sectors;
 
+        /*
+         * Register the new request and wait if the reconstruction
+         * thread has put up a bar for new requests.
+         * Continue immediately if no resync is active currently.
+         */
+        wait_barrier(conf);
+
         sectors = bio_sectors(bio);
         while (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
             bio->bi_iter.bi_sector < conf->reshape_progress &&
@@ -1552,12 +1559,6 @@ static void make_request(struct mddev *mddev, struct bio *bio)
 
         md_write_start(mddev, bio);
 
-        /*
-         * Register the new request and wait if the reconstruction
-         * thread has put up a bar for new requests.
-         * Continue immediately if no resync is active currently.
-         */
-        wait_barrier(conf);
 
         do {
 
diff --git a/drivers/media/i2c/ov7670.c b/drivers/media/i2c/ov7670.c
index e8a1ce204036..cdd7c1b7259b 100644
--- a/drivers/media/i2c/ov7670.c
+++ b/drivers/media/i2c/ov7670.c
@@ -1109,7 +1109,7 @@ static int ov7670_enum_framesizes(struct v4l2_subdev *sd,
          * windows that fall outside that.
          */
         for (i = 0; i < n_win_sizes; i++) {
-                struct ov7670_win_size *win = &info->devtype->win_sizes[index];
+                struct ov7670_win_size *win = &info->devtype->win_sizes[i];
                 if (info->min_width && win->width < info->min_width)
                         continue;
                 if (info->min_height && win->height < info->min_height)
diff --git a/drivers/media/i2c/s5c73m3/s5c73m3-core.c b/drivers/media/i2c/s5c73m3/s5c73m3-core.c
index a4459301b5f8..ee0f57e01b56 100644
--- a/drivers/media/i2c/s5c73m3/s5c73m3-core.c
+++ b/drivers/media/i2c/s5c73m3/s5c73m3-core.c
@@ -1616,7 +1616,7 @@ static int s5c73m3_get_platform_data(struct s5c73m3 *state)
         if (ret < 0)
                 return -EINVAL;
 
-        node_ep = v4l2_of_get_next_endpoint(node, NULL);
+        node_ep = of_graph_get_next_endpoint(node, NULL);
         if (!node_ep) {
                 dev_warn(dev, "no endpoint defined for node: %s\n",
                                                 node->full_name);
diff --git a/drivers/media/media-device.c b/drivers/media/media-device.c
index d5a7a135f75d..703560fa5e73 100644
--- a/drivers/media/media-device.c
+++ b/drivers/media/media-device.c
@@ -93,6 +93,7 @@ static long media_device_enum_entities(struct media_device *mdev,
         struct media_entity *ent;
         struct media_entity_desc u_ent;
 
+        memset(&u_ent, 0, sizeof(u_ent));
         if (copy_from_user(&u_ent.id, &uent->id, sizeof(u_ent.id)))
                 return -EFAULT;
 
diff --git a/drivers/media/platform/davinci/vpbe_display.c b/drivers/media/platform/davinci/vpbe_display.c
index b4f12d00be05..656708252962 100644
--- a/drivers/media/platform/davinci/vpbe_display.c
+++ b/drivers/media/platform/davinci/vpbe_display.c
@@ -372,18 +372,32 @@ static int vpbe_stop_streaming(struct vb2_queue *vq)
 {
         struct vpbe_fh *fh = vb2_get_drv_priv(vq);
         struct vpbe_layer *layer = fh->layer;
+        struct vpbe_display *disp = fh->disp_dev;
+        unsigned long flags;
 
         if (!vb2_is_streaming(vq))
                 return 0;
 
         /* release all active buffers */
+        spin_lock_irqsave(&disp->dma_queue_lock, flags);
+        if (layer->cur_frm == layer->next_frm) {
+                vb2_buffer_done(&layer->cur_frm->vb, VB2_BUF_STATE_ERROR);
+        } else {
+                if (layer->cur_frm != NULL)
+                        vb2_buffer_done(&layer->cur_frm->vb,
+                                        VB2_BUF_STATE_ERROR);
+                if (layer->next_frm != NULL)
+                        vb2_buffer_done(&layer->next_frm->vb,
+                                        VB2_BUF_STATE_ERROR);
+        }
+
         while (!list_empty(&layer->dma_queue)) {
                 layer->next_frm = list_entry(layer->dma_queue.next,
                                                 struct vpbe_disp_buffer, list);
                 list_del(&layer->next_frm->list);
                 vb2_buffer_done(&layer->next_frm->vb, VB2_BUF_STATE_ERROR);
         }
-
+        spin_unlock_irqrestore(&disp->dma_queue_lock, flags);
         return 0;
 }
 
diff --git a/drivers/media/platform/davinci/vpfe_capture.c b/drivers/media/platform/davinci/vpfe_capture.c
index d762246eabf5..0379cb9f9a9c 100644
--- a/drivers/media/platform/davinci/vpfe_capture.c
+++ b/drivers/media/platform/davinci/vpfe_capture.c
@@ -734,6 +734,8 @@ static int vpfe_release(struct file *file)
                 }
                 vpfe_dev->io_usrs = 0;
                 vpfe_dev->numbuffers = config_params.numbuffers;
+                videobuf_stop(&vpfe_dev->buffer_queue);
+                videobuf_mmap_free(&vpfe_dev->buffer_queue);
         }
 
         /* Decrement device usrs counter */
diff --git a/drivers/media/platform/davinci/vpif_capture.c b/drivers/media/platform/davinci/vpif_capture.c
index 756da78bac23..8dea0b84a3ad 100644
--- a/drivers/media/platform/davinci/vpif_capture.c
+++ b/drivers/media/platform/davinci/vpif_capture.c
@@ -358,8 +358,31 @@ static int vpif_stop_streaming(struct vb2_queue *vq)
 
         common = &ch->common[VPIF_VIDEO_INDEX];
 
+        /* Disable channel as per its device type and channel id */
+        if (VPIF_CHANNEL0_VIDEO == ch->channel_id) {
+                enable_channel0(0);
+                channel0_intr_enable(0);
+        }
+        if ((VPIF_CHANNEL1_VIDEO == ch->channel_id) ||
+                (2 == common->started)) {
+                enable_channel1(0);
+                channel1_intr_enable(0);
+        }
+        common->started = 0;
+
         /* release all active buffers */
         spin_lock_irqsave(&common->irqlock, flags);
+        if (common->cur_frm == common->next_frm) {
+                vb2_buffer_done(&common->cur_frm->vb, VB2_BUF_STATE_ERROR);
+        } else {
+                if (common->cur_frm != NULL)
+                        vb2_buffer_done(&common->cur_frm->vb,
+                                        VB2_BUF_STATE_ERROR);
+                if (common->next_frm != NULL)
+                        vb2_buffer_done(&common->next_frm->vb,
+                                        VB2_BUF_STATE_ERROR);
+        }
+
         while (!list_empty(&common->dma_queue)) {
                 common->next_frm = list_entry(common->dma_queue.next,
                                                 struct vpif_cap_buffer, list);
@@ -933,17 +956,6 @@ static int vpif_release(struct file *filep)
         if (fh->io_allowed[VPIF_VIDEO_INDEX]) {
                 /* Reset io_usrs member of channel object */
                 common->io_usrs = 0;
-                /* Disable channel as per its device type and channel id */
-                if (VPIF_CHANNEL0_VIDEO == ch->channel_id) {
-                        enable_channel0(0);
-                        channel0_intr_enable(0);
-                }
-                if ((VPIF_CHANNEL1_VIDEO == ch->channel_id) ||
-                    (2 == common->started)) {
-                        enable_channel1(0);
-                        channel1_intr_enable(0);
-                }
-                common->started = 0;
                 /* Free buffers allocated */
                 vb2_queue_release(&common->buffer_queue);
                 vb2_dma_contig_cleanup_ctx(common->alloc_ctx);
diff --git a/drivers/media/platform/davinci/vpif_display.c b/drivers/media/platform/davinci/vpif_display.c
index 0ac841e35aa4..aed41edd0501 100644
--- a/drivers/media/platform/davinci/vpif_display.c
+++ b/drivers/media/platform/davinci/vpif_display.c
@@ -320,8 +320,31 @@ static int vpif_stop_streaming(struct vb2_queue *vq)
 
         common = &ch->common[VPIF_VIDEO_INDEX];
 
+        /* Disable channel */
+        if (VPIF_CHANNEL2_VIDEO == ch->channel_id) {
+                enable_channel2(0);
+                channel2_intr_enable(0);
+        }
+        if ((VPIF_CHANNEL3_VIDEO == ch->channel_id) ||
+                (2 == common->started)) {
+                enable_channel3(0);
+                channel3_intr_enable(0);
+        }
+        common->started = 0;
+
         /* release all active buffers */
         spin_lock_irqsave(&common->irqlock, flags);
+        if (common->cur_frm == common->next_frm) {
+                vb2_buffer_done(&common->cur_frm->vb, VB2_BUF_STATE_ERROR);
+        } else {
+                if (common->cur_frm != NULL)
+                        vb2_buffer_done(&common->cur_frm->vb,
+                                        VB2_BUF_STATE_ERROR);
+                if (common->next_frm != NULL)
+                        vb2_buffer_done(&common->next_frm->vb,
+                                        VB2_BUF_STATE_ERROR);
+        }
+
         while (!list_empty(&common->dma_queue)) {
                 common->next_frm = list_entry(common->dma_queue.next,
                                                 struct vpif_disp_buffer, list);
@@ -773,18 +796,6 @@ static int vpif_release(struct file *filep)
         if (fh->io_allowed[VPIF_VIDEO_INDEX]) {
                 /* Reset io_usrs member of channel object */
                 common->io_usrs = 0;
-                /* Disable channel */
-                if (VPIF_CHANNEL2_VIDEO == ch->channel_id) {
-                        enable_channel2(0);
-                        channel2_intr_enable(0);
-                }
-                if ((VPIF_CHANNEL3_VIDEO == ch->channel_id) ||
-                    (2 == common->started)) {
-                        enable_channel3(0);
-                        channel3_intr_enable(0);
-                }
-                common->started = 0;
-
                 /* Free buffers allocated */
                 vb2_queue_release(&common->buffer_queue);
                 vb2_dma_contig_cleanup_ctx(common->alloc_ctx);
diff --git a/drivers/media/platform/exynos4-is/fimc-core.c b/drivers/media/platform/exynos4-is/fimc-core.c
index da2fc86cc524..25dbf5b05a96 100644
--- a/drivers/media/platform/exynos4-is/fimc-core.c
+++ b/drivers/media/platform/exynos4-is/fimc-core.c
@@ -122,7 +122,7 @@ static struct fimc_fmt fimc_formats[] = {
         }, {
                 .name           = "YUV 4:2:2 planar, Y/Cb/Cr",
                 .fourcc         = V4L2_PIX_FMT_YUV422P,
-                .depth          = { 12 },
+                .depth          = { 16 },
                 .color          = FIMC_FMT_YCBYCR422,
                 .memplanes      = 1,
                 .colplanes      = 3,
diff --git a/drivers/media/tuners/fc2580.c b/drivers/media/tuners/fc2580.c
index 3aecaf465094..f0c9c42867de 100644
--- a/drivers/media/tuners/fc2580.c
+++ b/drivers/media/tuners/fc2580.c
@@ -195,7 +195,7 @@ static int fc2580_set_params(struct dvb_frontend *fe)
 
         f_ref = 2UL * priv->cfg->clock / r_val;
         n_val = div_u64_rem(f_vco, f_ref, &k_val);
-        k_val_reg = 1UL * k_val * (1 << 20) / f_ref;
+        k_val_reg = div_u64(1ULL * k_val * (1 << 20), f_ref);
 
         ret = fc2580_wr_reg(priv, 0x18, r18_val | ((k_val_reg >> 16) & 0xff));
         if (ret < 0)
@@ -348,8 +348,8 @@ static int fc2580_set_params(struct dvb_frontend *fe)
         if (ret < 0)
                 goto err;
 
-        ret = fc2580_wr_reg(priv, 0x37, 1UL * priv->cfg->clock * \
-                        fc2580_if_filter_lut[i].mul / 1000000000);
+        ret = fc2580_wr_reg(priv, 0x37, div_u64(1ULL * priv->cfg->clock *
+                        fc2580_if_filter_lut[i].mul, 1000000000));
         if (ret < 0)
                 goto err;
 
diff --git a/drivers/media/tuners/fc2580_priv.h b/drivers/media/tuners/fc2580_priv.h
index be38a9e637e0..646c99452136 100644
--- a/drivers/media/tuners/fc2580_priv.h
+++ b/drivers/media/tuners/fc2580_priv.h
@@ -22,6 +22,7 @@
 #define FC2580_PRIV_H
 
 #include "fc2580.h"
+#include <linux/math64.h>
 
 struct fc2580_reg_val {
         u8 reg;
diff --git a/drivers/media/usb/dvb-usb-v2/Makefile b/drivers/media/usb/dvb-usb-v2/Makefile
index 7407b8338ccf..bc38f03394cd 100644
--- a/drivers/media/usb/dvb-usb-v2/Makefile
+++ b/drivers/media/usb/dvb-usb-v2/Makefile
@@ -41,4 +41,3 @@ ccflags-y += -I$(srctree)/drivers/media/dvb-core
 ccflags-y += -I$(srctree)/drivers/media/dvb-frontends
 ccflags-y += -I$(srctree)/drivers/media/tuners
 ccflags-y += -I$(srctree)/drivers/media/common
-ccflags-y += -I$(srctree)/drivers/staging/media/rtl2832u_sdr
diff --git a/drivers/media/usb/dvb-usb-v2/rtl28xxu.c b/drivers/media/usb/dvb-usb-v2/rtl28xxu.c
index 61d196e8b3ab..dcbd392e6efc 100644
--- a/drivers/media/usb/dvb-usb-v2/rtl28xxu.c
+++ b/drivers/media/usb/dvb-usb-v2/rtl28xxu.c
@@ -24,7 +24,6 @@
 
 #include "rtl2830.h"
 #include "rtl2832.h"
-#include "rtl2832_sdr.h"
 
 #include "qt1010.h"
 #include "mt2060.h"
@@ -36,6 +35,45 @@
 #include "tua9001.h"
 #include "r820t.h"
 
+/*
+ * RTL2832_SDR module is in staging. That logic is added in order to avoid any
+ * hard dependency to drivers/staging/ directory as we want compile mainline
+ * driver even whole staging directory is missing.
+ */
+#include <media/v4l2-subdev.h>
+
+#if IS_ENABLED(CONFIG_DVB_RTL2832_SDR)
+struct dvb_frontend *rtl2832_sdr_attach(struct dvb_frontend *fe,
+        struct i2c_adapter *i2c, const struct rtl2832_config *cfg,
+        struct v4l2_subdev *sd);
+#else
+static inline struct dvb_frontend *rtl2832_sdr_attach(struct dvb_frontend *fe,
+        struct i2c_adapter *i2c, const struct rtl2832_config *cfg,
+        struct v4l2_subdev *sd)
+{
+        return NULL;
+}
+#endif
+
+#ifdef CONFIG_MEDIA_ATTACH
+#define dvb_attach_sdr(FUNCTION, ARGS...) ({ \
+        void *__r = NULL; \
+        typeof(&FUNCTION) __a = symbol_request(FUNCTION); \
+        if (__a) { \
+                __r = (void *) __a(ARGS); \
+                if (__r == NULL) \
+                        symbol_put(FUNCTION); \
+        } \
+        __r; \
+})
+
+#else
+#define dvb_attach_sdr(FUNCTION, ARGS...) ({ \
+        FUNCTION(ARGS); \
+})
+
+#endif
+
 static int rtl28xxu_disable_rc;
 module_param_named(disable_rc, rtl28xxu_disable_rc, int, 0644);
 MODULE_PARM_DESC(disable_rc, "disable RTL2832U remote controller");
@@ -908,7 +946,7 @@ static int rtl2832u_tuner_attach(struct dvb_usb_adapter *adap)
                                 adap->fe[0]->ops.tuner_ops.get_rf_strength;
 
                 /* attach SDR */
-                dvb_attach(rtl2832_sdr_attach, adap->fe[0], &d->i2c_adap,
+                dvb_attach_sdr(rtl2832_sdr_attach, adap->fe[0], &d->i2c_adap,
                                 &rtl28xxu_rtl2832_fc0012_config, NULL);
                 break;
         case TUNER_RTL2832_FC0013:
@@ -920,7 +958,7 @@ static int rtl2832u_tuner_attach(struct dvb_usb_adapter *adap)
                                 adap->fe[0]->ops.tuner_ops.get_rf_strength;
 
                 /* attach SDR */
-                dvb_attach(rtl2832_sdr_attach, adap->fe[0], &d->i2c_adap,
+                dvb_attach_sdr(rtl2832_sdr_attach, adap->fe[0], &d->i2c_adap,
                                 &rtl28xxu_rtl2832_fc0013_config, NULL);
                 break;
         case TUNER_RTL2832_E4000: {
@@ -951,7 +989,7 @@ static int rtl2832u_tuner_attach(struct dvb_usb_adapter *adap)
                         i2c_set_adapdata(i2c_adap_internal, d);
 
                         /* attach SDR */
-                        dvb_attach(rtl2832_sdr_attach, adap->fe[0],
+                        dvb_attach_sdr(rtl2832_sdr_attach, adap->fe[0],
                                         i2c_adap_internal,
                                         &rtl28xxu_rtl2832_e4000_config, sd);
                 }
@@ -982,7 +1020,7 @@ static int rtl2832u_tuner_attach(struct dvb_usb_adapter *adap)
                                 adap->fe[0]->ops.tuner_ops.get_rf_strength;
 
                 /* attach SDR */
-                dvb_attach(rtl2832_sdr_attach, adap->fe[0], &d->i2c_adap,
+                dvb_attach_sdr(rtl2832_sdr_attach, adap->fe[0], &d->i2c_adap,
                                 &rtl28xxu_rtl2832_r820t_config, NULL);
                 break;
         case TUNER_RTL2832_R828D:
diff --git a/drivers/media/usb/gspca/sonixb.c b/drivers/media/usb/gspca/sonixb.c
index 7277dbd2afcd..ecbcb39feb71 100644
--- a/drivers/media/usb/gspca/sonixb.c
+++ b/drivers/media/usb/gspca/sonixb.c
@@ -1430,10 +1430,8 @@ static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x0c45, 0x600d), SB(PAS106, 101)},
         {USB_DEVICE(0x0c45, 0x6011), SB(OV6650, 101)},
         {USB_DEVICE(0x0c45, 0x6019), SB(OV7630, 101)},
-#if !IS_ENABLED(CONFIG_USB_SN9C102)
         {USB_DEVICE(0x0c45, 0x6024), SB(TAS5130CXX, 102)},
         {USB_DEVICE(0x0c45, 0x6025), SB(TAS5130CXX, 102)},
-#endif
         {USB_DEVICE(0x0c45, 0x6027), SB(OV7630, 101)}, /* Genius Eye 310 */
         {USB_DEVICE(0x0c45, 0x6028), SB(PAS202, 102)},
         {USB_DEVICE(0x0c45, 0x6029), SB(PAS106, 102)},
diff --git a/drivers/media/v4l2-core/v4l2-compat-ioctl32.c b/drivers/media/v4l2-core/v4l2-compat-ioctl32.c
index 04b2daf567be..7e2411c36419 100644
--- a/drivers/media/v4l2-core/v4l2-compat-ioctl32.c
+++ b/drivers/media/v4l2-core/v4l2-compat-ioctl32.c
@@ -178,6 +178,9 @@ struct v4l2_create_buffers32 {
 
 static int __get_v4l2_format32(struct v4l2_format *kp, struct v4l2_format32 __user *up)
 {
+        if (get_user(kp->type, &up->type))
+                return -EFAULT;
+
         switch (kp->type) {
         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
         case V4L2_BUF_TYPE_VIDEO_OUTPUT:
@@ -204,17 +207,16 @@ static int __get_v4l2_format32(struct v4l2_format *kp, struct v4l2_format32 __us
 
 static int get_v4l2_format32(struct v4l2_format *kp, struct v4l2_format32 __user *up)
 {
-        if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_format32)) ||
-                        get_user(kp->type, &up->type))
-                        return -EFAULT;
+        if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_format32)))
+                return -EFAULT;
         return __get_v4l2_format32(kp, up);
 }
 
 static int get_v4l2_create32(struct v4l2_create_buffers *kp, struct v4l2_create_buffers32 __user *up)
 {
         if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_create_buffers32)) ||
-            copy_from_user(kp, up, offsetof(struct v4l2_create_buffers32, format.fmt)))
-                        return -EFAULT;
+            copy_from_user(kp, up, offsetof(struct v4l2_create_buffers32, format)))
+                return -EFAULT;
         return __get_v4l2_format32(&kp->format, &up->format);
 }
 
diff --git a/drivers/memory/mvebu-devbus.c b/drivers/memory/mvebu-devbus.c
index 110c03627051..b59a17fb7c3e 100644
--- a/drivers/memory/mvebu-devbus.c
+++ b/drivers/memory/mvebu-devbus.c
@@ -108,8 +108,19 @@ static int devbus_set_timing_params(struct devbus *devbus,
                         node->full_name);
                 return err;
         }
-        /* Convert bit width to byte width */
-        r.bus_width /= 8;
+
+        /*
+         * The bus width is encoded into the register as 0 for 8 bits,
+         * and 1 for 16 bits, so we do the necessary conversion here.
+         */
+        if (r.bus_width == 8)
+                r.bus_width = 0;
+        else if (r.bus_width == 16)
+                r.bus_width = 1;
+        else {
+                dev_err(devbus->dev, "invalid bus width %d\n", r.bus_width);
+                return -EINVAL;
+        }
 
         err = get_timing_param_ps(devbus, node, "devbus,badr-skew-ps",
                                  &r.badr_skew);
diff --git a/drivers/of/base.c b/drivers/of/base.c
index 6d4ee22708c9..32e969d95319 100644
--- a/drivers/of/base.c
+++ b/drivers/of/base.c
@@ -1831,6 +1831,10 @@ int of_update_property(struct device_node *np, struct property *newprop)
         if (!found)
                 return -ENODEV;
 
+        /* At early boot, bail out and defer setup to of_init() */
+        if (!of_kset)
+                return found ? 0 : -ENODEV;
+
         /* Update the sysfs attribute */
         sysfs_remove_bin_file(&np->kobj, &oldprop->attr);
         __of_add_property_sysfs(np, newprop);
diff --git a/drivers/pci/host/pci-mvebu.c b/drivers/pci/host/pci-mvebu.c
index d3d1cfd51e09..e384e2534594 100644
--- a/drivers/pci/host/pci-mvebu.c
+++ b/drivers/pci/host/pci-mvebu.c
@@ -293,6 +293,58 @@ static int mvebu_pcie_hw_wr_conf(struct mvebu_pcie_port *port,
         return PCIBIOS_SUCCESSFUL;
 }
 
+/*
+ * Remove windows, starting from the largest ones to the smallest
+ * ones.
+ */
+static void mvebu_pcie_del_windows(struct mvebu_pcie_port *port,
+                                   phys_addr_t base, size_t size)
+{
+        while (size) {
+                size_t sz = 1 << (fls(size) - 1);
+
+                mvebu_mbus_del_window(base, sz);
+                base += sz;
+                size -= sz;
+        }
+}
+
+/*
+ * MBus windows can only have a power of two size, but PCI BARs do not
+ * have this constraint. Therefore, we have to split the PCI BAR into
+ * areas each having a power of two size. We start from the largest
+ * one (i.e highest order bit set in the size).
+ */
+static void mvebu_pcie_add_windows(struct mvebu_pcie_port *port,
+                                   unsigned int target, unsigned int attribute,
+                                   phys_addr_t base, size_t size,
+                                   phys_addr_t remap)
+{
+        size_t size_mapped = 0;
+
+        while (size) {
+                size_t sz = 1 << (fls(size) - 1);
+                int ret;
+
+                ret = mvebu_mbus_add_window_remap_by_id(target, attribute, base,
+                                                        sz, remap);
+                if (ret) {
+                        dev_err(&port->pcie->pdev->dev,
+                                "Could not create MBus window at 0x%x, size 0x%x: %d\n",
+                                base, sz, ret);
+                        mvebu_pcie_del_windows(port, base - size_mapped,
+                                               size_mapped);
+                        return;
+                }
+
+                size -= sz;
+                size_mapped += sz;
+                base += sz;
+                if (remap != MVEBU_MBUS_NO_REMAP)
+                        remap += sz;
+        }
+}
+
 static void mvebu_pcie_handle_iobase_change(struct mvebu_pcie_port *port)
 {
         phys_addr_t iobase;
@@ -304,8 +356,8 @@ static void mvebu_pcie_handle_iobase_change(struct mvebu_pcie_port *port)
 
                 /* If a window was configured, remove it */
                 if (port->iowin_base) {
-                        mvebu_mbus_del_window(port->iowin_base,
-                                              port->iowin_size);
+                        mvebu_pcie_del_windows(port, port->iowin_base,
+                                               port->iowin_size);
                         port->iowin_base = 0;
                         port->iowin_size = 0;
                 }
@@ -331,11 +383,11 @@ static void mvebu_pcie_handle_iobase_change(struct mvebu_pcie_port *port)
         port->iowin_base = port->pcie->io.start + iobase;
         port->iowin_size = ((0xFFF | ((port->bridge.iolimit & 0xF0) << 8) |
                             (port->bridge.iolimitupper << 16)) -
-                            iobase);
+                            iobase) + 1;
 
-        mvebu_mbus_add_window_remap_by_id(port->io_target, port->io_attr,
-                                          port->iowin_base, port->iowin_size,
-                                          iobase);
+        mvebu_pcie_add_windows(port, port->io_target, port->io_attr,
+                               port->iowin_base, port->iowin_size,
+                               iobase);
 }
 
 static void mvebu_pcie_handle_membase_change(struct mvebu_pcie_port *port)
@@ -346,8 +398,8 @@ static void mvebu_pcie_handle_membase_change(struct mvebu_pcie_port *port)
 
                 /* If a window was configured, remove it */
                 if (port->memwin_base) {
-                        mvebu_mbus_del_window(port->memwin_base,
-                                              port->memwin_size);
+                        mvebu_pcie_del_windows(port, port->memwin_base,
+                                               port->memwin_size);
                         port->memwin_base = 0;
                         port->memwin_size = 0;
                 }
@@ -364,10 +416,11 @@ static void mvebu_pcie_handle_membase_change(struct mvebu_pcie_port *port)
         port->memwin_base  = ((port->bridge.membase & 0xFFF0) << 16);
         port->memwin_size  =
                 (((port->bridge.memlimit & 0xFFF0) << 16) | 0xFFFFF) -
-                port->memwin_base;
+                port->memwin_base + 1;
 
-        mvebu_mbus_add_window_by_id(port->mem_target, port->mem_attr,
-                                    port->memwin_base, port->memwin_size);
+        mvebu_pcie_add_windows(port, port->mem_target, port->mem_attr,
+                               port->memwin_base, port->memwin_size,
+                               MVEBU_MBUS_NO_REMAP);
 }
 
 /*
@@ -743,14 +796,21 @@ static resource_size_t mvebu_pcie_align_resource(struct pci_dev *dev,
 
         /*
          * On the PCI-to-PCI bridge side, the I/O windows must have at
-         * least a 64 KB size and be aligned on their size, and the
-         * memory windows must have at least a 1 MB size and be
-         * aligned on their size
+         * least a 64 KB size and the memory windows must have at
+         * least a 1 MB size. Moreover, MBus windows need to have a
+         * base address aligned on their size, and their size must be
+         * a power of two. This means that if the BAR doesn't have a
+         * power of two size, several MBus windows will actually be
+         * created. We need to ensure that the biggest MBus window
+         * (which will be the first one) is aligned on its size, which
+         * explains the rounddown_pow_of_two() being done here.
          */
         if (res->flags & IORESOURCE_IO)
-                return round_up(start, max_t(resource_size_t, SZ_64K, size));
+                return round_up(start, max_t(resource_size_t, SZ_64K,
+                                             rounddown_pow_of_two(size)));
         else if (res->flags & IORESOURCE_MEM)
-                return round_up(start, max_t(resource_size_t, SZ_1M, size));
+                return round_up(start, max_t(resource_size_t, SZ_1M,
+                                             rounddown_pow_of_two(size)));
         else
                 return start;
 }
diff --git a/drivers/pci/hotplug/shpchp_ctrl.c b/drivers/pci/hotplug/shpchp_ctrl.c
index 58499277903a..6efc2ec5e4db 100644
--- a/drivers/pci/hotplug/shpchp_ctrl.c
+++ b/drivers/pci/hotplug/shpchp_ctrl.c
@@ -282,8 +282,8 @@ static int board_added(struct slot *p_slot)
                 return WRONG_BUS_FREQUENCY;
         }
 
-        bsp = ctrl->pci_dev->bus->cur_bus_speed;
-        msp = ctrl->pci_dev->bus->max_bus_speed;
+        bsp = ctrl->pci_dev->subordinate->cur_bus_speed;
+        msp = ctrl->pci_dev->subordinate->max_bus_speed;
 
         /* Check if there are other slots or devices on the same bus */
         if (!list_empty(&ctrl->pci_dev->subordinate->devices))
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index 7325d43bf030..759475ef6ff3 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -3067,7 +3067,8 @@ int pci_wait_for_pending_transaction(struct pci_dev *dev)
         if (!pci_is_pcie(dev))
                 return 1;
 
-        return pci_wait_for_pending(dev, PCI_EXP_DEVSTA, PCI_EXP_DEVSTA_TRPND);
+        return pci_wait_for_pending(dev, pci_pcie_cap(dev) + PCI_EXP_DEVSTA,
+                                    PCI_EXP_DEVSTA_TRPND);
 }
 EXPORT_SYMBOL(pci_wait_for_pending_transaction);
 
@@ -3109,7 +3110,7 @@ static int pci_af_flr(struct pci_dev *dev, int probe)
                 return 0;
 
         /* Wait for Transaction Pending bit clean */
-        if (pci_wait_for_pending(dev, PCI_AF_STATUS, PCI_AF_STATUS_TP))
+        if (pci_wait_for_pending(dev, pos + PCI_AF_STATUS, PCI_AF_STATUS_TP))
                 goto clear;
 
         dev_err(&dev->dev, "transaction is not cleared; "
diff --git a/drivers/rtc/rtc-hym8563.c b/drivers/rtc/rtc-hym8563.c
index bd628a6f981d..e5f13c4310fe 100644
--- a/drivers/rtc/rtc-hym8563.c
+++ b/drivers/rtc/rtc-hym8563.c
@@ -569,6 +569,9 @@ static int hym8563_probe(struct i2c_client *client,
         if (IS_ERR(hym8563->rtc))
                 return PTR_ERR(hym8563->rtc);
 
+        /* the hym8563 alarm only supports a minute accuracy */
+        hym8563->rtc->uie_unsupported = 1;
+
 #ifdef CONFIG_COMMON_CLK
         hym8563_clkout_register_clk(hym8563);
 #endif
diff --git a/drivers/sh/Makefile b/drivers/sh/Makefile
index fc67f564f02c..788ed9b59b4e 100644
--- a/drivers/sh/Makefile
+++ b/drivers/sh/Makefile
@@ -1,10 +1,12 @@
 #
 # Makefile for the SuperH specific drivers.
 #
-obj-y   := intc/
+obj-$(CONFIG_SUPERH)                    += intc/
+obj-$(CONFIG_ARCH_SHMOBILE_LEGACY)      += intc/
+ifneq ($(CONFIG_COMMON_CLK),y)
+obj-$(CONFIG_HAVE_CLK)                  += clk/
+endif
+obj-$(CONFIG_MAPLE)                     += maple/
+obj-$(CONFIG_SUPERHYWAY)                += superhyway/
 
-obj-$(CONFIG_HAVE_CLK)          += clk/
-obj-$(CONFIG_MAPLE)             += maple/
-obj-$(CONFIG_SUPERHYWAY)        += superhyway/
-
-obj-y                           += pm_runtime.o
+obj-y                                   += pm_runtime.o
diff --git a/drivers/sh/pm_runtime.c b/drivers/sh/pm_runtime.c
index 8afa5a4589f2..10c65eb51f85 100644
--- a/drivers/sh/pm_runtime.c
+++ b/drivers/sh/pm_runtime.c
@@ -50,8 +50,25 @@ static struct pm_clk_notifier_block platform_bus_notifier = {
         .con_ids = { NULL, },
 };
 
+static bool default_pm_on;
+
 static int __init sh_pm_runtime_init(void)
 {
+        if (IS_ENABLED(CONFIG_ARCH_SHMOBILE_MULTI)) {
+                if (!of_machine_is_compatible("renesas,emev2") &&
+                    !of_machine_is_compatible("renesas,r7s72100") &&
+                    !of_machine_is_compatible("renesas,r8a73a4") &&
+                    !of_machine_is_compatible("renesas,r8a7740") &&
+                    !of_machine_is_compatible("renesas,r8a7778") &&
+                    !of_machine_is_compatible("renesas,r8a7779") &&
+                    !of_machine_is_compatible("renesas,r8a7790") &&
+                    !of_machine_is_compatible("renesas,r8a7791") &&
+                    !of_machine_is_compatible("renesas,sh7372") &&
+                    !of_machine_is_compatible("renesas,sh73a0"))
+                        return 0;
+        }
+
+        default_pm_on = true;
         pm_clk_add_notifier(&platform_bus_type, &platform_bus_notifier);
         return 0;
 }
@@ -59,7 +76,8 @@ core_initcall(sh_pm_runtime_init);
 
 static int __init sh_pm_runtime_late_init(void)
 {
-        pm_genpd_poweroff_unused();
+        if (default_pm_on)
+                pm_genpd_poweroff_unused();
         return 0;
 }
 late_initcall(sh_pm_runtime_late_init);
diff --git a/drivers/spi/spi-pxa2xx-dma.c b/drivers/spi/spi-pxa2xx-dma.c
index 713af4806f26..f6759dc0153b 100644
--- a/drivers/spi/spi-pxa2xx-dma.c
+++ b/drivers/spi/spi-pxa2xx-dma.c
@@ -29,18 +29,6 @@ static int pxa2xx_spi_map_dma_buffer(struct driver_data *drv_data,
         struct sg_table *sgt;
         void *buf, *pbuf;
 
-        /*
-         * Some DMA controllers have problems transferring buffers that are
-         * not multiple of 4 bytes. So we truncate the transfer so that it
-         * is suitable for such controllers, and handle the trailing bytes
-         * manually after the DMA completes.
-         *
-         * REVISIT: It would be better if this information could be
-         * retrieved directly from the DMA device in a similar way than
-         * ->copy_align etc. is done.
-         */
-        len = ALIGN(drv_data->len, 4);
-
         if (dir == DMA_TO_DEVICE) {
                 dmadev = drv_data->tx_chan->device->dev;
                 sgt = &drv_data->tx_sgt;
@@ -144,12 +132,8 @@ static void pxa2xx_spi_dma_transfer_complete(struct driver_data *drv_data,
                 if (!error) {
                         pxa2xx_spi_unmap_dma_buffers(drv_data);
 
-                        /* Handle the last bytes of unaligned transfer */
                         drv_data->tx += drv_data->tx_map_len;
-                        drv_data->write(drv_data);
-
                         drv_data->rx += drv_data->rx_map_len;
-                        drv_data->read(drv_data);
 
                         msg->actual_length += drv_data->len;
                         msg->state = pxa2xx_spi_next_transfer(drv_data);
diff --git a/drivers/spi/spi-qup.c b/drivers/spi/spi-qup.c
index b032e8885e24..78c66e3c53ed 100644
--- a/drivers/spi/spi-qup.c
+++ b/drivers/spi/spi-qup.c
@@ -734,7 +734,7 @@ static int spi_qup_remove(struct platform_device *pdev)
         int ret;
 
         ret = pm_runtime_get_sync(&pdev->dev);
-        if (ret)
+        if (ret < 0)
                 return ret;
 
         ret = spi_qup_set_state(controller, QUP_STATE_RESET);
diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c
index 4eb9bf02996c..939edf473235 100644
--- a/drivers/spi/spi.c
+++ b/drivers/spi/spi.c
@@ -580,6 +580,7 @@ static void spi_set_cs(struct spi_device *spi, bool enable)
                 spi->master->set_cs(spi, !enable);
 }
 
+#ifdef CONFIG_HAS_DMA
 static int spi_map_buf(struct spi_master *master, struct device *dev,
                        struct sg_table *sgt, void *buf, size_t len,
                        enum dma_data_direction dir)
@@ -637,55 +638,12 @@ static void spi_unmap_buf(struct spi_master *master, struct device *dev,
         }
 }
 
-static int spi_map_msg(struct spi_master *master, struct spi_message *msg)
+static int __spi_map_msg(struct spi_master *master, struct spi_message *msg)
 {
         struct device *tx_dev, *rx_dev;
         struct spi_transfer *xfer;
-        void *tmp;
-        unsigned int max_tx, max_rx;
         int ret;
 
-        if (master->flags & (SPI_MASTER_MUST_RX | SPI_MASTER_MUST_TX)) {
-                max_tx = 0;
-                max_rx = 0;
-
-                list_for_each_entry(xfer, &msg->transfers, transfer_list) {
-                        if ((master->flags & SPI_MASTER_MUST_TX) &&
-                            !xfer->tx_buf)
-                                max_tx = max(xfer->len, max_tx);
-                        if ((master->flags & SPI_MASTER_MUST_RX) &&
-                            !xfer->rx_buf)
-                                max_rx = max(xfer->len, max_rx);
-                }
-
-                if (max_tx) {
-                        tmp = krealloc(master->dummy_tx, max_tx,
-                                       GFP_KERNEL | GFP_DMA);
-                        if (!tmp)
-                                return -ENOMEM;
-                        master->dummy_tx = tmp;
-                        memset(tmp, 0, max_tx);
-                }
-
-                if (max_rx) {
-                        tmp = krealloc(master->dummy_rx, max_rx,
-                                       GFP_KERNEL | GFP_DMA);
-                        if (!tmp)
-                                return -ENOMEM;
-                        master->dummy_rx = tmp;
-                }
-
-                if (max_tx || max_rx) {
-                        list_for_each_entry(xfer, &msg->transfers,
-                                            transfer_list) {
-                                if (!xfer->tx_buf)
-                                        xfer->tx_buf = master->dummy_tx;
-                                if (!xfer->rx_buf)
-                                        xfer->rx_buf = master->dummy_rx;
-                        }
-                }
-        }
-
         if (!master->can_dma)
                 return 0;
 
@@ -742,6 +700,69 @@ static int spi_unmap_msg(struct spi_master *master, struct spi_message *msg)
 
         return 0;
 }
+#else /* !CONFIG_HAS_DMA */
+static inline int __spi_map_msg(struct spi_master *master,
+                                struct spi_message *msg)
+{
+        return 0;
+}
+
+static inline int spi_unmap_msg(struct spi_master *master,
+                                struct spi_message *msg)
+{
+        return 0;
+}
+#endif /* !CONFIG_HAS_DMA */
+
+static int spi_map_msg(struct spi_master *master, struct spi_message *msg)
+{
+        struct spi_transfer *xfer;
+        void *tmp;
+        unsigned int max_tx, max_rx;
+
+        if (master->flags & (SPI_MASTER_MUST_RX | SPI_MASTER_MUST_TX)) {
+                max_tx = 0;
+                max_rx = 0;
+
+                list_for_each_entry(xfer, &msg->transfers, transfer_list) {
+                        if ((master->flags & SPI_MASTER_MUST_TX) &&
+                            !xfer->tx_buf)
+                                max_tx = max(xfer->len, max_tx);
+                        if ((master->flags & SPI_MASTER_MUST_RX) &&
+                            !xfer->rx_buf)
+                                max_rx = max(xfer->len, max_rx);
+                }
+
+                if (max_tx) {
+                        tmp = krealloc(master->dummy_tx, max_tx,
+                                       GFP_KERNEL | GFP_DMA);
+                        if (!tmp)
+                                return -ENOMEM;
+                        master->dummy_tx = tmp;
+                        memset(tmp, 0, max_tx);
+                }
+
+                if (max_rx) {
+                        tmp = krealloc(master->dummy_rx, max_rx,
+                                       GFP_KERNEL | GFP_DMA);
+                        if (!tmp)
+                                return -ENOMEM;
+                        master->dummy_rx = tmp;
+                }
+
+                if (max_tx || max_rx) {
+                        list_for_each_entry(xfer, &msg->transfers,
+                                            transfer_list) {
+                                if (!xfer->tx_buf)
+                                        xfer->tx_buf = master->dummy_tx;
+                                if (!xfer->rx_buf)
+                                        xfer->rx_buf = master->dummy_rx;
+                        }
+                }
+        }
+
+        return __spi_map_msg(master, msg);
+}
 
 /*
  * spi_transfer_one_message - Default implementation of transfer_one_message()
@@ -1151,7 +1172,6 @@ static int spi_master_initialize_queue(struct spi_master *master)
 {
         int ret;
 
-        master->queued = true;
         master->transfer = spi_queued_transfer;
         if (!master->transfer_one_message)
                 master->transfer_one_message = spi_transfer_one_message;
@@ -1162,6 +1182,7 @@ static int spi_master_initialize_queue(struct spi_master *master)
                 dev_err(&master->dev, "problem initializing queue\n");
                 goto err_init_queue;
         }
+        master->queued = true;
         ret = spi_start_queue(master);
         if (ret) {
                 dev_err(&master->dev, "problem starting queue\n");
@@ -1171,8 +1192,8 @@ static int spi_master_initialize_queue(struct spi_master *master)
         return 0;
 
 err_start_queue:
-err_init_queue:
         spi_destroy_queue(master);
+err_init_queue:
         return ret;
 }
 
@@ -1756,7 +1777,7 @@ EXPORT_SYMBOL_GPL(spi_busnum_to_master);
  */
 int spi_setup(struct spi_device *spi)
 {
-        unsigned        bad_bits;
+        unsigned        bad_bits, ugly_bits;
         int             status = 0;
 
         /* check mode to prevent that DUAL and QUAD set at the same time
@@ -1776,6 +1797,15 @@ int spi_setup(struct spi_device *spi)
          * that aren't supported with their current master
          */
         bad_bits = spi->mode & ~spi->master->mode_bits;
+        ugly_bits = bad_bits &
+                    (SPI_TX_DUAL | SPI_TX_QUAD | SPI_RX_DUAL | SPI_RX_QUAD);
+        if (ugly_bits) {
+                dev_warn(&spi->dev,
+                         "setup: ignoring unsupported mode bits %x\n",
+                         ugly_bits);
+                spi->mode &= ~ugly_bits;
+                bad_bits &= ~ugly_bits;
+        }
         if (bad_bits) {
                 dev_err(&spi->dev, "setup: unsupported mode bits %x\n",
                         bad_bits);
diff --git a/drivers/staging/imx-drm/imx-drm-core.c b/drivers/staging/imx-drm/imx-drm-core.c
index 4144a75e5f71..c270c9ae6d27 100644
--- a/drivers/staging/imx-drm/imx-drm-core.c
+++ b/drivers/staging/imx-drm/imx-drm-core.c
@@ -517,7 +517,7 @@ int imx_drm_encoder_get_mux_id(struct device_node *node,
                 of_node_put(port);
                 if (port == imx_crtc->port) {
                         ret = of_graph_parse_endpoint(ep, &endpoint);
-                        return ret ? ret : endpoint.id;
+                        return ret ? ret : endpoint.port;
                 }
         } while (ep);
 
@@ -675,6 +675,11 @@ static int imx_drm_platform_probe(struct platform_device *pdev)
                         if (!remote || !of_device_is_available(remote)) {
                                 of_node_put(remote);
                                 continue;
+                        } else if (!of_device_is_available(remote->parent)) {
+                                dev_warn(&pdev->dev, "parent device of %s is not available\n",
+                                         remote->full_name);
+                                of_node_put(remote);
+                                continue;
                         }
 
                         ret = imx_drm_add_component(&pdev->dev, remote);
diff --git a/drivers/staging/imx-drm/imx-tve.c b/drivers/staging/imx-drm/imx-tve.c
index 575533f4fd64..a23f4f773146 100644
--- a/drivers/staging/imx-drm/imx-tve.c
+++ b/drivers/staging/imx-drm/imx-tve.c
@@ -582,7 +582,7 @@ static int imx_tve_bind(struct device *dev, struct device *master, void *data)
         tve->dev = dev;
         spin_lock_init(&tve->lock);
 
-        ddc_node = of_parse_phandle(np, "i2c-ddc-bus", 0);
+        ddc_node = of_parse_phandle(np, "ddc-i2c-bus", 0);
         if (ddc_node) {
                 tve->ddc = of_find_i2c_adapter_by_node(ddc_node);
                 of_node_put(ddc_node);
diff --git a/drivers/staging/media/davinci_vpfe/vpfe_video.c b/drivers/staging/media/davinci_vpfe/vpfe_video.c
index 8c101cbbee97..acc8184c46cd 100644
--- a/drivers/staging/media/davinci_vpfe/vpfe_video.c
+++ b/drivers/staging/media/davinci_vpfe/vpfe_video.c
@@ -1247,9 +1247,18 @@ static int vpfe_stop_streaming(struct vb2_queue *vq)
         struct vpfe_fh *fh = vb2_get_drv_priv(vq);
         struct vpfe_video_device *video = fh->video;
 
-        if (!vb2_is_streaming(vq))
-                return 0;
         /* release all active buffers */
+        if (video->cur_frm == video->next_frm) {
+                vb2_buffer_done(&video->cur_frm->vb, VB2_BUF_STATE_ERROR);
+        } else {
+                if (video->cur_frm != NULL)
+                        vb2_buffer_done(&video->cur_frm->vb,
+                                        VB2_BUF_STATE_ERROR);
+                if (video->next_frm != NULL)
+                        vb2_buffer_done(&video->next_frm->vb,
+                                        VB2_BUF_STATE_ERROR);
+        }
+
         while (!list_empty(&video->dma_queue)) {
                 video->next_frm = list_entry(video->dma_queue.next,
                                                 struct vpfe_cap_buffer, list);
diff --git a/drivers/staging/media/sn9c102/sn9c102_devtable.h b/drivers/staging/media/sn9c102/sn9c102_devtable.h
index b3d2cc729657..4ba569258498 100644
--- a/drivers/staging/media/sn9c102/sn9c102_devtable.h
+++ b/drivers/staging/media/sn9c102/sn9c102_devtable.h
@@ -48,10 +48,8 @@ static const struct usb_device_id sn9c102_id_table[] = {
         { SN9C102_USB_DEVICE(0x0c45, 0x600d, BRIDGE_SN9C102), },
 /*      { SN9C102_USB_DEVICE(0x0c45, 0x6011, BRIDGE_SN9C102), }, OV6650 */
         { SN9C102_USB_DEVICE(0x0c45, 0x6019, BRIDGE_SN9C102), },
-#endif
         { SN9C102_USB_DEVICE(0x0c45, 0x6024, BRIDGE_SN9C102), },
         { SN9C102_USB_DEVICE(0x0c45, 0x6025, BRIDGE_SN9C102), },
-#if !defined CONFIG_USB_GSPCA_SONIXB && !defined CONFIG_USB_GSPCA_SONIXB_MODULE
         { SN9C102_USB_DEVICE(0x0c45, 0x6028, BRIDGE_SN9C102), },
         { SN9C102_USB_DEVICE(0x0c45, 0x6029, BRIDGE_SN9C102), },
         { SN9C102_USB_DEVICE(0x0c45, 0x602a, BRIDGE_SN9C102), },
diff --git a/drivers/staging/rtl8723au/os_dep/os_intfs.c b/drivers/staging/rtl8723au/os_dep/os_intfs.c
index 57eca7a45672..4fe751f7c2bf 100644
--- a/drivers/staging/rtl8723au/os_dep/os_intfs.c
+++ b/drivers/staging/rtl8723au/os_dep/os_intfs.c
@@ -953,8 +953,6 @@ static int netdev_close(struct net_device *pnetdev)
 #endif /* CONFIG_8723AU_P2P */
 
         rtw_scan_abort23a(padapter);
-         /* set this at the end */
-        padapter->rtw_wdev->iftype = NL80211_IFTYPE_MONITOR;
 
         RT_TRACE(_module_os_intfs_c_, _drv_info_, ("-871x_drv - drv_close\n"));
         DBG_8723A("-871x_drv - drv_close, bup =%d\n", padapter->bup);
diff --git a/drivers/staging/rtl8723au/os_dep/usb_ops_linux.c b/drivers/staging/rtl8723au/os_dep/usb_ops_linux.c
index c49160e477d8..07e542e5d156 100644
--- a/drivers/staging/rtl8723au/os_dep/usb_ops_linux.c
+++ b/drivers/staging/rtl8723au/os_dep/usb_ops_linux.c
@@ -26,7 +26,7 @@ unsigned int ffaddr2pipehdl23a(struct dvobj_priv *pdvobj, u32 addr)
         if (addr == RECV_BULK_IN_ADDR) {
                 pipe = usb_rcvbulkpipe(pusbd, pdvobj->RtInPipe[0]);
         } else if (addr == RECV_INT_IN_ADDR) {
-                pipe = usb_rcvbulkpipe(pusbd, pdvobj->RtInPipe[1]);
+                pipe = usb_rcvintpipe(pusbd, pdvobj->RtInPipe[1]);
         } else if (addr < HW_QUEUE_ENTRY) {
                 ep_num = pdvobj->Queue2Pipe[addr];
                 pipe = usb_sndbulkpipe(pusbd, ep_num);
diff --git a/drivers/target/iscsi/iscsi_target.c b/drivers/target/iscsi/iscsi_target.c
index 78cab13bbb1b..46588c85d39b 100644
--- a/drivers/target/iscsi/iscsi_target.c
+++ b/drivers/target/iscsi/iscsi_target.c
@@ -1593,7 +1593,9 @@ int iscsit_process_nop_out(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
          * Initiator is expecting a NopIN ping reply..
          */
         if (hdr->itt != RESERVED_ITT) {
-                BUG_ON(!cmd);
+                if (!cmd)
+                        return iscsit_add_reject(conn, ISCSI_REASON_PROTOCOL_ERROR,
+                                                (unsigned char *)hdr);
 
                 spin_lock_bh(&conn->cmd_lock);
                 list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
diff --git a/drivers/target/iscsi/iscsi_target_core.h b/drivers/target/iscsi/iscsi_target_core.h
index 6960f22909ae..302eb3b78715 100644
--- a/drivers/target/iscsi/iscsi_target_core.h
+++ b/drivers/target/iscsi/iscsi_target_core.h
@@ -775,6 +775,7 @@ struct iscsi_np {
         int                     np_ip_proto;
         int                     np_sock_type;
         enum np_thread_state_table np_thread_state;
+        bool                    enabled;
         enum iscsi_timer_flags_table np_login_timer_flags;
         u32                     np_exports;
         enum np_flags_table     np_flags;
diff --git a/drivers/target/iscsi/iscsi_target_login.c b/drivers/target/iscsi/iscsi_target_login.c
index 8739b98f6f93..ca31fa1b8a4b 100644
--- a/drivers/target/iscsi/iscsi_target_login.c
+++ b/drivers/target/iscsi/iscsi_target_login.c
@@ -436,7 +436,7 @@ static int iscsi_login_zero_tsih_s2(
                 }
                 off = mrdsl % PAGE_SIZE;
                 if (!off)
-                        return 0;
+                        goto check_prot;
 
                 if (mrdsl < PAGE_SIZE)
                         mrdsl = PAGE_SIZE;
@@ -452,6 +452,31 @@ static int iscsi_login_zero_tsih_s2(
                                 ISCSI_LOGIN_STATUS_NO_RESOURCES);
                         return -1;
                 }
+                /*
+                 * ISER currently requires that ImmediateData + Unsolicited
+                 * Data be disabled when protection / signature MRs are enabled.
+                 */
+check_prot:
+                if (sess->se_sess->sup_prot_ops &
+                   (TARGET_PROT_DOUT_STRIP | TARGET_PROT_DOUT_PASS |
+                    TARGET_PROT_DOUT_INSERT)) {
+
+                        sprintf(buf, "ImmediateData=No");
+                        if (iscsi_change_param_value(buf, conn->param_list, 0) < 0) {
+                                iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
+                                                    ISCSI_LOGIN_STATUS_NO_RESOURCES);
+                                return -1;
+                        }
+
+                        sprintf(buf, "InitialR2T=Yes");
+                        if (iscsi_change_param_value(buf, conn->param_list, 0) < 0) {
+                                iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
+                                                    ISCSI_LOGIN_STATUS_NO_RESOURCES);
+                                return -1;
+                        }
+                        pr_debug("Forcing ImmediateData=No + InitialR2T=Yes for"
+                                 " T10-PI enabled ISER session\n");
+                }
         }
 
         return 0;
@@ -984,6 +1009,7 @@ int iscsi_target_setup_login_socket(
         }
 
         np->np_transport = t;
+        np->enabled = true;
         return 0;
 }
 
diff --git a/drivers/target/iscsi/iscsi_target_tpg.c b/drivers/target/iscsi/iscsi_target_tpg.c
index eb96b20dc09e..ca1811858afd 100644
--- a/drivers/target/iscsi/iscsi_target_tpg.c
+++ b/drivers/target/iscsi/iscsi_target_tpg.c
@@ -184,6 +184,7 @@ static void iscsit_clear_tpg_np_login_thread(
                 return;
         }
 
+        tpg_np->tpg_np->enabled = false;
         iscsit_reset_np_thread(tpg_np->tpg_np, tpg_np, tpg, shutdown);
 }
 
diff --git a/drivers/target/target_core_device.c b/drivers/target/target_core_device.c
index 65001e133670..26416c15d65c 100644
--- a/drivers/target/target_core_device.c
+++ b/drivers/target/target_core_device.c
@@ -798,10 +798,10 @@ int se_dev_set_emulate_write_cache(struct se_device *dev, int flag)
                 pr_err("emulate_write_cache not supported for pSCSI\n");
                 return -EINVAL;
         }
-        if (dev->transport->get_write_cache) {
-                pr_warn("emulate_write_cache cannot be changed when underlying"
-                        " HW reports WriteCacheEnabled, ignoring request\n");
-                return 0;
+        if (flag &&
+            dev->transport->get_write_cache) {
+                pr_err("emulate_write_cache not supported for this device\n");
+                return -EINVAL;
         }
 
         dev->dev_attrib.emulate_write_cache = flag;
@@ -936,6 +936,10 @@ int se_dev_set_pi_prot_type(struct se_device *dev, int flag)
                 return 0;
         }
         if (!dev->transport->init_prot || !dev->transport->free_prot) {
+                /* 0 is only allowed value for non-supporting backends */
+                if (flag == 0)
+                        return 0;
+
                 pr_err("DIF protection not supported by backend: %s\n",
                        dev->transport->name);
                 return -ENOSYS;
diff --git a/drivers/target/target_core_transport.c b/drivers/target/target_core_transport.c
index d4b98690a736..789aa9eb0a1e 100644
--- a/drivers/target/target_core_transport.c
+++ b/drivers/target/target_core_transport.c
@@ -1113,6 +1113,7 @@ void transport_init_se_cmd(
         init_completion(&cmd->cmd_wait_comp);
         init_completion(&cmd->task_stop_comp);
         spin_lock_init(&cmd->t_state_lock);
+        kref_init(&cmd->cmd_kref);
         cmd->transport_state = CMD_T_DEV_ACTIVE;
 
         cmd->se_tfo = tfo;
@@ -2357,7 +2358,6 @@ int target_get_sess_cmd(struct se_session *se_sess, struct se_cmd *se_cmd,
         unsigned long flags;
         int ret = 0;
 
-        kref_init(&se_cmd->cmd_kref);
         /*
          * Add a second kref if the fabric caller is expecting to handle
          * fabric acknowledgement that requires two target_put_sess_cmd()
diff --git a/drivers/target/tcm_fc/tfc_cmd.c b/drivers/target/tcm_fc/tfc_cmd.c
index 01cf37f212c3..f5fd515b2bee 100644
--- a/drivers/target/tcm_fc/tfc_cmd.c
+++ b/drivers/target/tcm_fc/tfc_cmd.c
@@ -90,18 +90,18 @@ static void ft_free_cmd(struct ft_cmd *cmd)
 {
         struct fc_frame *fp;
         struct fc_lport *lport;
-        struct se_session *se_sess;
+        struct ft_sess *sess;
 
         if (!cmd)
                 return;
-        se_sess = cmd->sess->se_sess;
+        sess = cmd->sess;
         fp = cmd->req_frame;
         lport = fr_dev(fp);
         if (fr_seq(fp))
                 lport->tt.seq_release(fr_seq(fp));
         fc_frame_free(fp);
-        percpu_ida_free(&se_sess->sess_tag_pool, cmd->se_cmd.map_tag);
-        ft_sess_put(cmd->sess); /* undo get from lookup at recv */
+        percpu_ida_free(&sess->se_sess->sess_tag_pool, cmd->se_cmd.map_tag);
+        ft_sess_put(sess);      /* undo get from lookup at recv */
 }
 
 void ft_release_cmd(struct se_cmd *se_cmd)
diff --git a/drivers/xen/events/events_fifo.c b/drivers/xen/events/events_fifo.c
index 96109a9972b6..84b4bfb84344 100644
--- a/drivers/xen/events/events_fifo.c
+++ b/drivers/xen/events/events_fifo.c
@@ -66,7 +66,22 @@ static DEFINE_PER_CPU(struct evtchn_fifo_queue, cpu_queue);
 static event_word_t *event_array[MAX_EVENT_ARRAY_PAGES] __read_mostly;
 static unsigned event_array_pages __read_mostly;
 
+/*
+ * sync_set_bit() and friends must be unsigned long aligned on non-x86
+ * platforms.
+ */
+#if !defined(CONFIG_X86) && BITS_PER_LONG > 32
+
+#define BM(w) (unsigned long *)((unsigned long)w & ~0x7UL)
+#define EVTCHN_FIFO_BIT(b, w) \
+    (((unsigned long)w & 0x4UL) ? (EVTCHN_FIFO_ ##b + 32) : EVTCHN_FIFO_ ##b)
+
+#else
+
 #define BM(w) ((unsigned long *)(w))
+#define EVTCHN_FIFO_BIT(b, w) EVTCHN_FIFO_ ##b
+
+#endif
 
 static inline event_word_t *event_word_from_port(unsigned port)
 {
@@ -161,33 +176,38 @@ static void evtchn_fifo_bind_to_cpu(struct irq_info *info, unsigned cpu)
 static void evtchn_fifo_clear_pending(unsigned port)
 {
         event_word_t *word = event_word_from_port(port);
-        sync_clear_bit(EVTCHN_FIFO_PENDING, BM(word));
+        sync_clear_bit(EVTCHN_FIFO_BIT(PENDING, word), BM(word));
 }
 
 static void evtchn_fifo_set_pending(unsigned port)
 {
         event_word_t *word = event_word_from_port(port);
-        sync_set_bit(EVTCHN_FIFO_PENDING, BM(word));
+        sync_set_bit(EVTCHN_FIFO_BIT(PENDING, word), BM(word));
 }
 
 static bool evtchn_fifo_is_pending(unsigned port)
 {
         event_word_t *word = event_word_from_port(port);
-        return sync_test_bit(EVTCHN_FIFO_PENDING, BM(word));
+        return sync_test_bit(EVTCHN_FIFO_BIT(PENDING, word), BM(word));
 }
 
 static bool evtchn_fifo_test_and_set_mask(unsigned port)
 {
         event_word_t *word = event_word_from_port(port);
-        return sync_test_and_set_bit(EVTCHN_FIFO_MASKED, BM(word));
+        return sync_test_and_set_bit(EVTCHN_FIFO_BIT(MASKED, word), BM(word));
 }
 
 static void evtchn_fifo_mask(unsigned port)
 {
         event_word_t *word = event_word_from_port(port);
-        sync_set_bit(EVTCHN_FIFO_MASKED, BM(word));
+        sync_set_bit(EVTCHN_FIFO_BIT(MASKED, word), BM(word));
 }
 
+static bool evtchn_fifo_is_masked(unsigned port)
+{
+        event_word_t *word = event_word_from_port(port);
+        return sync_test_bit(EVTCHN_FIFO_BIT(MASKED, word), BM(word));
+}
 /*
  * Clear MASKED, spinning if BUSY is set.
  */
@@ -211,7 +231,7 @@ static void evtchn_fifo_unmask(unsigned port)
         BUG_ON(!irqs_disabled());
 
         clear_masked(word);
-        if (sync_test_bit(EVTCHN_FIFO_PENDING, BM(word))) {
+        if (evtchn_fifo_is_pending(port)) {
                 struct evtchn_unmask unmask = { .port = port };
                 (void)HYPERVISOR_event_channel_op(EVTCHNOP_unmask, &unmask);
         }
@@ -243,7 +263,7 @@ static void handle_irq_for_port(unsigned port)
 
 static void consume_one_event(unsigned cpu,
                               struct evtchn_fifo_control_block *control_block,
-                              unsigned priority, uint32_t *ready)
+                              unsigned priority, unsigned long *ready)
 {
         struct evtchn_fifo_queue *q = &per_cpu(cpu_queue, cpu);
         uint32_t head;
@@ -273,10 +293,9 @@ static void consume_one_event(unsigned cpu,
          * copy of the ready word.
          */
         if (head == 0)
-                clear_bit(priority, BM(ready));
+                clear_bit(priority, ready);
 
-        if (sync_test_bit(EVTCHN_FIFO_PENDING, BM(word))
-            && !sync_test_bit(EVTCHN_FIFO_MASKED, BM(word)))
+        if (evtchn_fifo_is_pending(port) && !evtchn_fifo_is_masked(port))
                 handle_irq_for_port(port);
 
         q->head[priority] = head;
@@ -285,7 +304,7 @@ static void consume_one_event(unsigned cpu,
 static void evtchn_fifo_handle_events(unsigned cpu)
 {
         struct evtchn_fifo_control_block *control_block;
-        uint32_t ready;
+        unsigned long ready;
         unsigned q;
 
         control_block = per_cpu(cpu_control_block, cpu);