drivers/tty/serial/tegra-tcu.c

   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 = 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");