platform.c

#include <stdio.h>
#include <string.h>
#include <core/clk.h>
#include <lib/assert.h>
#include <nrf_soc.h>
#include <nrf_nvic.h>
#include <app_error.h>
#include <ble.h>
#include <debug-uart.h>
#include <core/work.h>
#include <ble/ble.h>
#include <toc/toc-app.h>
#include "platform.h"

/* Disable debug spam from the module */
#ifndef NDEBUG
  #define NDEBUG
#endif

/** The macro provides debug print functionality */
#ifdef NDEBUG
  #define PRINTD(FORMAT, args...) do {} while (0)
#else
  #define PRINTD(FORMAT, args...) printf(FORMAT, ##args)
#endif

extern uint32_t __data_start__;

// TODO: HACK!!!
extern void eve_dm_init(void);

// TODO: HACK!!!
extern bool EveBleServiceEnabled;

static void BleWorkCb(struct work_t *Work);

static struct work_t BleWork;

static bool SoftdeviceEnabled;

void SOFTDEVICE_EVT_IRQHandler(void) __attribute__ ((section(".text"),interrupt));

#define SOFTDEVICE_EVT_IRQ        SWI2_EGU2_IRQn
#define SOFTDEVICE_EVT_IRQHandler SWI2_EGU2_IRQHandler

static void softdevice_fault_handler(uint32_t id, uint32_t pc, uint32_t info)
{
  __disable_irq();
  dbg_panic();
  printf("Softdevice fault handler: error %d @ 0x%.8X (info: %d)\n",
      (unsigned) id, (unsigned) pc, (unsigned) info);
  dbg_drain();

  register uint32_t r_id __ASM("r0") = id;
  register uint32_t r_pc __ASM("r1") = pc;
  register uint32_t r_info __ASM("r2") = info;
  __ASM volatile ("BKPT #0x00" :  : "r" (r_id), "r" (r_pc), "r" (r_info));
  while(1);
}

void app_error_handler(uint32_t error_code, uint32_t line_num, const uint8_t *p_file_name)
{
  __disable_irq();
  dbg_panic();
  printf("Software error handler: error 0x%.8X in %s:%d\n",
      (unsigned) error_code, (const char *) p_file_name, (unsigned) line_num);
  dbg_drain();

  register uint32_t r_error_code __ASM("r0") = error_code;
  register uint32_t r_line_num __ASM("r1") = line_num;
  register const char *r_p_file_name __ASM("r2") = (const void *) p_file_name;
  __ASM volatile ("BKPT #0x00" :  : "r" (r_error_code), "r" (r_line_num), "r" (r_p_file_name));
  while(1);
}

void app_error_handler_bare(uint32_t error_code)
{
  __disable_irq();
  dbg_panic();
  printf("Software error handler: error 0x%.8X\n", (unsigned) error_code);
  dbg_drain();

  register uint32_t r_error_code __ASM("r0") = error_code;
  __ASM volatile ("BKPT #0x00" :  : "r" (r_error_code));
  while(1);
}

uint32_t EvePlatformInitEx(const ble_enable_params_t *BleEnableParams, const nrf_clock_lf_cfg_t *ClockConfig)
{
  uint32_t app_ram_base = (uint32_t) &__data_start__;
  uint32_t err_code;
  clk_init();

  BleWork = WORK_INIT_TYPED(BleWork, BleWorkCb);

  eve_dm_init();

  err_code = sd_softdevice_enable(ClockConfig, softdevice_fault_handler);
  if (err_code != 0)
  {
    printf("%s: Cannot enable softdevice: error %d\n", __func__, (unsigned) err_code);
    return err_code;
  }

  SoftdeviceEnabled = true;

  err_code = sd_nvic_EnableIRQ(SOFTDEVICE_EVT_IRQ);
  APP_ERROR_CHECK(err_code);

  if (BleEnableParams)
  {
    ble_enable_params_t ble_enable_params = *BleEnableParams;
    err_code = sd_ble_enable(&ble_enable_params, &app_ram_base);
    if (err_code != 0)
    {
      if (err_code == NRF_ERROR_NO_MEM)
      {
        printf("%s: Not enough memory for BLE: %d bytes extra required\n", __func__,
            (unsigned) (app_ram_base - (uint32_t) &__data_start__));
      }
      else
      {
        printf("%s: Cannot enable BLE: error %d\n", __func__, (unsigned) err_code);
      }
      return err_code;
    }

    APP_ERROR_CHECK_BOOL(app_ram_base <= (uint32_t) &__data_start__);
    if (app_ram_base != (uint32_t) &__data_start__)
      printf("%s: %d bytes can be added to RAM segment.\n", __func__,
        (unsigned) ((uint32_t) &__data_start__ - app_ram_base));
  }
  return 0;
}

