neorv32_uart.h

Go to the documentation of this file.

// ================================================================================ //
// The NEORV32 RISC-V Processor - https://github.com/stnolting/neorv32              //
// Copyright (c) NEORV32 contributors.                                              //
// Copyright (c) Stephan Nolting. All rights reserved.                              //
// Licensed under the BSD-3-Clause license, see LICENSE for details.                //
// SPDX-License-Identifier: BSD-3-Clause                                            //
// ================================================================================ //

 
#ifndef NEORV32_UART_H
#define NEORV32_UART_H
 
#include <neorv32.h>
#include <stdint.h>
#include <stdarg.h>
 
/**********************************************************************/
typedef volatile struct __attribute__((packed,aligned(4))) {
  uint32_t       CTRL; 
  uint32_t       BAUD; 
  uint32_t       DATA; 
  const uint32_t _rsv; 
} neorv32_uart_t;

#define NEORV32_UART0 ((neorv32_uart_t*) (NEORV32_UART0_BASE))

#define NEORV32_UART1 ((neorv32_uart_t*) (NEORV32_UART1_BASE))

enum NEORV32_UART_CTRL_enum {
  UART_CTRL_RX_EN       =  0, 
  UART_CTRL_TX_EN       =  1, 
  UART_CTRL_TX_SIM_EN   =  2, 
  UART_CTRL_RTS_EN      =  3, 
  UART_CTRL_CTS_EN      =  4, 
 
  UART_CTRL_RX_EMPTY    =  8, 
  UART_CTRL_RX_HALF     =  9, 
  UART_CTRL_RX_FULL     = 10, 
  UART_CTRL_RX_OVER     = 11, 
  UART_CTRL_TX_EMPTY    = 12, 
  UART_CTRL_TX_HALF     = 13, 
  UART_CTRL_TX_FULL     = 14, 
  UART_CTRL_TX_BUSY     = 15, 
 
  UART_CTRL_RX_IRQ_SEL0 = 16, 
  UART_CTRL_RX_IRQ_SEL1 = 17, 
  UART_CTRL_TX_IRQ_SEL0 = 18, 
  UART_CTRL_TX_IRQ_SEL1 = 19, 
  UART_CTRL_RX_IRQ_PEND = 20, 
  UART_CTRL_TX_IRQ_PEND = 21, 
 
  UART_CTRL_RX_FIFO_LSB = 24, 
  UART_CTRL_RX_FIFO_MSB = 27, 
  UART_CTRL_TX_FIFO_LSB = 28, 
  UART_CTRL_TX_FIFO_MSB = 31  
};

enum NEORV32_UART_RX_IRQ_SEL_enum {
  UART_RX_IRQ_NONE  = 0, 
  UART_RX_IRQ_AVAIL = 1, 
  UART_RX_IRQ_HALF  = 2, 
  UART_RX_IRQ_FULL  = 3  
};

enum NEORV32_UART_TX_IRQ_SEL_enum {
  UART_TX_IRQ_NONE  = 0, 
  UART_TX_IRQ_IDLE  = 1, 
  UART_TX_IRQ_NHALF = 2, 
  UART_TX_IRQ_NFULL = 3  
};

 
/**********************************************************************/
int  neorv32_uart_available(neorv32_uart_t *uartx);
void neorv32_uart_setup(neorv32_uart_t *uartx, uint32_t baud, int rx_irq, int tx_irq);
void neorv32_uart_putc(neorv32_uart_t *uartx, char c);
char neorv32_uart_getc(neorv32_uart_t *uartx);
void neorv32_uart_puts(neorv32_uart_t *uartx, const char *s);
void neorv32_uart_vprintf(neorv32_uart_t *uartx, const char *format, va_list args);
void neorv32_uart_printf(neorv32_uart_t *uartx, const char *format, ...);
int  neorv32_uart_scan(neorv32_uart_t *uartx, char *buffer, int max_size, int echo);
 
 
/**********************************************************************/
static inline int __attribute__((always_inline)) neorv32_uart_rx_fifo_depth(neorv32_uart_t *uartx) {
  return (int)(1U << ((uartx->CTRL >> UART_CTRL_RX_FIFO_LSB) & 0x0fU));
}
 
