170 files changed, 1813 insertions, 1044 deletions
diff --git a/drivers/acpi/acpica/exconfig.c b/drivers/acpi/acpica/exconfig.c
index a1d177d58254..21932d640a41 100644
--- a/drivers/acpi/acpica/exconfig.c
+++ b/drivers/acpi/acpica/exconfig.c
@@ -108,7 +108,9 @@ acpi_ex_add_table(u32 table_index,
        /* Add the table to the namespace */
+        acpi_ex_exit_interpreter();
        status = acpi_ns_load_table(table_index, parent_node);
+        acpi_ex_enter_interpreter();
        if (ACPI_FAILURE(status)) {
                acpi_ut_remove_reference(obj_desc);
                *ddb_handle = NULL;
diff --git a/drivers/acpi/acpica/nsparse.c b/drivers/acpi/acpica/nsparse.c
index f631a47724f0..1783cd7e1446 100644
--- a/drivers/acpi/acpica/nsparse.c
+++ b/drivers/acpi/acpica/nsparse.c
@@ -47,6 +47,7 @@
 #include "acparser.h"
 #include "acdispat.h"
 #include "actables.h"
+#include "acinterp.h"
 #define _COMPONENT          ACPI_NAMESPACE
 ACPI_MODULE_NAME("nsparse")
@@ -170,6 +171,8 @@ acpi_ns_parse_table(u32 table_index, struct acpi_namespace_node *start_node)
        ACPI_FUNCTION_TRACE(ns_parse_table);
+        acpi_ex_enter_interpreter();
        /*
         * AML Parse, pass 1
         *
@@ -185,7 +188,7 @@ acpi_ns_parse_table(u32 table_index, struct acpi_namespace_node *start_node)
        status = acpi_ns_one_complete_parse(ACPI_IMODE_LOAD_PASS1,
                                            table_index, start_node);
        if (ACPI_FAILURE(status)) {
-                return_ACPI_STATUS(status);
+                goto error_exit;
        }
        /*
@@ -201,8 +204,10 @@ acpi_ns_parse_table(u32 table_index, struct acpi_namespace_node *start_node)
        status = acpi_ns_one_complete_parse(ACPI_IMODE_LOAD_PASS2,
                                            table_index, start_node);
        if (ACPI_FAILURE(status)) {
-                return_ACPI_STATUS(status);
+                goto error_exit;
        }
+error_exit:
+        acpi_ex_exit_interpreter();
        return_ACPI_STATUS(status);
 }
diff --git a/drivers/ata/ahci_seattle.c b/drivers/ata/ahci_seattle.c
index 6e702ab57220..1d31c0c0fc20 100644
--- a/drivers/ata/ahci_seattle.c
+++ b/drivers/ata/ahci_seattle.c
@@ -137,7 +137,7 @@ static const struct ata_port_info *ahci_seattle_get_port_info(
        u32 val;
        plat_data = devm_kzalloc(dev, sizeof(*plat_data), GFP_KERNEL);
-        if (IS_ERR(plat_data))
+        if (!plat_data)
                return &ahci_port_info;
        plat_data->sgpio_ctrl = devm_ioremap_resource(dev,
diff --git a/drivers/ata/libata-eh.c b/drivers/ata/libata-eh.c
index 61dc7a99e89a..c6f017458958 100644
--- a/drivers/ata/libata-eh.c
+++ b/drivers/ata/libata-eh.c
@@ -606,7 +606,7 @@ void ata_scsi_error(struct Scsi_Host *host)
        ata_scsi_port_error_handler(host, ap);
        /* finish or retry handled scmd's and clean up */
-        WARN_ON(host->host_failed || !list_empty(&eh_work_q));
+        WARN_ON(!list_empty(&eh_work_q));
        DPRINTK("EXIT\n");
 }
diff --git a/drivers/ata/sata_mv.c b/drivers/ata/sata_mv.c
index bd74ee555278..745489a1c86a 100644
--- a/drivers/ata/sata_mv.c
+++ b/drivers/ata/sata_mv.c
@@ -986,7 +986,7 @@ static inline void mv_write_cached_reg(void __iomem *addr, u32 *old, u32 new)
                 * Looks like a lot of fuss, but it avoids an unnecessary
                 * +1 usec read-after-write delay for unaffected registers.
                 */
-                laddr = (long)addr & 0xffff;
+                laddr = (unsigned long)addr & 0xffff;
                if (laddr >= 0x300 && laddr <= 0x33c) {
                        laddr &= 0x000f;
                        if (laddr == 0x4 || laddr == 0xc) {
diff --git a/drivers/block/aoe/aoecmd.c b/drivers/block/aoe/aoecmd.c
index d597e432e195..ab19adb07a12 100644
--- a/drivers/block/aoe/aoecmd.c
+++ b/drivers/block/aoe/aoecmd.c
@@ -1750,7 +1750,7 @@ aoecmd_init(void)
        int ret;
        /* get_zeroed_page returns page with ref count 1 */
-        p = (void *) get_zeroed_page(GFP_KERNEL | __GFP_REPEAT);
+        p = (void *) get_zeroed_page(GFP_KERNEL);
        if (!p)
                return -ENOMEM;
        empty_page = virt_to_page(p);
diff --git a/drivers/connector/cn_proc.c b/drivers/connector/cn_proc.c
index 15d06fcf0b50..b02f9c606e0b 100644
--- a/drivers/connector/cn_proc.c
+++ b/drivers/connector/cn_proc.c
@@ -56,11 +56,21 @@ static struct cb_id cn_proc_event_id = { CN_IDX_PROC, CN_VAL_PROC };
 /* proc_event_counts is used as the sequence number of the netlink message */
 static DEFINE_PER_CPU(__u32, proc_event_counts) = { 0 };
-static inline void get_seq(__u32 *ts, int *cpu)
+static inline void send_msg(struct cn_msg *msg)
 {
        preempt_disable();
-        *ts = __this_cpu_inc_return(proc_event_counts) - 1;
-        *cpu = smp_processor_id();
+        msg->seq = __this_cpu_inc_return(proc_event_counts) - 1;
+        ((struct proc_event *)msg->data)->cpu = smp_processor_id();
+        /*
+         * Preemption remains disabled during send to ensure the messages are
+         * ordered according to their sequence numbers.
+         *
+         * If cn_netlink_send() fails, the data is not sent.
+         */
+        cn_netlink_send(msg, 0, CN_IDX_PROC, GFP_NOWAIT);
        preempt_enable();
 }
@@ -77,7 +87,6 @@ void proc_fork_connector(struct task_struct *task)
        msg = buffer_to_cn_msg(buffer);
        ev = (struct proc_event *)msg->data;
        memset(&ev->event_data, 0, sizeof(ev->event_data));
-        get_seq(&msg->seq, &ev->cpu);
        ev->timestamp_ns = ktime_get_ns();
        ev->what = PROC_EVENT_FORK;
        rcu_read_lock();
@@ -92,8 +101,7 @@ void proc_fork_connector(struct task_struct *task)
        msg->ack = 0; /* not used */
        msg->len = sizeof(*ev);
        msg->flags = 0; /* not used */
-        /*  If cn_netlink_send() failed, the data is not sent */
+        send_msg(msg);
-        cn_netlink_send(msg, 0, CN_IDX_PROC, GFP_KERNEL);
 }
 void proc_exec_connector(struct task_struct *task)
@@ -108,7 +116,6 @@ void proc_exec_connector(struct task_struct *task)
        msg = buffer_to_cn_msg(buffer);
        ev = (struct proc_event *)msg->data;
        memset(&ev->event_data, 0, sizeof(ev->event_data));
-        get_seq(&msg->seq, &ev->cpu);
        ev->timestamp_ns = ktime_get_ns();
        ev->what = PROC_EVENT_EXEC;
        ev->event_data.exec.process_pid = task->pid;
@@ -118,7 +125,7 @@ void proc_exec_connector(struct task_struct *task)
        msg->ack = 0; /* not used */
        msg->len = sizeof(*ev);
        msg->flags = 0; /* not used */
-        cn_netlink_send(msg, 0, CN_IDX_PROC, GFP_KERNEL);
+        send_msg(msg);
 }
 void proc_id_connector(struct task_struct *task, int which_id)
@@ -150,14 +157,13 @@ void proc_id_connector(struct task_struct *task, int which_id)
                return;
        }
        rcu_read_unlock();
-        get_seq(&msg->seq, &ev->cpu);
        ev->timestamp_ns = ktime_get_ns();
        memcpy(&msg->id, &cn_proc_event_id, sizeof(msg->id));
        msg->ack = 0; /* not used */
        msg->len = sizeof(*ev);
        msg->flags = 0; /* not used */
-        cn_netlink_send(msg, 0, CN_IDX_PROC, GFP_KERNEL);
+        send_msg(msg);
 }
 void proc_sid_connector(struct task_struct *task)
@@ -172,7 +178,6 @@ void proc_sid_connector(struct task_struct *task)
        msg = buffer_to_cn_msg(buffer);
        ev = (struct proc_event *)msg->data;
        memset(&ev->event_data, 0, sizeof(ev->event_data));
-        get_seq(&msg->seq, &ev->cpu);
        ev->timestamp_ns = ktime_get_ns();
        ev->what = PROC_EVENT_SID;
        ev->event_data.sid.process_pid = task->pid;
@@ -182,7 +187,7 @@ void proc_sid_connector(struct task_struct *task)
        msg->ack = 0; /* not used */
        msg->len = sizeof(*ev);
        msg->flags = 0; /* not used */
-        cn_netlink_send(msg, 0, CN_IDX_PROC, GFP_KERNEL);
+        send_msg(msg);
 }
 void proc_ptrace_connector(struct task_struct *task, int ptrace_id)
@@ -197,7 +202,6 @@ void proc_ptrace_connector(struct task_struct *task, int ptrace_id)
        msg = buffer_to_cn_msg(buffer);
        ev = (struct proc_event *)msg->data;
        memset(&ev->event_data, 0, sizeof(ev->event_data));
-        get_seq(&msg->seq, &ev->cpu);
        ev->timestamp_ns = ktime_get_ns();
        ev->what = PROC_EVENT_PTRACE;
        ev->event_data.ptrace.process_pid  = task->pid;
@@ -215,7 +219,7 @@ void proc_ptrace_connector(struct task_struct *task, int ptrace_id)
        msg->ack = 0; /* not used */
        msg->len = sizeof(*ev);
        msg->flags = 0; /* not used */
-        cn_netlink_send(msg, 0, CN_IDX_PROC, GFP_KERNEL);
+        send_msg(msg);
 }
 void proc_comm_connector(struct task_struct *task)
@@ -230,7 +234,6 @@ void proc_comm_connector(struct task_struct *task)
        msg = buffer_to_cn_msg(buffer);
        ev = (struct proc_event *)msg->data;
        memset(&ev->event_data, 0, sizeof(ev->event_data));
-        get_seq(&msg->seq, &ev->cpu);
        ev->timestamp_ns = ktime_get_ns();
        ev->what = PROC_EVENT_COMM;
        ev->event_data.comm.process_pid  = task->pid;
@@ -241,7 +244,7 @@ void proc_comm_connector(struct task_struct *task)
        msg->ack = 0; /* not used */
        msg->len = sizeof(*ev);
        msg->flags = 0; /* not used */
-        cn_netlink_send(msg, 0, CN_IDX_PROC, GFP_KERNEL);
+        send_msg(msg);
 }
 void proc_coredump_connector(struct task_struct *task)
@@ -256,7 +259,6 @@ void proc_coredump_connector(struct task_struct *task)
        msg = buffer_to_cn_msg(buffer);
        ev = (struct proc_event *)msg->data;
        memset(&ev->event_data, 0, sizeof(ev->event_data));
-        get_seq(&msg->seq, &ev->cpu);
        ev->timestamp_ns = ktime_get_ns();
        ev->what = PROC_EVENT_COREDUMP;
        ev->event_data.coredump.process_pid = task->pid;
@@ -266,7 +268,7 @@ void proc_coredump_connector(struct task_struct *task)
        msg->ack = 0; /* not used */
        msg->len = sizeof(*ev);
        msg->flags = 0; /* not used */
-        cn_netlink_send(msg, 0, CN_IDX_PROC, GFP_KERNEL);
+        send_msg(msg);
 }
 void proc_exit_connector(struct task_struct *task)
@@ -281,7 +283,6 @@ void proc_exit_connector(struct task_struct *task)
        msg = buffer_to_cn_msg(buffer);
        ev = (struct proc_event *)msg->data;
        memset(&ev->event_data, 0, sizeof(ev->event_data));
-        get_seq(&msg->seq, &ev->cpu);
        ev->timestamp_ns = ktime_get_ns();
        ev->what = PROC_EVENT_EXIT;
        ev->event_data.exit.process_pid = task->pid;
@@ -293,7 +294,7 @@ void proc_exit_connector(struct task_struct *task)
        msg->ack = 0; /* not used */
        msg->len = sizeof(*ev);
        msg->flags = 0; /* not used */
-        cn_netlink_send(msg, 0, CN_IDX_PROC, GFP_KERNEL);
+        send_msg(msg);
 }
 /*
@@ -325,7 +326,7 @@ static void cn_proc_ack(int err, int rcvd_seq, int rcvd_ack)
        msg->ack = rcvd_ack + 1;
        msg->len = sizeof(*ev);
        msg->flags = 0; /* not used */
-        cn_netlink_send(msg, 0, CN_IDX_PROC, GFP_KERNEL);
+        send_msg(msg);
 }
 /**
diff --git a/drivers/cpufreq/pcc-cpufreq.c b/drivers/cpufreq/pcc-cpufreq.c
index 808a320e9d5d..a7ecb9a84c15 100644
--- a/drivers/cpufreq/pcc-cpufreq.c
+++ b/drivers/cpufreq/pcc-cpufreq.c
@@ -487,7 +487,7 @@ static int __init pcc_cpufreq_probe(void)
        doorbell.space_id = reg_resource->space_id;
        doorbell.bit_width = reg_resource->bit_width;
        doorbell.bit_offset = reg_resource->bit_offset;
-        doorbell.access_width = 64;
+        doorbell.access_width = 4;
        doorbell.address = reg_resource->address;
        pr_debug("probe: doorbell: space_id is %d, bit_width is %d, "
diff --git a/drivers/crypto/ux500/hash/hash_core.c b/drivers/crypto/ux500/hash/hash_core.c
index 574e87c7f2b8..9acccad26928 100644
--- a/drivers/crypto/ux500/hash/hash_core.c
+++ b/drivers/crypto/ux500/hash/hash_core.c
@@ -781,7 +781,7 @@ static int hash_process_data(struct hash_device_data *device_data,
                                                &device_data->state);
                                memmove(req_ctx->state.buffer,
                                        device_data->state.buffer,
-                                        HASH_BLOCK_SIZE / sizeof(u32));
+                                        HASH_BLOCK_SIZE);
                                if (ret) {
                                        dev_err(device_data->dev,
                                                "%s: hash_resume_state() failed!\n",
@@ -832,7 +832,7 @@ static int hash_process_data(struct hash_device_data *device_data,
                        memmove(device_data->state.buffer,
                                req_ctx->state.buffer,
-                                HASH_BLOCK_SIZE / sizeof(u32));
+                                HASH_BLOCK_SIZE);
                        if (ret) {
                                dev_err(device_data->dev, "%s: hash_save_state() failed!\n",
                                        __func__);
diff --git a/drivers/crypto/vmx/aes_cbc.c b/drivers/crypto/vmx/aes_cbc.c
index 495577b6d31b..94ad5c0adbcb 100644
--- a/drivers/crypto/vmx/aes_cbc.c
+++ b/drivers/crypto/vmx/aes_cbc.c
@@ -182,7 +182,7 @@ struct crypto_alg p8_aes_cbc_alg = {
        .cra_name = "cbc(aes)",
        .cra_driver_name = "p8_aes_cbc",
        .cra_module = THIS_MODULE,
-        .cra_priority = 1000,
+        .cra_priority = 2000,
        .cra_type = &crypto_blkcipher_type,
        .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER | CRYPTO_ALG_NEED_FALLBACK,
        .cra_alignmask = 0,
diff --git a/drivers/crypto/vmx/aes_ctr.c b/drivers/crypto/vmx/aes_ctr.c
index 0a3c1b04cf3c..38ed10d761d0 100644
--- a/drivers/crypto/vmx/aes_ctr.c
+++ b/drivers/crypto/vmx/aes_ctr.c
@@ -166,7 +166,7 @@ struct crypto_alg p8_aes_ctr_alg = {
        .cra_name = "ctr(aes)",
        .cra_driver_name = "p8_aes_ctr",
        .cra_module = THIS_MODULE,
-        .cra_priority = 1000,
+        .cra_priority = 2000,
        .cra_type = &crypto_blkcipher_type,
        .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER | CRYPTO_ALG_NEED_FALLBACK,
        .cra_alignmask = 0,
diff --git a/drivers/crypto/vmx/ppc-xlate.pl b/drivers/crypto/vmx/ppc-xlate.pl
index 9f4994cabcc7..b18e67d0e065 100644
--- a/drivers/crypto/vmx/ppc-xlate.pl
+++ b/drivers/crypto/vmx/ppc-xlate.pl
@@ -141,7 +141,7 @@ my $vmr = sub {
 # Some ABIs specify vrsave, special-purpose register #256, as reserved
 # for system use.
-my $no_vrsave = ($flavour =~ /aix|linux64le/);
+my $no_vrsave = ($flavour =~ /linux-ppc64le/);
 my $mtspr = sub {
    my ($f,$idx,$ra) = @_;
    if ($idx == 256 && $no_vrsave) {
diff --git a/drivers/devfreq/devfreq.c b/drivers/devfreq/devfreq.c
index 1d6c803804d5..e92418facc92 100644
--- a/drivers/devfreq/devfreq.c
+++ b/drivers/devfreq/devfreq.c
@@ -268,8 +268,11 @@ int update_devfreq(struct devfreq *devfreq)
        devfreq_notify_transition(devfreq, &freqs, DEVFREQ_PRECHANGE);
        err = devfreq->profile->target(devfreq->dev.parent, &freq, flags);
-        if (err)
+        if (err) {
+                freqs.new = cur_freq;
+                devfreq_notify_transition(devfreq, &freqs, DEVFREQ_POSTCHANGE);
                return err;
+        }
        freqs.new = freq;
        devfreq_notify_transition(devfreq, &freqs, DEVFREQ_POSTCHANGE);
@@ -552,6 +555,7 @@ struct devfreq *devfreq_add_device(struct device *dev,
        devfreq->profile = profile;
        strncpy(devfreq->governor_name, governor_name, DEVFREQ_NAME_LEN);
        devfreq->previous_freq = profile->initial_freq;
+        devfreq->last_status.current_frequency = profile->initial_freq;
        devfreq->data = data;
        devfreq->nb.notifier_call = devfreq_notifier_call;
@@ -561,23 +565,22 @@ struct devfreq *devfreq_add_device(struct device *dev,
                mutex_lock(&devfreq->lock);
        }
-        devfreq->trans_table =  devm_kzalloc(dev, sizeof(unsigned int) *
-                                                devfreq->profile->max_state *
-                                                devfreq->profile->max_state,
-                                                GFP_KERNEL);
-        devfreq->time_in_state = devm_kzalloc(dev, sizeof(unsigned long) *
-                                                devfreq->profile->max_state,
-                                                GFP_KERNEL);
-        devfreq->last_stat_updated = jiffies;
        dev_set_name(&devfreq->dev, "%s", dev_name(dev));
        err = device_register(&devfreq->dev);
        if (err) {
-                put_device(&devfreq->dev);
                mutex_unlock(&devfreq->lock);
                goto err_out;
        }
+        devfreq->trans_table =  devm_kzalloc(&devfreq->dev, sizeof(unsigned int) *
+                                                devfreq->profile->max_state *
+                                                devfreq->profile->max_state,
+                                                GFP_KERNEL);
+        devfreq->time_in_state = devm_kzalloc(&devfreq->dev, sizeof(unsigned long) *
+                                                devfreq->profile->max_state,
+                                                GFP_KERNEL);
+        devfreq->last_stat_updated = jiffies;
        srcu_init_notifier_head(&devfreq->transition_notifier_list);
        mutex_unlock(&devfreq->lock);
@@ -603,7 +606,6 @@ struct devfreq *devfreq_add_device(struct device *dev,
 err_init:
        list_del(&devfreq->node);
        device_unregister(&devfreq->dev);
-        kfree(devfreq);
 err_out:
        return ERR_PTR(err);
 }
@@ -621,7 +623,6 @@ int devfreq_remove_device(struct devfreq *devfreq)
                return -EINVAL;
        device_unregister(&devfreq->dev);
-        put_device(&devfreq->dev);
        return 0;
 }
diff --git a/drivers/devfreq/event/exynos-nocp.c b/drivers/devfreq/event/exynos-nocp.c
index 6b6a5f310486..a5841403bde8 100644
--- a/drivers/devfreq/event/exynos-nocp.c
+++ b/drivers/devfreq/event/exynos-nocp.c
@@ -220,9 +220,6 @@ static int exynos_nocp_parse_dt(struct platform_device *pdev,
        /* Maps the memory mapped IO to control nocp register */
        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (IS_ERR(res))
-                return PTR_ERR(res);
        base = devm_ioremap_resource(dev, res);
        if (IS_ERR(base))
                return PTR_ERR(base);
diff --git a/drivers/gpio/gpio-104-idi-48.c b/drivers/gpio/gpio-104-idi-48.c
index 6c75c83baf5a..2d2763ea1a68 100644
--- a/drivers/gpio/gpio-104-idi-48.c
+++ b/drivers/gpio/gpio-104-idi-48.c
@@ -247,6 +247,7 @@ static int idi_48_probe(struct device *dev, unsigned int id)
        idi48gpio->irq = irq[id];
        spin_lock_init(&idi48gpio->lock);
+        spin_lock_init(&idi48gpio->ack_lock);
        dev_set_drvdata(dev, idi48gpio);
diff --git a/drivers/gpio/gpio-tegra.c b/drivers/gpio/gpio-tegra.c
index ec891a27952f..661b0e34e067 100644
--- a/drivers/gpio/gpio-tegra.c
+++ b/drivers/gpio/gpio-tegra.c
@@ -98,7 +98,6 @@ struct tegra_gpio_info {
        const struct tegra_gpio_soc_config      *soc;
        struct gpio_chip                        gc;
        struct irq_chip                         ic;
-        struct lock_class_key                   lock_class;
        u32                                     bank_count;
 };
@@ -547,6 +546,12 @@ static const struct dev_pm_ops tegra_gpio_pm_ops = {
        SET_SYSTEM_SLEEP_PM_OPS(tegra_gpio_suspend, tegra_gpio_resume)
 };
+/*
+ * This lock class tells lockdep that GPIO irqs are in a different category
+ * than their parents, so it won't report false recursion.
+ */
+static struct lock_class_key gpio_lock_class;
 static int tegra_gpio_probe(struct platform_device *pdev)
 {
        const struct tegra_gpio_soc_config *config;
@@ -660,7 +665,7 @@ static int tegra_gpio_probe(struct platform_device *pdev)
                bank = &tgi->bank_info[GPIO_BANK(gpio)];
-                irq_set_lockdep_class(irq, &tgi->lock_class);
+                irq_set_lockdep_class(irq, &gpio_lock_class);
                irq_set_chip_data(irq, bank);
                irq_set_chip_and_handler(irq, &tgi->ic, handle_simple_irq);
        }
diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c
index 58d822d7e8da..570771ed19e6 100644
--- a/drivers/gpio/gpiolib.c
+++ b/drivers/gpio/gpiolib.c
@@ -1373,8 +1373,12 @@ done:
 #define VALIDATE_DESC(desc) do { \
        if (!desc) \
                return 0; \
+        if (IS_ERR(desc)) {                                             \
+                pr_warn("%s: invalid GPIO (errorpointer)\n", __func__); \
+                return PTR_ERR(desc); \
+        } \
        if (!desc->gdev) { \
-                pr_warn("%s: invalid GPIO\n", __func__); \
+                pr_warn("%s: invalid GPIO (no device)\n", __func__); \
                return -EINVAL; \
        } \
        if ( !desc->gdev->chip ) { \
@@ -1386,8 +1390,12 @@ done:
 #define VALIDATE_DESC_VOID(desc) do { \
        if (!desc) \
                return; \
+        if (IS_ERR(desc)) {                                             \
+                pr_warn("%s: invalid GPIO (errorpointer)\n", __func__); \
+                return; \
+        } \
        if (!desc->gdev) { \
-                pr_warn("%s: invalid GPIO\n", __func__); \
+                pr_warn("%s: invalid GPIO (no device)\n", __func__); \
                return; \
        } \
        if (!desc->gdev->chip) { \
@@ -2056,7 +2064,14 @@ int gpiod_to_irq(const struct gpio_desc *desc)
        struct gpio_chip *chip;
        int offset;
-        VALIDATE_DESC(desc);
+        /*
+         * Cannot VALIDATE_DESC() here as gpiod_to_irq() consumer semantics
+         * requires this function to not return zero on an invalid descriptor
+         * but rather a negative error number.
+         */
+        if (!desc || IS_ERR(desc) || !desc->gdev || !desc->gdev->chip)
+                return -EINVAL;
        chip = desc->gdev->chip;
        offset = gpio_chip_hwgpio(desc);
        if (chip->to_irq) {
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_cgs.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_cgs.c
index 8943099eb135..cf6f49fc1c75 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_cgs.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_cgs.c
@@ -909,7 +909,7 @@ static int amdgpu_cgs_acpi_eval_object(struct cgs_device *cgs_device,
        struct cgs_acpi_method_argument *argument = NULL;
        uint32_t i, count;
        acpi_status status;
-        int result;
+        int result = 0;
        uint32_t func_no = 0xFFFFFFFF;
        handle = ACPI_HANDLE(&adev->pdev->dev);
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
index 66482b429458..6e920086af46 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
@@ -1535,7 +1535,7 @@ int amdgpu_device_init(struct amdgpu_device *adev,
        /* Post card if necessary */
        if (!amdgpu_card_posted(adev) ||
            (adev->virtualization.is_virtual &&
-             !adev->virtualization.caps & AMDGPU_VIRT_CAPS_SRIOV_EN)) {
+             !(adev->virtualization.caps & AMDGPU_VIRT_CAPS_SRIOV_EN))) {
                if (!adev->bios) {
                        dev_err(adev->dev, "Card not posted and no BIOS - ignoring\n");
                        return -EINVAL;
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c
index 40a23704a981..d851ea15059f 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c
@@ -447,7 +447,8 @@ static int amdgpu_info_ioctl(struct drm_device *dev, void *data, struct drm_file
                        dev_info.max_memory_clock = adev->pm.default_mclk * 10;
                }
                dev_info.enabled_rb_pipes_mask = adev->gfx.config.backend_enable_mask;
-                dev_info.num_rb_pipes = adev->gfx.config.num_rbs;
+                dev_info.num_rb_pipes = adev->gfx.config.max_backends_per_se *
+                        adev->gfx.config.max_shader_engines;
                dev_info.num_hw_gfx_contexts = adev->gfx.config.max_hw_contexts;
                dev_info._pad = 0;
                dev_info.ids_flags = 0;
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_pm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_pm.c
index 589b36e8c5cf..0e13d80d2a95 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_pm.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_pm.c
@@ -270,30 +270,28 @@ static ssize_t amdgpu_set_pp_force_state(struct device *dev,
        struct drm_device *ddev = dev_get_drvdata(dev);
        struct amdgpu_device *adev = ddev->dev_private;
        enum amd_pm_state_type state = 0;
-        long idx;
+        unsigned long idx;
        int ret;
        if (strlen(buf) == 1)
                adev->pp_force_state_enabled = false;
-        else {
+        else if (adev->pp_enabled) {
-                ret = kstrtol(buf, 0, &idx);
+                struct pp_states_info data;
-                if (ret) {
+                ret = kstrtoul(buf, 0, &idx);
+                if (ret || idx >= ARRAY_SIZE(data.states)) {
                        count = -EINVAL;
                        goto fail;
                }
-                if (adev->pp_enabled) {
+                amdgpu_dpm_get_pp_num_states(adev, &data);
-                        struct pp_states_info data;
+                state = data.states[idx];
-                        amdgpu_dpm_get_pp_num_states(adev, &data);
+                /* only set user selected power states */
-                        state = data.states[idx];
+                if (state != POWER_STATE_TYPE_INTERNAL_BOOT &&
-                        /* only set user selected power states */
+                    state != POWER_STATE_TYPE_DEFAULT) {
-                        if (state != POWER_STATE_TYPE_INTERNAL_BOOT &&
+                        amdgpu_dpm_dispatch_task(adev,
-                                state != POWER_STATE_TYPE_DEFAULT) {
+                                        AMD_PP_EVENT_ENABLE_USER_STATE, &state, NULL);
-                                amdgpu_dpm_dispatch_task(adev,
+                        adev->pp_force_state_enabled = true;
-                                                AMD_PP_EVENT_ENABLE_USER_STATE, &state, NULL);
-                                adev->pp_force_state_enabled = true;
-                        }
                }
        }
 fail:
diff --git a/drivers/gpu/drm/amd/amdgpu/gfx_v8_0.c b/drivers/gpu/drm/amd/amdgpu/gfx_v8_0.c
index 9f6f8669edc3..1a5cbaff1e34 100644
--- a/drivers/gpu/drm/amd/amdgpu/gfx_v8_0.c
+++ b/drivers/gpu/drm/amd/amdgpu/gfx_v8_0.c
@@ -297,7 +297,8 @@ static const u32 polaris11_golden_common_all[] =
 static const u32 golden_settings_polaris10_a11[] =
 {
        mmATC_MISC_CG, 0x000c0fc0, 0x000c0200,
-        mmCB_HW_CONTROL, 0xfffdf3cf, 0x00006208,
+        mmCB_HW_CONTROL, 0xfffdf3cf, 0x00007208,
+        mmCB_HW_CONTROL_2, 0, 0x0f000000,
        mmCB_HW_CONTROL_3, 0x000001ff, 0x00000040,
        mmDB_DEBUG2, 0xf00fffff, 0x00000400,
        mmPA_SC_ENHANCE, 0xffffffff, 0x20000001,
diff --git a/drivers/gpu/drm/amd/include/atombios.h b/drivers/gpu/drm/amd/include/atombios.h
index 32f3e345de08..3493da5c8f0e 100644
--- a/drivers/gpu/drm/amd/include/atombios.h
+++ b/drivers/gpu/drm/amd/include/atombios.h
@@ -5538,6 +5538,78 @@ typedef struct  _ATOM_ASIC_PROFILING_INFO_V3_5
  ULONG  ulReserved[12];
 }ATOM_ASIC_PROFILING_INFO_V3_5;
+/* for Polars10/11 AVFS parameters */
+typedef struct  _ATOM_ASIC_PROFILING_INFO_V3_6
+{
+  ATOM_COMMON_TABLE_HEADER         asHeader;
+  ULONG  ulMaxVddc;
+  ULONG  ulMinVddc;
+  USHORT usLkgEuseIndex;
+  UCHAR  ucLkgEfuseBitLSB;
+  UCHAR  ucLkgEfuseLength;
+  ULONG  ulLkgEncodeLn_MaxDivMin;
+  ULONG  ulLkgEncodeMax;
+  ULONG  ulLkgEncodeMin;
+  EFUSE_LINEAR_FUNC_PARAM sRoFuse;
+  ULONG  ulEvvDefaultVddc;
+  ULONG  ulEvvNoCalcVddc;
+  ULONG  ulSpeed_Model;
+  ULONG  ulSM_A0;
+  ULONG  ulSM_A1;
+  ULONG  ulSM_A2;
+  ULONG  ulSM_A3;
+  ULONG  ulSM_A4;
+  ULONG  ulSM_A5;
+  ULONG  ulSM_A6;
+  ULONG  ulSM_A7;
+  UCHAR  ucSM_A0_sign;
+  UCHAR  ucSM_A1_sign;
+  UCHAR  ucSM_A2_sign;
+  UCHAR  ucSM_A3_sign;
+  UCHAR  ucSM_A4_sign;
+  UCHAR  ucSM_A5_sign;
+  UCHAR  ucSM_A6_sign;
+  UCHAR  ucSM_A7_sign;
+  ULONG  ulMargin_RO_a;
+  ULONG  ulMargin_RO_b;
+  ULONG  ulMargin_RO_c;
+  ULONG  ulMargin_fixed;
+  ULONG  ulMargin_Fmax_mean;
+  ULONG  ulMargin_plat_mean;
+  ULONG  ulMargin_Fmax_sigma;
+  ULONG  ulMargin_plat_sigma;
+  ULONG  ulMargin_DC_sigma;
+  ULONG  ulLoadLineSlop;
+  ULONG  ulaTDClimitPerDPM[8];
+  ULONG  ulaNoCalcVddcPerDPM[8];
+  ULONG  ulAVFS_meanNsigma_Acontant0;
+  ULONG  ulAVFS_meanNsigma_Acontant1;
+  ULONG  ulAVFS_meanNsigma_Acontant2;
+  USHORT usAVFS_meanNsigma_DC_tol_sigma;
+  USHORT usAVFS_meanNsigma_Platform_mean;
+  USHORT usAVFS_meanNsigma_Platform_sigma;
+  ULONG  ulGB_VDROOP_TABLE_CKSOFF_a0;
+  ULONG  ulGB_VDROOP_TABLE_CKSOFF_a1;
+  ULONG  ulGB_VDROOP_TABLE_CKSOFF_a2;
+  ULONG  ulGB_VDROOP_TABLE_CKSON_a0;
+  ULONG  ulGB_VDROOP_TABLE_CKSON_a1;
+  ULONG  ulGB_VDROOP_TABLE_CKSON_a2;
+  ULONG  ulAVFSGB_FUSE_TABLE_CKSOFF_m1;
+  USHORT usAVFSGB_FUSE_TABLE_CKSOFF_m2;
+  ULONG  ulAVFSGB_FUSE_TABLE_CKSOFF_b;
+  ULONG  ulAVFSGB_FUSE_TABLE_CKSON_m1;
+  USHORT usAVFSGB_FUSE_TABLE_CKSON_m2;
+  ULONG  ulAVFSGB_FUSE_TABLE_CKSON_b;
+  USHORT usMaxVoltage_0_25mv;
+  UCHAR  ucEnableGB_VDROOP_TABLE_CKSOFF;
+  UCHAR  ucEnableGB_VDROOP_TABLE_CKSON;
+  UCHAR  ucEnableGB_FUSE_TABLE_CKSOFF;
+  UCHAR  ucEnableGB_FUSE_TABLE_CKSON;
+  USHORT usPSM_Age_ComFactor;
+  UCHAR  ucEnableApplyAVFS_CKS_OFF_Voltage;
+  UCHAR  ucReserved;
+}ATOM_ASIC_PROFILING_INFO_V3_6;
 typedef struct _ATOM_SCLK_FCW_RANGE_ENTRY_V1{
  ULONG  ulMaxSclkFreq;
diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/fiji_hwmgr.c b/drivers/gpu/drm/amd/powerplay/hwmgr/fiji_hwmgr.c
index 586f73276226..92912ab20944 100644
--- a/drivers/gpu/drm/amd/powerplay/hwmgr/fiji_hwmgr.c
+++ b/drivers/gpu/drm/amd/powerplay/hwmgr/fiji_hwmgr.c
@@ -633,6 +633,8 @@ static int fiji_hwmgr_backend_init(struct pp_hwmgr *hwmgr)
        data->vddci_control = FIJI_VOLTAGE_CONTROL_NONE;
        data->mvdd_control = FIJI_VOLTAGE_CONTROL_NONE;
+        data->force_pcie_gen = PP_PCIEGenInvalid;
        if (atomctrl_is_voltage_controled_by_gpio_v3(hwmgr,
                        VOLTAGE_TYPE_VDDC, VOLTAGE_OBJ_SVID2))
                data->voltage_control = FIJI_VOLTAGE_CONTROL_BY_SVID2;
diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/hardwaremanager.c b/drivers/gpu/drm/amd/powerplay/hwmgr/hardwaremanager.c
index fa208ada6892..efb77eda7508 100644
--- a/drivers/gpu/drm/amd/powerplay/hwmgr/hardwaremanager.c
+++ b/drivers/gpu/drm/amd/powerplay/hwmgr/hardwaremanager.c
@@ -306,10 +306,14 @@ int phm_store_dal_configuration_data(struct pp_hwmgr *hwmgr,
 {
        PHM_FUNC_CHECK(hwmgr);
-        if (hwmgr->hwmgr_func->store_cc6_data == NULL)
+        if (display_config == NULL)
                return -EINVAL;
        hwmgr->display_config = *display_config;
+        if (hwmgr->hwmgr_func->store_cc6_data == NULL)
+                return -EINVAL;
        /* to do pass other display configuration in furture */
        if (hwmgr->hwmgr_func->store_cc6_data)
diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/polaris10_hwmgr.c b/drivers/gpu/drm/amd/powerplay/hwmgr/polaris10_hwmgr.c
index 1400bc420881..64ee78f7d41e 100644
--- a/drivers/gpu/drm/amd/powerplay/hwmgr/polaris10_hwmgr.c
+++ b/drivers/gpu/drm/amd/powerplay/hwmgr/polaris10_hwmgr.c
@@ -1296,7 +1296,6 @@ static int polaris10_populate_single_memory_level(struct pp_hwmgr *hwmgr,
        }
        mem_level->MclkFrequency = clock;
-        mem_level->StutterEnable = 0;
        mem_level->EnabledForThrottle = 1;
        mem_level->EnabledForActivity = 0;
        mem_level->UpHyst = 0;
@@ -1304,7 +1303,6 @@ static int polaris10_populate_single_memory_level(struct pp_hwmgr *hwmgr,
        mem_level->VoltageDownHyst = 0;
        mem_level->ActivityLevel = (uint16_t)data->mclk_activity_target;
        mem_level->StutterEnable = false;
        mem_level->DisplayWatermark = PPSMC_DISPLAY_WATERMARK_LOW;
        data->display_timing.num_existing_displays = info.display_count;
@@ -1363,7 +1361,7 @@ static int polaris10_populate_all_memory_levels(struct pp_hwmgr *hwmgr)
         * a higher state by default such that we are not effected by
         * up threshold or and MCLK DPM latency.
         */
-        levels[0].ActivityLevel = (uint16_t)data->mclk_dpm0_activity_target;
+        levels[0].ActivityLevel = 0x1f;
        CONVERT_FROM_HOST_TO_SMC_US(levels[0].ActivityLevel);
        data->smc_state_table.MemoryDpmLevelCount =
@@ -1761,12 +1759,9 @@ static int polaris10_populate_smc_initailial_state(struct pp_hwmgr *hwmgr)
 static int polaris10_populate_clock_stretcher_data_table(struct pp_hwmgr *hwmgr)
 {
-        uint32_t ro, efuse, efuse2, clock_freq, volt_without_cks,
+        uint32_t ro, efuse, volt_without_cks, volt_with_cks, value, max, min;
-                        volt_with_cks, value;
-        uint16_t clock_freq_u16;
        struct polaris10_hwmgr *data = (struct polaris10_hwmgr *)(hwmgr->backend);
-        uint8_t type, i, j, cks_setting, stretch_amount, stretch_amount2,
+        uint8_t i, stretch_amount, stretch_amount2, volt_offset = 0;
-                        volt_offset = 0;
        struct phm_ppt_v1_information *table_info =
                        (struct phm_ppt_v1_information *)(hwmgr->pptable);
        struct phm_ppt_v1_clock_voltage_dependency_table *sclk_table =
@@ -1778,50 +1773,38 @@ static int polaris10_populate_clock_stretcher_data_table(struct pp_hwmgr *hwmgr)
         * if the part is SS or FF. if RO >= 1660MHz, part is FF.
         */
        efuse = cgs_read_ind_register(hwmgr->device, CGS_IND_REG__SMC,
-                        ixSMU_EFUSE_0 + (146 * 4));
+                        ixSMU_EFUSE_0 + (67 * 4));
-        efuse2 = cgs_read_ind_register(hwmgr->device, CGS_IND_REG__SMC,
-                        ixSMU_EFUSE_0 + (148 * 4));
        efuse &= 0xFF000000;
        efuse = efuse >> 24;
-        efuse2 &= 0xF;
-        if (efuse2 == 1)
-                ro = (2300 - 1350) * efuse / 255 + 1350;
-        else
-                ro = (2500 - 1000) * efuse / 255 + 1000;
-        if (ro >= 1660)
+        if (hwmgr->chip_id == CHIP_POLARIS10) {
-                type = 0;
+                min = 1000;
-        else
+                max = 2300;
-                type = 1;
+        } else {
+                min = 1100;
+                max = 2100;
+        }
-        /* Populate Stretch amount */
+        ro = efuse * (max -min)/255 + min;
-        data->smc_state_table.ClockStretcherAmount = stretch_amount;
        /* Populate Sclk_CKS_masterEn0_7 and Sclk_voltageOffset */
        for (i = 0; i < sclk_table->count; i++) {
                data->smc_state_table.Sclk_CKS_masterEn0_7 |=
                                sclk_table->entries[i].cks_enable << i;
-                volt_without_cks = (uint32_t)((14041 *
-                        (sclk_table->entries[i].clk/100) / 10000 + 3571 + 75 - ro) * 1000 /
+                volt_without_cks =  (uint32_t)(((ro - 40) * 1000 - 2753594 - sclk_table->entries[i].clk/100 * 136418 /1000) / \
-                        (4026 - (13924 * (sclk_table->entries[i].clk/100) / 10000)));
+                                        (sclk_table->entries[i].clk/100 * 1132925 /10000 - 242418)/100);
-                volt_with_cks = (uint32_t)((13946 *
-                        (sclk_table->entries[i].clk/100) / 10000 + 3320 + 45 - ro) * 1000 /
+                volt_with_cks = (uint32_t)((ro * 1000 -2396351 - sclk_table->entries[i].clk/100 * 329021/1000) / \
-                        (3664 - (11454 * (sclk_table->entries[i].clk/100) / 10000)));
+                                (sclk_table->entries[i].clk/10000 * 649434 /1000  - 18005)/10);
                if (volt_without_cks >= volt_with_cks)
                        volt_offset = (uint8_t)(((volt_without_cks - volt_with_cks +
                                        sclk_table->entries[i].cks_voffset) * 100 / 625) + 1);
                data->smc_state_table.Sclk_voltageOffset[i] = volt_offset;
        }
-        PHM_WRITE_INDIRECT_FIELD(hwmgr->device, CGS_IND_REG__SMC, PWR_CKS_ENABLE,
-                        STRETCH_ENABLE, 0x0);
-        PHM_WRITE_INDIRECT_FIELD(hwmgr->device, CGS_IND_REG__SMC, PWR_CKS_ENABLE,
-                        masterReset, 0x1);
-        /* PHM_WRITE_INDIRECT_FIELD(hwmgr->device, CGS_IND_REG__SMC, PWR_CKS_ENABLE, staticEnable, 0x1); */
-        PHM_WRITE_INDIRECT_FIELD(hwmgr->device, CGS_IND_REG__SMC, PWR_CKS_ENABLE,
-                        masterReset, 0x0);
        /* Populate CKS Lookup Table */
        if (stretch_amount == 1 || stretch_amount == 2 || stretch_amount == 5)
                stretch_amount2 = 0;
@@ -1835,69 +1818,6 @@ static int polaris10_populate_clock_stretcher_data_table(struct pp_hwmgr *hwmgr)
                                return -EINVAL);
        }
-        value = cgs_read_ind_register(hwmgr->device, CGS_IND_REG__SMC,
-                        ixPWR_CKS_CNTL);
-        value &= 0xFFC2FF87;
-        data->smc_state_table.CKS_LOOKUPTable.CKS_LOOKUPTableEntry[0].minFreq =
-                        polaris10_clock_stretcher_lookup_table[stretch_amount2][0];
-        data->smc_state_table.CKS_LOOKUPTable.CKS_LOOKUPTableEntry[0].maxFreq =
-                        polaris10_clock_stretcher_lookup_table[stretch_amount2][1];
-        clock_freq_u16 = (uint16_t)(PP_SMC_TO_HOST_UL(data->smc_state_table.
-                        GraphicsLevel[data->smc_state_table.GraphicsDpmLevelCount - 1].SclkSetting.SclkFrequency) / 100);
-        if (polaris10_clock_stretcher_lookup_table[stretch_amount2][0] < clock_freq_u16
-        && polaris10_clock_stretcher_lookup_table[stretch_amount2][1] > clock_freq_u16) {
-                /* Program PWR_CKS_CNTL. CKS_USE_FOR_LOW_FREQ */
-                value |= (polaris10_clock_stretcher_lookup_table[stretch_amount2][3]) << 16;
-                /* Program PWR_CKS_CNTL. CKS_LDO_REFSEL */
-                value |= (polaris10_clock_stretcher_lookup_table[stretch_amount2][2]) << 18;
-                /* Program PWR_CKS_CNTL. CKS_STRETCH_AMOUNT */
-                value |= (polaris10_clock_stretch_amount_conversion
-                                [polaris10_clock_stretcher_lookup_table[stretch_amount2][3]]
-                                 [stretch_amount]) << 3;
-        }
-        CONVERT_FROM_HOST_TO_SMC_US(data->smc_state_table.CKS_LOOKUPTable.CKS_LOOKUPTableEntry[0].minFreq);
-        CONVERT_FROM_HOST_TO_SMC_US(data->smc_state_table.CKS_LOOKUPTable.CKS_LOOKUPTableEntry[0].maxFreq);
-        data->smc_state_table.CKS_LOOKUPTable.CKS_LOOKUPTableEntry[0].setting =
-                        polaris10_clock_stretcher_lookup_table[stretch_amount2][2] & 0x7F;
-        data->smc_state_table.CKS_LOOKUPTable.CKS_LOOKUPTableEntry[0].setting |=
-                        (polaris10_clock_stretcher_lookup_table[stretch_amount2][3]) << 7;
-        cgs_write_ind_register(hwmgr->device, CGS_IND_REG__SMC,
-                        ixPWR_CKS_CNTL, value);
-        /* Populate DDT Lookup Table */
-        for (i = 0; i < 4; i++) {
-                /* Assign the minimum and maximum VID stored
-                 * in the last row of Clock Stretcher Voltage Table.
-                 */
-                data->smc_state_table.ClockStretcherDataTable.ClockStretcherDataTableEntry[i].minVID =
-                                (uint8_t) polaris10_clock_stretcher_ddt_table[type][i][2];
-                data->smc_state_table.ClockStretcherDataTable.ClockStretcherDataTableEntry[i].maxVID =
-                                (uint8_t) polaris10_clock_stretcher_ddt_table[type][i][3];
-                /* Loop through each SCLK and check the frequency
-                 * to see if it lies within the frequency for clock stretcher.
-                 */
-                for (j = 0; j < data->smc_state_table.GraphicsDpmLevelCount; j++) {
-                        cks_setting = 0;
-                        clock_freq = PP_SMC_TO_HOST_UL(
-                                        data->smc_state_table.GraphicsLevel[j].SclkSetting.SclkFrequency);
-                        /* Check the allowed frequency against the sclk level[j].
-                         *  Sclk's endianness has already been converted,
-                         *  and it's in 10Khz unit,
-                         *  as opposed to Data table, which is in Mhz unit.
-                         */
-                        if (clock_freq >= (polaris10_clock_stretcher_ddt_table[type][i][0]) * 100) {
-                                cks_setting |= 0x2;
-                                if (clock_freq < (polaris10_clock_stretcher_ddt_table[type][i][1]) * 100)
-                                        cks_setting |= 0x1;
-                        }
-                        data->smc_state_table.ClockStretcherDataTable.ClockStretcherDataTableEntry[i].setting
-                                                        |= cks_setting << (j * 2);
-                }
-                CONVERT_FROM_HOST_TO_SMC_US(
-                        data->smc_state_table.ClockStretcherDataTable.ClockStretcherDataTableEntry[i].setting);
-        }
        value = cgs_read_ind_register(hwmgr->device, CGS_IND_REG__SMC, ixPWR_CKS_CNTL);
        value &= 0xFFFFFFFE;
        cgs_write_ind_register(hwmgr->device, CGS_IND_REG__SMC, ixPWR_CKS_CNTL, value);
@@ -1956,6 +1876,90 @@ static int polaris10_populate_vr_config(struct pp_hwmgr *hwmgr,
        return 0;
 }
+int polaris10_populate_avfs_parameters(struct pp_hwmgr *hwmgr)
+{
+        struct polaris10_hwmgr *data = (struct polaris10_hwmgr *)(hwmgr->backend);
+        SMU74_Discrete_DpmTable  *table = &(data->smc_state_table);
+        int result = 0;
+        struct pp_atom_ctrl__avfs_parameters avfs_params = {0};
+        AVFS_meanNsigma_t AVFS_meanNsigma = { {0} };
+        AVFS_Sclk_Offset_t AVFS_SclkOffset = { {0} };
+        uint32_t tmp, i;
+        struct pp_smumgr *smumgr = hwmgr->smumgr;
+        struct polaris10_smumgr *smu_data = (struct polaris10_smumgr *)(smumgr->backend);
+        struct phm_ppt_v1_information *table_info =
+                        (struct phm_ppt_v1_information *)hwmgr->pptable;
+        struct phm_ppt_v1_clock_voltage_dependency_table *sclk_table =
+                        table_info->vdd_dep_on_sclk;
+        if (smu_data->avfs.avfs_btc_status == AVFS_BTC_NOTSUPPORTED)
+                return result;
+        result = atomctrl_get_avfs_information(hwmgr, &avfs_params);
+        if (0 == result) {
+                table->BTCGB_VDROOP_TABLE[0].a0  = PP_HOST_TO_SMC_UL(avfs_params.ulGB_VDROOP_TABLE_CKSON_a0);
+                table->BTCGB_VDROOP_TABLE[0].a1  = PP_HOST_TO_SMC_UL(avfs_params.ulGB_VDROOP_TABLE_CKSON_a1);
+                table->BTCGB_VDROOP_TABLE[0].a2  = PP_HOST_TO_SMC_UL(avfs_params.ulGB_VDROOP_TABLE_CKSON_a2);
+                table->BTCGB_VDROOP_TABLE[1].a0  = PP_HOST_TO_SMC_UL(avfs_params.ulGB_VDROOP_TABLE_CKSOFF_a0);
+                table->BTCGB_VDROOP_TABLE[1].a1  = PP_HOST_TO_SMC_UL(avfs_params.ulGB_VDROOP_TABLE_CKSOFF_a1);
+                table->BTCGB_VDROOP_TABLE[1].a2  = PP_HOST_TO_SMC_UL(avfs_params.ulGB_VDROOP_TABLE_CKSOFF_a2);
+                table->AVFSGB_VDROOP_TABLE[0].m1 = PP_HOST_TO_SMC_UL(avfs_params.ulAVFSGB_FUSE_TABLE_CKSON_m1);
+                table->AVFSGB_VDROOP_TABLE[0].m2 = PP_HOST_TO_SMC_US(avfs_params.usAVFSGB_FUSE_TABLE_CKSON_m2);
+                table->AVFSGB_VDROOP_TABLE[0].b  = PP_HOST_TO_SMC_UL(avfs_params.ulAVFSGB_FUSE_TABLE_CKSON_b);
+                table->AVFSGB_VDROOP_TABLE[0].m1_shift = 24;
+                table->AVFSGB_VDROOP_TABLE[0].m2_shift  = 12;
+                table->AVFSGB_VDROOP_TABLE[1].m1 = PP_HOST_TO_SMC_UL(avfs_params.ulAVFSGB_FUSE_TABLE_CKSOFF_m1);
+                table->AVFSGB_VDROOP_TABLE[1].m2 = PP_HOST_TO_SMC_US(avfs_params.usAVFSGB_FUSE_TABLE_CKSOFF_m2);
+                table->AVFSGB_VDROOP_TABLE[1].b  = PP_HOST_TO_SMC_UL(avfs_params.ulAVFSGB_FUSE_TABLE_CKSOFF_b);
+                table->AVFSGB_VDROOP_TABLE[1].m1_shift = 24;
+                table->AVFSGB_VDROOP_TABLE[1].m2_shift  = 12;
+                table->MaxVoltage                = PP_HOST_TO_SMC_US(avfs_params.usMaxVoltage_0_25mv);
+                AVFS_meanNsigma.Aconstant[0]      = PP_HOST_TO_SMC_UL(avfs_params.ulAVFS_meanNsigma_Acontant0);
+                AVFS_meanNsigma.Aconstant[1]      = PP_HOST_TO_SMC_UL(avfs_params.ulAVFS_meanNsigma_Acontant1);
+                AVFS_meanNsigma.Aconstant[2]      = PP_HOST_TO_SMC_UL(avfs_params.ulAVFS_meanNsigma_Acontant2);
+                AVFS_meanNsigma.DC_tol_sigma      = PP_HOST_TO_SMC_US(avfs_params.usAVFS_meanNsigma_DC_tol_sigma);
+                AVFS_meanNsigma.Platform_mean     = PP_HOST_TO_SMC_US(avfs_params.usAVFS_meanNsigma_Platform_mean);
+                AVFS_meanNsigma.PSM_Age_CompFactor = PP_HOST_TO_SMC_US(avfs_params.usPSM_Age_ComFactor);
+                AVFS_meanNsigma.Platform_sigma     = PP_HOST_TO_SMC_US(avfs_params.usAVFS_meanNsigma_Platform_sigma);
+                for (i = 0; i < NUM_VFT_COLUMNS; i++) {
+                        AVFS_meanNsigma.Static_Voltage_Offset[i] = (uint8_t)(sclk_table->entries[i].cks_voffset * 100 / 625);
+                        AVFS_SclkOffset.Sclk_Offset[i] = PP_HOST_TO_SMC_US((uint16_t)(sclk_table->entries[i].sclk_offset) / 100);
+                }
+                result = polaris10_read_smc_sram_dword(smumgr,
+                                SMU7_FIRMWARE_HEADER_LOCATION + offsetof(SMU74_Firmware_Header, AvfsMeanNSigma),
+                                &tmp, data->sram_end);
+                polaris10_copy_bytes_to_smc(smumgr,
+                                        tmp,
+                                        (uint8_t *)&AVFS_meanNsigma,
+                                        sizeof(AVFS_meanNsigma_t),
+                                        data->sram_end);
+                result = polaris10_read_smc_sram_dword(smumgr,
+                                SMU7_FIRMWARE_HEADER_LOCATION + offsetof(SMU74_Firmware_Header, AvfsSclkOffsetTable),
+                                &tmp, data->sram_end);
+                polaris10_copy_bytes_to_smc(smumgr,
+                                        tmp,
+                                        (uint8_t *)&AVFS_SclkOffset,
+                                        sizeof(AVFS_Sclk_Offset_t),
+                                        data->sram_end);
+                data->avfs_vdroop_override_setting = (avfs_params.ucEnableGB_VDROOP_TABLE_CKSON << BTCGB0_Vdroop_Enable_SHIFT) |
+                                                (avfs_params.ucEnableGB_VDROOP_TABLE_CKSOFF << BTCGB1_Vdroop_Enable_SHIFT) |
+                                                (avfs_params.ucEnableGB_FUSE_TABLE_CKSON << AVFSGB0_Vdroop_Enable_SHIFT) |
+                                                (avfs_params.ucEnableGB_FUSE_TABLE_CKSOFF << AVFSGB1_Vdroop_Enable_SHIFT);
+                data->apply_avfs_cks_off_voltage = (avfs_params.ucEnableApplyAVFS_CKS_OFF_Voltage == 1) ? true : false;
+        }
+        return result;
+}
 /**
 * Initializes the SMC table and uploads it
 *
@@ -2056,6 +2060,10 @@ static int polaris10_init_smc_table(struct pp_hwmgr *hwmgr)
                                "Failed to populate Clock Stretcher Data Table!",
                                return result);
        }
+        result = polaris10_populate_avfs_parameters(hwmgr);
+        PP_ASSERT_WITH_CODE(0 == result, "Failed to populate AVFS Parameters!", return result;);
        table->CurrSclkPllRange = 0xff;
        table->GraphicsVoltageChangeEnable  = 1;
        table->GraphicsThermThrottleEnable  = 1;
@@ -2252,6 +2260,9 @@ static int polaris10_enable_deep_sleep_master_switch(struct pp_hwmgr *hwmgr)
 static int polaris10_enable_sclk_mclk_dpm(struct pp_hwmgr *hwmgr)
 {
        struct polaris10_hwmgr *data = (struct polaris10_hwmgr *)(hwmgr->backend);
+        uint32_t soft_register_value = 0;
+        uint32_t handshake_disables_offset = data->soft_regs_start
+                                + offsetof(SMU74_SoftRegisters, HandshakeDisables);
        /* enable SCLK dpm */
        if (!data->sclk_dpm_key_disabled)
@@ -2262,6 +2273,12 @@ static int polaris10_enable_sclk_mclk_dpm(struct pp_hwmgr *hwmgr)
        /* enable MCLK dpm */
        if (0 == data->mclk_dpm_key_disabled) {
+/* Disable UVD - SMU handshake for MCLK. */
+                soft_register_value = cgs_read_ind_register(hwmgr->device,
+                                        CGS_IND_REG__SMC, handshake_disables_offset);
+                soft_register_value |= SMU7_UVD_MCLK_HANDSHAKE_DISABLE;
+                cgs_write_ind_register(hwmgr->device, CGS_IND_REG__SMC,
+                                handshake_disables_offset, soft_register_value);
                PP_ASSERT_WITH_CODE(
                                (0 == smum_send_msg_to_smc(hwmgr->smumgr,
@@ -2269,7 +2286,6 @@ static int polaris10_enable_sclk_mclk_dpm(struct pp_hwmgr *hwmgr)
                                "Failed to enable MCLK DPM during DPM Start Function!",
                                return -1);
                PHM_WRITE_FIELD(hwmgr->device, MC_SEQ_CNTL_3, CAC_EN, 0x1);
                cgs_write_ind_register(hwmgr->device, CGS_IND_REG__SMC, ixLCAC_MC0_CNTL, 0x5);
@@ -2606,6 +2622,7 @@ int polaris10_set_features_platform_caps(struct pp_hwmgr *hwmgr)
        phm_cap_set(hwmgr->platform_descriptor.platformCaps,
                                                PHM_PlatformCaps_FanSpeedInTableIsRPM);
        if (hwmgr->chip_id == CHIP_POLARIS11)
                phm_cap_set(hwmgr->platform_descriptor.platformCaps,
                                        PHM_PlatformCaps_SPLLShutdownSupport);
@@ -2938,6 +2955,11 @@ int polaris10_hwmgr_backend_init(struct pp_hwmgr *hwmgr)
        data->vddci_control = POLARIS10_VOLTAGE_CONTROL_NONE;
        data->mvdd_control = POLARIS10_VOLTAGE_CONTROL_NONE;
+        data->enable_tdc_limit_feature = true;
+        data->enable_pkg_pwr_tracking_feature = true;
+        data->force_pcie_gen = PP_PCIEGenInvalid;
+        data->mclk_stutter_mode_threshold = 40000;
        if (atomctrl_is_voltage_controled_by_gpio_v3(hwmgr,
                        VOLTAGE_TYPE_VDDC, VOLTAGE_OBJ_SVID2))
                data->voltage_control = POLARIS10_VOLTAGE_CONTROL_BY_SVID2;
@@ -2962,6 +2984,10 @@ int polaris10_hwmgr_backend_init(struct pp_hwmgr *hwmgr)
                        data->vddci_control = POLARIS10_VOLTAGE_CONTROL_BY_SVID2;
        }
+        if (table_info->cac_dtp_table->usClockStretchAmount != 0)
+                phm_cap_set(hwmgr->platform_descriptor.platformCaps,
+                                        PHM_PlatformCaps_ClockStretcher);
        polaris10_set_features_platform_caps(hwmgr);
        polaris10_init_dpm_defaults(hwmgr);
diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/polaris10_hwmgr.h b/drivers/gpu/drm/amd/powerplay/hwmgr/polaris10_hwmgr.h
index beedf35cbfa6..d717789441f5 100644
--- a/drivers/gpu/drm/amd/powerplay/hwmgr/polaris10_hwmgr.h
+++ b/drivers/gpu/drm/amd/powerplay/hwmgr/polaris10_hwmgr.h
@@ -312,6 +312,9 @@ struct polaris10_hwmgr {
        /* soft pptable for re-uploading into smu */
        void *soft_pp_table;
+        uint32_t                              avfs_vdroop_override_setting;
+        bool                                  apply_avfs_cks_off_voltage;
 };
 /* To convert to Q8.8 format for firmware */
diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/polaris10_thermal.c b/drivers/gpu/drm/amd/powerplay/hwmgr/polaris10_thermal.c
index aba167f7d167..b206632d4650 100644
--- a/drivers/gpu/drm/amd/powerplay/hwmgr/polaris10_thermal.c
+++ b/drivers/gpu/drm/amd/powerplay/hwmgr/polaris10_thermal.c
@@ -625,10 +625,14 @@ static int tf_polaris10_thermal_avfs_enable(struct pp_hwmgr *hwmgr,
        int ret;
        struct pp_smumgr *smumgr = (struct pp_smumgr *)(hwmgr->smumgr);
        struct polaris10_smumgr *smu_data = (struct polaris10_smumgr *)(smumgr->backend);
+        struct polaris10_hwmgr *data = (struct polaris10_hwmgr *)(hwmgr->backend);
-        if (smu_data->avfs.avfs_btc_status != AVFS_BTC_ENABLEAVFS)
+        if (smu_data->avfs.avfs_btc_status == AVFS_BTC_NOTSUPPORTED)
                return 0;
+        ret = smum_send_msg_to_smc_with_parameter(hwmgr->smumgr,
+                        PPSMC_MSG_SetGBDroopSettings, data->avfs_vdroop_override_setting);
        ret = (smum_send_msg_to_smc(smumgr, PPSMC_MSG_EnableAvfs) == 0) ?
                        0 : -1;
diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/pp_acpi.c b/drivers/gpu/drm/amd/powerplay/hwmgr/pp_acpi.c
index 58742e0d1492..a3c38bbd1e94 100644
--- a/drivers/gpu/drm/amd/powerplay/hwmgr/pp_acpi.c
+++ b/drivers/gpu/drm/amd/powerplay/hwmgr/pp_acpi.c
@@ -44,6 +44,20 @@ bool acpi_atcs_functions_supported(void *device, uint32_t index)
        return result == 0 ? (output_buf.function_bits & (1 << (index - 1))) != 0 : false;
 }
+bool acpi_atcs_notify_pcie_device_ready(void *device)
+{
+        int32_t temp_buffer = 1;
+        return cgs_call_acpi_method(device, CGS_ACPI_METHOD_ATCS,
+                                ATCS_FUNCTION_PCIE_DEVICE_READY_NOTIFICATION,
+                                                &temp_buffer,
+                                                NULL,
+                                                0,
+                                                sizeof(temp_buffer),
+                                                0);
+}
 int acpi_pcie_perf_request(void *device, uint8_t perf_req, bool advertise)
 {
        struct atcs_pref_req_input atcs_input;
@@ -52,7 +66,7 @@ int acpi_pcie_perf_request(void *device, uint8_t perf_req, bool advertise)
        int result;
        struct cgs_system_info info = {0};
-        if (!acpi_atcs_functions_supported(device, ATCS_FUNCTION_PCIE_PERFORMANCE_REQUEST))
+        if( 0 != acpi_atcs_notify_pcie_device_ready(device))
                return -EINVAL;
        info.size = sizeof(struct cgs_system_info);
@@ -77,7 +91,7 @@ int acpi_pcie_perf_request(void *device, uint8_t perf_req, bool advertise)
                                                ATCS_FUNCTION_PCIE_PERFORMANCE_REQUEST,
                                                &atcs_input,
                                                &atcs_output,
-                                                0,
+                                                1,
                                                sizeof(atcs_input),
                                                sizeof(atcs_output));
                if (result != 0)
diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/ppatomctrl.c b/drivers/gpu/drm/amd/powerplay/hwmgr/ppatomctrl.c
index da9f5f1b6dc2..bf4e18fd3872 100644
--- a/drivers/gpu/drm/amd/powerplay/hwmgr/ppatomctrl.c
+++ b/drivers/gpu/drm/amd/powerplay/hwmgr/ppatomctrl.c
@@ -1302,3 +1302,46 @@ int atomctrl_get_smc_sclk_range_table(struct pp_hwmgr *hwmgr, struct pp_atom_ctr
        return 0;
 }
+int atomctrl_get_avfs_information(struct pp_hwmgr *hwmgr, struct pp_atom_ctrl__avfs_parameters *param)
+{
+        ATOM_ASIC_PROFILING_INFO_V3_6 *profile = NULL;
+        if (param == NULL)
+                return -EINVAL;
+        profile = (ATOM_ASIC_PROFILING_INFO_V3_6 *)
+                        cgs_atom_get_data_table(hwmgr->device,
+                                        GetIndexIntoMasterTable(DATA, ASIC_ProfilingInfo),
+                                        NULL, NULL, NULL);
+        if (!profile)
+                return -1;
+        param->ulAVFS_meanNsigma_Acontant0 = profile->ulAVFS_meanNsigma_Acontant0;
+        param->ulAVFS_meanNsigma_Acontant1 = profile->ulAVFS_meanNsigma_Acontant1;
+        param->ulAVFS_meanNsigma_Acontant2 = profile->ulAVFS_meanNsigma_Acontant2;
+        param->usAVFS_meanNsigma_DC_tol_sigma = profile->usAVFS_meanNsigma_DC_tol_sigma;
+        param->usAVFS_meanNsigma_Platform_mean = profile->usAVFS_meanNsigma_Platform_mean;
+        param->usAVFS_meanNsigma_Platform_sigma = profile->usAVFS_meanNsigma_Platform_sigma;
+        param->ulGB_VDROOP_TABLE_CKSOFF_a0 = profile->ulGB_VDROOP_TABLE_CKSOFF_a0;
+        param->ulGB_VDROOP_TABLE_CKSOFF_a1 = profile->ulGB_VDROOP_TABLE_CKSOFF_a1;
+        param->ulGB_VDROOP_TABLE_CKSOFF_a2 = profile->ulGB_VDROOP_TABLE_CKSOFF_a2;
+        param->ulGB_VDROOP_TABLE_CKSON_a0 = profile->ulGB_VDROOP_TABLE_CKSON_a0;
+        param->ulGB_VDROOP_TABLE_CKSON_a1 = profile->ulGB_VDROOP_TABLE_CKSON_a1;
+        param->ulGB_VDROOP_TABLE_CKSON_a2 = profile->ulGB_VDROOP_TABLE_CKSON_a2;
+        param->ulAVFSGB_FUSE_TABLE_CKSOFF_m1 = profile->ulAVFSGB_FUSE_TABLE_CKSOFF_m1;
+        param->usAVFSGB_FUSE_TABLE_CKSOFF_m2 = profile->usAVFSGB_FUSE_TABLE_CKSOFF_m2;
+        param->ulAVFSGB_FUSE_TABLE_CKSOFF_b = profile->ulAVFSGB_FUSE_TABLE_CKSOFF_b;
+        param->ulAVFSGB_FUSE_TABLE_CKSON_m1 = profile->ulAVFSGB_FUSE_TABLE_CKSON_m1;
+        param->usAVFSGB_FUSE_TABLE_CKSON_m2 = profile->usAVFSGB_FUSE_TABLE_CKSON_m2;
+        param->ulAVFSGB_FUSE_TABLE_CKSON_b = profile->ulAVFSGB_FUSE_TABLE_CKSON_b;
+        param->usMaxVoltage_0_25mv = profile->usMaxVoltage_0_25mv;
+        param->ucEnableGB_VDROOP_TABLE_CKSOFF = profile->ucEnableGB_VDROOP_TABLE_CKSOFF;
+        param->ucEnableGB_VDROOP_TABLE_CKSON = profile->ucEnableGB_VDROOP_TABLE_CKSON;
+        param->ucEnableGB_FUSE_TABLE_CKSOFF = profile->ucEnableGB_FUSE_TABLE_CKSOFF;
+        param->ucEnableGB_FUSE_TABLE_CKSON = profile->ucEnableGB_FUSE_TABLE_CKSON;
+        param->usPSM_Age_ComFactor = profile->usPSM_Age_ComFactor;
+        param->ucEnableApplyAVFS_CKS_OFF_Voltage = profile->ucEnableApplyAVFS_CKS_OFF_Voltage;
+        return 0;
+}
diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/ppatomctrl.h b/drivers/gpu/drm/amd/powerplay/hwmgr/ppatomctrl.h
index d24ebb566905..248c5db5f380 100644
--- a/drivers/gpu/drm/amd/powerplay/hwmgr/ppatomctrl.h
+++ b/drivers/gpu/drm/amd/powerplay/hwmgr/ppatomctrl.h
@@ -250,6 +250,35 @@ struct pp_atomctrl_gpio_pin_assignment {
 };
 typedef struct pp_atomctrl_gpio_pin_assignment pp_atomctrl_gpio_pin_assignment;
+struct pp_atom_ctrl__avfs_parameters {
+        uint32_t  ulAVFS_meanNsigma_Acontant0;
+        uint32_t  ulAVFS_meanNsigma_Acontant1;
+        uint32_t  ulAVFS_meanNsigma_Acontant2;
+        uint16_t usAVFS_meanNsigma_DC_tol_sigma;
+        uint16_t usAVFS_meanNsigma_Platform_mean;
+        uint16_t usAVFS_meanNsigma_Platform_sigma;
+        uint32_t  ulGB_VDROOP_TABLE_CKSOFF_a0;
+        uint32_t  ulGB_VDROOP_TABLE_CKSOFF_a1;
+        uint32_t  ulGB_VDROOP_TABLE_CKSOFF_a2;
+        uint32_t  ulGB_VDROOP_TABLE_CKSON_a0;
+        uint32_t  ulGB_VDROOP_TABLE_CKSON_a1;
+        uint32_t  ulGB_VDROOP_TABLE_CKSON_a2;
+        uint32_t  ulAVFSGB_FUSE_TABLE_CKSOFF_m1;
+        uint16_t  usAVFSGB_FUSE_TABLE_CKSOFF_m2;
+        uint32_t  ulAVFSGB_FUSE_TABLE_CKSOFF_b;
+        uint32_t  ulAVFSGB_FUSE_TABLE_CKSON_m1;
+        uint16_t  usAVFSGB_FUSE_TABLE_CKSON_m2;
+        uint32_t  ulAVFSGB_FUSE_TABLE_CKSON_b;
+        uint16_t  usMaxVoltage_0_25mv;
+        uint8_t  ucEnableGB_VDROOP_TABLE_CKSOFF;
+        uint8_t  ucEnableGB_VDROOP_TABLE_CKSON;
+        uint8_t  ucEnableGB_FUSE_TABLE_CKSOFF;
+        uint8_t  ucEnableGB_FUSE_TABLE_CKSON;
+        uint16_t usPSM_Age_ComFactor;
+        uint8_t  ucEnableApplyAVFS_CKS_OFF_Voltage;
+        uint8_t  ucReserved;
+};
 extern bool atomctrl_get_pp_assign_pin(struct pp_hwmgr *hwmgr, const uint32_t pinId, pp_atomctrl_gpio_pin_assignment *gpio_pin_assignment);
 extern int atomctrl_get_voltage_evv_on_sclk(struct pp_hwmgr *hwmgr, uint8_t voltage_type, uint32_t sclk, uint16_t virtual_voltage_Id, uint16_t *voltage);
 extern uint32_t atomctrl_get_mpll_reference_clock(struct pp_hwmgr *hwmgr);
@@ -278,5 +307,8 @@ extern int atomctrl_set_ac_timing_ai(struct pp_hwmgr *hwmgr, uint32_t memory_clo
 extern int atomctrl_get_voltage_evv_on_sclk_ai(struct pp_hwmgr *hwmgr, uint8_t voltage_type,
                                uint32_t sclk, uint16_t virtual_voltage_Id, uint16_t *voltage);
 extern int atomctrl_get_smc_sclk_range_table(struct pp_hwmgr *hwmgr, struct pp_atom_ctrl_sclk_range_table *table);
+extern int atomctrl_get_avfs_information(struct pp_hwmgr *hwmgr, struct pp_atom_ctrl__avfs_parameters *param);
 #endif
diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/tonga_hwmgr.c b/drivers/gpu/drm/amd/powerplay/hwmgr/tonga_hwmgr.c
index d27e8c40602a..233eb7f36c1d 100644
--- a/drivers/gpu/drm/amd/powerplay/hwmgr/tonga_hwmgr.c
+++ b/drivers/gpu/drm/amd/powerplay/hwmgr/tonga_hwmgr.c
@@ -4489,6 +4489,7 @@ int tonga_hwmgr_backend_init(struct pp_hwmgr *hwmgr)
        data->vdd_ci_control = TONGA_VOLTAGE_CONTROL_NONE;
        data->vdd_gfx_control = TONGA_VOLTAGE_CONTROL_NONE;
        data->mvdd_control = TONGA_VOLTAGE_CONTROL_NONE;
+        data->force_pcie_gen = PP_PCIEGenInvalid;
        if (atomctrl_is_voltage_controled_by_gpio_v3(hwmgr,
                                VOLTAGE_TYPE_VDDC, VOLTAGE_OBJ_SVID2)) {
diff --git a/drivers/gpu/drm/amd/powerplay/inc/polaris10_ppsmc.h b/drivers/gpu/drm/amd/powerplay/inc/polaris10_ppsmc.h
index 0c6a413eaa5b..d41d37ab5b7c 100644
--- a/drivers/gpu/drm/amd/powerplay/inc/polaris10_ppsmc.h
+++ b/drivers/gpu/drm/amd/powerplay/inc/polaris10_ppsmc.h
@@ -27,6 +27,7 @@
 #pragma pack(push, 1)
+#define PPSMC_MSG_SetGBDroopSettings          ((uint16_t) 0x305)
 #define PPSMC_SWSTATE_FLAG_DC                           0x01
 #define PPSMC_SWSTATE_FLAG_UVD                          0x02
diff --git a/drivers/gpu/drm/amd/powerplay/inc/pp_acpi.h b/drivers/gpu/drm/amd/powerplay/inc/pp_acpi.h
index 3bd5e69b9045..3df5de2cdab0 100644
--- a/drivers/gpu/drm/amd/powerplay/inc/pp_acpi.h
+++ b/drivers/gpu/drm/amd/powerplay/inc/pp_acpi.h
@@ -26,3 +26,4 @@ extern bool acpi_atcs_functions_supported(void *device,
 extern int acpi_pcie_perf_request(void *device,
                                                uint8_t perf_req,
                                                bool advertise);
+extern bool acpi_atcs_notify_pcie_device_ready(void *device);
diff --git a/drivers/gpu/drm/amd/powerplay/inc/smu74.h b/drivers/gpu/drm/amd/powerplay/inc/smu74.h
index 1a12d85b8e97..fd10a9fa843d 100644
--- a/drivers/gpu/drm/amd/powerplay/inc/smu74.h
+++ b/drivers/gpu/drm/amd/powerplay/inc/smu74.h
@@ -34,6 +34,30 @@
 #define SMU__NUM_LCLK_DPM_LEVELS 8
 #define SMU__NUM_PCIE_DPM_LEVELS 8
+#define EXP_M1  35
+#define EXP_M2  92821
+#define EXP_B   66629747
+#define EXP_M1_1  365
+#define EXP_M2_1  658700
+#define EXP_B_1   305506134
+#define EXP_M1_2  189
+#define EXP_M2_2  379692
+#define EXP_B_2   194609469
+#define EXP_M1_3  99
+#define EXP_M2_3  217915
+#define EXP_B_3   122255994
+#define EXP_M1_4  51
+#define EXP_M2_4  122643
+#define EXP_B_4   74893384
+#define EXP_M1_5  423
+#define EXP_M2_5  1103326
+#define EXP_B_5   728122621
 enum SID_OPTION {
        SID_OPTION_HI,
        SID_OPTION_LO,
@@ -548,20 +572,20 @@ struct SMU74_Firmware_Header {
        uint32_t CacConfigTable;
        uint32_t CacStatusTable;
        uint32_t mcRegisterTable;
        uint32_t mcArbDramTimingTable;
        uint32_t PmFuseTable;
        uint32_t Globals;
        uint32_t ClockStretcherTable;
        uint32_t VftTable;
-        uint32_t Reserved[21];
+        uint32_t Reserved1;
+        uint32_t AvfsTable;
+        uint32_t AvfsCksOffGbvTable;
+        uint32_t AvfsMeanNSigma;
+        uint32_t AvfsSclkOffsetTable;
+        uint32_t Reserved[16];
        uint32_t Signature;
 };
@@ -701,8 +725,6 @@ VR Config info is contained in dpmTable.VRConfig */
 struct SMU_ClockStretcherDataTableEntry {
        uint8_t minVID;
        uint8_t maxVID;
        uint16_t setting;
 };
 typedef struct SMU_ClockStretcherDataTableEntry SMU_ClockStretcherDataTableEntry;
@@ -769,6 +791,43 @@ struct VFT_TABLE_t {
 typedef struct VFT_TABLE_t VFT_TABLE_t;
+/* Total margin, root mean square of Fmax + DC + Platform */
+struct AVFS_Margin_t {
+        VFT_CELL_t Cell[NUM_VFT_COLUMNS];
+};
+typedef struct AVFS_Margin_t AVFS_Margin_t;
+#define BTCGB_VDROOP_TABLE_MAX_ENTRIES 2
+#define AVFSGB_VDROOP_TABLE_MAX_ENTRIES 2
+struct GB_VDROOP_TABLE_t {
+        int32_t a0;
+        int32_t a1;
+        int32_t a2;
+        uint32_t spare;
+};
+typedef struct GB_VDROOP_TABLE_t GB_VDROOP_TABLE_t;
+struct AVFS_CksOff_Gbv_t {
+        VFT_CELL_t Cell[NUM_VFT_COLUMNS];
+};
+typedef struct AVFS_CksOff_Gbv_t AVFS_CksOff_Gbv_t;
+struct AVFS_meanNsigma_t {
+        uint32_t Aconstant[3];
+        uint16_t DC_tol_sigma;
+        uint16_t Platform_mean;
+        uint16_t Platform_sigma;
+        uint16_t PSM_Age_CompFactor;
+        uint8_t  Static_Voltage_Offset[NUM_VFT_COLUMNS];
+};
+typedef struct AVFS_meanNsigma_t AVFS_meanNsigma_t;
+struct AVFS_Sclk_Offset_t {
+        uint16_t Sclk_Offset[8];
+};
+typedef struct AVFS_Sclk_Offset_t AVFS_Sclk_Offset_t;
 #endif
diff --git a/drivers/gpu/drm/amd/powerplay/inc/smu74_discrete.h b/drivers/gpu/drm/amd/powerplay/inc/smu74_discrete.h
index 0dfe82336dc7..b85ff5400e57 100644
--- a/drivers/gpu/drm/amd/powerplay/inc/smu74_discrete.h
+++ b/drivers/gpu/drm/amd/powerplay/inc/smu74_discrete.h
@@ -223,6 +223,16 @@ struct SMU74_Discrete_StateInfo {
 typedef struct SMU74_Discrete_StateInfo SMU74_Discrete_StateInfo;
+struct SMU_QuadraticCoeffs {
+        int32_t m1;
+        uint32_t b;
+        int16_t m2;
+        uint8_t m1_shift;
+        uint8_t m2_shift;
+};
+typedef struct SMU_QuadraticCoeffs SMU_QuadraticCoeffs;
 struct SMU74_Discrete_DpmTable {
        SMU74_PIDController                  GraphicsPIDController;
@@ -258,7 +268,14 @@ struct SMU74_Discrete_DpmTable {
        uint8_t                             ThermOutPolarity;
        uint8_t                             ThermOutMode;
        uint8_t                             BootPhases;
-        uint32_t                            Reserved[4];
+        uint8_t                             VRHotLevel;
+        uint8_t                             Reserved1[3];
+        uint16_t                            FanStartTemperature;
+        uint16_t                            FanStopTemperature;
+        uint16_t                            MaxVoltage;
+        uint16_t                            Reserved2;
+        uint32_t                            Reserved[1];
        SMU74_Discrete_GraphicsLevel        GraphicsLevel[SMU74_MAX_LEVELS_GRAPHICS];
        SMU74_Discrete_MemoryLevel          MemoryACPILevel;
@@ -347,6 +364,8 @@ struct SMU74_Discrete_DpmTable {
        uint32_t                            CurrSclkPllRange;
        sclkFcwRange_t                      SclkFcwRangeTable[NUM_SCLK_RANGE];
+        GB_VDROOP_TABLE_t                   BTCGB_VDROOP_TABLE[BTCGB_VDROOP_TABLE_MAX_ENTRIES];
+        SMU_QuadraticCoeffs                 AVFSGB_VDROOP_TABLE[AVFSGB_VDROOP_TABLE_MAX_ENTRIES];
 };
 typedef struct SMU74_Discrete_DpmTable SMU74_Discrete_DpmTable;
@@ -550,16 +569,6 @@ struct SMU7_AcpiScoreboard {
 typedef struct SMU7_AcpiScoreboard SMU7_AcpiScoreboard;
-struct SMU_QuadraticCoeffs {
-        int32_t m1;
-        uint32_t b;
-        int16_t m2;
-        uint8_t m1_shift;
-        uint8_t m2_shift;
-};
-typedef struct SMU_QuadraticCoeffs SMU_QuadraticCoeffs;
 struct SMU74_Discrete_PmFuses {
        uint8_t BapmVddCVidHiSidd[8];
        uint8_t BapmVddCVidLoSidd[8];
@@ -821,6 +830,17 @@ typedef struct SMU7_GfxCuPgScoreboard SMU7_GfxCuPgScoreboard;
 #define DB_PCC_SHIFT 26 
 #define DB_EDC_SHIFT 27
+#define BTCGB0_Vdroop_Enable_MASK  0x1
+#define BTCGB1_Vdroop_Enable_MASK  0x2
+#define AVFSGB0_Vdroop_Enable_MASK 0x4
+#define AVFSGB1_Vdroop_Enable_MASK 0x8
+#define BTCGB0_Vdroop_Enable_SHIFT  0
+#define BTCGB1_Vdroop_Enable_SHIFT  1
+#define AVFSGB0_Vdroop_Enable_SHIFT 2
+#define AVFSGB1_Vdroop_Enable_SHIFT 3
 #pragma pack(pop)
diff --git a/drivers/gpu/drm/amd/powerplay/smumgr/polaris10_smumgr.c b/drivers/gpu/drm/amd/powerplay/smumgr/polaris10_smumgr.c
index 043b6ac09d5f..5dba7c509710 100644
--- a/drivers/gpu/drm/amd/powerplay/smumgr/polaris10_smumgr.c
+++ b/drivers/gpu/drm/amd/powerplay/smumgr/polaris10_smumgr.c
@@ -52,19 +52,18 @@
 static const SMU74_Discrete_GraphicsLevel avfs_graphics_level_polaris10[8] = {
        /*  Min      pcie   DeepSleep Activity  CgSpll      CgSpll    CcPwr  CcPwr  Sclk         Enabled      Enabled                       Voltage    Power */
        /* Voltage, DpmLevel, DivId,  Level,  FuncCntl3,  FuncCntl4,  DynRm, DynRm1 Did, Padding,ForActivity, ForThrottle, UpHyst, DownHyst, DownHyst, Throttle */
-        { 0x3c0fd047, 0x00, 0x03, 0x1e00, 0x00200410, 0x87020000, 0, 0, 0x16, 0, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, { 0x30750000, 0, 0, 0, 0, 0, 0, 0 } },
+        { 0x100ea446, 0x00, 0x03, 0x3200, 0, 0, 0, 0, 0, 0, 0x01, 0x01, 0x0a, 0x00, 0x00, 0x00, { 0x30750000, 0x3000, 0, 0x2600, 0, 0, 0x0004, 0x8f02, 0xffff, 0x2f00, 0x300e, 0x2700 } },
-        { 0xa00fd047, 0x01, 0x04, 0x1e00, 0x00800510, 0x87020000, 0, 0, 0x16, 0, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, { 0x409c0000, 0, 0, 0, 0, 0, 0, 0 } },
+        { 0x400ea446, 0x01, 0x04, 0x3200, 0, 0, 0, 0, 0, 0, 0x01, 0x01, 0x0a, 0x00, 0x00, 0x00, { 0x409c0000, 0x2000, 0, 0x1e00, 1, 1, 0x0004, 0x8300, 0xffff, 0x1f00, 0xcb5e, 0x1a00 } },
-        { 0x0410d047, 0x01, 0x00, 0x1e00, 0x00600410, 0x87020000, 0, 0, 0x0e, 0, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, { 0x50c30000, 0, 0, 0, 0, 0, 0, 0 } },
+        { 0x740ea446, 0x01, 0x00, 0x3200, 0, 0, 0, 0, 0, 0, 0x01, 0x01, 0x0a, 0x00, 0x00, 0x00, { 0x50c30000, 0x2800, 0, 0x2000, 1, 1, 0x0004, 0x0c02, 0xffff, 0x2700, 0x6433, 0x2100 } },
-        { 0x6810d047, 0x01, 0x00, 0x1e00, 0x00800410, 0x87020000, 0, 0, 0x0c, 0, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, { 0x60ea0000, 0, 0, 0, 0, 0, 0, 0 } },
+        { 0xa40ea446, 0x01, 0x00, 0x3200, 0, 0, 0, 0, 0, 0, 0x01, 0x01, 0x0a, 0x00, 0x00, 0x00, { 0x60ea0000, 0x3000, 0, 0x2600, 1, 1, 0x0004, 0x8f02, 0xffff, 0x2f00, 0x300e, 0x2700 } },
-        { 0xcc10d047, 0x01, 0x00, 0x1e00, 0x00e00410, 0x87020000, 0, 0, 0x0c, 0, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, { 0xe8fd0000, 0, 0, 0, 0, 0, 0, 0 } },
+        { 0xd80ea446, 0x01, 0x00, 0x3200, 0, 0, 0, 0, 0, 0, 0x01, 0x01, 0x0a, 0x00, 0x00, 0x00, { 0x70110100, 0x3800, 0, 0x2c00, 1, 1, 0x0004, 0x1203, 0xffff, 0x3600, 0xc9e2, 0x2e00 } },
-        { 0x3011d047, 0x01, 0x00, 0x1e00, 0x00400510, 0x87020000, 0, 0, 0x0c, 0, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, { 0x70110100, 0, 0, 0, 0, 0, 0, 0 } },
+        { 0x3c0fa446, 0x01, 0x00, 0x3200, 0, 0, 0, 0, 0, 0, 0x01, 0x01, 0x0a, 0x00, 0x00, 0x00, { 0x80380100, 0x2000, 0, 0x1e00, 2, 1, 0x0004, 0x8300, 0xffff, 0x1f00, 0xcb5e, 0x1a00 } },
-        { 0x9411d047, 0x01, 0x00, 0x1e00, 0x00a00510, 0x87020000, 0, 0, 0x0c, 0, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, { 0xf8240100, 0, 0, 0, 0, 0, 0, 0 } },
+        { 0x6c0fa446, 0x01, 0x00, 0x3200, 0, 0, 0, 0, 0, 0, 0x01, 0x01, 0x0a, 0x00, 0x00, 0x00, { 0x905f0100, 0x2400, 0, 0x1e00, 2, 1, 0x0004, 0x8901, 0xffff, 0x2300, 0x314c, 0x1d00 } },
-        { 0xf811d047, 0x01, 0x00, 0x1e00, 0x00000610, 0x87020000, 0, 0, 0x0c, 0, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, { 0x80380100, 0, 0, 0, 0, 0, 0, 0 } }
+        { 0xa00fa446, 0x01, 0x00, 0x3200, 0, 0, 0, 0, 0, 0, 0x01, 0x01, 0x0a, 0x00, 0x00, 0x00, { 0xa0860100, 0x2800, 0, 0x2000, 2, 1, 0x0004, 0x0c02, 0xffff, 0x2700, 0x6433, 0x2100 } }
 };
 static const SMU74_Discrete_MemoryLevel avfs_memory_level_polaris10 =
-        {0x50140000, 0x50140000, 0x00320000, 0x00, 0x00,
+        {0x100ea446, 0, 0x30750000, 0x01, 0x01, 0x01, 0x00, 0x00, 0x64, 0x00, 0x00, 0x1f00, 0x00, 0x00};
-         0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x0000, 0x00, 0x00};
 /**
 * Set the address for reading/writing the SMC SRAM space.
@@ -219,6 +218,18 @@ bool polaris10_is_smc_ram_running(struct pp_smumgr *smumgr)
        && (0x20100 <= cgs_read_ind_register(smumgr->device, CGS_IND_REG__SMC, ixSMC_PC_C)));
 }
+static bool polaris10_is_hw_avfs_present(struct pp_smumgr *smumgr)
+{
+        uint32_t efuse;
+        efuse = cgs_read_ind_register(smumgr->device, CGS_IND_REG__SMC, ixSMU_EFUSE_0 + (49*4));
+        efuse &= 0x00000001;
+        if (efuse)
+                return true;
+        return false;
+}
 /**
 * Send a message to the SMC, and wait for its response.
 *
@@ -228,21 +239,27 @@ bool polaris10_is_smc_ram_running(struct pp_smumgr *smumgr)
 */
 int polaris10_send_msg_to_smc(struct pp_smumgr *smumgr, uint16_t msg)
 {
+        int ret;
        if (!polaris10_is_smc_ram_running(smumgr))
                return -1;
        SMUM_WAIT_FIELD_UNEQUAL(smumgr, SMC_RESP_0, SMC_RESP, 0);
-        if (1 != SMUM_READ_FIELD(smumgr->device, SMC_RESP_0, SMC_RESP))
+        ret = SMUM_READ_FIELD(smumgr->device, SMC_RESP_0, SMC_RESP);
-                printk("Failed to send Previous Message.\n");
+        if (ret != 1)
+                printk("\n failed to send pre message %x ret is %d \n",  msg, ret);
        cgs_write_register(smumgr->device, mmSMC_MESSAGE_0, msg);
        SMUM_WAIT_FIELD_UNEQUAL(smumgr, SMC_RESP_0, SMC_RESP, 0);
-        if (1 != SMUM_READ_FIELD(smumgr->device, SMC_RESP_0, SMC_RESP))
+        ret = SMUM_READ_FIELD(smumgr->device, SMC_RESP_0, SMC_RESP);
-                printk("Failed to send Message.\n");
+        if (ret != 1)
+                printk("\n failed to send message %x ret is %d \n",  msg, ret);
        return 0;
 }
@@ -953,6 +970,11 @@ static int polaris10_smu_init(struct pp_smumgr *smumgr)
                (cgs_handle_t)smu_data->smu_buffer.handle);
                return -1;);
+        if (polaris10_is_hw_avfs_present(smumgr))
+                smu_data->avfs.avfs_btc_status = AVFS_BTC_BOOT;
+        else
+                smu_data->avfs.avfs_btc_status = AVFS_BTC_NOTSUPPORTED;
        return 0;
 }
diff --git a/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_output.c b/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_output.c
index 39802c0539b6..3d34fc4ca826 100644
--- a/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_output.c
+++ b/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_output.c
@@ -266,9 +266,10 @@ int atmel_hlcdc_create_outputs(struct drm_device *dev)
                if (!ret)
                        ret = atmel_hlcdc_check_endpoint(dev, &ep);
-                of_node_put(ep_np);
+                if (ret) {
-                if (ret)
+                        of_node_put(ep_np);
                        return ret;
+                }
        }
        for_each_endpoint_of_node(dev->dev->of_node, ep_np) {
@@ -276,9 +277,10 @@ int atmel_hlcdc_create_outputs(struct drm_device *dev)
                if (!ret)
                        ret = atmel_hlcdc_attach_endpoint(dev, &ep);
-                of_node_put(ep_np);
+                if (ret) {
-                if (ret)
+                        of_node_put(ep_np);
                        return ret;
+                }
        }
        return 0;
diff --git a/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_plane.c b/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_plane.c
index aef3ca8a81fa..016c191221f3 100644
--- a/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_plane.c
+++ b/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_plane.c
@@ -339,6 +339,8 @@ atmel_hlcdc_plane_update_pos_and_size(struct atmel_hlcdc_plane *plane,
                atmel_hlcdc_layer_update_cfg(&plane->layer, 13, 0xffffffff,
                                             factor_reg);
+        } else {
+                atmel_hlcdc_layer_update_cfg(&plane->layer, 13, 0xffffffff, 0);
        }
 }
diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c
index c204ef32df16..9bb99e274d23 100644
--- a/drivers/gpu/drm/drm_atomic.c
+++ b/drivers/gpu/drm/drm_atomic.c
@@ -1296,14 +1296,39 @@ EXPORT_SYMBOL(drm_atomic_add_affected_planes);
 */
 void drm_atomic_legacy_backoff(struct drm_atomic_state *state)
 {
+        struct drm_device *dev = state->dev;
+        unsigned crtc_mask = 0;
+        struct drm_crtc *crtc;
        int ret;
+        bool global = false;
+        drm_for_each_crtc(crtc, dev) {
+                if (crtc->acquire_ctx != state->acquire_ctx)
+                        continue;
+                crtc_mask |= drm_crtc_mask(crtc);
+                crtc->acquire_ctx = NULL;
+        }
+        if (WARN_ON(dev->mode_config.acquire_ctx == state->acquire_ctx)) {
+                global = true;
+                dev->mode_config.acquire_ctx = NULL;
+        }
 retry:
        drm_modeset_backoff(state->acquire_ctx);
-        ret = drm_modeset_lock_all_ctx(state->dev, state->acquire_ctx);
+        ret = drm_modeset_lock_all_ctx(dev, state->acquire_ctx);
        if (ret)
                goto retry;
+        drm_for_each_crtc(crtc, dev)
+                if (drm_crtc_mask(crtc) & crtc_mask)
+                        crtc->acquire_ctx = state->acquire_ctx;
+        if (global)
+                dev->mode_config.acquire_ctx = state->acquire_ctx;
 }
 EXPORT_SYMBOL(drm_atomic_legacy_backoff);
diff --git a/drivers/gpu/drm/exynos/exynos7_drm_decon.c b/drivers/gpu/drm/exynos/exynos7_drm_decon.c
index f6223f907c15..7f9901b7777b 100644
--- a/drivers/gpu/drm/exynos/exynos7_drm_decon.c
+++ b/drivers/gpu/drm/exynos/exynos7_drm_decon.c
@@ -31,7 +31,6 @@
 #include "exynos_drm_plane.h"
 #include "exynos_drm_drv.h"
 #include "exynos_drm_fb.h"
-#include "exynos_drm_fbdev.h"
 #include "exynos_drm_iommu.h"
 /*
diff --git a/drivers/gpu/drm/exynos/exynos_dp.c b/drivers/gpu/drm/exynos/exynos_dp.c
index 468498e3fec1..4c1fb3f8b5a6 100644
--- a/drivers/gpu/drm/exynos/exynos_dp.c
+++ b/drivers/gpu/drm/exynos/exynos_dp.c
@@ -34,7 +34,7 @@
 struct exynos_dp_device {
        struct drm_encoder         encoder;
-        struct drm_connector       connector;
+        struct drm_connector       *connector;
        struct drm_bridge          *ptn_bridge;
        struct drm_device          *drm_dev;
        struct device              *dev;
@@ -70,7 +70,7 @@ static int exynos_dp_poweroff(struct analogix_dp_plat_data *plat_data)
 static int exynos_dp_get_modes(struct analogix_dp_plat_data *plat_data)
 {
        struct exynos_dp_device *dp = to_dp(plat_data);
-        struct drm_connector *connector = &dp->connector;
+        struct drm_connector *connector = dp->connector;
        struct drm_display_mode *mode;
        int num_modes = 0;
@@ -103,6 +103,7 @@ static int exynos_dp_bridge_attach(struct analogix_dp_plat_data *plat_data,
        int ret;
        drm_connector_register(connector);
+        dp->connector = connector;
        /* Pre-empt DP connector creation if there's a bridge */
        if (dp->ptn_bridge) {
diff --git a/drivers/gpu/drm/exynos/exynos_drm_core.c b/drivers/gpu/drm/exynos/exynos_drm_core.c
index 011211e4167d..edbd98ff293e 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_core.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_core.c
@@ -15,7 +15,6 @@
 #include <drm/drmP.h>
 #include "exynos_drm_drv.h"
 #include "exynos_drm_crtc.h"
-#include "exynos_drm_fbdev.h"
 static LIST_HEAD(exynos_drm_subdrv_list);
diff --git a/drivers/gpu/drm/exynos/exynos_drm_fimd.c b/drivers/gpu/drm/exynos/exynos_drm_fimd.c
index 3efe1aa89416..d47216488985 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_fimd.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_fimd.c
@@ -30,7 +30,6 @@
 #include "exynos_drm_drv.h"
 #include "exynos_drm_fb.h"
-#include "exynos_drm_fbdev.h"
 #include "exynos_drm_crtc.h"
 #include "exynos_drm_plane.h"
 #include "exynos_drm_iommu.h"
@@ -120,7 +119,6 @@ static struct fimd_driver_data s3c64xx_fimd_driver_data = {
        .timing_base = 0x0,
        .has_clksel = 1,
        .has_limited_fmt = 1,
-        .has_hw_trigger = 1,
 };
 static struct fimd_driver_data exynos3_fimd_driver_data = {
@@ -171,14 +169,11 @@ static struct fimd_driver_data exynos5420_fimd_driver_data = {
        .lcdblk_vt_shift = 24,
        .lcdblk_bypass_shift = 15,
        .lcdblk_mic_bypass_shift = 11,
-        .trg_type = I80_HW_TRG,
        .has_shadowcon = 1,
        .has_vidoutcon = 1,
        .has_vtsel = 1,
        .has_mic_bypass = 1,
        .has_dp_clk = 1,
-        .has_hw_trigger = 1,
-        .has_trigger_per_te = 1,
 };
 struct fimd_context {
diff --git a/drivers/gpu/drm/exynos/exynos_drm_g2d.c b/drivers/gpu/drm/exynos/exynos_drm_g2d.c
index 493552368295..8564c3da0d22 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_g2d.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_g2d.c
@@ -48,13 +48,13 @@
 /* registers for base address */
 #define G2D_SRC_BASE_ADDR               0x0304
-#define G2D_SRC_STRIDE_REG              0x0308
+#define G2D_SRC_STRIDE                  0x0308
 #define G2D_SRC_COLOR_MODE              0x030C
 #define G2D_SRC_LEFT_TOP                0x0310
 #define G2D_SRC_RIGHT_BOTTOM            0x0314
 #define G2D_SRC_PLANE2_BASE_ADDR        0x0318
 #define G2D_DST_BASE_ADDR               0x0404
-#define G2D_DST_STRIDE_REG              0x0408
+#define G2D_DST_STRIDE                  0x0408
 #define G2D_DST_COLOR_MODE              0x040C
 #define G2D_DST_LEFT_TOP                0x0410
 #define G2D_DST_RIGHT_BOTTOM            0x0414
@@ -563,7 +563,7 @@ static enum g2d_reg_type g2d_get_reg_type(int reg_offset)
        switch (reg_offset) {
        case G2D_SRC_BASE_ADDR:
-        case G2D_SRC_STRIDE_REG:
+        case G2D_SRC_STRIDE:
        case G2D_SRC_COLOR_MODE:
        case G2D_SRC_LEFT_TOP:
        case G2D_SRC_RIGHT_BOTTOM:
@@ -573,7 +573,7 @@ static enum g2d_reg_type g2d_get_reg_type(int reg_offset)
                reg_type = REG_TYPE_SRC_PLANE2;
                break;
        case G2D_DST_BASE_ADDR:
-        case G2D_DST_STRIDE_REG:
+        case G2D_DST_STRIDE:
        case G2D_DST_COLOR_MODE:
        case G2D_DST_LEFT_TOP:
        case G2D_DST_RIGHT_BOTTOM:
@@ -968,8 +968,8 @@ static int g2d_check_reg_offset(struct device *dev,
                        } else
                                buf_info->types[reg_type] = BUF_TYPE_GEM;
                        break;
-                case G2D_SRC_STRIDE_REG:
+                case G2D_SRC_STRIDE:
-                case G2D_DST_STRIDE_REG:
+                case G2D_DST_STRIDE:
                        if (for_addr)
                                goto err;
diff --git a/drivers/gpu/drm/exynos/exynos_drm_plane.c b/drivers/gpu/drm/exynos/exynos_drm_plane.c
index 55f1d37c666a..77f12c00abf9 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_plane.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_plane.c
@@ -242,7 +242,7 @@ exynos_drm_plane_check_size(const struct exynos_drm_plane_config *config,
            state->v_ratio == (1 << 15))
                height_ok = true;
-        if (width_ok & height_ok)
+        if (width_ok && height_ok)
                return 0;
        DRM_DEBUG_KMS("scaling mode is not supported");
diff --git a/drivers/gpu/drm/i915/intel_dp.c b/drivers/gpu/drm/i915/intel_dp.c
index ffe5f8430957..79cf2d5f5a20 100644
--- a/drivers/gpu/drm/i915/intel_dp.c
+++ b/drivers/gpu/drm/i915/intel_dp.c
@@ -4977,9 +4977,6 @@ intel_dp_hpd_pulse(struct intel_digital_port *intel_dig_port, bool long_hpd)
        intel_display_power_get(dev_priv, power_domain);
        if (long_hpd) {
-                /* indicate that we need to restart link training */
-                intel_dp->train_set_valid = false;
                intel_dp_long_pulse(intel_dp->attached_connector);
                if (intel_dp->is_mst)
                        ret = IRQ_HANDLED;
diff --git a/drivers/gpu/drm/i915/intel_dp_link_training.c b/drivers/gpu/drm/i915/intel_dp_link_training.c
index 0b8eefc2acc5..60fb39cd220b 100644
--- a/drivers/gpu/drm/i915/intel_dp_link_training.c
+++ b/drivers/gpu/drm/i915/intel_dp_link_training.c
@@ -85,8 +85,7 @@ static bool
 intel_dp_reset_link_train(struct intel_dp *intel_dp,
                        uint8_t dp_train_pat)
 {
-        if (!intel_dp->train_set_valid)
+        memset(intel_dp->train_set, 0, sizeof(intel_dp->train_set));
-                memset(intel_dp->train_set, 0, sizeof(intel_dp->train_set));
        intel_dp_set_signal_levels(intel_dp);
        return intel_dp_set_link_train(intel_dp, dp_train_pat);
 }
@@ -161,23 +160,6 @@ intel_dp_link_training_clock_recovery(struct intel_dp *intel_dp)
                        break;
                }
-                /*
-                 * if we used previously trained voltage and pre-emphasis values
-                 * and we don't get clock recovery, reset link training values
-                 */
-                if (intel_dp->train_set_valid) {
-                        DRM_DEBUG_KMS("clock recovery not ok, reset");
-                        /* clear the flag as we are not reusing train set */
-                        intel_dp->train_set_valid = false;
-                        if (!intel_dp_reset_link_train(intel_dp,
-                                                       DP_TRAINING_PATTERN_1 |
-                                                       DP_LINK_SCRAMBLING_DISABLE)) {
-                                DRM_ERROR("failed to enable link training\n");
-                                return;
-                        }
-                        continue;
-                }
                /* Check to see if we've tried the max voltage */
                for (i = 0; i < intel_dp->lane_count; i++)
                        if ((intel_dp->train_set[i] & DP_TRAIN_MAX_SWING_REACHED) == 0)
@@ -284,7 +266,6 @@ intel_dp_link_training_channel_equalization(struct intel_dp *intel_dp)
                /* Make sure clock is still ok */
                if (!drm_dp_clock_recovery_ok(link_status,
                                              intel_dp->lane_count)) {
-                        intel_dp->train_set_valid = false;
                        intel_dp_link_training_clock_recovery(intel_dp);
                        intel_dp_set_link_train(intel_dp,
                                                training_pattern |
@@ -301,7 +282,6 @@ intel_dp_link_training_channel_equalization(struct intel_dp *intel_dp)
                /* Try 5 times, then try clock recovery if that fails */
                if (tries > 5) {
-                        intel_dp->train_set_valid = false;
                        intel_dp_link_training_clock_recovery(intel_dp);
                        intel_dp_set_link_train(intel_dp,
                                                training_pattern |
@@ -322,10 +302,8 @@ intel_dp_link_training_channel_equalization(struct intel_dp *intel_dp)
        intel_dp_set_idle_link_train(intel_dp);
-        if (channel_eq) {
+        if (channel_eq)
-                intel_dp->train_set_valid = true;
                DRM_DEBUG_KMS("Channel EQ done. DP Training successful\n");
-        }
 }
 void intel_dp_stop_link_train(struct intel_dp *intel_dp)
diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h
index 4a24b0067a3a..f7f0f01814f6 100644
--- a/drivers/gpu/drm/i915/intel_drv.h
+++ b/drivers/gpu/drm/i915/intel_drv.h
@@ -863,8 +863,6 @@ struct intel_dp {
        /* This is called before a link training is starterd */
        void (*prepare_link_retrain)(struct intel_dp *intel_dp);
-        bool train_set_valid;
        /* Displayport compliance testing */
        unsigned long compliance_test_type;
        unsigned long compliance_test_data;
diff --git a/drivers/gpu/drm/i915/intel_fbc.c b/drivers/gpu/drm/i915/intel_fbc.c
index d5a7cfec589b..647127f3aaff 100644
--- a/drivers/gpu/drm/i915/intel_fbc.c
+++ b/drivers/gpu/drm/i915/intel_fbc.c
@@ -824,8 +824,7 @@ static bool intel_fbc_can_choose(struct intel_crtc *crtc)
 {
        struct drm_i915_private *dev_priv = crtc->base.dev->dev_private;
        struct intel_fbc *fbc = &dev_priv->fbc;
-        bool enable_by_default = IS_HASWELL(dev_priv) ||
+        bool enable_by_default = IS_BROADWELL(dev_priv);
-                                 IS_BROADWELL(dev_priv);
        if (intel_vgpu_active(dev_priv->dev)) {
                fbc->no_fbc_reason = "VGPU is active";
diff --git a/drivers/gpu/drm/nouveau/nouveau_fbcon.c b/drivers/gpu/drm/nouveau/nouveau_fbcon.c
index 300ea03be8f0..d1f248fd3506 100644
--- a/drivers/gpu/drm/nouveau/nouveau_fbcon.c
+++ b/drivers/gpu/drm/nouveau/nouveau_fbcon.c
@@ -552,7 +552,8 @@ nouveau_fbcon_init(struct drm_device *dev)
        if (ret)
                goto fini;
-        fbcon->helper.fbdev->pixmap.buf_align = 4;
+        if (fbcon->helper.fbdev)
+                fbcon->helper.fbdev->pixmap.buf_align = 4;
        return 0;
 fini:
diff --git a/drivers/gpu/drm/sun4i/Kconfig b/drivers/gpu/drm/sun4i/Kconfig
index 99510e64e91a..a4b357db8856 100644
--- a/drivers/gpu/drm/sun4i/Kconfig
+++ b/drivers/gpu/drm/sun4i/Kconfig
@@ -1,6 +1,6 @@
 config DRM_SUN4I
        tristate "DRM Support for Allwinner A10 Display Engine"
-        depends on DRM && ARM
+        depends on DRM && ARM && COMMON_CLK
        depends on ARCH_SUNXI || COMPILE_TEST
        select DRM_GEM_CMA_HELPER
        select DRM_KMS_HELPER
diff --git a/drivers/gpu/drm/sun4i/sun4i_backend.c b/drivers/gpu/drm/sun4i/sun4i_backend.c
index f7a15c1a93bf..3ab560450a82 100644
--- a/drivers/gpu/drm/sun4i/sun4i_backend.c
+++ b/drivers/gpu/drm/sun4i/sun4i_backend.c
@@ -190,7 +190,7 @@ int sun4i_backend_update_layer_buffer(struct sun4i_backend *backend,
        /* Get the physical address of the buffer in memory */
        gem = drm_fb_cma_get_gem_obj(fb, 0);
-        DRM_DEBUG_DRIVER("Using GEM @ 0x%x\n", gem->paddr);
+        DRM_DEBUG_DRIVER("Using GEM @ %pad\n", &gem->paddr);
        /* Compute the start of the displayed memory */
        bpp = drm_format_plane_cpp(fb->pixel_format, 0);
@@ -198,7 +198,7 @@ int sun4i_backend_update_layer_buffer(struct sun4i_backend *backend,
        paddr += (state->src_x >> 16) * bpp;
        paddr += (state->src_y >> 16) * fb->pitches[0];
-        DRM_DEBUG_DRIVER("Setting buffer address to 0x%x\n", paddr);
+        DRM_DEBUG_DRIVER("Setting buffer address to %pad\n", &paddr);
        /* Write the 32 lower bits of the address (in bits) */
        lo_paddr = paddr << 3;
diff --git a/drivers/gpu/drm/sun4i/sun4i_dotclock.c b/drivers/gpu/drm/sun4i/sun4i_dotclock.c
index 3ff668cb463c..5b3463197c48 100644
--- a/drivers/gpu/drm/sun4i/sun4i_dotclock.c
+++ b/drivers/gpu/drm/sun4i/sun4i_dotclock.c
@@ -72,14 +72,40 @@ static unsigned long sun4i_dclk_recalc_rate(struct clk_hw *hw,
 static long sun4i_dclk_round_rate(struct clk_hw *hw, unsigned long rate,
                                  unsigned long *parent_rate)
 {
-        return *parent_rate / DIV_ROUND_CLOSEST(*parent_rate, rate);
+        unsigned long best_parent = 0;
+        u8 best_div = 1;
+        int i;
+        for (i = 6; i < 127; i++) {
+                unsigned long ideal = rate * i;
+                unsigned long rounded;
+                rounded = clk_hw_round_rate(clk_hw_get_parent(hw),
+                                            ideal);
+                if (rounded == ideal) {
+                        best_parent = rounded;
+                        best_div = i;
+                        goto out;
+                }
+                if ((rounded < ideal) && (rounded > best_parent)) {
+                        best_parent = rounded;
+                        best_div = i;
+                }
+        }
+out:
+        *parent_rate = best_parent;
+        return best_parent / best_div;
 }
 static int sun4i_dclk_set_rate(struct clk_hw *hw, unsigned long rate,
                               unsigned long parent_rate)
 {
        struct sun4i_dclk *dclk = hw_to_dclk(hw);
-        int div = DIV_ROUND_CLOSEST(parent_rate, rate);
+        u8 div = parent_rate / rate;
        return regmap_update_bits(dclk->regmap, SUN4I_TCON0_DCLK_REG,
                                  GENMASK(6, 0), div);
@@ -127,10 +153,14 @@ int sun4i_dclk_create(struct device *dev, struct sun4i_tcon *tcon)
        const char *clk_name, *parent_name;
        struct clk_init_data init;
        struct sun4i_dclk *dclk;
+        int ret;
        parent_name = __clk_get_name(tcon->sclk0);
-        of_property_read_string_index(dev->of_node, "clock-output-names", 0,
+        ret = of_property_read_string_index(dev->of_node,
-                                      &clk_name);
+                                            "clock-output-names", 0,
+                                            &clk_name);
+        if (ret)
+                return ret;
        dclk = devm_kzalloc(dev, sizeof(*dclk), GFP_KERNEL);
        if (!dclk)
@@ -140,6 +170,7 @@ int sun4i_dclk_create(struct device *dev, struct sun4i_tcon *tcon)
        init.ops = &sun4i_dclk_ops;
        init.parent_names = &parent_name;
        init.num_parents = 1;
+        init.flags = CLK_SET_RATE_PARENT;
        dclk->regmap = tcon->regs;
        dclk->hw.init = &init;
diff --git a/drivers/gpu/drm/sun4i/sun4i_drv.c b/drivers/gpu/drm/sun4i/sun4i_drv.c
index 76e922bb60e5..257d2b4f3645 100644
--- a/drivers/gpu/drm/sun4i/sun4i_drv.c
+++ b/drivers/gpu/drm/sun4i/sun4i_drv.c
@@ -24,34 +24,6 @@
 #include "sun4i_layer.h"
 #include "sun4i_tcon.h"
-static int sun4i_drv_connector_plug_all(struct drm_device *drm)
-{
-        struct drm_connector *connector, *failed;
-        int ret;
-        mutex_lock(&drm->mode_config.mutex);
-        list_for_each_entry(connector, &drm->mode_config.connector_list, head) {
-                ret = drm_connector_register(connector);
-                if (ret) {
-                        failed = connector;
-                        goto err;
-                }
-        }
-        mutex_unlock(&drm->mode_config.mutex);
-        return 0;
-err:
-        list_for_each_entry(connector, &drm->mode_config.connector_list, head) {
-                if (failed == connector)
-                        break;
-                drm_connector_unregister(connector);
-        }
-        mutex_unlock(&drm->mode_config.mutex);
-        return ret;
-}
 static int sun4i_drv_enable_vblank(struct drm_device *drm, unsigned int pipe)
 {
        struct sun4i_drv *drv = drm->dev_private;
@@ -125,6 +97,22 @@ static struct drm_driver sun4i_drv_driver = {
        .disable_vblank         = sun4i_drv_disable_vblank,
 };
+static void sun4i_remove_framebuffers(void)
+{
+        struct apertures_struct *ap;
+        ap = alloc_apertures(1);
+        if (!ap)
+                return;
+        /* The framebuffer can be located anywhere in RAM */
+        ap->ranges[0].base = 0;
+        ap->ranges[0].size = ~0;
+        remove_conflicting_framebuffers(ap, "sun4i-drm-fb", false);
+        kfree(ap);
+}
 static int sun4i_drv_bind(struct device *dev)
 {
        struct drm_device *drm;
@@ -172,6 +160,9 @@ static int sun4i_drv_bind(struct device *dev)
        }
        drm->irq_enabled = true;
+        /* Remove early framebuffers (ie. simplefb) */
+        sun4i_remove_framebuffers();
        /* Create our framebuffer */
        drv->fbdev = sun4i_framebuffer_init(drm);
        if (IS_ERR(drv->fbdev)) {
@@ -187,7 +178,7 @@ static int sun4i_drv_bind(struct device *dev)
        if (ret)
                goto free_drm;
-        ret = sun4i_drv_connector_plug_all(drm);
+        ret = drm_connector_register_all(drm);
        if (ret)
                goto unregister_drm;
@@ -204,6 +195,7 @@ static void sun4i_drv_unbind(struct device *dev)
 {
        struct drm_device *drm = dev_get_drvdata(dev);
+        drm_connector_unregister_all(drm);
        drm_dev_unregister(drm);
        drm_kms_helper_poll_fini(drm);
        sun4i_framebuffer_free(drm);
diff --git a/drivers/gpu/drm/sun4i/sun4i_rgb.c b/drivers/gpu/drm/sun4i/sun4i_rgb.c
index ab6494818050..aaffe9e64ffb 100644
--- a/drivers/gpu/drm/sun4i/sun4i_rgb.c
+++ b/drivers/gpu/drm/sun4i/sun4i_rgb.c
@@ -54,8 +54,13 @@ static int sun4i_rgb_get_modes(struct drm_connector *connector)
 static int sun4i_rgb_mode_valid(struct drm_connector *connector,
                                struct drm_display_mode *mode)
 {
+        struct sun4i_rgb *rgb = drm_connector_to_sun4i_rgb(connector);
+        struct sun4i_drv *drv = rgb->drv;
+        struct sun4i_tcon *tcon = drv->tcon;
        u32 hsync = mode->hsync_end - mode->hsync_start;
        u32 vsync = mode->vsync_end - mode->vsync_start;
+        unsigned long rate = mode->clock * 1000;
+        long rounded_rate;
        DRM_DEBUG_DRIVER("Validating modes...\n");
@@ -87,6 +92,15 @@ static int sun4i_rgb_mode_valid(struct drm_connector *connector,
        DRM_DEBUG_DRIVER("Vertical parameters OK\n");
+        rounded_rate = clk_round_rate(tcon->dclk, rate);
+        if (rounded_rate < rate)
+                return MODE_CLOCK_LOW;
+        if (rounded_rate > rate)
+                return MODE_CLOCK_HIGH;
+        DRM_DEBUG_DRIVER("Clock rate OK\n");
        return MODE_OK;
 }
@@ -203,7 +217,7 @@ int sun4i_rgb_init(struct drm_device *drm)
        int ret;
        /* If we don't have a panel, there's no point in going on */
-        if (!tcon->panel)
+        if (IS_ERR(tcon->panel))
                return -ENODEV;
        rgb = devm_kzalloc(drm->dev, sizeof(*rgb), GFP_KERNEL);
diff --git a/drivers/gpu/drm/sun4i/sun4i_tcon.c b/drivers/gpu/drm/sun4i/sun4i_tcon.c
index 9f19b0e08560..652385f09735 100644
--- a/drivers/gpu/drm/sun4i/sun4i_tcon.c
+++ b/drivers/gpu/drm/sun4i/sun4i_tcon.c
@@ -425,11 +425,11 @@ static struct drm_panel *sun4i_tcon_find_panel(struct device_node *node)
        remote = of_graph_get_remote_port_parent(end_node);
        if (!remote) {
-                DRM_DEBUG_DRIVER("Enable to parse remote node\n");
+                DRM_DEBUG_DRIVER("Unable to parse remote node\n");
                return ERR_PTR(-EINVAL);
        }
-        return of_drm_find_panel(remote);
+        return of_drm_find_panel(remote) ?: ERR_PTR(-EPROBE_DEFER);
 }
 static int sun4i_tcon_bind(struct device *dev, struct device *master,
@@ -490,7 +490,11 @@ static int sun4i_tcon_bind(struct device *dev, struct device *master,
                return 0;
        }
-        return sun4i_rgb_init(drm);
+        ret = sun4i_rgb_init(drm);
+        if (ret < 0)
+                goto err_free_clocks;
+        return 0;
 err_free_clocks:
        sun4i_tcon_free_clocks(tcon);
@@ -522,12 +526,13 @@ static int sun4i_tcon_probe(struct platform_device *pdev)
         * Defer the probe.
         */
        panel = sun4i_tcon_find_panel(node);
-        if (IS_ERR(panel)) {
-                /*
+        /*
-                 * If we don't have a panel endpoint, just go on
+         * If we don't have a panel endpoint, just go on
-                 */
+         */
-                if (PTR_ERR(panel) != -ENODEV)
+        if (PTR_ERR(panel) == -EPROBE_DEFER) {
-                        return -EPROBE_DEFER;
+                DRM_DEBUG_DRIVER("Still waiting for our panel. Deferring...\n");
+                return -EPROBE_DEFER;
        }
        return component_add(&pdev->dev, &sun4i_tcon_ops);
diff --git a/drivers/hid/hid-multitouch.c b/drivers/hid/hid-multitouch.c
index 95b7d61d9910..fb6f1f447279 100644
--- a/drivers/hid/hid-multitouch.c
+++ b/drivers/hid/hid-multitouch.c
@@ -61,6 +61,7 @@ MODULE_LICENSE("GPL");
 #define MT_QUIRK_ALWAYS_VALID           (1 << 4)
 #define MT_QUIRK_VALID_IS_INRANGE       (1 << 5)
 #define MT_QUIRK_VALID_IS_CONFIDENCE    (1 << 6)
+#define MT_QUIRK_CONFIDENCE             (1 << 7)
 #define MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE    (1 << 8)
 #define MT_QUIRK_NO_AREA                (1 << 9)
 #define MT_QUIRK_IGNORE_DUPLICATES      (1 << 10)
@@ -78,6 +79,7 @@ struct mt_slot {
        __s32 contactid;        /* the device ContactID assigned to this slot */
        bool touch_state;       /* is the touch valid? */
        bool inrange_state;     /* is the finger in proximity of the sensor? */
+        bool confidence_state;  /* is the touch made by a finger? */
 };
 struct mt_class {
@@ -503,10 +505,8 @@ static int mt_touch_input_mapping(struct hid_device *hdev, struct hid_input *hi,
                        return 1;
                case HID_DG_CONFIDENCE:
                        if (cls->name == MT_CLS_WIN_8 &&
-                                field->application == HID_DG_TOUCHPAD) {
+                                field->application == HID_DG_TOUCHPAD)
-                                cls->quirks &= ~MT_QUIRK_ALWAYS_VALID;
+                                cls->quirks |= MT_QUIRK_CONFIDENCE;
-                                cls->quirks |= MT_QUIRK_VALID_IS_CONFIDENCE;
-                        }
                        mt_store_field(usage, td, hi);
                        return 1;
                case HID_DG_TIPSWITCH:
@@ -619,6 +619,7 @@ static void mt_complete_slot(struct mt_device *td, struct input_dev *input)
                return;
        if (td->curvalid || (td->mtclass.quirks & MT_QUIRK_ALWAYS_VALID)) {
+                int active;
                int slotnum = mt_compute_slot(td, input);
                struct mt_slot *s = &td->curdata;
                struct input_mt *mt = input->mt;
@@ -633,10 +634,14 @@ static void mt_complete_slot(struct mt_device *td, struct input_dev *input)
                                return;
                }
+                if (!(td->mtclass.quirks & MT_QUIRK_CONFIDENCE))
+                        s->confidence_state = 1;
+                active = (s->touch_state || s->inrange_state) &&
+                                                        s->confidence_state;
                input_mt_slot(input, slotnum);
-                input_mt_report_slot_state(input, MT_TOOL_FINGER,
+                input_mt_report_slot_state(input, MT_TOOL_FINGER, active);
-                        s->touch_state || s->inrange_state);
+                if (active) {
-                if (s->touch_state || s->inrange_state) {
                        /* this finger is in proximity of the sensor */
                        int wide = (s->w > s->h);
                        /* divided by two to match visual scale of touch */
@@ -701,6 +706,8 @@ static void mt_process_mt_event(struct hid_device *hid, struct hid_field *field,
                        td->curdata.touch_state = value;
                        break;
                case HID_DG_CONFIDENCE:
+                        if (quirks & MT_QUIRK_CONFIDENCE)
+                                td->curdata.confidence_state = value;
                        if (quirks & MT_QUIRK_VALID_IS_CONFIDENCE)
                                td->curvalid = value;
                        break;
diff --git a/drivers/hid/usbhid/hiddev.c b/drivers/hid/usbhid/hiddev.c
index 2f1ddca6f2e0..700145b15088 100644
--- a/drivers/hid/usbhid/hiddev.c
+++ b/drivers/hid/usbhid/hiddev.c
@@ -516,13 +516,13 @@ static noinline int hiddev_ioctl_usage(struct hiddev *hiddev, unsigned int cmd,
                                        goto inval;
                        } else if (uref->usage_index >= field->report_count)
                                goto inval;
-                        else if ((cmd == HIDIOCGUSAGES || cmd == HIDIOCSUSAGES) &&
-                                 (uref_multi->num_values > HID_MAX_MULTI_USAGES ||
-                                  uref->usage_index + uref_multi->num_values > field->report_count))
-                                goto inval;
                }
+                if ((cmd == HIDIOCGUSAGES || cmd == HIDIOCSUSAGES) &&
+                    (uref_multi->num_values > HID_MAX_MULTI_USAGES ||
+                     uref->usage_index + uref_multi->num_values > field->report_count))
+                        goto inval;
                switch (cmd) {
                case HIDIOCGUSAGE:
                        uref->value = field->value[uref->usage_index];
diff --git a/drivers/hwmon/dell-smm-hwmon.c b/drivers/hwmon/dell-smm-hwmon.c
index c43318d3416e..2ac87d553e22 100644
--- a/drivers/hwmon/dell-smm-hwmon.c
+++ b/drivers/hwmon/dell-smm-hwmon.c
@@ -35,6 +35,7 @@
 #include <linux/uaccess.h>
 #include <linux/io.h>
 #include <linux/sched.h>
+#include <linux/ctype.h>
 #include <linux/i8k.h>
@@ -66,11 +67,13 @@
 static DEFINE_MUTEX(i8k_mutex);
 static char bios_version[4];
+static char bios_machineid[16];
 static struct device *i8k_hwmon_dev;
 static u32 i8k_hwmon_flags;
 static uint i8k_fan_mult = I8K_FAN_MULT;
 static uint i8k_pwm_mult;
 static uint i8k_fan_max = I8K_FAN_HIGH;
+static bool disallow_fan_type_call;
 #define I8K_HWMON_HAVE_TEMP1    (1 << 0)
 #define I8K_HWMON_HAVE_TEMP2    (1 << 1)
@@ -94,13 +97,13 @@ module_param(ignore_dmi, bool, 0);
 MODULE_PARM_DESC(ignore_dmi, "Continue probing hardware even if DMI data does not match");
 #if IS_ENABLED(CONFIG_I8K)
-static bool restricted;
+static bool restricted = true;
 module_param(restricted, bool, 0);
-MODULE_PARM_DESC(restricted, "Allow fan control if SYS_ADMIN capability set");
+MODULE_PARM_DESC(restricted, "Restrict fan control and serial number to CAP_SYS_ADMIN (default: 1)");
 static bool power_status;
 module_param(power_status, bool, 0600);
-MODULE_PARM_DESC(power_status, "Report power status in /proc/i8k");
+MODULE_PARM_DESC(power_status, "Report power status in /proc/i8k (default: 0)");
 #endif
 static uint fan_mult;
@@ -235,14 +238,28 @@ static int i8k_get_fan_speed(int fan)
 /*
 * Read the fan type.
 */
-static int i8k_get_fan_type(int fan)
+static int _i8k_get_fan_type(int fan)
 {
        struct smm_regs regs = { .eax = I8K_SMM_GET_FAN_TYPE, };
+        if (disallow_fan_type_call)
+                return -EINVAL;
        regs.ebx = fan & 0xff;
        return i8k_smm(&regs) ? : regs.eax & 0xff;
 }
+static int i8k_get_fan_type(int fan)
+{
+        /* I8K_SMM_GET_FAN_TYPE SMM call is expensive, so cache values */
+        static int types[2] = { INT_MIN, INT_MIN };
+        if (types[fan] == INT_MIN)
+                types[fan] = _i8k_get_fan_type(fan);
+        return types[fan];
+}
 /*
 * Read the fan nominal rpm for specific fan speed.
 */
@@ -387,14 +404,20 @@ i8k_ioctl_unlocked(struct file *fp, unsigned int cmd, unsigned long arg)
        switch (cmd) {
        case I8K_BIOS_VERSION:
+                if (!isdigit(bios_version[0]) || !isdigit(bios_version[1]) ||
+                    !isdigit(bios_version[2]))
+                        return -EINVAL;
                val = (bios_version[0] << 16) |
                                (bios_version[1] << 8) | bios_version[2];
                break;
        case I8K_MACHINE_ID:
-                memset(buff, 0, 16);
+                if (restricted && !capable(CAP_SYS_ADMIN))
-                strlcpy(buff, i8k_get_dmi_data(DMI_PRODUCT_SERIAL),
+                        return -EPERM;
-                        sizeof(buff));
+                memset(buff, 0, sizeof(buff));
+                strlcpy(buff, bios_machineid, sizeof(buff));
                break;
        case I8K_FN_STATUS:
@@ -511,7 +534,7 @@ static int i8k_proc_show(struct seq_file *seq, void *offset)
        seq_printf(seq, "%s %s %s %d %d %d %d %d %d %d\n",
                   I8K_PROC_FMT,
                   bios_version,
-                   i8k_get_dmi_data(DMI_PRODUCT_SERIAL),
+                   (restricted && !capable(CAP_SYS_ADMIN)) ? "-1" : bios_machineid,
                   cpu_temp,
                   left_fan, right_fan, left_speed, right_speed,
                   ac_power, fn_key);
@@ -718,6 +741,9 @@ static struct attribute *i8k_attrs[] = {
 static umode_t i8k_is_visible(struct kobject *kobj, struct attribute *attr,
                              int index)
 {
+        if (disallow_fan_type_call &&
+            (index == 9 || index == 12))
+                return 0;
        if (index >= 0 && index <= 1 &&
            !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP1))
                return 0;
@@ -767,13 +793,17 @@ static int __init i8k_init_hwmon(void)
        if (err >= 0)
                i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP4;
-        /* First fan attributes, if fan type is OK */
+        /* First fan attributes, if fan status or type is OK */
-        err = i8k_get_fan_type(0);
+        err = i8k_get_fan_status(0);
+        if (err < 0)
+                err = i8k_get_fan_type(0);
        if (err >= 0)
                i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN1;
-        /* Second fan attributes, if fan type is OK */
+        /* Second fan attributes, if fan status or type is OK */
-        err = i8k_get_fan_type(1);
+        err = i8k_get_fan_status(1);
+        if (err < 0)
+                err = i8k_get_fan_type(1);
        if (err >= 0)
                i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN2;
@@ -929,12 +959,14 @@ static struct dmi_system_id i8k_dmi_table[] __initdata = {
 MODULE_DEVICE_TABLE(dmi, i8k_dmi_table);
-static struct dmi_system_id i8k_blacklist_dmi_table[] __initdata = {
+/*
+ * On some machines once I8K_SMM_GET_FAN_TYPE is issued then CPU fan speed
+ * randomly going up and down due to bug in Dell SMM or BIOS. Here is blacklist
+ * of affected Dell machines for which we disallow I8K_SMM_GET_FAN_TYPE call.
+ * See bug: https://bugzilla.kernel.org/show_bug.cgi?id=100121
+ */
+static struct dmi_system_id i8k_blacklist_fan_type_dmi_table[] __initdata = {
        {
-                /*
-                 * CPU fan speed going up and down on Dell Studio XPS 8000
-                 * for unknown reasons.
-                 */
                .ident = "Dell Studio XPS 8000",
                .matches = {
                        DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
@@ -942,16 +974,19 @@ static struct dmi_system_id i8k_blacklist_dmi_table[] __initdata = {
                },
        },
        {
-                /*
-                 * CPU fan speed going up and down on Dell Studio XPS 8100
-                 * for unknown reasons.
-                 */
                .ident = "Dell Studio XPS 8100",
                .matches = {
                        DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
                        DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Studio XPS 8100"),
                },
        },
+        {
+                .ident = "Dell Inspiron 580",
+                .matches = {
+                        DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
+                        DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Inspiron 580 "),
+                },
+        },
        { }
 };
@@ -966,8 +1001,7 @@ static int __init i8k_probe(void)
        /*
         * Get DMI information
         */
-        if (!dmi_check_system(i8k_dmi_table) ||
+        if (!dmi_check_system(i8k_dmi_table)) {
-            dmi_check_system(i8k_blacklist_dmi_table)) {
                if (!ignore_dmi && !force)
                        return -ENODEV;
@@ -978,8 +1012,13 @@ static int __init i8k_probe(void)
                        i8k_get_dmi_data(DMI_BIOS_VERSION));
        }
+        if (dmi_check_system(i8k_blacklist_fan_type_dmi_table))
+                disallow_fan_type_call = true;
        strlcpy(bios_version, i8k_get_dmi_data(DMI_BIOS_VERSION),
                sizeof(bios_version));
+        strlcpy(bios_machineid, i8k_get_dmi_data(DMI_PRODUCT_SERIAL),
+                sizeof(bios_machineid));
        /*
         * Get SMM Dell signature
diff --git a/drivers/infiniband/core/cache.c b/drivers/infiniband/core/cache.c
index 040966775f40..1a2984c28b95 100644
--- a/drivers/infiniband/core/cache.c
+++ b/drivers/infiniband/core/cache.c
@@ -411,7 +411,9 @@ int ib_cache_gid_del_all_netdev_gids(struct ib_device *ib_dev, u8 port,
        for (ix = 0; ix < table->sz; ix++)
                if (table->data_vec[ix].attr.ndev == ndev)
-                        if (!del_gid(ib_dev, port, table, ix, false))
+                        if (!del_gid(ib_dev, port, table, ix,
+                                     !!(table->data_vec[ix].props &
+                                        GID_TABLE_ENTRY_DEFAULT)))
                                deleted = true;
        write_unlock_irq(&table->rwlock);
diff --git a/drivers/infiniband/core/cma.c b/drivers/infiniband/core/cma.c
index f0c91ba3178a..ad1b1adcf6f0 100644
--- a/drivers/infiniband/core/cma.c
+++ b/drivers/infiniband/core/cma.c
@@ -708,17 +708,6 @@ static void cma_deref_id(struct rdma_id_private *id_priv)
                complete(&id_priv->comp);
 }
-static int cma_disable_callback(struct rdma_id_private *id_priv,
-                                enum rdma_cm_state state)
-{
-        mutex_lock(&id_priv->handler_mutex);
-        if (id_priv->state != state) {
-                mutex_unlock(&id_priv->handler_mutex);
-                return -EINVAL;
-        }
-        return 0;
-}
 struct rdma_cm_id *rdma_create_id(struct net *net,
                                  rdma_cm_event_handler event_handler,
                                  void *context, enum rdma_port_space ps,
@@ -1671,11 +1660,12 @@ static int cma_ib_handler(struct ib_cm_id *cm_id, struct ib_cm_event *ib_event)
        struct rdma_cm_event event;
        int ret = 0;
+        mutex_lock(&id_priv->handler_mutex);
        if ((ib_event->event != IB_CM_TIMEWAIT_EXIT &&
-                cma_disable_callback(id_priv, RDMA_CM_CONNECT)) ||
+             id_priv->state != RDMA_CM_CONNECT) ||
            (ib_event->event == IB_CM_TIMEWAIT_EXIT &&
-                cma_disable_callback(id_priv, RDMA_CM_DISCONNECT)))
+             id_priv->state != RDMA_CM_DISCONNECT))
-                return 0;
+                goto out;
        memset(&event, 0, sizeof event);
        switch (ib_event->event) {
@@ -1870,7 +1860,7 @@ static int cma_check_req_qp_type(struct rdma_cm_id *id, struct ib_cm_event *ib_e
 static int cma_req_handler(struct ib_cm_id *cm_id, struct ib_cm_event *ib_event)
 {
-        struct rdma_id_private *listen_id, *conn_id;
+        struct rdma_id_private *listen_id, *conn_id = NULL;
        struct rdma_cm_event event;
        struct net_device *net_dev;
        int offset, ret;
@@ -1884,9 +1874,10 @@ static int cma_req_handler(struct ib_cm_id *cm_id, struct ib_cm_event *ib_event)
                goto net_dev_put;
        }
-        if (cma_disable_callback(listen_id, RDMA_CM_LISTEN)) {
+        mutex_lock(&listen_id->handler_mutex);
+        if (listen_id->state != RDMA_CM_LISTEN) {
                ret = -ECONNABORTED;
-                goto net_dev_put;
+                goto err1;
        }
        memset(&event, 0, sizeof event);
@@ -1976,8 +1967,9 @@ static int cma_iw_handler(struct iw_cm_id *iw_id, struct iw_cm_event *iw_event)
        struct sockaddr *laddr = (struct sockaddr *)&iw_event->local_addr;
        struct sockaddr *raddr = (struct sockaddr *)&iw_event->remote_addr;
-        if (cma_disable_callback(id_priv, RDMA_CM_CONNECT))
+        mutex_lock(&id_priv->handler_mutex);
-                return 0;
+        if (id_priv->state != RDMA_CM_CONNECT)
+                goto out;
        memset(&event, 0, sizeof event);
        switch (iw_event->event) {
@@ -2029,6 +2021,7 @@ static int cma_iw_handler(struct iw_cm_id *iw_id, struct iw_cm_event *iw_event)
                return ret;
        }
+out:
        mutex_unlock(&id_priv->handler_mutex);
        return ret;
 }
@@ -2039,13 +2032,15 @@ static int iw_conn_req_handler(struct iw_cm_id *cm_id,
        struct rdma_cm_id *new_cm_id;
        struct rdma_id_private *listen_id, *conn_id;
        struct rdma_cm_event event;
-        int ret;
+        int ret = -ECONNABORTED;
        struct sockaddr *laddr = (struct sockaddr *)&iw_event->local_addr;
        struct sockaddr *raddr = (struct sockaddr *)&iw_event->remote_addr;
        listen_id = cm_id->context;
-        if (cma_disable_callback(listen_id, RDMA_CM_LISTEN))
-                return -ECONNABORTED;
+        mutex_lock(&listen_id->handler_mutex);
+        if (listen_id->state != RDMA_CM_LISTEN)
+                goto out;
        /* Create a new RDMA id for the new IW CM ID */
        new_cm_id = rdma_create_id(listen_id->id.route.addr.dev_addr.net,
@@ -3216,8 +3211,9 @@ static int cma_sidr_rep_handler(struct ib_cm_id *cm_id,
        struct ib_cm_sidr_rep_event_param *rep = &ib_event->param.sidr_rep_rcvd;
        int ret = 0;
-        if (cma_disable_callback(id_priv, RDMA_CM_CONNECT))
+        mutex_lock(&id_priv->handler_mutex);
-                return 0;
+        if (id_priv->state != RDMA_CM_CONNECT)
+                goto out;
        memset(&event, 0, sizeof event);
        switch (ib_event->event) {
@@ -3673,12 +3669,13 @@ static int cma_ib_mc_handler(int status, struct ib_sa_multicast *multicast)
        struct rdma_id_private *id_priv;
        struct cma_multicast *mc = multicast->context;
        struct rdma_cm_event event;
-        int ret;
+        int ret = 0;
        id_priv = mc->id_priv;
-        if (cma_disable_callback(id_priv, RDMA_CM_ADDR_BOUND) &&
+        mutex_lock(&id_priv->handler_mutex);
-            cma_disable_callback(id_priv, RDMA_CM_ADDR_RESOLVED))
+        if (id_priv->state != RDMA_CM_ADDR_BOUND &&
-                return 0;
+            id_priv->state != RDMA_CM_ADDR_RESOLVED)
+                goto out;
        if (!status)
                status = cma_set_qkey(id_priv, be32_to_cpu(multicast->rec.qkey));
@@ -3720,6 +3717,7 @@ static int cma_ib_mc_handler(int status, struct ib_sa_multicast *multicast)
                return 0;
        }
+out:
        mutex_unlock(&id_priv->handler_mutex);
        return 0;
 }
@@ -3878,12 +3876,12 @@ static int cma_iboe_join_multicast(struct rdma_id_private *id_priv,
        gid_type = id_priv->cma_dev->default_gid_type[id_priv->id.port_num -
                   rdma_start_port(id_priv->cma_dev->device)];
        if (addr->sa_family == AF_INET) {
-                if (gid_type == IB_GID_TYPE_ROCE_UDP_ENCAP)
+                if (gid_type == IB_GID_TYPE_ROCE_UDP_ENCAP) {
+                        mc->multicast.ib->rec.hop_limit = IPV6_DEFAULT_HOPLIMIT;
                        err = cma_igmp_send(ndev, &mc->multicast.ib->rec.mgid,
                                            true);
-                if (!err) {
+                        if (!err)
-                        mc->igmp_joined = true;
+                                mc->igmp_joined = true;
-                        mc->multicast.ib->rec.hop_limit = IPV6_DEFAULT_HOPLIMIT;
                }
        } else {
                if (gid_type == IB_GID_TYPE_ROCE_UDP_ENCAP)
diff --git a/drivers/infiniband/core/uverbs_cmd.c b/drivers/infiniband/core/uverbs_cmd.c
index 1a8babb8ee3c..825021d1008b 100644
--- a/drivers/infiniband/core/uverbs_cmd.c
+++ b/drivers/infiniband/core/uverbs_cmd.c
@@ -1747,7 +1747,7 @@ static int create_qp(struct ib_uverbs_file *file,
        struct ib_srq                   *srq = NULL;
        struct ib_qp                    *qp;
        char                            *buf;
-        struct ib_qp_init_attr          attr;
+        struct ib_qp_init_attr          attr = {};
        struct ib_uverbs_ex_create_qp_resp resp;
        int                             ret;
diff --git a/drivers/infiniband/core/verbs.c b/drivers/infiniband/core/verbs.c
index 1d7d4cf442e3..6298f54b4137 100644
--- a/drivers/infiniband/core/verbs.c
+++ b/drivers/infiniband/core/verbs.c
@@ -511,12 +511,16 @@ int ib_init_ah_from_wc(struct ib_device *device, u8 port_num,
                ah_attr->grh.dgid = sgid;
                if (!rdma_cap_eth_ah(device, port_num)) {
-                        ret = ib_find_cached_gid_by_port(device, &dgid,
+                        if (dgid.global.interface_id != cpu_to_be64(IB_SA_WELL_KNOWN_GUID)) {
-                                                         IB_GID_TYPE_IB,
+                                ret = ib_find_cached_gid_by_port(device, &dgid,
-                                                         port_num, NULL,
+                                                                 IB_GID_TYPE_IB,
-                                                         &gid_index);
+                                                                 port_num, NULL,
-                        if (ret)
+                                                                 &gid_index);
-                                return ret;
+                                if (ret)
+                                        return ret;
+                        } else {
+                                gid_index = 0;
+                        }
                }
                ah_attr->grh.sgid_index = (u8) gid_index;
diff --git a/drivers/infiniband/hw/hfi1/chip.c b/drivers/infiniband/hw/hfi1/chip.c
index 81619fbb5842..f5de85178055 100644
--- a/drivers/infiniband/hw/hfi1/chip.c
+++ b/drivers/infiniband/hw/hfi1/chip.c
@@ -1037,7 +1037,7 @@ static void dc_shutdown(struct hfi1_devdata *);
 static void dc_start(struct hfi1_devdata *);
 static int qos_rmt_entries(struct hfi1_devdata *dd, unsigned int *mp,
                           unsigned int *np);
-static void remove_full_mgmt_pkey(struct hfi1_pportdata *ppd);
+static void clear_full_mgmt_pkey(struct hfi1_pportdata *ppd);
 /*
 * Error interrupt table entry.  This is used as input to the interrupt
@@ -6962,8 +6962,6 @@ void handle_link_down(struct work_struct *work)
        }
        reset_neighbor_info(ppd);
-        if (ppd->mgmt_allowed)
-                remove_full_mgmt_pkey(ppd);
        /* disable the port */
        clear_rcvctrl(ppd->dd, RCV_CTRL_RCV_PORT_ENABLE_SMASK);
@@ -7070,12 +7068,16 @@ static void add_full_mgmt_pkey(struct hfi1_pportdata *ppd)
                            __func__, ppd->pkeys[2], FULL_MGMT_P_KEY);
        ppd->pkeys[2] = FULL_MGMT_P_KEY;
        (void)hfi1_set_ib_cfg(ppd, HFI1_IB_CFG_PKEYS, 0);
+        hfi1_event_pkey_change(ppd->dd, ppd->port);
 }
-static void remove_full_mgmt_pkey(struct hfi1_pportdata *ppd)
+static void clear_full_mgmt_pkey(struct hfi1_pportdata *ppd)
 {
-        ppd->pkeys[2] = 0;
+        if (ppd->pkeys[2] != 0) {
-        (void)hfi1_set_ib_cfg(ppd, HFI1_IB_CFG_PKEYS, 0);
+                ppd->pkeys[2] = 0;
+                (void)hfi1_set_ib_cfg(ppd, HFI1_IB_CFG_PKEYS, 0);
+                hfi1_event_pkey_change(ppd->dd, ppd->port);
+        }
 }
 /*
@@ -9168,6 +9170,13 @@ int start_link(struct hfi1_pportdata *ppd)
                return 0;
        }
+        /*
+         * FULL_MGMT_P_KEY is cleared from the pkey table, so that the
+         * pkey table can be configured properly if the HFI unit is connected
+         * to switch port with MgmtAllowed=NO
+         */
+        clear_full_mgmt_pkey(ppd);
        return set_link_state(ppd, HLS_DN_POLL);
 }
@@ -9777,7 +9786,7 @@ static void set_send_length(struct hfi1_pportdata *ppd)
        u64 len1 = 0, len2 = (((dd->vld[15].mtu + max_hb) >> 2)
                              & SEND_LEN_CHECK1_LEN_VL15_MASK) <<
                SEND_LEN_CHECK1_LEN_VL15_SHIFT;
-        int i;
+        int i, j;
        u32 thres;
        for (i = 0; i < ppd->vls_supported; i++) {
@@ -9801,7 +9810,10 @@ static void set_send_length(struct hfi1_pportdata *ppd)
                            sc_mtu_to_threshold(dd->vld[i].sc,
                                                dd->vld[i].mtu,
                                                dd->rcd[0]->rcvhdrqentsize));
-                sc_set_cr_threshold(dd->vld[i].sc, thres);
+                for (j = 0; j < INIT_SC_PER_VL; j++)
+                        sc_set_cr_threshold(
+                                        pio_select_send_context_vl(dd, j, i),
+                                            thres);
        }
        thres = min(sc_percent_to_threshold(dd->vld[15].sc, 50),
                    sc_mtu_to_threshold(dd->vld[15].sc,
diff --git a/drivers/infiniband/hw/hfi1/file_ops.c b/drivers/infiniband/hw/hfi1/file_ops.c
index 7a5b0e676cc7..c702a009608f 100644
--- a/drivers/infiniband/hw/hfi1/file_ops.c
+++ b/drivers/infiniband/hw/hfi1/file_ops.c
@@ -203,6 +203,9 @@ static long hfi1_file_ioctl(struct file *fp, unsigned int cmd,
        switch (cmd) {
        case HFI1_IOCTL_ASSIGN_CTXT:
+                if (uctxt)
+                        return -EINVAL;
                if (copy_from_user(&uinfo,
                                   (struct hfi1_user_info __user *)arg,
                                   sizeof(uinfo)))
diff --git a/drivers/infiniband/hw/hfi1/init.c b/drivers/infiniband/hw/hfi1/init.c
index 0d28a5a40fae..eed971ccd2a1 100644
--- a/drivers/infiniband/hw/hfi1/init.c
+++ b/drivers/infiniband/hw/hfi1/init.c
@@ -1383,7 +1383,7 @@ static void postinit_cleanup(struct hfi1_devdata *dd)
 static int init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 {
        int ret = 0, j, pidx, initfail;
-        struct hfi1_devdata *dd = NULL;
+        struct hfi1_devdata *dd = ERR_PTR(-EINVAL);
        struct hfi1_pportdata *ppd;
        /* First, lock the non-writable module parameters */
diff --git a/drivers/infiniband/hw/hfi1/mad.c b/drivers/infiniband/hw/hfi1/mad.c
index 219029576ba0..fca07a1d6c28 100644
--- a/drivers/infiniband/hw/hfi1/mad.c
+++ b/drivers/infiniband/hw/hfi1/mad.c
@@ -78,6 +78,16 @@ static inline void clear_opa_smp_data(struct opa_smp *smp)
        memset(data, 0, size);
 }
+void hfi1_event_pkey_change(struct hfi1_devdata *dd, u8 port)
+{
+        struct ib_event event;
+        event.event = IB_EVENT_PKEY_CHANGE;
+        event.device = &dd->verbs_dev.rdi.ibdev;
+        event.element.port_num = port;
+        ib_dispatch_event(&event);
+}
 static void send_trap(struct hfi1_ibport *ibp, void *data, unsigned len)
 {
        struct ib_mad_send_buf *send_buf;
@@ -1418,15 +1428,10 @@ static int set_pkeys(struct hfi1_devdata *dd, u8 port, u16 *pkeys)
        }
        if (changed) {
-                struct ib_event event;
                (void)hfi1_set_ib_cfg(ppd, HFI1_IB_CFG_PKEYS, 0);
+                hfi1_event_pkey_change(dd, port);
-                event.event = IB_EVENT_PKEY_CHANGE;
-                event.device = &dd->verbs_dev.rdi.ibdev;
-                event.element.port_num = port;
-                ib_dispatch_event(&event);
        }
        return 0;
 }
diff --git a/drivers/infiniband/hw/hfi1/mad.h b/drivers/infiniband/hw/hfi1/mad.h
index 55ee08675333..8b734aaae88a 100644
--- a/drivers/infiniband/hw/hfi1/mad.h
+++ b/drivers/infiniband/hw/hfi1/mad.h
@@ -434,4 +434,6 @@ struct sc2vlnt {
                    COUNTER_MASK(1, 3) | \
                    COUNTER_MASK(1, 4))
+void hfi1_event_pkey_change(struct hfi1_devdata *dd, u8 port);
 #endif                          /* _HFI1_MAD_H */
diff --git a/drivers/infiniband/hw/hfi1/pio.c b/drivers/infiniband/hw/hfi1/pio.c
index d5edb1afbb8f..d4022450b73f 100644
--- a/drivers/infiniband/hw/hfi1/pio.c
+++ b/drivers/infiniband/hw/hfi1/pio.c
@@ -995,7 +995,7 @@ static void sc_wait_for_packet_egress(struct send_context *sc, int pause)
                /* counter is reset if occupancy count changes */
                if (reg != reg_prev)
                        loop = 0;
-                if (loop > 500) {
+                if (loop > 50000) {
                        /* timed out - bounce the link */
                        dd_dev_err(dd,
                                   "%s: context %u(%u) timeout waiting for packets to egress, remaining count %u, bouncing link\n",
@@ -1798,6 +1798,21 @@ static void pio_map_rcu_callback(struct rcu_head *list)
 }
 /*
+ * Set credit return threshold for the kernel send context
+ */
+static void set_threshold(struct hfi1_devdata *dd, int scontext, int i)
+{
+        u32 thres;
+        thres = min(sc_percent_to_threshold(dd->kernel_send_context[scontext],
+                                            50),
+                    sc_mtu_to_threshold(dd->kernel_send_context[scontext],
+                                        dd->vld[i].mtu,
+                                        dd->rcd[0]->rcvhdrqentsize));
+        sc_set_cr_threshold(dd->kernel_send_context[scontext], thres);
+}
+/*
 * pio_map_init - called when #vls change
 * @dd: hfi1_devdata
 * @port: port number
@@ -1872,11 +1887,16 @@ int pio_map_init(struct hfi1_devdata *dd, u8 port, u8 num_vls, u8 *vl_scontexts)
                        if (!newmap->map[i])
                                goto bail;
                        newmap->map[i]->mask = (1 << ilog2(sz)) - 1;
-                        /* assign send contexts */
+                        /*
+                         * assign send contexts and
+                         * adjust credit return threshold
+                         */
                        for (j = 0; j < sz; j++) {
-                                if (dd->kernel_send_context[scontext])
+                                if (dd->kernel_send_context[scontext]) {
                                        newmap->map[i]->ksc[j] =
                                        dd->kernel_send_context[scontext];
+                                        set_threshold(dd, scontext, i);
+                                }
                                if (++scontext >= first_scontext +
                                                  vl_scontexts[i])
                                        /* wrap back to first send context */
diff --git a/drivers/infiniband/hw/hfi1/qsfp.c b/drivers/infiniband/hw/hfi1/qsfp.c
index 2441669f0817..9fb561682c66 100644
--- a/drivers/infiniband/hw/hfi1/qsfp.c
+++ b/drivers/infiniband/hw/hfi1/qsfp.c
@@ -579,7 +579,8 @@ int qsfp_dump(struct hfi1_pportdata *ppd, char *buf, int len)
        if (ppd->qsfp_info.cache_valid) {
                if (QSFP_IS_CU(cache[QSFP_MOD_TECH_OFFS]))
-                        sprintf(lenstr, "%dM ", cache[QSFP_MOD_LEN_OFFS]);
+                        snprintf(lenstr, sizeof(lenstr), "%dM ",
+                                 cache[QSFP_MOD_LEN_OFFS]);
                power_byte = cache[QSFP_MOD_PWR_OFFS];
                sofar += scnprintf(buf + sofar, len - sofar, "PWR:%.3sW\n",
diff --git a/drivers/infiniband/hw/hfi1/verbs_txreq.c b/drivers/infiniband/hw/hfi1/verbs_txreq.c
index bc95c4112c61..d8fb056526f8 100644
--- a/drivers/infiniband/hw/hfi1/verbs_txreq.c
+++ b/drivers/infiniband/hw/hfi1/verbs_txreq.c
@@ -92,11 +92,10 @@ void hfi1_put_txreq(struct verbs_txreq *tx)
 struct verbs_txreq *__get_txreq(struct hfi1_ibdev *dev,
                                struct rvt_qp *qp)
+        __must_hold(&qp->s_lock)
 {
        struct verbs_txreq *tx = ERR_PTR(-EBUSY);
-        unsigned long flags;
-        spin_lock_irqsave(&qp->s_lock, flags);
        write_seqlock(&dev->iowait_lock);
        if (ib_rvt_state_ops[qp->state] & RVT_PROCESS_RECV_OK) {
                struct hfi1_qp_priv *priv;
@@ -116,7 +115,6 @@ struct verbs_txreq *__get_txreq(struct hfi1_ibdev *dev,
        }
 out:
        write_sequnlock(&dev->iowait_lock);
-        spin_unlock_irqrestore(&qp->s_lock, flags);
        return tx;
 }
diff --git a/drivers/infiniband/hw/hfi1/verbs_txreq.h b/drivers/infiniband/hw/hfi1/verbs_txreq.h
index 1cf69b2fe4a5..a1d6e0807f97 100644
--- a/drivers/infiniband/hw/hfi1/verbs_txreq.h
+++ b/drivers/infiniband/hw/hfi1/verbs_txreq.h
@@ -73,6 +73,7 @@ struct verbs_txreq *__get_txreq(struct hfi1_ibdev *dev,
 static inline struct verbs_txreq *get_txreq(struct hfi1_ibdev *dev,
                                            struct rvt_qp *qp)
+        __must_hold(&qp->slock)
 {
        struct verbs_txreq *tx;
        struct hfi1_qp_priv *priv = qp->priv;
diff --git a/drivers/infiniband/hw/i40iw/i40iw.h b/drivers/infiniband/hw/i40iw/i40iw.h
index 8b9532034558..b738acdb9b02 100644
--- a/drivers/infiniband/hw/i40iw/i40iw.h
+++ b/drivers/infiniband/hw/i40iw/i40iw.h
@@ -113,6 +113,8 @@
 #define IW_HMC_OBJ_TYPE_NUM ARRAY_SIZE(iw_hmc_obj_types)
 #define IW_CFG_FPM_QP_COUNT             32768
+#define I40IW_MAX_PAGES_PER_FMR         512
+#define I40IW_MIN_PAGES_PER_FMR         1
 #define I40IW_MTU_TO_MSS                40
 #define I40IW_DEFAULT_MSS               1460
diff --git a/drivers/infiniband/hw/i40iw/i40iw_verbs.c b/drivers/infiniband/hw/i40iw/i40iw_verbs.c
index 02a735b64208..33959ed14563 100644
--- a/drivers/infiniband/hw/i40iw/i40iw_verbs.c
+++ b/drivers/infiniband/hw/i40iw/i40iw_verbs.c
@@ -79,6 +79,7 @@ static int i40iw_query_device(struct ib_device *ibdev,
        props->max_qp_init_rd_atom = props->max_qp_rd_atom;
        props->atomic_cap = IB_ATOMIC_NONE;
        props->max_map_per_fmr = 1;
+        props->max_fast_reg_page_list_len = I40IW_MAX_PAGES_PER_FMR;
        return 0;
 }
@@ -1527,7 +1528,7 @@ static struct ib_mr *i40iw_alloc_mr(struct ib_pd *pd,
        mutex_lock(&iwdev->pbl_mutex);
        status = i40iw_get_pble(&iwdev->sc_dev, iwdev->pble_rsrc, palloc, iwmr->page_cnt);
        mutex_unlock(&iwdev->pbl_mutex);
-        if (!status)
+        if (status)
                goto err1;
        if (palloc->level != I40IW_LEVEL_1)
@@ -2149,6 +2150,7 @@ static int i40iw_post_send(struct ib_qp *ibqp,
                        struct i40iw_sc_dev *dev = &iwqp->iwdev->sc_dev;
                        struct i40iw_fast_reg_stag_info info;
+                        memset(&info, 0, sizeof(info));
                        info.access_rights = I40IW_ACCESS_FLAGS_LOCALREAD;
                        info.access_rights |= i40iw_get_user_access(flags);
                        info.stag_key = reg_wr(ib_wr)->key & 0xff;
@@ -2158,10 +2160,14 @@ static int i40iw_post_send(struct ib_qp *ibqp,
                        info.addr_type = I40IW_ADDR_TYPE_VA_BASED;
                        info.va = (void *)(uintptr_t)iwmr->ibmr.iova;
                        info.total_len = iwmr->ibmr.length;
+                        info.reg_addr_pa = *(u64 *)palloc->level1.addr;
                        info.first_pm_pbl_index = palloc->level1.idx;
                        info.local_fence = ib_wr->send_flags & IB_SEND_FENCE;
                        info.signaled = ib_wr->send_flags & IB_SEND_SIGNALED;
+                        if (iwmr->npages > I40IW_MIN_PAGES_PER_FMR)
+                                info.chunk_size = 1;
                        if (page_shift == 21)
                                info.page_size = 1; /* 2M page */
@@ -2327,13 +2333,16 @@ static int i40iw_req_notify_cq(struct ib_cq *ibcq,
 {
        struct i40iw_cq *iwcq;
        struct i40iw_cq_uk *ukcq;
-        enum i40iw_completion_notify cq_notify = IW_CQ_COMPL_SOLICITED;
+        unsigned long flags;
+        enum i40iw_completion_notify cq_notify = IW_CQ_COMPL_EVENT;
        iwcq = (struct i40iw_cq *)ibcq;
        ukcq = &iwcq->sc_cq.cq_uk;
-        if (notify_flags == IB_CQ_NEXT_COMP)
+        if (notify_flags == IB_CQ_SOLICITED)
-                cq_notify = IW_CQ_COMPL_EVENT;
+                cq_notify = IW_CQ_COMPL_SOLICITED;
+        spin_lock_irqsave(&iwcq->lock, flags);
        ukcq->ops.iw_cq_request_notification(ukcq, cq_notify);
+        spin_unlock_irqrestore(&iwcq->lock, flags);
        return 0;
 }
diff --git a/drivers/infiniband/hw/mlx4/ah.c b/drivers/infiniband/hw/mlx4/ah.c
index 105246fba2e7..5fc623362731 100644
--- a/drivers/infiniband/hw/mlx4/ah.c
+++ b/drivers/infiniband/hw/mlx4/ah.c
@@ -47,6 +47,7 @@ static struct ib_ah *create_ib_ah(struct ib_pd *pd, struct ib_ah_attr *ah_attr,
        ah->av.ib.port_pd = cpu_to_be32(to_mpd(pd)->pdn | (ah_attr->port_num << 24));
        ah->av.ib.g_slid  = ah_attr->src_path_bits;
+        ah->av.ib.sl_tclass_flowlabel = cpu_to_be32(ah_attr->sl << 28);
        if (ah_attr->ah_flags & IB_AH_GRH) {
                ah->av.ib.g_slid   |= 0x80;
                ah->av.ib.gid_index = ah_attr->grh.sgid_index;
@@ -64,7 +65,6 @@ static struct ib_ah *create_ib_ah(struct ib_pd *pd, struct ib_ah_attr *ah_attr,
                       !(1 << ah->av.ib.stat_rate & dev->caps.stat_rate_support))
                        --ah->av.ib.stat_rate;
        }
-        ah->av.ib.sl_tclass_flowlabel = cpu_to_be32(ah_attr->sl << 28);
        return &ah->ibah;
 }
diff --git a/drivers/infiniband/hw/mlx4/mad.c b/drivers/infiniband/hw/mlx4/mad.c
index d68f506c1922..9c2e53d28f98 100644
--- a/drivers/infiniband/hw/mlx4/mad.c
+++ b/drivers/infiniband/hw/mlx4/mad.c
@@ -527,7 +527,7 @@ int mlx4_ib_send_to_slave(struct mlx4_ib_dev *dev, int slave, u8 port,
                tun_tx_ix = (++tun_qp->tx_ix_head) & (MLX4_NUM_TUNNEL_BUFS - 1);
        spin_unlock(&tun_qp->tx_lock);
        if (ret)
-                goto out;
+                goto end;
        tun_mad = (struct mlx4_rcv_tunnel_mad *) (tun_qp->tx_ring[tun_tx_ix].buf.addr);
        if (tun_qp->tx_ring[tun_tx_ix].ah)
@@ -596,9 +596,15 @@ int mlx4_ib_send_to_slave(struct mlx4_ib_dev *dev, int slave, u8 port,
        wr.wr.send_flags = IB_SEND_SIGNALED;
        ret = ib_post_send(src_qp, &wr.wr, &bad_wr);
-out:
+        if (!ret)
-        if (ret)
+                return 0;
-                ib_destroy_ah(ah);
+ out:
+        spin_lock(&tun_qp->tx_lock);
+        tun_qp->tx_ix_tail++;
+        spin_unlock(&tun_qp->tx_lock);
+        tun_qp->tx_ring[tun_tx_ix].ah = NULL;
+end:
+        ib_destroy_ah(ah);
        return ret;
 }
@@ -1326,9 +1332,15 @@ int mlx4_ib_send_to_wire(struct mlx4_ib_dev *dev, int slave, u8 port,
        ret = ib_post_send(send_qp, &wr.wr, &bad_wr);
+        if (!ret)
+                return 0;
+        spin_lock(&sqp->tx_lock);
+        sqp->tx_ix_tail++;
+        spin_unlock(&sqp->tx_lock);
+        sqp->tx_ring[wire_tx_ix].ah = NULL;
 out:
-        if (ret)
+        ib_destroy_ah(ah);
-                ib_destroy_ah(ah);
        return ret;
 }
diff --git a/drivers/infiniband/hw/mlx4/main.c b/drivers/infiniband/hw/mlx4/main.c
index 0eb09e104542..42a46078d7d5 100644
--- a/drivers/infiniband/hw/mlx4/main.c
+++ b/drivers/infiniband/hw/mlx4/main.c
@@ -1704,6 +1704,9 @@ static struct ib_flow *mlx4_ib_create_flow(struct ib_qp *qp,
        struct mlx4_dev *dev = (to_mdev(qp->device))->dev;
        int is_bonded = mlx4_is_bonded(dev);
+        if (flow_attr->port < 1 || flow_attr->port > qp->device->phys_port_cnt)
+                return ERR_PTR(-EINVAL);
        if ((flow_attr->flags & IB_FLOW_ATTR_FLAGS_DONT_TRAP) &&
            (flow_attr->type != IB_FLOW_ATTR_NORMAL))
                return ERR_PTR(-EOPNOTSUPP);
diff --git a/drivers/infiniband/hw/mlx4/mlx4_ib.h b/drivers/infiniband/hw/mlx4/mlx4_ib.h
index 6c5ac5d8f32f..29acda249612 100644
--- a/drivers/infiniband/hw/mlx4/mlx4_ib.h
+++ b/drivers/infiniband/hw/mlx4/mlx4_ib.h
@@ -139,7 +139,7 @@ struct mlx4_ib_mr {
        u32                     max_pages;
        struct mlx4_mr          mmr;
        struct ib_umem         *umem;
-        void                    *pages_alloc;
+        size_t                  page_map_size;
 };
 struct mlx4_ib_mw {
diff --git a/drivers/infiniband/hw/mlx4/mr.c b/drivers/infiniband/hw/mlx4/mr.c
index 631272172a0b..5d73989d9771 100644
--- a/drivers/infiniband/hw/mlx4/mr.c
+++ b/drivers/infiniband/hw/mlx4/mr.c
@@ -277,20 +277,23 @@ mlx4_alloc_priv_pages(struct ib_device *device,
                      struct mlx4_ib_mr *mr,
                      int max_pages)
 {
-        int size = max_pages * sizeof(u64);
-        int add_size;
        int ret;
-        add_size = max_t(int, MLX4_MR_PAGES_ALIGN - ARCH_KMALLOC_MINALIGN, 0);
+        /* Ensure that size is aligned to DMA cacheline
+         * requirements.
+         * max_pages is limited to MLX4_MAX_FAST_REG_PAGES
+         * so page_map_size will never cross PAGE_SIZE.
+         */
+        mr->page_map_size = roundup(max_pages * sizeof(u64),
+                                    MLX4_MR_PAGES_ALIGN);
-        mr->pages_alloc = kzalloc(size + add_size, GFP_KERNEL);
+        /* Prevent cross page boundary allocation. */
-        if (!mr->pages_alloc)
+        mr->pages = (__be64 *)get_zeroed_page(GFP_KERNEL);
+        if (!mr->pages)
                return -ENOMEM;
-        mr->pages = PTR_ALIGN(mr->pages_alloc, MLX4_MR_PAGES_ALIGN);
        mr->page_map = dma_map_single(device->dma_device, mr->pages,
-                                      size, DMA_TO_DEVICE);
+                                      mr->page_map_size, DMA_TO_DEVICE);
        if (dma_mapping_error(device->dma_device, mr->page_map)) {
                ret = -ENOMEM;
@@ -298,9 +301,9 @@ mlx4_alloc_priv_pages(struct ib_device *device,
        }
        return 0;
-err:
-        kfree(mr->pages_alloc);
+err:
+        free_page((unsigned long)mr->pages);
        return ret;
 }
@@ -309,11 +312,10 @@ mlx4_free_priv_pages(struct mlx4_ib_mr *mr)
 {
        if (mr->pages) {
                struct ib_device *device = mr->ibmr.device;
-                int size = mr->max_pages * sizeof(u64);
                dma_unmap_single(device->dma_device, mr->page_map,
-                                 size, DMA_TO_DEVICE);
+                                 mr->page_map_size, DMA_TO_DEVICE);
-                kfree(mr->pages_alloc);
+                free_page((unsigned long)mr->pages);
                mr->pages = NULL;
        }
 }
@@ -537,14 +539,12 @@ int mlx4_ib_map_mr_sg(struct ib_mr *ibmr, struct scatterlist *sg, int sg_nents,
        mr->npages = 0;
        ib_dma_sync_single_for_cpu(ibmr->device, mr->page_map,
-                                   sizeof(u64) * mr->max_pages,
+                                   mr->page_map_size, DMA_TO_DEVICE);
-                                   DMA_TO_DEVICE);
        rc = ib_sg_to_pages(ibmr, sg, sg_nents, sg_offset, mlx4_set_page);
        ib_dma_sync_single_for_device(ibmr->device, mr->page_map,
-                                      sizeof(u64) * mr->max_pages,
+                                      mr->page_map_size, DMA_TO_DEVICE);
-                                      DMA_TO_DEVICE);
        return rc;
 }
diff --git a/drivers/infiniband/hw/mlx4/qp.c b/drivers/infiniband/hw/mlx4/qp.c
index 81b0e1fbec1d..8db8405c1e99 100644
--- a/drivers/infiniband/hw/mlx4/qp.c
+++ b/drivers/infiniband/hw/mlx4/qp.c
@@ -362,7 +362,7 @@ static int send_wqe_overhead(enum mlx4_ib_qp_type type, u32 flags)
                        sizeof (struct mlx4_wqe_raddr_seg);
        case MLX4_IB_QPT_RC:
                return sizeof (struct mlx4_wqe_ctrl_seg) +
-                        sizeof (struct mlx4_wqe_atomic_seg) +
+                        sizeof (struct mlx4_wqe_masked_atomic_seg) +
                        sizeof (struct mlx4_wqe_raddr_seg);
        case MLX4_IB_QPT_SMI:
        case MLX4_IB_QPT_GSI:
@@ -1191,8 +1191,10 @@ static struct ib_qp *_mlx4_ib_create_qp(struct ib_pd *pd,
        {
                err = create_qp_common(to_mdev(pd->device), pd, init_attr,
                                       udata, 0, &qp, gfp);
-                if (err)
+                if (err) {
+                        kfree(qp);
                        return ERR_PTR(err);
+                }
                qp->ibqp.qp_num = qp->mqp.qpn;
                qp->xrcdn = xrcdn;
diff --git a/drivers/infiniband/hw/mlx5/mad.c b/drivers/infiniband/hw/mlx5/mad.c
index 1534af113058..364aab9f3c9e 100644
--- a/drivers/infiniband/hw/mlx5/mad.c
+++ b/drivers/infiniband/hw/mlx5/mad.c
@@ -121,7 +121,7 @@ static void pma_cnt_ext_assign(struct ib_pma_portcounters_ext *pma_cnt_ext,
        pma_cnt_ext->port_xmit_data =
                cpu_to_be64(MLX5_SUM_CNT(out, transmitted_ib_unicast.octets,
                                         transmitted_ib_multicast.octets) >> 2);
-        pma_cnt_ext->port_xmit_data =
+        pma_cnt_ext->port_rcv_data =
                cpu_to_be64(MLX5_SUM_CNT(out, received_ib_unicast.octets,
                                         received_ib_multicast.octets) >> 2);
        pma_cnt_ext->port_xmit_packets =
diff --git a/drivers/infiniband/hw/mlx5/qp.c b/drivers/infiniband/hw/mlx5/qp.c
index ce434228a5ea..ce0a7ab35a22 100644
--- a/drivers/infiniband/hw/mlx5/qp.c
+++ b/drivers/infiniband/hw/mlx5/qp.c
@@ -3332,10 +3332,11 @@ static u8 get_fence(u8 fence, struct ib_send_wr *wr)
                        return MLX5_FENCE_MODE_SMALL_AND_FENCE;
                else
                        return fence;
+        } else if (unlikely(wr->send_flags & IB_SEND_FENCE)) {
-        } else {
+                return MLX5_FENCE_MODE_FENCE;
-                return 0;
        }
+        return 0;
 }
 static int begin_wqe(struct mlx5_ib_qp *qp, void **seg,
diff --git a/drivers/infiniband/hw/qib/qib_file_ops.c b/drivers/infiniband/hw/qib/qib_file_ops.c
index ff946d5f59e4..382466a90da7 100644
--- a/drivers/infiniband/hw/qib/qib_file_ops.c
+++ b/drivers/infiniband/hw/qib/qib_file_ops.c
@@ -2178,6 +2178,11 @@ static ssize_t qib_write(struct file *fp, const char __user *data,
        switch (cmd.type) {
        case QIB_CMD_ASSIGN_CTXT:
+                if (rcd) {
+                        ret = -EINVAL;
+                        goto bail;
+                }
                ret = qib_assign_ctxt(fp, &cmd.cmd.user_info);
                if (ret)
                        goto bail;
diff --git a/drivers/infiniband/sw/rdmavt/qp.c b/drivers/infiniband/sw/rdmavt/qp.c
index 7de5134bec85..41ba7e9cadaa 100644
--- a/drivers/infiniband/sw/rdmavt/qp.c
+++ b/drivers/infiniband/sw/rdmavt/qp.c
@@ -369,8 +369,8 @@ static int alloc_qpn(struct rvt_dev_info *rdi, struct rvt_qpn_table *qpt,
                        /* wrap to first map page, invert bit 0 */
                        offset = qpt->incr | ((offset & 1) ^ 1);
                }
-                /* there can be no bits at shift and below */
+                /* there can be no set bits in low-order QoS bits */
-                WARN_ON(offset & (rdi->dparms.qos_shift - 1));
+                WARN_ON(offset & (BIT(rdi->dparms.qos_shift) - 1));
                qpn = mk_qpn(qpt, map, offset);
        }
@@ -576,12 +576,6 @@ static void rvt_reset_qp(struct rvt_dev_info *rdi, struct rvt_qp *qp,
        qp->s_ssn = 1;
        qp->s_lsn = 0;
        qp->s_mig_state = IB_MIG_MIGRATED;
-        if (qp->s_ack_queue)
-                memset(
-                        qp->s_ack_queue,
-                        0,
-                        rvt_max_atomic(rdi) *
-                                sizeof(*qp->s_ack_queue));
        qp->r_head_ack_queue = 0;
        qp->s_tail_ack_queue = 0;
        qp->s_num_rd_atomic = 0;
@@ -705,8 +699,10 @@ struct ib_qp *rvt_create_qp(struct ib_pd *ibpd,
                 * initialization that is needed.
                 */
                priv = rdi->driver_f.qp_priv_alloc(rdi, qp, gfp);
-                if (!priv)
+                if (IS_ERR(priv)) {
+                        ret = priv;
                        goto bail_qp;
+                }
                qp->priv = priv;
                qp->timeout_jiffies =
                        usecs_to_jiffies((4096UL * (1UL << qp->timeout)) /
diff --git a/drivers/infiniband/sw/rdmavt/vt.c b/drivers/infiniband/sw/rdmavt/vt.c
index e1cc2cc42f25..30c4fda7a05a 100644
--- a/drivers/infiniband/sw/rdmavt/vt.c
+++ b/drivers/infiniband/sw/rdmavt/vt.c
@@ -501,9 +501,7 @@ static noinline int check_support(struct rvt_dev_info *rdi, int verb)
                            !rdi->driver_f.quiesce_qp ||
                            !rdi->driver_f.notify_error_qp ||
                            !rdi->driver_f.mtu_from_qp ||
-                            !rdi->driver_f.mtu_to_path_mtu ||
+                            !rdi->driver_f.mtu_to_path_mtu)
-                            !rdi->driver_f.shut_down_port ||
-                            !rdi->driver_f.cap_mask_chg)
                                return -EINVAL;
                break;
diff --git a/drivers/infiniband/ulp/srpt/ib_srpt.c b/drivers/infiniband/ulp/srpt/ib_srpt.c
index e68b20cba70b..4a4155640d51 100644
--- a/drivers/infiniband/ulp/srpt/ib_srpt.c
+++ b/drivers/infiniband/ulp/srpt/ib_srpt.c
@@ -1638,8 +1638,7 @@ retry:
         */
        qp_init->cap.max_send_wr = srp_sq_size / 2;
        qp_init->cap.max_rdma_ctxs = srp_sq_size / 2;
-        qp_init->cap.max_send_sge = max(sdev->device->attrs.max_sge_rd,
+        qp_init->cap.max_send_sge = SRPT_DEF_SG_PER_WQE;
-                                        sdev->device->attrs.max_sge);
        qp_init->port_num = ch->sport->port;
        ch->qp = ib_create_qp(sdev->pd, qp_init);
diff --git a/drivers/infiniband/ulp/srpt/ib_srpt.h b/drivers/infiniband/ulp/srpt/ib_srpt.h
index fee6bfd7ca21..389030487da7 100644
--- a/drivers/infiniband/ulp/srpt/ib_srpt.h
+++ b/drivers/infiniband/ulp/srpt/ib_srpt.h
@@ -106,6 +106,7 @@ enum {
        SRP_LOGIN_RSP_MULTICHAN_MAINTAINED = 0x2,
        SRPT_DEF_SG_TABLESIZE = 128,
+        SRPT_DEF_SG_PER_WQE = 16,
        MIN_SRPT_SQ_SIZE = 16,
        DEF_SRPT_SQ_SIZE = 4096,
diff --git a/drivers/input/joystick/xpad.c b/drivers/input/joystick/xpad.c
index 804dbcc37d3f..3438e98c145a 100644
--- a/drivers/input/joystick/xpad.c
+++ b/drivers/input/joystick/xpad.c
@@ -1031,17 +1031,17 @@ static int xpad_play_effect(struct input_dev *dev, void *data, struct ff_effect
        case XTYPE_XBOXONE:
                packet->data[0] = 0x09; /* activate rumble */
-                packet->data[1] = 0x08;
+                packet->data[1] = 0x00;
                packet->data[2] = xpad->odata_serial++;
-                packet->data[3] = 0x08; /* continuous effect */
+                packet->data[3] = 0x09;
-                packet->data[4] = 0x00; /* simple rumble mode */
+                packet->data[4] = 0x00;
-                packet->data[5] = 0x03; /* L and R actuator only */
+                packet->data[5] = 0x0F;
-                packet->data[6] = 0x00; /* TODO: LT actuator */
+                packet->data[6] = 0x00;
-                packet->data[7] = 0x00; /* TODO: RT actuator */
+                packet->data[7] = 0x00;
                packet->data[8] = strong / 512; /* left actuator */
                packet->data[9] = weak / 512;   /* right actuator */
-                packet->data[10] = 0x80;        /* length of pulse */
+                packet->data[10] = 0xFF;
-                packet->data[11] = 0x00;        /* stop period of pulse */
+                packet->data[11] = 0x00;
                packet->data[12] = 0x00;
                packet->len = 13;
                packet->pending = true;
@@ -1437,16 +1437,6 @@ static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id
                        break;
        }
-        if (xpad_device[i].xtype == XTYPE_XBOXONE &&
-            intf->cur_altsetting->desc.bInterfaceNumber != 0) {
-                /*
-                 * The Xbox One controller lists three interfaces all with the
-                 * same interface class, subclass and protocol. Differentiate by
-                 * interface number.
-                 */
-                return -ENODEV;
-        }
        xpad = kzalloc(sizeof(struct usb_xpad), GFP_KERNEL);
        if (!xpad)
                return -ENOMEM;
@@ -1478,6 +1468,8 @@ static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id
                if (intf->cur_altsetting->desc.bInterfaceClass == USB_CLASS_VENDOR_SPEC) {
                        if (intf->cur_altsetting->desc.bInterfaceProtocol == 129)
                                xpad->xtype = XTYPE_XBOX360W;
+                        else if (intf->cur_altsetting->desc.bInterfaceProtocol == 208)
+                                xpad->xtype = XTYPE_XBOXONE;
                        else
                                xpad->xtype = XTYPE_XBOX360;
                } else {
@@ -1492,6 +1484,17 @@ static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id
                        xpad->mapping |= MAP_STICKS_TO_NULL;
        }
+        if (xpad->xtype == XTYPE_XBOXONE &&
+            intf->cur_altsetting->desc.bInterfaceNumber != 0) {
+                /*
+                 * The Xbox One controller lists three interfaces all with the
+                 * same interface class, subclass and protocol. Differentiate by
+                 * interface number.
+                 */
+                error = -ENODEV;
+                goto err_free_in_urb;
+        }
        error = xpad_init_output(intf, xpad);
        if (error)
                goto err_free_in_urb;
diff --git a/drivers/input/mouse/elantech.c b/drivers/input/mouse/elantech.c
index 78f93cf68840..be5b399da5d3 100644
--- a/drivers/input/mouse/elantech.c
+++ b/drivers/input/mouse/elantech.c
@@ -1568,13 +1568,7 @@ static int elantech_set_properties(struct elantech_data *etd)
                case 5:
                        etd->hw_version = 3;
                        break;
-                case 6:
+                case 6 ... 14:
-                case 7:
-                case 8:
-                case 9:
-                case 10:
-                case 13:
-                case 14:
                        etd->hw_version = 4;
                        break;
                default:
diff --git a/drivers/input/mouse/vmmouse.c b/drivers/input/mouse/vmmouse.c
index a3f0f5a47490..0f586780ceb4 100644
--- a/drivers/input/mouse/vmmouse.c
+++ b/drivers/input/mouse/vmmouse.c
@@ -355,18 +355,11 @@ int vmmouse_detect(struct psmouse *psmouse, bool set_properties)
                return -ENXIO;
        }
-        if (!request_region(VMMOUSE_PROTO_PORT, 4, "vmmouse")) {
-                psmouse_dbg(psmouse, "VMMouse port in use.\n");
-                return -EBUSY;
-        }
        /* Check if the device is present */
        response = ~VMMOUSE_PROTO_MAGIC;
        VMMOUSE_CMD(GETVERSION, 0, version, response, dummy1, dummy2);
-        if (response != VMMOUSE_PROTO_MAGIC || version == 0xffffffffU) {
+        if (response != VMMOUSE_PROTO_MAGIC || version == 0xffffffffU)
-                release_region(VMMOUSE_PROTO_PORT, 4);
                return -ENXIO;
-        }
        if (set_properties) {
                psmouse->vendor = VMMOUSE_VENDOR;
@@ -374,8 +367,6 @@ int vmmouse_detect(struct psmouse *psmouse, bool set_properties)
                psmouse->model = version;
        }
-        release_region(VMMOUSE_PROTO_PORT, 4);
        return 0;
 }
@@ -394,7 +385,6 @@ static void vmmouse_disconnect(struct psmouse *psmouse)
        psmouse_reset(psmouse);
        input_unregister_device(priv->abs_dev);
        kfree(priv);
-        release_region(VMMOUSE_PROTO_PORT, 4);
 }
 /**
@@ -438,15 +428,10 @@ int vmmouse_init(struct psmouse *psmouse)
        struct input_dev *rel_dev = psmouse->dev, *abs_dev;
        int error;
-        if (!request_region(VMMOUSE_PROTO_PORT, 4, "vmmouse")) {
-                psmouse_dbg(psmouse, "VMMouse port in use.\n");
-                return -EBUSY;
-        }
        psmouse_reset(psmouse);
        error = vmmouse_enable(psmouse);
        if (error)
-                goto release_region;
+                return error;
        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
        abs_dev = input_allocate_device();
@@ -502,8 +487,5 @@ init_fail:
        kfree(priv);
        psmouse->private = NULL;
-release_region:
-        release_region(VMMOUSE_PROTO_PORT, 4);
        return error;
 }
diff --git a/drivers/input/touchscreen/wacom_w8001.c b/drivers/input/touchscreen/wacom_w8001.c
index bab3c6acf6a2..0c9191cf324d 100644
--- a/drivers/input/touchscreen/wacom_w8001.c
+++ b/drivers/input/touchscreen/wacom_w8001.c
@@ -27,7 +27,7 @@ MODULE_AUTHOR("Jaya Kumar <jayakumar.lkml@gmail.com>");
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
-#define W8001_MAX_LENGTH        11
+#define W8001_MAX_LENGTH        13
 #define W8001_LEAD_MASK         0x80
 #define W8001_LEAD_BYTE         0x80
 #define W8001_TAB_MASK          0x40
@@ -339,6 +339,15 @@ static irqreturn_t w8001_interrupt(struct serio *serio,
                w8001->idx = 0;
                parse_multi_touch(w8001);
                break;
+        default:
+                /*
+                 * ThinkPad X60 Tablet PC (pen only device) sometimes
+                 * sends invalid data packets that are larger than
+                 * W8001_PKTLEN_TPCPEN. Let's start over again.
+                 */
+                if (!w8001->touch_dev && w8001->idx > W8001_PKTLEN_TPCPEN - 1)
+                        w8001->idx = 0;
        }
        return IRQ_HANDLED;
diff --git a/drivers/irqchip/irq-mips-gic.c b/drivers/irqchip/irq-mips-gic.c
index 3b5e10aa48ab..8a4adbeb2b8c 100644
--- a/drivers/irqchip/irq-mips-gic.c
+++ b/drivers/irqchip/irq-mips-gic.c
@@ -746,6 +746,12 @@ static int gic_irq_domain_alloc(struct irq_domain *d, unsigned int virq,
                /* verify that it doesn't conflict with an IPI irq */
                if (test_bit(spec->hwirq, ipi_resrv))
                        return -EBUSY;
+                hwirq = GIC_SHARED_TO_HWIRQ(spec->hwirq);
+                return irq_domain_set_hwirq_and_chip(d, virq, hwirq,
+                                                     &gic_level_irq_controller,
+                                                     NULL);
        } else {
                base_hwirq = find_first_bit(ipi_resrv, gic_shared_intrs);
                if (base_hwirq == gic_shared_intrs) {
@@ -867,10 +873,14 @@ static int gic_dev_domain_alloc(struct irq_domain *d, unsigned int virq,
                                                    &gic_level_irq_controller,
                                                    NULL);
                if (ret)
-                        return ret;
+                        goto error;
        }
        return 0;
+error:
+        irq_domain_free_irqs_parent(d, virq, nr_irqs);
+        return ret;
 }
 void gic_dev_domain_free(struct irq_domain *d, unsigned int virq,
diff --git a/drivers/mtd/ubi/eba.c b/drivers/mtd/ubi/eba.c
index 5780dd1ba79d..ebf517271d29 100644
--- a/drivers/mtd/ubi/eba.c
+++ b/drivers/mtd/ubi/eba.c
@@ -575,6 +575,7 @@ static int recover_peb(struct ubi_device *ubi, int pnum, int vol_id, int lnum,
        int err, idx = vol_id2idx(ubi, vol_id), new_pnum, data_size, tries = 0;
        struct ubi_volume *vol = ubi->volumes[idx];
        struct ubi_vid_hdr *vid_hdr;
+        uint32_t crc;
        vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
        if (!vid_hdr)
@@ -599,14 +600,8 @@ retry:
                goto out_put;
        }
-        vid_hdr->sqnum = cpu_to_be64(ubi_next_sqnum(ubi));
+        ubi_assert(vid_hdr->vol_type == UBI_VID_DYNAMIC);
-        err = ubi_io_write_vid_hdr(ubi, new_pnum, vid_hdr);
-        if (err) {
-                up_read(&ubi->fm_eba_sem);
-                goto write_error;
-        }
-        data_size = offset + len;
        mutex_lock(&ubi->buf_mutex);
        memset(ubi->peb_buf + offset, 0xFF, len);
@@ -621,6 +616,19 @@ retry:
        memcpy(ubi->peb_buf + offset, buf, len);
+        data_size = offset + len;
+        crc = crc32(UBI_CRC32_INIT, ubi->peb_buf, data_size);
+        vid_hdr->sqnum = cpu_to_be64(ubi_next_sqnum(ubi));
+        vid_hdr->copy_flag = 1;
+        vid_hdr->data_size = cpu_to_be32(data_size);
+        vid_hdr->data_crc = cpu_to_be32(crc);
+        err = ubi_io_write_vid_hdr(ubi, new_pnum, vid_hdr);
+        if (err) {
+                mutex_unlock(&ubi->buf_mutex);
+                up_read(&ubi->fm_eba_sem);
+                goto write_error;
+        }
        err = ubi_io_write_data(ubi, ubi->peb_buf, new_pnum, 0, data_size);
        if (err) {
                mutex_unlock(&ubi->buf_mutex);
diff --git a/drivers/net/bonding/bond_3ad.c b/drivers/net/bonding/bond_3ad.c
index b9304a295f86..ca81f46ea1aa 100644
--- a/drivers/net/bonding/bond_3ad.c
+++ b/drivers/net/bonding/bond_3ad.c
@@ -657,6 +657,20 @@ static void __set_agg_ports_ready(struct aggregator *aggregator, int val)
        }
 }
+static int __agg_active_ports(struct aggregator *agg)
+{
+        struct port *port;
+        int active = 0;
+        for (port = agg->lag_ports; port;
+             port = port->next_port_in_aggregator) {
+                if (port->is_enabled)
+                        active++;
+        }
+        return active;
+}
 /**
 * __get_agg_bandwidth - get the total bandwidth of an aggregator
 * @aggregator: the aggregator we're looking at
@@ -664,39 +678,40 @@ static void __set_agg_ports_ready(struct aggregator *aggregator, int val)
 */
 static u32 __get_agg_bandwidth(struct aggregator *aggregator)
 {
+        int nports = __agg_active_ports(aggregator);
        u32 bandwidth = 0;
-        if (aggregator->num_of_ports) {
+        if (nports) {
                switch (__get_link_speed(aggregator->lag_ports)) {
                case AD_LINK_SPEED_1MBPS:
-                        bandwidth = aggregator->num_of_ports;
+                        bandwidth = nports;
                        break;
                case AD_LINK_SPEED_10MBPS:
-                        bandwidth = aggregator->num_of_ports * 10;
+                        bandwidth = nports * 10;
                        break;
                case AD_LINK_SPEED_100MBPS:
-                        bandwidth = aggregator->num_of_ports * 100;
+                        bandwidth = nports * 100;
                        break;
                case AD_LINK_SPEED_1000MBPS:
-                        bandwidth = aggregator->num_of_ports * 1000;
+                        bandwidth = nports * 1000;
                        break;
                case AD_LINK_SPEED_2500MBPS:
-                        bandwidth = aggregator->num_of_ports * 2500;
+                        bandwidth = nports * 2500;
                        break;
                case AD_LINK_SPEED_10000MBPS:
-                        bandwidth = aggregator->num_of_ports * 10000;
+                        bandwidth = nports * 10000;
                        break;
                case AD_LINK_SPEED_20000MBPS:
-                        bandwidth = aggregator->num_of_ports * 20000;
+                        bandwidth = nports * 20000;
                        break;
                case AD_LINK_SPEED_40000MBPS:
-                        bandwidth = aggregator->num_of_ports * 40000;
+                        bandwidth = nports * 40000;
                        break;
                case AD_LINK_SPEED_56000MBPS:
-                        bandwidth = aggregator->num_of_ports * 56000;
+                        bandwidth = nports * 56000;
                        break;
                case AD_LINK_SPEED_100000MBPS:
-                        bandwidth = aggregator->num_of_ports * 100000;
+                        bandwidth = nports * 100000;
                        break;
                default:
                        bandwidth = 0; /* to silence the compiler */
@@ -1530,10 +1545,10 @@ static struct aggregator *ad_agg_selection_test(struct aggregator *best,
        switch (__get_agg_selection_mode(curr->lag_ports)) {
        case BOND_AD_COUNT:
-                if (curr->num_of_ports > best->num_of_ports)
+                if (__agg_active_ports(curr) > __agg_active_ports(best))
                        return curr;
-                if (curr->num_of_ports < best->num_of_ports)
+                if (__agg_active_ports(curr) < __agg_active_ports(best))
                        return best;
                /*FALLTHROUGH*/
@@ -1561,8 +1576,14 @@ static int agg_device_up(const struct aggregator *agg)
        if (!port)
                return 0;
-        return netif_running(port->slave->dev) &&
+        for (port = agg->lag_ports; port;
-               netif_carrier_ok(port->slave->dev);
+             port = port->next_port_in_aggregator) {
+                if (netif_running(port->slave->dev) &&
+                    netif_carrier_ok(port->slave->dev))
+                        return 1;
+        }
+        return 0;
 }
 /**
@@ -1610,7 +1631,7 @@ static void ad_agg_selection_logic(struct aggregator *agg,
                agg->is_active = 0;
-                if (agg->num_of_ports && agg_device_up(agg))
+                if (__agg_active_ports(agg) && agg_device_up(agg))
                        best = ad_agg_selection_test(best, agg);
        }
@@ -1622,7 +1643,7 @@ static void ad_agg_selection_logic(struct aggregator *agg,
                 * answering partner.
                 */
                if (active && active->lag_ports &&
-                    active->lag_ports->is_enabled &&
+                    __agg_active_ports(active) &&
                    (__agg_has_partner(active) ||
                     (!__agg_has_partner(active) &&
                     !__agg_has_partner(best)))) {
@@ -2133,7 +2154,7 @@ void bond_3ad_unbind_slave(struct slave *slave)
                                else
                                        temp_aggregator->lag_ports = temp_port->next_port_in_aggregator;
                                temp_aggregator->num_of_ports--;
-                                if (temp_aggregator->num_of_ports == 0) {
+                                if (__agg_active_ports(temp_aggregator) == 0) {
                                        select_new_active_agg = temp_aggregator->is_active;
                                        ad_clear_agg(temp_aggregator);
                                        if (select_new_active_agg) {
@@ -2432,7 +2453,9 @@ void bond_3ad_adapter_speed_duplex_changed(struct slave *slave)
 */
 void bond_3ad_handle_link_change(struct slave *slave, char link)
 {
+        struct aggregator *agg;
        struct port *port;
+        bool dummy;
        port = &(SLAVE_AD_INFO(slave)->port);
@@ -2459,6 +2482,9 @@ void bond_3ad_handle_link_change(struct slave *slave, char link)
                port->is_enabled = false;
                ad_update_actor_keys(port, true);
        }
+        agg = __get_first_agg(port);
+        ad_agg_selection_logic(agg, &dummy);
        netdev_dbg(slave->bond->dev, "Port %d changed link status to %s\n",
                   port->actor_port_number,
                   link == BOND_LINK_UP ? "UP" : "DOWN");
@@ -2499,7 +2525,7 @@ int bond_3ad_set_carrier(struct bonding *bond)
        active = __get_active_agg(&(SLAVE_AD_INFO(first_slave)->aggregator));
        if (active) {
                /* are enough slaves available to consider link up? */
-                if (active->num_of_ports < bond->params.min_links) {
+                if (__agg_active_ports(active) < bond->params.min_links) {
                        if (netif_carrier_ok(bond->dev)) {
                                netif_carrier_off(bond->dev);
                                goto out;
diff --git a/drivers/net/can/at91_can.c b/drivers/net/can/at91_can.c
index 8b3275d7792a..8f5e93cb7975 100644
--- a/drivers/net/can/at91_can.c
+++ b/drivers/net/can/at91_can.c
@@ -712,9 +712,10 @@ static int at91_poll_rx(struct net_device *dev, int quota)
        /* upper group completed, look again in lower */
        if (priv->rx_next > get_mb_rx_low_last(priv) &&
-            quota > 0 && mb > get_mb_rx_last(priv)) {
+            mb > get_mb_rx_last(priv)) {
                priv->rx_next = get_mb_rx_first(priv);
-                goto again;
+                if (quota > 0)
+                        goto again;
        }
        return received;
diff --git a/drivers/net/can/c_can/c_can.c b/drivers/net/can/c_can/c_can.c
index f91b094288da..e3dccd3200d5 100644
--- a/drivers/net/can/c_can/c_can.c
+++ b/drivers/net/can/c_can/c_can.c
@@ -332,9 +332,23 @@ static void c_can_setup_tx_object(struct net_device *dev, int iface,
        priv->write_reg(priv, C_CAN_IFACE(MSGCTRL_REG, iface), ctrl);
-        for (i = 0; i < frame->can_dlc; i += 2) {
+        if (priv->type == BOSCH_D_CAN) {
-                priv->write_reg(priv, C_CAN_IFACE(DATA1_REG, iface) + i / 2,
+                u32 data = 0, dreg = C_CAN_IFACE(DATA1_REG, iface);
-                                frame->data[i] | (frame->data[i + 1] << 8));
+                for (i = 0; i < frame->can_dlc; i += 4, dreg += 2) {
+                        data = (u32)frame->data[i];
+                        data |= (u32)frame->data[i + 1] << 8;
+                        data |= (u32)frame->data[i + 2] << 16;
+                        data |= (u32)frame->data[i + 3] << 24;
+                        priv->write_reg32(priv, dreg, data);
+                }
+        } else {
+                for (i = 0; i < frame->can_dlc; i += 2) {
+                        priv->write_reg(priv,
+                                        C_CAN_IFACE(DATA1_REG, iface) + i / 2,
+                                        frame->data[i] |
+                                        (frame->data[i + 1] << 8));
+                }
        }
 }
@@ -402,10 +416,20 @@ static int c_can_read_msg_object(struct net_device *dev, int iface, u32 ctrl)
        } else {
                int i, dreg = C_CAN_IFACE(DATA1_REG, iface);
-                for (i = 0; i < frame->can_dlc; i += 2, dreg ++) {
+                if (priv->type == BOSCH_D_CAN) {
-                        data = priv->read_reg(priv, dreg);
+                        for (i = 0; i < frame->can_dlc; i += 4, dreg += 2) {
-                        frame->data[i] = data;
+                                data = priv->read_reg32(priv, dreg);
-                        frame->data[i + 1] = data >> 8;
+                                frame->data[i] = data;
+                                frame->data[i + 1] = data >> 8;
+                                frame->data[i + 2] = data >> 16;
+                                frame->data[i + 3] = data >> 24;
+                        }
+                } else {
+                        for (i = 0; i < frame->can_dlc; i += 2, dreg++) {
+                                data = priv->read_reg(priv, dreg);
+                                frame->data[i] = data;
+                                frame->data[i + 1] = data >> 8;
+                        }
                }
        }
diff --git a/drivers/net/can/dev.c b/drivers/net/can/dev.c
index 910c12e2638e..ad535a854e5c 100644
--- a/drivers/net/can/dev.c
+++ b/drivers/net/can/dev.c
@@ -798,6 +798,9 @@ static int can_validate(struct nlattr *tb[], struct nlattr *data[])
         * - control mode with CAN_CTRLMODE_FD set
         */
+        if (!data)
+                return 0;
        if (data[IFLA_CAN_CTRLMODE]) {
                struct can_ctrlmode *cm = nla_data(data[IFLA_CAN_CTRLMODE]);
@@ -1008,6 +1011,11 @@ static int can_newlink(struct net *src_net, struct net_device *dev,
        return -EOPNOTSUPP;
 }
+static void can_dellink(struct net_device *dev, struct list_head *head)
+{
+        return;
+}
 static struct rtnl_link_ops can_link_ops __read_mostly = {
        .kind           = "can",
        .maxtype        = IFLA_CAN_MAX,
@@ -1016,6 +1024,7 @@ static struct rtnl_link_ops can_link_ops __read_mostly = {
        .validate       = can_validate,
        .newlink        = can_newlink,
        .changelink     = can_changelink,
+        .dellink        = can_dellink,
        .get_size       = can_get_size,
        .fill_info      = can_fill_info,
        .get_xstats_size = can_get_xstats_size,
diff --git a/drivers/net/can/usb/Kconfig b/drivers/net/can/usb/Kconfig
index bcb272f6c68a..8483a40e7e9e 100644
--- a/drivers/net/can/usb/Kconfig
+++ b/drivers/net/can/usb/Kconfig
@@ -16,7 +16,8 @@ config CAN_ESD_USB2
 config CAN_GS_USB
        tristate "Geschwister Schneider UG interfaces"
        ---help---
-          This driver supports the Geschwister Schneider USB/CAN devices.
+          This driver supports the Geschwister Schneider and bytewerk.org
+          candleLight USB CAN interfaces USB/CAN devices
          If unsure choose N,
          choose Y for built in support,
          M to compile as module (module will be named: gs_usb).
@@ -46,6 +47,8 @@ config CAN_KVASER_USB
            - Kvaser USBcan R
            - Kvaser Leaf Light v2
            - Kvaser Mini PCI Express HS
+            - Kvaser Mini PCI Express 2xHS
+            - Kvaser USBcan Light 2xHS
            - Kvaser USBcan II HS/HS
            - Kvaser USBcan II HS/LS
            - Kvaser USBcan Rugged ("USBcan Rev B")
diff --git a/drivers/net/can/usb/gs_usb.c b/drivers/net/can/usb/gs_usb.c
index 1556d4286235..acb0c8490673 100644
--- a/drivers/net/can/usb/gs_usb.c
+++ b/drivers/net/can/usb/gs_usb.c
@@ -1,7 +1,9 @@
-/* CAN driver for Geschwister Schneider USB/CAN devices.
+/* CAN driver for Geschwister Schneider USB/CAN devices
+ * and bytewerk.org candleLight USB CAN interfaces.
 *
- * Copyright (C) 2013 Geschwister Schneider Technologie-,
+ * Copyright (C) 2013-2016 Geschwister Schneider Technologie-,
 * Entwicklungs- und Vertriebs UG (Haftungsbeschränkt).
+ * Copyright (C) 2016 Hubert Denkmair
 *
 * Many thanks to all socketcan devs!
 *
@@ -29,6 +31,9 @@
 #define USB_GSUSB_1_VENDOR_ID      0x1d50
 #define USB_GSUSB_1_PRODUCT_ID     0x606f
+#define USB_CANDLELIGHT_VENDOR_ID  0x1209
+#define USB_CANDLELIGHT_PRODUCT_ID 0x2323
 #define GSUSB_ENDPOINT_IN          1
 #define GSUSB_ENDPOINT_OUT         2
@@ -952,6 +957,8 @@ static void gs_usb_disconnect(struct usb_interface *intf)
 static const struct usb_device_id gs_usb_table[] = {
        { USB_DEVICE_INTERFACE_NUMBER(USB_GSUSB_1_VENDOR_ID,
                                      USB_GSUSB_1_PRODUCT_ID, 0) },
+        { USB_DEVICE_INTERFACE_NUMBER(USB_CANDLELIGHT_VENDOR_ID,
+                                      USB_CANDLELIGHT_PRODUCT_ID, 0) },
        {} /* Terminating entry */
 };
@@ -969,5 +976,6 @@ module_usb_driver(gs_usb_driver);
 MODULE_AUTHOR("Maximilian Schneider <mws@schneidersoft.net>");
 MODULE_DESCRIPTION(
 "Socket CAN device driver for Geschwister Schneider Technologie-, "
-"Entwicklungs- und Vertriebs UG. USB2.0 to CAN interfaces.");
+"Entwicklungs- und Vertriebs UG. USB2.0 to CAN interfaces\n"
+"and bytewerk.org candleLight USB CAN interfaces.");
 MODULE_LICENSE("GPL v2");
diff --git a/drivers/net/can/usb/kvaser_usb.c b/drivers/net/can/usb/kvaser_usb.c
index 022bfa13ebfa..6f1f3b675ff5 100644
--- a/drivers/net/can/usb/kvaser_usb.c
+++ b/drivers/net/can/usb/kvaser_usb.c
@@ -59,11 +59,14 @@
 #define USB_CAN_R_PRODUCT_ID            39
 #define USB_LEAF_LITE_V2_PRODUCT_ID     288
 #define USB_MINI_PCIE_HS_PRODUCT_ID     289
+#define USB_LEAF_LIGHT_HS_V2_OEM_PRODUCT_ID 290
+#define USB_USBCAN_LIGHT_2HS_PRODUCT_ID 291
+#define USB_MINI_PCIE_2HS_PRODUCT_ID    292
 static inline bool kvaser_is_leaf(const struct usb_device_id *id)
 {
        return id->idProduct >= USB_LEAF_DEVEL_PRODUCT_ID &&
-               id->idProduct <= USB_MINI_PCIE_HS_PRODUCT_ID;
+               id->idProduct <= USB_MINI_PCIE_2HS_PRODUCT_ID;
 }
 /* Kvaser USBCan-II devices */
@@ -537,6 +540,9 @@ static const struct usb_device_id kvaser_usb_table[] = {
                .driver_info = KVASER_HAS_TXRX_ERRORS },
        { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_V2_PRODUCT_ID) },
        { USB_DEVICE(KVASER_VENDOR_ID, USB_MINI_PCIE_HS_PRODUCT_ID) },
+        { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LIGHT_HS_V2_OEM_PRODUCT_ID) },
+        { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_LIGHT_2HS_PRODUCT_ID) },
+        { USB_DEVICE(KVASER_VENDOR_ID, USB_MINI_PCIE_2HS_PRODUCT_ID) },
        /* USBCANII family IDs */
        { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN2_PRODUCT_ID),
diff --git a/drivers/net/ethernet/amd/au1000_eth.c b/drivers/net/ethernet/amd/au1000_eth.c
index e0fb0f1122db..20760e10211a 100644
--- a/drivers/net/ethernet/amd/au1000_eth.c
+++ b/drivers/net/ethernet/amd/au1000_eth.c
@@ -509,8 +509,8 @@ static int au1000_mii_probe(struct net_device *dev)
         * on the current MAC's MII bus
         */
        for (phy_addr = 0; phy_addr < PHY_MAX_ADDR; phy_addr++)
-                if (mdiobus_get_phy(aup->mii_bus, aup->phy_addr)) {
+                if (mdiobus_get_phy(aup->mii_bus, phy_addr)) {
-                        phydev = mdiobus_get_phy(aup->mii_bus, aup->phy_addr);
+                        phydev = mdiobus_get_phy(aup->mii_bus, phy_addr);
                        if (!aup->phy_search_highest_addr)
                                /* break out with first one found */
                                break;
diff --git a/drivers/net/ethernet/atheros/alx/alx.h b/drivers/net/ethernet/atheros/alx/alx.h
index d02c4240b7df..8fc93c5f6abc 100644
--- a/drivers/net/ethernet/atheros/alx/alx.h
+++ b/drivers/net/ethernet/atheros/alx/alx.h
@@ -96,10 +96,6 @@ struct alx_priv {
        unsigned int rx_ringsz;
        unsigned int rxbuf_size;
-        struct page  *rx_page;
-        unsigned int rx_page_offset;
-        unsigned int rx_frag_size;
        struct napi_struct napi;
        struct alx_tx_queue txq;
        struct alx_rx_queue rxq;
diff --git a/drivers/net/ethernet/atheros/alx/main.c b/drivers/net/ethernet/atheros/alx/main.c
index c98acdc0d14f..e708e360a9e3 100644
--- a/drivers/net/ethernet/atheros/alx/main.c
+++ b/drivers/net/ethernet/atheros/alx/main.c
@@ -70,35 +70,6 @@ static void alx_free_txbuf(struct alx_priv *alx, int entry)
        }
 }
-static struct sk_buff *alx_alloc_skb(struct alx_priv *alx, gfp_t gfp)
-{
-        struct sk_buff *skb;
-        struct page *page;
-        if (alx->rx_frag_size > PAGE_SIZE)
-                return __netdev_alloc_skb(alx->dev, alx->rxbuf_size, gfp);
-        page = alx->rx_page;
-        if (!page) {
-                alx->rx_page = page = alloc_page(gfp);
-                if (unlikely(!page))
-                        return NULL;
-                alx->rx_page_offset = 0;
-        }
-        skb = build_skb(page_address(page) + alx->rx_page_offset,
-                        alx->rx_frag_size);
-        if (likely(skb)) {
-                alx->rx_page_offset += alx->rx_frag_size;
-                if (alx->rx_page_offset >= PAGE_SIZE)
-                        alx->rx_page = NULL;
-                else
-                        get_page(page);
-        }
-        return skb;
-}
 static int alx_refill_rx_ring(struct alx_priv *alx, gfp_t gfp)
 {
        struct alx_rx_queue *rxq = &alx->rxq;
@@ -115,9 +86,22 @@ static int alx_refill_rx_ring(struct alx_priv *alx, gfp_t gfp)
        while (!cur_buf->skb && next != rxq->read_idx) {
                struct alx_rfd *rfd = &rxq->rfd[cur];
-                skb = alx_alloc_skb(alx, gfp);
+                /*
+                 * When DMA RX address is set to something like
+                 * 0x....fc0, it will be very likely to cause DMA
+                 * RFD overflow issue.
+                 *
+                 * To work around it, we apply rx skb with 64 bytes
+                 * longer space, and offset the address whenever
+                 * 0x....fc0 is detected.
+                 */
+                skb = __netdev_alloc_skb(alx->dev, alx->rxbuf_size + 64, gfp);
                if (!skb)
                        break;
+                if (((unsigned long)skb->data & 0xfff) == 0xfc0)
+                        skb_reserve(skb, 64);
                dma = dma_map_single(&alx->hw.pdev->dev,
                                     skb->data, alx->rxbuf_size,
                                     DMA_FROM_DEVICE);
@@ -153,7 +137,6 @@ static int alx_refill_rx_ring(struct alx_priv *alx, gfp_t gfp)
                alx_write_mem16(&alx->hw, ALX_RFD_PIDX, cur);
        }
        return count;
 }
@@ -622,11 +605,6 @@ static void alx_free_rings(struct alx_priv *alx)
        kfree(alx->txq.bufs);
        kfree(alx->rxq.bufs);
-        if (alx->rx_page) {
-                put_page(alx->rx_page);
-                alx->rx_page = NULL;
-        }
        dma_free_coherent(&alx->hw.pdev->dev,
                          alx->descmem.size,
                          alx->descmem.virt,
@@ -681,7 +659,6 @@ static int alx_request_irq(struct alx_priv *alx)
                                  alx->dev->name, alx);
                if (!err)
                        goto out;
                /* fall back to legacy interrupt */
                pci_disable_msi(alx->hw.pdev);
        }
@@ -725,7 +702,6 @@ static int alx_init_sw(struct alx_priv *alx)
        struct pci_dev *pdev = alx->hw.pdev;
        struct alx_hw *hw = &alx->hw;
        int err;
-        unsigned int head_size;
        err = alx_identify_hw(alx);
        if (err) {
@@ -741,12 +717,7 @@ static int alx_init_sw(struct alx_priv *alx)
        hw->smb_timer = 400;
        hw->mtu = alx->dev->mtu;
        alx->rxbuf_size = ALX_MAX_FRAME_LEN(hw->mtu);
-        head_size = SKB_DATA_ALIGN(alx->rxbuf_size + NET_SKB_PAD) +
-                    SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
-        alx->rx_frag_size = roundup_pow_of_two(head_size);
        alx->tx_ringsz = 256;
        alx->rx_ringsz = 512;
        hw->imt = 200;
@@ -848,7 +819,6 @@ static int alx_change_mtu(struct net_device *netdev, int mtu)
 {
        struct alx_priv *alx = netdev_priv(netdev);
        int max_frame = ALX_MAX_FRAME_LEN(mtu);
-        unsigned int head_size;
        if ((max_frame < ALX_MIN_FRAME_SIZE) ||
            (max_frame > ALX_MAX_FRAME_SIZE))
@@ -860,9 +830,6 @@ static int alx_change_mtu(struct net_device *netdev, int mtu)
        netdev->mtu = mtu;
        alx->hw.mtu = mtu;
        alx->rxbuf_size = max(max_frame, ALX_DEF_RXBUF_SIZE);
-        head_size = SKB_DATA_ALIGN(alx->rxbuf_size + NET_SKB_PAD) +
-                    SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
-        alx->rx_frag_size = roundup_pow_of_two(head_size);
        netdev_update_features(netdev);
        if (netif_running(netdev))
                alx_reinit(alx);
diff --git a/drivers/net/ethernet/broadcom/bgmac.c b/drivers/net/ethernet/broadcom/bgmac.c
index ee5f431ab32a..a6333d38ecc0 100644
--- a/drivers/net/ethernet/broadcom/bgmac.c
+++ b/drivers/net/ethernet/broadcom/bgmac.c
@@ -267,15 +267,16 @@ static void bgmac_dma_tx_free(struct bgmac *bgmac, struct bgmac_dma_ring *ring)
        while (ring->start != ring->end) {
                int slot_idx = ring->start % BGMAC_TX_RING_SLOTS;
                struct bgmac_slot_info *slot = &ring->slots[slot_idx];
-                u32 ctl1;
+                u32 ctl0, ctl1;
                int len;
                if (slot_idx == empty_slot)
                        break;
+                ctl0 = le32_to_cpu(ring->cpu_base[slot_idx].ctl0);
                ctl1 = le32_to_cpu(ring->cpu_base[slot_idx].ctl1);
                len = ctl1 & BGMAC_DESC_CTL1_LEN;
-                if (ctl1 & BGMAC_DESC_CTL0_SOF)
+                if (ctl0 & BGMAC_DESC_CTL0_SOF)
                        /* Unmap no longer used buffer */
                        dma_unmap_single(dma_dev, slot->dma_addr, len,
                                         DMA_TO_DEVICE);
@@ -1312,7 +1313,8 @@ static int bgmac_open(struct net_device *net_dev)
        phy_start(bgmac->phy_dev);
-        netif_carrier_on(net_dev);
+        netif_start_queue(net_dev);
        return 0;
 }
diff --git a/drivers/net/ethernet/cavium/thunder/nic_main.c b/drivers/net/ethernet/cavium/thunder/nic_main.c
index 95f17f8cadac..16ed20357c5c 100644
--- a/drivers/net/ethernet/cavium/thunder/nic_main.c
+++ b/drivers/net/ethernet/cavium/thunder/nic_main.c
@@ -499,6 +499,7 @@ static void nic_tx_channel_cfg(struct nicpf *nic, u8 vnic,
        u32 rr_quantum;
        u8 sq_idx = sq->sq_num;
        u8 pqs_vnic;
+        int svf;
        if (sq->sqs_mode)
                pqs_vnic = nic->pqs_vf[vnic];
@@ -511,10 +512,19 @@ static void nic_tx_channel_cfg(struct nicpf *nic, u8 vnic,
        /* 24 bytes for FCS, IPG and preamble */
        rr_quantum = ((NIC_HW_MAX_FRS + 24) / 4);
-        tl4 = (lmac * NIC_TL4_PER_LMAC) + (bgx * NIC_TL4_PER_BGX);
+        if (!sq->sqs_mode) {
+                tl4 = (lmac * NIC_TL4_PER_LMAC) + (bgx * NIC_TL4_PER_BGX);
+        } else {
+                for (svf = 0; svf < MAX_SQS_PER_VF; svf++) {
+                        if (nic->vf_sqs[pqs_vnic][svf] == vnic)
+                                break;
+                }
+                tl4 = (MAX_LMAC_PER_BGX * NIC_TL4_PER_LMAC);
+                tl4 += (lmac * NIC_TL4_PER_LMAC * MAX_SQS_PER_VF);
+                tl4 += (svf * NIC_TL4_PER_LMAC);
+                tl4 += (bgx * NIC_TL4_PER_BGX);
+        }
        tl4 += sq_idx;
-        if (sq->sqs_mode)
-                tl4 += vnic * 8;
        tl3 = tl4 / (NIC_MAX_TL4 / NIC_MAX_TL3);
        nic_reg_write(nic, NIC_PF_QSET_0_127_SQ_0_7_CFG2 |
diff --git a/drivers/net/ethernet/cavium/thunder/thunder_bgx.c b/drivers/net/ethernet/cavium/thunder/thunder_bgx.c
index 3ed21988626b..63a39ac97d53 100644
--- a/drivers/net/ethernet/cavium/thunder/thunder_bgx.c
+++ b/drivers/net/ethernet/cavium/thunder/thunder_bgx.c
@@ -551,7 +551,9 @@ static int bgx_xaui_check_link(struct lmac *lmac)
        }
        /* Clear rcvflt bit (latching high) and read it back */
-        bgx_reg_modify(bgx, lmacid, BGX_SPUX_STATUS2, SPU_STATUS2_RCVFLT);
+        if (bgx_reg_read(bgx, lmacid, BGX_SPUX_STATUS2) & SPU_STATUS2_RCVFLT)
+                bgx_reg_modify(bgx, lmacid,
+                               BGX_SPUX_STATUS2, SPU_STATUS2_RCVFLT);
        if (bgx_reg_read(bgx, lmacid, BGX_SPUX_STATUS2) & SPU_STATUS2_RCVFLT) {
                dev_err(&bgx->pdev->dev, "Receive fault, retry training\n");
                if (bgx->use_training) {
@@ -570,13 +572,6 @@ static int bgx_xaui_check_link(struct lmac *lmac)
                return -1;
        }
-        /* Wait for MAC RX to be ready */
-        if (bgx_poll_reg(bgx, lmacid, BGX_SMUX_RX_CTL,
-                         SMU_RX_CTL_STATUS, true)) {
-                dev_err(&bgx->pdev->dev, "SMU RX link not okay\n");
-                return -1;
-        }
        /* Wait for BGX RX to be idle */
        if (bgx_poll_reg(bgx, lmacid, BGX_SMUX_CTL, SMU_CTL_RX_IDLE, false)) {
                dev_err(&bgx->pdev->dev, "SMU RX not idle\n");
@@ -589,29 +584,30 @@ static int bgx_xaui_check_link(struct lmac *lmac)
                return -1;
        }
-        if (bgx_reg_read(bgx, lmacid, BGX_SPUX_STATUS2) & SPU_STATUS2_RCVFLT) {
+        /* Clear receive packet disable */
-                dev_err(&bgx->pdev->dev, "Receive fault\n");
-                return -1;
-        }
-        /* Receive link is latching low. Force it high and verify it */
-        bgx_reg_modify(bgx, lmacid, BGX_SPUX_STATUS1, SPU_STATUS1_RCV_LNK);
-        if (bgx_poll_reg(bgx, lmacid, BGX_SPUX_STATUS1,
-                         SPU_STATUS1_RCV_LNK, false)) {
-                dev_err(&bgx->pdev->dev, "SPU receive link down\n");
-                return -1;
-        }
        cfg = bgx_reg_read(bgx, lmacid, BGX_SPUX_MISC_CONTROL);
        cfg &= ~SPU_MISC_CTL_RX_DIS;
        bgx_reg_write(bgx, lmacid, BGX_SPUX_MISC_CONTROL, cfg);
-        return 0;
+        /* Check for MAC RX faults */
+        cfg = bgx_reg_read(bgx, lmacid, BGX_SMUX_RX_CTL);
+        /* 0 - Link is okay, 1 - Local fault, 2 - Remote fault */
+        cfg &= SMU_RX_CTL_STATUS;
+        if (!cfg)
+                return 0;
+        /* Rx local/remote fault seen.
+         * Do lmac reinit to see if condition recovers
+         */
+        bgx_lmac_xaui_init(bgx, lmacid, bgx->lmac_type);
+        return -1;
 }
 static void bgx_poll_for_link(struct work_struct *work)
 {
        struct lmac *lmac;
-        u64 link;
+        u64 spu_link, smu_link;
        lmac = container_of(work, struct lmac, dwork.work);
@@ -621,8 +617,11 @@ static void bgx_poll_for_link(struct work_struct *work)
        bgx_poll_reg(lmac->bgx, lmac->lmacid, BGX_SPUX_STATUS1,
                     SPU_STATUS1_RCV_LNK, false);
-        link = bgx_reg_read(lmac->bgx, lmac->lmacid, BGX_SPUX_STATUS1);
+        spu_link = bgx_reg_read(lmac->bgx, lmac->lmacid, BGX_SPUX_STATUS1);
-        if (link & SPU_STATUS1_RCV_LNK) {
+        smu_link = bgx_reg_read(lmac->bgx, lmac->lmacid, BGX_SMUX_RX_CTL);
+        if ((spu_link & SPU_STATUS1_RCV_LNK) &&
+            !(smu_link & SMU_RX_CTL_STATUS)) {
                lmac->link_up = 1;
                if (lmac->bgx->lmac_type == BGX_MODE_XLAUI)
                        lmac->last_speed = 40000;
@@ -636,9 +635,15 @@ static void bgx_poll_for_link(struct work_struct *work)
        }
        if (lmac->last_link != lmac->link_up) {
+                if (lmac->link_up) {
+                        if (bgx_xaui_check_link(lmac)) {
+                                /* Errors, clear link_up state */
+                                lmac->link_up = 0;
+                                lmac->last_speed = SPEED_UNKNOWN;
+                                lmac->last_duplex = DUPLEX_UNKNOWN;
+                        }
+                }
                lmac->last_link = lmac->link_up;
-                if (lmac->link_up)
-                        bgx_xaui_check_link(lmac);
        }
        queue_delayed_work(lmac->check_link, &lmac->dwork, HZ * 2);
@@ -710,7 +715,7 @@ static int bgx_lmac_enable(struct bgx *bgx, u8 lmacid)
 static void bgx_lmac_disable(struct bgx *bgx, u8 lmacid)
 {
        struct lmac *lmac;
-        u64 cmrx_cfg;
+        u64 cfg;
        lmac = &bgx->lmac[lmacid];
        if (lmac->check_link) {
@@ -719,9 +724,33 @@ static void bgx_lmac_disable(struct bgx *bgx, u8 lmacid)
                destroy_workqueue(lmac->check_link);
        }
-        cmrx_cfg = bgx_reg_read(bgx, lmacid, BGX_CMRX_CFG);
+        /* Disable packet reception */
-        cmrx_cfg &= ~(1 << 15);
+        cfg = bgx_reg_read(bgx, lmacid, BGX_CMRX_CFG);
-        bgx_reg_write(bgx, lmacid, BGX_CMRX_CFG, cmrx_cfg);
+        cfg &= ~CMR_PKT_RX_EN;
+        bgx_reg_write(bgx, lmacid, BGX_CMRX_CFG, cfg);
+        /* Give chance for Rx/Tx FIFO to get drained */
+        bgx_poll_reg(bgx, lmacid, BGX_CMRX_RX_FIFO_LEN, (u64)0x1FFF, true);
+        bgx_poll_reg(bgx, lmacid, BGX_CMRX_TX_FIFO_LEN, (u64)0x3FFF, true);
+        /* Disable packet transmission */
+        cfg = bgx_reg_read(bgx, lmacid, BGX_CMRX_CFG);
+        cfg &= ~CMR_PKT_TX_EN;
+        bgx_reg_write(bgx, lmacid, BGX_CMRX_CFG, cfg);
+        /* Disable serdes lanes */
+        if (!lmac->is_sgmii)
+                bgx_reg_modify(bgx, lmacid,
+                               BGX_SPUX_CONTROL1, SPU_CTL_LOW_POWER);
+        else
+                bgx_reg_modify(bgx, lmacid,
+                               BGX_GMP_PCS_MRX_CTL, PCS_MRX_CTL_PWR_DN);
+        /* Disable LMAC */
+        cfg = bgx_reg_read(bgx, lmacid, BGX_CMRX_CFG);
+        cfg &= ~CMR_EN;
+        bgx_reg_write(bgx, lmacid, BGX_CMRX_CFG, cfg);
        bgx_flush_dmac_addrs(bgx, lmacid);
        if ((bgx->lmac_type != BGX_MODE_XFI) &&
diff --git a/drivers/net/ethernet/cavium/thunder/thunder_bgx.h b/drivers/net/ethernet/cavium/thunder/thunder_bgx.h
index 149e179363a1..42010d2e5ddf 100644
--- a/drivers/net/ethernet/cavium/thunder/thunder_bgx.h
+++ b/drivers/net/ethernet/cavium/thunder/thunder_bgx.h
@@ -41,6 +41,7 @@
 #define BGX_CMRX_RX_STAT10              0xC0
 #define BGX_CMRX_RX_BP_DROP             0xC8
 #define BGX_CMRX_RX_DMAC_CTL            0x0E8
+#define BGX_CMRX_RX_FIFO_LEN            0x108
 #define BGX_CMR_RX_DMACX_CAM            0x200
 #define  RX_DMACX_CAM_EN                        BIT_ULL(48)
 #define  RX_DMACX_CAM_LMACID(x)                 (x << 49)
@@ -50,6 +51,7 @@
 #define BGX_CMR_CHAN_MSK_AND            0x450
 #define BGX_CMR_BIST_STATUS             0x460
 #define BGX_CMR_RX_LMACS                0x468
+#define BGX_CMRX_TX_FIFO_LEN            0x518
 #define BGX_CMRX_TX_STAT0               0x600
 #define BGX_CMRX_TX_STAT1               0x608
 #define BGX_CMRX_TX_STAT2               0x610
diff --git a/drivers/net/ethernet/ibm/ibmvnic.c b/drivers/net/ethernet/ibm/ibmvnic.c
index 864cb21351a4..ecdb6854a898 100644
--- a/drivers/net/ethernet/ibm/ibmvnic.c
+++ b/drivers/net/ethernet/ibm/ibmvnic.c
@@ -2121,7 +2121,7 @@ static void handle_error_info_rsp(union ibmvnic_crq *crq,
                                  struct ibmvnic_adapter *adapter)
 {
        struct device *dev = &adapter->vdev->dev;
-        struct ibmvnic_error_buff *error_buff;
+        struct ibmvnic_error_buff *error_buff, *tmp;
        unsigned long flags;
        bool found = false;
        int i;
@@ -2133,7 +2133,7 @@ static void handle_error_info_rsp(union ibmvnic_crq *crq,
        }
        spin_lock_irqsave(&adapter->error_list_lock, flags);
-        list_for_each_entry(error_buff, &adapter->errors, list)
+        list_for_each_entry_safe(error_buff, tmp, &adapter->errors, list)
                if (error_buff->error_id == crq->request_error_rsp.error_id) {
                        found = true;
                        list_del(&error_buff->list);
@@ -3141,14 +3141,14 @@ static void handle_request_ras_comp_num_rsp(union ibmvnic_crq *crq,
 static void ibmvnic_free_inflight(struct ibmvnic_adapter *adapter)
 {
-        struct ibmvnic_inflight_cmd *inflight_cmd;
+        struct ibmvnic_inflight_cmd *inflight_cmd, *tmp1;
        struct device *dev = &adapter->vdev->dev;
-        struct ibmvnic_error_buff *error_buff;
+        struct ibmvnic_error_buff *error_buff, *tmp2;
        unsigned long flags;
        unsigned long flags2;
        spin_lock_irqsave(&adapter->inflight_lock, flags);
-        list_for_each_entry(inflight_cmd, &adapter->inflight, list) {
+        list_for_each_entry_safe(inflight_cmd, tmp1, &adapter->inflight, list) {
                switch (inflight_cmd->crq.generic.cmd) {
                case LOGIN:
                        dma_unmap_single(dev, adapter->login_buf_token,
@@ -3165,8 +3165,8 @@ static void ibmvnic_free_inflight(struct ibmvnic_adapter *adapter)
                        break;
                case REQUEST_ERROR_INFO:
                        spin_lock_irqsave(&adapter->error_list_lock, flags2);
-                        list_for_each_entry(error_buff, &adapter->errors,
+                        list_for_each_entry_safe(error_buff, tmp2,
-                                            list) {
+                                                 &adapter->errors, list) {
                                dma_unmap_single(dev, error_buff->dma,
                                                 error_buff->len,
                                                 DMA_FROM_DEVICE);
diff --git a/drivers/net/ethernet/intel/e1000e/netdev.c b/drivers/net/ethernet/intel/e1000e/netdev.c
index 75e60897b7e7..73f745205a1c 100644
--- a/drivers/net/ethernet/intel/e1000e/netdev.c
+++ b/drivers/net/ethernet/intel/e1000e/netdev.c
@@ -154,6 +154,16 @@ void __ew32(struct e1000_hw *hw, unsigned long reg, u32 val)
        writel(val, hw->hw_addr + reg);
 }
+static bool e1000e_vlan_used(struct e1000_adapter *adapter)
+{
+        u16 vid;
+        for_each_set_bit(vid, adapter->active_vlans, VLAN_N_VID)
+                return true;
+        return false;
+}
 /**
 * e1000_regdump - register printout routine
 * @hw: pointer to the HW structure
@@ -2789,7 +2799,7 @@ static void e1000e_vlan_filter_enable(struct e1000_adapter *adapter)
 }
 /**
- * e1000e_vlan_strip_enable - helper to disable HW VLAN stripping
+ * e1000e_vlan_strip_disable - helper to disable HW VLAN stripping
 * @adapter: board private structure to initialize
 **/
 static void e1000e_vlan_strip_disable(struct e1000_adapter *adapter)
@@ -3443,7 +3453,8 @@ static void e1000e_set_rx_mode(struct net_device *netdev)
        ew32(RCTL, rctl);
-        if (netdev->features & NETIF_F_HW_VLAN_CTAG_RX)
+        if (netdev->features & NETIF_F_HW_VLAN_CTAG_RX ||
+            e1000e_vlan_used(adapter))
                e1000e_vlan_strip_enable(adapter);
        else
                e1000e_vlan_strip_disable(adapter);
diff --git a/drivers/net/ethernet/mediatek/mtk_eth_soc.c b/drivers/net/ethernet/mediatek/mtk_eth_soc.c
index 4763252bbf85..d1cdc2d76151 100644
--- a/drivers/net/ethernet/mediatek/mtk_eth_soc.c
+++ b/drivers/net/ethernet/mediatek/mtk_eth_soc.c
@@ -481,20 +481,23 @@ static inline void mtk_rx_get_desc(struct mtk_rx_dma *rxd,
 /* the qdma core needs scratch memory to be setup */
 static int mtk_init_fq_dma(struct mtk_eth *eth)
 {
-        dma_addr_t phy_ring_head, phy_ring_tail;
+        dma_addr_t phy_ring_tail;
        int cnt = MTK_DMA_SIZE;
        dma_addr_t dma_addr;
        int i;
        eth->scratch_ring = dma_alloc_coherent(eth->dev,
                                               cnt * sizeof(struct mtk_tx_dma),
-                                               &phy_ring_head,
+                                               &eth->phy_scratch_ring,
                                               GFP_ATOMIC | __GFP_ZERO);
        if (unlikely(!eth->scratch_ring))
                return -ENOMEM;
        eth->scratch_head = kcalloc(cnt, MTK_QDMA_PAGE_SIZE,
                                    GFP_KERNEL);
+        if (unlikely(!eth->scratch_head))
+                return -ENOMEM;
        dma_addr = dma_map_single(eth->dev,
                                  eth->scratch_head, cnt * MTK_QDMA_PAGE_SIZE,
                                  DMA_FROM_DEVICE);
@@ -502,19 +505,19 @@ static int mtk_init_fq_dma(struct mtk_eth *eth)
                return -ENOMEM;
        memset(eth->scratch_ring, 0x0, sizeof(struct mtk_tx_dma) * cnt);
-        phy_ring_tail = phy_ring_head +
+        phy_ring_tail = eth->phy_scratch_ring +
                        (sizeof(struct mtk_tx_dma) * (cnt - 1));
        for (i = 0; i < cnt; i++) {
                eth->scratch_ring[i].txd1 =
                                        (dma_addr + (i * MTK_QDMA_PAGE_SIZE));
                if (i < cnt - 1)
-                        eth->scratch_ring[i].txd2 = (phy_ring_head +
+                        eth->scratch_ring[i].txd2 = (eth->phy_scratch_ring +
                                ((i + 1) * sizeof(struct mtk_tx_dma)));
                eth->scratch_ring[i].txd3 = TX_DMA_SDL(MTK_QDMA_PAGE_SIZE);
        }
-        mtk_w32(eth, phy_ring_head, MTK_QDMA_FQ_HEAD);
+        mtk_w32(eth, eth->phy_scratch_ring, MTK_QDMA_FQ_HEAD);
        mtk_w32(eth, phy_ring_tail, MTK_QDMA_FQ_TAIL);
        mtk_w32(eth, (cnt << 16) | cnt, MTK_QDMA_FQ_CNT);
        mtk_w32(eth, MTK_QDMA_PAGE_SIZE << 16, MTK_QDMA_FQ_BLEN);
@@ -671,7 +674,7 @@ static int mtk_tx_map(struct sk_buff *skb, struct net_device *dev,
 err_dma:
        do {
-                tx_buf = mtk_desc_to_tx_buf(ring, txd);
+                tx_buf = mtk_desc_to_tx_buf(ring, itxd);
                /* unmap dma */
                mtk_tx_unmap(&dev->dev, tx_buf);
@@ -701,6 +704,20 @@ static inline int mtk_cal_txd_req(struct sk_buff *skb)
        return nfrags;
 }
+static int mtk_queue_stopped(struct mtk_eth *eth)
+{
+        int i;
+        for (i = 0; i < MTK_MAC_COUNT; i++) {
+                if (!eth->netdev[i])
+                        continue;
+                if (netif_queue_stopped(eth->netdev[i]))
+                        return 1;
+        }
+        return 0;
+}
 static void mtk_wake_queue(struct mtk_eth *eth)
 {
        int i;
@@ -766,12 +783,9 @@ static int mtk_start_xmit(struct sk_buff *skb, struct net_device *dev)
        if (mtk_tx_map(skb, dev, tx_num, ring, gso) < 0)
                goto drop;
-        if (unlikely(atomic_read(&ring->free_count) <= ring->thresh)) {
+        if (unlikely(atomic_read(&ring->free_count) <= ring->thresh))
                mtk_stop_queue(eth);
-                if (unlikely(atomic_read(&ring->free_count) >
-                             ring->thresh))
-                        mtk_wake_queue(eth);
-        }
        spin_unlock_irqrestore(&eth->page_lock, flags);
        return NETDEV_TX_OK;
@@ -826,6 +840,7 @@ static int mtk_poll_rx(struct napi_struct *napi, int budget,
                                          DMA_FROM_DEVICE);
                if (unlikely(dma_mapping_error(&netdev->dev, dma_addr))) {
                        skb_free_frag(new_data);
+                        netdev->stats.rx_dropped++;
                        goto release_desc;
                }
@@ -833,6 +848,7 @@ static int mtk_poll_rx(struct napi_struct *napi, int budget,
                skb = build_skb(data, ring->frag_size);
                if (unlikely(!skb)) {
                        put_page(virt_to_head_page(new_data));
+                        netdev->stats.rx_dropped++;
                        goto release_desc;
                }
                skb_reserve(skb, NET_SKB_PAD + NET_IP_ALIGN);
@@ -921,7 +937,6 @@ static int mtk_poll_tx(struct mtk_eth *eth, int budget, bool *tx_again)
                }
                mtk_tx_unmap(eth->dev, tx_buf);
-                ring->last_free->txd2 = next_cpu;
                ring->last_free = desc;
                atomic_inc(&ring->free_count);
@@ -946,7 +961,8 @@ static int mtk_poll_tx(struct mtk_eth *eth, int budget, bool *tx_again)
        if (!total)
                return 0;
-        if (atomic_read(&ring->free_count) > ring->thresh)
+        if (mtk_queue_stopped(eth) &&
+            (atomic_read(&ring->free_count) > ring->thresh))
                mtk_wake_queue(eth);
        return total;
@@ -1027,9 +1043,8 @@ static int mtk_tx_alloc(struct mtk_eth *eth)
        atomic_set(&ring->free_count, MTK_DMA_SIZE - 2);
        ring->next_free = &ring->dma[0];
-        ring->last_free = &ring->dma[MTK_DMA_SIZE - 2];
+        ring->last_free = &ring->dma[MTK_DMA_SIZE - 1];
-        ring->thresh = max((unsigned long)MTK_DMA_SIZE >> 2,
+        ring->thresh = MAX_SKB_FRAGS;
-                              MAX_SKB_FRAGS);
        /* make sure that all changes to the dma ring are flushed before we
         * continue
@@ -1207,6 +1222,14 @@ static void mtk_dma_free(struct mtk_eth *eth)
        for (i = 0; i < MTK_MAC_COUNT; i++)
                if (eth->netdev[i])
                        netdev_reset_queue(eth->netdev[i]);
+        if (eth->scratch_ring) {
+                dma_free_coherent(eth->dev,
+                                  MTK_DMA_SIZE * sizeof(struct mtk_tx_dma),
+                                  eth->scratch_ring,
+                                  eth->phy_scratch_ring);
+                eth->scratch_ring = NULL;
+                eth->phy_scratch_ring = 0;
+        }
        mtk_tx_clean(eth);
        mtk_rx_clean(eth);
        kfree(eth->scratch_head);
@@ -1269,7 +1292,7 @@ static int mtk_start_dma(struct mtk_eth *eth)
        mtk_w32(eth,
                MTK_TX_WB_DDONE | MTK_RX_DMA_EN | MTK_TX_DMA_EN |
                MTK_RX_2B_OFFSET | MTK_DMA_SIZE_16DWORDS |
-                MTK_RX_BT_32DWORDS,
+                MTK_RX_BT_32DWORDS | MTK_NDP_CO_PRO,
                MTK_QDMA_GLO_CFG);
        return 0;
@@ -1383,7 +1406,7 @@ static int __init mtk_hw_init(struct mtk_eth *eth)
        /* disable delay and normal interrupt */
        mtk_w32(eth, 0, MTK_QDMA_DELAY_INT);
-        mtk_irq_disable(eth, MTK_TX_DONE_INT | MTK_RX_DONE_INT);
+        mtk_irq_disable(eth, ~0);
        mtk_w32(eth, RST_GL_PSE, MTK_RST_GL);
        mtk_w32(eth, 0, MTK_RST_GL);
@@ -1697,7 +1720,7 @@ static int mtk_add_mac(struct mtk_eth *eth, struct device_node *np)
        mac->hw_stats->reg_offset = id * MTK_STAT_OFFSET;
        SET_NETDEV_DEV(eth->netdev[id], eth->dev);
-        eth->netdev[id]->watchdog_timeo = HZ;
+        eth->netdev[id]->watchdog_timeo = 5 * HZ;
        eth->netdev[id]->netdev_ops = &mtk_netdev_ops;
        eth->netdev[id]->base_addr = (unsigned long)eth->base;
        eth->netdev[id]->vlan_features = MTK_HW_FEATURES &
diff --git a/drivers/net/ethernet/mediatek/mtk_eth_soc.h b/drivers/net/ethernet/mediatek/mtk_eth_soc.h
index eed626d56ea4..a5eb7c62306b 100644
--- a/drivers/net/ethernet/mediatek/mtk_eth_soc.h
+++ b/drivers/net/ethernet/mediatek/mtk_eth_soc.h
@@ -91,6 +91,7 @@
 #define MTK_QDMA_GLO_CFG        0x1A04
 #define MTK_RX_2B_OFFSET        BIT(31)
 #define MTK_RX_BT_32DWORDS      (3 << 11)
+#define MTK_NDP_CO_PRO          BIT(10)
 #define MTK_TX_WB_DDONE         BIT(6)
 #define MTK_DMA_SIZE_16DWORDS   (2 << 4)
 #define MTK_RX_DMA_BUSY         BIT(3)
@@ -357,6 +358,7 @@ struct mtk_rx_ring {
 * @rx_ring:            Pointer to the memore holding info about the RX ring
 * @rx_napi:            The NAPI struct
 * @scratch_ring:       Newer SoCs need memory for a second HW managed TX ring
+ * @phy_scratch_ring:   physical address of scratch_ring
 * @scratch_head:       The scratch memory that scratch_ring points to.
 * @clk_ethif:          The ethif clock
 * @clk_esw:            The switch clock
@@ -384,6 +386,7 @@ struct mtk_eth {
        struct mtk_rx_ring              rx_ring;
        struct napi_struct              rx_napi;
        struct mtk_tx_dma               *scratch_ring;
+        dma_addr_t                      phy_scratch_ring;
        void                            *scratch_head;
        struct clk                      *clk_ethif;
        struct clk                      *clk_esw;
diff --git a/drivers/net/ethernet/mellanox/mlx4/cmd.c b/drivers/net/ethernet/mellanox/mlx4/cmd.c
index e94ca1c3fc7c..f04a423ff79d 100644
--- a/drivers/net/ethernet/mellanox/mlx4/cmd.c
+++ b/drivers/net/ethernet/mellanox/mlx4/cmd.c
@@ -2597,7 +2597,6 @@ int mlx4_cmd_use_events(struct mlx4_dev *dev)
        priv->cmd.free_head = 0;
        sema_init(&priv->cmd.event_sem, priv->cmd.max_cmds);
-        spin_lock_init(&priv->cmd.context_lock);
        for (priv->cmd.token_mask = 1;
             priv->cmd.token_mask < priv->cmd.max_cmds;
diff --git a/drivers/net/ethernet/mellanox/mlx4/en_netdev.c b/drivers/net/ethernet/mellanox/mlx4/en_netdev.c
index 19ceced6736c..0c0dfd6cdca6 100644
--- a/drivers/net/ethernet/mellanox/mlx4/en_netdev.c
+++ b/drivers/net/ethernet/mellanox/mlx4/en_netdev.c
@@ -406,14 +406,18 @@ static int mlx4_en_vlan_rx_add_vid(struct net_device *dev,
        mutex_lock(&mdev->state_lock);
        if (mdev->device_up && priv->port_up) {
                err = mlx4_SET_VLAN_FLTR(mdev->dev, priv);
-                if (err)
+                if (err) {
                        en_err(priv, "Failed configuring VLAN filter\n");
+                        goto out;
+                }
        }
-        if (mlx4_register_vlan(mdev->dev, priv->port, vid, &idx))
+        err = mlx4_register_vlan(mdev->dev, priv->port, vid, &idx);
-                en_dbg(HW, priv, "failed adding vlan %d\n", vid);
+        if (err)
-        mutex_unlock(&mdev->state_lock);
+                en_dbg(HW, priv, "Failed adding vlan %d\n", vid);
-        return 0;
+out:
+        mutex_unlock(&mdev->state_lock);
+        return err;
 }
 static int mlx4_en_vlan_rx_kill_vid(struct net_device *dev,
@@ -421,7 +425,7 @@ static int mlx4_en_vlan_rx_kill_vid(struct net_device *dev,
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = priv->mdev;
-        int err;
+        int err = 0;
        en_dbg(HW, priv, "Killing VID:%d\n", vid);
@@ -438,7 +442,7 @@ static int mlx4_en_vlan_rx_kill_vid(struct net_device *dev,
        }
        mutex_unlock(&mdev->state_lock);
-        return 0;
+        return err;
 }
 static void mlx4_en_u64_to_mac(unsigned char dst_mac[ETH_ALEN + 2], u64 src_mac)
@@ -2032,11 +2036,20 @@ err:
        return -ENOMEM;
 }
+static void mlx4_en_shutdown(struct net_device *dev)
+{
+        rtnl_lock();
+        netif_device_detach(dev);
+        mlx4_en_close(dev);
+        rtnl_unlock();
+}
 void mlx4_en_destroy_netdev(struct net_device *dev)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = priv->mdev;
+        bool shutdown = mdev->dev->persist->interface_state &
+                                            MLX4_INTERFACE_STATE_SHUTDOWN;
        en_dbg(DRV, priv, "Destroying netdev on port:%d\n", priv->port);
@@ -2044,7 +2057,10 @@ void mlx4_en_destroy_netdev(struct net_device *dev)
        if (priv->registered) {
                devlink_port_type_clear(mlx4_get_devlink_port(mdev->dev,
                                                              priv->port));
-                unregister_netdev(dev);
+                if (shutdown)
+                        mlx4_en_shutdown(dev);
+                else
+                        unregister_netdev(dev);
        }
        if (priv->allocated)
@@ -2069,7 +2085,8 @@ void mlx4_en_destroy_netdev(struct net_device *dev)
        kfree(priv->tx_ring);
        kfree(priv->tx_cq);
-        free_netdev(dev);
+        if (!shutdown)
+                free_netdev(dev);
 }
 static int mlx4_en_change_mtu(struct net_device *dev, int new_mtu)
@@ -2447,9 +2464,14 @@ static netdev_features_t mlx4_en_features_check(struct sk_buff *skb,
         * strip that feature if this is an IPv6 encapsulated frame.
         */
        if (skb->encapsulation &&
-            (skb->ip_summed == CHECKSUM_PARTIAL) &&
+            (skb->ip_summed == CHECKSUM_PARTIAL)) {
-            (ip_hdr(skb)->version != 4))
+                struct mlx4_en_priv *priv = netdev_priv(dev);
-                features &= ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK);
+                if (!priv->vxlan_port ||
+                    (ip_hdr(skb)->version != 4) ||
+                    (udp_hdr(skb)->dest != priv->vxlan_port))
+                        features &= ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK);
+        }
        return features;
 }
diff --git a/drivers/net/ethernet/mellanox/mlx4/main.c b/drivers/net/ethernet/mellanox/mlx4/main.c
index 12c77a70abdb..546fab0ecc3b 100644
--- a/drivers/net/ethernet/mellanox/mlx4/main.c
+++ b/drivers/net/ethernet/mellanox/mlx4/main.c
@@ -3222,6 +3222,7 @@ static int mlx4_load_one(struct pci_dev *pdev, int pci_dev_data,
        INIT_LIST_HEAD(&priv->pgdir_list);
        mutex_init(&priv->pgdir_mutex);
+        spin_lock_init(&priv->cmd.context_lock);
        INIT_LIST_HEAD(&priv->bf_list);
        mutex_init(&priv->bf_mutex);
@@ -4134,8 +4135,11 @@ static void mlx4_shutdown(struct pci_dev *pdev)
        mlx4_info(persist->dev, "mlx4_shutdown was called\n");
        mutex_lock(&persist->interface_state_mutex);
-        if (persist->interface_state & MLX4_INTERFACE_STATE_UP)
+        if (persist->interface_state & MLX4_INTERFACE_STATE_UP) {
+                /* Notify mlx4 clients that the kernel is being shut down */
+                persist->interface_state |= MLX4_INTERFACE_STATE_SHUTDOWN;
                mlx4_unload_one(pdev);
+        }
        mutex_unlock(&persist->interface_state_mutex);
 }
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/cmd.c b/drivers/net/ethernet/mellanox/mlx5/core/cmd.c
index dcd2df6518de..0b4986268cc9 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/cmd.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/cmd.c
@@ -545,6 +545,7 @@ const char *mlx5_command_str(int command)
        MLX5_COMMAND_STR_CASE(ALLOC_FLOW_COUNTER);
        MLX5_COMMAND_STR_CASE(DEALLOC_FLOW_COUNTER);
        MLX5_COMMAND_STR_CASE(QUERY_FLOW_COUNTER);
+        MLX5_COMMAND_STR_CASE(MODIFY_FLOW_TABLE);
        default: return "unknown command opcode";
        }
 }
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en.h b/drivers/net/ethernet/mellanox/mlx5/core/en.h
index e8a6c3325b39..baa991a23475 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/en.h
+++ b/drivers/net/ethernet/mellanox/mlx5/core/en.h
@@ -401,7 +401,7 @@ enum mlx5e_traffic_types {
 };
 enum {
-        MLX5E_STATE_ASYNC_EVENTS_ENABLE,
+        MLX5E_STATE_ASYNC_EVENTS_ENABLED,
        MLX5E_STATE_OPENED,
        MLX5E_STATE_DESTROYING,
 };
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_ethtool.c b/drivers/net/ethernet/mellanox/mlx5/core/en_ethtool.c
index fc7dcc03b1de..e667a870e0c2 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/en_ethtool.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/en_ethtool.c
@@ -184,7 +184,9 @@ static unsigned long mlx5e_query_pfc_combined(struct mlx5e_priv *priv)
 #define MLX5E_NUM_SQ_STATS(priv) \
        (NUM_SQ_STATS * priv->params.num_channels * priv->params.num_tc * \
         test_bit(MLX5E_STATE_OPENED, &priv->state))
-#define MLX5E_NUM_PFC_COUNTERS(priv) hweight8(mlx5e_query_pfc_combined(priv))
+#define MLX5E_NUM_PFC_COUNTERS(priv) \
+        (hweight8(mlx5e_query_pfc_combined(priv)) * \
+         NUM_PPORT_PER_PRIO_PFC_COUNTERS)
 static int mlx5e_get_sset_count(struct net_device *dev, int sset)
 {
@@ -211,42 +213,41 @@ static void mlx5e_fill_stats_strings(struct mlx5e_priv *priv, uint8_t *data)
        /* SW counters */
        for (i = 0; i < NUM_SW_COUNTERS; i++)
-                strcpy(data + (idx++) * ETH_GSTRING_LEN, sw_stats_desc[i].name);
+                strcpy(data + (idx++) * ETH_GSTRING_LEN, sw_stats_desc[i].format);
        /* Q counters */
        for (i = 0; i < MLX5E_NUM_Q_CNTRS(priv); i++)
-                strcpy(data + (idx++) * ETH_GSTRING_LEN, q_stats_desc[i].name);
+                strcpy(data + (idx++) * ETH_GSTRING_LEN, q_stats_desc[i].format);
        /* VPORT counters */
        for (i = 0; i < NUM_VPORT_COUNTERS; i++)
                strcpy(data + (idx++) * ETH_GSTRING_LEN,
-                       vport_stats_desc[i].name);
+                       vport_stats_desc[i].format);
        /* PPORT counters */
        for (i = 0; i < NUM_PPORT_802_3_COUNTERS; i++)
                strcpy(data + (idx++) * ETH_GSTRING_LEN,
-                       pport_802_3_stats_desc[i].name);
+                       pport_802_3_stats_desc[i].format);
        for (i = 0; i < NUM_PPORT_2863_COUNTERS; i++)
                strcpy(data + (idx++) * ETH_GSTRING_LEN,
-                       pport_2863_stats_desc[i].name);
+                       pport_2863_stats_desc[i].format);
        for (i = 0; i < NUM_PPORT_2819_COUNTERS; i++)
                strcpy(data + (idx++) * ETH_GSTRING_LEN,
-                       pport_2819_stats_desc[i].name);
+                       pport_2819_stats_desc[i].format);
        for (prio = 0; prio < NUM_PPORT_PRIO; prio++) {
                for (i = 0; i < NUM_PPORT_PER_PRIO_TRAFFIC_COUNTERS; i++)
-                        sprintf(data + (idx++) * ETH_GSTRING_LEN, "prio%d_%s",
+                        sprintf(data + (idx++) * ETH_GSTRING_LEN,
-                                prio,
+                                pport_per_prio_traffic_stats_desc[i].format, prio);
-                                pport_per_prio_traffic_stats_desc[i].name);
        }
        pfc_combined = mlx5e_query_pfc_combined(priv);
        for_each_set_bit(prio, &pfc_combined, NUM_PPORT_PRIO) {
                for (i = 0; i < NUM_PPORT_PER_PRIO_PFC_COUNTERS; i++) {
-                        sprintf(data + (idx++) * ETH_GSTRING_LEN, "prio%d_%s",
+                        sprintf(data + (idx++) * ETH_GSTRING_LEN,
-                                prio, pport_per_prio_pfc_stats_desc[i].name);
+                                pport_per_prio_pfc_stats_desc[i].format, prio);
                }
        }
@@ -256,16 +257,15 @@ static void mlx5e_fill_stats_strings(struct mlx5e_priv *priv, uint8_t *data)
        /* per channel counters */
        for (i = 0; i < priv->params.num_channels; i++)
                for (j = 0; j < NUM_RQ_STATS; j++)
-                        sprintf(data + (idx++) * ETH_GSTRING_LEN, "rx%d_%s", i,
+                        sprintf(data + (idx++) * ETH_GSTRING_LEN,
-                                rq_stats_desc[j].name);
+                                rq_stats_desc[j].format, i);
        for (tc = 0; tc < priv->params.num_tc; tc++)
                for (i = 0; i < priv->params.num_channels; i++)
                        for (j = 0; j < NUM_SQ_STATS; j++)
                                sprintf(data + (idx++) * ETH_GSTRING_LEN,
-                                        "tx%d_%s",
+                                        sq_stats_desc[j].format,
-                                        priv->channeltc_to_txq_map[i][tc],
+                                        priv->channeltc_to_txq_map[i][tc]);
-                                        sq_stats_desc[j].name);
 }
 static void mlx5e_get_strings(struct net_device *dev,
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_main.c b/drivers/net/ethernet/mellanox/mlx5/core/en_main.c
index f5c8d5db25a8..cb6defd71fc1 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/en_main.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/en_main.c
@@ -105,11 +105,11 @@ static void mlx5e_update_sw_counters(struct mlx5e_priv *priv)
                s->rx_packets   += rq_stats->packets;
                s->rx_bytes     += rq_stats->bytes;
-                s->lro_packets  += rq_stats->lro_packets;
+                s->rx_lro_packets += rq_stats->lro_packets;
-                s->lro_bytes    += rq_stats->lro_bytes;
+                s->rx_lro_bytes += rq_stats->lro_bytes;
                s->rx_csum_none += rq_stats->csum_none;
-                s->rx_csum_sw   += rq_stats->csum_sw;
+                s->rx_csum_complete += rq_stats->csum_complete;
-                s->rx_csum_inner += rq_stats->csum_inner;
+                s->rx_csum_unnecessary_inner += rq_stats->csum_unnecessary_inner;
                s->rx_wqe_err   += rq_stats->wqe_err;
                s->rx_mpwqe_filler += rq_stats->mpwqe_filler;
                s->rx_mpwqe_frag   += rq_stats->mpwqe_frag;
@@ -122,24 +122,23 @@ static void mlx5e_update_sw_counters(struct mlx5e_priv *priv)
                        s->tx_packets           += sq_stats->packets;
                        s->tx_bytes             += sq_stats->bytes;
-                        s->tso_packets          += sq_stats->tso_packets;
+                        s->tx_tso_packets       += sq_stats->tso_packets;
-                        s->tso_bytes            += sq_stats->tso_bytes;
+                        s->tx_tso_bytes         += sq_stats->tso_bytes;
-                        s->tso_inner_packets    += sq_stats->tso_inner_packets;
+                        s->tx_tso_inner_packets += sq_stats->tso_inner_packets;
-                        s->tso_inner_bytes      += sq_stats->tso_inner_bytes;
+                        s->tx_tso_inner_bytes   += sq_stats->tso_inner_bytes;
                        s->tx_queue_stopped     += sq_stats->stopped;
                        s->tx_queue_wake        += sq_stats->wake;
                        s->tx_queue_dropped     += sq_stats->dropped;
-                        s->tx_csum_inner        += sq_stats->csum_offload_inner;
+                        s->tx_csum_partial_inner += sq_stats->csum_partial_inner;
-                        tx_offload_none         += sq_stats->csum_offload_none;
+                        tx_offload_none         += sq_stats->csum_none;
                }
        }
        /* Update calculated offload counters */
-        s->tx_csum_offload = s->tx_packets - tx_offload_none - s->tx_csum_inner;
+        s->tx_csum_partial = s->tx_packets - tx_offload_none - s->tx_csum_partial_inner;
-        s->rx_csum_good    = s->rx_packets - s->rx_csum_none -
+        s->rx_csum_unnecessary = s->rx_packets - s->rx_csum_none - s->rx_csum_complete;
-                             s->rx_csum_sw;
-        s->link_down_events = MLX5_GET(ppcnt_reg,
+        s->link_down_events_phy = MLX5_GET(ppcnt_reg,
                                priv->stats.pport.phy_counters,
                                counter_set.phys_layer_cntrs.link_down_events);
 }
@@ -244,7 +243,7 @@ static void mlx5e_async_event(struct mlx5_core_dev *mdev, void *vpriv,
 {
        struct mlx5e_priv *priv = vpriv;
-        if (!test_bit(MLX5E_STATE_ASYNC_EVENTS_ENABLE, &priv->state))
+        if (!test_bit(MLX5E_STATE_ASYNC_EVENTS_ENABLED, &priv->state))
                return;
        switch (event) {
@@ -260,12 +259,12 @@ static void mlx5e_async_event(struct mlx5_core_dev *mdev, void *vpriv,
 static void mlx5e_enable_async_events(struct mlx5e_priv *priv)
 {
-        set_bit(MLX5E_STATE_ASYNC_EVENTS_ENABLE, &priv->state);
+        set_bit(MLX5E_STATE_ASYNC_EVENTS_ENABLED, &priv->state);
 }
 static void mlx5e_disable_async_events(struct mlx5e_priv *priv)
 {
-        clear_bit(MLX5E_STATE_ASYNC_EVENTS_ENABLE, &priv->state);
+        clear_bit(MLX5E_STATE_ASYNC_EVENTS_ENABLED, &priv->state);
        synchronize_irq(mlx5_get_msix_vec(priv->mdev, MLX5_EQ_VEC_ASYNC));
 }
@@ -580,7 +579,7 @@ static int mlx5e_create_sq(struct mlx5e_channel *c,
        void *sqc_wq = MLX5_ADDR_OF(sqc, sqc, wq);
        int err;
-        err = mlx5_alloc_map_uar(mdev, &sq->uar, true);
+        err = mlx5_alloc_map_uar(mdev, &sq->uar, !!MLX5_CAP_GEN(mdev, bf));
        if (err)
                return err;
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_rx.c b/drivers/net/ethernet/mellanox/mlx5/core/en_rx.c
index bd947704b59c..022acc2e8922 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/en_rx.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/en_rx.c
@@ -689,7 +689,7 @@ static inline void mlx5e_handle_csum(struct net_device *netdev,
        if (is_first_ethertype_ip(skb)) {
                skb->ip_summed = CHECKSUM_COMPLETE;
                skb->csum = csum_unfold((__force __sum16)cqe->check_sum);
-                rq->stats.csum_sw++;
+                rq->stats.csum_complete++;
                return;
        }
@@ -699,7 +699,7 @@ static inline void mlx5e_handle_csum(struct net_device *netdev,
                if (cqe_is_tunneled(cqe)) {
                        skb->csum_level = 1;
                        skb->encapsulation = 1;
-                        rq->stats.csum_inner++;
+                        rq->stats.csum_unnecessary_inner++;
                }
                return;
        }
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_stats.h b/drivers/net/ethernet/mellanox/mlx5/core/en_stats.h
index 83bc32b25849..fcd490cc5610 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/en_stats.h
+++ b/drivers/net/ethernet/mellanox/mlx5/core/en_stats.h
@@ -42,9 +42,11 @@
        be64_to_cpu(*(__be32 *)((char *)ptr + dsc[i].offset))
 #define MLX5E_DECLARE_STAT(type, fld) #fld, offsetof(type, fld)
+#define MLX5E_DECLARE_RX_STAT(type, fld) "rx%d_"#fld, offsetof(type, fld)
+#define MLX5E_DECLARE_TX_STAT(type, fld) "tx%d_"#fld, offsetof(type, fld)
 struct counter_desc {
-        char            name[ETH_GSTRING_LEN];
+        char            format[ETH_GSTRING_LEN];
        int             offset; /* Byte offset */
 };
@@ -53,18 +55,18 @@ struct mlx5e_sw_stats {
        u64 rx_bytes;
        u64 tx_packets;
        u64 tx_bytes;
-        u64 tso_packets;
+        u64 tx_tso_packets;
-        u64 tso_bytes;
+        u64 tx_tso_bytes;
-        u64 tso_inner_packets;
+        u64 tx_tso_inner_packets;
-        u64 tso_inner_bytes;
+        u64 tx_tso_inner_bytes;
-        u64 lro_packets;
+        u64 rx_lro_packets;
-        u64 lro_bytes;
+        u64 rx_lro_bytes;
-        u64 rx_csum_good;
+        u64 rx_csum_unnecessary;
        u64 rx_csum_none;
-        u64 rx_csum_sw;
+        u64 rx_csum_complete;
-        u64 rx_csum_inner;
+        u64 rx_csum_unnecessary_inner;
-        u64 tx_csum_offload;
+        u64 tx_csum_partial;
-        u64 tx_csum_inner;
+        u64 tx_csum_partial_inner;
        u64 tx_queue_stopped;
        u64 tx_queue_wake;
        u64 tx_queue_dropped;
@@ -76,7 +78,7 @@ struct mlx5e_sw_stats {
        u64 rx_cqe_compress_pkts;
        /* Special handling counters */
-        u64 link_down_events;
+        u64 link_down_events_phy;
 };
 static const struct counter_desc sw_stats_desc[] = {
@@ -84,18 +86,18 @@ static const struct counter_desc sw_stats_desc[] = {
        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_bytes) },
        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_packets) },
        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_bytes) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tso_packets) },
+        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_tso_packets) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tso_bytes) },
+        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_tso_bytes) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tso_inner_packets) },
+        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_tso_inner_packets) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tso_inner_bytes) },
+        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_tso_inner_bytes) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, lro_packets) },
+        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_lro_packets) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, lro_bytes) },
+        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_lro_bytes) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_csum_good) },
+        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_csum_unnecessary) },
        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_csum_none) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_csum_sw) },
+        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_csum_complete) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_csum_inner) },
+        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_csum_unnecessary_inner) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_csum_offload) },
+        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_csum_partial) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_csum_inner) },
+        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_csum_partial_inner) },
        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_queue_stopped) },
        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_queue_wake) },
        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_queue_dropped) },
@@ -105,7 +107,7 @@ static const struct counter_desc sw_stats_desc[] = {
        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_buff_alloc_err) },
        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_cqe_compress_blks) },
        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_cqe_compress_pkts) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, link_down_events) },
+        { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, link_down_events_phy) },
 };
 struct mlx5e_qcounter_stats {
@@ -125,12 +127,6 @@ struct mlx5e_vport_stats {
 };
 static const struct counter_desc vport_stats_desc[] = {
-        { "rx_vport_error_packets",
-                VPORT_COUNTER_OFF(received_errors.packets) },
-        { "rx_vport_error_bytes", VPORT_COUNTER_OFF(received_errors.octets) },
-        { "tx_vport_error_packets",
-                VPORT_COUNTER_OFF(transmit_errors.packets) },
-        { "tx_vport_error_bytes", VPORT_COUNTER_OFF(transmit_errors.octets) },
        { "rx_vport_unicast_packets",
                VPORT_COUNTER_OFF(received_eth_unicast.packets) },
        { "rx_vport_unicast_bytes",
@@ -192,94 +188,68 @@ struct mlx5e_pport_stats {
 };
 static const struct counter_desc pport_802_3_stats_desc[] = {
-        { "frames_tx", PPORT_802_3_OFF(a_frames_transmitted_ok) },
+        { "tx_packets_phy", PPORT_802_3_OFF(a_frames_transmitted_ok) },
-        { "frames_rx", PPORT_802_3_OFF(a_frames_received_ok) },
+        { "rx_packets_phy", PPORT_802_3_OFF(a_frames_received_ok) },
-        { "check_seq_err", PPORT_802_3_OFF(a_frame_check_sequence_errors) },
+        { "rx_crc_errors_phy", PPORT_802_3_OFF(a_frame_check_sequence_errors) },
-        { "alignment_err", PPORT_802_3_OFF(a_alignment_errors) },
+        { "tx_bytes_phy", PPORT_802_3_OFF(a_octets_transmitted_ok) },
-        { "octets_tx", PPORT_802_3_OFF(a_octets_transmitted_ok) },
+        { "rx_bytes_phy", PPORT_802_3_OFF(a_octets_received_ok) },
-        { "octets_received", PPORT_802_3_OFF(a_octets_received_ok) },
+        { "tx_multicast_phy", PPORT_802_3_OFF(a_multicast_frames_xmitted_ok) },
-        { "multicast_xmitted", PPORT_802_3_OFF(a_multicast_frames_xmitted_ok) },
+        { "tx_broadcast_phy", PPORT_802_3_OFF(a_broadcast_frames_xmitted_ok) },
-        { "broadcast_xmitted", PPORT_802_3_OFF(a_broadcast_frames_xmitted_ok) },
+        { "rx_multicast_phy", PPORT_802_3_OFF(a_multicast_frames_received_ok) },
-        { "multicast_rx", PPORT_802_3_OFF(a_multicast_frames_received_ok) },
+        { "rx_broadcast_phy", PPORT_802_3_OFF(a_broadcast_frames_received_ok) },
-        { "broadcast_rx", PPORT_802_3_OFF(a_broadcast_frames_received_ok) },
+        { "rx_in_range_len_errors_phy", PPORT_802_3_OFF(a_in_range_length_errors) },
-        { "in_range_len_errors", PPORT_802_3_OFF(a_in_range_length_errors) },
+        { "rx_out_of_range_len_phy", PPORT_802_3_OFF(a_out_of_range_length_field) },
-        { "out_of_range_len", PPORT_802_3_OFF(a_out_of_range_length_field) },
+        { "rx_oversize_pkts_phy", PPORT_802_3_OFF(a_frame_too_long_errors) },
-        { "too_long_errors", PPORT_802_3_OFF(a_frame_too_long_errors) },
+        { "rx_symbol_err_phy", PPORT_802_3_OFF(a_symbol_error_during_carrier) },
-        { "symbol_err", PPORT_802_3_OFF(a_symbol_error_during_carrier) },
+        { "tx_mac_control_phy", PPORT_802_3_OFF(a_mac_control_frames_transmitted) },
-        { "mac_control_tx", PPORT_802_3_OFF(a_mac_control_frames_transmitted) },
+        { "rx_mac_control_phy", PPORT_802_3_OFF(a_mac_control_frames_received) },
-        { "mac_control_rx", PPORT_802_3_OFF(a_mac_control_frames_received) },
+        { "rx_unsupported_op_phy", PPORT_802_3_OFF(a_unsupported_opcodes_received) },
-        { "unsupported_op_rx",
+        { "rx_pause_ctrl_phy", PPORT_802_3_OFF(a_pause_mac_ctrl_frames_received) },
-                PPORT_802_3_OFF(a_unsupported_opcodes_received) },
+        { "tx_pause_ctrl_phy", PPORT_802_3_OFF(a_pause_mac_ctrl_frames_transmitted) },
-        { "pause_ctrl_rx", PPORT_802_3_OFF(a_pause_mac_ctrl_frames_received) },
-        { "pause_ctrl_tx",
-                PPORT_802_3_OFF(a_pause_mac_ctrl_frames_transmitted) },
 };
 static const struct counter_desc pport_2863_stats_desc[] = {
-        { "in_octets", PPORT_2863_OFF(if_in_octets) },
+        { "rx_discards_phy", PPORT_2863_OFF(if_in_discards) },
-        { "in_ucast_pkts", PPORT_2863_OFF(if_in_ucast_pkts) },
+        { "tx_discards_phy", PPORT_2863_OFF(if_out_discards) },
-        { "in_discards", PPORT_2863_OFF(if_in_discards) },
+        { "tx_errors_phy", PPORT_2863_OFF(if_out_errors) },
-        { "in_errors", PPORT_2863_OFF(if_in_errors) },
-        { "in_unknown_protos", PPORT_2863_OFF(if_in_unknown_protos) },
-        { "out_octets", PPORT_2863_OFF(if_out_octets) },
-        { "out_ucast_pkts", PPORT_2863_OFF(if_out_ucast_pkts) },
-        { "out_discards", PPORT_2863_OFF(if_out_discards) },
-        { "out_errors", PPORT_2863_OFF(if_out_errors) },
-        { "in_multicast_pkts", PPORT_2863_OFF(if_in_multicast_pkts) },
-        { "in_broadcast_pkts", PPORT_2863_OFF(if_in_broadcast_pkts) },
-        { "out_multicast_pkts", PPORT_2863_OFF(if_out_multicast_pkts) },
-        { "out_broadcast_pkts", PPORT_2863_OFF(if_out_broadcast_pkts) },
 };
 static const struct counter_desc pport_2819_stats_desc[] = {
-        { "drop_events", PPORT_2819_OFF(ether_stats_drop_events) },
+        { "rx_undersize_pkts_phy", PPORT_2819_OFF(ether_stats_undersize_pkts) },
-        { "octets", PPORT_2819_OFF(ether_stats_octets) },
+        { "rx_fragments_phy", PPORT_2819_OFF(ether_stats_fragments) },
-        { "pkts", PPORT_2819_OFF(ether_stats_pkts) },
+        { "rx_jabbers_phy", PPORT_2819_OFF(ether_stats_jabbers) },
-        { "broadcast_pkts", PPORT_2819_OFF(ether_stats_broadcast_pkts) },
+        { "rx_64_bytes_phy", PPORT_2819_OFF(ether_stats_pkts64octets) },
-        { "multicast_pkts", PPORT_2819_OFF(ether_stats_multicast_pkts) },
+        { "rx_65_to_127_bytes_phy", PPORT_2819_OFF(ether_stats_pkts65to127octets) },
-        { "crc_align_errors", PPORT_2819_OFF(ether_stats_crc_align_errors) },
+        { "rx_128_to_255_bytes_phy", PPORT_2819_OFF(ether_stats_pkts128to255octets) },
-        { "undersize_pkts", PPORT_2819_OFF(ether_stats_undersize_pkts) },
+        { "rx_256_to_511_bytes_phy", PPORT_2819_OFF(ether_stats_pkts256to511octets) },
-        { "oversize_pkts", PPORT_2819_OFF(ether_stats_oversize_pkts) },
+        { "rx_512_to_1023_bytes_phy", PPORT_2819_OFF(ether_stats_pkts512to1023octets) },
-        { "fragments", PPORT_2819_OFF(ether_stats_fragments) },
+        { "rx_1024_to_1518_bytes_phy", PPORT_2819_OFF(ether_stats_pkts1024to1518octets) },
-        { "jabbers", PPORT_2819_OFF(ether_stats_jabbers) },
+        { "rx_1519_to_2047_bytes_phy", PPORT_2819_OFF(ether_stats_pkts1519to2047octets) },
-        { "collisions", PPORT_2819_OFF(ether_stats_collisions) },
+        { "rx_2048_to_4095_bytes_phy", PPORT_2819_OFF(ether_stats_pkts2048to4095octets) },
-        { "p64octets", PPORT_2819_OFF(ether_stats_pkts64octets) },
+        { "rx_4096_to_8191_bytes_phy", PPORT_2819_OFF(ether_stats_pkts4096to8191octets) },
-        { "p65to127octets", PPORT_2819_OFF(ether_stats_pkts65to127octets) },
+        { "rx_8192_to_10239_bytes_phy", PPORT_2819_OFF(ether_stats_pkts8192to10239octets) },
-        { "p128to255octets", PPORT_2819_OFF(ether_stats_pkts128to255octets) },
-        { "p256to511octets", PPORT_2819_OFF(ether_stats_pkts256to511octets) },
-        { "p512to1023octets", PPORT_2819_OFF(ether_stats_pkts512to1023octets) },
-        { "p1024to1518octets",
-                PPORT_2819_OFF(ether_stats_pkts1024to1518octets) },
-        { "p1519to2047octets",
-                PPORT_2819_OFF(ether_stats_pkts1519to2047octets) },
-        { "p2048to4095octets",
-                PPORT_2819_OFF(ether_stats_pkts2048to4095octets) },
-        { "p4096to8191octets",
-                PPORT_2819_OFF(ether_stats_pkts4096to8191octets) },
-        { "p8192to10239octets",
-                PPORT_2819_OFF(ether_stats_pkts8192to10239octets) },
 };
 static const struct counter_desc pport_per_prio_traffic_stats_desc[] = {
-        { "rx_octets", PPORT_PER_PRIO_OFF(rx_octets) },
+        { "rx_prio%d_bytes", PPORT_PER_PRIO_OFF(rx_octets) },
-        { "rx_frames", PPORT_PER_PRIO_OFF(rx_frames) },
+        { "rx_prio%d_packets", PPORT_PER_PRIO_OFF(rx_frames) },
-        { "tx_octets", PPORT_PER_PRIO_OFF(tx_octets) },
+        { "tx_prio%d_bytes", PPORT_PER_PRIO_OFF(tx_octets) },
-        { "tx_frames", PPORT_PER_PRIO_OFF(tx_frames) },
+        { "tx_prio%d_packets", PPORT_PER_PRIO_OFF(tx_frames) },
 };
 static const struct counter_desc pport_per_prio_pfc_stats_desc[] = {
-        { "rx_pause", PPORT_PER_PRIO_OFF(rx_pause) },
+        { "rx_prio%d_pause", PPORT_PER_PRIO_OFF(rx_pause) },
-        { "rx_pause_duration", PPORT_PER_PRIO_OFF(rx_pause_duration) },
+        { "rx_prio%d_pause_duration", PPORT_PER_PRIO_OFF(rx_pause_duration) },
-        { "tx_pause", PPORT_PER_PRIO_OFF(tx_pause) },
+        { "tx_prio%d_pause", PPORT_PER_PRIO_OFF(tx_pause) },
-        { "tx_pause_duration", PPORT_PER_PRIO_OFF(tx_pause_duration) },
+        { "tx_prio%d_pause_duration", PPORT_PER_PRIO_OFF(tx_pause_duration) },
-        { "rx_pause_transition", PPORT_PER_PRIO_OFF(rx_pause_transition) },
+        { "rx_prio%d_pause_transition", PPORT_PER_PRIO_OFF(rx_pause_transition) },
 };
 struct mlx5e_rq_stats {
        u64 packets;
        u64 bytes;
-        u64 csum_sw;
+        u64 csum_complete;
-        u64 csum_inner;
+        u64 csum_unnecessary_inner;
        u64 csum_none;
        u64 lro_packets;
        u64 lro_bytes;
@@ -292,19 +262,19 @@ struct mlx5e_rq_stats {
 };
 static const struct counter_desc rq_stats_desc[] = {
-        { MLX5E_DECLARE_STAT(struct mlx5e_rq_stats, packets) },
+        { MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, packets) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_rq_stats, bytes) },
+        { MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, bytes) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_rq_stats, csum_sw) },
+        { MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, csum_complete) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_rq_stats, csum_inner) },
+        { MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, csum_unnecessary_inner) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_rq_stats, csum_none) },
+        { MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, csum_none) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_rq_stats, lro_packets) },
+        { MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, lro_packets) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_rq_stats, lro_bytes) },
+        { MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, lro_bytes) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_rq_stats, wqe_err) },
+        { MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, wqe_err) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_rq_stats, mpwqe_filler) },
+        { MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, mpwqe_filler) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_rq_stats, mpwqe_frag) },
+        { MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, mpwqe_frag) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_rq_stats, buff_alloc_err) },
+        { MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, buff_alloc_err) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_rq_stats, cqe_compress_blks) },
+        { MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, cqe_compress_blks) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_rq_stats, cqe_compress_pkts) },
+        { MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, cqe_compress_pkts) },
 };
 struct mlx5e_sq_stats {
@@ -315,28 +285,28 @@ struct mlx5e_sq_stats {
        u64 tso_bytes;
        u64 tso_inner_packets;
        u64 tso_inner_bytes;
-        u64 csum_offload_inner;
+        u64 csum_partial_inner;
        u64 nop;
        /* less likely accessed in data path */
-        u64 csum_offload_none;
+        u64 csum_none;
        u64 stopped;
        u64 wake;
        u64 dropped;
 };
 static const struct counter_desc sq_stats_desc[] = {
-        { MLX5E_DECLARE_STAT(struct mlx5e_sq_stats, packets) },
+        { MLX5E_DECLARE_TX_STAT(struct mlx5e_sq_stats, packets) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_sq_stats, bytes) },
+        { MLX5E_DECLARE_TX_STAT(struct mlx5e_sq_stats, bytes) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_sq_stats, tso_packets) },
+        { MLX5E_DECLARE_TX_STAT(struct mlx5e_sq_stats, tso_packets) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_sq_stats, tso_bytes) },
+        { MLX5E_DECLARE_TX_STAT(struct mlx5e_sq_stats, tso_bytes) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_sq_stats, tso_inner_packets) },
+        { MLX5E_DECLARE_TX_STAT(struct mlx5e_sq_stats, tso_inner_packets) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_sq_stats, tso_inner_bytes) },
+        { MLX5E_DECLARE_TX_STAT(struct mlx5e_sq_stats, tso_inner_bytes) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_sq_stats, csum_offload_inner) },
+        { MLX5E_DECLARE_TX_STAT(struct mlx5e_sq_stats, csum_partial_inner) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_sq_stats, nop) },
+        { MLX5E_DECLARE_TX_STAT(struct mlx5e_sq_stats, nop) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_sq_stats, csum_offload_none) },
+        { MLX5E_DECLARE_TX_STAT(struct mlx5e_sq_stats, csum_none) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_sq_stats, stopped) },
+        { MLX5E_DECLARE_TX_STAT(struct mlx5e_sq_stats, stopped) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_sq_stats, wake) },
+        { MLX5E_DECLARE_TX_STAT(struct mlx5e_sq_stats, wake) },
-        { MLX5E_DECLARE_STAT(struct mlx5e_sq_stats, dropped) },
+        { MLX5E_DECLARE_TX_STAT(struct mlx5e_sq_stats, dropped) },
 };
 #define NUM_SW_COUNTERS                 ARRAY_SIZE(sw_stats_desc)
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_tx.c b/drivers/net/ethernet/mellanox/mlx5/core/en_tx.c
index b000ddc29553..5a750b9cd006 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/en_tx.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/en_tx.c
@@ -192,12 +192,12 @@ static netdev_tx_t mlx5e_sq_xmit(struct mlx5e_sq *sq, struct sk_buff *skb)
                if (skb->encapsulation) {
                        eseg->cs_flags |= MLX5_ETH_WQE_L3_INNER_CSUM |
                                          MLX5_ETH_WQE_L4_INNER_CSUM;
-                        sq->stats.csum_offload_inner++;
+                        sq->stats.csum_partial_inner++;
                } else {
                        eseg->cs_flags |= MLX5_ETH_WQE_L4_CSUM;
                }
        } else
-                sq->stats.csum_offload_none++;
+                sq->stats.csum_none++;
        if (sq->cc != sq->prev_cc) {
                sq->prev_cc = sq->cc;
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/main.c b/drivers/net/ethernet/mellanox/mlx5/core/main.c
index a19b59348dd6..c65f4a13e17e 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/main.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/main.c
@@ -1508,8 +1508,9 @@ static const struct pci_device_id mlx5_core_pci_table[] = {
        { PCI_VDEVICE(MELLANOX, 0x1014), MLX5_PCI_DEV_IS_VF},   /* ConnectX-4 VF */
        { PCI_VDEVICE(MELLANOX, 0x1015) },                      /* ConnectX-4LX */
        { PCI_VDEVICE(MELLANOX, 0x1016), MLX5_PCI_DEV_IS_VF},   /* ConnectX-4LX VF */
-        { PCI_VDEVICE(MELLANOX, 0x1017) },                      /* ConnectX-5 */
+        { PCI_VDEVICE(MELLANOX, 0x1017) },                      /* ConnectX-5, PCIe 3.0 */
        { PCI_VDEVICE(MELLANOX, 0x1018), MLX5_PCI_DEV_IS_VF},   /* ConnectX-5 VF */
+        { PCI_VDEVICE(MELLANOX, 0x1019) },                      /* ConnectX-5, PCIe 4.0 */
        { 0, }
 };
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/vxlan.c b/drivers/net/ethernet/mellanox/mlx5/core/vxlan.c
index f2fd1ef16da7..05de77267d58 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/vxlan.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/vxlan.c
@@ -105,6 +105,9 @@ static void mlx5e_vxlan_add_port(struct work_struct *work)
        struct mlx5e_vxlan *vxlan;
        int err;
+        if (mlx5e_vxlan_lookup_port(priv, port))
+                goto free_work;
        if (mlx5e_vxlan_core_add_port_cmd(priv->mdev, port))
                goto free_work;
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/wq.c b/drivers/net/ethernet/mellanox/mlx5/core/wq.c
index ce21ee5b2357..821a087c7ae2 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/wq.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/wq.c
@@ -75,14 +75,14 @@ int mlx5_wq_cyc_create(struct mlx5_core_dev *mdev, struct mlx5_wq_param *param,
        err = mlx5_db_alloc_node(mdev, &wq_ctrl->db, param->db_numa_node);
        if (err) {
-                mlx5_core_warn(mdev, "mlx5_db_alloc() failed, %d\n", err);
+                mlx5_core_warn(mdev, "mlx5_db_alloc_node() failed, %d\n", err);
                return err;
        }
        err = mlx5_buf_alloc_node(mdev, mlx5_wq_cyc_get_byte_size(wq),
                                  &wq_ctrl->buf, param->buf_numa_node);
        if (err) {
-                mlx5_core_warn(mdev, "mlx5_buf_alloc() failed, %d\n", err);
+                mlx5_core_warn(mdev, "mlx5_buf_alloc_node() failed, %d\n", err);
                goto err_db_free;
        }
@@ -111,14 +111,14 @@ int mlx5_cqwq_create(struct mlx5_core_dev *mdev, struct mlx5_wq_param *param,
        err = mlx5_db_alloc_node(mdev, &wq_ctrl->db, param->db_numa_node);
        if (err) {
-                mlx5_core_warn(mdev, "mlx5_db_alloc() failed, %d\n", err);
+                mlx5_core_warn(mdev, "mlx5_db_alloc_node() failed, %d\n", err);
                return err;
        }
        err = mlx5_buf_alloc_node(mdev, mlx5_cqwq_get_byte_size(wq),
                                  &wq_ctrl->buf, param->buf_numa_node);
        if (err) {
-                mlx5_core_warn(mdev, "mlx5_buf_alloc() failed, %d\n", err);
+                mlx5_core_warn(mdev, "mlx5_buf_alloc_node() failed, %d\n", err);
                goto err_db_free;
        }
@@ -148,13 +148,14 @@ int mlx5_wq_ll_create(struct mlx5_core_dev *mdev, struct mlx5_wq_param *param,
        err = mlx5_db_alloc_node(mdev, &wq_ctrl->db, param->db_numa_node);
        if (err) {
-                mlx5_core_warn(mdev, "mlx5_db_alloc() failed, %d\n", err);
+                mlx5_core_warn(mdev, "mlx5_db_alloc_node() failed, %d\n", err);
                return err;
        }
-        err = mlx5_buf_alloc(mdev, mlx5_wq_ll_get_byte_size(wq), &wq_ctrl->buf);
+        err = mlx5_buf_alloc_node(mdev, mlx5_wq_ll_get_byte_size(wq),
+                                  &wq_ctrl->buf, param->buf_numa_node);
        if (err) {
-                mlx5_core_warn(mdev, "mlx5_buf_alloc() failed, %d\n", err);
+                mlx5_core_warn(mdev, "mlx5_buf_alloc_node() failed, %d\n", err);
                goto err_db_free;
        }
diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum.c b/drivers/net/ethernet/mellanox/mlxsw/spectrum.c
index 6f9e3ddff4a8..660429ebfbe1 100644
--- a/drivers/net/ethernet/mellanox/mlxsw/spectrum.c
+++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum.c
@@ -408,7 +408,11 @@ static netdev_tx_t mlxsw_sp_port_xmit(struct sk_buff *skb,
        }
        mlxsw_sp_txhdr_construct(skb, &tx_info);
-        len = skb->len;
+        /* TX header is consumed by HW on the way so we shouldn't count its
+         * bytes as being sent.
+         */
+        len = skb->len - MLXSW_TXHDR_LEN;
        /* Due to a race we might fail here because of a full queue. In that
         * unlikely case we simply drop the packet.
         */
diff --git a/drivers/net/ethernet/mellanox/mlxsw/switchx2.c b/drivers/net/ethernet/mellanox/mlxsw/switchx2.c
index 3842eab9449a..25f658b3849a 100644
--- a/drivers/net/ethernet/mellanox/mlxsw/switchx2.c
+++ b/drivers/net/ethernet/mellanox/mlxsw/switchx2.c
@@ -316,7 +316,10 @@ static netdev_tx_t mlxsw_sx_port_xmit(struct sk_buff *skb,
                }
        }
        mlxsw_sx_txhdr_construct(skb, &tx_info);
-        len = skb->len;
+        /* TX header is consumed by HW on the way so we shouldn't count its
+         * bytes as being sent.
+         */
+        len = skb->len - MLXSW_TXHDR_LEN;
        /* Due to a race we might fail here because of a full queue. In that
         * unlikely case we simply drop the packet.
         */
diff --git a/drivers/net/ethernet/netronome/nfp/nfp_net_common.c b/drivers/net/ethernet/netronome/nfp/nfp_net_common.c
index fa47c14c743a..ba26bb356b8d 100644
--- a/drivers/net/ethernet/netronome/nfp/nfp_net_common.c
+++ b/drivers/net/ethernet/netronome/nfp/nfp_net_common.c
@@ -2015,7 +2015,7 @@ static void nfp_net_open_stack(struct nfp_net *nn)
        netif_tx_wake_all_queues(nn->netdev);
-        enable_irq(nn->irq_entries[NFP_NET_CFG_LSC].vector);
+        enable_irq(nn->irq_entries[NFP_NET_IRQ_LSC_IDX].vector);
        nfp_net_read_link_status(nn);
 }
@@ -2044,7 +2044,7 @@ static int nfp_net_netdev_open(struct net_device *netdev)
                                      NFP_NET_IRQ_LSC_IDX, nn->lsc_handler);
        if (err)
                goto err_free_exn;
-        disable_irq(nn->irq_entries[NFP_NET_CFG_LSC].vector);
+        disable_irq(nn->irq_entries[NFP_NET_IRQ_LSC_IDX].vector);
        nn->rx_rings = kcalloc(nn->num_rx_rings, sizeof(*nn->rx_rings),
                               GFP_KERNEL);
@@ -2133,7 +2133,7 @@ static void nfp_net_close_stack(struct nfp_net *nn)
 {
        unsigned int r;
-        disable_irq(nn->irq_entries[NFP_NET_CFG_LSC].vector);
+        disable_irq(nn->irq_entries[NFP_NET_IRQ_LSC_IDX].vector);
        netif_carrier_off(nn->netdev);
        nn->link_up = false;
diff --git a/drivers/net/ethernet/qlogic/qed/qed_hsi.h b/drivers/net/ethernet/qlogic/qed/qed_hsi.h
index 9afc15fdbb02..e29ed5a69566 100644
--- a/drivers/net/ethernet/qlogic/qed/qed_hsi.h
+++ b/drivers/net/ethernet/qlogic/qed/qed_hsi.h
@@ -3700,6 +3700,7 @@ struct public_port {
 #define MEDIA_DA_TWINAX         0x3
 #define MEDIA_BASE_T            0x4
 #define MEDIA_SFP_1G_FIBER      0x5
+#define MEDIA_MODULE_FIBER      0x6
 #define MEDIA_KR                0xf0
 #define MEDIA_NOT_PRESENT       0xff
diff --git a/drivers/net/ethernet/qlogic/qed/qed_l2.c b/drivers/net/ethernet/qlogic/qed/qed_l2.c
index 8fba87dd48af..aada4c7e095f 100644
--- a/drivers/net/ethernet/qlogic/qed/qed_l2.c
+++ b/drivers/net/ethernet/qlogic/qed/qed_l2.c
@@ -72,6 +72,7 @@ int qed_sp_eth_vport_start(struct qed_hwfn *p_hwfn,
        p_ramrod->mtu                   = cpu_to_le16(p_params->mtu);
        p_ramrod->inner_vlan_removal_en = p_params->remove_inner_vlan;
        p_ramrod->drop_ttl0_en          = p_params->drop_ttl0;
+        p_ramrod->untagged              = p_params->only_untagged;
        SET_FIELD(rx_mode, ETH_VPORT_RX_MODE_UCAST_DROP_ALL, 1);
        SET_FIELD(rx_mode, ETH_VPORT_RX_MODE_MCAST_DROP_ALL, 1);
@@ -247,10 +248,6 @@ qed_sp_update_accept_mode(struct qed_hwfn *p_hwfn,
                SET_FIELD(state, ETH_VPORT_TX_MODE_UCAST_DROP_ALL,
                          !!(accept_filter & QED_ACCEPT_NONE));
-                SET_FIELD(state, ETH_VPORT_TX_MODE_UCAST_ACCEPT_ALL,
-                          (!!(accept_filter & QED_ACCEPT_UCAST_MATCHED) &&
-                           !!(accept_filter & QED_ACCEPT_UCAST_UNMATCHED)));
                SET_FIELD(state, ETH_VPORT_TX_MODE_MCAST_DROP_ALL,
                          !!(accept_filter & QED_ACCEPT_NONE));
@@ -1748,7 +1745,8 @@ static int qed_start_vport(struct qed_dev *cdev,
                           start.vport_id, start.mtu);
        }
-        qed_reset_vport_stats(cdev);
+        if (params->clear_stats)
+                qed_reset_vport_stats(cdev);
        return 0;
 }
diff --git a/drivers/net/ethernet/qlogic/qed/qed_main.c b/drivers/net/ethernet/qlogic/qed/qed_main.c
index 61cc6869fa65..c7e01b303540 100644
--- a/drivers/net/ethernet/qlogic/qed/qed_main.c
+++ b/drivers/net/ethernet/qlogic/qed/qed_main.c
@@ -1085,6 +1085,7 @@ static int qed_get_port_type(u32 media_type)
        case MEDIA_SFPP_10G_FIBER:
        case MEDIA_SFP_1G_FIBER:
        case MEDIA_XFP_FIBER:
+        case MEDIA_MODULE_FIBER:
        case MEDIA_KR:
                port_type = PORT_FIBRE;
                break;
diff --git a/drivers/net/ethernet/qlogic/qed/qed_spq.c b/drivers/net/ethernet/qlogic/qed/qed_spq.c
index acac6626a1b2..b122f6013b6c 100644
--- a/drivers/net/ethernet/qlogic/qed/qed_spq.c
+++ b/drivers/net/ethernet/qlogic/qed/qed_spq.c
@@ -213,19 +213,15 @@ static int qed_spq_hw_post(struct qed_hwfn *p_hwfn,
        SET_FIELD(db.params, CORE_DB_DATA_AGG_VAL_SEL,
                  DQ_XCM_CORE_SPQ_PROD_CMD);
        db.agg_flags = DQ_XCM_CORE_DQ_CF_CMD;
-        /* validate producer is up to-date */
-        rmb();
        db.spq_prod = cpu_to_le16(qed_chain_get_prod_idx(p_chain));
-        /* do not reorder */
+        /* make sure the SPQE is updated before the doorbell */
-        barrier();
+        wmb();
        DOORBELL(p_hwfn, qed_db_addr(p_spq->cid, DQ_DEMS_LEGACY), *(u32 *)&db);
        /* make sure doorbell is rang */
-        mmiowb();
+        wmb();
        DP_VERBOSE(p_hwfn, QED_MSG_SPQ,
                   "Doorbelled [0x%08x, CID 0x%08x] with Flags: %02x agg_params: %02x, prod: %04x\n",
@@ -614,7 +610,9 @@ qed_spq_add_entry(struct qed_hwfn *p_hwfn,
                        *p_en2 = *p_ent;
-                        kfree(p_ent);
+                        /* EBLOCK responsible to free the allocated p_ent */
+                        if (p_ent->comp_mode != QED_SPQ_MODE_EBLOCK)
+                                kfree(p_ent);
                        p_ent = p_en2;
                }
@@ -749,6 +747,15 @@ int qed_spq_post(struct qed_hwfn *p_hwfn,
                 * Thus, after gaining the answer perform the cleanup here.
                 */
                rc = qed_spq_block(p_hwfn, p_ent, fw_return_code);
+                if (p_ent->queue == &p_spq->unlimited_pending) {
+                        /* This is an allocated p_ent which does not need to
+                         * return to pool.
+                         */
+                        kfree(p_ent);
+                        return rc;
+                }
                if (rc)
                        goto spq_post_fail2;
@@ -844,8 +851,12 @@ int qed_spq_completion(struct qed_hwfn *p_hwfn,
                found->comp_cb.function(p_hwfn, found->comp_cb.cookie, p_data,
                                        fw_return_code);
-        if (found->comp_mode != QED_SPQ_MODE_EBLOCK)
+        if ((found->comp_mode != QED_SPQ_MODE_EBLOCK) ||
-                /* EBLOCK is responsible for freeing its own entry */
+            (found->queue == &p_spq->unlimited_pending))
+                /* EBLOCK  is responsible for returning its own entry into the
+                 * free list, unless it originally added the entry into the
+                 * unlimited pending list.
+                 */
                qed_spq_return_entry(p_hwfn, found);
        /* Attempt to post pending requests */
diff --git a/drivers/net/ethernet/qlogic/qede/qede_main.c b/drivers/net/ethernet/qlogic/qede/qede_main.c
index 5733d1888223..f8e11f953acb 100644
--- a/drivers/net/ethernet/qlogic/qede/qede_main.c
+++ b/drivers/net/ethernet/qlogic/qede/qede_main.c
@@ -3231,7 +3231,7 @@ static int qede_stop_queues(struct qede_dev *edev)
        return rc;
 }
-static int qede_start_queues(struct qede_dev *edev)
+static int qede_start_queues(struct qede_dev *edev, bool clear_stats)
 {
        int rc, tc, i;
        int vlan_removal_en = 1;
@@ -3462,6 +3462,7 @@ out:
 enum qede_load_mode {
        QEDE_LOAD_NORMAL,
+        QEDE_LOAD_RELOAD,
 };
 static int qede_load(struct qede_dev *edev, enum qede_load_mode mode)
@@ -3500,7 +3501,7 @@ static int qede_load(struct qede_dev *edev, enum qede_load_mode mode)
                goto err3;
        DP_INFO(edev, "Setup IRQs succeeded\n");
-        rc = qede_start_queues(edev);
+        rc = qede_start_queues(edev, mode != QEDE_LOAD_RELOAD);
        if (rc)
                goto err4;
        DP_INFO(edev, "Start VPORT, RXQ and TXQ succeeded\n");
@@ -3555,7 +3556,7 @@ void qede_reload(struct qede_dev *edev,
        if (func)
                func(edev, args);
-        qede_load(edev, QEDE_LOAD_NORMAL);
+        qede_load(edev, QEDE_LOAD_RELOAD);
        mutex_lock(&edev->qede_lock);
        qede_config_rx_mode(edev->ndev);
diff --git a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_io.c b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_io.c
index 7bd6f25b4625..607bb7d4514d 100644
--- a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_io.c
+++ b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_io.c
@@ -2220,7 +2220,7 @@ void qlcnic_83xx_process_rcv_ring_diag(struct qlcnic_host_sds_ring *sds_ring)
        if (!opcode)
                return;
-        ring = QLCNIC_FETCH_RING_ID(qlcnic_83xx_hndl(sts_data[0]));
+        ring = QLCNIC_FETCH_RING_ID(sts_data[0]);
        qlcnic_83xx_process_rcv_diag(adapter, ring, sts_data);
        desc = &sds_ring->desc_head[consumer];
        desc->status_desc_data[0] = cpu_to_le64(STATUS_OWNER_PHANTOM);
diff --git a/drivers/net/ethernet/sfc/farch.c b/drivers/net/ethernet/sfc/farch.c
index 133e9e35be9e..4c83739d158f 100644
--- a/drivers/net/ethernet/sfc/farch.c
+++ b/drivers/net/ethernet/sfc/farch.c
@@ -104,7 +104,8 @@ int efx_farch_test_registers(struct efx_nic *efx,
                             const struct efx_farch_register_test *regs,
                             size_t n_regs)
 {
-        unsigned address = 0, i, j;
+        unsigned address = 0;
+        int i, j;
        efx_oword_t mask, imask, original, reg, buf;
        for (i = 0; i < n_regs; ++i) {
diff --git a/drivers/net/ethernet/smsc/smsc911x.c b/drivers/net/ethernet/smsc/smsc911x.c
index 8af25563f627..b5ab5e120bca 100644
--- a/drivers/net/ethernet/smsc/smsc911x.c
+++ b/drivers/net/ethernet/smsc/smsc911x.c
@@ -116,7 +116,6 @@ struct smsc911x_data {
        struct phy_device *phy_dev;
        struct mii_bus *mii_bus;
-        int phy_irq[PHY_MAX_ADDR];
        unsigned int using_extphy;
        int last_duplex;
        int last_carrier;
@@ -1073,7 +1072,6 @@ static int smsc911x_mii_init(struct platform_device *pdev,
        pdata->mii_bus->priv = pdata;
        pdata->mii_bus->read = smsc911x_mii_read;
        pdata->mii_bus->write = smsc911x_mii_write;
-        memcpy(pdata->mii_bus->irq, pdata->phy_irq, sizeof(pdata->mii_bus));
        pdata->mii_bus->parent = &pdev->dev;
diff --git a/drivers/net/ethernet/ti/cpsw.c b/drivers/net/ethernet/ti/cpsw.c
index e6bb0ecb12c7..53190894f17a 100644
--- a/drivers/net/ethernet/ti/cpsw.c
+++ b/drivers/net/ethernet/ti/cpsw.c
@@ -2505,8 +2505,6 @@ static int cpsw_probe(struct platform_device *pdev)
 clean_ale_ret:
        cpsw_ale_destroy(priv->ale);
 clean_dma_ret:
-        cpdma_chan_destroy(priv->txch);
-        cpdma_chan_destroy(priv->rxch);
        cpdma_ctlr_destroy(priv->dma);
 clean_runtime_disable_ret:
        pm_runtime_disable(&pdev->dev);
@@ -2534,8 +2532,6 @@ static int cpsw_remove(struct platform_device *pdev)
        unregister_netdev(ndev);
        cpsw_ale_destroy(priv->ale);
-        cpdma_chan_destroy(priv->txch);
-        cpdma_chan_destroy(priv->rxch);
        cpdma_ctlr_destroy(priv->dma);
        pm_runtime_disable(&pdev->dev);
        device_for_each_child(&pdev->dev, NULL, cpsw_remove_child_device);
diff --git a/drivers/net/ethernet/tile/tilegx.c b/drivers/net/ethernet/tile/tilegx.c
index 0a15acc075b3..11213a38c795 100644
--- a/drivers/net/ethernet/tile/tilegx.c
+++ b/drivers/net/ethernet/tile/tilegx.c
@@ -462,7 +462,7 @@ static void tile_tx_timestamp(struct sk_buff *skb, int instance)
        if (unlikely((shtx->tx_flags & SKBTX_HW_TSTAMP) != 0)) {
                struct mpipe_data *md = &mpipe_data[instance];
                struct skb_shared_hwtstamps shhwtstamps;
-                struct timespec ts;
+                struct timespec64 ts;
                shtx->tx_flags |= SKBTX_IN_PROGRESS;
                gxio_mpipe_get_timestamp(&md->context, &ts);
@@ -886,9 +886,9 @@ static struct ptp_clock_info ptp_mpipe_caps = {
 /* Sync mPIPE's timestamp up with Linux system time and register PTP clock. */
 static void register_ptp_clock(struct net_device *dev, struct mpipe_data *md)
 {
-        struct timespec ts;
+        struct timespec64 ts;
-        getnstimeofday(&ts);
+        ktime_get_ts64(&ts);
        gxio_mpipe_set_timestamp(&md->context, &ts);
        mutex_init(&md->ptp_lock);
diff --git a/drivers/net/fddi/skfp/Makefile b/drivers/net/fddi/skfp/Makefile
index b0be0234abf6..a957a1c7e5ba 100644
--- a/drivers/net/fddi/skfp/Makefile
+++ b/drivers/net/fddi/skfp/Makefile
@@ -17,4 +17,4 @@ skfp-objs :=  skfddi.o    hwmtm.o    fplustm.o  smt.o      cfm.o     \
 #   projects. To keep the source common for all those drivers (and
 #   thus simplify fixes to it), please do not clean it up!
-ccflags-y := -Idrivers/net/skfp -DPCI -DMEM_MAPPED_IO -Wno-strict-prototypes
+ccflags-y := -DPCI -DMEM_MAPPED_IO -Wno-strict-prototypes
diff --git a/drivers/net/geneve.c b/drivers/net/geneve.c
index cadefe4fdaa2..cc39cefeae45 100644
--- a/drivers/net/geneve.c
+++ b/drivers/net/geneve.c
@@ -958,8 +958,8 @@ tx_error:
                dev->stats.collisions++;
        else if (err == -ENETUNREACH)
                dev->stats.tx_carrier_errors++;
-        else
-                dev->stats.tx_errors++;
+        dev->stats.tx_errors++;
        return NETDEV_TX_OK;
 }
@@ -1048,8 +1048,8 @@ tx_error:
                dev->stats.collisions++;
        else if (err == -ENETUNREACH)
                dev->stats.tx_carrier_errors++;
-        else
-                dev->stats.tx_errors++;
+        dev->stats.tx_errors++;
        return NETDEV_TX_OK;
 }
 #endif
@@ -1508,6 +1508,7 @@ struct net_device *geneve_dev_create_fb(struct net *net, const char *name,
 {
        struct nlattr *tb[IFLA_MAX + 1];
        struct net_device *dev;
+        LIST_HEAD(list_kill);
        int err;
        memset(tb, 0, sizeof(tb));
@@ -1519,8 +1520,10 @@ struct net_device *geneve_dev_create_fb(struct net *net, const char *name,
        err = geneve_configure(net, dev, &geneve_remote_unspec,
                               0, 0, 0, 0, htons(dst_port), true,
                               GENEVE_F_UDP_ZERO_CSUM6_RX);
-        if (err)
+        if (err) {
-                goto err;
+                free_netdev(dev);
+                return ERR_PTR(err);
+        }
        /* openvswitch users expect packet sizes to be unrestricted,
         * so set the largest MTU we can.
@@ -1529,10 +1532,15 @@ struct net_device *geneve_dev_create_fb(struct net *net, const char *name,
        if (err)
                goto err;
+        err = rtnl_configure_link(dev, NULL);
+        if (err < 0)
+                goto err;
        return dev;
 err:
-        free_netdev(dev);
+        geneve_dellink(dev, &list_kill);
+        unregister_netdevice_many(&list_kill);
        return ERR_PTR(err);
 }
 EXPORT_SYMBOL_GPL(geneve_dev_create_fb);
diff --git a/drivers/net/macsec.c b/drivers/net/macsec.c
index 47ee2c840b55..0e7eff7f1cd2 100644
--- a/drivers/net/macsec.c
+++ b/drivers/net/macsec.c
@@ -605,12 +605,41 @@ static void macsec_encrypt_done(struct crypto_async_request *base, int err)
        dev_put(dev);
 }
+static struct aead_request *macsec_alloc_req(struct crypto_aead *tfm,
+                                             unsigned char **iv,
+                                             struct scatterlist **sg)
+{
+        size_t size, iv_offset, sg_offset;
+        struct aead_request *req;
+        void *tmp;
+        size = sizeof(struct aead_request) + crypto_aead_reqsize(tfm);
+        iv_offset = size;
+        size += GCM_AES_IV_LEN;
+        size = ALIGN(size, __alignof__(struct scatterlist));
+        sg_offset = size;
+        size += sizeof(struct scatterlist) * (MAX_SKB_FRAGS + 1);
+        tmp = kmalloc(size, GFP_ATOMIC);
+        if (!tmp)
+                return NULL;
+        *iv = (unsigned char *)(tmp + iv_offset);
+        *sg = (struct scatterlist *)(tmp + sg_offset);
+        req = tmp;
+        aead_request_set_tfm(req, tfm);
+        return req;
+}
 static struct sk_buff *macsec_encrypt(struct sk_buff *skb,
                                      struct net_device *dev)
 {
        int ret;
-        struct scatterlist sg[MAX_SKB_FRAGS + 1];
+        struct scatterlist *sg;
-        unsigned char iv[GCM_AES_IV_LEN];
+        unsigned char *iv;
        struct ethhdr *eth;
        struct macsec_eth_header *hh;
        size_t unprotected_len;
@@ -668,8 +697,6 @@ static struct sk_buff *macsec_encrypt(struct sk_buff *skb,
        macsec_fill_sectag(hh, secy, pn);
        macsec_set_shortlen(hh, unprotected_len - 2 * ETH_ALEN);
-        macsec_fill_iv(iv, secy->sci, pn);
        skb_put(skb, secy->icv_len);
        if (skb->len - ETH_HLEN > macsec_priv(dev)->real_dev->mtu) {
@@ -684,13 +711,15 @@ static struct sk_buff *macsec_encrypt(struct sk_buff *skb,
                return ERR_PTR(-EINVAL);
        }
-        req = aead_request_alloc(tx_sa->key.tfm, GFP_ATOMIC);
+        req = macsec_alloc_req(tx_sa->key.tfm, &iv, &sg);
        if (!req) {
                macsec_txsa_put(tx_sa);
                kfree_skb(skb);
                return ERR_PTR(-ENOMEM);
        }
+        macsec_fill_iv(iv, secy->sci, pn);
        sg_init_table(sg, MAX_SKB_FRAGS + 1);
        skb_to_sgvec(skb, sg, 0, skb->len);
@@ -861,7 +890,6 @@ static void macsec_decrypt_done(struct crypto_async_request *base, int err)
 out:
        macsec_rxsa_put(rx_sa);
        dev_put(dev);
-        return;
 }
 static struct sk_buff *macsec_decrypt(struct sk_buff *skb,
@@ -871,8 +899,8 @@ static struct sk_buff *macsec_decrypt(struct sk_buff *skb,
                                      struct macsec_secy *secy)
 {
        int ret;
-        struct scatterlist sg[MAX_SKB_FRAGS + 1];
+        struct scatterlist *sg;
-        unsigned char iv[GCM_AES_IV_LEN];
+        unsigned char *iv;
        struct aead_request *req;
        struct macsec_eth_header *hdr;
        u16 icv_len = secy->icv_len;
@@ -882,7 +910,7 @@ static struct sk_buff *macsec_decrypt(struct sk_buff *skb,
        if (!skb)
                return ERR_PTR(-ENOMEM);
-        req = aead_request_alloc(rx_sa->key.tfm, GFP_ATOMIC);
+        req = macsec_alloc_req(rx_sa->key.tfm, &iv, &sg);
        if (!req) {
                kfree_skb(skb);
                return ERR_PTR(-ENOMEM);
@@ -1234,7 +1262,7 @@ static struct crypto_aead *macsec_alloc_tfm(char *key, int key_len, int icv_len)
        struct crypto_aead *tfm;
        int ret;
-        tfm = crypto_alloc_aead("gcm(aes)", 0, CRYPTO_ALG_ASYNC);
+        tfm = crypto_alloc_aead("gcm(aes)", 0, 0);
        if (!tfm || IS_ERR(tfm))
                return NULL;
@@ -3361,6 +3389,7 @@ static void __exit macsec_exit(void)
        genl_unregister_family(&macsec_fam);
        rtnl_link_unregister(&macsec_link_ops);
        unregister_netdevice_notifier(&macsec_notifier);
+        rcu_barrier();
 }
 module_init(macsec_init);
diff --git a/drivers/net/phy/fixed_phy.c b/drivers/net/phy/fixed_phy.c
index 2d2e4339f0df..9ec7f7353434 100644
--- a/drivers/net/phy/fixed_phy.c
+++ b/drivers/net/phy/fixed_phy.c
@@ -23,6 +23,7 @@
 #include <linux/slab.h>
 #include <linux/of.h>
 #include <linux/gpio.h>
+#include <linux/idr.h>
 #define MII_REGS_NUM 29
@@ -286,6 +287,8 @@ err_regs:
 }
 EXPORT_SYMBOL_GPL(fixed_phy_add);
+static DEFINE_IDA(phy_fixed_ida);
 static void fixed_phy_del(int phy_addr)
 {
        struct fixed_mdio_bus *fmb = &platform_fmb;
@@ -297,14 +300,12 @@ static void fixed_phy_del(int phy_addr)
                        if (gpio_is_valid(fp->link_gpio))
                                gpio_free(fp->link_gpio);
                        kfree(fp);
+                        ida_simple_remove(&phy_fixed_ida, phy_addr);
                        return;
                }
        }
 }
-static int phy_fixed_addr;
-static DEFINE_SPINLOCK(phy_fixed_addr_lock);
 struct phy_device *fixed_phy_register(unsigned int irq,
                                      struct fixed_phy_status *status,
                                      int link_gpio,
@@ -319,17 +320,15 @@ struct phy_device *fixed_phy_register(unsigned int irq,
                return ERR_PTR(-EPROBE_DEFER);
        /* Get the next available PHY address, up to PHY_MAX_ADDR */
-        spin_lock(&phy_fixed_addr_lock);
+        phy_addr = ida_simple_get(&phy_fixed_ida, 0, PHY_MAX_ADDR, GFP_KERNEL);
-        if (phy_fixed_addr == PHY_MAX_ADDR) {
+        if (phy_addr < 0)
-                spin_unlock(&phy_fixed_addr_lock);
+                return ERR_PTR(phy_addr);
-                return ERR_PTR(-ENOSPC);
-        }
-        phy_addr = phy_fixed_addr++;
-        spin_unlock(&phy_fixed_addr_lock);
        ret = fixed_phy_add(irq, phy_addr, status, link_gpio);
-        if (ret < 0)
+        if (ret < 0) {
+                ida_simple_remove(&phy_fixed_ida, phy_addr);
                return ERR_PTR(ret);
+        }
        phy = get_phy_device(fmb->mii_bus, phy_addr, false);
        if (IS_ERR(phy)) {
@@ -434,6 +433,7 @@ static void __exit fixed_mdio_bus_exit(void)
                list_del(&fp->node);
                kfree(fp);
        }
+        ida_destroy(&phy_fixed_ida);
 }
 module_exit(fixed_mdio_bus_exit);
diff --git a/drivers/net/phy/marvell.c b/drivers/net/phy/marvell.c
index 280e8795b463..ec2c1eee6405 100644
--- a/drivers/net/phy/marvell.c
+++ b/drivers/net/phy/marvell.c
@@ -285,6 +285,48 @@ static int marvell_config_aneg(struct phy_device *phydev)
        return 0;
 }
+static int m88e1111_config_aneg(struct phy_device *phydev)
+{
+        int err;
+        /* The Marvell PHY has an errata which requires
+         * that certain registers get written in order
+         * to restart autonegotiation
+         */
+        err = phy_write(phydev, MII_BMCR, BMCR_RESET);
+        err = marvell_set_polarity(phydev, phydev->mdix);
+        if (err < 0)
+                return err;
+        err = phy_write(phydev, MII_M1111_PHY_LED_CONTROL,
+                        MII_M1111_PHY_LED_DIRECT);
+        if (err < 0)
+                return err;
+        err = genphy_config_aneg(phydev);
+        if (err < 0)
+                return err;
+        if (phydev->autoneg != AUTONEG_ENABLE) {
+                int bmcr;
+                /* A write to speed/duplex bits (that is performed by
+                 * genphy_config_aneg() call above) must be followed by
+                 * a software reset. Otherwise, the write has no effect.
+                 */
+                bmcr = phy_read(phydev, MII_BMCR);
+                if (bmcr < 0)
+                        return bmcr;
+                err = phy_write(phydev, MII_BMCR, bmcr | BMCR_RESET);
+                if (err < 0)
+                        return err;
+        }
+        return 0;
+}
 #ifdef CONFIG_OF_MDIO
 /*
 * Set and/or override some configuration registers based on the
@@ -407,15 +449,7 @@ static int m88e1121_config_aneg(struct phy_device *phydev)
        if (err < 0)
                return err;
-        oldpage = phy_read(phydev, MII_MARVELL_PHY_PAGE);
+        return genphy_config_aneg(phydev);
-        phy_write(phydev, MII_MARVELL_PHY_PAGE, MII_88E1121_PHY_LED_PAGE);
-        phy_write(phydev, MII_88E1121_PHY_LED_CTRL, MII_88E1121_PHY_LED_DEF);
-        phy_write(phydev, MII_MARVELL_PHY_PAGE, oldpage);
-        err = genphy_config_aneg(phydev);
-        return err;
 }
 static int m88e1318_config_aneg(struct phy_device *phydev)
@@ -636,6 +670,28 @@ static int m88e1111_config_init(struct phy_device *phydev)
        return phy_write(phydev, MII_BMCR, BMCR_RESET);
 }
+static int m88e1121_config_init(struct phy_device *phydev)
+{
+        int err, oldpage;
+        oldpage = phy_read(phydev, MII_MARVELL_PHY_PAGE);
+        err = phy_write(phydev, MII_MARVELL_PHY_PAGE, MII_88E1121_PHY_LED_PAGE);
+        if (err < 0)
+                return err;
+        /* Default PHY LED config: LED[0] .. Link, LED[1] .. Activity */
+        err = phy_write(phydev, MII_88E1121_PHY_LED_CTRL,
+                        MII_88E1121_PHY_LED_DEF);
+        if (err < 0)
+                return err;
+        phy_write(phydev, MII_MARVELL_PHY_PAGE, oldpage);
+        /* Set marvell,reg-init configuration from device tree */
+        return marvell_config_init(phydev);
+}
 static int m88e1510_config_init(struct phy_device *phydev)
 {
        int err;
@@ -668,7 +724,7 @@ static int m88e1510_config_init(struct phy_device *phydev)
                        return err;
        }
-        return marvell_config_init(phydev);
+        return m88e1121_config_init(phydev);
 }
 static int m88e1118_config_aneg(struct phy_device *phydev)
@@ -1161,7 +1217,7 @@ static struct phy_driver marvell_drivers[] = {
                .flags = PHY_HAS_INTERRUPT,
                .probe = marvell_probe,
                .config_init = &m88e1111_config_init,
-                .config_aneg = &marvell_config_aneg,
+                .config_aneg = &m88e1111_config_aneg,
                .read_status = &marvell_read_status,
                .ack_interrupt = &marvell_ack_interrupt,
                .config_intr = &marvell_config_intr,
@@ -1196,7 +1252,7 @@ static struct phy_driver marvell_drivers[] = {
                .features = PHY_GBIT_FEATURES,
                .flags = PHY_HAS_INTERRUPT,
                .probe = marvell_probe,
-                .config_init = &marvell_config_init,
+                .config_init = &m88e1121_config_init,
                .config_aneg = &m88e1121_config_aneg,
                .read_status = &marvell_read_status,
                .ack_interrupt = &marvell_ack_interrupt,
@@ -1215,7 +1271,7 @@ static struct phy_driver marvell_drivers[] = {
                .features = PHY_GBIT_FEATURES,
                .flags = PHY_HAS_INTERRUPT,
                .probe = marvell_probe,
-                .config_init = &marvell_config_init,
+                .config_init = &m88e1121_config_init,
                .config_aneg = &m88e1318_config_aneg,
                .read_status = &marvell_read_status,
                .ack_interrupt = &marvell_ack_interrupt,
diff --git a/drivers/net/phy/smsc.c b/drivers/net/phy/smsc.c
index 2e21e9366f76..b62c4aaee40b 100644
--- a/drivers/net/phy/smsc.c
+++ b/drivers/net/phy/smsc.c
@@ -75,22 +75,13 @@ static int smsc_phy_reset(struct phy_device *phydev)
         * in all capable mode before using it.
         */
        if ((rc & MII_LAN83C185_MODE_MASK) == MII_LAN83C185_MODE_POWERDOWN) {
-                int timeout = 50000;
+                /* set "all capable" mode */
-                /* set "all capable" mode and reset the phy */
                rc |= MII_LAN83C185_MODE_ALL;
                phy_write(phydev, MII_LAN83C185_SPECIAL_MODES, rc);
-                phy_write(phydev, MII_BMCR, BMCR_RESET);
-                /* wait end of reset (max 500 ms) */
-                do {
-                        udelay(10);
-                        if (timeout-- == 0)
-                                return -1;
-                        rc = phy_read(phydev, MII_BMCR);
-                } while (rc & BMCR_RESET);
        }
-        return 0;
+        /* reset the phy */
+        return genphy_soft_reset(phydev);
 }
 static int lan911x_config_init(struct phy_device *phydev)
diff --git a/drivers/net/team/team.c b/drivers/net/team/team.c
index 2ace126533cd..fdee77207323 100644
--- a/drivers/net/team/team.c
+++ b/drivers/net/team/team.c
@@ -1203,8 +1203,10 @@ static int team_port_add(struct team *team, struct net_device *port_dev)
                goto err_dev_open;
        }
+        netif_addr_lock_bh(dev);
        dev_uc_sync_multiple(port_dev, dev);
        dev_mc_sync_multiple(port_dev, dev);
+        netif_addr_unlock_bh(dev);
        err = vlan_vids_add_by_dev(port_dev, dev);
        if (err) {
diff --git a/drivers/net/usb/r8152.c b/drivers/net/usb/r8152.c
index 3f9f6ed3eec4..4e257b8d8f3e 100644
--- a/drivers/net/usb/r8152.c
+++ b/drivers/net/usb/r8152.c
@@ -31,7 +31,7 @@
 #define NETNEXT_VERSION         "08"
 /* Information for net */
-#define NET_VERSION             "3"
+#define NET_VERSION             "4"
 #define DRIVER_VERSION          "v1." NETNEXT_VERSION "." NET_VERSION
 #define DRIVER_AUTHOR "Realtek linux nic maintainers <nic_swsd@realtek.com>"
@@ -116,6 +116,7 @@
 #define USB_TX_DMA              0xd434
 #define USB_TOLERANCE           0xd490
 #define USB_LPM_CTRL            0xd41a
+#define USB_BMU_RESET           0xd4b0
 #define USB_UPS_CTRL            0xd800
 #define USB_MISC_0              0xd81a
 #define USB_POWER_CUT           0xd80a
@@ -338,6 +339,10 @@
 #define TEST_MODE_DISABLE       0x00000001
 #define TX_SIZE_ADJUST1         0x00000100
+/* USB_BMU_RESET */
+#define BMU_RESET_EP_IN         0x01
+#define BMU_RESET_EP_OUT        0x02
 /* USB_UPS_CTRL */
 #define POWER_CUT               0x0100
@@ -2169,7 +2174,7 @@ static void r8153_set_rx_early_timeout(struct r8152 *tp)
 static void r8153_set_rx_early_size(struct r8152 *tp)
 {
        u32 mtu = tp->netdev->mtu;
-        u32 ocp_data = (agg_buf_sz - mtu - VLAN_ETH_HLEN - VLAN_HLEN) / 4;
+        u32 ocp_data = (agg_buf_sz - mtu - VLAN_ETH_HLEN - VLAN_HLEN) / 8;
        ocp_write_word(tp, MCU_TYPE_USB, USB_RX_EARLY_SIZE, ocp_data);
 }
@@ -2456,6 +2461,17 @@ static void r8153_teredo_off(struct r8152 *tp)
        ocp_write_dword(tp, MCU_TYPE_PLA, PLA_TEREDO_TIMER, 0);
 }
+static void rtl_reset_bmu(struct r8152 *tp)
+{
+        u32 ocp_data;
+        ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, USB_BMU_RESET);
+        ocp_data &= ~(BMU_RESET_EP_IN | BMU_RESET_EP_OUT);
+        ocp_write_byte(tp, MCU_TYPE_USB, USB_BMU_RESET, ocp_data);
+        ocp_data |= BMU_RESET_EP_IN | BMU_RESET_EP_OUT;
+        ocp_write_byte(tp, MCU_TYPE_USB, USB_BMU_RESET, ocp_data);
+}
 static void r8152_aldps_en(struct r8152 *tp, bool enable)
 {
        if (enable) {
@@ -2681,6 +2697,7 @@ static void r8153_first_init(struct r8152 *tp)
        r8153_hw_phy_cfg(tp);
        rtl8152_nic_reset(tp);
+        rtl_reset_bmu(tp);
        ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
        ocp_data &= ~NOW_IS_OOB;
@@ -2742,6 +2759,7 @@ static void r8153_enter_oob(struct r8152 *tp)
        ocp_write_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL, ocp_data);
        rtl_disable(tp);
+        rtl_reset_bmu(tp);
        for (i = 0; i < 1000; i++) {
                ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
@@ -2803,6 +2821,7 @@ static void rtl8153_disable(struct r8152 *tp)
 {
        r8153_aldps_en(tp, false);
        rtl_disable(tp);
+        rtl_reset_bmu(tp);
        r8153_aldps_en(tp, true);
        usb_enable_lpm(tp->udev);
 }
@@ -3382,15 +3401,11 @@ static void r8153_init(struct r8152 *tp)
        r8153_power_cut_en(tp, false);
        r8153_u1u2en(tp, true);
-        ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL, ALDPS_SPDWN_RATIO);
+        /* MAC clock speed down */
-        ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL2, EEE_SPDWN_RATIO);
+        ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL, 0);
-        ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL3,
+        ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL2, 0);
-                       PKT_AVAIL_SPDWN_EN | SUSPEND_SPDWN_EN |
+        ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL3, 0);
-                       U1U2_SPDWN_EN | L1_SPDWN_EN);
+        ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL4, 0);
-        ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL4,
-                       PWRSAVE_SPDWN_EN | RXDV_SPDWN_EN | TX10MIDLE_EN |
-                       TP100_SPDWN_EN | TP500_SPDWN_EN | TP1000_SPDWN_EN |
-                       EEE_SPDWN_EN);
        r8153_enable_eee(tp);
        r8153_aldps_en(tp, true);
diff --git a/drivers/net/vrf.c b/drivers/net/vrf.c
index dff08842f26d..8bd8c7e1ee87 100644
--- a/drivers/net/vrf.c
+++ b/drivers/net/vrf.c
@@ -304,7 +304,7 @@ static int vrf_rt6_create(struct net_device *dev)
        dst_hold(&rt6->dst);
        rt6->rt6i_table = rt6i_table;
-        rt6->dst.output = vrf_output6;
+        rt6->dst.output = vrf_output6;
        rcu_assign_pointer(vrf->rt6, rt6);
        rc = 0;
@@ -403,7 +403,7 @@ static int vrf_rtable_create(struct net_device *dev)
        if (!rth)
                return -ENOMEM;
-        rth->dst.output = vrf_output;
+        rth->dst.output = vrf_output;
        rth->rt_table_id = vrf->tb_id;
        rcu_assign_pointer(vrf->rth, rth);
diff --git a/drivers/net/vxlan.c b/drivers/net/vxlan.c
index f999db2f97b4..b3b9db68f758 100644
--- a/drivers/net/vxlan.c
+++ b/drivers/net/vxlan.c
@@ -2952,30 +2952,6 @@ static int vxlan_dev_configure(struct net *src_net, struct net_device *dev,
        return 0;
 }
-struct net_device *vxlan_dev_create(struct net *net, const char *name,
-                                    u8 name_assign_type, struct vxlan_config *conf)
-{
-        struct nlattr *tb[IFLA_MAX+1];
-        struct net_device *dev;
-        int err;
-        memset(&tb, 0, sizeof(tb));
-        dev = rtnl_create_link(net, name, name_assign_type,
-                               &vxlan_link_ops, tb);
-        if (IS_ERR(dev))
-                return dev;
-        err = vxlan_dev_configure(net, dev, conf);
-        if (err < 0) {
-                free_netdev(dev);
-                return ERR_PTR(err);
-        }
-        return dev;
-}
-EXPORT_SYMBOL_GPL(vxlan_dev_create);
 static int vxlan_newlink(struct net *src_net, struct net_device *dev,
                         struct nlattr *tb[], struct nlattr *data[])
 {
@@ -3268,6 +3244,40 @@ static struct rtnl_link_ops vxlan_link_ops __read_mostly = {
        .get_link_net   = vxlan_get_link_net,
 };
+struct net_device *vxlan_dev_create(struct net *net, const char *name,
+                                    u8 name_assign_type,
+                                    struct vxlan_config *conf)
+{
+        struct nlattr *tb[IFLA_MAX + 1];
+        struct net_device *dev;
+        int err;
+        memset(&tb, 0, sizeof(tb));
+        dev = rtnl_create_link(net, name, name_assign_type,
+                               &vxlan_link_ops, tb);
+        if (IS_ERR(dev))
+                return dev;
+        err = vxlan_dev_configure(net, dev, conf);
+        if (err < 0) {
+                free_netdev(dev);
+                return ERR_PTR(err);
+        }
+        err = rtnl_configure_link(dev, NULL);
+        if (err < 0) {
+                LIST_HEAD(list_kill);
+                vxlan_dellink(dev, &list_kill);
+                unregister_netdevice_many(&list_kill);
+                return ERR_PTR(err);
+        }
+        return dev;
+}
+EXPORT_SYMBOL_GPL(vxlan_dev_create);
 static void vxlan_handle_lowerdev_unregister(struct vxlan_net *vn,
                                             struct net_device *dev)
 {
diff --git a/drivers/net/wireless/ath/ath10k/core.c b/drivers/net/wireless/ath/ath10k/core.c
index 49af62428c88..a92a0ba829f5 100644
--- a/drivers/net/wireless/ath/ath10k/core.c
+++ b/drivers/net/wireless/ath/ath10k/core.c
@@ -1083,7 +1083,7 @@ int ath10k_core_fetch_firmware_api_n(struct ath10k *ar, const char *name,
                        }
                        ath10k_dbg_dump(ar, ATH10K_DBG_BOOT, "features", "",
-                                        ar->running_fw->fw_file.fw_features,
+                                        fw_file->fw_features,
                                        sizeof(fw_file->fw_features));
                        break;
                case ATH10K_FW_IE_FW_IMAGE:
diff --git a/drivers/net/wireless/ath/ath10k/htt_rx.c b/drivers/net/wireless/ath/ath10k/htt_rx.c
index cc979a4faeb0..813cdd2621a1 100644
--- a/drivers/net/wireless/ath/ath10k/htt_rx.c
+++ b/drivers/net/wireless/ath/ath10k/htt_rx.c
@@ -1904,7 +1904,6 @@ static void ath10k_htt_rx_in_ord_ind(struct ath10k *ar, struct sk_buff *skb)
                        return;
                }
        }
-        ath10k_htt_rx_msdu_buff_replenish(htt);
 }
 static void ath10k_htt_rx_tx_fetch_resp_id_confirm(struct ath10k *ar,
diff --git a/drivers/net/wireless/ath/ath10k/mac.c b/drivers/net/wireless/ath/ath10k/mac.c
index 6dd1d26b357f..4040f9413e86 100644
--- a/drivers/net/wireless/ath/ath10k/mac.c
+++ b/drivers/net/wireless/ath/ath10k/mac.c
@@ -679,10 +679,10 @@ static int ath10k_peer_create(struct ath10k *ar,
        peer = ath10k_peer_find(ar, vdev_id, addr);
        if (!peer) {
+                spin_unlock_bh(&ar->data_lock);
                ath10k_warn(ar, "failed to find peer %pM on vdev %i after creation\n",
                            addr, vdev_id);
                ath10k_wmi_peer_delete(ar, vdev_id, addr);
-                spin_unlock_bh(&ar->data_lock);
                return -ENOENT;
        }
diff --git a/drivers/net/wireless/ath/ath9k/reg.h b/drivers/net/wireless/ath/ath9k/reg.h
index 9272ca90632b..80ff69f99229 100644
--- a/drivers/net/wireless/ath/ath9k/reg.h
+++ b/drivers/net/wireless/ath/ath9k/reg.h
@@ -1122,12 +1122,12 @@ enum {
 #define AR9300_NUM_GPIO                          16
 #define AR9330_NUM_GPIO                          16
 #define AR9340_NUM_GPIO                          23
-#define AR9462_NUM_GPIO                          10
+#define AR9462_NUM_GPIO                          14
 #define AR9485_NUM_GPIO                          12
 #define AR9531_NUM_GPIO                          18
 #define AR9550_NUM_GPIO                          24
 #define AR9561_NUM_GPIO                          23
-#define AR9565_NUM_GPIO                          12
+#define AR9565_NUM_GPIO                          14
 #define AR9580_NUM_GPIO                          16
 #define AR7010_NUM_GPIO                          16
@@ -1139,12 +1139,12 @@ enum {
 #define AR9300_GPIO_MASK                         0x0000F4FF
 #define AR9330_GPIO_MASK                         0x0000F4FF
 #define AR9340_GPIO_MASK                         0x0000000F
-#define AR9462_GPIO_MASK                         0x000003FF
+#define AR9462_GPIO_MASK                         0x00003FFF
 #define AR9485_GPIO_MASK                         0x00000FFF
 #define AR9531_GPIO_MASK                         0x0000000F
 #define AR9550_GPIO_MASK                         0x0000000F
 #define AR9561_GPIO_MASK                         0x0000000F
-#define AR9565_GPIO_MASK                         0x00000FFF
+#define AR9565_GPIO_MASK                         0x00003FFF
 #define AR9580_GPIO_MASK                         0x0000F4FF
 #define AR7010_GPIO_MASK                         0x0000FFFF
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c b/drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c
index e5f267b21316..18a8474b5760 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c
@@ -3851,8 +3851,8 @@ static int iwl_mvm_mac_get_survey(struct ieee80211_hw *hw, int idx,
        if (idx != 0)
                return -ENOENT;
-        if (fw_has_capa(&mvm->fw->ucode_capa,
+        if (!fw_has_capa(&mvm->fw->ucode_capa,
-                        IWL_UCODE_TLV_CAPA_RADIO_BEACON_STATS))
+                         IWL_UCODE_TLV_CAPA_RADIO_BEACON_STATS))
                return -ENOENT;
        mutex_lock(&mvm->mutex);
@@ -3898,8 +3898,8 @@ static void iwl_mvm_mac_sta_statistics(struct ieee80211_hw *hw,
        struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
        struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
-        if (fw_has_capa(&mvm->fw->ucode_capa,
+        if (!fw_has_capa(&mvm->fw->ucode_capa,
-                        IWL_UCODE_TLV_CAPA_RADIO_BEACON_STATS))
+                         IWL_UCODE_TLV_CAPA_RADIO_BEACON_STATS))
                return;
        /* if beacon filtering isn't on mac80211 does it anyway */
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/rxmq.c b/drivers/net/wireless/intel/iwlwifi/mvm/rxmq.c
index ac2c5718e454..2c61516d06ff 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/rxmq.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/rxmq.c
@@ -581,7 +581,7 @@ static bool iwl_mvm_reorder(struct iwl_mvm *mvm,
                            struct iwl_rx_mpdu_desc *desc)
 {
        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
-        struct iwl_mvm_sta *mvm_sta = iwl_mvm_sta_from_mac80211(sta);
+        struct iwl_mvm_sta *mvm_sta;
        struct iwl_mvm_baid_data *baid_data;
        struct iwl_mvm_reorder_buffer *buffer;
        struct sk_buff *tail;
@@ -604,6 +604,8 @@ static bool iwl_mvm_reorder(struct iwl_mvm *mvm,
        if (WARN_ON(IS_ERR_OR_NULL(sta)))
                return false;
+        mvm_sta = iwl_mvm_sta_from_mac80211(sta);
        /* not a data packet */
        if (!ieee80211_is_data_qos(hdr->frame_control) ||
            is_multicast_ether_addr(hdr->addr1))
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/scan.c b/drivers/net/wireless/intel/iwlwifi/mvm/scan.c
index 6f609dd5c222..e78fc567ff7d 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/scan.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/scan.c
@@ -1222,7 +1222,7 @@ static int iwl_mvm_check_running_scans(struct iwl_mvm *mvm, int type)
        return -EIO;
 }
-#define SCAN_TIMEOUT (16 * HZ)
+#define SCAN_TIMEOUT (20 * HZ)
 void iwl_mvm_scan_timeout(unsigned long data)
 {
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/sta.c b/drivers/net/wireless/intel/iwlwifi/mvm/sta.c
index fea4d3437e2f..b23ab4a4504f 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/sta.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/sta.c
@@ -1852,12 +1852,18 @@ static struct iwl_mvm_sta *iwl_mvm_get_key_sta(struct iwl_mvm *mvm,
            mvmvif->ap_sta_id != IWL_MVM_STATION_COUNT) {
                u8 sta_id = mvmvif->ap_sta_id;
+                sta = rcu_dereference_check(mvm->fw_id_to_mac_id[sta_id],
+                                            lockdep_is_held(&mvm->mutex));
                /*
                 * It is possible that the 'sta' parameter is NULL,
                 * for example when a GTK is removed - the sta_id will then
                 * be the AP ID, and no station was passed by mac80211.
                 */
-                return iwl_mvm_sta_from_staid_protected(mvm, sta_id);
+                if (IS_ERR_OR_NULL(sta))
+                        return NULL;
+                return iwl_mvm_sta_from_mac80211(sta);
        }
        return NULL;
@@ -1955,6 +1961,14 @@ static int iwl_mvm_send_sta_igtk(struct iwl_mvm *mvm,
                struct ieee80211_key_seq seq;
                const u8 *pn;
+                switch (keyconf->cipher) {
+                case WLAN_CIPHER_SUITE_AES_CMAC:
+                        igtk_cmd.ctrl_flags |= cpu_to_le32(STA_KEY_FLG_CCM);
+                        break;
+                default:
+                        return -EINVAL;
+                }
                memcpy(igtk_cmd.IGTK, keyconf->key, keyconf->keylen);
                ieee80211_get_key_rx_seq(keyconf, 0, &seq);
                pn = seq.aes_cmac.pn;
diff --git a/drivers/net/wireless/realtek/rtl8xxxu/rtl8xxxu_8192e.c b/drivers/net/wireless/realtek/rtl8xxxu/rtl8xxxu_8192e.c
index fe19ace0d6a0..b04cf30f3959 100644
--- a/drivers/net/wireless/realtek/rtl8xxxu/rtl8xxxu_8192e.c
+++ b/drivers/net/wireless/realtek/rtl8xxxu/rtl8xxxu_8192e.c
@@ -1149,7 +1149,7 @@ static void rtl8192eu_phy_iqcalibrate(struct rtl8xxxu_priv *priv,
                for (i = 0; i < retry; i++) {
                        path_b_ok = rtl8192eu_rx_iqk_path_b(priv);
-                        if (path_a_ok == 0x03) {
+                        if (path_b_ok == 0x03) {
                                val32 = rtl8xxxu_read32(priv,
                                                        REG_RX_POWER_BEFORE_IQK_B_2);
                                result[t][6] = (val32 >> 16) & 0x3ff;
diff --git a/drivers/pci/vc.c b/drivers/pci/vc.c
index dfbab61a1b47..1fa3a3219c45 100644
--- a/drivers/pci/vc.c
+++ b/drivers/pci/vc.c
@@ -221,9 +221,9 @@ static int pci_vc_do_save_buffer(struct pci_dev *dev, int pos,
                else
                        pci_write_config_word(dev, pos + PCI_VC_PORT_CTRL,
                                              *(u16 *)buf);
-                buf += 2;
+                buf += 4;
        }
-        len += 2;
+        len += 4;
        /*
         * If we have any Low Priority VCs and a VC Arbitration Table Offset
diff --git a/drivers/pinctrl/Makefile b/drivers/pinctrl/Makefile
index e4bc1151e04f..42a5c1dddfef 100644
--- a/drivers/pinctrl/Makefile
+++ b/drivers/pinctrl/Makefile
@@ -23,7 +23,7 @@ obj-$(CONFIG_PINCTRL_PISTACHIO)	+= pinctrl-pistachio.o
 obj-$(CONFIG_PINCTRL_ROCKCHIP)  += pinctrl-rockchip.o
 obj-$(CONFIG_PINCTRL_SINGLE)    += pinctrl-single.o
 obj-$(CONFIG_PINCTRL_SIRF)      += sirf/
-obj-$(CONFIG_PINCTRL_TEGRA)     += tegra/
+obj-$(CONFIG_ARCH_TEGRA)        += tegra/
 obj-$(CONFIG_PINCTRL_TZ1090)    += pinctrl-tz1090.o
 obj-$(CONFIG_PINCTRL_TZ1090_PDC)        += pinctrl-tz1090-pdc.o
 obj-$(CONFIG_PINCTRL_U300)      += pinctrl-u300.o
diff --git a/drivers/pinctrl/freescale/pinctrl-imx.c b/drivers/pinctrl/freescale/pinctrl-imx.c
index 47ccfcc8a647..eccb47480e1d 100644
--- a/drivers/pinctrl/freescale/pinctrl-imx.c
+++ b/drivers/pinctrl/freescale/pinctrl-imx.c
@@ -209,9 +209,9 @@ static int imx_pmx_set(struct pinctrl_dev *pctldev, unsigned selector,
                pin_reg = &info->pin_regs[pin_id];
                if (pin_reg->mux_reg == -1) {
-                        dev_err(ipctl->dev, "Pin(%s) does not support mux function\n",
+                        dev_dbg(ipctl->dev, "Pin(%s) does not support mux function\n",
                                info->pins[pin_id].name);
-                        return -EINVAL;
+                        continue;
                }
                if (info->flags & SHARE_MUX_CONF_REG) {
diff --git a/drivers/pinctrl/intel/pinctrl-baytrail.c b/drivers/pinctrl/intel/pinctrl-baytrail.c
index 677a811b3a6f..7abfd42e8ffd 100644
--- a/drivers/pinctrl/intel/pinctrl-baytrail.c
+++ b/drivers/pinctrl/intel/pinctrl-baytrail.c
@@ -401,9 +401,9 @@ static const struct byt_simple_func_mux byt_score_sata_mux[] = {
 static const unsigned int byt_score_plt_clk0_pins[] = { 96 };
 static const unsigned int byt_score_plt_clk1_pins[] = { 97 };
 static const unsigned int byt_score_plt_clk2_pins[] = { 98 };
-static const unsigned int byt_score_plt_clk4_pins[] = { 99 };
+static const unsigned int byt_score_plt_clk3_pins[] = { 99 };
-static const unsigned int byt_score_plt_clk5_pins[] = { 100 };
+static const unsigned int byt_score_plt_clk4_pins[] = { 100 };
-static const unsigned int byt_score_plt_clk3_pins[] = { 101 };
+static const unsigned int byt_score_plt_clk5_pins[] = { 101 };
 static const struct byt_simple_func_mux byt_score_plt_clk_mux[] = {
        SIMPLE_FUNC("plt_clk", 1),
 };
diff --git a/drivers/pinctrl/pinctrl-single.c b/drivers/pinctrl/pinctrl-single.c
index cf9bafa10acf..bfdf720db270 100644
--- a/drivers/pinctrl/pinctrl-single.c
+++ b/drivers/pinctrl/pinctrl-single.c
@@ -1580,6 +1580,9 @@ static inline void pcs_irq_set(struct pcs_soc_data *pcs_soc,
                else
                        mask &= ~soc_mask;
                pcs->write(mask, pcswi->reg);
+                /* flush posted write */
+                mask = pcs->read(pcswi->reg);
                raw_spin_unlock(&pcs->lock);
        }
diff --git a/drivers/pinctrl/tegra/Makefile b/drivers/pinctrl/tegra/Makefile
index a927379b6794..d9ea2be69cc4 100644
--- a/drivers/pinctrl/tegra/Makefile
+++ b/drivers/pinctrl/tegra/Makefile
@@ -1,4 +1,4 @@
-obj-y                                   += pinctrl-tegra.o
+obj-$(CONFIG_PINCTRL_TEGRA)             += pinctrl-tegra.o
 obj-$(CONFIG_PINCTRL_TEGRA20)           += pinctrl-tegra20.o
 obj-$(CONFIG_PINCTRL_TEGRA30)           += pinctrl-tegra30.o
 obj-$(CONFIG_PINCTRL_TEGRA114)          += pinctrl-tegra114.o
diff --git a/drivers/power/power_supply_core.c b/drivers/power/power_supply_core.c
index 456987c88baa..b13cd074c52a 100644
--- a/drivers/power/power_supply_core.c
+++ b/drivers/power/power_supply_core.c
@@ -565,11 +565,12 @@ static int power_supply_read_temp(struct thermal_zone_device *tzd,
        WARN_ON(tzd == NULL);
        psy = tzd->devdata;
-        ret = psy->desc->get_property(psy, POWER_SUPPLY_PROP_TEMP, &val);
+        ret = power_supply_get_property(psy, POWER_SUPPLY_PROP_TEMP, &val);
+        if (ret)
+                return ret;
        /* Convert tenths of degree Celsius to milli degree Celsius. */
-        if (!ret)
+        *temp = val.intval * 100;
-                *temp = val.intval * 100;
        return ret;
 }
@@ -612,10 +613,12 @@ static int ps_get_max_charge_cntl_limit(struct thermal_cooling_device *tcd,
        int ret;
        psy = tcd->devdata;
-        ret = psy->desc->get_property(psy,
+        ret = power_supply_get_property(psy,
-                POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX, &val);
+                        POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX, &val);
-        if (!ret)
+        if (ret)
-                *state = val.intval;
+                return ret;
+        *state = val.intval;
        return ret;
 }
@@ -628,10 +631,12 @@ static int ps_get_cur_chrage_cntl_limit(struct thermal_cooling_device *tcd,
        int ret;
        psy = tcd->devdata;
-        ret = psy->desc->get_property(psy,
+        ret = power_supply_get_property(psy,
-                POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT, &val);
+                        POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT, &val);
-        if (!ret)
+        if (ret)
-                *state = val.intval;
+                return ret;
+        *state = val.intval;
        return ret;
 }
diff --git a/drivers/power/tps65217_charger.c b/drivers/power/tps65217_charger.c
index d9f56730c735..73dfae41def8 100644
--- a/drivers/power/tps65217_charger.c
+++ b/drivers/power/tps65217_charger.c
@@ -197,6 +197,7 @@ static int tps65217_charger_probe(struct platform_device *pdev)
 {
        struct tps65217 *tps = dev_get_drvdata(pdev->dev.parent);
        struct tps65217_charger *charger;
+        struct power_supply_config cfg = {};
        int ret;
        dev_dbg(&pdev->dev, "%s\n", __func__);
@@ -208,9 +209,12 @@ static int tps65217_charger_probe(struct platform_device *pdev)
        charger->tps = tps;
        charger->dev = &pdev->dev;
+        cfg.of_node = pdev->dev.of_node;
+        cfg.drv_data = charger;
        charger->ac = devm_power_supply_register(&pdev->dev,
                                                 &tps65217_charger_desc,
-                                                 NULL);
+                                                 &cfg);
        if (IS_ERR(charger->ac)) {
                dev_err(&pdev->dev, "failed: power supply register\n");
                return PTR_ERR(charger->ac);
diff --git a/drivers/scsi/53c700.c b/drivers/scsi/53c700.c
index d4c285688ce9..3ddc85e6efd6 100644
--- a/drivers/scsi/53c700.c
+++ b/drivers/scsi/53c700.c
@@ -1122,7 +1122,7 @@ process_script_interrupt(__u32 dsps, __u32 dsp, struct scsi_cmnd *SCp,
                } else {
                        struct scsi_cmnd *SCp;
-                        SCp = scsi_host_find_tag(SDp->host, SCSI_NO_TAG);
+                        SCp = SDp->current_cmnd;
                        if(unlikely(SCp == NULL)) {
                                sdev_printk(KERN_ERR, SDp,
                                        "no saved request for untagged cmd\n");
@@ -1826,7 +1826,7 @@ NCR_700_queuecommand_lck(struct scsi_cmnd *SCp, void (*done)(struct scsi_cmnd *)
                       slot->tag, slot);
        } else {
                slot->tag = SCSI_NO_TAG;
-                /* must populate current_cmnd for scsi_host_find_tag to work */
+                /* save current command for reselection */
                SCp->device->current_cmnd = SCp;
        }
        /* sanity check: some of the commands generated by the mid-layer
diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index a8b610eaa0ca..106a6adbd6f1 100644
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@ -1128,7 +1128,6 @@ static int scsi_eh_action(struct scsi_cmnd *scmd, int rtn)
 */
 void scsi_eh_finish_cmd(struct scsi_cmnd *scmd, struct list_head *done_q)
 {
-        scmd->device->host->host_failed--;
        scmd->eh_eflags = 0;
        list_move_tail(&scmd->eh_entry, done_q);
 }
@@ -2227,6 +2226,9 @@ int scsi_error_handler(void *data)
                else
                        scsi_unjam_host(shost);
+                /* All scmds have been handled */
+                shost->host_failed = 0;
                /*
                 * Note - if the above fails completely, the action is to take
                 * individual devices offline and flush the queue of any
diff --git a/drivers/xen/balloon.c b/drivers/xen/balloon.c
index d46839f51e73..e4db19e88ab1 100644
--- a/drivers/xen/balloon.c
+++ b/drivers/xen/balloon.c
@@ -151,8 +151,6 @@ static DECLARE_WAIT_QUEUE_HEAD(balloon_wq);
 static void balloon_process(struct work_struct *work);
 static DECLARE_DELAYED_WORK(balloon_worker, balloon_process);
-static void release_memory_resource(struct resource *resource);
 /* When ballooning out (allocating memory to return to Xen) we don't really
   want the kernel to try too hard since that can trigger the oom killer. */
 #define GFP_BALLOON \
@@ -248,6 +246,19 @@ static enum bp_state update_schedule(enum bp_state state)
 }
 #ifdef CONFIG_XEN_BALLOON_MEMORY_HOTPLUG
+static void release_memory_resource(struct resource *resource)
+{
+        if (!resource)
+                return;
+        /*
+         * No need to reset region to identity mapped since we now
+         * know that no I/O can be in this region
+         */
+        release_resource(resource);
+        kfree(resource);
+}
 static struct resource *additional_memory_resource(phys_addr_t size)
 {
        struct resource *res;
@@ -286,19 +297,6 @@ static struct resource *additional_memory_resource(phys_addr_t size)
        return res;
 }
-static void release_memory_resource(struct resource *resource)
-{
-        if (!resource)
-                return;
-        /*
-         * No need to reset region to identity mapped since we now
-         * know that no I/O can be in this region
-         */
-        release_resource(resource);
-        kfree(resource);
-}
 static enum bp_state reserve_additional_memory(void)
 {
        long credit;
diff --git a/drivers/xen/xen-pciback/conf_space.c b/drivers/xen/xen-pciback/conf_space.c
index 8e67336f8ddd..6a25533da237 100644
--- a/drivers/xen/xen-pciback/conf_space.c
+++ b/drivers/xen/xen-pciback/conf_space.c
@@ -183,8 +183,7 @@ int xen_pcibk_config_read(struct pci_dev *dev, int offset, int size,
                field_start = OFFSET(cfg_entry);
                field_end = OFFSET(cfg_entry) + field->size;
-                if ((req_start >= field_start && req_start < field_end)
+                 if (req_end > field_start && field_end > req_start) {
-                    || (req_end > field_start && req_end <= field_end)) {
                        err = conf_space_read(dev, cfg_entry, field_start,
                                              &tmp_val);
                        if (err)
@@ -230,8 +229,7 @@ int xen_pcibk_config_write(struct pci_dev *dev, int offset, int size, u32 value)
                field_start = OFFSET(cfg_entry);
                field_end = OFFSET(cfg_entry) + field->size;
-                if ((req_start >= field_start && req_start < field_end)
+                 if (req_end > field_start && field_end > req_start) {
-                    || (req_end > field_start && req_end <= field_end)) {
                        tmp_val = 0;
                        err = xen_pcibk_config_read(dev, field_start,
diff --git a/drivers/xen/xen-pciback/conf_space_header.c b/drivers/xen/xen-pciback/conf_space_header.c
index ad3d17d29c81..9ead1c2ff1dd 100644
--- a/drivers/xen/xen-pciback/conf_space_header.c
+++ b/drivers/xen/xen-pciback/conf_space_header.c
@@ -145,7 +145,7 @@ static int rom_write(struct pci_dev *dev, int offset, u32 value, void *data)
        /* A write to obtain the length must happen as a 32-bit write.
         * This does not (yet) support writing individual bytes
         */
-        if (value == ~PCI_ROM_ADDRESS_ENABLE)
+        if ((value | ~PCI_ROM_ADDRESS_MASK) == ~0U)
                bar->which = 1;
        else {
                u32 tmpval;
@@ -225,38 +225,42 @@ static inline void read_dev_bar(struct pci_dev *dev,
                           (PCI_BASE_ADDRESS_SPACE_MEMORY |
                                PCI_BASE_ADDRESS_MEM_TYPE_64))) {
                        bar_info->val = res[pos - 1].start >> 32;
-                        bar_info->len_val = res[pos - 1].end >> 32;
+                        bar_info->len_val = -resource_size(&res[pos - 1]) >> 32;
                        return;
                }
        }
+        if (!res[pos].flags ||
+            (res[pos].flags & (IORESOURCE_DISABLED | IORESOURCE_UNSET |
+                               IORESOURCE_BUSY)))
+                return;
        bar_info->val = res[pos].start |
                        (res[pos].flags & PCI_REGION_FLAG_MASK);
-        bar_info->len_val = resource_size(&res[pos]);
+        bar_info->len_val = -resource_size(&res[pos]) |
+                            (res[pos].flags & PCI_REGION_FLAG_MASK);
 }
 static void *bar_init(struct pci_dev *dev, int offset)
 {
-        struct pci_bar_info *bar = kmalloc(sizeof(*bar), GFP_KERNEL);
+        struct pci_bar_info *bar = kzalloc(sizeof(*bar), GFP_KERNEL);
        if (!bar)
                return ERR_PTR(-ENOMEM);
        read_dev_bar(dev, bar, offset, ~0);
-        bar->which = 0;
        return bar;
 }
 static void *rom_init(struct pci_dev *dev, int offset)
 {
-        struct pci_bar_info *bar = kmalloc(sizeof(*bar), GFP_KERNEL);
+        struct pci_bar_info *bar = kzalloc(sizeof(*bar), GFP_KERNEL);
        if (!bar)
                return ERR_PTR(-ENOMEM);
        read_dev_bar(dev, bar, offset, ~PCI_ROM_ADDRESS_ENABLE);
-        bar->which = 0;
        return bar;
 }