Merge branch 'core/urgent' into x86/urgent, to pick up objtool fix

Signed-off-by: Ingo Molnar <mingo@kernel.org>

25 files changed, 1431 insertions, 48 deletions

diff --git a/drivers/firmware/Kconfig b/drivers/firmware/Kconfig
index 6e83880046d7..7670e8dda829 100644
--- a/drivers/firmware/Kconfig
+++ b/drivers/firmware/Kconfig
@@ -289,7 +289,9 @@ config HAVE_ARM_SMCCC
 source "drivers/firmware/broadcom/Kconfig"
 source "drivers/firmware/google/Kconfig"
 source "drivers/firmware/efi/Kconfig"
+source "drivers/firmware/imx/Kconfig"
 source "drivers/firmware/meson/Kconfig"
 source "drivers/firmware/tegra/Kconfig"
+source "drivers/firmware/xilinx/Kconfig"
 
 endmenu
diff --git a/drivers/firmware/Makefile b/drivers/firmware/Makefile
index e18a041cfc53..13660a951437 100644
--- a/drivers/firmware/Makefile
+++ b/drivers/firmware/Makefile
@@ -31,4 +31,6 @@ obj-y				+= meson/
 obj-$(CONFIG_GOOGLE_FIRMWARE)   += google/
 obj-$(CONFIG_EFI)               += efi/
 obj-$(CONFIG_UEFI_CPER)         += efi/
+obj-y                           += imx/
 obj-y                           += tegra/
