ENGR00320327 mcc: mcc posix pty interface demo driver

- /dev/ttyMCCp0 can be created.
- use schedule delayed work to kick off the demo
- one simple test app(mxc_mcc_tty_test.out) used to do
the mcc pty interface demo tests.
  - m4 part of the mcc pingpong demo is required to be run
  on m4.
  - up to now, only the unsigned int decimal number is used
  in the tests.

test how-to by the simple test app:

./mxc_mcc_tty_test.out /dev/ttyMCCp0 115200 R 1 512 &
echo <your input> > /dev/ttyMCCp0

then
<your input + 1> would be received the test app.

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

3 files changed, 262 insertions, 0 deletions

diff --git a/drivers/char/imx_mcc/Kconfig b/drivers/char/imx_mcc/Kconfig
index d60cf66cd8fd..9625efa2df7f 100644
--- a/drivers/char/imx_mcc/Kconfig
+++ b/drivers/char/imx_mcc/Kconfig
@@ -13,3 +13,11 @@ config IMX_MCC_DEMO
         depends on SOC_IMX6SX && IMX_SEMA4
         help
           Support for IMX MCC DEMO, most people should say N here.
+
+config IMX_MCC_TTY
+        bool "imx pty for mcc interface"
+        depends on SOC_IMX6SX && IMX_SEMA4
+        help
+          This enables a pty node for imx6sx mcc interface.
+
+#end imx mcc
diff --git a/drivers/char/imx_mcc/Makefile b/drivers/char/imx_mcc/Makefile
index a0d60f341d07..f5bda928e23c 100644
--- a/drivers/char/imx_mcc/Makefile
+++ b/drivers/char/imx_mcc/Makefile
@@ -4,3 +4,4 @@
 #
 obj-$(CONFIG_IMX_SEMA4)         += imx_sema4.o
 obj-$(CONFIG_IMX_MCC_DEMO)      += imx_mcc_demo.o
