[RFC 0/4]Enable rpmsg support on imx amp platforms

[RFC 0/4]Enable rpmsg support on imx amp platforms

[Richard Zhu]

Implement the rpmsg on imx amp platforms, such as imx6sx and imx7d.
Create one imx pingpong sample that demonstrate the data
transactions on imx amp platforms over the rpmsg bus.

[RFC 1/4] ARM: imx: enable rpmsg support on imx amp platforms

[Richard Zhu]

From: Richard Zhu <Richard.Zhu@freescale.com>

enable the rpmsg support on imx amp platforms.
such as imx6sx, and imx7d.

Signed-off-by: Richard Zhu <hongxing.zhu@nxp.com>
---
 arch/arm/boot/dts/Makefile          |  6 ++--
 arch/arm/boot/dts/imx6sx-sdb-m4.dts | 56 +++++++++++++++++++++++++++++++++++++
 arch/arm/boot/dts/imx6sx.dtsi       | 12 ++++++++
 arch/arm/boot/dts/imx7d-sdb-m4.dts  | 44 +++++++++++++++++++++++++++++
 arch/arm/boot/dts/imx7d.dtsi        | 14 ++++++++++
 5 files changed, 130 insertions(+), 2 deletions(-)
 create mode 100644 arch/arm/boot/dts/imx6sx-sdb-m4.dts
 create mode 100644 arch/arm/boot/dts/imx7d-sdb-m4.dts

diff --git a/arch/arm/boot/dts/Makefile b/arch/arm/boot/dts/Makefile
index 30bbc37..5d40c1d 100644
--- a/arch/arm/boot/dts/Makefile
+++ b/arch/arm/boot/dts/Makefile
@@ -346,11 +346,13 @@ dtb-$(CONFIG_SOC_IMX6SL) += \
 dtb-$(CONFIG_SOC_IMX6SX) += \
 	imx6sx-sabreauto.dtb \
 	imx6sx-sdb-reva.dtb \
-	imx6sx-sdb.dtb
+	imx6sx-sdb.dtb \
+	imx6sx-sdb-m4.dtb
 dtb-$(CONFIG_SOC_IMX6UL) += \
 	imx6ul-14x14-evk.dtb
 dtb-$(CONFIG_SOC_IMX7D) += \
-	imx7d-sdb.dtb
+	imx7d-sdb.dtb \
+	imx7d-sdb-m4.dtb
 dtb-$(CONFIG_SOC_LS1021A) += \
 	ls1021a-qds.dtb \
 	ls1021a-twr.dtb
diff --git a/arch/arm/boot/dts/imx6sx-sdb-m4.dts b/arch/arm/boot/dts/imx6sx-sdb-m4.dts
new file mode 100644
index 0000000..3a45301
--- /dev/null
+++ b/arch/arm/boot/dts/imx6sx-sdb-m4.dts
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ *
+ * 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 "imx6sx-sdb.dts"
+
+/*
+ * The following modules are manupulated by M4, should be disabled
+ * at A7/Linux side
+ * ADC1/2, FLEXCAN1/2, I2C3, QSPI2, UART2, WDOG3
+ *
+ */
+
+&adc1 {
+	status = "disabled";
+};
+
+&adc2 {
+	status = "disabled";
+};
+
+&flexcan1 {
+	status = "disabled";
+};
+
+&flexcan2 {
+	status = "disabled";
+};
+
+&i2c3 {
+	status = "disabled";
+};
+
+&mu {
+	status = "okay";
+};
+
+&ocram {
+	reg = <0x00901000 0xf000>;
+};
+
+&qspi2 {
+	status = "disabled";
+};
+
+&rpmsg{
+	status = "okay";
+};
+
+&uart2 {
+	status = "disabled";
+};
diff --git a/arch/arm/boot/dts/imx6sx.dtsi b/arch/arm/boot/dts/imx6sx.dtsi
index 167f77b..47a7f03 100644
--- a/arch/arm/boot/dts/imx6sx.dtsi
+++ b/arch/arm/boot/dts/imx6sx.dtsi
@@ -1184,6 +1184,18 @@
 				status = "disabled";
 			};
 
+			mu: mu@02294000 { /* mu */
+				compatible = "fsl,imx6sx-mu";
+				reg = <0x02294000 0x4000>;
+				interrupts = <0 90 0x04>;
+				status = "disabled";
+			};
+
+			rpmsg: rpmsg{
+				compatible = "fsl,imx6sx-rpmsg";
+				status = "disabled";
+			};
+
 			uart6: serial@022a0000 {
 				compatible = "fsl,imx6sx-uart", "fsl,imx21-uart";
 				reg = <0x022a0000 0x4000>;
diff --git a/arch/arm/boot/dts/imx7d-sdb-m4.dts b/arch/arm/boot/dts/imx7d-sdb-m4.dts
new file mode 100644
index 0000000..c941c3e
--- /dev/null
+++ b/arch/arm/boot/dts/imx7d-sdb-m4.dts
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ *
+ * 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 "imx7d-sdb.dts"
+
+/*
+ * The following modules are manupulated by M4, should be disabled
+ * at A7/Linux side
+ * ADC1/2, FLEXCAN, I2C2, GPT3/4, UART2, WDOG3
+ *
+ */
+
+&i2c2 {
+	status = "disabled";
+};
+
+&gpt3 {
+	status = "disabled";
+};
+
+&gpt4 {
+	status = "disabled";
+};
+
+&mu{
+	status = "okay";
+};
+
+&rpmsg{
+	status = "okay";
+};
+
+&uart2 {
+	status = "disabled";
+};
+
+&wdog3{
+	status = "disabled";
+};
diff --git a/arch/arm/boot/dts/imx7d.dtsi b/arch/arm/boot/dts/imx7d.dtsi
index ebc053a..b60b125 100644
--- a/arch/arm/boot/dts/imx7d.dtsi
+++ b/arch/arm/boot/dts/imx7d.dtsi
@@ -752,6 +752,20 @@
 				status = "disabled";
 			};
 
+			mu: mu@30aa0000 {
+				compatible = "fsl,imx7d-mu", "fsl,imx6sx-mu";
+				reg = <0x30aa0000 0x10000>;
+				interrupts = <GIC_SPI 88 IRQ_TYPE_LEVEL_HIGH>;
+				clocks = <&clks IMX7D_MU_ROOT_CLK>;
+				clock-names = "mu";
+				status = "disabled";
+			};
+
+			rpmsg: rpmsg{
+				compatible = "fsl,imx7d-rpmsg";
+				status = "disabled";
+			};
+
 			usbotg1: usb@30b10000 {
 				compatible = "fsl,imx7d-usb", "fsl,imx27-usb";
 				reg = <0x30b10000 0x200>;
-- 
1.9.1

[RFC 2/4] clk: imx7d: enable the mu and m4 root clocks

[Richard Zhu]

From: Richard Zhu <Richard.Zhu@freescale.com>

enable the mu and m4 root clocks

Signed-off-by: Richard Zhu <hongxing.zhu@nxp.com>
---
 drivers/clk/imx/clk-imx7d.c | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/drivers/clk/imx/clk-imx7d.c b/drivers/clk/imx/clk-imx7d.c
index 448ef32..ac8288b 100644
--- a/drivers/clk/imx/clk-imx7d.c
+++ b/drivers/clk/imx/clk-imx7d.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014-2015 Freescale Semiconductor, Inc.
+ * Copyright (C) 2014-2016 Freescale Semiconductor, Inc.
  *
  * The code contained herein is licensed under the GNU General Public
  * License. You may obtain a copy of the GNU General Public License
@@ -692,6 +692,7 @@ static void __init imx7d_clocks_init(struct device_node *ccm_node)
 	clks[IMX7D_ENET_AXI_ROOT_DIV] = imx_clk_divider("enet_axi_post_div", "enet_axi_pre_div", base + 0x8900, 0, 6);
 	clks[IMX7D_NAND_USDHC_BUS_ROOT_DIV] = imx_clk_divider("nand_usdhc_post_div", "nand_usdhc_pre_div", base + 0x8980, 0, 6);
 	clks[IMX7D_AHB_CHANNEL_ROOT_DIV] = imx_clk_divider("ahb_post_div", "ahb_pre_div", base + 0x9000, 0, 6);
+	clks[IMX7D_IPG_ROOT_CLK] = imx_clk_divider("ipg_root_clk", "ahb_root_clk", base + 0x9080, 0, 2);
 	clks[IMX7D_DRAM_ROOT_DIV] = imx_clk_divider("dram_post_div", "dram_cg", base + 0x9880, 0, 3);
 	clks[IMX7D_DRAM_PHYM_ALT_ROOT_DIV] = imx_clk_divider("dram_phym_alt_post_div", "dram_phym_alt_pre_div", base + 0xa000, 0, 3);
 	clks[IMX7D_DRAM_ALT_ROOT_DIV] = imx_clk_divider("dram_alt_post_div", "dram_alt_pre_div", base + 0xa080, 0, 3);
@@ -769,6 +770,7 @@ static void __init imx7d_clocks_init(struct device_node *ccm_node)
 	clks[IMX7D_DRAM_PHYM_ROOT_CLK] = imx_clk_gate2("dram_phym_root_clk", "dram_phym_cg", base + 0x4130, 0);
 	clks[IMX7D_DRAM_PHYM_ALT_ROOT_CLK] = imx_clk_gate2("dram_phym_alt_root_clk", "dram_phym_alt_post_div", base + 0x4130, 0);
 	clks[IMX7D_DRAM_ALT_ROOT_CLK] = imx_clk_gate2("dram_alt_root_clk", "dram_alt_post_div", base + 0x4130, 0);
+	clks[IMX7D_MU_ROOT_CLK] = imx_clk_gate2("mu_root_clk", "ipg_root_clk", base + 0x4270, 0);
 	clks[IMX7D_USB_HSIC_ROOT_CLK] = imx_clk_gate2("usb_hsic_root_clk", "usb_hsic_post_div", base + 0x4420, 0);
 	clks[IMX7D_PCIE_CTRL_ROOT_CLK] = imx_clk_gate2("pcie_ctrl_root_clk", "pcie_ctrl_post_div", base + 0x4600, 0);
 	clks[IMX7D_PCIE_PHY_ROOT_CLK] = imx_clk_gate2("pcie_phy_root_clk", "pcie_phy_post_div", base + 0x4600, 0);
@@ -870,5 +872,9 @@ static void __init imx7d_clocks_init(struct device_node *ccm_node)
 
 	imx_register_uart_clocks(uart_clks);
 
+	/* set the parent clock source of m4, then keep it enabled */
+	clk_set_parent(clks[IMX7D_ARM_M4_ROOT_SRC], clks[IMX7D_PLL_SYS_MAIN_240M_CLK]);
+	clk_prepare_enable(clks[IMX7D_ARM_M4_ROOT_CLK]);
+
 }
 CLK_OF_DECLARE(imx7d, "fsl,imx7d-ccm", imx7d_clocks_init);
-- 
1.9.1

[RFC 3/4] ARM: imx: add the platform related rpmsg implementation

[Richard Zhu]

From: Richard Zhu <Richard.Zhu@freescale.com>

- add mu driver support, the irq and 4bytes msg of
the mu module are as the interaction channel
between A# core and the M4 core on imx amp platforms.
- register one notify in isr of the mu's irq used by
rpmsg.
- instance the virtual processor, and fill up the
virtio_config_ops in the platform related rpmsg
implementation codes.
- hard-code the vring storage shared by A# core and
M# core on AMP SOCs.

Signed-off-by: Richard Zhu <hongxing.zhu@nxp.com>
---
 arch/arm/mach-imx/Kconfig     |  12 ++
 arch/arm/mach-imx/Makefile    |   2 +
 arch/arm/mach-imx/imx_rpmsg.c | 364 ++++++++++++++++++++++++++++++++++++++++++
 arch/arm/mach-imx/mu.c        | 217 +++++++++++++++++++++++++
 include/linux/imx_rpmsg.h     |  27 ++++
 5 files changed, 622 insertions(+)
 create mode 100644 arch/arm/mach-imx/imx_rpmsg.c
 create mode 100644 arch/arm/mach-imx/mu.c
 create mode 100644 include/linux/imx_rpmsg.h

diff --git a/arch/arm/mach-imx/Kconfig b/arch/arm/mach-imx/Kconfig
index 8ceda28..a7bc41c 100644
--- a/arch/arm/mach-imx/Kconfig
+++ b/arch/arm/mach-imx/Kconfig
@@ -56,6 +56,12 @@ config HAVE_IMX_GPC
 config HAVE_IMX_MMDC
 	bool
 
+config HAVE_IMX_MU
+	bool
+
+config HAVE_IMX_RPMSG
+	bool
+
 config HAVE_IMX_SRC
 	def_bool y if SMP
 	select ARCH_HAS_RESET_CONTROLLER
@@ -544,6 +550,9 @@ config SOC_IMX6SX
 	bool "i.MX6 SoloX support"
 	select PINCTRL_IMX6SX
 	select SOC_IMX6
+	select HAVE_IMX_MU
+	select HAVE_IMX_RPMSG
+	select RPMSG
 
 	help
 	  This enables support for Freescale i.MX6 SoloX processor.
@@ -562,6 +571,9 @@ config SOC_IMX7D
 	select ARM_GIC
 	select HAVE_IMX_ANATOP
 	select HAVE_IMX_MMDC
+	select HAVE_IMX_MU
+	select HAVE_IMX_RPMSG
+	select RPMSG
 	help
 		This enables support for Freescale i.MX7 Dual processor.
 
