1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved. 4 */ 5 6 #include <linux/console.h> 7 #include <linux/mailbox_client.h> 8 #include <linux/module.h> 9 #include <linux/of.h> 10 #include <linux/platform_device.h> 11 #include <linux/serial.h> 12 #include <linux/serial_core.h> 13 #include <linux/slab.h> 14 #include <linux/tty.h> 15 #include <linux/tty_flip.h> 16 17 #define TCU_MBOX_BYTE(i, x) ((x) << (i * 8)) 18 #define TCU_MBOX_BYTE_V(x, i) (((x) >> (i * 8)) & 0xff) 19 #define TCU_MBOX_NUM_BYTES(x) ((x) << 24) 20 #define TCU_MBOX_NUM_BYTES_V(x) (((x) >> 24) & 0x3) 21 22 struct tegra_tcu { 23 struct uart_driver driver; 24 #if IS_ENABLED(CONFIG_SERIAL_TEGRA_TCU_CONSOLE) 25 struct console console; 26 #endif 27 struct uart_port port; 28 29 struct mbox_client tx_client, rx_client; 30 struct mbox_chan *tx, *rx; 31 }; 32 33 static unsigned int tegra_tcu_uart_tx_empty(struct uart_port *port) 34 { 35 return TIOCSER_TEMT; 36 } 37 38 static void tegra_tcu_uart_set_mctrl(struct uart_port *port, unsigned int mctrl) 39 { 40 } 41 42 static unsigned int tegra_tcu_uart_get_mctrl(struct uart_port *port) 43 { 44 return 0; 45 } 46 47 static void tegra_tcu_uart_stop_tx(struct uart_port *port) 48 { 49 } 50 51 static void tegra_tcu_write_one(struct tegra_tcu *tcu, u32 value, 52 unsigned int count) 53 { 54 void *msg; 55 56 value |= TCU_MBOX_NUM_BYTES(count); 57 msg = (void *)(unsigned long)value; 58 mbox_send_message(tcu->tx, msg); 59 mbox_flush(tcu->tx, 1000); 60 } 61 62 static void tegra_tcu_write(struct tegra_tcu *tcu, const char *s, 63 unsigned int count) 64 { 65 unsigned int written = 0, i = 0; 66 bool insert_nl = false; 67 u32 value = 0; 68 69 while (i < count) { 70 if (insert_nl) { 71 value |= TCU_MBOX_BYTE(written++, '\n'); 72 insert_nl = false; 73 i++; 74 } else if (s[i] == '\n') { 75 value |= TCU_MBOX_BYTE(written++, '\r'); 76 insert_nl = true; 77 } else { 78 value |= TCU_MBOX_BYTE(written++, s[i++]); 79 } 80 81 if (written == 3) { 82 tegra_tcu_write_one(tcu, value, 3); 83 value = written = 0; 84 } 85 } 86 87 if (written) 88 tegra_tcu_write_one(tcu, value, written); 89 } 90 91 static void tegra_tcu_uart_start_tx(struct uart_port *port) 92 { 93 struct tegra_tcu *tcu = port->private_data; 94 struct tty_port *tport = &port->state->port; 95 unsigned char *tail; 96 unsigned int count; 97 98 for (;;) { 99 count = kfifo_out_linear_ptr(&tport->xmit_fifo, &tail, 100 UART_XMIT_SIZE); 101 if (!count) 102 break; 103 104 tegra_tcu_write(tcu, tail, count); 105 uart_xmit_advance(port, count); 106 } 107 108 uart_write_wakeup(port); 109 } 110 111 static void tegra_tcu_uart_stop_rx(struct uart_port *port) 112 { 113 } 114 115 static void tegra_tcu_uart_break_ctl(struct uart_port *port, int ctl) 116 { 117 } 118 119 static int tegra_tcu_uart_startup(struct uart_port *port) 120 { 121 return 0; 122 } 123 124 static void tegra_tcu_uart_shutdown(struct uart_port *port) 125 { 126 } 127 128 static void tegra_tcu_uart_set_termios(struct uart_port *port, 129 struct ktermios *new, 130 const struct ktermios *old) 131 { 132 } 133 134 static const struct uart_ops tegra_tcu_uart_ops = { 135 .tx_empty = tegra_tcu_uart_tx_empty, 136 .set_mctrl = tegra_tcu_uart_set_mctrl, 137 .get_mctrl = tegra_tcu_uart_get_mctrl, 138 .stop_tx = tegra_tcu_uart_stop_tx, 139 .start_tx = tegra_tcu_uart_start_tx, 140 .stop_rx = tegra_tcu_uart_stop_rx, 141 .break_ctl = tegra_tcu_uart_break_ctl, 142 .startup = tegra_tcu_uart_startup, 143 .shutdown = tegra_tcu_uart_shutdown, 144 .set_termios = tegra_tcu_uart_set_termios, 145 }; 146 147 #if IS_ENABLED(CONFIG_SERIAL_TEGRA_TCU_CONSOLE) 148 static void tegra_tcu_console_write(struct console *cons, const char *s, 149 unsigned int count) 150 { 151 struct tegra_tcu *tcu = container_of(cons, struct tegra_tcu, console); 152 153 tegra_tcu_write(tcu, s, count); 154 } 155 156 static int tegra_tcu_console_setup(struct console *cons, char *options) 157 { 158 return 0; 159 } 160 #endif 161 162 static void tegra_tcu_receive(struct mbox_client *cl, void *msg) 163 { 164 struct tegra_tcu *tcu = container_of(cl, struct tegra_tcu, rx_client); 165 struct tty_port *port = &tcu->port.state->port; 166 u32 value = (u32)(unsigned long)msg; 167 unsigned int num_bytes, i; 168 169 num_bytes = TCU_MBOX_NUM_BYTES_V(value); 170 171 for (i = 0; i < num_bytes; i++) 172 tty_insert_flip_char(port, TCU_MBOX_BYTE_V(value, i), 173 TTY_NORMAL); 174 175 tty_flip_buffer_push(port); 176 } 177 178 static int tegra_tcu_probe(struct platform_device *pdev) 179 { 180 struct uart_port *port; 181 struct tegra_tcu *tcu; 182 int err; 183 184 tcu = devm_kzalloc(&pdev->dev, sizeof(*tcu), GFP_KERNEL); 185 if (!tcu) 186 return -ENOMEM; 187 188 tcu->tx_client.dev = &pdev->dev; 189 tcu->rx_client.dev = &pdev->dev; 190 tcu->rx_client.rx_callback = tegra_tcu_receive; 191 192 tcu->tx = mbox_request_channel_byname(&tcu->tx_client, "tx"); 193 if (IS_ERR(tcu->tx)) { 194 err = PTR_ERR(tcu->tx); 195 dev_err(&pdev->dev, "failed to get tx mailbox: %d\n", err); 196 return err; 197 } 198 199 #if IS_ENABLED(CONFIG_SERIAL_TEGRA_TCU_CONSOLE) 200 /* setup the console */ 201 strcpy(tcu->console.name, "ttyTCU"); 202 tcu->console.device = uart_console_device; 203 tcu->console.flags = CON_PRINTBUFFER | CON_ANYTIME; 204 tcu->console.index = -1; 205 tcu->console.write = tegra_tcu_console_write; 206 tcu->console.setup = tegra_tcu_console_setup; 207 tcu->console.data = &tcu->driver; 208 #endif 209 210 /* setup the driver */ 211 tcu->driver.owner = THIS_MODULE; 212 tcu->driver.driver_name = "tegra-tcu"; 213 tcu->driver.dev_name = "ttyTCU"; 214 #if IS_ENABLED(CONFIG_SERIAL_TEGRA_TCU_CONSOLE) 215 tcu->driver.cons = &tcu->console; 216 #endif 217 tcu->driver.nr = 1; 218 219 err = uart_register_driver(&tcu->driver); 220 if (err) { 221 dev_err(&pdev->dev, "failed to register UART driver: %d\n", 222 err); 223 goto free_tx; 224 } 225 226 /* setup the port */ 227 port = &tcu->port; 228 spin_lock_init(&port->lock); 229 port->dev = &pdev->dev; 230 port->type = PORT_TEGRA_TCU; 231 port->ops = &tegra_tcu_uart_ops; 232 port->fifosize = 1; 233 port->iotype = UPIO_MEM; 234 port->flags = UPF_BOOT_AUTOCONF; 235 port->private_data = tcu; 236 237 err = uart_add_one_port(&tcu->driver, port); 238 if (err) { 239 dev_err(&pdev->dev, "failed to add UART port: %d\n", err); 240 goto unregister_uart; 241 } 242 243 /* 244 * Request RX channel after creating port to ensure tcu->port 245 * is ready for any immediate incoming bytes. 246 */ 247 tcu->rx = mbox_request_channel_byname(&tcu->rx_client, "rx"); 248 if (IS_ERR(tcu->rx)) { 249 err = PTR_ERR(tcu->rx); 250 dev_err(&pdev->dev, "failed to get rx mailbox: %d\n", err); 251 goto remove_uart_port; 252 } 253 254 platform_set_drvdata(pdev, tcu); 255 #if IS_ENABLED(CONFIG_SERIAL_TEGRA_TCU_CONSOLE) 256 register_console(&tcu->console); 257 #endif 258 259 return 0; 260 261 remove_uart_port: 262 uart_remove_one_port(&tcu->driver, &tcu->port); 263 unregister_uart: 264 uart_unregister_driver(&tcu->driver); 265 free_tx: 266 mbox_free_channel(tcu->tx); 267 268 return err; 269 } 270 271 static void tegra_tcu_remove(struct platform_device *pdev) 272 { 273 struct tegra_tcu *tcu = platform_get_drvdata(pdev); 274 275 #if IS_ENABLED(CONFIG_SERIAL_TEGRA_TCU_CONSOLE) 276 unregister_console(&tcu->console); 277 #endif 278 mbox_free_channel(tcu->rx); 279 uart_remove_one_port(&tcu->driver, &tcu->port); 280 uart_unregister_driver(&tcu->driver); 281 mbox_free_channel(tcu->tx); 282 } 283 284 static const struct of_device_id tegra_tcu_match[] = { 285 { .compatible = "nvidia,tegra194-tcu" }, 286 { } 287 }; 288 MODULE_DEVICE_TABLE(of, tegra_tcu_match); 289 290 static struct platform_driver tegra_tcu_driver = { 291 .driver = { 292 .name = "tegra-tcu", 293 .of_match_table = tegra_tcu_match, 294 }, 295 .probe = tegra_tcu_probe, 296 .remove_new = tegra_tcu_remove, 297 }; 298 module_platform_driver(tegra_tcu_driver); 299 300 MODULE_AUTHOR("Mikko Perttunen <mperttunen@nvidia.com>"); 301 MODULE_LICENSE("GPL v2"); 302 MODULE_DESCRIPTION("NVIDIA Tegra Combined UART driver"); 303