+obj-$(CONFIG_IMX_MCC_TTY)       += imx_mcc_tty.o
diff --git a/drivers/char/imx_mcc/imx_mcc_tty.c b/drivers/char/imx_mcc/imx_mcc_tty.c
new file mode 100644
index 000000000000..843b5fcbd010
--- /dev/null
+++ b/drivers/char/imx_mcc/imx_mcc_tty.c
@@ -0,0 +1,253 @@
+/*
+ * imx_mcc_tty.c - pty demo driver used to test imx mcc
+ * posix pty interface.
+ *
+ * Copyright (C) 2014 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/delay.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/tty.h>
+#include <linux/tty_driver.h>
+#include <linux/tty_flip.h>
+#include <linux/mcc_common.h>
+#include <linux/mcc_api.h>
+
+/**
+ * struct mcctty_port - Wrapper struct for imx mcc pty port.
+ * @port:               TTY port data
+ * @rx_lock:            Lock for rx_buf.
+ * @rx_buf:             Read buffer
+ */
+struct mcctty_port {
+        struct delayed_work     read;
+        struct tty_port         port;
+        spinlock_t              rx_lock;
+        char                    *rx_buf;
+};
+
+static struct mcctty_port mcc_tty_port;
+
+enum {
+        MCC_NODE_A9 = 0,
+        MCC_NODE_M4 = 0,
+
+        MCC_A9_PORT = 1,
+        MCC_M4_PORT = 2,
+};
+
+/* mcc tty/pingpong demo */
+static MCC_ENDPOINT mcc_endpoint_a9_pingpong = {0, MCC_NODE_A9, MCC_A9_PORT};
+static MCC_ENDPOINT mcc_endpoint_m4_pingpong = {1, MCC_NODE_M4, MCC_M4_PORT};
+struct mcc_pp_msg {
+        unsigned int data;
+};
+
+static void mcctty_delay_work(struct work_struct *work)
+{
+        struct mcctty_port *cport = &mcc_tty_port;
+        int ret, space;
+        unsigned char *cbuf;
+        struct mcc_pp_msg pp_msg;
+        MCC_MEM_SIZE num_of_received_bytes;
+        MCC_INFO_STRUCT mcc_info;
+
+        /* start mcc tty recv here */
+        ret = mcc_initialize(MCC_NODE_A9);
+        if (ret)
+                pr_err("failed to initialize mcc.\n");
+
+        ret = mcc_get_info(MCC_NODE_A9, &mcc_info);
+        if (ret)
+                pr_err("failed to get mcc info.\n");
+        pr_info("\nA9 mcc prepares run, MCC version is %s\n",
+                        mcc_info.version_string);
+
+        pr_info("imx mcc tty/pingpong demo begin.\n");
+        ret = mcc_create_endpoint(&mcc_endpoint_a9_pingpong,
+                        MCC_A9_PORT);
+        if (ret)
+                pr_err("failed to create a9 mcc ep.\n");
+
+        while (1) {
+                ret = mcc_recv_copy(&mcc_endpoint_a9_pingpong, &pp_msg,
+                                sizeof(struct mcc_pp_msg),
+                                &num_of_received_bytes, 0xffffffff);
+
+                if (MCC_SUCCESS != ret) {
+                        pr_err("A9 Main task receive error: %d\n", ret);
+                } else {
+                        /* flush the recv-ed data to tty node */
+                        spin_lock_bh(&cport->rx_lock);
+                        space = tty_prepare_flip_string(&cport->port, &cbuf,
+                                                        num_of_received_bytes);
+                        if ((space <= 0) || (cport->rx_buf == NULL))
+                                goto pp_unlock;
+
+                        memcpy(cport->rx_buf, &pp_msg.data,
+                                        num_of_received_bytes);
+                        memcpy(cbuf, cport->rx_buf, space);
+                        tty_flip_buffer_push(&cport->port);
+pp_unlock:
+                        spin_unlock_bh(&cport->rx_lock);
+                }
+        }
+}
+
+static struct tty_port_operations  mcctty_port_ops = { };
+
+static int mcctty_install(struct tty_driver *driver, struct tty_struct *tty)
+{
+        return tty_port_install(&mcc_tty_port.port, driver, tty);
+}
+
+static int mcctty_open(struct tty_struct *tty, struct file *filp)
+{
+        return tty_port_open(tty->port, tty, filp);
+}
+
+static void mcctty_close(struct tty_struct *tty, struct file *filp)
+{
+        return tty_port_close(tty->port, tty, filp);
+}
+
+static int mcctty_write(struct tty_struct *tty, const unsigned char *buf,
+                         int total)
+{
+        int i, ret = 0;
+        struct mcc_pp_msg pp_msg;
+
+        if (NULL == buf)
+                return 0;
+
+        for (i = 0; i < total; i++) {
+                pp_msg.data = (unsigned int)buf[i];
+
+                /*
+                 * wait until the remote endpoint is created by
+                 * the other core
+                 */
+                ret = mcc_send(&mcc_endpoint_m4_pingpong, &pp_msg,
+                                sizeof(struct mcc_pp_msg),
+                                0xffffffff);
+
+                while (MCC_ERR_ENDPOINT == ret) {
+                        pr_err("\n send err ret %d, re-send\n", ret);
+                        ret = mcc_send(&mcc_endpoint_m4_pingpong, &pp_msg,
+                                        sizeof(struct mcc_pp_msg),
+                                        0xffffffff);
+                        msleep(5000);
+                }
+        }
+
+        return total;
+}
+
+static int mcctty_write_room(struct tty_struct *tty)
+{
+        int room;
+
+        /* report the space in the mcc buffer */
+        room = MCC_ATTR_BUFFER_SIZE_IN_BYTES;
+
+        return room;
+}
+
+static const struct tty_operations imxmcctty_ops = {
+        .install                = mcctty_install,
+        .open                   = mcctty_open,
+        .close                  = mcctty_close,
+        .write                  = mcctty_write,
+        .write_room             = mcctty_write_room,
+};
+
+static struct tty_driver *mcctty_driver;
+
+static int __init imxmcctty_init(void)
+{
+        int ret;
+        struct mcctty_port *cport = &mcc_tty_port;
+
+        mcctty_driver = tty_alloc_driver(1,
+                        TTY_DRIVER_RESET_TERMIOS |
+                        TTY_DRIVER_UNNUMBERED_NODE);
+        if (IS_ERR(mcctty_driver))
+                return PTR_ERR(mcctty_driver);
+
+        mcctty_driver->driver_name = "mcc_tty";
+        mcctty_driver->name = "ttyMCC";
+        mcctty_driver->major = TTYAUX_MAJOR;
+        mcctty_driver->minor_start = 3;
+        mcctty_driver->type = TTY_DRIVER_TYPE_PTY;
+        mcctty_driver->init_termios = tty_std_termios;
+        mcctty_driver->init_termios.c_cflag |= CLOCAL;
+
+        tty_set_operations(mcctty_driver, &imxmcctty_ops);
+
+        tty_port_init(&cport->port);
+        cport->port.ops = &mcctty_port_ops;
+        spin_lock_init(&cport->rx_lock);
+        spin_lock_init(&cport->tx_lock);
+
+        ret = tty_register_driver(mcctty_driver);
+        if (ret < 0) {
+                pr_err("Couldn't install mcc tty driver: err %d\n", ret);
+                goto error;
+        } else
+                pr_info("Install mcc tty driver!\n");
+
+        /* Allocate the buffer we use for reading data */
+        cport->rx_buf = kzalloc(MCC_ATTR_BUFFER_SIZE_IN_BYTES,
+                        GFP_KERNEL);
+        if (!cport->rx_buf) {
+                ret = -ENOMEM;
+                goto error;
+        }
+
+        INIT_DELAYED_WORK(&cport->read, mcctty_delay_work);
+        schedule_delayed_work(&cport->read, HZ/100);
+        return 0;
+
+error:
+        tty_unregister_driver(mcctty_driver);
+        put_tty_driver(mcctty_driver);
+        tty_port_destroy(&cport->port);
+        mcctty_driver = NULL;
+
+        return ret;
+}
+
+static void imxmcctty_exit(void)
+{
+        int ret = 0;
+        struct mcctty_port *cport = &mcc_tty_port;
+
+        /* stop reading, null the read buffer. */
+        kfree(cport->rx_buf);
+        cport->rx_buf = NULL;
+
+        /* destory the mcc tty endpoint here */
+        ret = mcc_destroy_endpoint(&mcc_endpoint_a9_pingpong);
+        if (ret)
+                pr_err("failed to destory a9 mcc ep.\n");
+        else
+                pr_info("destory a9 mcc ep.\n");
+
+        tty_unregister_driver(mcctty_driver);
+        tty_port_destroy(&cport->port);
+        put_tty_driver(mcctty_driver);
+}
+
+module_init(imxmcctty_init);
+module_exit(imxmcctty_exit);