/* SPDX-License-Identifier: BSD-2-Clause */
/*
* Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de)
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stm32h7/hal.h>
#include <bsp.h>
#include <bsp/irq.h>
#include <bsp/fatal.h>
#include <rtems/console.h>
#include <inttypes.h>
#include <stdio.h>
#include <unistd.h>
static stm32h7_uart_context * const stm32h7_uart_instances[] = {
#ifdef STM32H7_CONSOLE_ENABLE_USART1
&stm32h7_usart1_instance,
#endif
#ifdef STM32H7_CONSOLE_ENABLE_USART2
&stm32h7_usart2_instance,
#endif
#ifdef STM32H7_CONSOLE_ENABLE_USART3
&stm32h7_usart3_instance,
#endif
#ifdef STM32H7_CONSOLE_ENABLE_UART4
&stm32h7_uart4_instance,
#endif
#ifdef STM32H7_CONSOLE_ENABLE_UART5
&stm32h7_uart5_instance,
#endif
#ifdef STM32H7_CONSOLE_ENABLE_USART6
&stm32h7_usart6_instance,
#endif
#ifdef STM32H7_CONSOLE_ENABLE_UART7
&stm32h7_uart7_instance,
#endif
#ifdef STM32H7_CONSOLE_ENABLE_UART8
&stm32h7_uart8_instance,
#endif
#if defined(STM32H7_CONSOLE_ENABLE_UART9) && defined(UART9)
&stm32h7_uart9_instance,
#endif
#if defined(STM32H7_CONSOLE_ENABLE_USART10) && defined(USART10)
&stm32h7_usart10_instance
#endif
};
static bool stm32h7_uart_set_attributes(
rtems_termios_device_context *base,
const struct termios *term
)
{
stm32h7_uart_context *ctx;
uint32_t previous_baud;
uint32_t previous_stop_bits;
uint32_t previous_parity;
uint32_t previous_mode;
HAL_StatusTypeDef status;
if ((term->c_cflag & CSIZE) != CS8) {
return false;
}
ctx = stm32h7_uart_get_context(base);
previous_baud = ctx->uart.Init.BaudRate;
ctx->uart.Init.BaudRate = rtems_termios_baud_to_number(term->c_ospeed);
previous_stop_bits = ctx->uart.Init.StopBits;
if ((term->c_cflag & CSTOPB) != 0) {
ctx->uart.Init.StopBits = UART_STOPBITS_2;
} else {
ctx->uart.Init.StopBits = UART_STOPBITS_1;
}
previous_parity = ctx->uart.Init.Parity;
if ((term->c_cflag & PARENB) != 0) {
if ((term->c_cflag & PARODD) != 0) {
ctx->uart.Init.Parity = UART_PARITY_ODD;
} else {
ctx->uart.Init.Parity = UART_PARITY_EVEN;
}
} else {
ctx->uart.Init.Parity = UART_PARITY_NONE;
}
previous_mode = ctx->uart.Init.Mode;
if ((term->c_cflag & CREAD) != 0) {
ctx->uart.Init.Mode = UART_MODE_TX_RX;
} else {
ctx->uart.Init.Mode = UART_MODE_RX;
}
status = UART_SetConfig(&ctx->uart);
if (status != HAL_OK) {
ctx->uart.Init.BaudRate = previous_baud;
ctx->uart.Init.StopBits = previous_stop_bits;
ctx->uart.Init.Parity = previous_parity;
ctx->uart.Init.Mode = previous_mode;
return false;
}
return true;
}
#ifdef BSP_CONSOLE_USE_INTERRUPTS
static void stm32h7_uart_interrupt(void *arg)
{
rtems_termios_tty *tty;
rtems_termios_device_context *base;
stm32h7_uart_context *ctx;
USART_TypeDef *regs;
uint32_t isr;
tty = arg;
base = rtems_termios_get_device_context(tty);
ctx = stm32h7_uart_get_context(base);
regs = ctx->uart.Instance;
isr = regs->ISR;
while ((isr & USART_ISR_RXNE_RXFNE) != 0) {
char c;
c = (uint8_t) regs->RDR;
rtems_termios_enqueue_raw_characters(tty, &c, 1);
isr = regs->ISR;
}
if (ctx->transmitting && (isr & USART_ISR_TXE_TXFNF) != 0) {
rtems_termios_dequeue_characters(tty, 1);
}
regs->ICR = USART_ICR_ORECF;
}
#endif
static bool stm32h7_uart_first_open(
rtems_termios_tty *tty,
rtems_termios_device_context *base,
struct termios *term,
rtems_libio_open_close_args_t *args
)
{
stm32h7_uart_context *ctx;
UART_HandleTypeDef *uart;
#ifdef BSP_CONSOLE_USE_INTERRUPTS
rtems_status_code sc;
#endif
ctx = stm32h7_uart_get_context(base);
uart = &ctx->uart;
rtems_termios_set_initial_baud(tty, BSP_CONSOLE_BAUD);
(void) HAL_UART_Init(uart);
(void) HAL_UARTEx_SetTxFifoThreshold(uart, UART_TXFIFO_THRESHOLD_1_8);
(void) HAL_UARTEx_SetRxFifoThreshold(uart, UART_RXFIFO_THRESHOLD_1_8);
(void) HAL_UARTEx_EnableFifoMode(uart);
#ifdef BSP_CONSOLE_USE_INTERRUPTS
sc = rtems_interrupt_handler_install(
ctx->config->irq,
"UART",
RTEMS_INTERRUPT_SHARED,
stm32h7_uart_interrupt,
tty
);
if (sc != RTEMS_SUCCESSFUL) {
return false;
}
ctx->uart.Instance->CR1 |= USART_CR1_RXNEIE_RXFNEIE;
#endif
stm32h7_uart_set_attributes(base, term);
return true;
}
static void stm32h7_uart_last_close(
rtems_termios_tty *tty,
rtems_termios_device_context *base,
rtems_libio_open_close_args_t *args
)
{
#ifdef BSP_CONSOLE_USE_INTERRUPTS
stm32h7_uart_context *ctx;
ctx = stm32h7_uart_get_context(base);
(void) rtems_interrupt_handler_remove(
ctx->config->irq,
stm32h7_uart_interrupt,
tty
);
#endif
}
static void stm32h7_uart_write(
rtems_termios_device_context *base,
const char *buf,
size_t len
)
{
#ifdef BSP_CONSOLE_USE_INTERRUPTS
stm32h7_uart_context *ctx;
USART_TypeDef *regs;
ctx = stm32h7_uart_get_context(base);
regs = ctx->uart.Instance;
if (len > 0) {
ctx->transmitting = true;
regs->TDR = (uint8_t) buf[0];
regs->CR1 |= USART_CR1_TXEIE_TXFNFIE;
} else {
ctx->transmitting = false;
regs->CR1 &= ~USART_CR1_TXEIE_TXFNFIE;
}
#else
size_t i;
for (i = 0; i < len; ++i) {
stm32h7_uart_polled_write(base, buf[i]);
}
#endif
}
static const rtems_termios_device_handler stm32h7_uart_handler = {
.first_open = stm32h7_uart_first_open,
.last_close = stm32h7_uart_last_close,
.write = stm32h7_uart_write,
.set_attributes = stm32h7_uart_set_attributes,
#ifdef BSP_CONSOLE_USE_INTERRUPTS
.mode = TERMIOS_IRQ_DRIVEN
#else
.poll_read = stm32h7_uart_polled_read,
.mode = TERMIOS_POLLED
#endif
};
rtems_status_code console_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
size_t i;
rtems_termios_initialize();
for (i = 0; i < RTEMS_ARRAY_SIZE(stm32h7_uart_instances); ++i) {
stm32h7_uart_context *ctx;
char path[sizeof("/dev/ttySXXX")];
ctx = stm32h7_uart_instances[i];
snprintf(path, sizeof(path), "/dev/ttyS%" PRIu8, ctx->config->device_index);
rtems_termios_device_install(
path,
&stm32h7_uart_handler,
NULL,
&ctx->device
);
if (ctx == &STM32H7_PRINTK_INSTANCE) {
link(path, CONSOLE_DEVICE_NAME);
}
}
return RTEMS_SUCCESSFUL;
}
