usart.c

Go to the documentation of this file.

/*
 * SPDX-License-Identifier: GPL-3.0-only
 * This file is part of Lazuli.
 */
 
#include <stdint.h>
#include <stdio.h>
 
#include <Lazuli/common.h>
#include <Lazuli/config.h>
#include <Lazuli/serial.h>
#include <Lazuli/sys/arch/AVR/usart.h>
#include <Lazuli/sys/arch/arch.h>
#include <Lazuli/sys/compiler.h>
#include <Lazuli/sys/kernel.h>
 
static Usart * const usart = (Usart*)&UCSR0A;
 
static enum Lz_SerialSpeed currentSerialSpeed;
 
int
putchar(int c)
{
  const unsigned char value = (unsigned char)c;
 
  while (!(usart->ucsr0a & UCSR0A_UDRE0));
 
  usart->udr0 = value;
 
  return value;
}
 
int
puts(const char * s)
{
  const char newLine[] = LZ_CONFIG_SERIAL_NEWLINE;
  uint8_t i;
 
  if (NULL == s) {
    return EOF;
  }
 
  while ('\0' != *s) {
    putchar(*s);
    ++s;
  }
 
  for (i = 0; i < sizeof(newLine) - 1; ++i) {
    putchar(newLine[i]);
  }
 
  return 1;
}
 
static enum Lz_SerialEnableFlags
GetEnablingStatus(void)
{
  enum Lz_SerialEnableFlags flags = LZ_SERIAL_DISABLE_ALL;
 
  if (usart->ucsr0b & UCSR0B_TXEN0) {
    flags |= LZ_SERIAL_ENABLE_TRANSMIT;
  }
 
  if (usart->ucsr0b & UCSR0B_RXEN0) {
    flags |= LZ_SERIAL_ENABLE_RECEIVE;
  }
 
  return flags;
}
 
static enum Lz_SerialStopBits
GetStopBits(void)
{
  if (usart->ucsr0c & UCSR0C_USBS0) {
    return LZ_SERIAL_STOP_BITS_2;
  }
 
  return LZ_SERIAL_STOP_BITS_1;
}
 
static enum Lz_SerialParityBit
GetParityBit(void)
{
  if (usart->ucsr0c & UCSR0C_UPM01) {
    if (usart->ucsr0c & UCSR0C_UPM00) {
      return LZ_SERIAL_PARITY_ODD;
    }
 
    return LZ_SERIAL_PARITY_EVEN;
  }
 
  if (usart->ucsr0c & UCSR0C_UPM00) {
    Kernel_Panic();
  }
 
  return LZ_SERIAL_PARITY_NONE;
}
 
static enum Lz_SerialSize
GetSize(void)
{
  if (usart->ucsr0b & UCSR0B_UCSZ02) {
    Kernel_Panic();
  }
 
  if (usart->ucsr0c & UCSR0C_UCSZ01) {
    if (usart->ucsr0c & UCSR0C_UCSZ00) {
      return LZ_SERIAL_SIZE_8;
    }
 
    return LZ_SERIAL_SIZE_7;
  }
 
  if (usart->ucsr0c & UCSR0C_UCSZ00) {
    return LZ_SERIAL_SIZE_6;
  }
 
  return LZ_SERIAL_SIZE_5;
}
 
static void
SetEnablingStatus(const enum Lz_SerialEnableFlags flags)
{
  if (flags & LZ_SERIAL_ENABLE_TRANSMIT) {
    usart->ucsr0b |= UCSR0B_TXEN0;
  } else {
    usart->ucsr0b &= ~UCSR0B_TXEN0;
  }
 
  if (flags & LZ_SERIAL_ENABLE_RECEIVE) {
    usart->ucsr0b |= UCSR0B_RXEN0;
  } else {
    usart->ucsr0b &= ~UCSR0B_RXEN0;
  }
}
 
static void
SetStopBits1(void)
{
  usart->ucsr0c &= ~UCSR0C_USBS0;
}
 
