blob: 14904c7d517ed2dde8b60abc5d3f3d83e97dde2c [file] [log] [blame]
/*
* Copyright (C) 2015 Freescale Semiconductor, Inc.
*
* derived from the omap-rpmsg implementation.
* Remote processor messaging transport - tty 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/delay.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/rpmsg.h>
#include <linux/tty.h>
#include <linux/tty_driver.h>
#include <linux/tty_flip.h>
#include <linux/virtio.h>
/*
* struct rpmsgtty_port - Wrapper struct for imx rpmsg tty port.
* @port: TTY port data
*/
struct rpmsgtty_port {
struct tty_port port;
spinlock_t rx_lock;
struct rpmsg_channel *rpdev;
};
static struct rpmsgtty_port rpmsg_tty_port;
#define RPMSG_MAX_SIZE (512 - sizeof(struct rpmsg_hdr))
#define MSG "hello world!"
static void rpmsg_tty_cb(struct rpmsg_channel *rpdev, void *data, int len,
void *priv, u32 src)
{
int space;
unsigned char *cbuf;
struct rpmsgtty_port *cport = &rpmsg_tty_port;
/* flush the recv-ed none-zero data to tty node */
if (len == 0)
return;
dev_dbg(&rpdev->dev, "msg(<- src 0x%x) len %d\n", src, len);
print_hex_dump(KERN_DEBUG, __func__, DUMP_PREFIX_NONE, 16, 1,
data, len, true);
spin_lock_bh(&cport->rx_lock);
space = tty_prepare_flip_string(&cport->port, &cbuf, len);
if (space <= 0) {
dev_err(&rpdev->dev, "No memory for tty_prepare_flip_string\n");
spin_unlock_bh(&cport->rx_lock);
return;
}
memcpy(cbuf, data, len);
tty_flip_buffer_push(&cport->port);
spin_unlock_bh(&cport->rx_lock);
}
static struct tty_port_operations rpmsgtty_port_ops = { };
static int rpmsgtty_install(struct tty_driver *driver, struct tty_struct *tty)
{
return tty_port_install(&rpmsg_tty_port.port, driver, tty);
}
static int rpmsgtty_open(struct tty_struct *tty, struct file *filp)
{
return tty_port_open(tty->port, tty, filp);
}
static void rpmsgtty_close(struct tty_struct *tty, struct file *filp)
{
return tty_port_close(tty->port, tty, filp);
}
static int rpmsgtty_write(struct tty_struct *tty, const unsigned char *buf,
int total)
{
int count, ret = 0;
const unsigned char *tbuf;
struct rpmsgtty_port *rptty_port = container_of(tty->port,
struct rpmsgtty_port, port);
struct rpmsg_channel *rpdev = rptty_port->rpdev;
if (NULL == buf) {
pr_err("buf shouldn't be null.\n");
return -ENOMEM;
}
count = total;
tbuf = buf;
do {
/* send a message to our remote processor */
ret = rpmsg_send(rpdev, (void *)tbuf,
count > RPMSG_MAX_SIZE ? RPMSG_MAX_SIZE : count);
if (ret) {
dev_err(&rpdev->dev, "rpmsg_send failed: %d\n", ret);
return ret;
}
if (count > RPMSG_MAX_SIZE) {
count -= RPMSG_MAX_SIZE;
tbuf += RPMSG_MAX_SIZE;
} else {
count = 0;
}
} while (count > 0);
return total;
}
static int rpmsgtty_write_room(struct tty_struct *tty)
{
/* report the space in the rpmsg buffer */
return RPMSG_MAX_SIZE;
}
static const struct tty_operations imxrpmsgtty_ops = {
.install = rpmsgtty_install,
.open = rpmsgtty_open,
.close = rpmsgtty_close,
.write = rpmsgtty_write,
.write_room = rpmsgtty_write_room,
};
static struct tty_driver *rpmsgtty_driver;
static int rpmsg_tty_probe(struct rpmsg_channel *rpdev)
{
int err;
struct rpmsgtty_port *cport = &rpmsg_tty_port;
dev_info(&rpdev->dev, "new channel: 0x%x -> 0x%x!\n",
rpdev->src, rpdev->dst);
/*
* send a message to our remote processor, and tell remote
* processor about this channel
*/
err = rpmsg_send(rpdev, MSG, strlen(MSG));
if (err) {
dev_err(&rpdev->dev, "rpmsg_send failed: %d\n", err);
return err;
}
rpmsgtty_driver = tty_alloc_driver(1, TTY_DRIVER_UNNUMBERED_NODE);
if (IS_ERR(rpmsgtty_driver))
return PTR_ERR(rpmsgtty_driver);
rpmsgtty_driver->driver_name = "rpmsg_tty";
rpmsgtty_driver->name = "ttyRPMSG";
rpmsgtty_driver->major = TTYAUX_MAJOR;
rpmsgtty_driver->minor_start = 3;
rpmsgtty_driver->type = TTY_DRIVER_TYPE_CONSOLE;
rpmsgtty_driver->init_termios = tty_std_termios;
tty_set_operations(rpmsgtty_driver, &imxrpmsgtty_ops);
tty_port_init(&cport->port);
cport->port.ops = &rpmsgtty_port_ops;
spin_lock_init(&cport->rx_lock);
cport->port.low_latency = cport->port.flags | ASYNC_LOW_LATENCY;
err = tty_register_driver(rpmsgtty_driver);
if (err < 0) {
pr_err("Couldn't install rpmsg tty driver: err %d\n", err);
goto error;
} else
pr_info("Install rpmsg tty driver!\n");
cport->rpdev = rpdev;
return 0;
error:
tty_unregister_driver(rpmsgtty_driver);
put_tty_driver(rpmsgtty_driver);
tty_port_destroy(&cport->port);
rpmsgtty_driver = NULL;
return err;
}
static void rpmsg_tty_remove(struct rpmsg_channel *rpdev)
{
struct rpmsgtty_port *cport = &rpmsg_tty_port;
dev_info(&rpdev->dev, "rpmsg tty driver is removed\n");
tty_unregister_driver(rpmsgtty_driver);
put_tty_driver(rpmsgtty_driver);
tty_port_destroy(&cport->port);
rpmsgtty_driver = NULL;
}
static struct rpmsg_device_id rpmsg_driver_tty_id_table[] = {
{ .name = "rpmsg-openamp-demo-channel" },
{ },
};
MODULE_DEVICE_TABLE(rpmsg, rpmsg_driver_tty_id_table);
static struct rpmsg_driver rpmsg_tty_driver = {
.drv.name = KBUILD_MODNAME,
.drv.owner = THIS_MODULE,
.id_table = rpmsg_driver_tty_id_table,
.probe = rpmsg_tty_probe,
.callback = rpmsg_tty_cb,
.remove = rpmsg_tty_remove,
};
static int __init init(void)
{
return register_rpmsg_driver(&rpmsg_tty_driver);
}
static void __exit fini(void)
{
unregister_rpmsg_driver(&rpmsg_tty_driver);
}
module_init(init);
module_exit(fini);
MODULE_AUTHOR("Freescale Semiconductor, Inc.");
MODULE_DESCRIPTION("iMX virtio remote processor messaging tty driver");
MODULE_LICENSE("GPL v2");