stm32_uart.cpp

#include "stm32_uart.hpp"
 
#ifdef HAL_UART_MODULE_ENABLED
 
using namespace LibXR;
 
STM32UART* STM32UART::map[STM32_UART_NUMBER] = {nullptr};
 
stm32_uart_id_t stm32_uart_get_id(USART_TypeDef* addr)
{
  if (addr == nullptr)
  {  // NOLINT
    return stm32_uart_id_t::STM32_UART_ID_ERROR;
  }
#ifdef USART1
  else if (addr == USART1)  // NOLINT
  {
    return stm32_uart_id_t::STM32_USART1;
  }
#endif
#ifdef USART2
  else if (addr == USART2)  // NOLINT
  {
    return stm32_uart_id_t::STM32_USART2;
  }
#endif
#ifdef USART3
  else if (addr == USART3)  // NOLINT
  {
    return stm32_uart_id_t::STM32_USART3;
  }
#endif
#ifdef USART4
  else if (addr == USART4)  // NOLINT
  {
    return stm32_uart_id_t::STM32_USART4;
  }
#endif
#ifdef USART5
  else if (addr == USART5)  // NOLINT
  {
    return stm32_uart_id_t::STM32_USART5;
  }
#endif
#ifdef USART6
  else if (addr == USART6)  // NOLINT
  {
    return stm32_uart_id_t::STM32_USART6;
  }
#endif
#ifdef USART7
  else if (addr == USART7)  // NOLINT
  {
    return stm32_uart_id_t::STM32_USART7;
  }
#endif
#ifdef USART8
  else if (addr == USART8)  // NOLINT
  {
    return stm32_uart_id_t::STM32_USART8;
  }
#endif
#ifdef USART9
  else if (addr == USART9)  // NOLINT
  {
    return stm32_uart_id_t::STM32_USART9;
  }
#endif
#ifdef USART10
  else if (addr == USART10)  // NOLINT
  {
    return stm32_uart_id_t::STM32_USART10;
  }
#endif
#ifdef USART11
  else if (addr == USART11)  // NOLINT
  {
    return stm32_uart_id_t::STM32_USART11;
  }
#endif
#ifdef USART12
  else if (addr == USART12)  // NOLINT
  {
    return stm32_uart_id_t::STM32_USART12;
  }
#endif
#ifdef USART13
  else if (addr == USART13)  // NOLINT
  {
    return stm32_uart_id_t::STM32_USART13;
  }
#endif
#ifdef UART1
  else if (addr == UART1)  // NOLINT
  {
    return stm32_uart_id_t::STM32_UART1;
  }
#endif
#ifdef UART2
  else if (addr == UART2)  // NOLINT
  {
    return stm32_uart_id_t::STM32_UART2;
  }
#endif
#ifdef UART3
  else if (addr == UART3)  // NOLINT
  {
    return stm32_uart_id_t::STM32_UART3;
  }
#endif
#ifdef UART4
  else if (addr == UART4)  // NOLINT
  {
    return stm32_uart_id_t::STM32_UART4;
  }
#endif
#ifdef UART5
  else if (addr == UART5)  // NOLINT
  {
    return stm32_uart_id_t::STM32_UART5;
  }
#endif
#ifdef UART6
  else if (addr == UART6)  // NOLINT
  {
    return stm32_uart_id_t::STM32_UART6;
  }
#endif
#ifdef UART7
  else if (addr == UART7)  // NOLINT
  {
    return stm32_uart_id_t::STM32_UART7;
  }
#endif
#ifdef UART8
  else if (addr == UART8)  // NOLINT
  {
    return stm32_uart_id_t::STM32_UART8;
  }
#endif
#ifdef UART9
  else if (addr == UART9)  // NOLINT
  {
    return stm32_uart_id_t::STM32_UART9;
  }
#endif
#ifdef UART10
  else if (addr == UART10)  // NOLINT
  {
    return stm32_uart_id_t::STM32_UART10;
  }
#endif
#ifdef UART11
  else if (addr == UART11)  // NOLINT
  {
    return stm32_uart_id_t::STM32_UART11;
  }
#endif
#ifdef UART12
  else if (addr == UART12)  // NOLINT
  {
    return stm32_uart_id_t::STM32_UART12;
  }
#endif
#ifdef UART13
  else if (addr == UART13)  // NOLINT
  {
    return stm32_uart_id_t::STM32_UART13;
  }
#endif
#ifdef LPUART1
  else if (addr == LPUART1)  // NOLINT
  {
    return stm32_uart_id_t::STM32_LPUART1;
  }
#endif
#ifdef LPUART2
  else if (addr == LPUART2)  // NOLINT
  {
    return stm32_uart_id_t::STM32_LPUART2;
  }
#endif
#ifdef LPUART3
  else if (addr == LPUART3)  // NOLINT
  {
    return stm32_uart_id_t::STM32_LPUART3;
  }
#endif
  else
  {
    return stm32_uart_id_t::STM32_UART_ID_ERROR;
  }
}
 