bool softdevice_handler_is_enabled(void)
{
  return SoftdeviceEnabled;
}

static uint32_t ble_event_buffer[(sizeof(ble_evt_t) + (GATT_MTU_SIZE_DEFAULT) + 3) / sizeof(uint32_t)];

void NoApplicHandleSysEvent(uint32_t Event)
{}
void ApplicHandleSysEvent(uint32_t Event) __attribute__((weak,alias("NoApplicHandleSysEvent")));

void NoApplicHandleBleEvent(const ble_evt_t *Event)
{}
void ApplicHandleBleEvent(const ble_evt_t *Event) __attribute__((weak,alias("NoApplicHandleBleEvent")));

void NoTocAppGetToc(struct toc_blob_t *Ptr)
{
  memset(Ptr, 0, sizeof(struct toc_blob_t));
}
void TocAppGetToc(struct toc_blob_t *Ptr) __attribute__((weak,alias("NoTocAppGetToc")));

const struct toc_segment_descriptor_t TocSegmentTable[1] __attribute__((weak));

int NoTocVarCb(int Id, int Index)
{
  return 0;
}
int TocVarPreGet(int Id, int Index) __attribute__((weak,alias("NoTocVarCb")));
int TocVarPostGet(int Id, int Index) __attribute__((weak,alias("NoTocVarCb")));
int TocVarPreSet(int Id, int Index) __attribute__((weak,alias("NoTocVarCb")));
int TocVarPostSet(int Id, int Index) __attribute__((weak,alias("NoTocVarCb")));

void SOFTDEVICE_EVT_IRQHandler(void)
{
  work_schedule(&BleWork);
}

static void BleWorkCb(struct work_t *Work)
{
  uint32_t err_code;

  for (;;)
  {
    uint32_t evt_id;
    err_code = sd_evt_get(&evt_id);
    if (err_code == NRF_ERROR_NOT_FOUND) {
      break;
    } else if (err_code != NRF_SUCCESS) {
      APP_ERROR_CHECK(err_code);
    } else {
      PRINTD(">>> SYS: 0x%.8X\n", (unsigned) evt_id);
      if (EveBleServiceEnabled) {
        eve_dm_sys_event_handler(evt_id);
      }
      ApplicHandleSysEvent(evt_id);
    }
  }

  for (;;)
  {
    uint16_t evt_len = sizeof(ble_event_buffer);
    err_code = sd_ble_evt_get((void *) ble_event_buffer, &evt_len);
    if (err_code == NRF_ERROR_NOT_FOUND || err_code == BLE_ERROR_NOT_ENABLED) {
      break;
    } else if (err_code != NRF_SUCCESS) {
      APP_ERROR_CHECK(err_code);
    } else {
      const ble_evt_t *evt = (void *) ble_event_buffer;
      PRINTD(">>> BLE: 0x%.2X (%d bytes)\n",
          (unsigned) evt->header.evt_id,
          (unsigned) evt->header.evt_len);
      if (EveBleServiceEnabled) {
        eve_connection_on_ble_evt(evt);
        eve_svc_on_ble_evt(evt);
        eve_disc_on_ble_evt(evt);
      }
      ApplicHandleBleEvent(evt);
    }
  }
}