path: root/hw/mcu/native/src/hal_uart.c

/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

#include "os/os.h"
#include "hal/hal_uart.h"
#include "bsp/bsp.h"

#ifdef MN_LINUX
#include <pty.h>
#endif
#ifdef MN_OSX
#include <util.h>
#endif
#include <ctype.h>
#include <stdio.h>
#include <fcntl.h>
#include <assert.h>
#include <unistd.h>
#include <string.h>

#define UART_MAX_BYTES_PER_POLL	64
#define UART_POLLER_STACK_SZ	OS_STACK_ALIGN(1024)
#define UART_POLLER_PRIO	0

struct uart {
    int u_open;
    int u_fd;
    int u_tx_run;
    int u_rx_char;
    hal_uart_rx_char u_rx_func;
    hal_uart_tx_char u_tx_func;
    hal_uart_tx_done u_tx_done;
    void *u_func_arg;
};

/*
 * XXXX should try to use O_ASYNC/SIGIO for byte arrival notification,
 * so we wouldn't need an OS for pseudo ttys.
 */
char *native_uart_log_file = NULL;
static int uart_log_fd = -1;

static struct uart uarts[UART_CNT];
static int uart_poller_running;
static struct os_task uart_poller_task;
static os_stack_t uart_poller_stack[UART_POLLER_STACK_SZ];

static void
uart_open_log(void)
{
    if (native_uart_log_file && uart_log_fd < 0) {
        uart_log_fd = open(native_uart_log_file, O_WRONLY | O_CREAT | O_TRUNC,
          0666);
        assert(uart_log_fd >= 0);
    }
}

static void
uart_log_data(struct uart *u, int istx, uint8_t data)
{
    static struct {
        struct uart *uart;
        int istx;
        uint32_t time;
        int chars_in_line;
    } state = {
        .uart = NULL,
        .istx = 0
    };
    uint32_t now;
    char tmpbuf[32];
    int len;

    if (uart_log_fd < 0) {
        return;
    }
    now = os_time_get();
    if (state.uart) {
        if (u != state.uart || now != state.time || istx != state.istx) {
            /*
             * End current printout.
             */
            if (write(uart_log_fd, "\n", 1) != 1) {
                assert(0);
            }
            state.uart = NULL;
        } else {
            if (state.chars_in_line == 8) {
                if (write(uart_log_fd, "\n\t", 2) != 2) {
                    assert(0);
                }
                state.chars_in_line = 0;
            }
            len = snprintf(tmpbuf, sizeof(tmpbuf), "%c (%02x) ",
              isalnum(data) ? data : '?', data);
            if (write(uart_log_fd, tmpbuf, len) != len) {
                assert(0);
            }
            state.chars_in_line++;
        }
    }
    if (u && state.uart == NULL) {
        len = snprintf(tmpbuf, sizeof(tmpbuf), "%u:uart%d %s\n\t%c (%02x) ",
          now, u - uarts, istx ? "tx" : "rx", isalnum(data) ? data : '?', data);
        if (write(uart_log_fd, tmpbuf, len) != len) {
            assert(0);
        }
        state.chars_in_line = 1;
        state.uart = u;
        state.istx = istx;
        state.time = now;
    }
}

static int
uart_transmit_char(struct uart *uart)
{
    int sr;
    int rc;
    char ch;

    OS_ENTER_CRITICAL(sr);
    rc = uart->u_tx_func(uart->u_func_arg);
    if (rc < 0) {
        /*
         * No more data to send.
         */
        uart->u_tx_run = 0;
        if (uart->u_tx_done) {
            uart->u_tx_done(uart->u_func_arg);
        }
        OS_EXIT_CRITICAL(sr);
        return 0;
    }
    uart_log_data(uart, 1, ch);
    OS_EXIT_CRITICAL(sr);
    ch = rc;
    rc = write(uart->u_fd, &ch, 1);
    if (rc <= 0) {
        /* XXX EOF/error, what now? */
        return -1;
    }
    return 0;
}