/**********************************************************************/
static inline int __attribute__((always_inline)) neorv32_uart_tx_fifo_depth(neorv32_uart_t *uartx) {
  return (int)(1U <<((uartx->CTRL >> UART_CTRL_TX_FIFO_LSB) & 0x0fU));
}
 
/**********************************************************************/
static inline int __attribute__((always_inline)) neorv32_uart_rx_irq(neorv32_uart_t *uartx) {
  return (int)((uartx->CTRL >> UART_CTRL_RX_IRQ_PEND) & 1U);
}
 
/**********************************************************************/
static inline int __attribute__((always_inline)) neorv32_uart_tx_irq(neorv32_uart_t *uartx) {
  return (int)((uartx->CTRL >> UART_CTRL_TX_IRQ_PEND) & 1U);
}
 
/**********************************************************************/
static inline int __attribute__((always_inline)) neorv32_uart_rx_avail(neorv32_uart_t *uartx) {
  return (int)((~uartx->CTRL >> UART_CTRL_RX_EMPTY) & 1U);
}
 
/**********************************************************************/
static inline int __attribute__((always_inline)) neorv32_uart_tx_full(neorv32_uart_t *uartx) {
  return (int)((uartx->CTRL >> UART_CTRL_TX_FULL) & 1U);
}
 
/**********************************************************************/
static inline int __attribute__((always_inline)) neorv32_uart_tx_busy(neorv32_uart_t *uartx) {
  return (int)((uartx->CTRL >> UART_CTRL_TX_BUSY) & 1U);
}
 
/**********************************************************************/
static inline void __attribute__((always_inline)) neorv32_uart_tx_put(neorv32_uart_t *uartx, char data) {
  uartx->DATA = (uint32_t)data;
}
 
/**********************************************************************/
static inline char __attribute__((always_inline)) neorv32_uart_rx_get(neorv32_uart_t *uartx) {
  return (char)(uartx->DATA);
}
 
/**********************************************************************/
static inline int __attribute__((always_inline)) neorv32_uart_rx_overflow(neorv32_uart_t *uartx) {
  return (int)((uartx->CTRL >> UART_CTRL_RX_OVER) & 1U);
}
 
/**********************************************************************/
#define neorv32_uart0_available()                  neorv32_uart_available(NEORV32_UART0)
#define neorv32_uart0_setup(baud, rx_irq, tx_irq)  neorv32_uart_setup(NEORV32_UART0, baud, rx_irq, tx_irq)
#define neorv32_uart0_putc(c)                      neorv32_uart_putc(NEORV32_UART0, c)
#define neorv32_uart0_getc()                       neorv32_uart_getc(NEORV32_UART0)
#define neorv32_uart0_puts(s)                      neorv32_uart_puts(NEORV32_UART0, s)
#define neorv32_uart0_printf(...)                  neorv32_uart_printf(NEORV32_UART0, __VA_ARGS__)
#define neorv32_uart0_scan(buffer, max_size, echo) neorv32_uart_scan(NEORV32_UART0, buffer, max_size, echo)
 
#define neorv32_uart1_available()                  neorv32_uart_available(NEORV32_UART1)
#define neorv32_uart1_setup(baud, rx_irq, tx_irq)  neorv32_uart_setup(NEORV32_UART1, baud, rx_irq, tx_irq)
#define neorv32_uart1_putc(c)                      neorv32_uart_putc(NEORV32_UART1, c)
#define neorv32_uart1_getc()                       neorv32_uart_getc(NEORV32_UART1)
#define neorv32_uart1_puts(s)                      neorv32_uart_puts(NEORV32_UART1, s)
#define neorv32_uart1_printf(...)                  neorv32_uart_printf(NEORV32_UART1, __VA_ARGS__)
#define neorv32_uart1_scan(buffer, max_size, echo) neorv32_uart_scan(NEORV32_UART1, buffer, max_size, echo)
 
#endif // NEORV32_UART_H