1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) 2021 STMicroelectronics - All Rights Reserved 4 * 5 * The rpmsg tty driver implements serial communication on the RPMsg bus to makes 6 * possible for user-space programs to send and receive rpmsg messages as a standard 7 * tty protocol. 8 * 9 * The remote processor can instantiate a new tty by requesting a "rpmsg-tty" RPMsg service. 10 * The "rpmsg-tty" service is directly used for data exchange. No flow control is implemented yet. 11 */ 12 13 #include <linux/module.h> 14 #include <linux/rpmsg.h> 15 #include <linux/slab.h> 16 #include <linux/tty.h> 17 #include <linux/tty_flip.h> 18 19 #define MAX_TTY_RPMSG 32 20 21 static DEFINE_IDR(tty_idr); /* tty instance id */ 22 static DEFINE_MUTEX(idr_lock); /* protects tty_idr */ 23 24 static struct tty_driver *rpmsg_tty_driver; 25 26 struct rpmsg_tty_port { 27 struct tty_port port; /* TTY port data */ 28 int id; /* TTY rpmsg index */ 29 struct rpmsg_device *rpdev; /* rpmsg device */ 30 }; 31 32 static int rpmsg_tty_cb(struct rpmsg_device *rpdev, void *data, int len, void *priv, u32 src) 33 { 34 struct rpmsg_tty_port *cport = dev_get_drvdata(&rpdev->dev); 35 int copied; 36 37 if (!len) 38 return -EINVAL; 39 copied = tty_insert_flip_string(&cport->port, data, len); 40 if (copied != len) 41 dev_err_ratelimited(&rpdev->dev, "Trunc buffer: available space is %d\n", copied); 42 tty_flip_buffer_push(&cport->port); 43 44 return 0; 45 } 46 47 static int rpmsg_tty_install(struct tty_driver *driver, struct tty_struct *tty) 48 { 49 struct rpmsg_tty_port *cport = idr_find(&tty_idr, tty->index); 50 51 tty->driver_data = cport; 52 53 return tty_port_install(&cport->port, driver, tty); 54 } 55 56 static int rpmsg_tty_open(struct tty_struct *tty, struct file *filp) 57 { 58 return tty_port_open(tty->port, tty, filp); 59 } 60 61 static void rpmsg_tty_close(struct tty_struct *tty, struct file *filp) 62 { 63 return tty_port_close(tty->port, tty, filp); 64 } 65 66 static int rpmsg_tty_write(struct tty_struct *tty, const u8 *buf, int len) 67 { 68 struct rpmsg_tty_port *cport = tty->driver_data; 69 struct rpmsg_device *rpdev; 70 int msg_max_size, msg_size; 71 int ret; 72 73 rpdev = cport->rpdev; 74 75 msg_max_size = rpmsg_get_mtu(rpdev->ept); 76 if (msg_max_size < 0) 77 return msg_max_size; 78 79 msg_size = min(len, msg_max_size); 80 81 /* 82 * Use rpmsg_trysend instead of rpmsg_send to send the message so the caller is not 83 * hung until a rpmsg buffer is available. In such case rpmsg_trysend returns -ENOMEM. 84 */ 85 ret = rpmsg_trysend(rpdev->ept, (void *)buf, msg_size); 86 if (ret) { 87 dev_dbg_ratelimited(&rpdev->dev, "rpmsg_send failed: %d\n", ret); 88 return ret; 89 } 90 91 return msg_size; 92 } 93 94 static unsigned int rpmsg_tty_write_room(struct tty_struct *tty) 95 { 96 struct rpmsg_tty_port *cport = tty->driver_data; 97 int size; 98 99 size = rpmsg_get_mtu(cport->rpdev->ept); 100 if (size < 0) 101 return 0; 102 103 return size; 104 } 105 106 static const struct tty_operations rpmsg_tty_ops = { 107 .install = rpmsg_tty_install, 108 .open = rpmsg_tty_open, 109 .close = rpmsg_tty_close, 110 .write = rpmsg_tty_write, 111 .write_room = rpmsg_tty_write_room, 112 }; 113 114 static struct rpmsg_tty_port *rpmsg_tty_alloc_cport(void) 115 { 116 struct rpmsg_tty_port *cport; 117 int ret; 118 119 cport = kzalloc(sizeof(*cport), GFP_KERNEL); 120 if (!cport) 121 return ERR_PTR(-ENOMEM); 122 123 mutex_lock(&idr_lock); 124 ret = idr_alloc(&tty_idr, cport, 0, MAX_TTY_RPMSG, GFP_KERNEL); 125 mutex_unlock(&idr_lock); 126 127 if (ret < 0) { 128 kfree(cport); 129 return ERR_PTR(ret); 130 } 131 132 cport->id = ret; 133 134 return cport; 135 } 136 137 static void rpmsg_tty_release_cport(struct rpmsg_tty_port *cport) 138 { 139 mutex_lock(&idr_lock); 140 idr_remove(&tty_idr, cport->id); 141 mutex_unlock(&idr_lock); 142 143 kfree(cport); 144 } 145 146 static const struct tty_port_operations rpmsg_tty_port_ops = { }; 147 148 static int rpmsg_tty_probe(struct rpmsg_device *rpdev) 149 { 150 struct rpmsg_tty_port *cport; 151 struct device *dev = &rpdev->dev; 152 struct device *tty_dev; 153 int ret; 154 155 cport = rpmsg_tty_alloc_cport(); 156 if (IS_ERR(cport)) 157 return dev_err_probe(dev, PTR_ERR(cport), "Failed to alloc tty port\n"); 158 159 tty_port_init(&cport->port); 160 cport->port.ops = &rpmsg_tty_port_ops; 161 162 tty_dev = tty_port_register_device(&cport->port, rpmsg_tty_driver, 163 cport->id, dev); 164 if (IS_ERR(tty_dev)) { 165 ret = dev_err_probe(dev, PTR_ERR(tty_dev), "Failed to register tty port\n"); 166 goto err_destroy; 167 } 168 169 cport->rpdev = rpdev; 170 171 dev_set_drvdata(dev, cport); 172 173 dev_dbg(dev, "New channel: 0x%x -> 0x%x : ttyRPMSG%d\n", 174 rpdev->src, rpdev->dst, cport->id); 175 176 return 0; 177 178 err_destroy: 179 tty_port_destroy(&cport->port); 180 rpmsg_tty_release_cport(cport); 181 182 return ret; 183 } 184 185 static void rpmsg_tty_remove(struct rpmsg_device *rpdev) 186 { 187 struct rpmsg_tty_port *cport = dev_get_drvdata(&rpdev->dev); 188 189 dev_dbg(&rpdev->dev, "Removing rpmsg tty device %d\n", cport->id); 190 191 /* User hang up to release the tty */ 192 if (tty_port_initialized(&cport->port)) 193 tty_port_tty_hangup(&cport->port, false); 194 195 tty_unregister_device(rpmsg_tty_driver, cport->id); 196 197 tty_port_destroy(&cport->port); 198 rpmsg_tty_release_cport(cport); 199 } 200 201 static struct rpmsg_device_id rpmsg_driver_tty_id_table[] = { 202 { .name = "rpmsg-tty" }, 203 { }, 204 }; 205 MODULE_DEVICE_TABLE(rpmsg, rpmsg_driver_tty_id_table); 206 207 static struct rpmsg_driver rpmsg_tty_rpmsg_drv = { 208 .drv.name = KBUILD_MODNAME, 209 .id_table = rpmsg_driver_tty_id_table, 210 .probe = rpmsg_tty_probe, 211 .callback = rpmsg_tty_cb, 212 .remove = rpmsg_tty_remove, 213 }; 214 215 static int __init rpmsg_tty_init(void) 216 { 217 int ret; 218 219 rpmsg_tty_driver = tty_alloc_driver(MAX_TTY_RPMSG, TTY_DRIVER_REAL_RAW | 220 TTY_DRIVER_DYNAMIC_DEV); 221 if (IS_ERR(rpmsg_tty_driver)) 222 return PTR_ERR(rpmsg_tty_driver); 223 224 rpmsg_tty_driver->driver_name = "rpmsg_tty"; 225 rpmsg_tty_driver->name = "ttyRPMSG"; 226 rpmsg_tty_driver->major = 0; 227 rpmsg_tty_driver->type = TTY_DRIVER_TYPE_CONSOLE; 228 229 /* Disable unused mode by default */ 230 rpmsg_tty_driver->init_termios = tty_std_termios; 231 rpmsg_tty_driver->init_termios.c_lflag &= ~(ECHO | ICANON); 232 rpmsg_tty_driver->init_termios.c_oflag &= ~(OPOST | ONLCR); 233 234 tty_set_operations(rpmsg_tty_driver, &rpmsg_tty_ops); 235 236 ret = tty_register_driver(rpmsg_tty_driver); 237 if (ret < 0) { 238 pr_err("Couldn't install rpmsg tty driver: %d\n", ret); 239 goto error_put; 240 } 241 242 ret = register_rpmsg_driver(&rpmsg_tty_rpmsg_drv); 243 if (ret < 0) { 244 pr_err("Couldn't register rpmsg tty driver: %d\n", ret); 245 goto error_unregister; 246 } 247 248 return 0; 249 250 error_unregister: 251 tty_unregister_driver(rpmsg_tty_driver); 252 253 error_put: 254 tty_driver_kref_put(rpmsg_tty_driver); 255 256 return ret; 257 } 258 259 static void __exit rpmsg_tty_exit(void) 260 { 261 unregister_rpmsg_driver(&rpmsg_tty_rpmsg_drv); 262 tty_unregister_driver(rpmsg_tty_driver); 263 tty_driver_kref_put(rpmsg_tty_driver); 264 idr_destroy(&tty_idr); 265 } 266 267 module_init(rpmsg_tty_init); 268 module_exit(rpmsg_tty_exit); 269 270 MODULE_AUTHOR("Arnaud Pouliquen <arnaud.pouliquen@foss.st.com>"); 271 MODULE_DESCRIPTION("remote processor messaging tty driver"); 272 MODULE_LICENSE("GPL v2"); 273