Merge tag 'armsoc-drivers' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc

Pull ARM SoC driver updates from Olof Johansson:
 "Misc driver updates for platforms, many of them power related.

   - Rockchip adds power domain support for rk3066 and rk3188

   - Amlogic adds a power measurement driver

   - Allwinner adds SRAM support for three platforms (F1C100, H5, A64
     C1)

   - Wakeup and ti-sysc (platform bus) fixes for OMAP/DRA7

   - Broadcom fixes suspend/resume with Thumb2 kernels, and improves
     stability of a handful of firmware/platform interfaces

   - PXA completes their conversion to dmaengine framework

   - Renesas does a bunch of PM cleanups across many platforms

   - Tegra adds support for suspend/resume on T186/T194, which includes
     some driver cleanups and addition of wake events

   - Tegra also adds a driver for memory controller (EMC) on Tegra2

   - i.MX tweaks power domain bindings, and adds support for i.MX8MQ in
     GPC

   - Atmel adds identifiers and LPDDR2 support for a new SoC, SAM9X60

  and misc cleanups across several platforms"

* tag 'armsoc-drivers' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc: (73 commits)
  ARM: at91: add support in soc driver for new SAM9X60
  ARM: at91: add support in soc driver for LPDDR2 SiP
  memory: omap-gpmc: Use of_node_name_eq for node name comparisons
  bus: ti-sysc: Check for no-reset and no-idle flags at the child level
  ARM: OMAP2+: Check also the first dts child for hwmod flags
  soc: amlogic: meson-clk-measure: Add missing REGMAP_MMIO dependency
  soc: imx: gpc: Increase GPC_CLK_MAX to 7
  soc: renesas: rcar-sysc: Fix power domain control after system resume
  soc: renesas: rcar-sysc: Merge PM Domain registration and linking
  soc: renesas: rcar-sysc: Remove rcar_sysc_power_{down,up}() helpers
  soc: renesas: r8a77990-sysc: Fix initialization order of 3DG-{A,B}
  dt-bindings: sram: sunxi: Add compatible for the A64 SRAM C1
  dt-bindings: sram: sunxi: Add bindings for the H5 with SRAM C1
  dt-bindings: sram: Add Allwinner suniv F1C100s
  soc: sunxi: sram: Add support for the H5 SoC system control
  soc: sunxi: sram: Enable EMAC clock access for H3 variant
  soc: imx: gpcv2: add support for i.MX8MQ SoC
  soc: imx: gpcv2: move register access table to domain data
  soc: imx: gpcv2: prefix i.MX7 specific defines
  dmaengine: pxa: make the filter function internal
  ...

6 files changed, 442 insertions, 60 deletions

diff --git a/drivers/firmware/imx/Kconfig b/drivers/firmware/imx/Kconfig
index b170c2851e48..6a7a7c2c5b5f 100644
--- a/drivers/firmware/imx/Kconfig
+++ b/drivers/firmware/imx/Kconfig
@@ -9,3 +9,9 @@ config IMX_SCU
 
           This driver manages the IPC interface between host CPU and the
           SCU firmware running on M4.
+
+config IMX_SCU_PD
+        bool "IMX SCU Power Domain driver"
+        depends on IMX_SCU
+        help
+          The System Controller Firmware (SCFW) based power domain driver.
diff --git a/drivers/firmware/imx/Makefile b/drivers/firmware/imx/Makefile
index 0ac04dfda8d4..1b2e15b3c9ca 100644
--- a/drivers/firmware/imx/Makefile
+++ b/drivers/firmware/imx/Makefile
@@ -1,2 +1,3 @@
 # SPDX-License-Identifier: GPL-2.0
