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; }