Merge tag 'zynqmp-soc-for-v4.20-v2' of https://github.com/Xilinx/linux-xlnx into next/drivers

arm64: zynqmp: SoC changes for v4.20

- Adding firmware API for SoC with debugfs interface
  Firmware driver communicates to Platform Management Unit (PMU) by using
  SMC instructions routed to Arm Trusted Firmware (ATF). Initial version
  adds support for base firmware driver with query and clock APIs.

  EEMI spec is available here:
  https://www.xilinx.com/support/documentation/user_guides/ug1200-eemi-api.pdf

* tag 'zynqmp-soc-for-v4.20-v2' of https://github.com/Xilinx/linux-xlnx:
  firmware: xilinx: Add debugfs for query data API
  firmware: xilinx: Add debugfs interface
  firmware: xilinx: Add clock APIs
  firmware: xilinx: Add query data API
  firmware: xilinx: Add Zynqmp firmware driver
  dt-bindings: firmware: Add bindings for ZynqMP firmware

Signed-off-by: Arnd Bergmann <arnd@arndb.de>

10 files changed, 970 insertions, 0 deletions

diff --git a/Documentation/devicetree/bindings/firmware/xilinx/xlnx,zynqmp-firmware.txt b/Documentation/devicetree/bindings/firmware/xilinx/xlnx,zynqmp-firmware.txt
new file mode 100644
index 000000000000..1b431d9bbe44
--- /dev/null
+++ b/Documentation/devicetree/bindings/firmware/xilinx/xlnx,zynqmp-firmware.txt
@@ -0,0 +1,29 @@
+-----------------------------------------------------------------
+Device Tree Bindings for the Xilinx Zynq MPSoC Firmware Interface
+-----------------------------------------------------------------
+
+The zynqmp-firmware node describes the interface to platform firmware.
+ZynqMP has an interface to communicate with secure firmware. Firmware
+driver provides an interface to firmware APIs. Interface APIs can be
+used by any driver to communicate to PMUFW(Platform Management Unit).
+These requests include clock management, pin control, device control,
+power management service, FPGA service and other platform management
+services.
+
+Required properties:
+ - compatible:  Must contain:   "xlnx,zynqmp-firmware"
+ - method:      The method of calling the PM-API firmware layer.
+                Permitted values are:
+                  - "smc" : SMC #0, following the SMCCC
+                  - "hvc" : HVC #0, following the SMCCC
+
+-------
+Example
+-------
+
+firmware {
+        zynqmp_firmware: zynqmp-firmware {
+                compatible = "xlnx,zynqmp-firmware";
+                method = "smc";
+        };
+};
diff --git a/arch/arm64/Kconfig.platforms b/arch/arm64/Kconfig.platforms
index 393d2b524284..23f3928743c9 100644
--- a/arch/arm64/Kconfig.platforms
+++ b/arch/arm64/Kconfig.platforms
@@ -301,6 +301,7 @@ config ARCH_ZX
 
 config ARCH_ZYNQMP
         bool "Xilinx ZynqMP Family"
+        select ZYNQMP_FIRMWARE
         help
           This enables support for Xilinx ZynqMP Family
 
diff --git a/drivers/firmware/Kconfig b/drivers/firmware/Kconfig
index 6e83880046d7..36344cba764e 100644
--- a/drivers/firmware/Kconfig
+++ b/drivers/firmware/Kconfig
@@ -291,5 +291,6 @@ source "drivers/firmware/google/Kconfig"
 source "drivers/firmware/efi/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..99583d3df52f 100644
--- a/drivers/firmware/Makefile
+++ b/drivers/firmware/Makefile
@@ -32,3 +32,4 @@ obj-$(CONFIG_GOOGLE_FIRMWARE)	+= google/
 obj-$(CONFIG_EFI)               += efi/
 obj-$(CONFIG_UEFI_CPER)         += efi/
 obj-y                           += tegra/