+obj-y                           += xilinx/
diff --git a/drivers/firmware/arm_scmi/base.c b/drivers/firmware/arm_scmi/base.c
index 9dff33ea6416..204390297f4b 100644
--- a/drivers/firmware/arm_scmi/base.c
+++ b/drivers/firmware/arm_scmi/base.c
@@ -208,7 +208,7 @@ static int scmi_base_discover_agent_get(const struct scmi_handle *handle,
 
         ret = scmi_do_xfer(handle, t);
         if (!ret)
-                memcpy(name, t->rx.buf, SCMI_MAX_STR_SIZE);
+                strlcpy(name, t->rx.buf, SCMI_MAX_STR_SIZE);
 
         scmi_xfer_put(handle, t);
 
diff --git a/drivers/firmware/arm_scmi/clock.c b/drivers/firmware/arm_scmi/clock.c
index e4119eb34986..30fc04e28431 100644
--- a/drivers/firmware/arm_scmi/clock.c
+++ b/drivers/firmware/arm_scmi/clock.c
@@ -111,7 +111,7 @@ static int scmi_clock_attributes_get(const struct scmi_handle *handle,
 
         ret = scmi_do_xfer(handle, t);
         if (!ret)
-                memcpy(clk->name, attr->name, SCMI_MAX_STR_SIZE);
+                strlcpy(clk->name, attr->name, SCMI_MAX_STR_SIZE);
         else
                 clk->name[0] = '\0';
 
diff --git a/drivers/firmware/arm_scmi/perf.c b/drivers/firmware/arm_scmi/perf.c
index 64342944d917..3c8ae7cc35de 100644
--- a/drivers/firmware/arm_scmi/perf.c
+++ b/drivers/firmware/arm_scmi/perf.c
@@ -174,7 +174,7 @@ scmi_perf_domain_attributes_get(const struct scmi_handle *handle, u32 domain,
                         dom_info->mult_factor =
                                         (dom_info->sustained_freq_khz * 1000) /
                                         dom_info->sustained_perf_level;
-                memcpy(dom_info->name, attr->name, SCMI_MAX_STR_SIZE);
+                strlcpy(dom_info->name, attr->name, SCMI_MAX_STR_SIZE);
         }
 
         scmi_xfer_put(handle, t);
@@ -427,6 +427,33 @@ static int scmi_dvfs_freq_get(const struct scmi_handle *handle, u32 domain,
         return ret;
 }
 
+static int scmi_dvfs_est_power_get(const struct scmi_handle *handle, u32 domain,
+                                   unsigned long *freq, unsigned long *power)
+{
+        struct scmi_perf_info *pi = handle->perf_priv;
+        struct perf_dom_info *dom;
+        unsigned long opp_freq;
+        int idx, ret = -EINVAL;
+        struct scmi_opp *opp;
+
+        dom = pi->dom_info + domain;
+        if (!dom)
+                return -EIO;
+
+        for (opp = dom->opp, idx = 0; idx < dom->opp_count; idx++, opp++) {
+                opp_freq = opp->perf * dom->mult_factor;
+                if (opp_freq < *freq)
+                        continue;
+
+                *freq = opp_freq;
+                *power = opp->power;
+                ret = 0;
+                break;
+        }
+
+        return ret;
+}
+
 static struct scmi_perf_ops perf_ops = {
         .limits_set = scmi_perf_limits_set,
         .limits_get = scmi_perf_limits_get,
@@ -437,6 +464,7 @@ static struct scmi_perf_ops perf_ops = {
         .device_opps_add = scmi_dvfs_device_opps_add,
         .freq_set = scmi_dvfs_freq_set,
         .freq_get = scmi_dvfs_freq_get,
+        .est_power_get = scmi_dvfs_est_power_get,
 };
 
 static int scmi_perf_protocol_init(struct scmi_handle *handle)
diff --git a/drivers/firmware/arm_scmi/power.c b/drivers/firmware/arm_scmi/power.c
index cfa033b05aed..62f3401a1f01 100644
--- a/drivers/firmware/arm_scmi/power.c
+++ b/drivers/firmware/arm_scmi/power.c
@@ -106,7 +106,7 @@ scmi_power_domain_attributes_get(const struct scmi_handle *handle, u32 domain,
                 dom_info->state_set_notify = SUPPORTS_STATE_SET_NOTIFY(flags);
                 dom_info->state_set_async = SUPPORTS_STATE_SET_ASYNC(flags);
                 dom_info->state_set_sync = SUPPORTS_STATE_SET_SYNC(flags);
-                memcpy(dom_info->name, attr->name, SCMI_MAX_STR_SIZE);
+                strlcpy(dom_info->name, attr->name, SCMI_MAX_STR_SIZE);
         }
 
         scmi_xfer_put(handle, t);
diff --git a/drivers/firmware/arm_scmi/sensors.c b/drivers/firmware/arm_scmi/sensors.c
index 27f2092b9882..b53d5cc9c9f6 100644
--- a/drivers/firmware/arm_scmi/sensors.c
+++ b/drivers/firmware/arm_scmi/sensors.c
@@ -140,7 +140,7 @@ static int scmi_sensor_description_get(const struct scmi_handle *handle,
                         s = &si->sensors[desc_index + cnt];
                         s->id = le32_to_cpu(buf->desc[cnt].id);
                         s->type = SENSOR_TYPE(attrh);
-                        memcpy(s->name, buf->desc[cnt].name, SCMI_MAX_STR_SIZE);
+                        strlcpy(s->name, buf->desc[cnt].name, SCMI_MAX_STR_SIZE);
                 }
 
                 desc_index += num_returned;
diff --git a/drivers/firmware/dmi_scan.c b/drivers/firmware/dmi_scan.c
index f2483548cde9..099d83e4e910 100644
--- a/drivers/firmware/dmi_scan.c
+++ b/drivers/firmware/dmi_scan.c
@@ -5,7 +5,7 @@
 #include <linux/ctype.h>
 #include <linux/dmi.h>
 #include <linux/efi.h>
-#include <linux/bootmem.h>
+#include <linux/memblock.h>
 #include <linux/random.h>
 #include <asm/dmi.h>
 #include <asm/unaligned.h>
diff --git a/drivers/firmware/efi/apple-properties.c b/drivers/firmware/efi/apple-properties.c
index 60a95719ecb8..ac1654f74dc7 100644
--- a/drivers/firmware/efi/apple-properties.c
+++ b/drivers/firmware/efi/apple-properties.c
@@ -20,7 +20,7 @@
 
 #define pr_fmt(fmt) "apple-properties: " fmt
 
-#include <linux/bootmem.h>
+#include <linux/memblock.h>
 #include <linux/efi.h>
 #include <linux/io.h>
 #include <linux/platform_data/x86/apple.h>
@@ -235,7 +235,7 @@ static int __init map_properties(void)
                  */
                 data->len = 0;
                 memunmap(data);
-                free_bootmem_late(pa_data + sizeof(*data), data_len);
+                memblock_free_late(pa_data + sizeof(*data), data_len);
 
                 return ret;
         }
diff --git a/drivers/firmware/efi/memmap.c b/drivers/firmware/efi/memmap.c
index 5fc70520e04c..fa2904fb841f 100644
--- a/drivers/firmware/efi/memmap.c
+++ b/drivers/firmware/efi/memmap.c
@@ -15,7 +15,7 @@
 
 static phys_addr_t __init __efi_memmap_alloc_early(unsigned long size)
 {
-        return memblock_alloc(size, 0);
+        return memblock_phys_alloc(size, SMP_CACHE_BYTES);
 }
 
 static phys_addr_t __init __efi_memmap_alloc_late(unsigned long size)
diff --git a/drivers/firmware/imx/Kconfig b/drivers/firmware/imx/Kconfig
new file mode 100644
index 000000000000..b170c2851e48
--- /dev/null
+++ b/drivers/firmware/imx/Kconfig
@@ -0,0 +1,11 @@
+config IMX_SCU
+        bool "IMX SCU Protocol driver"
+        depends on IMX_MBOX
+        help
+          The System Controller Firmware (SCFW) is a low-level system function
+          which runs on a dedicated Cortex-M core to provide power, clock, and
+          resource management. It exists on some i.MX8 processors. e.g. i.MX8QM
+          (QM, QP), and i.MX8QX (QXP, DX).
+
+          This driver manages the IPC interface between host CPU and the
+          SCU firmware running on M4.
diff --git a/drivers/firmware/imx/Makefile b/drivers/firmware/imx/Makefile
new file mode 100644
index 000000000000..0ac04dfda8d4
--- /dev/null
+++ b/drivers/firmware/imx/Makefile
@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: GPL-2.0
+obj-$(CONFIG_IMX_SCU)   += imx-scu.o misc.o
diff --git a/drivers/firmware/imx/imx-scu.c b/drivers/firmware/imx/imx-scu.c
new file mode 100644
index 000000000000..2bb1a19c413f
--- /dev/null
+++ b/drivers/firmware/imx/imx-scu.c
@@ -0,0 +1,270 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Copyright 2018 NXP
+ *  Author: Dong Aisheng <aisheng.dong@nxp.com>
+ *
+ * Implementation of the SCU IPC functions using MUs (client side).
+ *
+ */
+
+#include <linux/err.h>
+#include <linux/firmware/imx/types.h>
+#include <linux/firmware/imx/ipc.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/kernel.h>
+#include <linux/mailbox_client.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/of_platform.h>
+#include <linux/platform_device.h>
+
+#define SCU_MU_CHAN_NUM         8
+#define MAX_RX_TIMEOUT          (msecs_to_jiffies(30))
+
+struct imx_sc_chan {
+        struct imx_sc_ipc *sc_ipc;
+
+        struct mbox_client cl;
+        struct mbox_chan *ch;
+        int idx;
+};
+
+struct imx_sc_ipc {
+        /* SCU uses 4 Tx and 4 Rx channels */
+        struct imx_sc_chan chans[SCU_MU_CHAN_NUM];
+        struct device *dev;
+        struct mutex lock;
+        struct completion done;
+
+        /* temporarily store the SCU msg */
+        u32 *msg;
+        u8 rx_size;
+        u8 count;
+};
+
+/*
+ * This type is used to indicate error response for most functions.
+ */
+enum imx_sc_error_codes {
+        IMX_SC_ERR_NONE = 0,    /* Success */
+        IMX_SC_ERR_VERSION = 1, /* Incompatible API version */
+        IMX_SC_ERR_CONFIG = 2,  /* Configuration error */
+        IMX_SC_ERR_PARM = 3,    /* Bad parameter */
+        IMX_SC_ERR_NOACCESS = 4,        /* Permission error (no access) */
+        IMX_SC_ERR_LOCKED = 5,  /* Permission error (locked) */
+        IMX_SC_ERR_UNAVAILABLE = 6,     /* Unavailable (out of resources) */
+        IMX_SC_ERR_NOTFOUND = 7,        /* Not found */
+        IMX_SC_ERR_NOPOWER = 8, /* No power */
+        IMX_SC_ERR_IPC = 9,             /* Generic IPC error */
+        IMX_SC_ERR_BUSY = 10,   /* Resource is currently busy/active */
+        IMX_SC_ERR_FAIL = 11,   /* General I/O failure */
+        IMX_SC_ERR_LAST
+};
+
+static int imx_sc_linux_errmap[IMX_SC_ERR_LAST] = {
+        0,       /* IMX_SC_ERR_NONE */
+        -EINVAL, /* IMX_SC_ERR_VERSION */
+        -EINVAL, /* IMX_SC_ERR_CONFIG */
+        -EINVAL, /* IMX_SC_ERR_PARM */
+        -EACCES, /* IMX_SC_ERR_NOACCESS */
+        -EACCES, /* IMX_SC_ERR_LOCKED */
+        -ERANGE, /* IMX_SC_ERR_UNAVAILABLE */
+        -EEXIST, /* IMX_SC_ERR_NOTFOUND */
+        -EPERM,  /* IMX_SC_ERR_NOPOWER */
+        -EPIPE,  /* IMX_SC_ERR_IPC */
+        -EBUSY,  /* IMX_SC_ERR_BUSY */
+        -EIO,    /* IMX_SC_ERR_FAIL */
+};
+
+static struct imx_sc_ipc *imx_sc_ipc_handle;
+
+static inline int imx_sc_to_linux_errno(int errno)
+{
+        if (errno >= IMX_SC_ERR_NONE && errno < IMX_SC_ERR_LAST)
+                return imx_sc_linux_errmap[errno];
+        return -EIO;
+}
+
+/*
+ * Get the default handle used by SCU
+ */
+int imx_scu_get_handle(struct imx_sc_ipc **ipc)
+{
+        if (!imx_sc_ipc_handle)
+                return -EPROBE_DEFER;
+
+        *ipc = imx_sc_ipc_handle;
+        return 0;
+}
+EXPORT_SYMBOL(imx_scu_get_handle);
+
+static void imx_scu_rx_callback(struct mbox_client *c, void *msg)
+{
+        struct imx_sc_chan *sc_chan = container_of(c, struct imx_sc_chan, cl);
+        struct imx_sc_ipc *sc_ipc = sc_chan->sc_ipc;
+        struct imx_sc_rpc_msg *hdr;
+        u32 *data = msg;
+
+        if (sc_chan->idx == 0) {
+                hdr = msg;
+                sc_ipc->rx_size = hdr->size;
+                dev_dbg(sc_ipc->dev, "msg rx size %u\n", sc_ipc->rx_size);
+                if (sc_ipc->rx_size > 4)
+                        dev_warn(sc_ipc->dev, "RPC does not support receiving over 4 words: %u\n",
+                                 sc_ipc->rx_size);
+        }
+
+        sc_ipc->msg[sc_chan->idx] = *data;
+        sc_ipc->count++;
+
+        dev_dbg(sc_ipc->dev, "mu %u msg %u 0x%x\n", sc_chan->idx,
+                sc_ipc->count, *data);
+
+        if ((sc_ipc->rx_size != 0) && (sc_ipc->count == sc_ipc->rx_size))
+                complete(&sc_ipc->done);
+}
+
+static int imx_scu_ipc_write(struct imx_sc_ipc *sc_ipc, void *msg)
+{
+        struct imx_sc_rpc_msg *hdr = msg;
+        struct imx_sc_chan *sc_chan;
+        u32 *data = msg;
+        int ret;
+        int i;
+
+        /* Check size */
+        if (hdr->size > IMX_SC_RPC_MAX_MSG)
+                return -EINVAL;
+
+        dev_dbg(sc_ipc->dev, "RPC SVC %u FUNC %u SIZE %u\n", hdr->svc,
+                hdr->func, hdr->size);
+
+        for (i = 0; i < hdr->size; i++) {
+                sc_chan = &sc_ipc->chans[i % 4];
+                ret = mbox_send_message(sc_chan->ch, &data[i]);
+                if (ret < 0)
+                        return ret;
+        }
+
+        return 0;
+}
+
+/*
+ * RPC command/response
+ */
+int imx_scu_call_rpc(struct imx_sc_ipc *sc_ipc, void *msg, bool have_resp)
+{
+        struct imx_sc_rpc_msg *hdr;
+        int ret;
+
+        if (WARN_ON(!sc_ipc || !msg))
+                return -EINVAL;
+
+        mutex_lock(&sc_ipc->lock);
+        reinit_completion(&sc_ipc->done);
+
+        sc_ipc->msg = msg;
+        sc_ipc->count = 0;
+        ret = imx_scu_ipc_write(sc_ipc, msg);
+        if (ret < 0) {
+                dev_err(sc_ipc->dev, "RPC send msg failed: %d\n", ret);
+                goto out;
+        }
+
+        if (have_resp) {
+                if (!wait_for_completion_timeout(&sc_ipc->done,
+                                                 MAX_RX_TIMEOUT)) {
+                        dev_err(sc_ipc->dev, "RPC send msg timeout\n");
+                        mutex_unlock(&sc_ipc->lock);
+                        return -ETIMEDOUT;
+                }
+
+                /* response status is stored in hdr->func field */
+                hdr = msg;
+                ret = hdr->func;
+        }
+
+out:
+        mutex_unlock(&sc_ipc->lock);
+
+        dev_dbg(sc_ipc->dev, "RPC SVC done\n");
+
+        return imx_sc_to_linux_errno(ret);
+}
+EXPORT_SYMBOL(imx_scu_call_rpc);
+
+static int imx_scu_probe(struct platform_device *pdev)
+{
+        struct device *dev = &pdev->dev;
+        struct imx_sc_ipc *sc_ipc;
+        struct imx_sc_chan *sc_chan;
+        struct mbox_client *cl;
+        char *chan_name;
+        int ret;
+        int i;
+
+        sc_ipc = devm_kzalloc(dev, sizeof(*sc_ipc), GFP_KERNEL);
+        if (!sc_ipc)
+                return -ENOMEM;
+
+        for (i = 0; i < SCU_MU_CHAN_NUM; i++) {
+                if (i < 4)
+                        chan_name = kasprintf(GFP_KERNEL, "tx%d", i);
+                else
+                        chan_name = kasprintf(GFP_KERNEL, "rx%d", i - 4);
+
+                if (!chan_name)
+                        return -ENOMEM;
+
+                sc_chan = &sc_ipc->chans[i];
+                cl = &sc_chan->cl;
+                cl->dev = dev;
+                cl->tx_block = false;
+                cl->knows_txdone = true;
+                cl->rx_callback = imx_scu_rx_callback;
+
+                sc_chan->sc_ipc = sc_ipc;
+                sc_chan->idx = i % 4;
+                sc_chan->ch = mbox_request_channel_byname(cl, chan_name);
+                if (IS_ERR(sc_chan->ch)) {
+                        ret = PTR_ERR(sc_chan->ch);
+                        if (ret != -EPROBE_DEFER)
+                                dev_err(dev, "Failed to request mbox chan %s ret %d\n",
+                                        chan_name, ret);
+                        return ret;
+                }
+
+                dev_dbg(dev, "request mbox chan %s\n", chan_name);
+                /* chan_name is not used anymore by framework */
+                kfree(chan_name);
+        }
+
+        sc_ipc->dev = dev;
+        mutex_init(&sc_ipc->lock);
+        init_completion(&sc_ipc->done);
+
+        imx_sc_ipc_handle = sc_ipc;
+
+        dev_info(dev, "NXP i.MX SCU Initialized\n");
+
+        return devm_of_platform_populate(dev);
+}
+
+static const struct of_device_id imx_scu_match[] = {
+        { .compatible = "fsl,imx-scu", },
+        { /* Sentinel */ }
+};
+
+static struct platform_driver imx_scu_driver = {
+        .driver = {
+                .name = "imx-scu",
+                .of_match_table = imx_scu_match,
+        },
+        .probe = imx_scu_probe,
+};
+builtin_platform_driver(imx_scu_driver);
+
+MODULE_AUTHOR("Dong Aisheng <aisheng.dong@nxp.com>");
+MODULE_DESCRIPTION("IMX SCU firmware protocol driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/firmware/imx/misc.c b/drivers/firmware/imx/misc.c
new file mode 100644
index 000000000000..97f5424dbac9
--- /dev/null
+++ b/drivers/firmware/imx/misc.c
@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ * Copyright 2017~2018 NXP
+ *  Author: Dong Aisheng <aisheng.dong@nxp.com>
+ *
+ * File containing client-side RPC functions for the MISC service. These
+ * function are ported to clients that communicate to the SC.
+ *
+ */
+
+#include <linux/firmware/imx/svc/misc.h>
+
+struct imx_sc_msg_req_misc_set_ctrl {
+        struct imx_sc_rpc_msg hdr;
+        u32 ctrl;
+        u32 val;
+        u16 resource;
+} __packed;
+
+struct imx_sc_msg_req_misc_get_ctrl {
+        struct imx_sc_rpc_msg hdr;
+        u32 ctrl;
+        u16 resource;
+} __packed;
+
+struct imx_sc_msg_resp_misc_get_ctrl {
+        struct imx_sc_rpc_msg hdr;
+        u32 val;
+} __packed;
+
+/*
+ * This function sets a miscellaneous control value.
+ *
+ * @param[in]     ipc         IPC handle
+ * @param[in]     resource    resource the control is associated with
+ * @param[in]     ctrl        control to change
+ * @param[in]     val         value to apply to the control
+ *
+ * @return Returns 0 for success and < 0 for errors.
+ */
+
+int imx_sc_misc_set_control(struct imx_sc_ipc *ipc, u32 resource,
+                            u8 ctrl, u32 val)
+{
+        struct imx_sc_msg_req_misc_set_ctrl msg;
+        struct imx_sc_rpc_msg *hdr = &msg.hdr;
+
+        hdr->ver = IMX_SC_RPC_VERSION;
+        hdr->svc = (uint8_t)IMX_SC_RPC_SVC_MISC;
+        hdr->func = (uint8_t)IMX_SC_MISC_FUNC_SET_CONTROL;
+        hdr->size = 4;
+
+        msg.ctrl = ctrl;
+        msg.val = val;
+        msg.resource = resource;
+
+        return imx_scu_call_rpc(ipc, &msg, true);
+}
+EXPORT_SYMBOL(imx_sc_misc_set_control);
+
+/*
+ * This function gets a miscellaneous control value.
+ *
+ * @param[in]     ipc         IPC handle
+ * @param[in]     resource    resource the control is associated with
+ * @param[in]     ctrl        control to get
+ * @param[out]    val         pointer to return the control value
+ *
+ * @return Returns 0 for success and < 0 for errors.
+ */
+
+int imx_sc_misc_get_control(struct imx_sc_ipc *ipc, u32 resource,
+                            u8 ctrl, u32 *val)
+{
+        struct imx_sc_msg_req_misc_get_ctrl msg;
+        struct imx_sc_msg_resp_misc_get_ctrl *resp;
+        struct imx_sc_rpc_msg *hdr = &msg.hdr;
+        int ret;
+
+        hdr->ver = IMX_SC_RPC_VERSION;
+        hdr->svc = (uint8_t)IMX_SC_RPC_SVC_MISC;
+        hdr->func = (uint8_t)IMX_SC_MISC_FUNC_GET_CONTROL;
+        hdr->size = 3;
+
+        msg.ctrl = ctrl;
+        msg.resource = resource;
+
+        ret = imx_scu_call_rpc(ipc, &msg, true);
+        if (ret)
+                return ret;
+
+        resp = (struct imx_sc_msg_resp_misc_get_ctrl *)&msg;
+        if (val != NULL)
+                *val = resp->val;
+
+        return 0;
+}
+EXPORT_SYMBOL(imx_sc_misc_get_control);
diff --git a/drivers/firmware/iscsi_ibft_find.c b/drivers/firmware/iscsi_ibft_find.c
index 2224f1dc074b..72d9ea18270b 100644
--- a/drivers/firmware/iscsi_ibft_find.c
+++ b/drivers/firmware/iscsi_ibft_find.c
@@ -18,7 +18,7 @@
  * GNU General Public License for more details.
  */
 
-#include <linux/bootmem.h>
+#include <linux/memblock.h>
 #include <linux/blkdev.h>
 #include <linux/ctype.h>
 #include <linux/device.h>
diff --git a/drivers/firmware/memmap.c b/drivers/firmware/memmap.c
index 5de3ed29282c..d168c87c7d30 100644
--- a/drivers/firmware/memmap.c
+++ b/drivers/firmware/memmap.c
@@ -19,7 +19,7 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/types.h>
-#include <linux/bootmem.h>
+#include <linux/memblock.h>
 #include <linux/slab.h>
 #include <linux/mm.h>
 
@@ -333,7 +333,8 @@ int __init firmware_map_add_early(u64 start, u64 end, const char *type)
 {
         struct firmware_map_entry *entry;
 
-        entry = memblock_virt_alloc(sizeof(struct firmware_map_entry), 0);
+        entry = memblock_alloc(sizeof(struct firmware_map_entry),
+                               SMP_CACHE_BYTES);
         if (WARN_ON(!entry))
                 return -ENOMEM;
 
diff --git a/drivers/firmware/meson/meson_sm.c b/drivers/firmware/meson/meson_sm.c
index 0ec2ca87318c..29fbc818a573 100644
--- a/drivers/firmware/meson/meson_sm.c
+++ b/drivers/firmware/meson/meson_sm.c
@@ -24,6 +24,7 @@
 #include <linux/printk.h>
 #include <linux/types.h>
 #include <linux/sizes.h>
+ #include <linux/slab.h>
 
 #include <linux/firmware/meson/meson_sm.h>
 
@@ -48,6 +49,7 @@ struct meson_sm_chip gxbb_chip = {
                 CMD(SM_EFUSE_READ,      0x82000030),
                 CMD(SM_EFUSE_WRITE,     0x82000031),
                 CMD(SM_EFUSE_USER_MAX,  0x82000033),
+                CMD(SM_GET_CHIP_ID,     0x82000044),
                 { /* sentinel */ },
         },
 };
@@ -214,6 +216,57 @@ int meson_sm_call_write(void *buffer, unsigned int size, unsigned int cmd_index,
 }
 EXPORT_SYMBOL(meson_sm_call_write);
 
+#define SM_CHIP_ID_LENGTH       119
+#define SM_CHIP_ID_OFFSET       4
+#define SM_CHIP_ID_SIZE         12
+
+static ssize_t serial_show(struct device *dev, struct device_attribute *attr,
+                         char *buf)
+{
+        uint8_t *id_buf;
+        int ret;
+
+        id_buf = kmalloc(SM_CHIP_ID_LENGTH, GFP_KERNEL);
+        if (!id_buf)
+                return -ENOMEM;
+
+        ret = meson_sm_call_read(id_buf, SM_CHIP_ID_LENGTH, SM_GET_CHIP_ID,
+                                 0, 0, 0, 0, 0);
+        if (ret < 0) {
+                kfree(id_buf);
+                return ret;
+        }
+
+        ret = sprintf(buf, "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\n",
+                        id_buf[SM_CHIP_ID_OFFSET + 0],
+                        id_buf[SM_CHIP_ID_OFFSET + 1],
+                        id_buf[SM_CHIP_ID_OFFSET + 2],
+                        id_buf[SM_CHIP_ID_OFFSET + 3],
+                        id_buf[SM_CHIP_ID_OFFSET + 4],
+                        id_buf[SM_CHIP_ID_OFFSET + 5],
+                        id_buf[SM_CHIP_ID_OFFSET + 6],
+                        id_buf[SM_CHIP_ID_OFFSET + 7],
+                        id_buf[SM_CHIP_ID_OFFSET + 8],
+                        id_buf[SM_CHIP_ID_OFFSET + 9],
+                        id_buf[SM_CHIP_ID_OFFSET + 10],
+                        id_buf[SM_CHIP_ID_OFFSET + 11]);
+
+        kfree(id_buf);
+
+        return ret;
+}
+
+static DEVICE_ATTR_RO(serial);
+
+static struct attribute *meson_sm_sysfs_attributes[] = {
+        &dev_attr_serial.attr,
+        NULL,
+};
+
+static const struct attribute_group meson_sm_sysfs_attr_group = {
+        .attrs = meson_sm_sysfs_attributes,
+};
+
 static const struct of_device_id meson_sm_ids[] = {
         { .compatible = "amlogic,meson-gxbb-sm", .data = &gxbb_chip },
         { /* sentinel */ },
@@ -242,6 +295,9 @@ static int __init meson_sm_probe(struct platform_device *pdev)
         fw.chip = chip;
         pr_info("secure-monitor enabled\n");
 
+        if (sysfs_create_group(&pdev->dev.kobj, &meson_sm_sysfs_attr_group))
+                goto out_in_base;
+
         return 0;
 
 out_in_base:
diff --git a/drivers/firmware/qcom_scm.c b/drivers/firmware/qcom_scm.c
index e778af766fae..af4eee86919d 100644
--- a/drivers/firmware/qcom_scm.c
+++ b/drivers/firmware/qcom_scm.c
@@ -525,34 +525,44 @@ static int qcom_scm_probe(struct platform_device *pdev)
                 return ret;
 
         clks = (unsigned long)of_device_get_match_data(&pdev->dev);
-        if (clks & SCM_HAS_CORE_CLK) {
-                scm->core_clk = devm_clk_get(&pdev->dev, "core");
-                if (IS_ERR(scm->core_clk)) {
-                        if (PTR_ERR(scm->core_clk) != -EPROBE_DEFER)
-                                dev_err(&pdev->dev,
-                                        "failed to acquire core clk\n");
+
+        scm->core_clk = devm_clk_get(&pdev->dev, "core");
+        if (IS_ERR(scm->core_clk)) {
+                if (PTR_ERR(scm->core_clk) == -EPROBE_DEFER)
+                        return PTR_ERR(scm->core_clk);
+
+                if (clks & SCM_HAS_CORE_CLK) {
+                        dev_err(&pdev->dev, "failed to acquire core clk\n");
                         return PTR_ERR(scm->core_clk);
                 }
+
+                scm->core_clk = NULL;
         }
 
-        if (clks & SCM_HAS_IFACE_CLK) {
-                scm->iface_clk = devm_clk_get(&pdev->dev, "iface");
-                if (IS_ERR(scm->iface_clk)) {
-                        if (PTR_ERR(scm->iface_clk) != -EPROBE_DEFER)
-                                dev_err(&pdev->dev,
-                                        "failed to acquire iface clk\n");
+        scm->iface_clk = devm_clk_get(&pdev->dev, "iface");
+        if (IS_ERR(scm->iface_clk)) {
+                if (PTR_ERR(scm->iface_clk) == -EPROBE_DEFER)
+                        return PTR_ERR(scm->iface_clk);
+
+                if (clks & SCM_HAS_IFACE_CLK) {
+                        dev_err(&pdev->dev, "failed to acquire iface clk\n");
                         return PTR_ERR(scm->iface_clk);
                 }
+
+                scm->iface_clk = NULL;
         }
 
-        if (clks & SCM_HAS_BUS_CLK) {
-                scm->bus_clk = devm_clk_get(&pdev->dev, "bus");
-                if (IS_ERR(scm->bus_clk)) {
-                        if (PTR_ERR(scm->bus_clk) != -EPROBE_DEFER)
-                                dev_err(&pdev->dev,
-                                        "failed to acquire bus clk\n");
+        scm->bus_clk = devm_clk_get(&pdev->dev, "bus");
+        if (IS_ERR(scm->bus_clk)) {
+                if (PTR_ERR(scm->bus_clk) == -EPROBE_DEFER)
+                        return PTR_ERR(scm->bus_clk);
+
+                if (clks & SCM_HAS_BUS_CLK) {
+                        dev_err(&pdev->dev, "failed to acquire bus clk\n");
                         return PTR_ERR(scm->bus_clk);
                 }
+
+                scm->bus_clk = NULL;
         }
 
         scm->reset.ops = &qcom_scm_pas_reset_ops;
@@ -594,23 +604,23 @@ static const struct of_device_id qcom_scm_dt_match[] = {
         { .compatible = "qcom,scm-apq8064",
           /* FIXME: This should have .data = (void *) SCM_HAS_CORE_CLK */
         },
-        { .compatible = "qcom,scm-msm8660",
-          .data = (void *) SCM_HAS_CORE_CLK,
-        },
-        { .compatible = "qcom,scm-msm8960",
-          .data = (void *) SCM_HAS_CORE_CLK,
-        },
-        { .compatible = "qcom,scm-msm8996",
-          .data = NULL, /* no clocks */
+        { .compatible = "qcom,scm-apq8084", .data = (void *)(SCM_HAS_CORE_CLK |
+                                                             SCM_HAS_IFACE_CLK |
+                                                             SCM_HAS_BUS_CLK)
         },
-        { .compatible = "qcom,scm-ipq4019",
-          .data = NULL, /* no clocks */
+        { .compatible = "qcom,scm-ipq4019" },
+        { .compatible = "qcom,scm-msm8660", .data = (void *) SCM_HAS_CORE_CLK },
+        { .compatible = "qcom,scm-msm8960", .data = (void *) SCM_HAS_CORE_CLK },
+        { .compatible = "qcom,scm-msm8916", .data = (void *)(SCM_HAS_CORE_CLK |
+                                                             SCM_HAS_IFACE_CLK |
+                                                             SCM_HAS_BUS_CLK)
         },
-        { .compatible = "qcom,scm",
-          .data = (void *)(SCM_HAS_CORE_CLK
-                           | SCM_HAS_IFACE_CLK
-                           | SCM_HAS_BUS_CLK),
+        { .compatible = "qcom,scm-msm8974", .data = (void *)(SCM_HAS_CORE_CLK |
+                                                             SCM_HAS_IFACE_CLK |
+                                                             SCM_HAS_BUS_CLK)
         },
+        { .compatible = "qcom,scm-msm8996" },
+        { .compatible = "qcom,scm" },
         {}
 };
 
diff --git a/drivers/firmware/tegra/bpmp.c b/drivers/firmware/tegra/bpmp.c
index 14a456afa379..a3d5b518c10e 100644
--- a/drivers/firmware/tegra/bpmp.c
+++ b/drivers/firmware/tegra/bpmp.c
@@ -18,6 +18,7 @@
 #include <linux/of_address.h>
 #include <linux/of_device.h>
 #include <linux/platform_device.h>
+#include <linux/pm.h>
 #include <linux/semaphore.h>
 #include <linux/sched/clock.h>
 
@@ -843,6 +844,23 @@ free_tx:
         return err;
 }
 
+static int __maybe_unused tegra_bpmp_resume(struct device *dev)
+{
+        struct tegra_bpmp *bpmp = dev_get_drvdata(dev);
+        unsigned int i;
+
+        /* reset message channels */
+        tegra_bpmp_channel_reset(bpmp->tx_channel);
+        tegra_bpmp_channel_reset(bpmp->rx_channel);
+
+        for (i = 0; i < bpmp->threaded.count; i++)
+                tegra_bpmp_channel_reset(&bpmp->threaded_channels[i]);
+
+        return 0;
+}
+
+static SIMPLE_DEV_PM_OPS(tegra_bpmp_pm_ops, NULL, tegra_bpmp_resume);
+
 static const struct tegra_bpmp_soc tegra186_soc = {
         .channels = {
                 .cpu_tx = {
@@ -871,6 +889,7 @@ static struct platform_driver tegra_bpmp_driver = {
         .driver = {
                 .name = "tegra-bpmp",
                 .of_match_table = tegra_bpmp_match,
+                .pm = &tegra_bpmp_pm_ops,
         },
         .probe = tegra_bpmp_probe,
 };
diff --git a/drivers/firmware/ti_sci.c b/drivers/firmware/ti_sci.c
index 7fa744793bc5..69ed1464175c 100644
--- a/drivers/firmware/ti_sci.c
+++ b/drivers/firmware/ti_sci.c
@@ -66,14 +66,14 @@ struct ti_sci_xfers_info {
 
 /**
  * struct ti_sci_desc - Description of SoC integration
- * @host_id:            Host identifier representing the compute entity
+ * @default_host_id:    Host identifier representing the compute entity
  * @max_rx_timeout_ms:  Timeout for communication with SoC (in Milliseconds)
  * @max_msgs: Maximum number of messages that can be pending
  *                simultaneously in the system
  * @max_msg_size: Maximum size of data per message that can be handled.
  */
 struct ti_sci_desc {
-        u8 host_id;
+        u8 default_host_id;
         int max_rx_timeout_ms;
         int max_msgs;
         int max_msg_size;
@@ -94,6 +94,7 @@ struct ti_sci_desc {
  * @chan_rx:    Receive mailbox channel
  * @minfo:      Message info
  * @node:       list head
+ * @host_id:    Host ID
  * @users:      Number of users of this instance
  */
 struct ti_sci_info {
@@ -110,6 +111,7 @@ struct ti_sci_info {
         struct mbox_chan *chan_rx;
         struct ti_sci_xfers_info minfo;
         struct list_head node;
+        u8 host_id;
         /* protected by ti_sci_list_mutex */
         int users;
 
@@ -370,7 +372,7 @@ static struct ti_sci_xfer *ti_sci_get_one_xfer(struct ti_sci_info *info,
 
         hdr->seq = xfer_id;
         hdr->type = msg_type;
-        hdr->host = info->desc->host_id;
+        hdr->host = info->host_id;
         hdr->flags = msg_flags;
 
         return xfer;
@@ -1793,7 +1795,7 @@ static int tisci_reboot_handler(struct notifier_block *nb, unsigned long mode,
 
 /* Description for K2G */
 static const struct ti_sci_desc ti_sci_pmmc_k2g_desc = {
-        .host_id = 2,
+        .default_host_id = 2,
         /* Conservative duration */
         .max_rx_timeout_ms = 1000,
         /* Limited by MBOX_TX_QUEUE_LEN. K2G can handle upto 128 messages! */
@@ -1819,6 +1821,7 @@ static int ti_sci_probe(struct platform_device *pdev)
         int ret = -EINVAL;
         int i;
         int reboot = 0;
+        u32 h_id;
 
         of_id = of_match_device(ti_sci_of_match, dev);
         if (!of_id) {
@@ -1833,6 +1836,19 @@ static int ti_sci_probe(struct platform_device *pdev)
 
         info->dev = dev;
         info->desc = desc;
+        ret = of_property_read_u32(dev->of_node, "ti,host-id", &h_id);
+        /* if the property is not present in DT, use a default from desc */
+        if (ret < 0) {
+                info->host_id = info->desc->default_host_id;
+        } else {
+                if (!h_id) {
+                        dev_warn(dev, "Host ID 0 is reserved for firmware\n");
+                        info->host_id = info->desc->default_host_id;
+                } else {
+                        info->host_id = h_id;
+                }
+        }
+
         reboot = of_property_read_bool(dev->of_node,
                                        "ti,system-reboot-controller");
         INIT_LIST_HEAD(&info->node);
diff --git a/drivers/firmware/xilinx/Kconfig b/drivers/firmware/xilinx/Kconfig
new file mode 100644
index 000000000000..8f44b9cd295a
--- /dev/null
+++ b/drivers/firmware/xilinx/Kconfig
@@ -0,0 +1,23 @@
+# SPDX-License-Identifier: GPL-2.0
+# Kconfig for Xilinx firmwares
+
+menu "Zynq MPSoC Firmware Drivers"
+        depends on ARCH_ZYNQMP
+
+config ZYNQMP_FIRMWARE
+        bool "Enable Xilinx Zynq MPSoC firmware interface"
+        help
+          Firmware interface driver is used by different
+          drivers to communicate with the firmware for
+          various platform management services.
+          Say yes to enable ZynqMP firmware interface driver.
+          If in doubt, say N.
+
+config ZYNQMP_FIRMWARE_DEBUG
+        bool "Enable Xilinx Zynq MPSoC firmware debug APIs"
+        depends on ZYNQMP_FIRMWARE && DEBUG_FS
+        help
+          Say yes to enable ZynqMP firmware interface debug APIs.
+          If in doubt, say N.
+
+endmenu
diff --git a/drivers/firmware/xilinx/Makefile b/drivers/firmware/xilinx/Makefile
new file mode 100644
index 000000000000..875a53703c82
--- /dev/null
+++ b/drivers/firmware/xilinx/Makefile
@@ -0,0 +1,5 @@
+# SPDX-License-Identifier: GPL-2.0
+# Makefile for Xilinx firmwares
+
+obj-$(CONFIG_ZYNQMP_FIRMWARE) += zynqmp.o
+obj-$(CONFIG_ZYNQMP_FIRMWARE_DEBUG) += zynqmp-debug.o
diff --git a/drivers/firmware/xilinx/zynqmp-debug.c b/drivers/firmware/xilinx/zynqmp-debug.c
new file mode 100644
index 000000000000..2771df6df379
--- /dev/null
+++ b/drivers/firmware/xilinx/zynqmp-debug.c
@@ -0,0 +1,250 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Xilinx Zynq MPSoC Firmware layer for debugfs APIs
+ *
+ *  Copyright (C) 2014-2018 Xilinx, Inc.
+ *
+ *  Michal Simek <michal.simek@xilinx.com>
+ *  Davorin Mista <davorin.mista@aggios.com>
+ *  Jolly Shah <jollys@xilinx.com>
+ *  Rajan Vaja <rajanv@xilinx.com>
+ */
+
+#include <linux/compiler.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/debugfs.h>
+#include <linux/uaccess.h>
+
+#include <linux/firmware/xlnx-zynqmp.h>
+#include "zynqmp-debug.h"
+
+#define PM_API_NAME_LEN                 50
+
+struct pm_api_info {
+        u32 api_id;
+        char api_name[PM_API_NAME_LEN];
+        char api_name_len;
+};
+
+static char debugfs_buf[PAGE_SIZE];
+
+#define PM_API(id)               {id, #id, strlen(#id)}
+static struct pm_api_info pm_api_list[] = {
+        PM_API(PM_GET_API_VERSION),
+        PM_API(PM_QUERY_DATA),
+};
+
+struct dentry *firmware_debugfs_root;
+
+/**
+ * zynqmp_pm_argument_value() - Extract argument value from a PM-API request
+ * @arg:        Entered PM-API argument in string format
+ *
+ * Return: Argument value in unsigned integer format on success
+ *         0 otherwise
+ */
+static u64 zynqmp_pm_argument_value(char *arg)
+{
+        u64 value;
+
+        if (!arg)
+                return 0;
+
+        if (!kstrtou64(arg, 0, &value))
+                return value;
+
+        return 0;
+}
+
+/**
+ * get_pm_api_id() - Extract API-ID from a PM-API request
+ * @pm_api_req:         Entered PM-API argument in string format
+ * @pm_id:              API-ID
+ *
+ * Return: 0 on success else error code
+ */
+static int get_pm_api_id(char *pm_api_req, u32 *pm_id)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(pm_api_list) ; i++) {
+                if (!strncasecmp(pm_api_req, pm_api_list[i].api_name,
+                                 pm_api_list[i].api_name_len)) {
+                        *pm_id = pm_api_list[i].api_id;
+                        break;
+                }
+        }
+
+        /* If no name was entered look for PM-API ID instead */
+        if (i == ARRAY_SIZE(pm_api_list) && kstrtouint(pm_api_req, 10, pm_id))
+                return -EINVAL;
+
+        return 0;
+}
+
+static int process_api_request(u32 pm_id, u64 *pm_api_arg, u32 *pm_api_ret)
+{
+        const struct zynqmp_eemi_ops *eemi_ops = zynqmp_pm_get_eemi_ops();
+        u32 pm_api_version;
+        int ret;
+        struct zynqmp_pm_query_data qdata = {0};
+
+        if (!eemi_ops)
+                return -ENXIO;
+
+        switch (pm_id) {
+        case PM_GET_API_VERSION:
+                ret = eemi_ops->get_api_version(&pm_api_version);
+                sprintf(debugfs_buf, "PM-API Version = %d.%d\n",
+                        pm_api_version >> 16, pm_api_version & 0xffff);
+                break;
+        case PM_QUERY_DATA:
+                qdata.qid = pm_api_arg[0];
+                qdata.arg1 = pm_api_arg[1];
+                qdata.arg2 = pm_api_arg[2];
+                qdata.arg3 = pm_api_arg[3];
+
+                ret = eemi_ops->query_data(qdata, pm_api_ret);
+                if (ret)
+                        break;
+
+                switch (qdata.qid) {
+                case PM_QID_CLOCK_GET_NAME:
+                        sprintf(debugfs_buf, "Clock name = %s\n",
+                                (char *)pm_api_ret);
+                        break;
+                case PM_QID_CLOCK_GET_FIXEDFACTOR_PARAMS:
+                        sprintf(debugfs_buf, "Multiplier = %d, Divider = %d\n",
+                                pm_api_ret[1], pm_api_ret[2]);
+                        break;
+                default:
+                        sprintf(debugfs_buf,
+                                "data[0] = 0x%08x\ndata[1] = 0x%08x\n data[2] = 0x%08x\ndata[3] = 0x%08x\n",
+                                pm_api_ret[0], pm_api_ret[1],
+                                pm_api_ret[2], pm_api_ret[3]);
+                }
+                break;
+        default:
+                sprintf(debugfs_buf, "Unsupported PM-API request\n");
+                ret = -EINVAL;
+        }
+
+        return ret;
+}
+
+/**
+ * zynqmp_pm_debugfs_api_write() - debugfs write function
+ * @file:       User file
+ * @ptr:        User entered PM-API string
+ * @len:        Length of the userspace buffer
+ * @off:        Offset within the file
+ *
+ * Used for triggering pm api functions by writing
+ * echo <pm_api_id>     > /sys/kernel/debug/zynqmp_pm/power or
+ * echo <pm_api_name>   > /sys/kernel/debug/zynqmp_pm/power
+ *
+ * Return: Number of bytes copied if PM-API request succeeds,
+ *         the corresponding error code otherwise
+ */
+static ssize_t zynqmp_pm_debugfs_api_write(struct file *file,
+                                           const char __user *ptr, size_t len,
+                                           loff_t *off)
+{
+        char *kern_buff, *tmp_buff;
+        char *pm_api_req;
+        u32 pm_id = 0;
+        u64 pm_api_arg[4] = {0, 0, 0, 0};
+        /* Return values from PM APIs calls */
+        u32 pm_api_ret[4] = {0, 0, 0, 0};
+
+        int ret;
+        int i = 0;
+
+        strcpy(debugfs_buf, "");
+
+        if (*off != 0 || len == 0)
+                return -EINVAL;
+
+        kern_buff = kzalloc(len, GFP_KERNEL);
+        if (!kern_buff)
+                return -ENOMEM;
+
+        tmp_buff = kern_buff;
+
+        ret = strncpy_from_user(kern_buff, ptr, len);
+        if (ret < 0) {
+                ret = -EFAULT;
+                goto err;
+        }
+
+        /* Read the API name from a user request */
+        pm_api_req = strsep(&kern_buff, " ");
+
+        ret = get_pm_api_id(pm_api_req, &pm_id);
+        if (ret < 0)
+                goto err;
+
+        /* Read node_id and arguments from the PM-API request */
+        pm_api_req = strsep(&kern_buff, " ");
+        while ((i < ARRAY_SIZE(pm_api_arg)) && pm_api_req) {
+                pm_api_arg[i++] = zynqmp_pm_argument_value(pm_api_req);
+                pm_api_req = strsep(&kern_buff, " ");
+        }
+
+        ret = process_api_request(pm_id, pm_api_arg, pm_api_ret);
+
+err:
+        kfree(tmp_buff);
+        if (ret)
+                return ret;
+
+        return len;
+}
+
+/**
+ * zynqmp_pm_debugfs_api_read() - debugfs read function
+ * @file:       User file
+ * @ptr:        Requested pm_api_version string
+ * @len:        Length of the userspace buffer
+ * @off:        Offset within the file
+ *
+ * Return: Length of the version string on success
+ *         else error code
+ */
+static ssize_t zynqmp_pm_debugfs_api_read(struct file *file, char __user *ptr,
+                                          size_t len, loff_t *off)
+{
+        return simple_read_from_buffer(ptr, len, off, debugfs_buf,
+                                       strlen(debugfs_buf));
+}
+
+/* Setup debugfs fops */
+static const struct file_operations fops_zynqmp_pm_dbgfs = {
+        .owner = THIS_MODULE,
+        .write = zynqmp_pm_debugfs_api_write,
+        .read = zynqmp_pm_debugfs_api_read,
+};
+
+/**
+ * zynqmp_pm_api_debugfs_init - Initialize debugfs interface
+ *
+ * Return:      None
+ */
+void zynqmp_pm_api_debugfs_init(void)
+{
+        /* Initialize debugfs interface */
+        firmware_debugfs_root = debugfs_create_dir("zynqmp-firmware", NULL);
+        debugfs_create_file("pm", 0660, firmware_debugfs_root, NULL,
+                            &fops_zynqmp_pm_dbgfs);
+}
+
+/**
+ * zynqmp_pm_api_debugfs_exit - Remove debugfs interface
+ *
+ * Return:      None
+ */
+void zynqmp_pm_api_debugfs_exit(void)
+{
+        debugfs_remove_recursive(firmware_debugfs_root);
+}
diff --git a/drivers/firmware/xilinx/zynqmp-debug.h b/drivers/firmware/xilinx/zynqmp-debug.h
new file mode 100644
index 000000000000..9929f8b433f5
--- /dev/null
+++ b/drivers/firmware/xilinx/zynqmp-debug.h
@@ -0,0 +1,24 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Xilinx Zynq MPSoC Firmware layer
+ *
+ *  Copyright (C) 2014-2018 Xilinx
+ *
+ *  Michal Simek <michal.simek@xilinx.com>
+ *  Davorin Mista <davorin.mista@aggios.com>
+ *  Jolly Shah <jollys@xilinx.com>
+ *  Rajan Vaja <rajanv@xilinx.com>
+ */
+
+#ifndef __FIRMWARE_ZYNQMP_DEBUG_H__
+#define __FIRMWARE_ZYNQMP_DEBUG_H__
+
+#if IS_REACHABLE(CONFIG_ZYNQMP_FIRMWARE_DEBUG)
+void zynqmp_pm_api_debugfs_init(void);
+void zynqmp_pm_api_debugfs_exit(void);
+#else
+static inline void zynqmp_pm_api_debugfs_init(void) { }
+static inline void zynqmp_pm_api_debugfs_exit(void) { }
+#endif
+
+#endif /* __FIRMWARE_ZYNQMP_DEBUG_H__ */
diff --git a/drivers/firmware/xilinx/zynqmp.c b/drivers/firmware/xilinx/zynqmp.c
new file mode 100644
index 000000000000..9a1c72a9280f
--- /dev/null
+++ b/drivers/firmware/xilinx/zynqmp.c
@@ -0,0 +1,565 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Xilinx Zynq MPSoC Firmware layer
+ *
+ *  Copyright (C) 2014-2018 Xilinx, Inc.
+ *
+ *  Michal Simek <michal.simek@xilinx.com>
+ *  Davorin Mista <davorin.mista@aggios.com>
+ *  Jolly Shah <jollys@xilinx.com>
+ *  Rajan Vaja <rajanv@xilinx.com>
+ */
+
+#include <linux/arm-smccc.h>
+#include <linux/compiler.h>
+#include <linux/device.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_platform.h>
+#include <linux/slab.h>
+#include <linux/uaccess.h>
+
+#include <linux/firmware/xlnx-zynqmp.h>
+#include "zynqmp-debug.h"
+
+/**
+ * zynqmp_pm_ret_code() - Convert PMU-FW error codes to Linux error codes
+ * @ret_status:         PMUFW return code
+ *
+ * Return: corresponding Linux error code
+ */
+static int zynqmp_pm_ret_code(u32 ret_status)
+{
+        switch (ret_status) {
+        case XST_PM_SUCCESS:
+        case XST_PM_DOUBLE_REQ:
+                return 0;
+        case XST_PM_NO_ACCESS:
+                return -EACCES;
+        case XST_PM_ABORT_SUSPEND:
+                return -ECANCELED;
+        case XST_PM_INTERNAL:
+        case XST_PM_CONFLICT:
+        case XST_PM_INVALID_NODE:
+        default:
+                return -EINVAL;
+        }
+}
+
+static noinline int do_fw_call_fail(u64 arg0, u64 arg1, u64 arg2,
+                                    u32 *ret_payload)
+{
+        return -ENODEV;
+}
+
+/*
+ * PM function call wrapper
+ * Invoke do_fw_call_smc or do_fw_call_hvc, depending on the configuration
+ */
+static int (*do_fw_call)(u64, u64, u64, u32 *ret_payload) = do_fw_call_fail;
+
+/**
+ * do_fw_call_smc() - Call system-level platform management layer (SMC)
+ * @arg0:               Argument 0 to SMC call
+ * @arg1:               Argument 1 to SMC call
+ * @arg2:               Argument 2 to SMC call
+ * @ret_payload:        Returned value array
+ *
+ * Invoke platform management function via SMC call (no hypervisor present).
+ *
+ * Return: Returns status, either success or error+reason
+ */
+static noinline int do_fw_call_smc(u64 arg0, u64 arg1, u64 arg2,
+                                   u32 *ret_payload)
+{
+        struct arm_smccc_res res;
+
+        arm_smccc_smc(arg0, arg1, arg2, 0, 0, 0, 0, 0, &res);
+
+        if (ret_payload) {
+                ret_payload[0] = lower_32_bits(res.a0);
+                ret_payload[1] = upper_32_bits(res.a0);
+                ret_payload[2] = lower_32_bits(res.a1);
+                ret_payload[3] = upper_32_bits(res.a1);
+        }
+
+        return zynqmp_pm_ret_code((enum pm_ret_status)res.a0);
+}
+
+/**
+ * do_fw_call_hvc() - Call system-level platform management layer (HVC)
+ * @arg0:               Argument 0 to HVC call
+ * @arg1:               Argument 1 to HVC call
+ * @arg2:               Argument 2 to HVC call
+ * @ret_payload:        Returned value array
+ *
+ * Invoke platform management function via HVC
+ * HVC-based for communication through hypervisor
+ * (no direct communication with ATF).
+ *
+ * Return: Returns status, either success or error+reason
+ */
+static noinline int do_fw_call_hvc(u64 arg0, u64 arg1, u64 arg2,
+                                   u32 *ret_payload)
+{
+        struct arm_smccc_res res;
+
+        arm_smccc_hvc(arg0, arg1, arg2, 0, 0, 0, 0, 0, &res);
+
+        if (ret_payload) {
+                ret_payload[0] = lower_32_bits(res.a0);
+                ret_payload[1] = upper_32_bits(res.a0);
+                ret_payload[2] = lower_32_bits(res.a1);
+                ret_payload[3] = upper_32_bits(res.a1);
+        }
+
+        return zynqmp_pm_ret_code((enum pm_ret_status)res.a0);
+}
+
+/**
+ * zynqmp_pm_invoke_fn() - Invoke the system-level platform management layer
+ *                         caller function depending on the configuration
+ * @pm_api_id:          Requested PM-API call
+ * @arg0:               Argument 0 to requested PM-API call
+ * @arg1:               Argument 1 to requested PM-API call
+ * @arg2:               Argument 2 to requested PM-API call
+ * @arg3:               Argument 3 to requested PM-API call
+ * @ret_payload:        Returned value array
+ *
+ * Invoke platform management function for SMC or HVC call, depending on
+ * configuration.
+ * Following SMC Calling Convention (SMCCC) for SMC64:
+ * Pm Function Identifier,
+ * PM_SIP_SVC + PM_API_ID =
+ *      ((SMC_TYPE_FAST << FUNCID_TYPE_SHIFT)
+ *      ((SMC_64) << FUNCID_CC_SHIFT)
+ *      ((SIP_START) << FUNCID_OEN_SHIFT)
+ *      ((PM_API_ID) & FUNCID_NUM_MASK))
+ *
+ * PM_SIP_SVC   - Registered ZynqMP SIP Service Call.
+ * PM_API_ID    - Platform Management API ID.
+ *
+ * Return: Returns status, either success or error+reason
+ */
+int zynqmp_pm_invoke_fn(u32 pm_api_id, u32 arg0, u32 arg1,
+                        u32 arg2, u32 arg3, u32 *ret_payload)
+{
+        /*
+         * Added SIP service call Function Identifier
+         * Make sure to stay in x0 register
+         */
+        u64 smc_arg[4];
+
+        smc_arg[0] = PM_SIP_SVC | pm_api_id;
+        smc_arg[1] = ((u64)arg1 << 32) | arg0;
+        smc_arg[2] = ((u64)arg3 << 32) | arg2;
+
+        return do_fw_call(smc_arg[0], smc_arg[1], smc_arg[2], ret_payload);
+}
+
+static u32 pm_api_version;
+static u32 pm_tz_version;
+
+/**
+ * zynqmp_pm_get_api_version() - Get version number of PMU PM firmware
+ * @version:    Returned version value
+ *
+ * Return: Returns status, either success or error+reason
+ */
+static int zynqmp_pm_get_api_version(u32 *version)
+{
+        u32 ret_payload[PAYLOAD_ARG_CNT];
+        int ret;
+
+        if (!version)
+                return -EINVAL;
+
+        /* Check is PM API version already verified */
+        if (pm_api_version > 0) {
+                *version = pm_api_version;
+                return 0;
+        }
+        ret = zynqmp_pm_invoke_fn(PM_GET_API_VERSION, 0, 0, 0, 0, ret_payload);
+        *version = ret_payload[1];
+
+        return ret;
+}
+
+/**
+ * zynqmp_pm_get_trustzone_version() - Get secure trustzone firmware version
+ * @version:    Returned version value
+ *
+ * Return: Returns status, either success or error+reason
+ */
+static int zynqmp_pm_get_trustzone_version(u32 *version)
+{
+        u32 ret_payload[PAYLOAD_ARG_CNT];
+        int ret;
+
+        if (!version)
+                return -EINVAL;
+
+        /* Check is PM trustzone version already verified */
+        if (pm_tz_version > 0) {
+                *version = pm_tz_version;
+                return 0;
+        }
+        ret = zynqmp_pm_invoke_fn(PM_GET_TRUSTZONE_VERSION, 0, 0,
+                                  0, 0, ret_payload);
+        *version = ret_payload[1];
+
+        return ret;
+}
+
+/**
+ * get_set_conduit_method() - Choose SMC or HVC based communication
+ * @np:         Pointer to the device_node structure
+ *
+ * Use SMC or HVC-based functions to communicate with EL2/EL3.
+ *
+ * Return: Returns 0 on success or error code
+ */
+static int get_set_conduit_method(struct device_node *np)
+{
+        const char *method;
+
+        if (of_property_read_string(np, "method", &method)) {
+                pr_warn("%s missing \"method\" property\n", __func__);
+                return -ENXIO;
+        }
+
+        if (!strcmp("hvc", method)) {
+                do_fw_call = do_fw_call_hvc;
+        } else if (!strcmp("smc", method)) {
+                do_fw_call = do_fw_call_smc;
+        } else {
+                pr_warn("%s Invalid \"method\" property: %s\n",
+                        __func__, method);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+/**
+ * zynqmp_pm_query_data() - Get query data from firmware
+ * @qdata:      Variable to the zynqmp_pm_query_data structure
+ * @out:        Returned output value
+ *
+ * Return: Returns status, either success or error+reason
+ */
+static int zynqmp_pm_query_data(struct zynqmp_pm_query_data qdata, u32 *out)
+{
+        int ret;
+
+        ret = zynqmp_pm_invoke_fn(PM_QUERY_DATA, qdata.qid, qdata.arg1,
+                                  qdata.arg2, qdata.arg3, out);
+
+        /*
+         * For clock name query, all bytes in SMC response are clock name
+         * characters and return code is always success. For invalid clocks,
+         * clock name bytes would be zeros.
+         */
+        return qdata.qid == PM_QID_CLOCK_GET_NAME ? 0 : ret;
+}
+
+/**
+ * zynqmp_pm_clock_enable() - Enable the clock for given id
+ * @clock_id:   ID of the clock to be enabled
+ *
+ * This function is used by master to enable the clock
+ * including peripherals and PLL clocks.
+ *
+ * Return: Returns status, either success or error+reason
+ */
+static int zynqmp_pm_clock_enable(u32 clock_id)
+{
+        return zynqmp_pm_invoke_fn(PM_CLOCK_ENABLE, clock_id, 0, 0, 0, NULL);
+}
+
+/**
+ * zynqmp_pm_clock_disable() - Disable the clock for given id
+ * @clock_id:   ID of the clock to be disable
+ *
+ * This function is used by master to disable the clock
+ * including peripherals and PLL clocks.
+ *
+ * Return: Returns status, either success or error+reason
+ */
+static int zynqmp_pm_clock_disable(u32 clock_id)
+{
+        return zynqmp_pm_invoke_fn(PM_CLOCK_DISABLE, clock_id, 0, 0, 0, NULL);
+}
+
+/**
+ * zynqmp_pm_clock_getstate() - Get the clock state for given id
+ * @clock_id:   ID of the clock to be queried
+ * @state:      1/0 (Enabled/Disabled)
+ *
+ * This function is used by master to get the state of clock
+ * including peripherals and PLL clocks.
+ *
+ * Return: Returns status, either success or error+reason
+ */
+static int zynqmp_pm_clock_getstate(u32 clock_id, u32 *state)
+{
+        u32 ret_payload[PAYLOAD_ARG_CNT];
+        int ret;
+
+        ret = zynqmp_pm_invoke_fn(PM_CLOCK_GETSTATE, clock_id, 0,
+                                  0, 0, ret_payload);
+        *state = ret_payload[1];
+
+        return ret;
+}
+
+/**
+ * zynqmp_pm_clock_setdivider() - Set the clock divider for given id
+ * @clock_id:   ID of the clock
+ * @divider:    divider value
+ *
+ * This function is used by master to set divider for any clock
+ * to achieve desired rate.
+ *
+ * Return: Returns status, either success or error+reason
+ */
+static int zynqmp_pm_clock_setdivider(u32 clock_id, u32 divider)
+{
+        return zynqmp_pm_invoke_fn(PM_CLOCK_SETDIVIDER, clock_id, divider,
+                                   0, 0, NULL);
+}
+
+/**
+ * zynqmp_pm_clock_getdivider() - Get the clock divider for given id
+ * @clock_id:   ID of the clock
+ * @divider:    divider value
+ *
+ * This function is used by master to get divider values
+ * for any clock.
+ *
+ * Return: Returns status, either success or error+reason
+ */
+static int zynqmp_pm_clock_getdivider(u32 clock_id, u32 *divider)
+{
+        u32 ret_payload[PAYLOAD_ARG_CNT];
+        int ret;
+
+        ret = zynqmp_pm_invoke_fn(PM_CLOCK_GETDIVIDER, clock_id, 0,
+                                  0, 0, ret_payload);
+        *divider = ret_payload[1];
+
+        return ret;
+}
+
+/**
+ * zynqmp_pm_clock_setrate() - Set the clock rate for given id
+ * @clock_id:   ID of the clock
+ * @rate:       rate value in hz
+ *
+ * This function is used by master to set rate for any clock.
+ *
+ * Return: Returns status, either success or error+reason
+ */
+static int zynqmp_pm_clock_setrate(u32 clock_id, u64 rate)
+{
+        return zynqmp_pm_invoke_fn(PM_CLOCK_SETRATE, clock_id,
+                                   lower_32_bits(rate),
+                                   upper_32_bits(rate),
+                                   0, NULL);
+}
+
+/**
+ * zynqmp_pm_clock_getrate() - Get the clock rate for given id
+ * @clock_id:   ID of the clock
+ * @rate:       rate value in hz
+ *
+ * This function is used by master to get rate
+ * for any clock.
+ *
+ * Return: Returns status, either success or error+reason
+ */
+static int zynqmp_pm_clock_getrate(u32 clock_id, u64 *rate)
+{
+        u32 ret_payload[PAYLOAD_ARG_CNT];
+        int ret;
+
+        ret = zynqmp_pm_invoke_fn(PM_CLOCK_GETRATE, clock_id, 0,
+                                  0, 0, ret_payload);
+        *rate = ((u64)ret_payload[2] << 32) | ret_payload[1];
+
+        return ret;
+}
+
+/**
+ * zynqmp_pm_clock_setparent() - Set the clock parent for given id
+ * @clock_id:   ID of the clock
+ * @parent_id:  parent id
+ *
+ * This function is used by master to set parent for any clock.
+ *
+ * Return: Returns status, either success or error+reason
+ */
+static int zynqmp_pm_clock_setparent(u32 clock_id, u32 parent_id)
+{
+        return zynqmp_pm_invoke_fn(PM_CLOCK_SETPARENT, clock_id,
+                                   parent_id, 0, 0, NULL);
+}
+
+/**
+ * zynqmp_pm_clock_getparent() - Get the clock parent for given id
+ * @clock_id:   ID of the clock
+ * @parent_id:  parent id
+ *
+ * This function is used by master to get parent index
+ * for any clock.
+ *
+ * Return: Returns status, either success or error+reason
+ */
+static int zynqmp_pm_clock_getparent(u32 clock_id, u32 *parent_id)
+{
+        u32 ret_payload[PAYLOAD_ARG_CNT];
+        int ret;
+
+        ret = zynqmp_pm_invoke_fn(PM_CLOCK_GETPARENT, clock_id, 0,
+                                  0, 0, ret_payload);
+        *parent_id = ret_payload[1];
+
+        return ret;
+}
+
+/**
+ * zynqmp_is_valid_ioctl() - Check whether IOCTL ID is valid or not
+ * @ioctl_id:   IOCTL ID
+ *
+ * Return: 1 if IOCTL is valid else 0
+ */
+static inline int zynqmp_is_valid_ioctl(u32 ioctl_id)
+{
+        switch (ioctl_id) {
+        case IOCTL_SET_PLL_FRAC_MODE:
+        case IOCTL_GET_PLL_FRAC_MODE:
+        case IOCTL_SET_PLL_FRAC_DATA:
+        case IOCTL_GET_PLL_FRAC_DATA:
+                return 1;
+        default:
+                return 0;
+        }
+}
+
+/**
+ * zynqmp_pm_ioctl() - PM IOCTL API for device control and configs
+ * @node_id:    Node ID of the device
+ * @ioctl_id:   ID of the requested IOCTL
+ * @arg1:       Argument 1 to requested IOCTL call
+ * @arg2:       Argument 2 to requested IOCTL call
+ * @out:        Returned output value
+ *
+ * This function calls IOCTL to firmware for device control and configuration.
+ *
+ * Return: Returns status, either success or error+reason
+ */
+static int zynqmp_pm_ioctl(u32 node_id, u32 ioctl_id, u32 arg1, u32 arg2,
+                           u32 *out)
+{
+        if (!zynqmp_is_valid_ioctl(ioctl_id))
+                return -EINVAL;
+
+        return zynqmp_pm_invoke_fn(PM_IOCTL, node_id, ioctl_id,
+                                   arg1, arg2, out);
+}
+
+static const struct zynqmp_eemi_ops eemi_ops = {
+        .get_api_version = zynqmp_pm_get_api_version,
+        .query_data = zynqmp_pm_query_data,
+        .clock_enable = zynqmp_pm_clock_enable,
+        .clock_disable = zynqmp_pm_clock_disable,
+        .clock_getstate = zynqmp_pm_clock_getstate,
+        .clock_setdivider = zynqmp_pm_clock_setdivider,
+        .clock_getdivider = zynqmp_pm_clock_getdivider,
+        .clock_setrate = zynqmp_pm_clock_setrate,
+        .clock_getrate = zynqmp_pm_clock_getrate,
+        .clock_setparent = zynqmp_pm_clock_setparent,
+        .clock_getparent = zynqmp_pm_clock_getparent,
+        .ioctl = zynqmp_pm_ioctl,
+};
+
+/**
+ * zynqmp_pm_get_eemi_ops - Get eemi ops functions
+ *
+ * Return: Pointer of eemi_ops structure
+ */
+const struct zynqmp_eemi_ops *zynqmp_pm_get_eemi_ops(void)
+{
+        return &eemi_ops;
+}
+EXPORT_SYMBOL_GPL(zynqmp_pm_get_eemi_ops);
+
+static int zynqmp_firmware_probe(struct platform_device *pdev)
+{
+        struct device *dev = &pdev->dev;
+        struct device_node *np;
+        int ret;
+
+        np = of_find_compatible_node(NULL, NULL, "xlnx,zynqmp");
+        if (!np)
+                return 0;
+        of_node_put(np);
+
+        ret = get_set_conduit_method(dev->of_node);
+        if (ret)
+                return ret;
+
+        /* Check PM API version number */
+        zynqmp_pm_get_api_version(&pm_api_version);
+        if (pm_api_version < ZYNQMP_PM_VERSION) {
+                panic("%s Platform Management API version error. Expected: v%d.%d - Found: v%d.%d\n",
+                      __func__,
+                      ZYNQMP_PM_VERSION_MAJOR, ZYNQMP_PM_VERSION_MINOR,
+                      pm_api_version >> 16, pm_api_version & 0xFFFF);
+        }
+
+        pr_info("%s Platform Management API v%d.%d\n", __func__,
+                pm_api_version >> 16, pm_api_version & 0xFFFF);
+
+        /* Check trustzone version number */
+        ret = zynqmp_pm_get_trustzone_version(&pm_tz_version);
+        if (ret)
+                panic("Legacy trustzone found without version support\n");
+
+        if (pm_tz_version < ZYNQMP_TZ_VERSION)
+                panic("%s Trustzone version error. Expected: v%d.%d - Found: v%d.%d\n",
+                      __func__,
+                      ZYNQMP_TZ_VERSION_MAJOR, ZYNQMP_TZ_VERSION_MINOR,
+                      pm_tz_version >> 16, pm_tz_version & 0xFFFF);
+
+        pr_info("%s Trustzone version v%d.%d\n", __func__,
+                pm_tz_version >> 16, pm_tz_version & 0xFFFF);
+
+        zynqmp_pm_api_debugfs_init();
+
+        return of_platform_populate(dev->of_node, NULL, NULL, dev);
+}
+
+static int zynqmp_firmware_remove(struct platform_device *pdev)
+{
+        zynqmp_pm_api_debugfs_exit();
+
+        return 0;
+}
+
+static const struct of_device_id zynqmp_firmware_of_match[] = {
+        {.compatible = "xlnx,zynqmp-firmware"},
+        {},
+};
+MODULE_DEVICE_TABLE(of, zynqmp_firmware_of_match);
+
+static struct platform_driver zynqmp_firmware_driver = {
+        .driver = {
+                .name = "zynqmp_firmware",
+                .of_match_table = zynqmp_firmware_of_match,
+        },
+        .probe = zynqmp_firmware_probe,
+        .remove = zynqmp_firmware_remove,
+};
+module_platform_driver(zynqmp_firmware_driver);