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

Pull ARM SoC driver updates from Arnd Bergmann:
 "Driver updates for ARM SoCs, including a couple of newly added
  drivers:

   - The Qualcomm external bus interface 2 (EBI2), used in some of their
     mobile phone chips for connecting flash memory, LCD displays or
     other peripherals

   - Secure monitor firmware for Amlogic SoCs, and an NVMEM driver for
     the EFUSE based on that firmware interface.

   - Perf support for the AppliedMicro X-Gene performance monitor unit

   - Reset driver for STMicroelectronics STM32

   - Reset driver for SocioNext UniPhier SoCs

  Aside from these, there are minor updates to SoC-specific bus,
  clocksource, firmware, pinctrl, reset, rtc and pmic drivers"

* tag 'armsoc-drivers' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc: (50 commits)
  bus: qcom-ebi2: depend on HAS_IOMEM
  pinctrl: mvebu: orion5x: Generalise mv88f5181l support for 88f5181
  clk: mvebu: Add clk support for the orion5x SoC mv88f5181
  dt-bindings: EXYNOS: Add Exynos5433 PMU compatible
  clocksource: exynos_mct: Add the support for ARM64
  perf: xgene: Add APM X-Gene SoC Performance Monitoring Unit driver
  Documentation: Add documentation for APM X-Gene SoC PMU DTS binding
  MAINTAINERS: Add entry for APM X-Gene SoC PMU driver
  bus: qcom: add EBI2 driver
  bus: qcom: add EBI2 device tree bindings
  rtc: rtc-pm8xxx: Add support for pm8018 rtc
  nvmem: amlogic: Add Amlogic Meson EFUSE driver
  firmware: Amlogic: Add secure monitor driver
  soc: qcom: smd: Reset rx tail rather than tx
  memory: atmel-sdramc: fix a possible NULL dereference
  reset: hi6220: allow to compile test driver on other architectures
  reset: zynq: add driver Kconfig option
  reset: sunxi: add driver Kconfig option
  reset: stm32: add driver Kconfig option
  reset: socfpga: add driver Kconfig option
  ...

6 files changed, 265 insertions, 14 deletions

diff --git a/drivers/firmware/Kconfig b/drivers/firmware/Kconfig
index 0e22f241403b..bca172d42c74 100644
--- a/drivers/firmware/Kconfig
+++ b/drivers/firmware/Kconfig
@@ -209,5 +209,6 @@ config HAVE_ARM_SMCCC
 source "drivers/firmware/broadcom/Kconfig"
 source "drivers/firmware/google/Kconfig"
 source "drivers/firmware/efi/Kconfig"
+source "drivers/firmware/meson/Kconfig"
 
 endmenu
diff --git a/drivers/firmware/Makefile b/drivers/firmware/Makefile
index 44a59dcfc398..898ac41fa8b3 100644
--- a/drivers/firmware/Makefile
+++ b/drivers/firmware/Makefile
@@ -22,6 +22,7 @@ obj-$(CONFIG_QCOM_SCM_32)	+= qcom_scm-32.o
 CFLAGS_qcom_scm-32.o :=$(call as-instr,.arch armv7-a\n.arch_extension sec,-DREQUIRES_SEC=1) -march=armv7-a
 
 obj-y                           += broadcom/
+obj-y                           += meson/
 obj-$(CONFIG_GOOGLE_FIRMWARE)   += google/
 obj-$(CONFIG_EFI)               += efi/
 obj-$(CONFIG_UEFI_CPER)         += efi/