+obj-y                           += xilinx/
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..84b3fd2eca8b
--- /dev/null
+++ b/drivers/firmware/xilinx/zynqmp.c
@@ -0,0 +1,523 @@
+// 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;
+}
+
+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,
+};
+
+/**
+ * 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);
diff --git a/include/linux/firmware/xlnx-zynqmp.h b/include/linux/firmware/xlnx-zynqmp.h
new file mode 100644
index 000000000000..015e130431e6
--- /dev/null
+++ b/include/linux/firmware/xlnx-zynqmp.h
@@ -0,0 +1,113 @@
+/* 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_H__
+#define __FIRMWARE_ZYNQMP_H__
+
+#define ZYNQMP_PM_VERSION_MAJOR 1
+#define ZYNQMP_PM_VERSION_MINOR 0
+
+#define ZYNQMP_PM_VERSION       ((ZYNQMP_PM_VERSION_MAJOR << 16) | \
+                                        ZYNQMP_PM_VERSION_MINOR)
+
+#define ZYNQMP_TZ_VERSION_MAJOR 1
+#define ZYNQMP_TZ_VERSION_MINOR 0
+
+#define ZYNQMP_TZ_VERSION       ((ZYNQMP_TZ_VERSION_MAJOR << 16) | \
+                                        ZYNQMP_TZ_VERSION_MINOR)
+
+/* SMC SIP service Call Function Identifier Prefix */
+#define PM_SIP_SVC                      0xC2000000
+#define PM_GET_TRUSTZONE_VERSION        0xa03
+
+/* Number of 32bits values in payload */
+#define PAYLOAD_ARG_CNT 4U
+
+enum pm_api_id {
+        PM_GET_API_VERSION = 1,
+        PM_QUERY_DATA = 35,
+        PM_CLOCK_ENABLE,
+        PM_CLOCK_DISABLE,
+        PM_CLOCK_GETSTATE,
+        PM_CLOCK_SETDIVIDER,
+        PM_CLOCK_GETDIVIDER,
+        PM_CLOCK_SETRATE,
+        PM_CLOCK_GETRATE,
+        PM_CLOCK_SETPARENT,
+        PM_CLOCK_GETPARENT,
+};
+
+/* PMU-FW return status codes */
+enum pm_ret_status {
+        XST_PM_SUCCESS = 0,
+        XST_PM_INTERNAL = 2000,
+        XST_PM_CONFLICT,
+        XST_PM_NO_ACCESS,
+        XST_PM_INVALID_NODE,
+        XST_PM_DOUBLE_REQ,
+        XST_PM_ABORT_SUSPEND,
+};
+
+enum pm_ioctl_id {
+        IOCTL_SET_PLL_FRAC_MODE = 8,
+        IOCTL_GET_PLL_FRAC_MODE,
+        IOCTL_SET_PLL_FRAC_DATA,
+        IOCTL_GET_PLL_FRAC_DATA,
+};
+
+enum pm_query_id {
+        PM_QID_INVALID,
+        PM_QID_CLOCK_GET_NAME,
+        PM_QID_CLOCK_GET_TOPOLOGY,
+        PM_QID_CLOCK_GET_FIXEDFACTOR_PARAMS,
+        PM_QID_CLOCK_GET_PARENTS,
+        PM_QID_CLOCK_GET_ATTRIBUTES,
+};
+
+/**
+ * struct zynqmp_pm_query_data - PM query data
+ * @qid:        query ID
+ * @arg1:       Argument 1 of query data
+ * @arg2:       Argument 2 of query data
+ * @arg3:       Argument 3 of query data
+ */
+struct zynqmp_pm_query_data {
+        u32 qid;
+        u32 arg1;
+        u32 arg2;
+        u32 arg3;
+};
+
+struct zynqmp_eemi_ops {
+        int (*get_api_version)(u32 *version);
+        int (*query_data)(struct zynqmp_pm_query_data qdata, u32 *out);
+        int (*clock_enable)(u32 clock_id);
+        int (*clock_disable)(u32 clock_id);
+        int (*clock_getstate)(u32 clock_id, u32 *state);
+        int (*clock_setdivider)(u32 clock_id, u32 divider);
+        int (*clock_getdivider)(u32 clock_id, u32 *divider);
+        int (*clock_setrate)(u32 clock_id, u64 rate);
+        int (*clock_getrate)(u32 clock_id, u64 *rate);
+        int (*clock_setparent)(u32 clock_id, u32 parent_id);
+        int (*clock_getparent)(u32 clock_id, u32 *parent_id);
+};
+
+#if IS_REACHABLE(CONFIG_ARCH_ZYNQMP)
+const struct zynqmp_eemi_ops *zynqmp_pm_get_eemi_ops(void);
+#else
+static inline struct zynqmp_eemi_ops *zynqmp_pm_get_eemi_ops(void)
+{
+        return NULL;
+}
+#endif
+
+#endif /* __FIRMWARE_ZYNQMP_H__ */