diff --git a/arch/arm/mach-imx/Makefile b/arch/arm/mach-imx/Makefile
index fb689d8..a3c1814 100644
--- a/arch/arm/mach-imx/Makefile
+++ b/arch/arm/mach-imx/Makefile
@@ -74,7 +74,9 @@ obj-$(CONFIG_MACH_IMX35_DT) += imx35-dt.o
 obj-$(CONFIG_HAVE_IMX_ANATOP) += anatop.o
 obj-$(CONFIG_HAVE_IMX_GPC) += gpc.o
 obj-$(CONFIG_HAVE_IMX_MMDC) += mmdc.o
+obj-$(CONFIG_HAVE_IMX_MU) += mu.o
 obj-$(CONFIG_HAVE_IMX_SRC) += src.o
+obj-$(CONFIG_HAVE_IMX_RPMSG) += imx_rpmsg.o
 ifneq ($(CONFIG_SOC_IMX6)$(CONFIG_SOC_LS1021A),)
 AFLAGS_headsmp.o :=-Wa,-march=armv7-a
 obj-$(CONFIG_SMP) += headsmp.o platsmp.o
diff --git a/arch/arm/mach-imx/imx_rpmsg.c b/arch/arm/mach-imx/imx_rpmsg.c
new file mode 100644
index 0000000..ab6ba7a
--- /dev/null
+++ b/arch/arm/mach-imx/imx_rpmsg.c
@@ -0,0 +1,364 @@
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ *
+ * derived from the omap-rpmsg implementation.
+ *
+ * The code contained herein is licensed under the GNU General Public
+ * License. You may obtain a copy of the GNU General Public License
+ * Version 2 or later at the following locations:
+ *
+ * http://www.opensource.org/licenses/gpl-license.html
+ * http://www.gnu.org/copyleft/gpl.html
+ */
+
+#include <linux/err.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/notifier.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <linux/rpmsg.h>
+#include <linux/slab.h>
+#include <linux/virtio.h>
+#include <linux/virtio_config.h>
+#include <linux/virtio_ids.h>
+#include <linux/virtio_ring.h>
+#include <linux/imx_rpmsg.h>
+
+struct imx_rpmsg_vproc {
+	struct virtio_device vdev;
+	unsigned int vring[2];
+	char *rproc_name;
+	struct mutex lock;
+	struct notifier_block nb;
+	struct virtqueue *vq[2];
+	int base_vq_id;
+	int num_of_vqs;
+};
+
+/*
+ * For now, allocate 256 buffers of 512 bytes for each side. each buffer
+ * will then have 16B for the msg header and 496B for the payload.
+ * This will require a total space of 256KB for the buffers themselves, and
+ * 3 pages for every vring (the size of the vring depends on the number of
+ * buffers it supports).
+ */
+#define RPMSG_NUM_BUFS		(512)
+#define RPMSG_BUF_SIZE		(512)
+#define RPMSG_BUFS_SPACE	(RPMSG_NUM_BUFS * RPMSG_BUF_SIZE)
+
+/*
+ * The alignment between the consumer and producer parts of the vring.
+ * Note: this is part of the "wire" protocol. If you change this, you need
+ * to update your BIOS image as well
+ */
+#define RPMSG_VRING_ALIGN	(4096)
+
+/* With 256 buffers, our vring will occupy 3 pages */
+#define RPMSG_RING_SIZE	((DIV_ROUND_UP(vring_size(RPMSG_NUM_BUFS / 2, \
+				RPMSG_VRING_ALIGN), PAGE_SIZE)) * PAGE_SIZE)
+
+#define to_imx_rpdev(vd) container_of(vd, struct imx_rpmsg_vproc, vdev)
+
+struct imx_rpmsg_vq_info {
+	__u16 num;	/* number of entries in the virtio_ring */
+	__u16 vq_id;	/* a globaly unique index of this virtqueue */
+	void *addr;	/* address where we mapped the virtio ring */
+	struct imx_rpmsg_vproc *rpdev;
+};
+
+static u64 imx_rpmsg_get_features(struct virtio_device *vdev)
+{
+	return 1 << VIRTIO_RPMSG_F_NS;
+}
+
+static int imx_rpmsg_finalize_features(struct virtio_device *vdev)
+{
+	/* Give virtio_ring a chance to accept features */
+	vring_transport_features(vdev);
+	return 0;
+}
+
+/* kick the remote processor, and let it know which virtqueue to poke at */
+static bool imx_rpmsg_notify(struct virtqueue *vq)
+{
+	int ret;
+	unsigned int mu_rpmsg = 0;
+	struct imx_rpmsg_vq_info *rpvq = vq->priv;
+
+	mu_rpmsg = rpvq->vq_id << 16;
+	mutex_lock(&rpvq->rpdev->lock);
+	/* send the index of the triggered virtqueue as the mu payload */
+	ret = imx_mu_rpmsg_send(mu_rpmsg);
+	mutex_unlock(&rpvq->rpdev->lock);
+	if (ret) {
+		pr_err("ugh, imx_mu_rpmsg_send() failed: %d\n", ret);
+		return false;
+	}
+
+	return true;
+}
+
+static int imx_mu_rpmsg_callback(struct notifier_block *this,
+					unsigned long index, void *data)
+{
+	u32 mu_msg = (u32) data;
+	struct imx_rpmsg_vproc *rpdev;
+
+	rpdev = container_of(this, struct imx_rpmsg_vproc, nb);
+
+	pr_debug("%s mu_msg: 0x%x\n", __func__, mu_msg);
+
+	/* ignore vq indices which are clearly not for us */
+	mu_msg = mu_msg >> 16;
+	if (mu_msg < rpdev->base_vq_id)
+		pr_err("mu_msg: 0x%x is invalid\n", mu_msg);
+
+	mu_msg -= rpdev->base_vq_id;
+
+	/*
+	 * Currently both PENDING_MSG and explicit-virtqueue-index
+	 * messaging are supported.
+	 * Whatever approach is taken, at this point 'mu_msg' contains
+	 * the index of the vring which was just triggered.
+	 */
+	if (mu_msg < rpdev->num_of_vqs)
+		vring_interrupt(mu_msg, rpdev->vq[mu_msg]);
+
+	return NOTIFY_DONE;
+}
+
+static struct virtqueue *rp_find_vq(struct virtio_device *vdev,
+				    unsigned index,
+				    void (*callback)(struct virtqueue *vq),
+				    const char *name)
+{
+	struct imx_rpmsg_vproc *rpdev = to_imx_rpdev(vdev);
+	struct imx_rpmsg_vq_info *rpvq;
+	struct virtqueue *vq;
+	int err;
+
+	rpvq = kmalloc(sizeof(*rpvq), GFP_KERNEL);
+	if (!rpvq)
+		return ERR_PTR(-ENOMEM);
+
+	/* ioremap'ing normal memory, so we cast away sparse's complaints */
+	rpvq->addr = (__force void *) ioremap_nocache(rpdev->vring[index],
+							RPMSG_RING_SIZE);
+	if (!rpvq->addr) {
+		err = -ENOMEM;
+		goto free_rpvq;
+	}
+
+	memset(rpvq->addr, 0, RPMSG_RING_SIZE);
+
+	pr_debug("vring%d: phys 0x%x, virt 0x%x\n", index, rpdev->vring[index],
+					(unsigned int) rpvq->addr);
+
+	vq = vring_new_virtqueue(index, RPMSG_NUM_BUFS / 2, RPMSG_VRING_ALIGN,
+			vdev, true, rpvq->addr, imx_rpmsg_notify, callback,
+			name);
+	if (!vq) {
+		pr_err("vring_new_virtqueue failed\n");
+		err = -ENOMEM;
+		goto unmap_vring;
+	}
+
+	rpdev->vq[index] = vq;
+	vq->priv = rpvq;
+	/* system-wide unique id for this virtqueue */
+	rpvq->vq_id = rpdev->base_vq_id + index;
+	rpvq->rpdev = rpdev;
+	mutex_init(&rpdev->lock);
+
+	return vq;
+
+unmap_vring:
+	/* iounmap normal memory, so make sparse happy */
+	iounmap((__force void __iomem *) rpvq->addr);
+free_rpvq:
+	kfree(rpvq);
+	return ERR_PTR(err);
+}
+
+static void imx_rpmsg_del_vqs(struct virtio_device *vdev)
+{
+	struct virtqueue *vq, *n;
+	struct imx_rpmsg_vproc *rpdev = to_imx_rpdev(vdev);
+
+	list_for_each_entry_safe(vq, n, &vdev->vqs, list) {
+		struct imx_rpmsg_vq_info *rpvq = vq->priv;
+
+		iounmap(rpvq->addr);
+		vring_del_virtqueue(vq);
+		kfree(rpvq);
+	}
+
+	if (&rpdev->nb)
+		imx_mu_rpmsg_unregister_nb((const char *)rpdev->rproc_name,
+				&rpdev->nb);
+}
+
+static int imx_rpmsg_find_vqs(struct virtio_device *vdev, unsigned nvqs,
+		       struct virtqueue *vqs[],
+		       vq_callback_t *callbacks[],
+		       const char *names[])
+{
+	struct imx_rpmsg_vproc *rpdev = to_imx_rpdev(vdev);
+	int i, err;
+
+	/* we maintain two virtqueues per remote processor (for RX and TX) */
+	if (nvqs != 2)
+		return -EINVAL;
+
+	for (i = 0; i < nvqs; ++i) {
+		vqs[i] = rp_find_vq(vdev, i, callbacks[i], names[i]);
+		if (IS_ERR(vqs[i])) {
+			err = PTR_ERR(vqs[i]);
+			goto error;
+		}
+	}
+
+	rpdev->num_of_vqs = nvqs;
+
+	rpdev->nb.notifier_call = imx_mu_rpmsg_callback;
+	imx_mu_rpmsg_register_nb((const char *)rpdev->rproc_name, &rpdev->nb);
+
+	return 0;
+
+error:
+	imx_rpmsg_del_vqs(vdev);
+	return err;
+}
+
+static void imx_rpmsg_reset(struct virtio_device *vdev)
+{
+	dev_dbg(&vdev->dev, "reset !\n");
+}
+
+static u8 imx_rpmsg_get_status(struct virtio_device *vdev)
+{
+	return 0;
+}
+
+static void imx_rpmsg_set_status(struct virtio_device *vdev, u8 status)
+{
+	dev_dbg(&vdev->dev, "%s new status: %d\n", __func__, status);
+}
+
+static void imx_rpmsg_vproc_release(struct device *dev)
+{
+	/* this handler is provided so driver core doesn't yell at us */
+}
+
+static struct virtio_config_ops imx_rpmsg_config_ops = {
+	.get_features	= imx_rpmsg_get_features,
+	.finalize_features = imx_rpmsg_finalize_features,
+	.find_vqs	= imx_rpmsg_find_vqs,
+	.del_vqs	= imx_rpmsg_del_vqs,
+	.reset		= imx_rpmsg_reset,
+	.set_status	= imx_rpmsg_set_status,
+	.get_status	= imx_rpmsg_get_status,
+};
+
+static struct imx_rpmsg_vproc imx_rpmsg_vprocs[] = {
+	{
+		.vdev.id.device	= VIRTIO_ID_RPMSG,
+		.vdev.config	= &imx_rpmsg_config_ops,
+		.rproc_name	= "m4",
+		.base_vq_id	= 0,
+	},
+};
+
+static const struct of_device_id imx_rpmsg_dt_ids[] = {
+	{ .compatible = "fsl,imx6sx-rpmsg", },
+	{ .compatible = "fsl,imx7d-rpmsg", },
+	{ /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, imx_rpmsg_dt_ids);
+
+static int imx_rpmsg_probe(struct platform_device *pdev)
+{
+	int i, ret = 0;
+	struct device_node *np = pdev->dev.of_node;
+
+	for (i = 0; i < ARRAY_SIZE(imx_rpmsg_vprocs); i++) {
+		struct imx_rpmsg_vproc *rpdev = &imx_rpmsg_vprocs[i];
+
+		if (!strcmp(rpdev->rproc_name, "m4")) {
+			ret = of_device_is_compatible(np, "fsl,imx7d-rpmsg");
+			ret |= of_device_is_compatible(np, "fsl,imx6sx-rpmsg");
+			if (ret) {
+				/* hardcodes here now. */
+				rpdev->vring[0] = 0xBFFF0000;
+				rpdev->vring[1] = 0xBFFF8000;
+			}
+		} else {
+			break;
+		}
+
+		pr_debug("%s rpdev%d: vring0 0x%x, vring1 0x%x\n", __func__,
+				i, rpdev->vring[0], rpdev->vring[1]);
+
+		rpdev->vdev.dev.parent = &pdev->dev;
+		rpdev->vdev.dev.release = imx_rpmsg_vproc_release;
+
+		ret = register_virtio_device(&rpdev->vdev);
+		if (ret) {
+			pr_err("%s failed to register rpdev: %d\n",
+					__func__, ret);
+			break;
+		}
+	}
+
+	return ret;
+}
+
+static int imx_rpmsg_remove(struct platform_device *pdev)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(imx_rpmsg_vprocs); i++) {
+		struct imx_rpmsg_vproc *rpdev = &imx_rpmsg_vprocs[i];
+
+		unregister_virtio_device(&rpdev->vdev);
+	}
+	return 0;
+}
+
+static struct platform_driver imx_rpmsg_driver = {
+	.driver = {
+		   .owner = THIS_MODULE,
+		   .name = "imx-rpmsg",
+		   .of_match_table = imx_rpmsg_dt_ids,
+		   },
+	.probe = imx_rpmsg_probe,
+	.remove = imx_rpmsg_remove,
+};
+
+static int __init imx_rpmsg_init(void)
+{
+	int ret;
+
+	ret = platform_driver_register(&imx_rpmsg_driver);
+	if (ret)
+		pr_err("Unable to initialize rpmsg driver\n");
+	else
+		pr_info("imx rpmsg driver is registered.\n");
+
+	return ret;
+}
+
+static void __exit imx_rpmsg_exit(void)
+{
+	pr_info("imx rpmsg driver is unregistered.\n");
+	platform_driver_unregister(&imx_rpmsg_driver);
+}
+
+module_exit(imx_rpmsg_exit);
+module_init(imx_rpmsg_init);
+
+MODULE_AUTHOR("Freescale Semiconductor, Inc.");
+MODULE_DESCRIPTION("iMX remote processor messaging virtio device");
+MODULE_LICENSE("GPL v2");
diff --git a/arch/arm/mach-imx/mu.c b/arch/arm/mach-imx/mu.c
new file mode 100644
index 0000000..7b07f48
--- /dev/null
+++ b/arch/arm/mach-imx/mu.c
@@ -0,0 +1,217 @@
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ *
+ * The code contained herein is licensed under the GNU General Public
+ * License. You may obtain a copy of the GNU General Public License
+ * Version 2 or later at the following locations:
+ *
+ * http://www.opensource.org/licenses/gpl-license.html
+ * http://www.gnu.org/copyleft/gpl.html
+ */
+
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/of_irq.h>
+#include <linux/notifier.h>
+#include <linux/platform_device.h>
+#include "common.h"
+#include "hardware.h"
+
+#define MU_ATR0_OFFSET	0x0
+#define MU_ARR0_OFFSET	0x10
+#define MU_ARR1_OFFSET	0x14
+#define MU_ASR		0x20
+#define MU_ACR		0x24
+
+#define MU_RPMSG_HANDSHAKE_INDEX	1
+
+struct imx_mu_rpmsg_box {
+	const char *name;
+	struct blocking_notifier_head notifier;
+};
+
+static struct imx_mu_rpmsg_box mu_rpmsg_box = {
+	.name	= "m4",
+};
+
+static void __iomem *mu_base;
+static u32 m4_message;
+static struct delayed_work rpmsg_work;
+
+static int imx_mu_send_message(unsigned int index, unsigned int data)
+{
+	u32 val, ep;
+	int i, te_flag = 0;
+	unsigned long timeout = jiffies + msecs_to_jiffies(500);
+
+	/* wait for transfer buffer empty, and no event pending */
+	do {
+		val = readl_relaxed(mu_base + MU_ASR);
+		ep = val & BIT(4);
+		if (time_after(jiffies, timeout)) {
+			pr_err("Waiting MU transmit buffer empty timeout!\n");
+			return -EIO;
+		}
+	} while (((val & (1 << (20 + 3 - index))) == 0) || (ep == BIT(4)));
+
+	writel_relaxed(data, mu_base + index * 0x4 + MU_ATR0_OFFSET);
+
+	/*
+	 * make a double check that TEn is not empty after write
+	 */
+	val = readl_relaxed(mu_base + MU_ASR);
+	ep = val & BIT(4);
+	if (((val & (1 << (20 + (3 - index)))) == 0) || (ep == BIT(4)))
+		return 0;
+
+	/*
+	 * Make sure that TEn flag is changed, after the ATRn is filled up.
+	 */
+	for (i = 0; i < 100; i++) {
+		val = readl_relaxed(mu_base + MU_ASR);
+		ep = val & BIT(4);
+		if (((val & (1 << (20 + 3 - index))) == 0) || (ep == BIT(4))) {
+			te_flag = 0;
+			break;
+		} else if (time_after(jiffies, timeout)) {
+			/* Can't see TEn 1->0, maybe already handled! */
+			te_flag = 1;
+			break;
+		}
+	}
+	if (te_flag == 0)
+		pr_info("TEn isn't changed when ATRn is filled up.\n");
+
+	return 0;
+}
+
+int imx_mu_rpmsg_send(unsigned int rpmsg)
+{
+	return imx_mu_send_message(MU_RPMSG_HANDSHAKE_INDEX, rpmsg);
+}
+
+int imx_mu_rpmsg_register_nb(const char *name, struct notifier_block *nb)
+{
+	if ((name == NULL) || (nb == NULL))
+		return -EINVAL;
+
+	if (!strcmp(mu_rpmsg_box.name, name))
+		blocking_notifier_chain_register(&(mu_rpmsg_box.notifier), nb);
+	else
+		return -ENOENT;
+
+	return 0;
+}
+
+int imx_mu_rpmsg_unregister_nb(const char *name, struct notifier_block *nb)
+{
+	if ((name == NULL) || (nb == NULL))
+		return -EINVAL;
+
+	if (!strcmp(mu_rpmsg_box.name, name))
+		blocking_notifier_chain_unregister(&(mu_rpmsg_box.notifier),
+				nb);
+	else
+		return -ENOENT;
+
+	return 0;
+}
+
+static void rpmsg_work_handler(struct work_struct *work)
+{
+
+	blocking_notifier_call_chain(&(mu_rpmsg_box.notifier), 4,
+						(void *)m4_message);
+	m4_message = 0;
+}
+
+static irqreturn_t imx_mu_isr(int irq, void *param)
+{
+	u32 irqs;
+
+	irqs = readl_relaxed(mu_base + MU_ASR);
+
+	/* RPMSG */
+	if (irqs & (1 << 26)) {
+		/* get message from receive buffer */
+		m4_message = readl_relaxed(mu_base + MU_ARR1_OFFSET);
+		schedule_delayed_work(&rpmsg_work, 0);
+	}
+
+	return IRQ_HANDLED;
+}
+
+static int imx_mu_probe(struct platform_device *pdev)
+{
+	int ret;
+	u32 irq;
+	struct device_node *np;
+	struct clk *clk;
+
+	np = of_find_compatible_node(NULL, NULL, "fsl,imx6sx-mu");
+	mu_base = of_iomap(np, 0);
+	WARN_ON(!mu_base);
+
+	irq = platform_get_irq(pdev, 0);
+	ret = request_irq(irq, imx_mu_isr,
+		IRQF_EARLY_RESUME, "imx-mu", &mu_rpmsg_box);
+	if (ret) {
+		pr_err("%s: register interrupt %d failed, rc %d\n",
+			__func__, irq, ret);
+		return ret;
+	}
+
+	ret = of_device_is_compatible(np, "fsl,imx7d-mu");
+	if (ret) {
+		clk = devm_clk_get(&pdev->dev, "mu");
+		if (IS_ERR(clk)) {
+			dev_err(&pdev->dev,
+				"mu clock source missing or invalid\n");
+			return PTR_ERR(clk);
+		}
+
+		ret = clk_prepare_enable(clk);
+		if (ret) {
+			dev_err(&pdev->dev,
+				"unable to enable mu clock\n");
+			return ret;
+		}
+	}
+
+	INIT_DELAYED_WORK(&rpmsg_work, rpmsg_work_handler);
+	/* enable the bit26(RIE1) of MU_ACR */
+	writel_relaxed(readl_relaxed(mu_base + MU_ACR) | BIT(26),
+			mu_base + MU_ACR);
+	BLOCKING_INIT_NOTIFIER_HEAD(&(mu_rpmsg_box.notifier));
+
+	pr_info("MU is ready for cross core communication!\n");
+
+	return 0;
+}
+
+static const struct of_device_id imx_mu_ids[] = {
+	{ .compatible = "fsl,imx6sx-mu" },
+	{ .compatible = "fsl,imx7d-mu" },
+	{ }
+};
+
+static struct platform_driver imx_mu_driver = {
+	.driver = {
+		.name   = "imx-mu",
+		.owner  = THIS_MODULE,
+		.of_match_table = imx_mu_ids,
+	},
+	.probe = imx_mu_probe,
+};
+
+static int __init imx_mu_init(void)
+{
+	return platform_driver_register(&imx_mu_driver);
+}
+subsys_initcall(imx_mu_init);
diff --git a/include/linux/imx_rpmsg.h b/include/linux/imx_rpmsg.h
new file mode 100644
index 0000000..2b0dca5
--- /dev/null
+++ b/include/linux/imx_rpmsg.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ */
+
+/*
+ * The code contained herein is licensed under the GNU Lesser General
+ * Public License.  You may obtain a copy of the GNU Lesser General
+ * Public License Version 2.1 or later at the following locations:
+ *
+ * http://www.opensource.org/licenses/lgpl-license.html
+ * http://www.gnu.org/copyleft/lgpl.html
+ */
+
+/*
+ * @file linux/imx_rpmsg.h
+ *
+ * @brief Global header file for imx RPMSG
+ *
+ * @ingroup RPMSG
+ */
+#ifndef __LINUX_IMX_RPMSG_H__
+#define __LINUX_IMX_RPMSG_H__
+
+int imx_mu_rpmsg_send(unsigned int vq_id);
+int imx_mu_rpmsg_register_nb(const char *name, struct notifier_block *nb);
+int imx_mu_rpmsg_unregister_nb(const char *name, struct notifier_block *nb);
+#endif /* __LINUX_IMX_RPMSG_H__ */
-- 
1.9.1