static void
SetStopBits2(void)
{
  usart->ucsr0c |= UCSR0C_USBS0;
}
 
PROGMEM static
void (* const setStopBits[])(void) = {
  SetStopBits1, 
  SetStopBits2  
};
 
STATIC_ASSERT
(
 ELEMENTS_COUNT(setStopBits) == __LZ_SERIAL_STOP_BITS_ENUM_END,
 all_entries_of_enum_Lz_SerialStopBits_must_be_set_in_setStopBits
);
static void
SetStopBits(const enum Lz_SerialStopBits stopBits)
{
  void (*jump)(void);
 
  if (LZ_CONFIG_CHECK_WRONG_ENUM_ENTRIES_IN_SERIAL) {
    if (stopBits <= __LZ_SERIAL_STOP_BITS_ENUM_BEGIN ||
        stopBits >= __LZ_SERIAL_STOP_BITS_ENUM_END) {
      Kernel_Panic();
    }
  }
 
  jump = Arch_LoadFunctionPointerFromProgmem(&setStopBits[stopBits]);
  jump();
}
 
static void
SetParityBitNone(void)
{
  usart->ucsr0c &= ~(UCSR0C_UPM01 | UCSR0C_UPM00);
}
 
static void
SetParityBitEven(void)
{
  usart->ucsr0c |= UCSR0C_UPM01;
  usart->ucsr0c &= ~UCSR0C_UPM00;
}
 
static void
SetParityBitOdd(void)
{
  usart->ucsr0c |= (UCSR0C_UPM01 | UCSR0C_UPM00);
}
 
PROGMEM static
void (* const setParityBit[])(void) = {
  SetParityBitNone, 
  SetParityBitEven, 
  SetParityBitOdd   
};
 
STATIC_ASSERT
(
 ELEMENTS_COUNT(setParityBit) == __LZ_SERIAL_PARITY_BIT_ENUM_END,
 all_entries_of_enum_Lz_SerialParityBit_must_be_set_in_setParityBit
);
static void
SetParityBit(const enum Lz_SerialParityBit parityBit)
{
  void (*jump)(void);
 
  if (LZ_CONFIG_CHECK_WRONG_ENUM_ENTRIES_IN_SERIAL) {
    if (parityBit <= __LZ_SERIAL_PARITY_BIT_ENUM_BEGIN ||
        parityBit >= __LZ_SERIAL_PARITY_BIT_ENUM_END) {
      Kernel_Panic();
    }
  }
 
  jump = Arch_LoadFunctionPointerFromProgmem(&setParityBit[parityBit]);
  jump();
}
 
static void
SetSize5(void)
{
  usart->ucsr0b &= ~UCSR0B_UCSZ02;
  usart->ucsr0c &= ~(UCSR0C_UCSZ01 | UCSR0C_UCSZ00);
}
 
static void
SetSize6(void)
{
  usart->ucsr0b &= ~UCSR0B_UCSZ02;
  usart->ucsr0c &= ~UCSR0C_UCSZ01;
  usart->ucsr0c |= UCSR0C_UCSZ00;
}
 
static void
SetSize7(void)
{
  usart->ucsr0b &= ~UCSR0B_UCSZ02;
  usart->ucsr0c |= UCSR0C_UCSZ01;
  usart->ucsr0c &= ~UCSR0C_UCSZ00;
}
 
static void
SetSize8(void)
{
  usart->ucsr0b &= ~UCSR0B_UCSZ02;
  usart->ucsr0c |= (UCSR0C_UCSZ01 | UCSR0C_UCSZ00);
}
 
PROGMEM static
void (* const setSize[])(void) = {
  SetSize5, 
  SetSize6, 
  SetSize7, 
  SetSize8  
};
 
