static void insert_char(char *pos, char c, uint8_t end)
{
char tmp;
/* Echo back to console */
uart_poll_out(uart_console_dev, c);
if (end == 0) {
*pos = c;
return;
}
tmp = *pos;
*(pos++) = c;
cursor_save();
while (end-- > 0) {
uart_poll_out(uart_console_dev, tmp);
c = *pos;
*(pos++) = tmp;
tmp = c;
}
/* Move cursor back to right place */
cursor_restore();
}
static int console_out(int c)
{
uart_poll_out(uart_console_dev, (unsigned char)c);
if ('\n' == c) {
uart_poll_out(uart_console_dev, (unsigned char)'\r');
}
return c;
}
static int console_out(int c)
{
int handled_by_debug_server = HANDLE_DEBUG_HOOK_OUT(c);
if (handled_by_debug_server) {
return c;
}
uart_poll_out(uart_console_dev, (unsigned char)c);
if ('\n' == c) {
uart_poll_out(uart_console_dev, (unsigned char)'\r');
}
return c;
}
size_t UARTClass::write( const uint8_t uc_data )
{
if (!opened)
return(0);
// Is the hardware currently busy?
if (_tx_buffer->_iTail != _tx_buffer->_iHead)
{
// If busy we buffer
int l = (_tx_buffer->_iHead + 1) % SERIAL_BUFFER_SIZE;
while (_tx_buffer->_iTail == l)
; // Spin locks if we're about to overwrite the buffer. This continues once the data is sent
_tx_buffer->_aucBuffer[_tx_buffer->_iHead] = uc_data;
_tx_buffer->_iHead = l;
// Make sure TX interrupt is enabled
uart_irq_tx_enable(CONFIG_UART_CONSOLE_INDEX);
}
else
{
// Bypass buffering and send character directly
uart_poll_out(CONFIG_UART_CONSOLE_INDEX, uc_data);
}
return 1;
}
void UARTClass::IrqHandler( void )
{
uint8_t uc_data;
int ret;
ret = uart_poll_in(CONFIG_UART_CONSOLE_INDEX, &uc_data);
while ( ret != -1 ) {
_rx_buffer->store_char(uc_data);
ret = uart_poll_in(CONFIG_UART_CONSOLE_INDEX, &uc_data);
}
// Do we need to keep sending data?
if (!uart_irq_tx_ready(CONFIG_UART_CONSOLE_INDEX))
{
if (_tx_buffer->_iTail != _tx_buffer->_iHead) {
uart_poll_out(CONFIG_UART_CONSOLE_INDEX, _tx_buffer->_aucBuffer[_tx_buffer->_iTail]);
_tx_buffer->_iTail = (unsigned int)(_tx_buffer->_iTail + 1) % SERIAL_BUFFER_SIZE;
}
else
{
// Mask off transmit interrupt so we don't get it anymore
uart_irq_tx_disable(CONFIG_UART_CONSOLE_INDEX);
}
}
}
static uint8_t h5_slip_byte(uint8_t byte)
{
switch (byte) {
case SLIP_DELIMITER:
uart_poll_out(h5_dev, SLIP_ESC);
uart_poll_out(h5_dev, SLIP_ESC_DELIM);
return 2;
case SLIP_ESC:
uart_poll_out(h5_dev, SLIP_ESC);
uart_poll_out(h5_dev, SLIP_ESC_ESC);
return 2;
default:
uart_poll_out(h5_dev, byte);
return 1;
}
}
int uart_pipe_send(const uint8_t *data, int len)
{
while (len--) {
uart_poll_out(uart_pipe_dev, *data++);
}
return 0;
}
static void monitor_send(const void *data, size_t len)
{
const uint8_t *buf = data;
while (len--) {
uart_poll_out(monitor_dev, *buf++);
}
}
static int h4_send(enum bt_buf_type buf_type, struct net_buf *buf)
{
if (buf_type == BT_ACL_OUT) {
uart_poll_out(h4_dev, H4_ACL);
} else if (buf_type == BT_CMD) {
uart_poll_out(h4_dev, H4_CMD);
} else {
return -EINVAL;
}
while (buf->len) {
uart_poll_out(h4_dev, net_buf_pull_u8(buf));
}
net_buf_unref(buf);
return 0;
}
static int console_out(int c)
{
#ifdef CONFIG_UART_CONSOLE_DEBUG_SERVER_HOOKS
int handled_by_debug_server = HANDLE_DEBUG_HOOK_OUT(c);
if (handled_by_debug_server) {
return c;
}
#endif /* CONFIG_UART_CONSOLE_DEBUG_SERVER_HOOKS */
if ('\n' == c) {
uart_poll_out(uart_console_dev, '\r');
}
uart_poll_out(uart_console_dev, c);
return c;
}
static void h5_send(const uint8_t *payload, uint8_t type, int len)
{
uint8_t hdr[4];
int i;
hexdump("<= ", payload, len);
memset(hdr, 0, sizeof(hdr));
/* Set ACK for outgoing packet and stop delayed fiber */
H5_SET_ACK(hdr, h5.tx_ack);
if (h5.ack_to) {
BT_DBG("Cancel delayed ack fiber");
fiber_delayed_start_cancel(h5.ack_to);
h5.ack_to = NULL;
}
if (reliable_packet(type)) {
H5_SET_RELIABLE(hdr);
H5_SET_SEQ(hdr, h5.tx_seq);
h5.tx_seq = (h5.tx_seq + 1) % 8;
}
H5_SET_TYPE(hdr, type);
H5_SET_LEN(hdr, len);
/* Calculate CRC */
hdr[3] = ~((hdr[0] + hdr[1] + hdr[2]) & 0xff);
h5_print_header(hdr, "TX: <");
uart_poll_out(h5_dev, SLIP_DELIMITER);
for (i = 0; i < 4; i++) {
h5_slip_byte(hdr[i]);
}
for (i = 0; i < len; i++) {
h5_slip_byte(payload[i]);
}
uart_poll_out(h5_dev, SLIP_DELIMITER);
}
/**
* Sends raw data over the UART.
*/
static int uart_mcumgr_send_raw(const void *data, int len, void *arg)
{
const u8_t *u8p;
u8p = data;
while (len--) {
uart_poll_out(uart_mcumgr_dev, *u8p++);
}
return 0;
}
static void del_char(char *pos, uint8_t end)
{
uart_poll_out(uart_console_dev, '\b');
if (end == 0) {
uart_poll_out(uart_console_dev, ' ');
uart_poll_out(uart_console_dev, '\b');
return;
}
cursor_save();
while (end-- > 0) {
*pos = *(pos + 1);
uart_poll_out(uart_console_dev, *(pos++));
}
uart_poll_out(uart_console_dev, ' ');
/* Move cursor back to right place */
cursor_restore();
}
static int h4_send(struct net_buf *buf)
{
BT_DBG("buf %p type %u len %u", buf, bt_buf_get_type(buf), buf->len);
switch (bt_buf_get_type(buf)) {
case BT_BUF_ACL_OUT:
uart_poll_out(h4_dev, H4_ACL);
break;
case BT_BUF_CMD:
uart_poll_out(h4_dev, H4_CMD);
break;
default:
return -EINVAL;
}
while (buf->len) {
uart_poll_out(h4_dev, net_buf_pull_u8(buf));
}
net_buf_unref(buf);
return 0;
}
void bt_log(int prio, const char *fmt, ...)
{
struct bt_monitor_user_logging log;
struct bt_monitor_hdr hdr;
const char id[] = "bt";
va_list ap;
int len;
va_start(ap, fmt);
len = vsnprintk(NULL, 0, fmt, ap);
va_end(ap);
if (len < 0) {
return;
}
log.priority = prio;
log.ident_len = sizeof(id);
if (atomic_test_and_set_bit(&flags, BT_LOG_BUSY)) {
drop_add(BT_MONITOR_USER_LOGGING);
return;
}
encode_hdr(&hdr, BT_MONITOR_USER_LOGGING,
sizeof(log) + sizeof(id) + len + 1);
monitor_send(&hdr, BT_MONITOR_BASE_HDR_LEN + hdr.hdr_len);
monitor_send(&log, sizeof(log));
monitor_send(id, sizeof(id));
va_start(ap, fmt);
_vprintk(log_out, NULL, fmt, ap);
va_end(ap);
/* Terminate the string with null */
uart_poll_out(monitor_dev, '\0');
atomic_clear_bit(&flags, BT_LOG_BUSY);
}
void bt_log(int prio, const char *fmt, ...)
{
struct bt_monitor_user_logging log;
struct bt_monitor_hdr hdr;
const char id[] = "bt";
va_list ap;
int len, key;
va_start(ap, fmt);
len = vsnprintk(NULL, 0, fmt, ap);
va_end(ap);
if (len < 0) {
return;
}
log.priority = prio;
log.ident_len = sizeof(id);
encode_hdr(&hdr, BT_MONITOR_USER_LOGGING,
sizeof(log) + sizeof(id) + len + 1);
key = irq_lock();
monitor_send(&hdr, sizeof(hdr));
monitor_send(&log, sizeof(log));
monitor_send(id, sizeof(id));
va_start(ap, fmt);
_vprintk(log_out, NULL, fmt, ap);
va_end(ap);
/* Terminate the string with null */
uart_poll_out(monitor_dev, '\0');
irq_unlock(key);
}
void uart_console_isr(struct device *unused)
{
ARG_UNUSED(unused);
while (uart_irq_update(uart_console_dev) &&
uart_irq_is_pending(uart_console_dev)) {
static struct uart_console_input *cmd;
uint8_t byte;
int rx;
if (!uart_irq_rx_ready(uart_console_dev)) {
continue;
}
/* Character(s) have been received */
rx = read_uart(uart_console_dev, &byte, 1);
if (rx < 0) {
return;
}
if (uart_irq_input_hook(uart_console_dev, byte) != 0) {
/*
* The input hook indicates that no further processing
* should be done by this handler.
*/
return;
}
if (!cmd) {
cmd = nano_isr_fifo_get(avail_queue, TICKS_NONE);
if (!cmd)
return;
}
/* Handle ANSI escape mode */
if (atomic_test_bit(&esc_state, ESC_ANSI)) {
handle_ansi(byte);
continue;
}
/* Handle escape mode */
if (atomic_test_and_clear_bit(&esc_state, ESC_ESC)) {
switch (byte) {
case ANSI_ESC:
atomic_set_bit(&esc_state, ESC_ANSI);
atomic_set_bit(&esc_state, ESC_ANSI_FIRST);
break;
default:
break;
}
continue;
}
/* Handle special control characters */
if (!isprint(byte)) {
switch (byte) {
case DEL:
if (cur > 0) {
del_char(&cmd->line[--cur], end);
}
break;
case ESC:
atomic_set_bit(&esc_state, ESC_ESC);
break;
case '\r':
cmd->line[cur + end] = '\0';
uart_poll_out(uart_console_dev, '\r');
uart_poll_out(uart_console_dev, '\n');
cur = 0;
end = 0;
nano_isr_fifo_put(lines_queue, cmd);
cmd = NULL;
break;
case '\t':
if (completion_cb && !end) {
cur += completion_cb(cmd->line, cur);
}
break;
default:
break;
}
continue;
}
/* Ignore characters if there's no more buffer space */
if (cur + end < sizeof(cmd->line) - 1) {
insert_char(&cmd->line[cur++], byte, end);
}
}
}
void uart_console_isr(struct device *unused)
{
ARG_UNUSED(unused);
while (uart_irq_update(uart_console_dev) &&
uart_irq_is_pending(uart_console_dev)) {
static struct console_input *cmd;
u8_t byte;
int rx;
if (!uart_irq_rx_ready(uart_console_dev)) {
continue;
}
/* Character(s) have been received */
rx = read_uart(uart_console_dev, &byte, 1);
if (rx < 0) {
return;
}
#ifdef CONFIG_UART_CONSOLE_DEBUG_SERVER_HOOKS
if (debug_hook_in != NULL && debug_hook_in(byte) != 0) {
/*
* The input hook indicates that no further processing
* should be done by this handler.
*/
return;
}
#endif
if (!cmd) {
cmd = k_fifo_get(avail_queue, K_NO_WAIT);
if (!cmd) {
return;
}
}
#ifdef CONFIG_UART_CONSOLE_MCUMGR
/* Divert this byte from normal console handling if it is part
* of an mcumgr frame.
*/
if (handle_mcumgr(cmd, byte)) {
continue;
}
#endif /* CONFIG_UART_CONSOLE_MCUMGR */
/* Handle ANSI escape mode */
if (atomic_test_bit(&esc_state, ESC_ANSI)) {
handle_ansi(byte, cmd->line);
continue;
}
/* Handle escape mode */
if (atomic_test_and_clear_bit(&esc_state, ESC_ESC)) {
if (byte == ANSI_ESC) {
atomic_set_bit(&esc_state, ESC_ANSI);
atomic_set_bit(&esc_state, ESC_ANSI_FIRST);
}
continue;
}
/* Handle special control characters */
if (!isprint(byte)) {
switch (byte) {
case DEL:
if (cur > 0) {
del_char(&cmd->line[--cur], end);
}
break;
case ESC:
atomic_set_bit(&esc_state, ESC_ESC);
break;
case '\r':
cmd->line[cur + end] = '\0';
uart_poll_out(uart_console_dev, '\r');
uart_poll_out(uart_console_dev, '\n');
cur = 0;
end = 0;
k_fifo_put(lines_queue, cmd);
cmd = NULL;
break;
case '\t':
if (completion_cb && !end) {
cur += completion_cb(cmd->line, cur);
}
break;
default:
break;
}
continue;
}
/* Ignore characters if there's no more buffer space */
if (cur + end < sizeof(cmd->line) - 1) {
insert_char(&cmd->line[cur++], byte, end);
}
}
}
static void write_string(struct device *dev, const char *str, int len)
{
for (int i = 0; i < len; i++)
uart_poll_out(dev, str[i]);
}
static int log_out(int c, void *unused)
{
uart_poll_out(monitor_dev, c);
return 0;
}