Re: [RFC 3/4] ARM: imx: add the platform related rpmsg implementation

[Shawn Guo]

On Wed, Jan 06, 2016 at 04:06:43PM +0800, Richard Zhu wrote:
> From: Richard Zhu <Richard.Zhu@freescale.com>
> 
> - add mu driver support, the irq and 4bytes msg of
> the mu module are as the interaction channel
> between A# core and the M4 core on imx amp platforms.
> - register one notify in isr of the mu's irq used by
> rpmsg.
> - instance the virtual processor, and fill up the
> virtio_config_ops in the platform related rpmsg
> implementation codes.
> - hard-code the vring storage shared by A# core and
> M# core on AMP SOCs.
> 
> Signed-off-by: Richard Zhu <hongxing.zhu@nxp.com>
> ---
>  arch/arm/mach-imx/Kconfig     |  12 ++
>  arch/arm/mach-imx/Makefile    |   2 +
>  arch/arm/mach-imx/imx_rpmsg.c | 364 ++++++++++++++++++++++++++++++++++++++++++
>  arch/arm/mach-imx/mu.c        | 217 +++++++++++++++++++++++++

I'm not rpmsg expert, but it seems to me that the driver should be
put into drivers/rpmsg/ rather than mach-imx.

Also, when you repost, you may want to copy
Stefan Agner <stefan@agner.ch>, who is helping maintain Vybrid platform
and might be interested in your patches.

Shawn