ErrorCode STM32UART::WriteFun(WritePort& port, bool in_isr)
{
  auto* uart = LibXR::ContainerOf(&port, &STM32UART::_write_port);
  return uart->tx_dma_model_.Submit(in_isr);
}
 
ErrorCode STM32UART::ReadFun(ReadPort&, bool) { return ErrorCode::PENDING; }
 
static UART::Configuration STM32_UART_GetConfig(UART_HandleTypeDef* handle)
{
  UART::Parity parity = UART::Parity::NO_PARITY;
  if (handle->Init.Parity == UART_PARITY_EVEN)
  {
    parity = UART::Parity::EVEN;
  }
  else if (handle->Init.Parity == UART_PARITY_ODD)
  {
    parity = UART::Parity::ODD;
  }
 
  return UART::Configuration{
      handle->Init.BaudRate, parity, 8U,
      static_cast<uint8_t>(handle->Init.StopBits == UART_STOPBITS_2 ? 2U : 1U)};
}
 
STM32UART::STM32UART(UART_HandleTypeDef* uart_handle, RawData dma_buff_rx,
                     RawData dma_buff_tx, uint32_t tx_queue_size)
    : UART(&_read_port, &_write_port),
      _read_port(dma_buff_rx.size_),
      _write_port(tx_queue_size, dma_buff_tx.size_ / 2),
      requested_config_(STM32_UART_GetConfig(uart_handle)),
      rx_dma_model_(dma_buff_rx),
      tx_dma_model_(*this, _write_port, dma_buff_tx),
      uart_handle_(uart_handle),
      id_(stm32_uart_get_id(uart_handle_->Instance))
{
  ASSERT(id_ != STM32_UART_ID_ERROR);
 
  map[id_] = this;
 
  if ((uart_handle->Init.Mode & UART_MODE_TX) == UART_MODE_TX)
  {
    ASSERT(uart_handle_->hdmatx != NULL);
    _write_port = WriteFun;
  }
 
  SetRxDMA();
}
 
ErrorCode STM32UART::SetConfig(UART::Configuration config)
{
  if ((config.stop_bits != 1U) && (config.stop_bits != 2U))
  {
    return ErrorCode::ARG_ERR;
  }
  if ((config.parity != UART::Parity::NO_PARITY) &&
      (config.parity != UART::Parity::EVEN) && (config.parity != UART::Parity::ODD))
  {
    return ErrorCode::ARG_ERR;
  }
 
  requested_config_.Store(config);
  tx_dma_model_.RequestConfig(false);
  return ErrorCode::OK;
}
 
