/*
|
* 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/mynewt.h"
|
#include "hal/hal_uart.h"
|
#include "bsp/bsp.h"
|
|
#ifdef MN_LINUX
|
#include <pty.h>
|
#endif
|
#ifdef MN_OSX
|
#include <util.h>
|
#endif
|
#ifdef MN_FreeBSD
|
#include <libutil.h>
|
#endif
|
#include <ctype.h>
|
#include <stdio.h>
|
#include <fcntl.h>
|
#include <assert.h>
|
#include <unistd.h>
|
#include <string.h>
|
#include <termios.h>
|
#include <errno.h>
|
|
#include "mcu/mcu_sim.h"
|
#include "native_uart_cfg_priv.h"
|
#include "nimble_syscfg.h"
|
|
#define UART_CNT 2
|
|
#if MYNEWT_VAL(CONSOLE_UART_TX_BUF_SIZE)
|
#define UART_MAX_BYTES_PER_POLL MYNEWT_VAL(CONSOLE_UART_TX_BUF_SIZE) - 2
|
#else
|
#define UART_MAX_BYTES_PER_POLL 64
|
#endif
|
#define UART_POLLER_STACK_SZ OS_STACK_ALIGN(1024)
|
|
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;
|
};
|
|
const char *native_uart_dev_strs[UART_CNT];
|
|
/*
|
* 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;
|
}
|
ch = rc;
|
uart_log_data(uart, 1, ch);
|
OS_EXIT_CRITICAL(sr);
|
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;
|
int didwork;
|
unsigned 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++) {
|
didwork = 0;
|
if (uart->u_tx_run) {
|
uart_transmit_char(uart);
|
didwork = 1;
|
}
|
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) {
|
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;
|
didwork = 1;
|
}
|
OS_EXIT_CRITICAL(sr);
|
}
|
if (!didwork) {
|
break;
|
}
|
}
|
}
|
uart_log_data(NULL, 0, 0);
|
os_time_delay(OS_TICKS_PER_SEC / 100);
|
}
|
}
|
|
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_pty_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;
|
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_pty_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;
|
}
|
|
/**
|
* Opens an external device terminal (/dev/cu.<...>).
|
*/
|
static int
|
uart_open_dev(int port, int32_t baudrate, uint8_t databits,
|
uint8_t stopbits, enum hal_uart_parity parity,
|
enum hal_uart_flow_ctl flow_ctl)
|
{
|
const char *filename;
|
int fd;
|
int rc;
|
|
filename = native_uart_dev_strs[port];
|
assert(filename != NULL);
|
|
fd = open(filename, O_RDWR);
|
if (fd < 0) {
|
return -1;
|
}
|
|
rc = uart_dev_set_attr(fd, baudrate, databits,
|
stopbits, parity, flow_ctl);
|
if (rc != 0) {
|
close(fd);
|
return rc;
|
}
|
|
dprintf(1, "uart%d at %s\n", port, filename);
|
|
return fd;
|
}
|
|
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, "uartpoll", uart_poller, NULL,
|
MYNEWT_VAL(MCU_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;
|
}
|
|
if (native_uart_dev_strs[port] == NULL) {
|
uart->u_fd = uart_pty(port);
|
} else {
|
uart->u_fd = uart_open_dev(port, baudrate, databits, stopbits,
|
parity, flow_ctl);
|
}
|
|
if (uart->u_fd < 0) {
|
return -1;
|
}
|
set_nonblock(uart->u_fd);
|
|
|
uart_open_log();
|
uart->u_open = 1;
|
return 0;
|
}
|
|
int
|
hal_uart_close(int port)
|
{
|
struct uart *uart;
|
int rc;
|
|
if (port >= UART_CNT) {
|
rc = -1;
|
goto err;
|
}
|
|
uart = &uarts[port];
|
if (!uart->u_open) {
|
rc = -1;
|
goto err;
|
}
|
|
close(uart->u_fd);
|
|
uart->u_open = 0;
|
return (0);
|
err:
|
return (rc);
|
}
|
|
int
|
hal_uart_init(int port, void *arg)
|
{
|
return (0);
|
}
|
|
int
|
uart_set_dev(int port, const char *dev_str)
|
{
|
if (port < 0 || port >= UART_CNT) {
|
return SYS_EINVAL;
|
}
|
|
if (uarts[port].u_open) {
|
return SYS_EBUSY;
|
}
|
|
native_uart_dev_strs[port] = dev_str;
|
|
return 0;
|
}
|