STATIC_ASSERT
(
 ELEMENTS_COUNT(setSize) == __LZ_SERIAL_SIZE_ENUM_END,
 all_entries_of_enum_Lz_SerialSize_must_be_set_in_setSize
);
static void
SetSize(const enum Lz_SerialSize size)
{
  void (* jump)(void);
 
  if (LZ_CONFIG_CHECK_WRONG_ENUM_ENTRIES_IN_SERIAL) {
    if (size <= __LZ_SERIAL_SIZE_ENUM_BEGIN ||
        size >= __LZ_SERIAL_SIZE_ENUM_END) {
      Kernel_Panic();
    }
  }
 
  jump = Arch_LoadFunctionPointerFromProgmem(&setSize[size]);
  jump();
}
 
PROGMEM static const
uint16_t serialSpeedRegisterValue[] = {
  (uint16_t)416, 
  (uint16_t)207, 
  (uint16_t)103, 
  (uint16_t)51   
};
 
STATIC_ASSERT
(
 ELEMENTS_COUNT(serialSpeedRegisterValue) == __LZ_SERIAL_SPEED_ENUM_END,
 all_entries_of_enum_Lz_SerialSpeed_must_be_set_in_serialSpeedRegisterValue
);
static void
SetSpeed(const enum Lz_SerialSpeed speed)
{
  uint16_t registerValue;
 
  if (LZ_CONFIG_CHECK_WRONG_ENUM_ENTRIES_IN_SERIAL) {
    if (speed <= __LZ_SERIAL_SPEED_ENUM_BEGIN ||
        speed >= __LZ_SERIAL_SPEED_ENUM_END) {
      Kernel_Panic();
    }
  }
 
  registerValue = Arch_LoadU16FromProgmem(&serialSpeedRegisterValue[speed]);
 
  usart->ubrr0l = LO8(registerValue);
  usart->ubrr0h = HI8(registerValue);
 
  currentSerialSpeed = speed;
}
 
void
Arch_GetSerialConfiguration(Lz_SerialConfiguration * const configuration)
{
  configuration->enableFlags = GetEnablingStatus();
  configuration->stopBits = GetStopBits();
  configuration->parityBit = GetParityBit();
  configuration->size = GetSize();
  configuration->speed = currentSerialSpeed;
}
 
void
Arch_SetSerialConfiguration(const Lz_SerialConfiguration * const configuration)
{
  InterruptsStatus interruptsStatus;
 
  /* Wait all receive and transmit operations has completed */
  /* TODO: This one doesn't work as expected */
  /* while (!(usart->ucsr0a & UCSR0A_TXC0) || (usart->ucsr0a & UCSR0A_RXC0)); */
 
  /*
   * From the ATmega328p datasheet:
   * "For interrupt driven USART operation, the Global Interrupt Flag should be
   * cleared (and interrupts globally disabled) when doing the initialization."
   */
  if (LZ_CONFIG_SERIAL_USE_INTERRUPTS) {
    interruptsStatus = Arch_DisableInterruptsGetStatus();
  }
 
  SetEnablingStatus(configuration->enableFlags);
  SetStopBits(configuration->stopBits);
  SetParityBit(configuration->parityBit);
  SetSize(configuration->size);
  SetSpeed(configuration->speed);
 
  if (LZ_CONFIG_SERIAL_USE_INTERRUPTS) {
    Arch_RestoreInterruptsStatus(interruptsStatus);
  }
}
 
void
Arch_InitSerial(void)
{
  const Lz_SerialConfiguration serialConfiguration = {
    LZ_SERIAL_DISABLE_ALL, 
    LZ_SERIAL_STOP_BITS_1, 
    LZ_SERIAL_PARITY_NONE, 
    LZ_SERIAL_SIZE_8,      
    LZ_SERIAL_SPEED_4800   
  };
 
  Arch_SetSerialConfiguration(&serialConfiguration);
 
  /* Set USART to asynchronous */
  CLEAR_BITS(usart->ucsr0c, uint8_t, UCSR0C_UMSEL01 | UCSR0C_UMSEL00);
}