bool STM32UART::ApplyPendingConfig(bool in_isr)
{
  if (!rx_config_gate_.TryEnterConfig())
  {
    return false;
  }
 
  UART::Configuration config{};
  (void)requested_config_.LoadLatest(config);
 
  HAL_UART_DeInit(uart_handle_);
  uart_handle_->Init.BaudRate = config.baudrate;
 
  switch (config.parity)
  {
    case UART::Parity::NO_PARITY:
      uart_handle_->Init.Parity = UART_PARITY_NONE;
      uart_handle_->Init.WordLength = UART_WORDLENGTH_8B;
      break;
    case UART::Parity::EVEN:
      uart_handle_->Init.Parity = UART_PARITY_EVEN;
      uart_handle_->Init.WordLength = UART_WORDLENGTH_9B;
      break;
    case UART::Parity::ODD:
      uart_handle_->Init.Parity = UART_PARITY_ODD;
      uart_handle_->Init.WordLength = UART_WORDLENGTH_9B;
      break;
    default:
      DEV_ASSERT_FROM_CALLBACK(false, in_isr);
      return true;
  }
 
  switch (config.stop_bits)
  {
    case 1:
      uart_handle_->Init.StopBits = UART_STOPBITS_1;
      break;
    case 2:
      uart_handle_->Init.StopBits = UART_STOPBITS_2;
      break;
    default:
      DEV_ASSERT_FROM_CALLBACK(false, in_isr);
      return true;
  }
 
  if (HAL_UART_Init(uart_handle_) != HAL_OK)
  {
    DEV_ASSERT_FROM_CALLBACK(false, in_isr);
    return true;
  }
 
  SetRxDMA();
  return true;
}
 
void STM32UART::SetRxDMA()
{
  if ((uart_handle_->Init.Mode & UART_MODE_RX) == UART_MODE_RX)
  {
    ASSERT(uart_handle_->hdmarx != NULL);
 
    rx_dma_model_.Start(*this);
    _read_port = ReadFun;
  }
}
 
// NOLINTNEXTLINE
static inline void STM32_UART_RX_ISR_Handler(UART_HandleTypeDef* uart_handle)
{
  auto uart = STM32UART::map[stm32_uart_get_id(uart_handle->Instance)];
  uart->OnRxDataAvailable(true);
}
 
void STM32UART::OnRxDataAvailable(bool in_isr)
{
  if (!rx_config_gate_.TryEnterRx())
  {
    return;
  }
 
  rx_dma_model_.OnDataAvailable(*this, _read_port, in_isr);
  if (rx_config_gate_.LeaveRx())
  {
    tx_dma_model_.RequestConfig(in_isr);
  }
}
 
// NOLINTNEXTLINE
void STM32_UART_ISR_Handler_TX_CPLT(stm32_uart_id_t id)
{
  auto uart = STM32UART::map[id];
  uart->tx_dma_model_.OnTransferDone(true);
}
 
extern "C" void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef* huart, uint16_t)
{
  STM32_UART_RX_ISR_Handler(huart);
}
 
extern "C" void HAL_UART_TxCpltCallback(UART_HandleTypeDef* huart)
{
  STM32_UART_ISR_Handler_TX_CPLT(stm32_uart_get_id(huart->Instance));
}
 
extern "C" __attribute__((used)) void HAL_UART_ErrorCallback(UART_HandleTypeDef* huart)
{
  auto uart = STM32UART::map[stm32_uart_get_id(huart->Instance)];
  uart->tx_dma_model_.RequestConfig(true);
}
 
extern "C" void HAL_UART_AbortCpltCallback(UART_HandleTypeDef* huart)
{
  auto uart = STM32UART::map[stm32_uart_get_id(huart->Instance)];
  uart->tx_dma_model_.RequestConfig(true);
}
 
bool STM32UART::StartDmaTx(uint8_t* data, size_t size, int)
{
  STM32_CleanDCacheByAddr(data, size);
  return HAL_UART_Transmit_DMA(uart_handle_, data, size) == HAL_OK;
}
 
#endif