>  include/linux/imx_rpmsg.h     |  27 ++++
>  5 files changed, 622 insertions(+)
>  create mode 100644 arch/arm/mach-imx/imx_rpmsg.c
>  create mode 100644 arch/arm/mach-imx/mu.c
>  create mode 100644 include/linux/imx_rpmsg.h
> 
> diff --git a/arch/arm/mach-imx/Kconfig b/arch/arm/mach-imx/Kconfig
> index 8ceda28..a7bc41c 100644
> --- a/arch/arm/mach-imx/Kconfig
> +++ b/arch/arm/mach-imx/Kconfig
> @@ -56,6 +56,12 @@ config HAVE_IMX_GPC
>  config HAVE_IMX_MMDC
>  	bool
>  
> +config HAVE_IMX_MU
> +	bool
> +
> +config HAVE_IMX_RPMSG
> +	bool
> +
>  config HAVE_IMX_SRC
>  	def_bool y if SMP
>  	select ARCH_HAS_RESET_CONTROLLER
> @@ -544,6 +550,9 @@ config SOC_IMX6SX
>  	bool "i.MX6 SoloX support"
>  	select PINCTRL_IMX6SX
>  	select SOC_IMX6
> +	select HAVE_IMX_MU
> +	select HAVE_IMX_RPMSG
> +	select RPMSG
>  
>  	help
>  	  This enables support for Freescale i.MX6 SoloX processor.
> @@ -562,6 +571,9 @@ config SOC_IMX7D
>  	select ARM_GIC
>  	select HAVE_IMX_ANATOP
>  	select HAVE_IMX_MMDC
> +	select HAVE_IMX_MU
> +	select HAVE_IMX_RPMSG
> +	select RPMSG
>  	help
>  		This enables support for Freescale i.MX7 Dual processor.
>  
> diff --git a/arch/arm/mach-imx/Makefile b/arch/arm/mach-imx/Makefile
> index fb689d8..a3c1814 100644
> --- a/arch/arm/mach-imx/Makefile
> +++ b/arch/arm/mach-imx/Makefile
> @@ -74,7 +74,9 @@ obj-$(CONFIG_MACH_IMX35_DT) += imx35-dt.o
>  obj-$(CONFIG_HAVE_IMX_ANATOP) += anatop.o
>  obj-$(CONFIG_HAVE_IMX_GPC) += gpc.o
>  obj-$(CONFIG_HAVE_IMX_MMDC) += mmdc.o
> +obj-$(CONFIG_HAVE_IMX_MU) += mu.o
>  obj-$(CONFIG_HAVE_IMX_SRC) += src.o
> +obj-$(CONFIG_HAVE_IMX_RPMSG) += imx_rpmsg.o
>  ifneq ($(CONFIG_SOC_IMX6)$(CONFIG_SOC_LS1021A),)
>  AFLAGS_headsmp.o :=-Wa,-march=armv7-a
>  obj-$(CONFIG_SMP) += headsmp.o platsmp.o
> diff --git a/arch/arm/mach-imx/imx_rpmsg.c b/arch/arm/mach-imx/imx_rpmsg.c
> new file mode 100644
> index 0000000..ab6ba7a
> --- /dev/null
> +++ b/arch/arm/mach-imx/imx_rpmsg.c
> @@ -0,0 +1,364 @@
> +/*
> + * Copyright (C) 2016 Freescale Semiconductor, Inc.
> + *
> + * derived from the omap-rpmsg implementation.
> + *
> + * The code contained herein is licensed under the GNU General Public
> + * License. You may obtain a copy of the GNU General Public License
> + * Version 2 or later at the following locations:
> + *
> + * http://www.opensource.org/licenses/gpl-license.html
> + * http://www.gnu.org/copyleft/gpl.html
> + */
> +
> +#include <linux/err.h>
> +#include <linux/init.h>
> +#include <linux/interrupt.h>
> +#include <linux/module.h>
> +#include <linux/notifier.h>
> +#include <linux/of.h>
> +#include <linux/platform_device.h>
> +#include <linux/rpmsg.h>
> +#include <linux/slab.h>
> +#include <linux/virtio.h>
> +#include <linux/virtio_config.h>
> +#include <linux/virtio_ids.h>
> +#include <linux/virtio_ring.h>
> +#include <linux/imx_rpmsg.h>
> +
> +struct imx_rpmsg_vproc {
> +	struct virtio_device vdev;
> +	unsigned int vring[2];
> +	char *rproc_name;
> +	struct mutex lock;
> +	struct notifier_block nb;
> +	struct virtqueue *vq[2];
> +	int base_vq_id;
> +	int num_of_vqs;
> +};
> +
> +/*
> + * For now, allocate 256 buffers of 512 bytes for each side. each buffer
> + * will then have 16B for the msg header and 496B for the payload.
> + * This will require a total space of 256KB for the buffers themselves, and
> + * 3 pages for every vring (the size of the vring depends on the number of
> + * buffers it supports).
> + */
> +#define RPMSG_NUM_BUFS		(512)
> +#define RPMSG_BUF_SIZE		(512)
> +#define RPMSG_BUFS_SPACE	(RPMSG_NUM_BUFS * RPMSG_BUF_SIZE)
> +
> +/*
> + * The alignment between the consumer and producer parts of the vring.
> + * Note: this is part of the "wire" protocol. If you change this, you need
> + * to update your BIOS image as well
> + */
> +#define RPMSG_VRING_ALIGN	(4096)
> +
> +/* With 256 buffers, our vring will occupy 3 pages */
> +#define RPMSG_RING_SIZE	((DIV_ROUND_UP(vring_size(RPMSG_NUM_BUFS / 2, \
> +				RPMSG_VRING_ALIGN), PAGE_SIZE)) * PAGE_SIZE)
> +
> +#define to_imx_rpdev(vd) container_of(vd, struct imx_rpmsg_vproc, vdev)
> +
> +struct imx_rpmsg_vq_info {
> +	__u16 num;	/* number of entries in the virtio_ring */
> +	__u16 vq_id;	/* a globaly unique index of this virtqueue */
> +	void *addr;	/* address where we mapped the virtio ring */
> +	struct imx_rpmsg_vproc *rpdev;
> +};
> +
> +static u64 imx_rpmsg_get_features(struct virtio_device *vdev)
> +{
> +	return 1 << VIRTIO_RPMSG_F_NS;
> +}
> +
> +static int imx_rpmsg_finalize_features(struct virtio_device *vdev)
> +{
> +	/* Give virtio_ring a chance to accept features */
> +	vring_transport_features(vdev);
> +	return 0;
> +}
> +
> +/* kick the remote processor, and let it know which virtqueue to poke at */
> +static bool imx_rpmsg_notify(struct virtqueue *vq)
> +{
> +	int ret;
> +	unsigned int mu_rpmsg = 0;
> +	struct imx_rpmsg_vq_info *rpvq = vq->priv;
> +
> +	mu_rpmsg = rpvq->vq_id << 16;
> +	mutex_lock(&rpvq->rpdev->lock);
> +	/* send the index of the triggered virtqueue as the mu payload */
> +	ret = imx_mu_rpmsg_send(mu_rpmsg);
> +	mutex_unlock(&rpvq->rpdev->lock);
> +	if (ret) {
> +		pr_err("ugh, imx_mu_rpmsg_send() failed: %d\n", ret);
> +		return false;
> +	}
> +
> +	return true;
> +}
> +
> +static int imx_mu_rpmsg_callback(struct notifier_block *this,
> +					unsigned long index, void *data)
> +{
> +	u32 mu_msg = (u32) data;
> +	struct imx_rpmsg_vproc *rpdev;
> +
> +	rpdev = container_of(this, struct imx_rpmsg_vproc, nb);
> +
> +	pr_debug("%s mu_msg: 0x%x\n", __func__, mu_msg);
> +
> +	/* ignore vq indices which are clearly not for us */
> +	mu_msg = mu_msg >> 16;
> +	if (mu_msg < rpdev->base_vq_id)
> +		pr_err("mu_msg: 0x%x is invalid\n", mu_msg);
> +
> +	mu_msg -= rpdev->base_vq_id;
> +
> +	/*
> +	 * Currently both PENDING_MSG and explicit-virtqueue-index
> +	 * messaging are supported.
> +	 * Whatever approach is taken, at this point 'mu_msg' contains
> +	 * the index of the vring which was just triggered.
> +	 */
> +	if (mu_msg < rpdev->num_of_vqs)
> +		vring_interrupt(mu_msg, rpdev->vq[mu_msg]);
> +
> +	return NOTIFY_DONE;
> +}
> +
> +static struct virtqueue *rp_find_vq(struct virtio_device *vdev,
> +				    unsigned index,
> +				    void (*callback)(struct virtqueue *vq),
> +				    const char *name)
> +{
> +	struct imx_rpmsg_vproc *rpdev = to_imx_rpdev(vdev);
> +	struct imx_rpmsg_vq_info *rpvq;
> +	struct virtqueue *vq;
> +	int err;
> +
> +	rpvq = kmalloc(sizeof(*rpvq), GFP_KERNEL);
> +	if (!rpvq)
> +		return ERR_PTR(-ENOMEM);
> +
> +	/* ioremap'ing normal memory, so we cast away sparse's complaints */
> +	rpvq->addr = (__force void *) ioremap_nocache(rpdev->vring[index],
> +							RPMSG_RING_SIZE);
> +	if (!rpvq->addr) {
> +		err = -ENOMEM;
> +		goto free_rpvq;
> +	}
> +
> +	memset(rpvq->addr, 0, RPMSG_RING_SIZE);
> +
> +	pr_debug("vring%d: phys 0x%x, virt 0x%x\n", index, rpdev->vring[index],
> +					(unsigned int) rpvq->addr);
> +
> +	vq = vring_new_virtqueue(index, RPMSG_NUM_BUFS / 2, RPMSG_VRING_ALIGN,
> +			vdev, true, rpvq->addr, imx_rpmsg_notify, callback,
> +			name);
> +	if (!vq) {
> +		pr_err("vring_new_virtqueue failed\n");
> +		err = -ENOMEM;
> +		goto unmap_vring;
> +	}
> +
> +	rpdev->vq[index] = vq;
> +	vq->priv = rpvq;
> +	/* system-wide unique id for this virtqueue */
> +	rpvq->vq_id = rpdev->base_vq_id + index;
> +	rpvq->rpdev = rpdev;
> +	mutex_init(&rpdev->lock);
> +
> +	return vq;
> +
> +unmap_vring:
> +	/* iounmap normal memory, so make sparse happy */
> +	iounmap((__force void __iomem *) rpvq->addr);
> +free_rpvq:
> +	kfree(rpvq);
> +	return ERR_PTR(err);
> +}
> +
> +static void imx_rpmsg_del_vqs(struct virtio_device *vdev)
> +{
> +	struct virtqueue *vq, *n;
> +	struct imx_rpmsg_vproc *rpdev = to_imx_rpdev(vdev);
> +
> +	list_for_each_entry_safe(vq, n, &vdev->vqs, list) {
> +		struct imx_rpmsg_vq_info *rpvq = vq->priv;
> +
> +		iounmap(rpvq->addr);
> +		vring_del_virtqueue(vq);
> +		kfree(rpvq);
> +	}
> +
> +	if (&rpdev->nb)
> +		imx_mu_rpmsg_unregister_nb((const char *)rpdev->rproc_name,
> +				&rpdev->nb);
> +}
> +
> +static int imx_rpmsg_find_vqs(struct virtio_device *vdev, unsigned nvqs,
> +		       struct virtqueue *vqs[],
> +		       vq_callback_t *callbacks[],
> +		       const char *names[])
> +{
> +	struct imx_rpmsg_vproc *rpdev = to_imx_rpdev(vdev);
> +	int i, err;
> +
> +	/* we maintain two virtqueues per remote processor (for RX and TX) */
> +	if (nvqs != 2)
> +		return -EINVAL;
> +
> +	for (i = 0; i < nvqs; ++i) {
> +		vqs[i] = rp_find_vq(vdev, i, callbacks[i], names[i]);
> +		if (IS_ERR(vqs[i])) {
> +			err = PTR_ERR(vqs[i]);
> +			goto error;
> +		}
> +	}
> +
> +	rpdev->num_of_vqs = nvqs;
> +
> +	rpdev->nb.notifier_call = imx_mu_rpmsg_callback;
> +	imx_mu_rpmsg_register_nb((const char *)rpdev->rproc_name, &rpdev->nb);
> +
> +	return 0;
> +
> +error:
> +	imx_rpmsg_del_vqs(vdev);
> +	return err;
> +}
> +
> +static void imx_rpmsg_reset(struct virtio_device *vdev)
> +{
> +	dev_dbg(&vdev->dev, "reset !\n");
> +}
> +
> +static u8 imx_rpmsg_get_status(struct virtio_device *vdev)
> +{
> +	return 0;
> +}
> +
> +static void imx_rpmsg_set_status(struct virtio_device *vdev, u8 status)
> +{
> +	dev_dbg(&vdev->dev, "%s new status: %d\n", __func__, status);
> +}
> +
> +static void imx_rpmsg_vproc_release(struct device *dev)
> +{
> +	/* this handler is provided so driver core doesn't yell at us */
> +}
> +
> +static struct virtio_config_ops imx_rpmsg_config_ops = {
> +	.get_features	= imx_rpmsg_get_features,
> +	.finalize_features = imx_rpmsg_finalize_features,
> +	.find_vqs	= imx_rpmsg_find_vqs,
> +	.del_vqs	= imx_rpmsg_del_vqs,
> +	.reset		= imx_rpmsg_reset,
> +	.set_status	= imx_rpmsg_set_status,
> +	.get_status	= imx_rpmsg_get_status,
> +};
> +
> +static struct imx_rpmsg_vproc imx_rpmsg_vprocs[] = {
> +	{
> +		.vdev.id.device	= VIRTIO_ID_RPMSG,
> +		.vdev.config	= &imx_rpmsg_config_ops,
> +		.rproc_name	= "m4",
> +		.base_vq_id	= 0,
> +	},
> +};
> +
> +static const struct of_device_id imx_rpmsg_dt_ids[] = {
> +	{ .compatible = "fsl,imx6sx-rpmsg", },
> +	{ .compatible = "fsl,imx7d-rpmsg", },
> +	{ /* sentinel */ }
> +};
> +MODULE_DEVICE_TABLE(of, imx_rpmsg_dt_ids);
> +
> +static int imx_rpmsg_probe(struct platform_device *pdev)
> +{
> +	int i, ret = 0;
> +	struct device_node *np = pdev->dev.of_node;
> +
> +	for (i = 0; i < ARRAY_SIZE(imx_rpmsg_vprocs); i++) {
> +		struct imx_rpmsg_vproc *rpdev = &imx_rpmsg_vprocs[i];
> +
> +		if (!strcmp(rpdev->rproc_name, "m4")) {
> +			ret = of_device_is_compatible(np, "fsl,imx7d-rpmsg");
> +			ret |= of_device_is_compatible(np, "fsl,imx6sx-rpmsg");
> +			if (ret) {
> +				/* hardcodes here now. */
> +				rpdev->vring[0] = 0xBFFF0000;
> +				rpdev->vring[1] = 0xBFFF8000;
> +			}
> +		} else {
> +			break;
> +		}
> +
> +		pr_debug("%s rpdev%d: vring0 0x%x, vring1 0x%x\n", __func__,
> +				i, rpdev->vring[0], rpdev->vring[1]);
> +
> +		rpdev->vdev.dev.parent = &pdev->dev;
> +		rpdev->vdev.dev.release = imx_rpmsg_vproc_release;
> +
> +		ret = register_virtio_device(&rpdev->vdev);
> +		if (ret) {
> +			pr_err("%s failed to register rpdev: %d\n",
> +					__func__, ret);
> +			break;
> +		}
> +	}
> +
> +	return ret;
> +}
> +
> +static int imx_rpmsg_remove(struct platform_device *pdev)
> +{
> +	int i;
> +
> +	for (i = 0; i < ARRAY_SIZE(imx_rpmsg_vprocs); i++) {
> +		struct imx_rpmsg_vproc *rpdev = &imx_rpmsg_vprocs[i];
> +
> +		unregister_virtio_device(&rpdev->vdev);
> +	}
> +	return 0;
> +}
> +
> +static struct platform_driver imx_rpmsg_driver = {
> +	.driver = {
> +		   .owner = THIS_MODULE,
> +		   .name = "imx-rpmsg",
> +		   .of_match_table = imx_rpmsg_dt_ids,
> +		   },
> +	.probe = imx_rpmsg_probe,
> +	.remove = imx_rpmsg_remove,
> +};
> +
> +static int __init imx_rpmsg_init(void)
> +{
> +	int ret;
> +
> +	ret = platform_driver_register(&imx_rpmsg_driver);
> +	if (ret)
> +		pr_err("Unable to initialize rpmsg driver\n");
> +	else
> +		pr_info("imx rpmsg driver is registered.\n");
> +
> +	return ret;
> +}
> +
> +static void __exit imx_rpmsg_exit(void)
> +{
> +	pr_info("imx rpmsg driver is unregistered.\n");
> +	platform_driver_unregister(&imx_rpmsg_driver);
> +}
> +
> +module_exit(imx_rpmsg_exit);
> +module_init(imx_rpmsg_init);
> +
> +MODULE_AUTHOR("Freescale Semiconductor, Inc.");
> +MODULE_DESCRIPTION("iMX remote processor messaging virtio device");
> +MODULE_LICENSE("GPL v2");
> diff --git a/arch/arm/mach-imx/mu.c b/arch/arm/mach-imx/mu.c
> new file mode 100644
> index 0000000..7b07f48
> --- /dev/null
> +++ b/arch/arm/mach-imx/mu.c
> @@ -0,0 +1,217 @@
> +/*
> + * Copyright (C) 2016 Freescale Semiconductor, Inc.
> + *
> + * The code contained herein is licensed under the GNU General Public
> + * License. You may obtain a copy of the GNU General Public License
> + * Version 2 or later at the following locations:
> + *
> + * http://www.opensource.org/licenses/gpl-license.html
> + * http://www.gnu.org/copyleft/gpl.html
> + */
> +
> +#include <linux/clk.h>
> +#include <linux/delay.h>
> +#include <linux/init.h>
> +#include <linux/interrupt.h>
> +#include <linux/io.h>
> +#include <linux/irq.h>
> +#include <linux/of.h>
> +#include <linux/of_address.h>
> +#include <linux/of_irq.h>
> +#include <linux/notifier.h>
> +#include <linux/platform_device.h>
> +#include "common.h"
> +#include "hardware.h"
> +
> +#define MU_ATR0_OFFSET	0x0
> +#define MU_ARR0_OFFSET	0x10
> +#define MU_ARR1_OFFSET	0x14
> +#define MU_ASR		0x20
> +#define MU_ACR		0x24
> +
> +#define MU_RPMSG_HANDSHAKE_INDEX	1
> +
> +struct imx_mu_rpmsg_box {
> +	const char *name;
> +	struct blocking_notifier_head notifier;
> +};
> +
> +static struct imx_mu_rpmsg_box mu_rpmsg_box = {
> +	.name	= "m4",
> +};
> +
> +static void __iomem *mu_base;
> +static u32 m4_message;
> +static struct delayed_work rpmsg_work;
> +
> +static int imx_mu_send_message(unsigned int index, unsigned int data)
> +{
> +	u32 val, ep;
> +	int i, te_flag = 0;
> +	unsigned long timeout = jiffies + msecs_to_jiffies(500);
> +
> +	/* wait for transfer buffer empty, and no event pending */
> +	do {
> +		val = readl_relaxed(mu_base + MU_ASR);
> +		ep = val & BIT(4);
> +		if (time_after(jiffies, timeout)) {
> +			pr_err("Waiting MU transmit buffer empty timeout!\n");
> +			return -EIO;
> +		}
> +	} while (((val & (1 << (20 + 3 - index))) == 0) || (ep == BIT(4)));
> +
> +	writel_relaxed(data, mu_base + index * 0x4 + MU_ATR0_OFFSET);
> +
> +	/*
> +	 * make a double check that TEn is not empty after write
> +	 */
> +	val = readl_relaxed(mu_base + MU_ASR);
> +	ep = val & BIT(4);
> +	if (((val & (1 << (20 + (3 - index)))) == 0) || (ep == BIT(4)))
> +		return 0;
> +
> +	/*
> +	 * Make sure that TEn flag is changed, after the ATRn is filled up.
> +	 */
> +	for (i = 0; i < 100; i++) {
> +		val = readl_relaxed(mu_base + MU_ASR);
> +		ep = val & BIT(4);
> +		if (((val & (1 << (20 + 3 - index))) == 0) || (ep == BIT(4))) {
> +			te_flag = 0;
> +			break;
> +		} else if (time_after(jiffies, timeout)) {
> +			/* Can't see TEn 1->0, maybe already handled! */
> +			te_flag = 1;
> +			break;
> +		}
> +	}
> +	if (te_flag == 0)
> +		pr_info("TEn isn't changed when ATRn is filled up.\n");
> +
> +	return 0;
> +}
> +
> +int imx_mu_rpmsg_send(unsigned int rpmsg)
> +{
> +	return imx_mu_send_message(MU_RPMSG_HANDSHAKE_INDEX, rpmsg);
> +}
> +
> +int imx_mu_rpmsg_register_nb(const char *name, struct notifier_block *nb)
> +{
> +	if ((name == NULL) || (nb == NULL))
> +		return -EINVAL;
> +
> +	if (!strcmp(mu_rpmsg_box.name, name))
> +		blocking_notifier_chain_register(&(mu_rpmsg_box.notifier), nb);
> +	else
> +		return -ENOENT;
> +
> +	return 0;
> +}
> +
> +int imx_mu_rpmsg_unregister_nb(const char *name, struct notifier_block *nb)
> +{
> +	if ((name == NULL) || (nb == NULL))
> +		return -EINVAL;
> +
> +	if (!strcmp(mu_rpmsg_box.name, name))
> +		blocking_notifier_chain_unregister(&(mu_rpmsg_box.notifier),
> +				nb);
> +	else
> +		return -ENOENT;
> +
> +	return 0;
> +}
> +
> +static void rpmsg_work_handler(struct work_struct *work)
> +{
> +
> +	blocking_notifier_call_chain(&(mu_rpmsg_box.notifier), 4,
> +						(void *)m4_message);
> +	m4_message = 0;
> +}
> +
> +static irqreturn_t imx_mu_isr(int irq, void *param)
> +{
> +	u32 irqs;
> +
> +	irqs = readl_relaxed(mu_base + MU_ASR);
> +
> +	/* RPMSG */
> +	if (irqs & (1 << 26)) {
> +		/* get message from receive buffer */
> +		m4_message = readl_relaxed(mu_base + MU_ARR1_OFFSET);
> +		schedule_delayed_work(&rpmsg_work, 0);
> +	}
> +
> +	return IRQ_HANDLED;
> +}
> +
> +static int imx_mu_probe(struct platform_device *pdev)
> +{
> +	int ret;
> +	u32 irq;
> +	struct device_node *np;
> +	struct clk *clk;
> +
> +	np = of_find_compatible_node(NULL, NULL, "fsl,imx6sx-mu");
> +	mu_base = of_iomap(np, 0);
> +	WARN_ON(!mu_base);
> +
> +	irq = platform_get_irq(pdev, 0);
> +	ret = request_irq(irq, imx_mu_isr,
> +		IRQF_EARLY_RESUME, "imx-mu", &mu_rpmsg_box);
> +	if (ret) {
> +		pr_err("%s: register interrupt %d failed, rc %d\n",
> +			__func__, irq, ret);
> +		return ret;
> +	}
> +
> +	ret = of_device_is_compatible(np, "fsl,imx7d-mu");
> +	if (ret) {
> +		clk = devm_clk_get(&pdev->dev, "mu");
> +		if (IS_ERR(clk)) {
> +			dev_err(&pdev->dev,
> +				"mu clock source missing or invalid\n");
> +			return PTR_ERR(clk);
> +		}
> +
> +		ret = clk_prepare_enable(clk);
> +		if (ret) {
> +			dev_err(&pdev->dev,
> +				"unable to enable mu clock\n");
> +			return ret;
> +		}
> +	}
> +
> +	INIT_DELAYED_WORK(&rpmsg_work, rpmsg_work_handler);
> +	/* enable the bit26(RIE1) of MU_ACR */
> +	writel_relaxed(readl_relaxed(mu_base + MU_ACR) | BIT(26),
> +			mu_base + MU_ACR);
> +	BLOCKING_INIT_NOTIFIER_HEAD(&(mu_rpmsg_box.notifier));
> +
> +	pr_info("MU is ready for cross core communication!\n");
> +
> +	return 0;
> +}
> +
> +static const struct of_device_id imx_mu_ids[] = {
> +	{ .compatible = "fsl,imx6sx-mu" },
> +	{ .compatible = "fsl,imx7d-mu" },
> +	{ }
> +};
> +
> +static struct platform_driver imx_mu_driver = {
> +	.driver = {
> +		.name   = "imx-mu",
> +		.owner  = THIS_MODULE,
> +		.of_match_table = imx_mu_ids,
> +	},
> +	.probe = imx_mu_probe,
> +};
> +
> +static int __init imx_mu_init(void)
> +{
> +	return platform_driver_register(&imx_mu_driver);
> +}
> +subsys_initcall(imx_mu_init);
> diff --git a/include/linux/imx_rpmsg.h b/include/linux/imx_rpmsg.h
> new file mode 100644
> index 0000000..2b0dca5
> --- /dev/null
> +++ b/include/linux/imx_rpmsg.h
> @@ -0,0 +1,27 @@
> +/*
> + * Copyright (C) 2016 Freescale Semiconductor, Inc.
> + */
> +
> +/*
> + * The code contained herein is licensed under the GNU Lesser General
> + * Public License.  You may obtain a copy of the GNU Lesser General
> + * Public License Version 2.1 or later at the following locations:
> + *
> + * http://www.opensource.org/licenses/lgpl-license.html
> + * http://www.gnu.org/copyleft/lgpl.html
> + */
> +
> +/*
> + * @file linux/imx_rpmsg.h
> + *
> + * @brief Global header file for imx RPMSG
> + *
> + * @ingroup RPMSG
> + */
> +#ifndef __LINUX_IMX_RPMSG_H__
> +#define __LINUX_IMX_RPMSG_H__
> +
> +int imx_mu_rpmsg_send(unsigned int vq_id);
> +int imx_mu_rpmsg_register_nb(const char *name, struct notifier_block *nb);
> +int imx_mu_rpmsg_unregister_nb(const char *name, struct notifier_block *nb);
> +#endif /* __LINUX_IMX_RPMSG_H__ */
> -- 
> 1.9.1
> 
> 