-obj-$(CONFIG_IMX_SCU)   += imx-scu.o misc.o
+obj-$(CONFIG_IMX_SCU)           += imx-scu.o misc.o
+obj-$(CONFIG_IMX_SCU_PD)        += scu-pd.o
diff --git a/drivers/firmware/imx/scu-pd.c b/drivers/firmware/imx/scu-pd.c
new file mode 100644
index 000000000000..407245f2efd0
--- /dev/null
+++ b/drivers/firmware/imx/scu-pd.c
@@ -0,0 +1,339 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ * Copyright 2017-2018 NXP
+ *      Dong Aisheng <aisheng.dong@nxp.com>
+ *
+ * Implementation of the SCU based Power Domains
+ *
+ * NOTE: a better implementation suggested by Ulf Hansson is using a
+ * single global power domain and implement the ->attach|detach_dev()
+ * callback for the genpd and use the regular of_genpd_add_provider_simple().
+ * From within the ->attach_dev(), we could get the OF node for
+ * the device that is being attached and then parse the power-domain
+ * cell containing the "resource id" and store that in the per device
+ * struct generic_pm_domain_data (we have void pointer there for
+ * storing these kind of things).
+ *
+ * Additionally, we need to implement the ->stop() and ->start()
+ * callbacks of genpd, which is where you "power on/off" devices,
+ * rather than using the above ->power_on|off() callbacks.
+ *
+ * However, there're two known issues:
+ * 1. The ->attach_dev() of power domain infrastructure still does
+ *    not support multi domains case as the struct device *dev passed
+ *    in is a virtual PD device, it does not help for parsing the real
+ *    device resource id from device tree, so it's unware of which
+ *    real sub power domain of device should be attached.
+ *
+ *    The framework needs some proper extension to support multi power
+ *    domain cases.
+ *
+ * 2. It also breaks most of current drivers as the driver probe sequence
+ *    behavior changed if removing ->power_on|off() callback and use
+ *    ->start() and ->stop() instead. genpd_dev_pm_attach will only power
+ *    up the domain and attach device, but will not call .start() which
+ *    relies on device runtime pm. That means the device power is still
+ *    not up before running driver probe function. For SCU enabled
+ *    platforms, all device drivers accessing registers/clock without power
+ *    domain enabled will trigger a HW access error. That means we need fix
+ *    most drivers probe sequence with proper runtime pm.
+ *
+ * In summary, we need fix above two issue before being able to switch to
+ * the "single global power domain" way.
+ *
+ */
+
+#include <dt-bindings/firmware/imx/rsrc.h>
+#include <linux/firmware/imx/sci.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/of_platform.h>
+#include <linux/platform_device.h>
+#include <linux/pm.h>
+#include <linux/pm_domain.h>
+#include <linux/slab.h>
+
+/* SCU Power Mode Protocol definition */
+struct imx_sc_msg_req_set_resource_power_mode {
+        struct imx_sc_rpc_msg hdr;
+        u16 resource;
+        u8 mode;
+} __packed;
+
+#define IMX_SCU_PD_NAME_SIZE 20
+struct imx_sc_pm_domain {
+        struct generic_pm_domain pd;
+        char name[IMX_SCU_PD_NAME_SIZE];
+        u32 rsrc;
+};
+
+struct imx_sc_pd_range {
+        char *name;
+        u32 rsrc;
+        u8 num;
+        bool postfix;
+};
+
+struct imx_sc_pd_soc {
+        const struct imx_sc_pd_range *pd_ranges;
+        u8 num_ranges;
+};
+
+static const struct imx_sc_pd_range imx8qxp_scu_pd_ranges[] = {
+        /* LSIO SS */
+        { "lsio-pwm", IMX_SC_R_PWM_0, 8, 1 },
+        { "lsio-gpio", IMX_SC_R_GPIO_0, 8, 1 },
+        { "lsio-gpt", IMX_SC_R_GPT_0, 5, 1 },
+        { "lsio-kpp", IMX_SC_R_KPP, 1, 0 },
+        { "lsio-fspi", IMX_SC_R_FSPI_0, 2, 1 },
+        { "lsio-mu", IMX_SC_R_MU_0A, 14, 1 },
+
+        /* CONN SS */
+        { "con-usb", IMX_SC_R_USB_0, 2, 1 },
+        { "con-usb0phy", IMX_SC_R_USB_0_PHY, 1, 0 },
+        { "con-usb2", IMX_SC_R_USB_2, 1, 0 },
+        { "con-usb2phy", IMX_SC_R_USB_2_PHY, 1, 0 },
+        { "con-sdhc", IMX_SC_R_SDHC_0, 3, 1 },
+        { "con-enet", IMX_SC_R_ENET_0, 2, 1 },
+        { "con-nand", IMX_SC_R_NAND, 1, 0 },
+        { "con-mlb", IMX_SC_R_MLB_0, 1, 1 },
+
+        /* Audio DMA SS */
+        { "adma-audio-pll0", IMX_SC_R_AUDIO_PLL_0, 1, 0 },
+        { "adma-audio-pll1", IMX_SC_R_AUDIO_PLL_1, 1, 0 },
+        { "adma-audio-clk-0", IMX_SC_R_AUDIO_CLK_0, 1, 0 },
+        { "adma-dma0-ch", IMX_SC_R_DMA_0_CH0, 16, 1 },
+        { "adma-dma1-ch", IMX_SC_R_DMA_1_CH0, 16, 1 },
+        { "adma-dma2-ch", IMX_SC_R_DMA_2_CH0, 5, 1 },
+        { "adma-asrc0", IMX_SC_R_ASRC_0, 1, 0 },
+        { "adma-asrc1", IMX_SC_R_ASRC_1, 1, 0 },
+        { "adma-esai0", IMX_SC_R_ESAI_0, 1, 0 },
+        { "adma-spdif0", IMX_SC_R_SPDIF_0, 1, 0 },
+        { "adma-sai", IMX_SC_R_SAI_0, 3, 1 },
+        { "adma-amix", IMX_SC_R_AMIX, 1, 0 },
+        { "adma-mqs0", IMX_SC_R_MQS_0, 1, 0 },
+        { "adma-dsp", IMX_SC_R_DSP, 1, 0 },
+        { "adma-dsp-ram", IMX_SC_R_DSP_RAM, 1, 0 },
+        { "adma-can", IMX_SC_R_CAN_0, 3, 1 },
+        { "adma-ftm", IMX_SC_R_FTM_0, 2, 1 },
+        { "adma-lpi2c", IMX_SC_R_I2C_0, 4, 1 },
+        { "adma-adc", IMX_SC_R_ADC_0, 1, 1 },
+        { "adma-lcd", IMX_SC_R_LCD_0, 1, 1 },
+        { "adma-lcd0-pwm", IMX_SC_R_LCD_0_PWM_0, 1, 1 },
+        { "adma-lpuart", IMX_SC_R_UART_0, 4, 1 },
+        { "adma-lpspi", IMX_SC_R_SPI_0, 4, 1 },
+
+        /* VPU SS  */
+        { "vpu", IMX_SC_R_VPU, 1, 0 },
+        { "vpu-pid", IMX_SC_R_VPU_PID0, 8, 1 },
+        { "vpu-dec0", IMX_SC_R_VPU_DEC_0, 1, 0 },
+        { "vpu-enc0", IMX_SC_R_VPU_ENC_0, 1, 0 },
+
+        /* GPU SS */
+        { "gpu0-pid", IMX_SC_R_GPU_0_PID0, 4, 1 },
+
+        /* HSIO SS */
+        { "hsio-pcie-b", IMX_SC_R_PCIE_B, 1, 0 },
+        { "hsio-serdes-1", IMX_SC_R_SERDES_1, 1, 0 },
+        { "hsio-gpio", IMX_SC_R_HSIO_GPIO, 1, 0 },
+
+        /* MIPI/LVDS SS */
+        { "mipi0", IMX_SC_R_MIPI_0, 1, 0 },
+        { "mipi0-pwm0", IMX_SC_R_MIPI_0_PWM_0, 1, 0 },
+        { "mipi0-i2c", IMX_SC_R_MIPI_0_I2C_0, 2, 1 },
+        { "lvds0", IMX_SC_R_LVDS_0, 1, 0 },
+
+        /* DC SS */
+        { "dc0", IMX_SC_R_DC_0, 1, 0 },
+        { "dc0-pll", IMX_SC_R_DC_0_PLL_0, 2, 1 },
+};
+
+static const struct imx_sc_pd_soc imx8qxp_scu_pd = {
+        .pd_ranges = imx8qxp_scu_pd_ranges,
+        .num_ranges = ARRAY_SIZE(imx8qxp_scu_pd_ranges),
+};
+
+static struct imx_sc_ipc *pm_ipc_handle;
+
+static inline struct imx_sc_pm_domain *
+to_imx_sc_pd(struct generic_pm_domain *genpd)
+{
+        return container_of(genpd, struct imx_sc_pm_domain, pd);
+}
+
+static int imx_sc_pd_power(struct generic_pm_domain *domain, bool power_on)
+{
+        struct imx_sc_msg_req_set_resource_power_mode msg;
+        struct imx_sc_rpc_msg *hdr = &msg.hdr;
+        struct imx_sc_pm_domain *pd;
+        int ret;
+
+        pd = to_imx_sc_pd(domain);
+
+        hdr->ver = IMX_SC_RPC_VERSION;
+        hdr->svc = IMX_SC_RPC_SVC_PM;
+        hdr->func = IMX_SC_PM_FUNC_SET_RESOURCE_POWER_MODE;
+        hdr->size = 2;
+
+        msg.resource = pd->rsrc;
+        msg.mode = power_on ? IMX_SC_PM_PW_MODE_ON : IMX_SC_PM_PW_MODE_LP;
+
+        ret = imx_scu_call_rpc(pm_ipc_handle, &msg, true);
+        if (ret)
+                dev_err(&domain->dev, "failed to power %s resource %d ret %d\n",
+                        power_on ? "up" : "off", pd->rsrc, ret);
+
+        return ret;
+}
+
+static int imx_sc_pd_power_on(struct generic_pm_domain *domain)
+{
+        return imx_sc_pd_power(domain, true);
+}
+
+static int imx_sc_pd_power_off(struct generic_pm_domain *domain)
+{
+        return imx_sc_pd_power(domain, false);
+}
+
+static struct generic_pm_domain *imx_scu_pd_xlate(struct of_phandle_args *spec,
+                                                  void *data)
+{
+        struct generic_pm_domain *domain = ERR_PTR(-ENOENT);
+        struct genpd_onecell_data *pd_data = data;
+        unsigned int i;
+
+        for (i = 0; i < pd_data->num_domains; i++) {
+                struct imx_sc_pm_domain *sc_pd;
+
+                sc_pd = to_imx_sc_pd(pd_data->domains[i]);
+                if (sc_pd->rsrc == spec->args[0]) {
+                        domain = &sc_pd->pd;
+                        break;
+                }
+        }
+
+        return domain;
+}
+
+static struct imx_sc_pm_domain *
+imx_scu_add_pm_domain(struct device *dev, int idx,
+                      const struct imx_sc_pd_range *pd_ranges)
+{
+        struct imx_sc_pm_domain *sc_pd;
+        int ret;
+
+        sc_pd = devm_kzalloc(dev, sizeof(*sc_pd), GFP_KERNEL);
+        if (!sc_pd)
+                return ERR_PTR(-ENOMEM);
+
+        sc_pd->rsrc = pd_ranges->rsrc + idx;
+        sc_pd->pd.power_off = imx_sc_pd_power_off;
+        sc_pd->pd.power_on = imx_sc_pd_power_on;
+
+        if (pd_ranges->postfix)
+                snprintf(sc_pd->name, sizeof(sc_pd->name),
+                         "%s%i", pd_ranges->name, idx);
+        else
+                snprintf(sc_pd->name, sizeof(sc_pd->name),
+                         "%s", pd_ranges->name);
+
+        sc_pd->pd.name = sc_pd->name;
+
+        if (sc_pd->rsrc >= IMX_SC_R_LAST) {
+                dev_warn(dev, "invalid pd %s rsrc id %d found",
+                         sc_pd->name, sc_pd->rsrc);
+
+                devm_kfree(dev, sc_pd);
+                return NULL;
+        }
+
+        ret = pm_genpd_init(&sc_pd->pd, NULL, true);
+        if (ret) {
+                dev_warn(dev, "failed to init pd %s rsrc id %d",
+                         sc_pd->name, sc_pd->rsrc);
+                devm_kfree(dev, sc_pd);
+                return NULL;
+        }
+
+        return sc_pd;
+}
+
+static int imx_scu_init_pm_domains(struct device *dev,
+                                    const struct imx_sc_pd_soc *pd_soc)
+{
+        const struct imx_sc_pd_range *pd_ranges = pd_soc->pd_ranges;
+        struct generic_pm_domain **domains;
+        struct genpd_onecell_data *pd_data;
+        struct imx_sc_pm_domain *sc_pd;
+        u32 count = 0;
+        int i, j;
+
+        for (i = 0; i < pd_soc->num_ranges; i++)
+                count += pd_ranges[i].num;
+
+        domains = devm_kcalloc(dev, count, sizeof(*domains), GFP_KERNEL);
+        if (!domains)
+                return -ENOMEM;
+
+        pd_data = devm_kzalloc(dev, sizeof(*pd_data), GFP_KERNEL);
+        if (!pd_data)
+                return -ENOMEM;
+
+        count = 0;
+        for (i = 0; i < pd_soc->num_ranges; i++) {
+                for (j = 0; j < pd_ranges[i].num; j++) {
+                        sc_pd = imx_scu_add_pm_domain(dev, j, &pd_ranges[i]);
+                        if (IS_ERR_OR_NULL(sc_pd))
+                                continue;
+
+                        domains[count++] = &sc_pd->pd;
+                        dev_dbg(dev, "added power domain %s\n", sc_pd->pd.name);
+                }
+        }
+
+        pd_data->domains = domains;
+        pd_data->num_domains = count;
+        pd_data->xlate = imx_scu_pd_xlate;
+
+        of_genpd_add_provider_onecell(dev->of_node, pd_data);
+
+        return 0;
+}
+
+static int imx_sc_pd_probe(struct platform_device *pdev)
+{
+        const struct imx_sc_pd_soc *pd_soc;
+        int ret;
+
+        ret = imx_scu_get_handle(&pm_ipc_handle);
+        if (ret)
+                return ret;
+
+        pd_soc = of_device_get_match_data(&pdev->dev);
+        if (!pd_soc)
+                return -ENODEV;
+
+        return imx_scu_init_pm_domains(&pdev->dev, pd_soc);
+}
+
+static const struct of_device_id imx_sc_pd_match[] = {
+        { .compatible = "fsl,imx8qxp-scu-pd", &imx8qxp_scu_pd},
+        { /* sentinel */ }
+};
+
+static struct platform_driver imx_sc_pd_driver = {
+        .driver = {
+                .name = "imx-scu-pd",
+                .of_match_table = imx_sc_pd_match,
+        },
+        .probe = imx_sc_pd_probe,
+};
+builtin_platform_driver(imx_sc_pd_driver);
+
+MODULE_AUTHOR("Dong Aisheng <aisheng.dong@nxp.com>");
+MODULE_DESCRIPTION("IMX SCU Power Domain driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/firmware/raspberrypi.c b/drivers/firmware/raspberrypi.c
index a200a2174611..a13558154ac3 100644
--- a/drivers/firmware/raspberrypi.c
+++ b/drivers/firmware/raspberrypi.c
@@ -1,12 +1,9 @@
+// SPDX-License-Identifier: GPL-2.0
 /*
  * Defines interfaces for interacting wtih the Raspberry Pi firmware's
  * property channel.
  *
  * Copyright © 2015 Broadcom
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
  */
 
 #include <linux/dma-mapping.h>
@@ -14,6 +11,7 @@
 #include <linux/module.h>
 #include <linux/of_platform.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 #include <soc/bcm2835/raspberrypi-firmware.h>
 
 #define MBOX_MSG(chan, data28)          (((data28) & ~0xf) | ((chan) & 0xf))
@@ -21,8 +19,6 @@
 #define MBOX_DATA28(msg)                ((msg) & ~0xf)
 #define MBOX_CHAN_PROPERTY              8
 
-#define MAX_RPI_FW_PROP_BUF_SIZE        32
-
 static struct platform_device *rpi_hwmon;
 
 struct rpi_firmware {
@@ -56,8 +52,12 @@ rpi_firmware_transaction(struct rpi_firmware *fw, u32 chan, u32 data)
         reinit_completion(&fw->c);
         ret = mbox_send_message(fw->chan, &message);
         if (ret >= 0) {
-                wait_for_completion(&fw->c);
-                ret = 0;
+                if (wait_for_completion_timeout(&fw->c, HZ)) {
+                        ret = 0;
+                } else {
+                        ret = -ETIMEDOUT;
+                        WARN_ONCE(1, "Firmware transaction timeout");
+                }
         } else {
                 dev_err(fw->cl.dev, "mbox_send_message returned %d\n", ret);
         }
@@ -144,28 +144,30 @@ EXPORT_SYMBOL_GPL(rpi_firmware_property_list);
 int rpi_firmware_property(struct rpi_firmware *fw,
                           u32 tag, void *tag_data, size_t buf_size)
 {
-        /* Single tags are very small (generally 8 bytes), so the
-         * stack should be safe.
-         */
-        u8 data[sizeof(struct rpi_firmware_property_tag_header) +
-                MAX_RPI_FW_PROP_BUF_SIZE];
-        struct rpi_firmware_property_tag_header *header =
-                (struct rpi_firmware_property_tag_header *)data;
+        struct rpi_firmware_property_tag_header *header;
         int ret;
 
-        if (WARN_ON(buf_size > sizeof(data) - sizeof(*header)))
-                return -EINVAL;
+        /* Some mailboxes can use over 1k bytes. Rather than checking
+         * size and using stack or kmalloc depending on requirements,
+         * just use kmalloc. Mailboxes don't get called enough to worry
+         * too much about the time taken in the allocation.
+         */
+        void *data = kmalloc(sizeof(*header) + buf_size, GFP_KERNEL);
 
+        if (!data)
+                return -ENOMEM;
+
+        header = data;
         header->tag = tag;
         header->buf_size = buf_size;
         header->req_resp_size = 0;
-        memcpy(data + sizeof(struct rpi_firmware_property_tag_header),
-               tag_data, buf_size);
+        memcpy(data + sizeof(*header), tag_data, buf_size);
+
+        ret = rpi_firmware_property_list(fw, data, buf_size + sizeof(*header));
+
+        memcpy(tag_data, data + sizeof(*header), buf_size);
 
-        ret = rpi_firmware_property_list(fw, &data, buf_size + sizeof(*header));
-        memcpy(tag_data,
-               data + sizeof(struct rpi_firmware_property_tag_header),
-               buf_size);
+        kfree(data);
 
         return ret;
 }
diff --git a/drivers/firmware/tegra/bpmp-debugfs.c b/drivers/firmware/tegra/bpmp-debugfs.c
index f7f6a0a5cb07..a84df1a8ca2b 100644
--- a/drivers/firmware/tegra/bpmp-debugfs.c
+++ b/drivers/firmware/tegra/bpmp-debugfs.c
@@ -379,33 +379,6 @@ static int create_debugfs_mirror(struct tegra_bpmp *bpmp, void *buf,
         return err;
 }
 
-static int mrq_is_supported(struct tegra_bpmp *bpmp, unsigned int mrq)
-{
-        struct mrq_query_abi_request req = { .mrq = cpu_to_le32(mrq) };
-        struct mrq_query_abi_response resp;
-        struct tegra_bpmp_message msg = {
-                .mrq = MRQ_QUERY_ABI,
-                .tx = {
-                        .data = &req,
-                        .size = sizeof(req),
-                },
-                .rx = {
-                        .data = &resp,
-                        .size = sizeof(resp),
-                },
-        };
-        int ret;
-
-        ret = tegra_bpmp_transfer(bpmp, &msg);
-        if (ret < 0) {
-                /* something went wrong; assume not supported */
-                dev_warn(bpmp->dev, "tegra_bpmp_transfer failed (%d)\n", ret);
-                return 0;
-        }
-
-        return resp.status ? 0 : 1;
-}
-
 int tegra_bpmp_init_debugfs(struct tegra_bpmp *bpmp)
 {
         dma_addr_t phys;
@@ -415,7 +388,7 @@ int tegra_bpmp_init_debugfs(struct tegra_bpmp *bpmp)
         int ret;
         struct dentry *root;
 
-        if (!mrq_is_supported(bpmp, MRQ_DEBUGFS))
+        if (!tegra_bpmp_mrq_is_supported(bpmp, MRQ_DEBUGFS))
                 return 0;
 
         root = debugfs_create_dir("bpmp", NULL);
diff --git a/drivers/firmware/tegra/bpmp.c b/drivers/firmware/tegra/bpmp.c
index a3d5b518c10e..689478b92bce 100644
--- a/drivers/firmware/tegra/bpmp.c
+++ b/drivers/firmware/tegra/bpmp.c
@@ -28,6 +28,7 @@
 
 #define MSG_ACK         BIT(0)
 #define MSG_RING        BIT(1)
+#define TAG_SZ          32
 
 static inline struct tegra_bpmp *
 mbox_client_to_bpmp(struct mbox_client *client)
@@ -470,6 +471,31 @@ unlock:
 }
 EXPORT_SYMBOL_GPL(tegra_bpmp_free_mrq);
 
+bool tegra_bpmp_mrq_is_supported(struct tegra_bpmp *bpmp, unsigned int mrq)
+{
+        struct mrq_query_abi_request req = { .mrq = cpu_to_le32(mrq) };
+        struct mrq_query_abi_response resp;
+        struct tegra_bpmp_message msg = {
+                .mrq = MRQ_QUERY_ABI,
+                .tx = {
+                        .data = &req,
+                        .size = sizeof(req),
+                },
+                .rx = {
+                        .data = &resp,
+                        .size = sizeof(resp),
+                },
+        };
+        int ret;
+
+        ret = tegra_bpmp_transfer(bpmp, &msg);
+        if (ret || msg.rx.ret)
+                return false;
+
+        return resp.status == 0;
+}
+EXPORT_SYMBOL_GPL(tegra_bpmp_mrq_is_supported);
+
 static void tegra_bpmp_mrq_handle_ping(unsigned int mrq,
                                        struct tegra_bpmp_channel *channel,
                                        void *data)
@@ -521,8 +547,9 @@ static int tegra_bpmp_ping(struct tegra_bpmp *bpmp)
         return err;
 }
 
-static int tegra_bpmp_get_firmware_tag(struct tegra_bpmp *bpmp, char *tag,
-                                       size_t size)
+/* deprecated version of tag query */
+static int tegra_bpmp_get_firmware_tag_old(struct tegra_bpmp *bpmp, char *tag,
+                                           size_t size)
 {
         struct mrq_query_tag_request request;
         struct tegra_bpmp_message msg;
@@ -531,7 +558,10 @@ static int tegra_bpmp_get_firmware_tag(struct tegra_bpmp *bpmp, char *tag,
         void *virt;
         int err;
 
-        virt = dma_alloc_coherent(bpmp->dev, MSG_DATA_MIN_SZ, &phys,
+        if (size != TAG_SZ)
+                return -EINVAL;
+
+        virt = dma_alloc_coherent(bpmp->dev, TAG_SZ, &phys,
                                   GFP_KERNEL | GFP_DMA32);
         if (!virt)
                 return -ENOMEM;
@@ -549,13 +579,44 @@ static int tegra_bpmp_get_firmware_tag(struct tegra_bpmp *bpmp, char *tag,
         local_irq_restore(flags);
 
         if (err == 0)
-                strlcpy(tag, virt, size);
+                memcpy(tag, virt, TAG_SZ);
 
-        dma_free_coherent(bpmp->dev, MSG_DATA_MIN_SZ, virt, phys);
+        dma_free_coherent(bpmp->dev, TAG_SZ, virt, phys);
 
         return err;
 }
 
+static int tegra_bpmp_get_firmware_tag(struct tegra_bpmp *bpmp, char *tag,
+                                       size_t size)
+{
+        if (tegra_bpmp_mrq_is_supported(bpmp, MRQ_QUERY_FW_TAG)) {
+                struct mrq_query_fw_tag_response resp;
+                struct tegra_bpmp_message msg = {
+                        .mrq = MRQ_QUERY_FW_TAG,
+                        .rx = {
+                                .data = &resp,
+                                .size = sizeof(resp),
+                        },
+                };
+                int err;
+
+                if (size != sizeof(resp.tag))
+                        return -EINVAL;
+
+                err = tegra_bpmp_transfer(bpmp, &msg);
+
+                if (err)
+                        return err;
+                if (msg.rx.ret < 0)
+                        return -EINVAL;
+
+                memcpy(tag, resp.tag, sizeof(resp.tag));
+                return 0;
+        }
+
+        return tegra_bpmp_get_firmware_tag_old(bpmp, tag, size);
+}
+
 static void tegra_bpmp_channel_signal(struct tegra_bpmp_channel *channel)
 {
         unsigned long flags = channel->ob->flags;
@@ -664,7 +725,7 @@ static int tegra_bpmp_probe(struct platform_device *pdev)
 {
         struct tegra_bpmp *bpmp;
         unsigned int i;
-        char tag[32];
+        char tag[TAG_SZ];
         size_t size;
         int err;
 
@@ -792,13 +853,13 @@ static int tegra_bpmp_probe(struct platform_device *pdev)
                 goto free_mrq;
         }
 
-        err = tegra_bpmp_get_firmware_tag(bpmp, tag, sizeof(tag) - 1);
+        err = tegra_bpmp_get_firmware_tag(bpmp, tag, sizeof(tag));
         if (err < 0) {
                 dev_err(&pdev->dev, "failed to get firmware tag: %d\n", err);
                 goto free_mrq;
         }
 
-        dev_info(&pdev->dev, "firmware: %s\n", tag);
+        dev_info(&pdev->dev, "firmware: %.*s\n", (int)sizeof(tag), tag);
 
         platform_set_drvdata(pdev, bpmp);