startup-efm32.c

#include <stdio.h>
#include <stdint.h>
#include <em_device.h>
#include <core_cm3.h>
#include <em_mpu.h>
#include <em_cmu.h>
#include <em_dbg.h>
#include <gpiointerrupt.h>
#include <core/clk.h>
#include <contiki-conf.h>

extern uint8_t __bss_start__[];
extern uint8_t __bss_end__[];
extern uint32_t __isr_vector[];

void _start(void) /*__attribute__((naked))*/;

extern int main(void);

static void
clear_bss(void)
{
  uint8_t *m = __bss_start__;
  while(m < __bss_end__) {
    *m++ = 0;
  }
}

static void
enable_fault_exceptions(void)
{
#if 0
  MPU_RegionInit_TypeDef flashInit       = MPU_INIT_FLASH_DEFAULT;
  MPU_RegionInit_TypeDef sramInit        = MPU_INIT_SRAM_DEFAULT;
  MPU_RegionInit_TypeDef peripheralInit  = MPU_INIT_PERIPHERAL_DEFAULT;

  MPU_Disable();
  /* TODO: Configure regions */
  MPU_ConfigureRegion(&flashInit);
  MPU_ConfigureRegion(&sramInit);
  MPU_ConfigureRegion(&peripheralInit);
  MPU_Enable(MPU_CTRL_PRIVDEFENA);

  SCB->SHCSR |= (SCB_SHCSR_MEMFAULTENA_Msk | SCB_SHCSR_BUSFAULTENA_Msk
     | SCB_SHCSR_USGFAULTENA_Msk);
#endif
}

static void
select_clocks()
{
  /* Starting LFRCO and waiting until it is stable */
  CMU_OscillatorEnable(cmuOsc_LFRCO, true, true);
  CMU_OscillatorEnable(cmuOsc_LFXO, false, false);

  /* Routing the LFRCO clock to the LF doamains A and B */
  CMU_ClockSelectSet(cmuClock_LFA, cmuSelect_LFRCO);
  CMU_ClockSelectSet(cmuClock_LFB, cmuSelect_LFRCO);
  CMU_ClockEnable(cmuClock_CORELE, true);

  /* Enable and select 1 MHz HF clock. Application will
   * change it later by platform framework.*/
  CMU_ClockSelectSet(cmuClock_HF, cmuSelect_HFRCO);
  CMU_HFRCOBandSet(cmuHFRCOBand_1MHz);
}

#ifdef EFM32_DEBUG_SWO
static void setupSWO(void)
{
  /* Enable GPIO Clock. */
  CMU->HFPERCLKEN0 |= CMU_HFPERCLKEN0_GPIO;
  /* Enable Serial wire output pin */
  GPIO->ROUTE |= GPIO_ROUTE_SWOPEN;
#if defined(_EFM32_GIANT_FAMILY) || defined(_EFM32_WONDER_FAMILY) || defined(_EFM32_LEOPARD_FAMILY)
  /* Set location 0 */
  GPIO->ROUTE = (GPIO->ROUTE & ~(_GPIO_ROUTE_SWLOCATION_MASK)) | GPIO_ROUTE_SWLOCATION_LOC0;

  /* Enable output on pin - GPIO Port F, Pin 2 */
  GPIO->P[5].MODEL &= ~(_GPIO_P_MODEL_MODE2_MASK);
  GPIO->P[5].MODEL |= GPIO_P_MODEL_MODE2_PUSHPULL;
#else
  /* Set location 1 */
  GPIO->ROUTE = (GPIO->ROUTE & ~(_GPIO_ROUTE_SWLOCATION_MASK)) | GPIO_ROUTE_SWLOCATION_LOC1;
  /* Enable output on pin */
  GPIO->P[2].MODEH &= ~(_GPIO_P_MODEH_MODE15_MASK);
  GPIO->P[2].MODEH |= GPIO_P_MODEH_MODE15_PUSHPULL;
#endif
  /* Enable debug clock AUXHFRCO */
  CMU->OSCENCMD = CMU_OSCENCMD_AUXHFRCOEN;

  while(!(CMU->STATUS & CMU_STATUS_AUXHFRCORDY));

  /* Enable trace in core debug */
  CoreDebug->DHCSR |= 1;
  CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;

  /* Enable PC and IRQ sampling output */
  DWT->CTRL = 0x400113FF;
  /* Set TPIU prescaler to 16. */
  TPI->ACPR = 0xf;
  /* Set protocol to NRZ */
  TPI->SPPR = 2;
  /* Unlock ITM and output data */
  ITM->LAR = 0xC5ACCE55;
  ITM->TCR = 0x10009;

  /* Disable GPIO Clock. */
  CMU->HFPERCLKEN0 &= ~CMU_HFPERCLKEN0_GPIO;
}
#endif /* EFM32_DEBUG_SWO */

void __attribute__((naked))
_start(void)
{
  /* Init stack pointer */
  asm (
    "ldr r3, =__isr_vector;"
    "ldr sp, [r3];"
  );

  /* Skip bootloader */
  SCB->VTOR = (uint32_t)__isr_vector;

  /* Setup core interrupt priorities */
  NVIC_SetPriority(PendSV_IRQn, 0xFF);

  clear_bss();
  enable_fault_exceptions();
  select_clocks();

  /* System tick counter is used by uwork */
  CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;
  DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;

#ifdef EFM32_DEBUG_SWO
  if (DBG_Connected())
  {
    setupSWO();
  }
#endif

  GPIOINT_Init();

  main();
  while(1);
}

void
_xassert(const char *file, int lineno)
{
  printf("Assertion failed: file %s, line %d.\n", file, lineno);
  /*
   * loop for a while;
   * call _reset_vector__();
   */
  while(1);
}

void uip_log(char *msg)
{
  printf("UIP: %s\r\n", msg);
}

/* TODO: Implement handlers */
void
NMI_Handler(void)
{
  while(1);
}

void
HardFault_Handler(void)
{
  while(1);
}

void
UsageFault_Handler(void)
{
  while(1);
}

void
MemManage_Handler(void)
{
  while(1);
}

void
BusFault_Handler(void)
{
  while(1);
}