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
 22struct 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
 33static unsigned int tegra_tcu_uart_tx_empty(struct uart_port *port)
 34{
 35	return TIOCSER_TEMT;
 36}
 37
 38static void tegra_tcu_uart_set_mctrl(struct uart_port *port, unsigned int mctrl)
 39{
 40}
 41
 42static unsigned int tegra_tcu_uart_get_mctrl(struct uart_port *port)
 43{
 44	return 0;
 45}
 46
 47static void tegra_tcu_uart_stop_tx(struct uart_port *port)
 48{
 49}
 50
 51static 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
 62static 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
 91static void tegra_tcu_uart_start_tx(struct uart_port *port)
 92{
 93	struct tegra_tcu *tcu = port->private_data;
 94	struct circ_buf *xmit = &port->state->xmit;
 95	unsigned long count;
 96
 97	for (;;) {
 98		count = CIRC_CNT_TO_END(xmit->head, xmit->tail, UART_XMIT_SIZE);
 99		if (!count)
100			break;
101
102		tegra_tcu_write(tcu, &xmit->buf[xmit->tail], count);
103		uart_xmit_advance(port, count);
104	}
105
106	uart_write_wakeup(port);
107}
108
109static void tegra_tcu_uart_stop_rx(struct uart_port *port)
110{
111}
112
113static void tegra_tcu_uart_break_ctl(struct uart_port *port, int ctl)
114{
115}
116
117static int tegra_tcu_uart_startup(struct uart_port *port)
118{
119	return 0;
120}
121
122static void tegra_tcu_uart_shutdown(struct uart_port *port)
123{
124}
125
126static void tegra_tcu_uart_set_termios(struct uart_port *port,
127				       struct ktermios *new,
128				       const struct ktermios *old)
129{
130}
131
132static const struct uart_ops tegra_tcu_uart_ops = {
133	.tx_empty = tegra_tcu_uart_tx_empty,
134	.set_mctrl = tegra_tcu_uart_set_mctrl,
135	.get_mctrl = tegra_tcu_uart_get_mctrl,
136	.stop_tx = tegra_tcu_uart_stop_tx,
137	.start_tx = tegra_tcu_uart_start_tx,
138	.stop_rx = tegra_tcu_uart_stop_rx,
139	.break_ctl = tegra_tcu_uart_break_ctl,
140	.startup = tegra_tcu_uart_startup,
141	.shutdown = tegra_tcu_uart_shutdown,
142	.set_termios = tegra_tcu_uart_set_termios,
143};
144
145#if IS_ENABLED(CONFIG_SERIAL_TEGRA_TCU_CONSOLE)
146static void tegra_tcu_console_write(struct console *cons, const char *s,
147				    unsigned int count)
148{
149	struct tegra_tcu *tcu = container_of(cons, struct tegra_tcu, console);
150
151	tegra_tcu_write(tcu, s, count);
152}
153
154static int tegra_tcu_console_setup(struct console *cons, char *options)
155{
156	return 0;
157}
158#endif
159
160static void tegra_tcu_receive(struct mbox_client *cl, void *msg)
161{
162	struct tegra_tcu *tcu = container_of(cl, struct tegra_tcu, rx_client);
163	struct tty_port *port = &tcu->port.state->port;
164	u32 value = (u32)(unsigned long)msg;
165	unsigned int num_bytes, i;
166
167	num_bytes = TCU_MBOX_NUM_BYTES_V(value);
168
169	for (i = 0; i < num_bytes; i++)
170		tty_insert_flip_char(port, TCU_MBOX_BYTE_V(value, i),
171				     TTY_NORMAL);
172
173	tty_flip_buffer_push(port);
174}
175
176static int tegra_tcu_probe(struct platform_device *pdev)
177{
178	struct uart_port *port;
179	struct tegra_tcu *tcu;
180	int err;
181
182	tcu = devm_kzalloc(&pdev->dev, sizeof(*tcu), GFP_KERNEL);
183	if (!tcu)
184		return -ENOMEM;
185
186	tcu->tx_client.dev = &pdev->dev;
187	tcu->rx_client.dev = &pdev->dev;
188	tcu->rx_client.rx_callback = tegra_tcu_receive;
189
190	tcu->tx = mbox_request_channel_byname(&tcu->tx_client, "tx");
191	if (IS_ERR(tcu->tx)) {
192		err = PTR_ERR(tcu->tx);
193		dev_err(&pdev->dev, "failed to get tx mailbox: %d\n", err);
194		return err;
195	}
196
197#if IS_ENABLED(CONFIG_SERIAL_TEGRA_TCU_CONSOLE)
198	/* setup the console */
199	strcpy(tcu->console.name, "ttyTCU");
200	tcu->console.device = uart_console_device;
201	tcu->console.flags = CON_PRINTBUFFER | CON_ANYTIME;
202	tcu->console.index = -1;
203	tcu->console.write = tegra_tcu_console_write;
204	tcu->console.setup = tegra_tcu_console_setup;
205	tcu->console.data = &tcu->driver;
206#endif
207
208	/* setup the driver */
209	tcu->driver.owner = THIS_MODULE;
210	tcu->driver.driver_name = "tegra-tcu";
211	tcu->driver.dev_name = "ttyTCU";
212#if IS_ENABLED(CONFIG_SERIAL_TEGRA_TCU_CONSOLE)
213	tcu->driver.cons = &tcu->console;
214#endif
215	tcu->driver.nr = 1;
216
217	err = uart_register_driver(&tcu->driver);
218	if (err) {
219		dev_err(&pdev->dev, "failed to register UART driver: %d\n",
220			err);
221		goto free_tx;
222	}
223
224	/* setup the port */
225	port = &tcu->port;
226	spin_lock_init(&port->lock);
227	port->dev = &pdev->dev;
228	port->type = PORT_TEGRA_TCU;
229	port->ops = &tegra_tcu_uart_ops;
230	port->fifosize = 1;
231	port->iotype = UPIO_MEM;
232	port->flags = UPF_BOOT_AUTOCONF;
233	port->private_data = tcu;
234
235	err = uart_add_one_port(&tcu->driver, port);
236	if (err) {
237		dev_err(&pdev->dev, "failed to add UART port: %d\n", err);
238		goto unregister_uart;
239	}
240
241	/*
242	 * Request RX channel after creating port to ensure tcu->port
243	 * is ready for any immediate incoming bytes.
244	 */
245	tcu->rx = mbox_request_channel_byname(&tcu->rx_client, "rx");
246	if (IS_ERR(tcu->rx)) {
247		err = PTR_ERR(tcu->rx);
248		dev_err(&pdev->dev, "failed to get rx mailbox: %d\n", err);
249		goto remove_uart_port;
250	}
251
252	platform_set_drvdata(pdev, tcu);
253#if IS_ENABLED(CONFIG_SERIAL_TEGRA_TCU_CONSOLE)
254	register_console(&tcu->console);
255#endif
256
257	return 0;
258
259remove_uart_port:
260	uart_remove_one_port(&tcu->driver, &tcu->port);
261unregister_uart:
262	uart_unregister_driver(&tcu->driver);
263free_tx:
264	mbox_free_channel(tcu->tx);
265
266	return err;
267}
268
269static void tegra_tcu_remove(struct platform_device *pdev)
270{
271	struct tegra_tcu *tcu = platform_get_drvdata(pdev);
272
273#if IS_ENABLED(CONFIG_SERIAL_TEGRA_TCU_CONSOLE)
274	unregister_console(&tcu->console);
275#endif
276	mbox_free_channel(tcu->rx);
277	uart_remove_one_port(&tcu->driver, &tcu->port);
278	uart_unregister_driver(&tcu->driver);
279	mbox_free_channel(tcu->tx);
280}
281
282static const struct of_device_id tegra_tcu_match[] = {
283	{ .compatible = "nvidia,tegra194-tcu" },
284	{ }
285};
286MODULE_DEVICE_TABLE(of, tegra_tcu_match);
287
288static struct platform_driver tegra_tcu_driver = {
289	.driver = {
290		.name = "tegra-tcu",
291		.of_match_table = tegra_tcu_match,
292	},
293	.probe = tegra_tcu_probe,
294	.remove_new = tegra_tcu_remove,
295};
296module_platform_driver(tegra_tcu_driver);
297
298MODULE_AUTHOR("Mikko Perttunen <mperttunen@nvidia.com>");
299MODULE_LICENSE("GPL v2");
300MODULE_DESCRIPTION("NVIDIA Tegra Combined UART driver");