diff --git a/drivers/firmware/meson/Kconfig b/drivers/firmware/meson/Kconfig
new file mode 100644
index 000000000000..170d7e8bcdfb
--- /dev/null
+++ b/drivers/firmware/meson/Kconfig
@@ -0,0 +1,9 @@
+#
+# Amlogic Secure Monitor driver
+#
+config MESON_SM
+        bool
+        default ARCH_MESON
+        depends on ARM64_4K_PAGES
+        help
+          Say y here to enable the Amlogic secure monitor driver
diff --git a/drivers/firmware/meson/Makefile b/drivers/firmware/meson/Makefile
new file mode 100644
index 000000000000..9ab3884f96bc
--- /dev/null
+++ b/drivers/firmware/meson/Makefile
@@ -0,0 +1 @@
+obj-$(CONFIG_MESON_SM) +=       meson_sm.o
diff --git a/drivers/firmware/meson/meson_sm.c b/drivers/firmware/meson/meson_sm.c
new file mode 100644
index 000000000000..b0d254930ed3
--- /dev/null
+++ b/drivers/firmware/meson/meson_sm.c
@@ -0,0 +1,248 @@
+/*
+ * Amlogic Secure Monitor driver
+ *
+ * Copyright (C) 2016 Endless Mobile, Inc.
+ * Author: Carlo Caione <carlo@endlessm.com>
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define pr_fmt(fmt) "meson-sm: " fmt
+
+#include <linux/arm-smccc.h>
+#include <linux/bug.h>
+#include <linux/io.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/printk.h>
+#include <linux/types.h>
+#include <linux/sizes.h>
+
+#include <linux/firmware/meson/meson_sm.h>
+
+struct meson_sm_cmd {
+        unsigned int index;
+        u32 smc_id;
+};
+#define CMD(d, s) { .index = (d), .smc_id = (s), }
+
+struct meson_sm_chip {
+        unsigned int shmem_size;
+        u32 cmd_shmem_in_base;
+        u32 cmd_shmem_out_base;
+        struct meson_sm_cmd cmd[];
+};
+
+struct meson_sm_chip gxbb_chip = {
+        .shmem_size             = SZ_4K,
+        .cmd_shmem_in_base      = 0x82000020,
+        .cmd_shmem_out_base     = 0x82000021,
+        .cmd = {
+                CMD(SM_EFUSE_READ,      0x82000030),
+                CMD(SM_EFUSE_WRITE,     0x82000031),
+                CMD(SM_EFUSE_USER_MAX,  0x82000033),
+                { /* sentinel */ },
+        },
+};
+
+struct meson_sm_firmware {
+        const struct meson_sm_chip *chip;
+        void __iomem *sm_shmem_in_base;
+        void __iomem *sm_shmem_out_base;
+};
+
+static struct meson_sm_firmware fw;
+
+static u32 meson_sm_get_cmd(const struct meson_sm_chip *chip,
+                            unsigned int cmd_index)
+{
+        const struct meson_sm_cmd *cmd = chip->cmd;
+
+        while (cmd->smc_id && cmd->index != cmd_index)
+                cmd++;
+
+        return cmd->smc_id;
+}
+
+static u32 __meson_sm_call(u32 cmd, u32 arg0, u32 arg1, u32 arg2,
+                           u32 arg3, u32 arg4)
+{
+        struct arm_smccc_res res;
+
+        arm_smccc_smc(cmd, arg0, arg1, arg2, arg3, arg4, 0, 0, &res);
+        return res.a0;
+}
+
+static void __iomem *meson_sm_map_shmem(u32 cmd_shmem, unsigned int size)
+{
+        u32 sm_phy_base;
+
+        sm_phy_base = __meson_sm_call(cmd_shmem, 0, 0, 0, 0, 0);
+        if (!sm_phy_base)
+                return 0;
+
+        return ioremap_cache(sm_phy_base, size);
+}
+
+/**
+ * meson_sm_call - generic SMC32 call to the secure-monitor
+ *
+ * @cmd_index:  Index of the SMC32 function ID
+ * @ret:        Returned value
+ * @arg0:       SMC32 Argument 0
+ * @arg1:       SMC32 Argument 1
+ * @arg2:       SMC32 Argument 2
+ * @arg3:       SMC32 Argument 3
+ * @arg4:       SMC32 Argument 4
+ *
+ * Return:      0 on success, a negative value on error
+ */
+int meson_sm_call(unsigned int cmd_index, u32 *ret, u32 arg0,
+                  u32 arg1, u32 arg2, u32 arg3, u32 arg4)
+{
+        u32 cmd, lret;
+
+        if (!fw.chip)
+                return -ENOENT;
+
+        cmd = meson_sm_get_cmd(fw.chip, cmd_index);
+        if (!cmd)
+                return -EINVAL;
+
+        lret = __meson_sm_call(cmd, arg0, arg1, arg2, arg3, arg4);
+
+        if (ret)
+                *ret = lret;
+
+        return 0;
+}
+EXPORT_SYMBOL(meson_sm_call);
+
+/**
+ * meson_sm_call_read - retrieve data from secure-monitor
+ *
+ * @buffer:     Buffer to store the retrieved data
+ * @cmd_index:  Index of the SMC32 function ID
+ * @arg0:       SMC32 Argument 0
+ * @arg1:       SMC32 Argument 1
+ * @arg2:       SMC32 Argument 2
+ * @arg3:       SMC32 Argument 3
+ * @arg4:       SMC32 Argument 4
+ *
+ * Return:      size of read data on success, a negative value on error
+ */
+int meson_sm_call_read(void *buffer, unsigned int cmd_index, u32 arg0,
+                       u32 arg1, u32 arg2, u32 arg3, u32 arg4)
+{
+        u32 size;
+
+        if (!fw.chip)
+                return -ENOENT;
+
+        if (!fw.chip->cmd_shmem_out_base)
+                return -EINVAL;
+
+        if (meson_sm_call(cmd_index, &size, arg0, arg1, arg2, arg3, arg4) < 0)
+                return -EINVAL;
+
+        if (!size || size > fw.chip->shmem_size)
+                return -EINVAL;
+
+        if (buffer)
+                memcpy(buffer, fw.sm_shmem_out_base, size);
+
+        return size;
+}
+EXPORT_SYMBOL(meson_sm_call_read);
+
+/**
+ * meson_sm_call_write - send data to secure-monitor
+ *
+ * @buffer:     Buffer containing data to send
+ * @size:       Size of the data to send
+ * @cmd_index:  Index of the SMC32 function ID
+ * @arg0:       SMC32 Argument 0
+ * @arg1:       SMC32 Argument 1
+ * @arg2:       SMC32 Argument 2
+ * @arg3:       SMC32 Argument 3
+ * @arg4:       SMC32 Argument 4
+ *
+ * Return:      size of sent data on success, a negative value on error
+ */
+int meson_sm_call_write(void *buffer, unsigned int size, unsigned int cmd_index,
+                        u32 arg0, u32 arg1, u32 arg2, u32 arg3, u32 arg4)
+{
+        u32 written;
+
+        if (!fw.chip)
+                return -ENOENT;
+
+        if (size > fw.chip->shmem_size)
+                return -EINVAL;
+
+        if (!fw.chip->cmd_shmem_in_base)
+                return -EINVAL;
+
+        memcpy(fw.sm_shmem_in_base, buffer, size);
+
+        if (meson_sm_call(cmd_index, &written, arg0, arg1, arg2, arg3, arg4) < 0)
+                return -EINVAL;
+
+        if (!written)
+                return -EINVAL;
+
+        return written;
+}
+EXPORT_SYMBOL(meson_sm_call_write);
+
+static const struct of_device_id meson_sm_ids[] = {
+        { .compatible = "amlogic,meson-gxbb-sm", .data = &gxbb_chip },
+        { /* sentinel */ },
+};
+
+int __init meson_sm_init(void)
+{
+        const struct meson_sm_chip *chip;
+        const struct of_device_id *matched_np;
+        struct device_node *np;
+
+        np = of_find_matching_node_and_match(NULL, meson_sm_ids, &matched_np);
+        if (!np)
+                return -ENODEV;
+
+        chip = matched_np->data;
+        if (!chip) {
+                pr_err("unable to setup secure-monitor data\n");
+                goto out;
+        }
+
+        if (chip->cmd_shmem_in_base) {
+                fw.sm_shmem_in_base = meson_sm_map_shmem(chip->cmd_shmem_in_base,
+                                                         chip->shmem_size);
+                if (WARN_ON(!fw.sm_shmem_in_base))
+                        goto out;
+        }
+
+        if (chip->cmd_shmem_out_base) {
+                fw.sm_shmem_out_base = meson_sm_map_shmem(chip->cmd_shmem_out_base,
+                                                          chip->shmem_size);
+                if (WARN_ON(!fw.sm_shmem_out_base))
+                        goto out_in_base;
+        }
+
+        fw.chip = chip;
+        pr_info("secure-monitor enabled\n");
+
+        return 0;
+
+out_in_base:
+        iounmap(fw.sm_shmem_in_base);
+out:
+        return -EINVAL;
+}
+device_initcall(meson_sm_init);
diff --git a/drivers/firmware/qcom_scm.c b/drivers/firmware/qcom_scm.c
index e64a501adbf4..d95c70227c05 100644
--- a/drivers/firmware/qcom_scm.c
+++ b/drivers/firmware/qcom_scm.c
@@ -1,4 +1,7 @@
-/* Copyright (c) 2010,2015, The Linux Foundation. All rights reserved.
+/*
+ * Qualcomm SCM driver
+ *
+ * Copyright (c) 2010,2015, The Linux Foundation. All rights reserved.
  * Copyright (C) 2015 Linaro Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
@@ -12,7 +15,7 @@
  *
  */
 #include <linux/platform_device.h>
-#include <linux/module.h>
+#include <linux/init.h>
 #include <linux/cpumask.h>
 #include <linux/export.h>
 #include <linux/dma-mapping.h>
@@ -376,8 +379,6 @@ static const struct of_device_id qcom_scm_dt_match[] = {
         {}
 };
 
-MODULE_DEVICE_TABLE(of, qcom_scm_dt_match);
-
 static struct platform_driver qcom_scm_driver = {
         .driver = {
                 .name   = "qcom_scm",
@@ -414,14 +415,4 @@ static int __init qcom_scm_init(void)
 
         return platform_driver_register(&qcom_scm_driver);
 }
-
 subsys_initcall(qcom_scm_init);
-
-static void __exit qcom_scm_exit(void)
-{
-        platform_driver_unregister(&qcom_scm_driver);
-}
-module_exit(qcom_scm_exit);
-
-MODULE_DESCRIPTION("Qualcomm SCM driver");
-MODULE_LICENSE("GPL v2");