Skip to content

A truly modular keyboard

C
7.6 KB
Raw Blame
/*
 * STM32_WPAN entry: CPU2 boot, transport layer, timer server and the
 * sequencer hook. Trimmed from ST's BLE_Hid app_entry.c (STM32CubeWB 1.24.0)
 * without the Nucleo LEDs, buttons and debug UART.
 *
 * main.c calls, all from USER CODE sections:
 *   MX_APPE_Config()  before SystemClock_Config (Init)
 *   MX_APPE_Init()    after the peripherals (RF_Init 2)
 *   MX_APPE_Process() once per pass of the main loop (WHILE)
 */
#include "app_common.h"
#include "main.h"
#include "app_entry.h"
#include "app_ble.h"
#include "ble.h"
#include "tl.h"
#include "stm32_seq.h"
#include "shci_tl.h"
#include "stm32_lpm.h"
#include "shci.h"
#include "otp.h"
#include "keymap.h"
#include "ota.h"
#include "fus.h"

RTC_HandleTypeDef hrtc;

#define POOL_SIZE (CFG_TLBLE_EVT_QUEUE_LENGTH * 4U * DIVC((sizeof(TL_PacketHeader_t) + TL_BLE_EVENT_FRAME_SIZE), 4U))

PLACE_IN_SECTION("MB_MEM2") ALIGN(4) static uint8_t EvtPool[POOL_SIZE];
PLACE_IN_SECTION("MB_MEM2") ALIGN(4) static TL_CmdPacket_t SystemCmdBuffer;
PLACE_IN_SECTION("MB_MEM2") ALIGN(4) static uint8_t SystemSpareEvtBuffer[sizeof(TL_PacketHeader_t) + TL_EVT_HDR_SIZE + 255U];
PLACE_IN_SECTION("MB_MEM2") ALIGN(4) static uint8_t BleSpareEvtBuffer[sizeof(TL_PacketHeader_t) + TL_EVT_HDR_SIZE + 255U];

static void APPE_SysUserEvtRx(void *pPayload);
static uint8_t cpu2_state = CPU2_UNKNOWN;
static void APPE_SysStatusNot(SHCI_TL_CmdStatus_t status);

/* Runs before SystemClock_Config: the backup domain reset has to happen
 * before the LSE is started, and the HSE trim before the HSE is. */
void MX_APPE_Config(void)
{
  __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_OPTVERR);

#if (CFG_HW_RESET_BY_FW == 1)
  /* After a pin reset (not a software one) CPU2 may still be running with
   * stale IPCC state, so start both clean. */
  /* A watchdog reset also sets PINRST; keep the backup domain (the
   * bootloader's crash count lives there) unless it was a real pin reset. */
  if (LL_RCC_IsActiveFlag_PINRST() && !LL_RCC_IsActiveFlag_SFTRST()
      && !LL_RCC_IsActiveFlag_IWDGRST() && !LL_RCC_IsActiveFlag_WWDGRST())
  {
    HAL_PWR_EnableBkUpAccess();
    __HAL_RCC_BACKUPRESET_FORCE();
    __HAL_RCC_BACKUPRESET_RELEASE();
  }
  LL_AHB3_GRP1_EnableClock(LL_AHB3_GRP1_PERIPH_IPCC);
  uint32_t ch = LL_IPCC_CHANNEL_1 | LL_IPCC_CHANNEL_2 | LL_IPCC_CHANNEL_3
              | LL_IPCC_CHANNEL_4 | LL_IPCC_CHANNEL_5 | LL_IPCC_CHANNEL_6;
  LL_C1_IPCC_ClearFlag_CHx(IPCC, ch);
  LL_C2_IPCC_ClearFlag_CHx(IPCC, ch);
  LL_C1_IPCC_DisableTransmitChannel(IPCC, ch);
  LL_C2_IPCC_DisableTransmitChannel(IPCC, ch);
  LL_C1_IPCC_DisableReceiveChannel(IPCC, ch);
  LL_C2_IPCC_DisableReceiveChannel(IPCC, ch);
