ENGR00308382-1 mcc: add a9 linux mcc_demo driver

- based on sema4 driver, mcc stack, add the mcc_demo driver
by sysfs.
  - mcc pingpong demo
  - mcc can demo
NOTE:
- rdc should be disabled in m4 mqx side, otherwise, a9 linux would
fail to mount rootfs.
- add the m4 related clks at linux side, because that the m4's clks
would be turned off/on during linux boot up if they are not added
at linux clk definitions.

Signed-off-by: Richard Zhu <r65037@freescale.com>

3 files changed, 302 insertions, 0 deletions

diff --git a/drivers/char/imx_mcc/Kconfig b/drivers/char/imx_mcc/Kconfig
index 1f892f8daccb..d60cf66cd8fd 100644
--- a/drivers/char/imx_mcc/Kconfig
+++ b/drivers/char/imx_mcc/Kconfig
@@ -7,3 +7,9 @@ config IMX_SEMA4
         depends on SOC_IMX6SX
         help
           Support for IMX SEMA4 driver, most people should say N here.
+
+config IMX_MCC_DEMO
+        bool "IMX MCC demo driver"
+        depends on SOC_IMX6SX && IMX_SEMA4
+        help
+          Support for IMX MCC DEMO, most people should say N here.
diff --git a/drivers/char/imx_mcc/Makefile b/drivers/char/imx_mcc/Makefile
index 4e7a91691b39..a0d60f341d07 100644
--- a/drivers/char/imx_mcc/Makefile
+++ b/drivers/char/imx_mcc/Makefile
@@ -3,3 +3,4 @@
 #
 #
 obj-$(CONFIG_IMX_SEMA4)         += imx_sema4.o
