xref: /linux/drivers/tty/serial/tegra-tcu.c (revision d8b78066f4c9c8ec898bd4246fc4db31d476dd88)
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 
tegra_tcu_uart_tx_empty(struct uart_port * port)33 static unsigned int tegra_tcu_uart_tx_empty(struct uart_port *port)
34 {
35 	return TIOCSER_TEMT;
36 }
37 
tegra_tcu_uart_set_mctrl(struct uart_port * port,unsigned int mctrl)38 static void tegra_tcu_uart_set_mctrl(struct uart_port *port, unsigned int mctrl)
39 {
40 }
41 
tegra_tcu_uart_get_mctrl(struct uart_port * port)42 static unsigned int tegra_tcu_uart_get_mctrl(struct uart_port *port)
43 {
44 	return 0;
45 }
46 
tegra_tcu_uart_stop_tx(struct uart_port * port)47 static void tegra_tcu_uart_stop_tx(struct uart_port *port)
48 {
49 }
50 
tegra_tcu_write_one(struct tegra_tcu * tcu,u32 value,unsigned int count)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 
tegra_tcu_write(struct tegra_tcu * tcu,const char * s,unsigned int count)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 
tegra_tcu_uart_start_tx(struct uart_port * port)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 
tegra_tcu_uart_stop_rx(struct uart_port * port)111 static void tegra_tcu_uart_stop_rx(struct uart_port *port)
112 {
113 }
114 
tegra_tcu_uart_break_ctl(struct uart_port * port,int ctl)115 static void tegra_tcu_uart_break_ctl(struct uart_port *port, int ctl)
116 {
117 }
118 
tegra_tcu_uart_startup(struct uart_port * port)119 static int tegra_tcu_uart_startup(struct uart_port *port)
120 {
121 	return 0;
122 }
123 
tegra_tcu_uart_shutdown(struct uart_port * port)124 static void tegra_tcu_uart_shutdown(struct uart_port *port)
125 {
126 }
127 
tegra_tcu_uart_set_termios(struct uart_port * port,struct ktermios * new,const struct ktermios * old)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)
tegra_tcu_console_write(struct console * cons,const char * s,unsigned int count)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 
tegra_tcu_console_setup(struct console * cons,char * options)156 static int tegra_tcu_console_setup(struct console *cons, char *options)
157 {
158 	return 0;
159 }
160 #endif
161 
tegra_tcu_receive(struct mbox_client * cl,void * msg)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 
tegra_tcu_probe(struct platform_device * pdev)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 
tegra_tcu_remove(struct platform_device * pdev)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 = 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