#endif

  /* The OTA bootloader trusts its SRAM1 request only after a software
   * reset, so every boot must start from fresh flags. */
  __HAL_RCC_CLEAR_RESET_FLAGS();

  OTP_ID0_t *p_otp = (OTP_ID0_t *)OTP_Read(0);
  if (p_otp)
  {
    LL_RCC_HSE_SetCapacitorTuning(p_otp->hse_tuning);
  }
}

/* The timer server runs off the RTC wakeup timer, clocked from the LSE. */
static void Init_Rtc(void)
{
  RCC_PeriphCLKInitTypeDef clk = {0};
  clk.PeriphClockSelection = RCC_PERIPHCLK_RTC;
  clk.RTCClockSelection = RCC_RTCCLKSOURCE_LSE;
  if (HAL_RCCEx_PeriphCLKConfig(&clk) != HAL_OK)
  {
    Error_Handler();
  }
  __HAL_RCC_RTC_ENABLE();
  __HAL_RCC_RTCAPB_CLK_ENABLE();
  HAL_NVIC_SetPriority(RTC_WKUP_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(RTC_WKUP_IRQn);

  hrtc.Instance = RTC;
  hrtc.Init.HourFormat = RTC_HOURFORMAT_24;
  hrtc.Init.AsynchPrediv = CFG_RTC_ASYNCH_PRESCALER;
  hrtc.Init.SynchPrediv = CFG_RTC_SYNCH_PRESCALER;
  hrtc.Init.OutPut = RTC_OUTPUT_DISABLE;
  hrtc.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
  hrtc.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
  hrtc.Init.OutPutRemap = RTC_OUTPUT_REMAP_NONE;
  if (HAL_RTC_Init(&hrtc) != HAL_OK)
  {
    Error_Handler();
  }
  HAL_RTCEx_EnableBypassShadow(&hrtc);

  LL_RTC_DisableWriteProtection(RTC);
  LL_RTC_WAKEUP_SetClock(RTC, CFG_RTC_WUCKSEL_DIVIDER);
  LL_RTC_EnableWriteProtection(RTC);
}

void MX_APPE_Init(void)
{
  __HAL_RCC_HSEM_CLK_ENABLE();

#if (CFG_USE_SMPS != 0)
  LL_PWR_SMPS_SetStartupCurrent(LL_PWR_SMPS_STARTUP_CURRENT_80MA);
  LL_PWR_SMPS_SetOutputVoltageLevel(LL_PWR_SMPS_OUTPUT_VOLTAGE_1V40);
  LL_PWR_SMPS_Enable();
#endif
  /* IPCC and HSEM wake CPU1 up */
  LL_EXTI_EnableIT_32_63(LL_EXTI_LINE_36 | LL_EXTI_LINE_38);
  Init_Rtc();

  LL_RCC_SetClkAfterWakeFromStop(LL_RCC_STOP_WAKEUPCLOCK_HSI);
  UTIL_LPM_Init();
  /* CPU2 may drop to shutdown whenever it wants, CPU1 decides the real mode. */
  LL_C2_PWR_SetPowerMode(LL_PWR_MODE_SHUTDOWN);

  HW_TS_Init(hw_ts_InitMode_Full, &hrtc);
  UTIL_LPM_SetOffMode(1 << CFG_LPM_APP, UTIL_LPM_DISABLE);

  /* Keys run whether or not the radio comes up, USB CDC needs them too. */
  KEYMAP_Init();

  /* Transport layer. CPU2 boots once TL_Enable() runs and answers with
   * SHCI_SUB_EVT_CODE_READY, which brings up the BLE app. */
  TL_MM_Config_t tl_mm_config;
  SHCI_TL_HciInitConf_t shci_conf;

  TL_Init();
  UTIL_SEQ_RegTask(1 << CFG_TASK_SYSTEM_HCI_ASYNCH_EVT_ID, UTIL_SEQ_RFU, shci_user_evt_proc);
  shci_conf.p_cmdbuffer = (uint8_t *)&SystemCmdBuffer;
  shci_conf.StatusNotCallBack = APPE_SysStatusNot;
  shci_init(APPE_SysUserEvtRx, (void *)&shci_conf);

  tl_mm_config.p_BleSpareEvtBuffer = BleSpareEvtBuffer;
  tl_mm_config.p_SystemSpareEvtBuffer = SystemSpareEvtBuffer;
  tl_mm_config.p_AsynchEvtPool = EvtPool;
  tl_mm_config.AsynchEvtPoolSize = POOL_SIZE;
  TL_MM_Init(&tl_mm_config);

  TL_Enable();
}

int APPE_Cpu2State(void)
{
  return cpu2_state;
}

void MX_APPE_Process(void)
{
  OTA_Service();
  UTIL_SEQ_Run(UTIL_SEQ_DEFAULT);
}

void UTIL_SEQ_Idle(void)
{
#if (CFG_LPM_SUPPORTED == 1)
  UTIL_LPM_EnterLowPower();
#endif
}

static void APPE_SysStatusNot(SHCI_TL_CmdStatus_t status)
{
  UNUSED(status);
}

static void APPE_SysUserEvtRx(void *pPayload)
{
  TL_AsynchEvt_t *p_sys_event = (TL_AsynchEvt_t *)(((tSHCI_UserEvtRxParam *)pPayload)->pckt->evtserial.evt.payload);
  if (p_sys_event->subevtcode != SHCI_SUB_EVT_CODE_READY) return;

  SHCI_C2_Ready_Evt_t *p_ready = (SHCI_C2_Ready_Evt_t *)p_sys_event->payload;
  if (p_ready->sysevt_ready_rsp == WIRELESS_FW_RUNNING)
  {
    cpu2_state = CPU2_BLE;
    FUS_OnCpu2Ready(CPU2_BLE);
    SHCI_C2_CONFIG_Cmd_Param_t config_param = {0};
    config_param.PayloadCmdSize = SHCI_C2_CONFIG_PAYLOAD_CMD_SIZE;
    config_param.EvtMask1 = SHCI_C2_CONFIG_EVTMASK1_BIT0_ERROR_NOTIF_ENABLE
                          + SHCI_C2_CONFIG_EVTMASK1_BIT1_BLE_NVM_RAM_UPDATE_ENABLE;
    config_param.RevisionID = (uint16_t)LL_DBGMCU_GetRevisionID();
    config_param.DeviceID = (uint16_t)LL_DBGMCU_GetDeviceID();
    (void)SHCI_C2_Config(&config_param);

    APP_BLE_Init();
    UTIL_LPM_SetOffMode(1U << CFG_LPM_APP, UTIL_LPM_ENABLE);
  }
  else
  {
    /* FUS is running instead of the BLE stack: the stack binary is missing
     * or was never started. No BLE (and no OTA); STACK? reports it. */
    cpu2_state = CPU2_FUS;
    FUS_OnCpu2Ready(CPU2_FUS);   /* installs a staged stack image, if any */
  }
}

void shci_notify_asynch_evt(void *pdata)
{
  UNUSED(pdata);
  UTIL_SEQ_SetTask(1 << CFG_TASK_SYSTEM_HCI_ASYNCH_EVT_ID, CFG_SCH_PRIO_0);
}

void shci_cmd_resp_release(uint32_t flag)
{
  UNUSED(flag);
  UTIL_SEQ_SetEvt(1 << CFG_IDLEEVT_SYSTEM_HCI_CMD_EVT_RSP_ID);
}

void shci_cmd_resp_wait(uint32_t timeout)
{
  UNUSED(timeout);
  UTIL_SEQ_WaitEvt(1 << CFG_IDLEEVT_SYSTEM_HCI_CMD_EVT_RSP_ID);
}

/* These IRQs aren't enabled in keyword.ioc, so the handlers live here
 * rather than in the generated stm32wbxx_it.c. */
void IPCC_C1_RX_IRQHandler(void)
{
  HW_IPCC_Rx_Handler();
}

void IPCC_C1_TX_IRQHandler(void)
{
  HW_IPCC_Tx_Handler();
}

void RTC_WKUP_IRQHandler(void)
{
  HW_TS_RTC_Wakeup_Handler();
}