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