RE: [RFC 3/4] ARM: imx: add the platform related rpmsg implementation

[Richard Zhu]

Hi Shawn:
Thanks for your comments.
Further review would copied to Stefan Agner.

Best Regards
hongxing zhu
Linux BSP team
Office: 86-21-28937189
Email: hongxing.zhu@nxp.com


-----Original Message-----
From: Shawn Guo [mailto:shawnguo@kernel.org] 
Sent: Thursday, January 28, 2016 9:35 AM
To: Richard Zhu
Cc: ohad@wizery.com; Stefan Agner; linux-kernel@vger.kernel.org
Subject: Re: [RFC 3/4] ARM: imx: add the platform related rpmsg implementation

On Wed, Jan 06, 2016 at 04:06:43PM +0800, Richard Zhu wrote:
> From: Richard Zhu <Richard.Zhu@freescale.com>
> 
> - add mu driver support, the irq and 4bytes msg of the mu module are 
> as the interaction channel between A# core and the M4 core on imx amp 
> platforms.
> - register one notify in isr of the mu's irq used by rpmsg.
> - instance the virtual processor, and fill up the virtio_config_ops in 
> the platform related rpmsg implementation codes.
> - hard-code the vring storage shared by A# core and M# core on AMP 
> SOCs.
> 
> Signed-off-by: Richard Zhu <hongxing.zhu@nxp.com>
> ---
>  arch/arm/mach-imx/Kconfig     |  12 ++
>  arch/arm/mach-imx/Makefile    |   2 +
>  arch/arm/mach-imx/imx_rpmsg.c | 364 ++++++++++++++++++++++++++++++++++++++++++
>  arch/arm/mach-imx/mu.c        | 217 +++++++++++++++++++++++++

I'm not rpmsg expert, but it seems to me that the driver should be put into drivers/rpmsg/ rather than mach-imx.
[Richard] This part rpmsg codes are closed related to the platform. For example, kinds of ops callback functions.
Thus, these codes are placed into arch/arm/mach-imx/ folder. BTW,  so does to omap rpmsg implementation.
http://omappedia.org/wiki/RPMsg_Kernel_Sources

Also, when you repost, you may want to copy Stefan Agner <stefan@agner.ch>, who is helping maintain Vybrid platform and might be interested in your patches.

Shawn

