153 lines
4.6 KiB
C++
153 lines
4.6 KiB
C++
#pragma once
|
|
|
|
#include <cstdint>
|
|
|
|
#include <avr/interrupt.h>
|
|
#include <avr/io.h>
|
|
#include <avr/sfr_defs.h>
|
|
|
|
#include "config.hpp"
|
|
#include "hardware.hpp"
|
|
|
|
namespace uart {
|
|
|
|
namespace detail {
|
|
|
|
#if defined(__AVR_ATmega1284P__) || defined(__AVR_ATmega328P__)
|
|
|
|
/*
|
|
The following works in avr-gcc 5.4.0, but is not legal C++, because ptr's are not legal constexpr's:
|
|
constexpr auto *foo = ptr;
|
|
|
|
Workaround is to store the the address of the ptr in a uintptr_t and reinterpret_cast it at call site.
|
|
The _SFR_ADDR macro in sfr_defs.h would give the address, but it does that by taking the address of the dereferenced
|
|
pointer and casts it to uint16_t, which is still not a legal constexpr.
|
|
The workaround therefore is to disable the pointer cast and dereference macro _MMIO_BYTE temporarily.
|
|
*/
|
|
|
|
#pragma push_macro("_MMIO_BYTE")
|
|
#undef _MMIO_BYTE
|
|
#define _MMIO_BYTE
|
|
|
|
struct Registers0 {
|
|
static constexpr std::uintptr_t IO_REG_ADDR = UDR0;
|
|
static constexpr std::uintptr_t CTRL_STAT_REG_A_ADDR = UCSR0A;
|
|
static constexpr std::uintptr_t CTRL_STAT_REG_B_ADDR = UCSR0B;
|
|
static constexpr std::uintptr_t CTRL_STAT_REG_C_ADDR = UCSR0C;
|
|
static constexpr std::uintptr_t BAUD_REG_L_ADDR = UBRR0L;
|
|
static constexpr std::uintptr_t BAUD_REG_H_ADDR = UBRR0H;
|
|
};
|
|
|
|
#pragma pop_macro("_MMIO_BYTE")
|
|
|
|
enum class ControlFlagsA0 {
|
|
MULTI_PROC_COMM_MODE = MPCM0,
|
|
SPEED_2X = U2X0,
|
|
PARITY_ERROR = UPE0,
|
|
DATA_OVER_RUN = DOR0,
|
|
FRAME_ERROR = FE0,
|
|
DATA_REG_EMPTY = UDRE0,
|
|
TRANSMIT_COMPLETE = TXC0,
|
|
RECEIVE_COMPLETE = RXC0,
|
|
};
|
|
|
|
enum class ControlFlagsB0 {
|
|
TX_DATA_BIT_8 = TXB80,
|
|
RX_DATA_BIT_8 = RXB80,
|
|
CHAR_SIZE_2 = UCSZ02,
|
|
TX_ENABLE = TXEN0,
|
|
RX_ENABLE = RXEN0,
|
|
DATA_REG_EMPTY_INT_ENABLE = UDRIE0,
|
|
TX_INT_ENABLE = TXCIE0,
|
|
RX_INT_ENABLE = RXCIE0,
|
|
};
|
|
|
|
enum class ControlFlagsC0 {
|
|
CLK_POLARITY = UCPOL0,
|
|
CHAR_SIZE_0 = UCSZ00,
|
|
CHAR_SIZE_1 = UCSZ01,
|
|
STOP_BIT_SEL = USBS0,
|
|
PARITY_MODE_0 = UPM00,
|
|
PARITY_MODE_1 = UPM01,
|
|
MODE_SEL_0 = UMSEL00,
|
|
MODE_SEL_1 = UMSEL01,
|
|
};
|
|
|
|
// clang-format off
|
|
constexpr int operator<<(const int &lhs, const ControlFlagsA0 &rhs) { return lhs << static_cast<int>(rhs); }
|
|
constexpr int operator<<(const int &lhs, const ControlFlagsB0 &rhs) { return lhs << static_cast<int>(rhs); }
|
|
constexpr int operator<<(const int &lhs, const ControlFlagsC0 &rhs) { return lhs << static_cast<int>(rhs); }
|
|
// clang-format on
|
|
|
|
#if defined(__AVR_ATmega328P__)
|
|
#define USART0_RX_vect USART_RX_vect
|
|
#define USART0_UDRE_vect USART_UDRE_vect
|
|
#endif
|
|
|
|
#else
|
|
#error "This chip is not supported"
|
|
#endif
|
|
|
|
} // namespace detail
|
|
|
|
template <class cfg = Config<>, Driven driven = Driven::INTERRUPT, Mode mode = Mode::ASYNCHRONOUS>
|
|
class Hardware0 : public detail::BlockingHardware<detail::Registers0, detail::ControlFlagsA0, detail::ControlFlagsB0,
|
|
detail::ControlFlagsC0, cfg, mode> {
|
|
};
|
|
|
|
template <class cfg, Mode mode>
|
|
class Hardware0<cfg, Driven::INTERRUPT, mode>
|
|
: public detail::InterruptHardware<detail::Registers0, detail::ControlFlagsA0, detail::ControlFlagsB0,
|
|
detail::ControlFlagsC0, cfg, mode> {
|
|
public:
|
|
[[gnu::always_inline]] static void init()
|
|
{
|
|
HardwareImpl::init();
|
|
sei();
|
|
}
|
|
|
|
private:
|
|
using HardwareImpl = detail::Hardware<detail::Registers0, detail::ControlFlagsA0, detail::ControlFlagsB0,
|
|
detail::ControlFlagsC0, cfg, Driven::INTERRUPT, mode>;
|
|
|
|
using InterruptHardwareImpl = detail::InterruptHardware<detail::Registers0, detail::ControlFlagsA0,
|
|
detail::ControlFlagsB0, detail::ControlFlagsC0, cfg, mode>;
|
|
|
|
// Must be friends with Uart interface to call these private handlers
|
|
template <class Driver>
|
|
friend class Uart;
|
|
|
|
[[gnu::always_inline]] static void rxIntHandler()
|
|
{
|
|
InterruptHardwareImpl::rxIntHandler();
|
|
}
|
|
|
|
[[gnu::always_inline]] static void dataRegEmptyIntHandler()
|
|
{
|
|
InterruptHardwareImpl::dataRegEmptyIntHandler();
|
|
}
|
|
};
|
|
|
|
} // namespace uart
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
// Forward declare interrupt functions to allow adding them as friends
|
|
extern "C" {
|
|
void USART0_RX_vect() __attribute__((signal));
|
|
void USART0_UDRE_vect() __attribute__((signal));
|
|
}
|
|
|
|
// clang-format off
|
|
#define REGISTER_UART0_INT_VECTORS(uart_type) \
|
|
ISR(USART0_RX_vect) \
|
|
{ \
|
|
uart_type::rxIntHandler(); \
|
|
} \
|
|
ISR(USART0_UDRE_vect) \
|
|
{ \
|
|
uart_type::dataRegEmptyIntHandler(); \
|
|
} \
|
|
struct _##uart_type {}
|
|
// clang-format on
|