static void
uart_poller(void *arg)
{
    int i;
    int rc;
    int bytes;
    int sr;
    char ch;
    struct uart *uart;

    while (1) {
        for (i = 0; i < UART_CNT; i++) {
            if (!uarts[i].u_open) {
                continue;
            }
            uart = &uarts[i];

            for (bytes = 0; bytes < UART_MAX_BYTES_PER_POLL; bytes++) {
                if (uart->u_tx_run) {
                    uart_transmit_char(uart);
                }
            }
            for (bytes = 0; bytes < UART_MAX_BYTES_PER_POLL; bytes++) {
                if (uart->u_rx_char < 0) {
                    rc = read(uart->u_fd, &ch, 1);
                    if (rc == 0) {
                        /* XXX EOF, what now? */
                        assert(0);
                    } else if (rc < 0) {
                        break;
                    } else {
                        uart->u_rx_char = ch;
                    }
                }
                if (uart->u_rx_char >= 0) {
                    OS_ENTER_CRITICAL(sr);
                    uart_log_data(uart, 0, uart->u_rx_char);
                    rc = uart->u_rx_func(uart->u_func_arg, uart->u_rx_char);
                    /* Delivered */
                    if (rc >= 0) {
                        uart->u_rx_char = -1;
                    }
                    OS_EXIT_CRITICAL(sr);
                }
            }
        }
        uart_log_data(NULL, 0, 0);
        os_time_delay(10);
    }
}

static void
set_nonblock(int fd)
{
    int flags;

    flags = fcntl(fd, F_GETFL);
    if (flags == -1) {
        const char msg[] = "fcntl(F_GETFL) fail";
        write(1, msg, sizeof(msg));
        return;
    }
    if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0) {
        const char msg[] = "fcntl(F_SETFL) fail";
        write(1, msg, sizeof(msg));
        return;
    }
}

static int
uart_set_attr(int fd)
{
    struct termios tios;

    if (tcgetattr(fd, &tios)) {
        const char msg[] = "tcgetattr() failed";
        write(1, msg, sizeof(msg));
        return -1;
    }

    tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
    tios.c_cflag |= CS8 | CREAD;
    tios.c_iflag = IGNPAR | IXON;
    tios.c_oflag = 0;
    tios.c_lflag = 0;
    if (tcsetattr(fd, TCSAFLUSH, &tios) < 0) {
        const char msg[] = "tcsetattr() failed";
        write(1, msg, sizeof(msg));
        return -1;
    }
    return 0;
}

static int
uart_pty(int port)
{
    int fd;
    int loop_slave;
    char pty_name[32];
    char msg[64];

    if (openpty(&fd, &loop_slave, pty_name, NULL, NULL) < 0) {
        const char msg[] = "openpty() failed";
        write(1, msg, sizeof(msg));
        return -1;
    }

    if (uart_set_attr(loop_slave)) {
        goto err;
    }

    snprintf(msg, sizeof(msg), "uart%d at %s\n", port, pty_name);
    write(1, msg, strlen(msg));
    return fd;
err:
    close(fd);
    close(loop_slave);
    return -1;
}

void
hal_uart_start_tx(int port)
{
    int sr;

    if (port >= UART_CNT || uarts[port].u_open == 0) {
        return;
    }
    OS_ENTER_CRITICAL(sr);
    uarts[port].u_tx_run = 1;
    if (!os_started()) {
        /*
         * XXX this is a hack.
         */
        uart_transmit_char(&uarts[port]);
    }
    OS_EXIT_CRITICAL(sr);
}

void
hal_uart_start_rx(int port)
{
    /* nothing to do here */
}

void
hal_uart_blocking_tx(int port, uint8_t data)
{
    if (port >= UART_CNT || uarts[port].u_open == 0) {
        return;
    }

    /* XXX: Count statistics and add error checking here. */
    (void) write(uarts[port].u_fd, &data, sizeof(data));
}

int
hal_uart_init_cbs(int port, hal_uart_tx_char tx_func, hal_uart_tx_done tx_done,
  hal_uart_rx_char rx_func, void *arg)
{
    struct uart *uart;
    int rc;

    if (port >= UART_CNT) {
        return -1;
    }

    uart = &uarts[port];
    if (uart->u_open) {
        return -1;
    }
    uart->u_tx_func = tx_func;
    uart->u_tx_done = tx_done;
    uart->u_rx_func = rx_func;
    uart->u_func_arg = arg;
    uart->u_rx_char = -1;

    if (!uart_poller_running) {
        uart_poller_running = 1;
        rc = os_task_init(&uart_poller_task, "uart_poller", uart_poller, NULL,
          UART_POLLER_PRIO, OS_WAIT_FOREVER, uart_poller_stack,
          UART_POLLER_STACK_SZ);
        assert(rc == 0);
    }
    return 0;
}

int
hal_uart_config(int port, int32_t baudrate, uint8_t databits, uint8_t stopbits,
  enum hal_uart_parity parity, enum hal_uart_flow_ctl flow_ctl)
{
    struct uart *uart;

    if (port >= UART_CNT) {
        return -1;
    }

    uart = &uarts[port];
    if (uart->u_open) {
        return -1;
    }

    uart->u_fd = uart_pty(port);
    if (uart->u_fd < 0) {
        return -1;
    }
    set_nonblock(uart->u_fd);

    uart_open_log();
    uart->u_open = 1;
    return 0;
}