>  include/linux/imx_rpmsg.h     |  27 ++++
>  5 files changed, 622 insertions(+)
>  create mode 100644 arch/arm/mach-imx/imx_rpmsg.c  create mode 100644 
> arch/arm/mach-imx/mu.c  create mode 100644 include/linux/imx_rpmsg.h
> 
> diff --git a/arch/arm/mach-imx/Kconfig b/arch/arm/mach-imx/Kconfig 
> index 8ceda28..a7bc41c 100644
> --- a/arch/arm/mach-imx/Kconfig
> +++ b/arch/arm/mach-imx/Kconfig
> @@ -56,6 +56,12 @@ config HAVE_IMX_GPC  config HAVE_IMX_MMDC
>  	bool
>  
> +config HAVE_IMX_MU
> +	bool
> +
> +config HAVE_IMX_RPMSG
> +	bool
> +
>  config HAVE_IMX_SRC
>  	def_bool y if SMP
>  	select ARCH_HAS_RESET_CONTROLLER
> @@ -544,6 +550,9 @@ config SOC_IMX6SX
>  	bool "i.MX6 SoloX support"
>  	select PINCTRL_IMX6SX
>  	select SOC_IMX6
> +	select HAVE_IMX_MU
> +	select HAVE_IMX_RPMSG
> +	select RPMSG
>  
>  	help
>  	  This enables support for Freescale i.MX6 SoloX processor.
> @@ -562,6 +571,9 @@ config SOC_IMX7D
>  	select ARM_GIC
>  	select HAVE_IMX_ANATOP
>  	select HAVE_IMX_MMDC
> +	select HAVE_IMX_MU
> +	select HAVE_IMX_RPMSG
> +	select RPMSG
>  	help
>  		This enables support for Freescale i.MX7 Dual processor.
>  
> diff --git a/arch/arm/mach-imx/Makefile b/arch/arm/mach-imx/Makefile 
> index fb689d8..a3c1814 100644
> --- a/arch/arm/mach-imx/Makefile
> +++ b/arch/arm/mach-imx/Makefile
> @@ -74,7 +74,9 @@ obj-$(CONFIG_MACH_IMX35_DT) += imx35-dt.o
>  obj-$(CONFIG_HAVE_IMX_ANATOP) += anatop.o
>  obj-$(CONFIG_HAVE_IMX_GPC) += gpc.o
>  obj-$(CONFIG_HAVE_IMX_MMDC) += mmdc.o
> +obj-$(CONFIG_HAVE_IMX_MU) += mu.o
>  obj-$(CONFIG_HAVE_IMX_SRC) += src.o
> +obj-$(CONFIG_HAVE_IMX_RPMSG) += imx_rpmsg.o
>  ifneq ($(CONFIG_SOC_IMX6)$(CONFIG_SOC_LS1021A),)
>  AFLAGS_headsmp.o :=-Wa,-march=armv7-a
>  obj-$(CONFIG_SMP) += headsmp.o platsmp.o diff --git 
> a/arch/arm/mach-imx/imx_rpmsg.c b/arch/arm/mach-imx/imx_rpmsg.c new 
> file mode 100644 index 0000000..ab6ba7a
> --- /dev/null
> +++ b/arch/arm/mach-imx/imx_rpmsg.c
> @@ -0,0 +1,364 @@
> +/*
> + * Copyright (C) 2016 Freescale Semiconductor, Inc.
> + *
> + * derived from the omap-rpmsg implementation.
> + *
> + * The code contained herein is licensed under the GNU General Public
> + * License. You may obtain a copy of the GNU General Public License
> + * Version 2 or later at the following locations:
> + *
> + * http://www.opensource.org/licenses/gpl-license.html
> + * http://www.gnu.org/copyleft/gpl.html
> + */
> +
> +#include <linux/err.h>
> +#include <linux/init.h>
> +#include <linux/interrupt.h>
> +#include <linux/module.h>
> +#include <linux/notifier.h>
> +#include <linux/of.h>
> +#include <linux/platform_device.h>
> +#include <linux/rpmsg.h>
> +#include <linux/slab.h>
> +#include <linux/virtio.h>
> +#include <linux/virtio_config.h>
> +#include <linux/virtio_ids.h>
> +#include <linux/virtio_ring.h>
> +#include <linux/imx_rpmsg.h>
> +
> +struct imx_rpmsg_vproc {
> +	struct virtio_device vdev;
> +	unsigned int vring[2];
> +	char *rproc_name;
> +	struct mutex lock;
> +	struct notifier_block nb;
> +	struct virtqueue *vq[2];
> +	int base_vq_id;
> +	int num_of_vqs;
> +};
> +
> +/*
> + * For now, allocate 256 buffers of 512 bytes for each side. each 
> +buffer
> + * will then have 16B for the msg header and 496B for the payload.
> + * This will require a total space of 256KB for the buffers 
> +themselves, and
> + * 3 pages for every vring (the size of the vring depends on the 
> +number of
> + * buffers it supports).
> + */
> +#define RPMSG_NUM_BUFS		(512)
> +#define RPMSG_BUF_SIZE		(512)
> +#define RPMSG_BUFS_SPACE	(RPMSG_NUM_BUFS * RPMSG_BUF_SIZE)
> +
> +/*
> + * The alignment between the consumer and producer parts of the vring.
> + * Note: this is part of the "wire" protocol. If you change this, you 
> +need
> + * to update your BIOS image as well
> + */
> +#define RPMSG_VRING_ALIGN	(4096)
> +
> +/* With 256 buffers, our vring will occupy 3 pages */
> +#define RPMSG_RING_SIZE	((DIV_ROUND_UP(vring_size(RPMSG_NUM_BUFS / 2, \
> +				RPMSG_VRING_ALIGN), PAGE_SIZE)) * PAGE_SIZE)
> +
> +#define to_imx_rpdev(vd) container_of(vd, struct imx_rpmsg_vproc, 
> +vdev)
> +
> +struct imx_rpmsg_vq_info {
> +	__u16 num;	/* number of entries in the virtio_ring */
> +	__u16 vq_id;	/* a globaly unique index of this virtqueue */
> +	void *addr;	/* address where we mapped the virtio ring */
> +	struct imx_rpmsg_vproc *rpdev;
> +};
> +
> +static u64 imx_rpmsg_get_features(struct virtio_device *vdev) {
> +	return 1 << VIRTIO_RPMSG_F_NS;
> +}
> +
> +static int imx_rpmsg_finalize_features(struct virtio_device *vdev) {
> +	/* Give virtio_ring a chance to accept features */
> +	vring_transport_features(vdev);
> +	return 0;
> +}
> +
> +/* kick the remote processor, and let it know which virtqueue to poke 
> +at */ static bool imx_rpmsg_notify(struct virtqueue *vq) {
> +	int ret;
> +	unsigned int mu_rpmsg = 0;
> +	struct imx_rpmsg_vq_info *rpvq = vq->priv;
> +
> +	mu_rpmsg = rpvq->vq_id << 16;
> +	mutex_lock(&rpvq->rpdev->lock);
> +	/* send the index of the triggered virtqueue as the mu payload */
> +	ret = imx_mu_rpmsg_send(mu_rpmsg);
> +	mutex_unlock(&rpvq->rpdev->lock);
> +	if (ret) {
> +		pr_err("ugh, imx_mu_rpmsg_send() failed: %d\n", ret);
> +		return false;
> +	}
> +
> +	return true;
> +}
> +
> +static int imx_mu_rpmsg_callback(struct notifier_block *this,
> +					unsigned long index, void *data) {
> +	u32 mu_msg = (u32) data;
> +	struct imx_rpmsg_vproc *rpdev;
> +
> +	rpdev = container_of(this, struct imx_rpmsg_vproc, nb);
> +
> +	pr_debug("%s mu_msg: 0x%x\n", __func__, mu_msg);
> +
> +	/* ignore vq indices which are clearly not for us */
> +	mu_msg = mu_msg >> 16;
> +	if (mu_msg < rpdev->base_vq_id)
> +		pr_err("mu_msg: 0x%x is invalid\n", mu_msg);
> +
> +	mu_msg -= rpdev->base_vq_id;
> +
> +	/*
> +	 * Currently both PENDING_MSG and explicit-virtqueue-index
> +	 * messaging are supported.
> +	 * Whatever approach is taken, at this point 'mu_msg' contains
> +	 * the index of the vring which was just triggered.
> +	 */
> +	if (mu_msg < rpdev->num_of_vqs)
> +		vring_interrupt(mu_msg, rpdev->vq[mu_msg]);
> +
> +	return NOTIFY_DONE;
> +}
> +
> +static struct virtqueue *rp_find_vq(struct virtio_device *vdev,
> +				    unsigned index,
> +				    void (*callback)(struct virtqueue *vq),
> +				    const char *name)
> +{
> +	struct imx_rpmsg_vproc *rpdev = to_imx_rpdev(vdev);
> +	struct imx_rpmsg_vq_info *rpvq;
> +	struct virtqueue *vq;
> +	int err;
> +
> +	rpvq = kmalloc(sizeof(*rpvq), GFP_KERNEL);
> +	if (!rpvq)
> +		return ERR_PTR(-ENOMEM);
> +
> +	/* ioremap'ing normal memory, so we cast away sparse's complaints */
> +	rpvq->addr = (__force void *) ioremap_nocache(rpdev->vring[index],
> +							RPMSG_RING_SIZE);
> +	if (!rpvq->addr) {
> +		err = -ENOMEM;
> +		goto free_rpvq;
> +	}
> +
> +	memset(rpvq->addr, 0, RPMSG_RING_SIZE);
> +
> +	pr_debug("vring%d: phys 0x%x, virt 0x%x\n", index, rpdev->vring[index],
> +					(unsigned int) rpvq->addr);
> +
> +	vq = vring_new_virtqueue(index, RPMSG_NUM_BUFS / 2, RPMSG_VRING_ALIGN,
> +			vdev, true, rpvq->addr, imx_rpmsg_notify, callback,
> +			name);
> +	if (!vq) {
> +		pr_err("vring_new_virtqueue failed\n");
> +		err = -ENOMEM;
> +		goto unmap_vring;
> +	}
> +
> +	rpdev->vq[index] = vq;
> +	vq->priv = rpvq;
> +	/* system-wide unique id for this virtqueue */
> +	rpvq->vq_id = rpdev->base_vq_id + index;
> +	rpvq->rpdev = rpdev;
> +	mutex_init(&rpdev->lock);
> +
> +	return vq;
> +
> +unmap_vring:
> +	/* iounmap normal memory, so make sparse happy */
> +	iounmap((__force void __iomem *) rpvq->addr);
> +free_rpvq:
> +	kfree(rpvq);
> +	return ERR_PTR(err);
> +}
> +
> +static void imx_rpmsg_del_vqs(struct virtio_device *vdev) {
> +	struct virtqueue *vq, *n;
> +	struct imx_rpmsg_vproc *rpdev = to_imx_rpdev(vdev);
> +
> +	list_for_each_entry_safe(vq, n, &vdev->vqs, list) {
> +		struct imx_rpmsg_vq_info *rpvq = vq->priv;
> +
> +		iounmap(rpvq->addr);
> +		vring_del_virtqueue(vq);
> +		kfree(rpvq);
> +	}
> +
> +	if (&rpdev->nb)
> +		imx_mu_rpmsg_unregister_nb((const char *)rpdev->rproc_name,
> +				&rpdev->nb);
> +}
> +
> +static int imx_rpmsg_find_vqs(struct virtio_device *vdev, unsigned nvqs,
> +		       struct virtqueue *vqs[],
> +		       vq_callback_t *callbacks[],
> +		       const char *names[])
> +{
> +	struct imx_rpmsg_vproc *rpdev = to_imx_rpdev(vdev);
> +	int i, err;
> +
> +	/* we maintain two virtqueues per remote processor (for RX and TX) */
> +	if (nvqs != 2)
> +		return -EINVAL;
> +
> +	for (i = 0; i < nvqs; ++i) {
> +		vqs[i] = rp_find_vq(vdev, i, callbacks[i], names[i]);
> +		if (IS_ERR(vqs[i])) {
> +			err = PTR_ERR(vqs[i]);
> +			goto error;
> +		}
> +	}
> +
> +	rpdev->num_of_vqs = nvqs;
> +
> +	rpdev->nb.notifier_call = imx_mu_rpmsg_callback;
> +	imx_mu_rpmsg_register_nb((const char *)rpdev->rproc_name, 
> +&rpdev->nb);
> +
> +	return 0;
> +
> +error:
> +	imx_rpmsg_del_vqs(vdev);
> +	return err;
> +}
> +
> +static void imx_rpmsg_reset(struct virtio_device *vdev) {
> +	dev_dbg(&vdev->dev, "reset !\n");
> +}
> +
> +static u8 imx_rpmsg_get_status(struct virtio_device *vdev) {
> +	return 0;
> +}
> +
> +static void imx_rpmsg_set_status(struct virtio_device *vdev, u8 
> +status) {
> +	dev_dbg(&vdev->dev, "%s new status: %d\n", __func__, status); }
> +
> +static void imx_rpmsg_vproc_release(struct device *dev) {
> +	/* this handler is provided so driver core doesn't yell at us */ }
> +
> +static struct virtio_config_ops imx_rpmsg_config_ops = {
> +	.get_features	= imx_rpmsg_get_features,
> +	.finalize_features = imx_rpmsg_finalize_features,
> +	.find_vqs	= imx_rpmsg_find_vqs,
> +	.del_vqs	= imx_rpmsg_del_vqs,
> +	.reset		= imx_rpmsg_reset,
> +	.set_status	= imx_rpmsg_set_status,
> +	.get_status	= imx_rpmsg_get_status,
> +};
> +
> +static struct imx_rpmsg_vproc imx_rpmsg_vprocs[] = {
> +	{
> +		.vdev.id.device	= VIRTIO_ID_RPMSG,
> +		.vdev.config	= &imx_rpmsg_config_ops,
> +		.rproc_name	= "m4",
> +		.base_vq_id	= 0,
> +	},
> +};
> +
> +static const struct of_device_id imx_rpmsg_dt_ids[] = {
> +	{ .compatible = "fsl,imx6sx-rpmsg", },
> +	{ .compatible = "fsl,imx7d-rpmsg", },
> +	{ /* sentinel */ }
> +};
> +MODULE_DEVICE_TABLE(of, imx_rpmsg_dt_ids);
> +
> +static int imx_rpmsg_probe(struct platform_device *pdev) {
> +	int i, ret = 0;
> +	struct device_node *np = pdev->dev.of_node;
> +
> +	for (i = 0; i < ARRAY_SIZE(imx_rpmsg_vprocs); i++) {
> +		struct imx_rpmsg_vproc *rpdev = &imx_rpmsg_vprocs[i];
> +
> +		if (!strcmp(rpdev->rproc_name, "m4")) {
> +			ret = of_device_is_compatible(np, "fsl,imx7d-rpmsg");
> +			ret |= of_device_is_compatible(np, "fsl,imx6sx-rpmsg");
> +			if (ret) {
> +				/* hardcodes here now. */
> +				rpdev->vring[0] = 0xBFFF0000;
> +				rpdev->vring[1] = 0xBFFF8000;
> +			}
> +		} else {
> +			break;
> +		}
> +
> +		pr_debug("%s rpdev%d: vring0 0x%x, vring1 0x%x\n", __func__,
> +				i, rpdev->vring[0], rpdev->vring[1]);
> +
> +		rpdev->vdev.dev.parent = &pdev->dev;
> +		rpdev->vdev.dev.release = imx_rpmsg_vproc_release;
> +
> +		ret = register_virtio_device(&rpdev->vdev);
> +		if (ret) {
> +			pr_err("%s failed to register rpdev: %d\n",
> +					__func__, ret);
> +			break;
> +		}
> +	}
> +
> +	return ret;
> +}
> +
> +static int imx_rpmsg_remove(struct platform_device *pdev) {
> +	int i;
> +
> +	for (i = 0; i < ARRAY_SIZE(imx_rpmsg_vprocs); i++) {
> +		struct imx_rpmsg_vproc *rpdev = &imx_rpmsg_vprocs[i];
> +
> +		unregister_virtio_device(&rpdev->vdev);
> +	}
> +	return 0;
> +}
> +
> +static struct platform_driver imx_rpmsg_driver = {
> +	.driver = {
> +		   .owner = THIS_MODULE,
> +		   .name = "imx-rpmsg",
> +		   .of_match_table = imx_rpmsg_dt_ids,
> +		   },
> +	.probe = imx_rpmsg_probe,
> +	.remove = imx_rpmsg_remove,
> +};
> +
> +static int __init imx_rpmsg_init(void) {
> +	int ret;
> +
> +	ret = platform_driver_register(&imx_rpmsg_driver);
> +	if (ret)
> +		pr_err("Unable to initialize rpmsg driver\n");
> +	else
> +		pr_info("imx rpmsg driver is registered.\n");
> +
> +	return ret;
> +}
> +
> +static void __exit imx_rpmsg_exit(void) {
> +	pr_info("imx rpmsg driver is unregistered.\n");
> +	platform_driver_unregister(&imx_rpmsg_driver);
> +}
> +
> +module_exit(imx_rpmsg_exit);
> +module_init(imx_rpmsg_init);
> +
> +MODULE_AUTHOR("Freescale Semiconductor, Inc."); 
> +MODULE_DESCRIPTION("iMX remote processor messaging virtio device"); 
> +MODULE_LICENSE("GPL v2");
> diff --git a/arch/arm/mach-imx/mu.c b/arch/arm/mach-imx/mu.c new file 
> mode 100644 index 0000000..7b07f48
> --- /dev/null
> +++ b/arch/arm/mach-imx/mu.c
> @@ -0,0 +1,217 @@
> +/*
> + * Copyright (C) 2016 Freescale Semiconductor, Inc.
> + *
> + * The code contained herein is licensed under the GNU General Public
> + * License. You may obtain a copy of the GNU General Public License
> + * Version 2 or later at the following locations:
> + *
> + * http://www.opensource.org/licenses/gpl-license.html
> + * http://www.gnu.org/copyleft/gpl.html
> + */
> +
> +#include <linux/clk.h>
> +#include <linux/delay.h>
> +#include <linux/init.h>
> +#include <linux/interrupt.h>
> +#include <linux/io.h>
> +#include <linux/irq.h>
> +#include <linux/of.h>
> +#include <linux/of_address.h>
> +#include <linux/of_irq.h>
> +#include <linux/notifier.h>
> +#include <linux/platform_device.h>
> +#include "common.h"
> +#include "hardware.h"
> +
> +#define MU_ATR0_OFFSET	0x0
> +#define MU_ARR0_OFFSET	0x10
> +#define MU_ARR1_OFFSET	0x14
> +#define MU_ASR		0x20
> +#define MU_ACR		0x24
> +
> +#define MU_RPMSG_HANDSHAKE_INDEX	1
> +
> +struct imx_mu_rpmsg_box {
> +	const char *name;
> +	struct blocking_notifier_head notifier; };
> +
> +static struct imx_mu_rpmsg_box mu_rpmsg_box = {
> +	.name	= "m4",
> +};
> +
> +static void __iomem *mu_base;
> +static u32 m4_message;
> +static struct delayed_work rpmsg_work;
> +
> +static int imx_mu_send_message(unsigned int index, unsigned int data) 
> +{
> +	u32 val, ep;
> +	int i, te_flag = 0;
> +	unsigned long timeout = jiffies + msecs_to_jiffies(500);
> +
> +	/* wait for transfer buffer empty, and no event pending */
> +	do {
> +		val = readl_relaxed(mu_base + MU_ASR);
> +		ep = val & BIT(4);
> +		if (time_after(jiffies, timeout)) {
> +			pr_err("Waiting MU transmit buffer empty timeout!\n");
> +			return -EIO;
> +		}
> +	} while (((val & (1 << (20 + 3 - index))) == 0) || (ep == BIT(4)));
> +
> +	writel_relaxed(data, mu_base + index * 0x4 + MU_ATR0_OFFSET);
> +
> +	/*
> +	 * make a double check that TEn is not empty after write
> +	 */
> +	val = readl_relaxed(mu_base + MU_ASR);
> +	ep = val & BIT(4);
> +	if (((val & (1 << (20 + (3 - index)))) == 0) || (ep == BIT(4)))
> +		return 0;
> +
> +	/*
> +	 * Make sure that TEn flag is changed, after the ATRn is filled up.
> +	 */
> +	for (i = 0; i < 100; i++) {
> +		val = readl_relaxed(mu_base + MU_ASR);
> +		ep = val & BIT(4);
> +		if (((val & (1 << (20 + 3 - index))) == 0) || (ep == BIT(4))) {
> +			te_flag = 0;
> +			break;
> +		} else if (time_after(jiffies, timeout)) {
> +			/* Can't see TEn 1->0, maybe already handled! */
> +			te_flag = 1;
> +			break;
> +		}
> +	}
> +	if (te_flag == 0)
> +		pr_info("TEn isn't changed when ATRn is filled up.\n");
> +
> +	return 0;
> +}
> +
> +int imx_mu_rpmsg_send(unsigned int rpmsg) {
> +	return imx_mu_send_message(MU_RPMSG_HANDSHAKE_INDEX, rpmsg); }
> +
> +int imx_mu_rpmsg_register_nb(const char *name, struct notifier_block 
> +*nb) {
> +	if ((name == NULL) || (nb == NULL))
> +		return -EINVAL;
> +
> +	if (!strcmp(mu_rpmsg_box.name, name))
> +		blocking_notifier_chain_register(&(mu_rpmsg_box.notifier), nb);
> +	else
> +		return -ENOENT;
> +
> +	return 0;
> +}
> +
> +int imx_mu_rpmsg_unregister_nb(const char *name, struct 
> +notifier_block *nb) {
> +	if ((name == NULL) || (nb == NULL))
> +		return -EINVAL;
> +
> +	if (!strcmp(mu_rpmsg_box.name, name))
> +		blocking_notifier_chain_unregister(&(mu_rpmsg_box.notifier),
> +				nb);
> +	else
> +		return -ENOENT;
> +
> +	return 0;
> +}
> +
> +static void rpmsg_work_handler(struct work_struct *work) {
> +
> +	blocking_notifier_call_chain(&(mu_rpmsg_box.notifier), 4,
> +						(void *)m4_message);
> +	m4_message = 0;
> +}
> +
> +static irqreturn_t imx_mu_isr(int irq, void *param) {
> +	u32 irqs;
> +
> +	irqs = readl_relaxed(mu_base + MU_ASR);
> +
> +	/* RPMSG */
> +	if (irqs & (1 << 26)) {
> +		/* get message from receive buffer */
> +		m4_message = readl_relaxed(mu_base + MU_ARR1_OFFSET);
> +		schedule_delayed_work(&rpmsg_work, 0);
> +	}
> +
> +	return IRQ_HANDLED;
> +}
> +
> +static int imx_mu_probe(struct platform_device *pdev) {
> +	int ret;
> +	u32 irq;
> +	struct device_node *np;
> +	struct clk *clk;
> +
> +	np = of_find_compatible_node(NULL, NULL, "fsl,imx6sx-mu");
> +	mu_base = of_iomap(np, 0);
> +	WARN_ON(!mu_base);
> +
> +	irq = platform_get_irq(pdev, 0);
> +	ret = request_irq(irq, imx_mu_isr,
> +		IRQF_EARLY_RESUME, "imx-mu", &mu_rpmsg_box);
> +	if (ret) {
> +		pr_err("%s: register interrupt %d failed, rc %d\n",
> +			__func__, irq, ret);
> +		return ret;
> +	}
> +
> +	ret = of_device_is_compatible(np, "fsl,imx7d-mu");
> +	if (ret) {
> +		clk = devm_clk_get(&pdev->dev, "mu");
> +		if (IS_ERR(clk)) {
> +			dev_err(&pdev->dev,
> +				"mu clock source missing or invalid\n");
> +			return PTR_ERR(clk);
> +		}
> +
> +		ret = clk_prepare_enable(clk);
> +		if (ret) {
> +			dev_err(&pdev->dev,
> +				"unable to enable mu clock\n");
> +			return ret;
> +		}
> +	}
> +
> +	INIT_DELAYED_WORK(&rpmsg_work, rpmsg_work_handler);
> +	/* enable the bit26(RIE1) of MU_ACR */
> +	writel_relaxed(readl_relaxed(mu_base + MU_ACR) | BIT(26),
> +			mu_base + MU_ACR);
> +	BLOCKING_INIT_NOTIFIER_HEAD(&(mu_rpmsg_box.notifier));
> +
> +	pr_info("MU is ready for cross core communication!\n");
> +
> +	return 0;
> +}
> +
> +static const struct of_device_id imx_mu_ids[] = {
> +	{ .compatible = "fsl,imx6sx-mu" },
> +	{ .compatible = "fsl,imx7d-mu" },
> +	{ }
> +};
> +
> +static struct platform_driver imx_mu_driver = {
> +	.driver = {
> +		.name   = "imx-mu",
> +		.owner  = THIS_MODULE,
> +		.of_match_table = imx_mu_ids,
> +	},
> +	.probe = imx_mu_probe,
> +};
> +
> +static int __init imx_mu_init(void)
> +{
> +	return platform_driver_register(&imx_mu_driver);
> +}
> +subsys_initcall(imx_mu_init);
> diff --git a/include/linux/imx_rpmsg.h b/include/linux/imx_rpmsg.h new 
> file mode 100644 index 0000000..2b0dca5
> --- /dev/null
> +++ b/include/linux/imx_rpmsg.h
> @@ -0,0 +1,27 @@
> +/*
> + * Copyright (C) 2016 Freescale Semiconductor, Inc.
> + */
> +
> +/*
> + * The code contained herein is licensed under the GNU Lesser General
> + * Public License.  You may obtain a copy of the GNU Lesser General
> + * Public License Version 2.1 or later at the following locations:
> + *
> + * http://www.opensource.org/licenses/lgpl-license.html
> + * http://www.gnu.org/copyleft/lgpl.html
> + */
> +
> +/*
> + * @file linux/imx_rpmsg.h
> + *
> + * @brief Global header file for imx RPMSG
> + *
> + * @ingroup RPMSG
> + */
> +#ifndef __LINUX_IMX_RPMSG_H__
> +#define __LINUX_IMX_RPMSG_H__
> +
> +int imx_mu_rpmsg_send(unsigned int vq_id); int 
> +imx_mu_rpmsg_register_nb(const char *name, struct notifier_block 
> +*nb); int imx_mu_rpmsg_unregister_nb(const char *name, struct 
> +notifier_block *nb); #endif /* __LINUX_IMX_RPMSG_H__ */
> --
> 1.9.1
> 
> 