+obj-$(CONFIG_IMX_MCC_DEMO)      += imx_mcc_demo.o
diff --git a/drivers/char/imx_mcc/imx_mcc_demo.c b/drivers/char/imx_mcc/imx_mcc_demo.c
new file mode 100644
index 000000000000..6882d81dee8c
--- /dev/null
+++ b/drivers/char/imx_mcc/imx_mcc_demo.c
@@ -0,0 +1,295 @@
+/*
+ * Copyright (C) 2014 Freescale Semiconductor, Inc. All Rights Reserved.
+ */
+
+/*
+ * 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/delay.h>
+#include <linux/err.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <linux/suspend.h>
+
+#include <linux/imx_sema4.h>
+#include <linux/mcc_common.h>
+#include <linux/mcc_api.h>
+#include <linux/mcc_linux.h>
+#include <linux/mcc_imx6sx.h>
+
+enum {
+        MCC_NODE_A9 = 0,
+        MCC_NODE_M4 = 0,
+
+        MCC_A9_PORT = 1,
+        MCC_M4_PORT = 2,
+};
+
+/* mcc pingpong demo */
+MCC_ENDPOINT mcc_endpoint_a9_pingpong = {0, MCC_NODE_A9, MCC_A9_PORT};
+MCC_ENDPOINT mcc_endpoint_m4_pingpong = {1, MCC_NODE_M4, MCC_M4_PORT};
+/* mcc can demo */
+MCC_ENDPOINT mcc_endpoint_a9_can = {0, MCC_NODE_A9, MCC_A9_PORT};
+
+struct mcc_pp_msg {
+        unsigned int data;
+};
+
+/* Set the max len of the can msg to be 1000 bytes */
+struct mcc_can_msg {
+        char data[MCC_ATTR_BUFFER_SIZE_IN_BYTES - 24];
+};
+
+static ssize_t imx_mcc_can_demo_en(struct device *dev,
+                struct device_attribute *attr,
+                const char *buf, size_t count)
+{
+        u32 can_demo_en;
+        int i = 0, ret = 0;
+        struct mcc_can_msg msg;
+        MCC_MEM_SIZE num_of_received_bytes;
+        MCC_INFO_STRUCT mcc_info;
+
+        sscanf(buf, "%d\n", &can_demo_en);
+
+        if (can_demo_en) {
+                pr_info("imx mcc can communication demo begin.\n");
+                ret = mcc_get_info(MCC_NODE_A9, &mcc_info);
+                if (ret) {
+                        pr_err("failed to get mcc info.\n");
+                        return -EINVAL;
+                }
+
+                ret = mcc_create_endpoint(&mcc_endpoint_a9_can, MCC_A9_PORT);
+                if (ret) {
+                        pr_err("failed to create a9 mcc ep.\n");
+                        return -EINVAL;
+                }
+
+                pr_info("\nA9 mcc prepares run, MCC version is %s\n",
+                                mcc_info.version_string);
+
+                while (i < 0x10000) {
+                        i++;
+                        /*
+                         * wait for the "sleep" msg from the remote ep.
+                         */
+                        ret = mcc_recv_copy(&mcc_endpoint_a9_can, &msg,
+                                        sizeof(struct mcc_can_msg),
+                                        &num_of_received_bytes, 0xffffffff);
+                        pr_info("%s", msg.data);
+                }
+
+                ret = mcc_destroy_endpoint(&mcc_endpoint_a9_can);
+                if (ret) {
+                        pr_err("failed to destory a9 mcc ep.\n");
+                        return -EINVAL;
+                } else {
+                        pr_info("destory a9 mcc ep.\n");
+                }
+        }
+
+        pr_info("imx mcc demo end after %08d times recv tests.\n", i);
+        return count;
+}
+
+static ssize_t imx_mcc_pingpong_en(struct device *dev,
+                struct device_attribute *attr, const char *buf, size_t count)
+{
+        u32 pingpong_en;
+        int i = 0, ret = 0;
+        struct timeval tv1, tv2, tv3;
+        u32 tv_count1 = 0, tv_count2 = 0;
+        struct mcc_pp_msg msg;
+        MCC_MEM_SIZE num_of_received_bytes;
+        MCC_INFO_STRUCT mcc_info;
+
+        sscanf(buf, "%d\n", &pingpong_en);
+        if (pingpong_en) {
+                pr_info("imx mcc pingpong demo begin.\n");
+                ret = mcc_get_info(MCC_NODE_A9, &mcc_info);
+                if (ret) {
+                        pr_err("failed to get mcc info.\n");
+                        return -EINVAL;
+                }
+
+                ret = mcc_create_endpoint(&mcc_endpoint_a9_pingpong,
+                                MCC_A9_PORT);
+                if (ret) {
+                        pr_err("failed to create a9 mcc ep.\n");
+                        return -EINVAL;
+                }
+
+                pr_info("\nA9 mcc prepares run, MCC version is %s\n",
+                                mcc_info.version_string);
+                msg.data = 1;
+                while (i < 0x50000) {
+                        i++;
+                        i++;
+                        /*
+                         * wait until the remote endpoint is created by
+                         * the other core
+                         */
+                        if (pingpong_en > 1)
+                                do_gettimeofday(&tv1);
+
+                        ret = mcc_send(&mcc_endpoint_m4_pingpong, &msg,
+                                        sizeof(struct mcc_pp_msg),
+                                        0xffffffff);
+
+                        if (pingpong_en > 1) {
+                                do_gettimeofday(&tv2);
+                                tv_count1 = (tv2.tv_sec - tv1.tv_sec)
+                                        * USEC_PER_SEC
+                                        + tv2.tv_usec - tv1.tv_usec;
+                        }
+                        while (MCC_ERR_ENDPOINT == ret) {
+                                pr_err("\n send err ret %d, re-send\n", ret);
+                                ret = mcc_send(&mcc_endpoint_m4_pingpong, &msg,
+                                                sizeof(struct mcc_pp_msg),
+                                                0xffffffff);
+                                msleep(5000);
+                        }
+
+                        if (pingpong_en > 1)
+                                do_gettimeofday(&tv2);
+
+                        ret = mcc_recv_copy(&mcc_endpoint_a9_pingpong, &msg,
+                                        sizeof(struct mcc_pp_msg),
+                                        &num_of_received_bytes, 0xffffffff);
+
+                        if (pingpong_en > 1) {
+                                do_gettimeofday(&tv3);
+                                tv_count2 = (tv3.tv_sec - tv2.tv_sec)
+                                        * USEC_PER_SEC
+                                        + tv3.tv_usec - tv2.tv_usec;
+                                pr_info("imx mcc: Data transfer speed tests"
+                                                "in pingpong. a9 -> m4:%08dus."
+                                                "a9 <- m4:%08dus.\n",
+                                                tv_count1, tv_count2);
+                        }
+
+                        if (MCC_SUCCESS != ret) {
+                                pr_err("A9 Main task receive error: %d\n", ret);
+                        } else {
+                                pr_info("%08x Main task received a msg\n", i);
+                                pr_info("Message: Size=0x%08x, data = 0x%08x\n",
+                                        num_of_received_bytes, msg.data);
+                                msg.data++;
+                        }
+                }
+                ret = mcc_destroy_endpoint(&mcc_endpoint_a9_pingpong);
+                if (ret) {
+                        pr_err("failed to destory a9 mcc ep.\n");
+                        return ret;
+                } else {
+                        pr_info("destory a9 mcc ep.\n");
+                }
+                pr_info("imx mcc demo end after %08d times tests.\n", i/2);
+        }
+
+        if (ret)
+                return ret;
+        else
+                return count;
+}
+
+static DEVICE_ATTR(pingpong_en, S_IWUGO, NULL, imx_mcc_pingpong_en);
+static DEVICE_ATTR(can_demo_en, S_IWUGO, NULL, imx_mcc_can_demo_en);
+
+static struct attribute *imx_mcc_attrs[] = {
+        &dev_attr_pingpong_en.attr,
+        &dev_attr_can_demo_en.attr,
+        NULL
+};
+
+static struct attribute_group imx_mcc_attrgroup = {
+        .attrs  = imx_mcc_attrs,
+};
+
+static int imx_mcc_demo_probe(struct platform_device *pdev)
+{
+        int ret = 0;
+        MCC_INFO_STRUCT mcc_info;
+
+        ret = mcc_initialize(MCC_NODE_A9);
+        if (ret) {
+                pr_err("failed to initialize mcc.\n");
+                ret = -EINVAL;
+                return ret;
+        }
+
+        ret = mcc_get_info(MCC_NODE_A9, &mcc_info);
+        if (ret) {
+                pr_err("failed to get mcc info.\n");
+                ret = -EINVAL;
+                goto out_node;
+        }
+        pr_info("\nA9 mcc prepares run, MCC version is %s\n",
+                        mcc_info.version_string);
+
+        if (strcmp(mcc_info.version_string, MCC_VERSION_STRING) != 0) {
+                pr_err("\nError, different versions of the MCC library");
+                pr_err("is used on each core!\n");
+                pr_err("\nApplication is stopped now.\n");
+                ret = -EINVAL;
+                goto out_node;
+        }
+
+        /* add attributes for device. */
+        ret = sysfs_create_group(&pdev->dev.kobj, &imx_mcc_attrgroup);
+        if (ret)
+                goto out_node;
+
+        return ret;
+
+out_node:
+        mcc_destroy(MCC_NODE_A9);
+
+        return ret;
+}
+
+static int imx_mcc_demo_remove(struct platform_device *pdev)
+{
+        return 0;
+}
+
+static const struct of_device_id imx_mcc_demo_dt_ids[] = {
+        { .compatible = "fsl,imx6sx-mcc-demo", },
+        { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, imx_mcc_demo_dt_ids);
+
+static struct platform_driver imx_mcc_demo_driver = {
+        .driver = {
+                   .owner = THIS_MODULE,
+                   .name = "imx6sx-mcc-demo",
+                   .of_match_table = imx_mcc_demo_dt_ids,
+                   },
+        .probe = imx_mcc_demo_probe,
+        .remove = imx_mcc_demo_remove,
+};
+
+static int __init imx_mcc_demo_init(void)
+{
+        int ret;
+
+        ret = platform_driver_register(&imx_mcc_demo_driver);
+        if (ret)
+                pr_err("failed to register imx mcc demo driver.\n");
+        else
+                pr_info("imx mcc demo is registered.\n");
+        return ret;
+}
+late_initcall(imx_mcc_demo_init);
+
+MODULE_AUTHOR("Freescale Semiconductor, Inc.");
+MODULE_DESCRIPTION("IMX MCC demo driver");
+MODULE_LICENSE("GPL");