tty/serial/tegra-tcu.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
0004  */
0005
0006 #include <linux/console.h>
0007 #include <linux/mailbox_client.h>
0008 #include <linux/module.h>
0009 #include <linux/of.h>
0010 #include <linux/of_device.h>
0011 #include <linux/platform_device.h>
0012 #include <linux/serial.h>
0013 #include <linux/serial_core.h>
0014 #include <linux/slab.h>
0015 #include <linux/tty.h>
0016 #include <linux/tty_flip.h>
0017
0018 #define TCU_MBOX_BYTE(i, x)         ((x) << (i * 8))
0019 #define TCU_MBOX_BYTE_V(x, i)           (((x) >> (i * 8)) & 0xff)
0020 #define TCU_MBOX_NUM_BYTES(x)           ((x) << 24)
0021 #define TCU_MBOX_NUM_BYTES_V(x)         (((x) >> 24) & 0x3)
0022
0023 struct tegra_tcu {
0024     struct uart_driver driver;
0025 #if IS_ENABLED(CONFIG_SERIAL_TEGRA_TCU_CONSOLE)
0026     struct console console;
0027 #endif
0028     struct uart_port port;
0029
0030     struct mbox_client tx_client, rx_client;
0031     struct mbox_chan *tx, *rx;
0032 };
0033
0034 static unsigned int tegra_tcu_uart_tx_empty(struct uart_port *port)
0035 {
0036     return TIOCSER_TEMT;
0037 }
0038
0039 static void tegra_tcu_uart_set_mctrl(struct uart_port *port, unsigned int mctrl)
0040 {
0041 }
0042
0043 static unsigned int tegra_tcu_uart_get_mctrl(struct uart_port *port)
0044 {
0045     return 0;
0046 }
0047
0048 static void tegra_tcu_uart_stop_tx(struct uart_port *port)
0049 {
0050 }
0051
0052 static void tegra_tcu_write_one(struct tegra_tcu *tcu, u32 value,
0053                 unsigned int count)
0054 {
0055     void *msg;
0056
0057     value |= TCU_MBOX_NUM_BYTES(count);
0058     msg = (void *)(unsigned long)value;
0059     mbox_send_message(tcu->tx, msg);
0060     mbox_flush(tcu->tx, 1000);
0061 }
0062
0063 static void tegra_tcu_write(struct tegra_tcu *tcu, const char *s,
0064                 unsigned int count)
0065 {
0066     unsigned int written = 0, i = 0;
0067     bool insert_nl = false;
0068     u32 value = 0;
0069
0070     while (i < count) {
0071         if (insert_nl) {
0072             value |= TCU_MBOX_BYTE(written++, '\n');
0073             insert_nl = false;
0074             i++;
0075         } else if (s[i] == '\n') {
0076             value |= TCU_MBOX_BYTE(written++, '\r');
0077             insert_nl = true;
0078         } else {
0079             value |= TCU_MBOX_BYTE(written++, s[i++]);
0080         }
0081
0082         if (written == 3) {
0083             tegra_tcu_write_one(tcu, value, 3);
0084             value = written = 0;
0085         }
0086     }
0087
0088     if (written)
0089         tegra_tcu_write_one(tcu, value, written);
0090 }
0091
0092 static void tegra_tcu_uart_start_tx(struct uart_port *port)
0093 {
0094     struct tegra_tcu *tcu = port->private_data;
0095     struct circ_buf *xmit = &port->state->xmit;
0096     unsigned long count;
0097
0098     for (;;) {
0099         count = CIRC_CNT_TO_END(xmit->head, xmit->tail, UART_XMIT_SIZE);
0100         if (!count)
0101             break;
0102
0103         tegra_tcu_write(tcu, &xmit->buf[xmit->tail], count);
0104         uart_xmit_advance(port, count);
0105     }
0106
0107     uart_write_wakeup(port);
0108 }
0109
0110 static void tegra_tcu_uart_stop_rx(struct uart_port *port)
0111 {
0112 }
0113
0114 static void tegra_tcu_uart_break_ctl(struct uart_port *port, int ctl)
0115 {
0116 }
0117
0118 static int tegra_tcu_uart_startup(struct uart_port *port)
0119 {
0120     return 0;
0121 }
0122
0123 static void tegra_tcu_uart_shutdown(struct uart_port *port)
0124 {
0125 }
0126
0127 static void tegra_tcu_uart_set_termios(struct uart_port *port,
0128                        struct ktermios *new,
0129                        struct ktermios *old)
0130 {
0131 }
0132
0133 static const struct uart_ops tegra_tcu_uart_ops = {
0134     .tx_empty = tegra_tcu_uart_tx_empty,
0135     .set_mctrl = tegra_tcu_uart_set_mctrl,
0136     .get_mctrl = tegra_tcu_uart_get_mctrl,
0137     .stop_tx = tegra_tcu_uart_stop_tx,
0138     .start_tx = tegra_tcu_uart_start_tx,
0139     .stop_rx = tegra_tcu_uart_stop_rx,
0140     .break_ctl = tegra_tcu_uart_break_ctl,
0141     .startup = tegra_tcu_uart_startup,
0142     .shutdown = tegra_tcu_uart_shutdown,
0143     .set_termios = tegra_tcu_uart_set_termios,
0144 };
0145
0146 #if IS_ENABLED(CONFIG_SERIAL_TEGRA_TCU_CONSOLE)
0147 static void tegra_tcu_console_write(struct console *cons, const char *s,
0148                     unsigned int count)
0149 {
0150     struct tegra_tcu *tcu = container_of(cons, struct tegra_tcu, console);
0151
0152     tegra_tcu_write(tcu, s, count);
0153 }
0154
0155 static int tegra_tcu_console_setup(struct console *cons, char *options)
0156 {
0157     return 0;
0158 }
0159 #endif
0160
0161 static void tegra_tcu_receive(struct mbox_client *cl, void *msg)
0162 {
0163     struct tegra_tcu *tcu = container_of(cl, struct tegra_tcu, rx_client);
0164     struct tty_port *port = &tcu->port.state->port;
0165     u32 value = (u32)(unsigned long)msg;
0166     unsigned int num_bytes, i;
0167
0168     num_bytes = TCU_MBOX_NUM_BYTES_V(value);
0169
0170     for (i = 0; i < num_bytes; i++)
0171         tty_insert_flip_char(port, TCU_MBOX_BYTE_V(value, i),
0172                      TTY_NORMAL);
0173
0174     tty_flip_buffer_push(port);
0175 }
0176
0177 static int tegra_tcu_probe(struct platform_device *pdev)
0178 {
0179     struct uart_port *port;
0180     struct tegra_tcu *tcu;
0181     int err;
0182
0183     tcu = devm_kzalloc(&pdev->dev, sizeof(*tcu), GFP_KERNEL);
0184     if (!tcu)
0185         return -ENOMEM;
0186
0187     tcu->tx_client.dev = &pdev->dev;
0188     tcu->rx_client.dev = &pdev->dev;
0189     tcu->rx_client.rx_callback = tegra_tcu_receive;
0190
0191     tcu->tx = mbox_request_channel_byname(&tcu->tx_client, "tx");
0192     if (IS_ERR(tcu->tx)) {
0193         err = PTR_ERR(tcu->tx);
0194         dev_err(&pdev->dev, "failed to get tx mailbox: %d\n", err);
0195         return err;
0196     }
0197
0198 #if IS_ENABLED(CONFIG_SERIAL_TEGRA_TCU_CONSOLE)
0199     /* setup the console */
0200     strcpy(tcu->console.name, "ttyTCU");
0201     tcu->console.device = uart_console_device;
0202     tcu->console.flags = CON_PRINTBUFFER | CON_ANYTIME;
0203     tcu->console.index = -1;
0204     tcu->console.write = tegra_tcu_console_write;
0205     tcu->console.setup = tegra_tcu_console_setup;
0206     tcu->console.data = &tcu->driver;
0207 #endif
0208
0209     /* setup the driver */
0210     tcu->driver.owner = THIS_MODULE;
0211     tcu->driver.driver_name = "tegra-tcu";
0212     tcu->driver.dev_name = "ttyTCU";
0213 #if IS_ENABLED(CONFIG_SERIAL_TEGRA_TCU_CONSOLE)
0214     tcu->driver.cons = &tcu->console;
0215 #endif
0216     tcu->driver.nr = 1;
0217
0218     err = uart_register_driver(&tcu->driver);
0219     if (err) {
0220         dev_err(&pdev->dev, "failed to register UART driver: %d\n",
0221             err);
0222         goto free_tx;
0223     }
0224
0225     /* setup the port */
0226     port = &tcu->port;
0227     spin_lock_init(&port->lock);
0228     port->dev = &pdev->dev;
0229     port->type = PORT_TEGRA_TCU;
0230     port->ops = &tegra_tcu_uart_ops;
0231     port->fifosize = 1;
0232     port->iotype = UPIO_MEM;
0233     port->flags = UPF_BOOT_AUTOCONF;
0234     port->private_data = tcu;
0235
0236     err = uart_add_one_port(&tcu->driver, port);
0237     if (err) {
0238         dev_err(&pdev->dev, "failed to add UART port: %d\n", err);
0239         goto unregister_uart;
0240     }
0241
0242     /*
0243      * Request RX channel after creating port to ensure tcu->port
0244      * is ready for any immediate incoming bytes.
0245      */
0246     tcu->rx = mbox_request_channel_byname(&tcu->rx_client, "rx");
0247     if (IS_ERR(tcu->rx)) {
0248         err = PTR_ERR(tcu->rx);
0249         dev_err(&pdev->dev, "failed to get rx mailbox: %d\n", err);
0250         goto remove_uart_port;
0251     }
0252
0253     platform_set_drvdata(pdev, tcu);
0254 #if IS_ENABLED(CONFIG_SERIAL_TEGRA_TCU_CONSOLE)
0255     register_console(&tcu->console);
0256 #endif
0257
0258     return 0;
0259
0260 remove_uart_port:
0261     uart_remove_one_port(&tcu->driver, &tcu->port);
0262 unregister_uart:
0263     uart_unregister_driver(&tcu->driver);
0264 free_tx:
0265     mbox_free_channel(tcu->tx);
0266
0267     return err;
0268 }
0269
0270 static int tegra_tcu_remove(struct platform_device *pdev)
0271 {
0272     struct tegra_tcu *tcu = platform_get_drvdata(pdev);
0273
0274 #if IS_ENABLED(CONFIG_SERIAL_TEGRA_TCU_CONSOLE)
0275     unregister_console(&tcu->console);
0276 #endif
0277     mbox_free_channel(tcu->rx);
0278     uart_remove_one_port(&tcu->driver, &tcu->port);
0279     uart_unregister_driver(&tcu->driver);
0280     mbox_free_channel(tcu->tx);
0281
0282     return 0;
0283 }
0284
0285 static const struct of_device_id tegra_tcu_match[] = {
0286     { .compatible = "nvidia,tegra194-tcu" },
0287     { }
0288 };
0289 MODULE_DEVICE_TABLE(of, tegra_tcu_match);
0290
0291 static struct platform_driver tegra_tcu_driver = {
0292     .driver = {
0293         .name = "tegra-tcu",
0294         .of_match_table = tegra_tcu_match,
0295     },
0296     .probe = tegra_tcu_probe,
0297     .remove = tegra_tcu_remove,
0298 };
0299 module_platform_driver(tegra_tcu_driver);
0300
0301 MODULE_AUTHOR("Mikko Perttunen <mperttunen@nvidia.com>");
0302 MODULE_LICENSE("GPL v2");
0303 MODULE_DESCRIPTION("NVIDIA Tegra Combined UART driver");