Re: [RFC 3/4] ARM: imx: add the platform related rpmsg implementation

[Shawn Guo]

On Thu, Jan 28, 2016 at 02:17:21AM +0000, Richard Zhu wrote:
> >  arch/arm/mach-imx/Kconfig     |  12 ++
> >  arch/arm/mach-imx/Makefile    |   2 +
> >  arch/arm/mach-imx/imx_rpmsg.c | 364 ++++++++++++++++++++++++++++++++++++++++++
> >  arch/arm/mach-imx/mu.c        | 217 +++++++++++++++++++++++++
> 
> I'm not rpmsg expert, but it seems to me that the driver should be put into drivers/rpmsg/ rather than mach-imx.
> [Richard] This part rpmsg codes are closed related to the platform. For example, kinds of ops callback functions.
> Thus, these codes are placed into arch/arm/mach-imx/ folder. BTW,  so does to omap rpmsg implementation.
> http://omappedia.org/wiki/RPMsg_Kernel_Sources

Okay, I will find some time slot to get myself familiar with rpmsg
subsystem and then review the patch.

Shawn

RE: [RFC 3/4] ARM: imx: add the platform related rpmsg implementation

[Richard Zhu]

Thanks a lot.

Best Regards
hongxing zhu
Linux BSP team
Office: 86-21-28937189
Email: hongxing.zhu@nxp.com


-----Original Message-----
From: Shawn Guo [mailto:shawnguo@kernel.org] 
Sent: Thursday, January 28, 2016 1:50 PM
To: Richard Zhu
Cc: ohad@wizery.com; Stefan Agner; linux-kernel@vger.kernel.org
Subject: Re: [RFC 3/4] ARM: imx: add the platform related rpmsg implementation

On Thu, Jan 28, 2016 at 02:17:21AM +0000, Richard Zhu wrote:
> >  arch/arm/mach-imx/Kconfig     |  12 ++
> >  arch/arm/mach-imx/Makefile    |   2 +
> >  arch/arm/mach-imx/imx_rpmsg.c | 364 ++++++++++++++++++++++++++++++++++++++++++
> >  arch/arm/mach-imx/mu.c        | 217 +++++++++++++++++++++++++
> 
> I'm not rpmsg expert, but it seems to me that the driver should be put into drivers/rpmsg/ rather than mach-imx.
> [Richard] This part rpmsg codes are closed related to the platform. For example, kinds of ops callback functions.
> Thus, these codes are placed into arch/arm/mach-imx/ folder. BTW,  so does to omap rpmsg implementation.
> http://omappedia.org/wiki/RPMsg_Kernel_Sources

Okay, I will find some time slot to get myself familiar with rpmsg subsystem and then review the patch.

Shawn

Re: [RFC 3/4] ARM: imx: add the platform related rpmsg implementation

[Shawn Guo]

+LAKML

On Thu, Jan 28, 2016 at 02:17:21AM +0000, Richard Zhu wrote:
> Hi Shawn:
> Thanks for your comments.
> Further review would copied to Stefan Agner.

Please do not top-posting.

> On Wed, Jan 06, 2016 at 04:06:43PM +0800, Richard Zhu wrote:
> > From: Richard Zhu <Richard.Zhu@freescale.com>
> > 
> > - add mu driver support, the irq and 4bytes msg of the mu module are 
> > as the interaction channel between A# core and the M4 core on imx amp 
> > platforms.
> > - register one notify in isr of the mu's irq used by rpmsg.
> > - instance the virtual processor, and fill up the virtio_config_ops in 
> > the platform related rpmsg implementation codes.
> > - hard-code the vring storage shared by A# core and M# core on AMP 
> > SOCs.
> > 
> > Signed-off-by: Richard Zhu <hongxing.zhu@nxp.com>
> > ---
> >  arch/arm/mach-imx/Kconfig     |  12 ++
> >  arch/arm/mach-imx/Makefile    |   2 +
> >  arch/arm/mach-imx/imx_rpmsg.c | 364 ++++++++++++++++++++++++++++++++++++++++++
> >  arch/arm/mach-imx/mu.c        | 217 +++++++++++++++++++++++++
> 
> I'm not rpmsg expert, but it seems to me that the driver should be put into drivers/rpmsg/ rather than mach-imx.
> [Richard] This part rpmsg codes are closed related to the platform. For example, kinds of ops callback functions.
> Thus, these codes are placed into arch/arm/mach-imx/ folder. BTW,  so does to omap rpmsg implementation.
> http://omappedia.org/wiki/RPMsg_Kernel_Sources

I just took a closer look at this.  What the omappedia page above
describes is an OMAP rpmsg implementation in a vendor tree which is
in turn based on a relatively old kernel version, i.e. v3.0.

I guess the implementation is a base of what mainline has today on
remoteproc/rpmsg support, but they are somehow different.  For example,
on mainline kernel today, there is no remoteproc/rpmsg code in
arch/arm/plat-omap.  And, instead of handling rpmsg with a platform
specific driver, remoteproc encapsulates the rpmsg support.  You can
find the details in commit ac8954a41393 (remoteproc: create rpmsg virtio
device).

I suggest you look at the mainline code today instead of any old
implementation for reference.  And in any case, with device tree
support to populate platform device as needed, it's a wrong to put
remoteproc/rpmsg related driver code into arch/arm/mach-imx.

Shawn

RE: [RFC 3/4] ARM: imx: add the platform related rpmsg implementation

[Richard Zhu]

> -----Original Message-----
> From: Shawn Guo [mailto:shawnguo@kernel.org]
> Sent: Monday, February 15, 2016 2:10 PM
> To: Richard Zhu
> Cc: ohad@wizery.com; Stefan Agner; linux-kernel@vger.kernel.org; linux-arm-
> kernel@lists.infradead.org
> Subject: Re: [RFC 3/4] ARM: imx: add the platform related rpmsg
> implementation
> 
> +LAKML
> 
> On Thu, Jan 28, 2016 at 02:17:21AM +0000, Richard Zhu wrote:
> > Hi Shawn:
> > Thanks for your comments.
> > Further review would copied to Stefan Agner.
> 
> Please do not top-posting.
> 
> > On Wed, Jan 06, 2016 at 04:06:43PM +0800, Richard Zhu wrote:
> > > From: Richard Zhu <Richard.Zhu@freescale.com>
> > >
> > > - add mu driver support, the irq and 4bytes msg of the mu module are
> > > as the interaction channel between A# core and the M4 core on imx
> > > amp platforms.
> > > - register one notify in isr of the mu's irq used by rpmsg.
> > > - instance the virtual processor, and fill up the virtio_config_ops
> > > in the platform related rpmsg implementation codes.
> > > - hard-code the vring storage shared by A# core and M# core on AMP
> > > SOCs.
> > >
> > > Signed-off-by: Richard Zhu <hongxing.zhu@nxp.com>
> > > ---
> > >  arch/arm/mach-imx/Kconfig     |  12 ++
> > >  arch/arm/mach-imx/Makefile    |   2 +
> > >  arch/arm/mach-imx/imx_rpmsg.c | 364
> ++++++++++++++++++++++++++++++++++++++++++
> > >  arch/arm/mach-imx/mu.c        | 217 +++++++++++++++++++++++++
> >
> > I'm not rpmsg expert, but it seems to me that the driver should be put into
> drivers/rpmsg/ rather than mach-imx.
> > [Richard] This part rpmsg codes are closed related to the platform. For
> example, kinds of ops callback functions.
> > Thus, these codes are placed into arch/arm/mach-imx/ folder. BTW,  so does
> to omap rpmsg implementation.
> > http://omappedia.org/wiki/RPMsg_Kernel_Sources
> 
> I just took a closer look at this.  What the omappedia page above describes is
> an OMAP rpmsg implementation in a vendor tree which is in turn based on a
> relatively old kernel version, i.e. v3.0.
> 
> I guess the implementation is a base of what mainline has today on
> remoteproc/rpmsg support, but they are somehow different.  For example, on
> mainline kernel today, there is no remoteproc/rpmsg code in arch/arm/plat-
> omap.  And, instead of handling rpmsg with a platform specific driver,
> remoteproc encapsulates the rpmsg support.  You can find the details in
> commit ac8954a41393 (remoteproc: create rpmsg virtio device).
> 
> I suggest you look at the mainline code today instead of any old
> implementation for reference.  And in any case, with device tree support to
> populate platform device as needed, it's a wrong to put remoteproc/rpmsg
> related driver code into arch/arm/mach-imx.
> 
> Shawn
[Zhu hongxing]  Thanks a lot for your advice. I would take look into it, and re-organize my
patch-set.

Best Regards
hongxing zhu

[RFC 4/4] samples/rpmsg: add the imx pingpong rpmsg sample

[Richard Zhu]

From: Richard Zhu <Richard.Zhu@freescale.com>

Add one pingpong rpmsg sample, that demostrate the
how to communicate with an AMP-configured remote
processor over rpmsg bus.

In this sample, A# core of imx AMP SOC would
send out one unsigned int data "rpmsg_pingpong",
the initialized value is "0",
to the remote M# core when this driver is loaded.

The "rpmsg_pingpong" would be plus one at M# core side,
then sent back to A# core.
A# would do the same operations, after receive the
"rpmsg_pingpong" sent out by M# core, then send it
back to M#.

The demonstration would be stopped after 10000 times

Signed-off-by: Richard Zhu <hongxing.zhu@nxp.com>
---
 samples/Kconfig                    |  8 +++
 samples/rpmsg/Makefile             |  1 +
 samples/rpmsg/imx_rpmsg_pingpong.c | 99 ++++++++++++++++++++++++++++++++++++++
 3 files changed, 108 insertions(+)
 create mode 100644 samples/rpmsg/imx_rpmsg_pingpong.c

diff --git a/samples/Kconfig b/samples/Kconfig
index d54f28c..49e0b62 100644
--- a/samples/Kconfig
+++ b/samples/Kconfig
@@ -63,6 +63,14 @@ config SAMPLE_RPMSG_CLIENT
 	  to communicate with an AMP-configured remote processor over
 	  the rpmsg bus.
 
+config IMX_RPMSG_PINGPONG
+	tristate "Build imx rpmsg pingpong sample -- loadable modules only"
+	depends on RPMSG && m
+	help
+	  Build an imx rpmsg pingpong sample driver, which demonstrates
+	  the data transactions on the AMP-configured imx processor over
+	  the rpmsg bus.
+
 config SAMPLE_LIVEPATCH
 	tristate "Build live patching sample -- loadable modules only"
 	depends on LIVEPATCH && m
diff --git a/samples/rpmsg/Makefile b/samples/rpmsg/Makefile
index 2d4973c..c01daae 100644
--- a/samples/rpmsg/Makefile
+++ b/samples/rpmsg/Makefile
@@ -1 +1,2 @@
 obj-$(CONFIG_SAMPLE_RPMSG_CLIENT) += rpmsg_client_sample.o
+obj-$(CONFIG_IMX_RPMSG_PINGPONG)	+= imx_rpmsg_pingpong.o
diff --git a/samples/rpmsg/imx_rpmsg_pingpong.c b/samples/rpmsg/imx_rpmsg_pingpong.c
new file mode 100644
index 0000000..f46ebe1
--- /dev/null
+++ b/samples/rpmsg/imx_rpmsg_pingpong.c
@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ *
+ * derived from the omap-rpmsg implementation.
+ * Remote processor messaging transport - pingpong driver
+ *
+ * The code contained herein is licensed under the GNU General Public
+ * License. You may obtain a copy of the GNU General Public License
+ * Version 2 or later at the following locations:
+ *
+ * http://www.opensource.org/licenses/gpl-license.html
+ * http://www.gnu.org/copyleft/gpl.html
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/virtio.h>
+#include <linux/rpmsg.h>
+
+#define MSG_LIMIT	100000
+static unsigned int rpmsg_pingpong;
+static int rx_count;
+
+static void rpmsg_pingpong_cb(struct rpmsg_channel *rpdev, void *data, int len,
+						void *priv, u32 src)
+{
+	int err;
+
+	/* reply */
+	rpmsg_pingpong = *(unsigned int *)data;
+	pr_info("get %d (src: 0x%x)\n",
+			rpmsg_pingpong, src);
+	rx_count++;
+
+	/* pingpongs should not live forever */
+	if (rx_count >= MSG_LIMIT) {
+		dev_info(&rpdev->dev, "goodbye!\n");
+		return;
+	}
+	rpmsg_pingpong++;
+	err = rpmsg_sendto(rpdev, (void *)(&rpmsg_pingpong), 4, src);
+
+	if (err)
+		dev_err(&rpdev->dev, "rpmsg_send failed: %d\n", err);
+}
+
+static int rpmsg_pingpong_probe(struct rpmsg_channel *rpdev)
+{
+	int err;
+
+	dev_info(&rpdev->dev, "new channel: 0x%x -> 0x%x!\n",
+			rpdev->src, rpdev->dst);
+
+	rpmsg_pingpong = 0;
+	rx_count = 0;
+	err = rpmsg_sendto(rpdev, (void *)(&rpmsg_pingpong), 4, rpdev->dst);
+	if (err) {
+		dev_err(&rpdev->dev, "rpmsg_send failed: %d\n", err);
+		return err;
+	}
+
+	return 0;
+}
+
+static void rpmsg_pingpong_remove(struct rpmsg_channel *rpdev)
+{
+	dev_info(&rpdev->dev, "rpmsg pingpong driver is removed\n");
+}
+
+static struct rpmsg_device_id rpmsg_driver_pingpong_id_table[] = {
+	{ .name	= "rpmsg-openamp-demo-channel" },
+	{ },
+};
+MODULE_DEVICE_TABLE(rpmsg, rpmsg_driver_pingpong_id_table);
+
+static struct rpmsg_driver rpmsg_pingpong_driver = {
+	.drv.name	= KBUILD_MODNAME,
+	.drv.owner	= THIS_MODULE,
+	.id_table	= rpmsg_driver_pingpong_id_table,
+	.probe		= rpmsg_pingpong_probe,
+	.callback	= rpmsg_pingpong_cb,
+	.remove		= rpmsg_pingpong_remove,
+};
+
+static int __init init(void)
+{
+	return register_rpmsg_driver(&rpmsg_pingpong_driver);
+}
+
+static void __exit fini(void)
+{
+	unregister_rpmsg_driver(&rpmsg_pingpong_driver);
+}
+module_init(init);
+module_exit(fini);
+
+MODULE_AUTHOR("Freescale Semiconductor, Inc.");
+MODULE_DESCRIPTION("iMX virtio remote processor messaging pingpong driver");
+MODULE_LICENSE("GPL v2");
-- 
1.9.1