NB_APP_Code/src/bsp_custom.c

/****************************************************************************
 *
 * Copy right:   2018 Copyrigths of EigenComm Ltd.
 * File name:    bsp_custom.c
 * Description:
 * History:
 *
 ****************************************************************************/
#include <stdio.h>
#include <stdarg.h>
#include "clock_ec616.h"
#include "bsp_custom.h"
#include "slpman_ec616.h"
#include "plat_config.h"
#include "debug_log.h"
#include "os_exception.h"
#if (WDT_FEATURE_ENABLE==1)
#include "wdt_ec616.h"
#define WDT_TIMEOUT_VALUE     (20)            // in unit of second, shall be less than 256s
#endif
#ifdef BL_FILE_LOG
extern uint8_t lockoutState;
#endif
extern UINT8 Lockstatus;
void GPR_SetUartClk(void)
{
    GPR_ClockDisable(GPR_UART0FuncClk);
    GPR_ClockDisable(GPR_UART1FuncClk);
    GPR_ClockDisable(GPR_UART2FuncClk);

    GPR_SetClockSrc(GPR_UART0FuncClk, GPR_UART0ClkSel_26M);
    GPR_SetClockSrc(GPR_UART1FuncClk, GPR_UART1ClkSel_26M);
    GPR_SetClockSrc(GPR_UART2FuncClk, GPR_UART1ClkSel_26M);

    GPR_ClockEnable(GPR_UART0FuncClk);
    GPR_ClockEnable(GPR_UART1FuncClk);
    GPR_ClockEnable(GPR_UART2FuncClk);

    GPR_SWReset(GPR_ResetUART0Func);
    GPR_SWReset(GPR_ResetUART1Func);
    GPR_SWReset(GPR_ResetUART2Func);
}

extern ARM_DRIVER_USART Driver_USART0;
extern ARM_DRIVER_USART Driver_USART1;

/*
 *  set printf uart port
 *  Parameter:      port: for printf
 */
static void SetPrintUart(usart_port_t port)
{
    if(port == PORT_USART_0)
    {
#if (RTE_UART0)
        UsartPrintHandle = &CREATE_SYMBOL(Driver_USART, 0);
        GPR_ClockDisable(GPR_UART0FuncClk);
        GPR_SetClockSrc(GPR_UART0FuncClk, GPR_UART0ClkSel_26M);
        GPR_ClockEnable(GPR_UART0FuncClk);
        GPR_SWReset(GPR_ResetUART0Func);
#endif
    }
    else if(port == PORT_USART_1)
    {
#if (RTE_UART1)
        UsartPrintHandle = &CREATE_SYMBOL(Driver_USART, 1);
        GPR_ClockDisable(GPR_UART1FuncClk);
        GPR_SetClockSrc(GPR_UART1FuncClk, GPR_UART1ClkSel_26M);
        GPR_ClockEnable(GPR_UART1FuncClk);
        GPR_SWReset(GPR_ResetUART1Func);
#endif
    }

    if(UsartPrintHandle == NULL)
        return;

    UsartPrintHandle->Initialize(NULL);
    UsartPrintHandle->PowerControl(ARM_POWER_FULL);
    UsartPrintHandle->Control(ARM_USART_MODE_ASYNCHRONOUS | ARM_USART_DATA_BITS_8 |
                        ARM_USART_PARITY_NONE       | ARM_USART_STOP_BITS_1 |
                        ARM_USART_FLOW_CONTROL_NONE, 115200ul);
}


#if LOW_POWER_AT_TEST
slpManSlpState_t CheckUsrdefSlpStatus(void)
{
    slpManSlpState_t status = SLP_HIB_STATE;
    if((slpManGetWakeupPinValue() & (0x1<<1)) == 0)         // pad1 value is low
        status = SLP_IDLE_STATE;
    else
        status = SLP_HIB_STATE;

    return status;
}

#endif

/**
  \fn        void CheckLockOutState(void)
  \brief      CheckLockOutState
  \param     void
 */
void CheckLockOutState(void){
	if((slpManGetWakeupPinValue() & (0x1<<2)) == 0)
    {
		#ifdef USING_PRINTF1
			printf("LOCK_OUT DOWN\r\n");
		#endif	
        Lockstatus = true;
		 #ifdef BL_FILE_LOG
			 lockoutState=1;
		#endif
	}
    else
    {
        Lockstatus = false;
		#ifdef USING_PRINTF1
			printf("LOCK_OUT UP\r\n",__LINE__);
		#endif	
		 #ifdef BL_FILE_LOG
			 lockoutState=0;
		#endif
	}
}


static void PMU_WakeupPadInit(void)
{
    const padWakeupSettings_t cfg =
    {
        false, true,             // group0 posedge, negedge
        true, true,             // group1 posedge, negedge
        true, true,             // group2 posedge, negedge
    };

    slpManSetWakeupPad(cfg);
}
#if (WDT_FEATURE_ENABLE == 1)

/*
 *  WDT Initialize, wdt timeout value is 20s
 *  Parameter:   none
 */
void BSP_WdtInit(void)
{
    // Config WDT clock, source from 32.768KHz and divide by WDT_TIMEOUT_VALUE
    GPR_SetClockSrc(GPR_WDGFuncClk, GPR_WDGClkSel_32K);
    GPR_SetClockDiv(GPR_WDGFuncClk, WDT_TIMEOUT_VALUE);

    wdt_config_t wdtConfig;
    wdtConfig.mode = WDT_InterruptResetMode;
    wdtConfig.timeoutValue = 32768U;
    WDT_Init(&wdtConfig);
}
void NMI_Handler()
{
    ECOMM_TRACE(UNILOG_PLA_APP, enter_NMI_handler, P_ERROR, 0, "WDT timeout!!! Enter NMI Handler!!!");
    // If we have been in exception handler excecution, we shall resume it.
    if(is_in_excep_handler())
    {
        WDT_Stop();
    }
    else
    {
        if(BSP_GetPlatConfigItemValue(PLAT_CONFIG_ITEM_FAULT_ACTION) == EXCEP_OPTION_SILENT_RESET)
        {
            ResetReasonWrite(RESET_REASON_WDT);
            EC_SystemReset();
            while(1);
        }
        else
        {
            EC_ASSERT(0, 0, 0, 0);
        }
    }
}
#endif
/*
 *  custom board related init
 *  Parameter:   none
 *  note: this function shall be called in OS task context for dependency of reading configure file
 *        which is implemented based on file system
 */
void BSP_CustomInit(void)
{
    extern void mpu_init(void);
    mpu_init();
	
    GPR_SetUartClk();
    relayConfigInit();

#if LOW_POWER_AT_TEST
    slpManRegisterUsrSlpDepthCb(CheckUsrdefSlpStatus);
#endif

    plat_config_raw_flash_t* rawFlashPlatConfig;

    BSP_LoadPlatConfigFromRawFlash();
    rawFlashPlatConfig = BSP_GetRawFlashPlatConfig();
 #if 1
#ifdef USING_PRINTF
	SetPrintUart(PORT_USART_0);
#else
    if(rawFlashPlatConfig && (rawFlashPlatConfig->logControl != 0 ))
    {
        SetUnilogUart(PORT_USART_0, rawFlashPlatConfig->uartBaudRate, true);
        uniLogInitStart(UART_0_FOR_UNILOG);
        ECOMM_STRING(UNILOG_PLA_STRING, build_info, P_SIG, "%s", getBuildInfo());
    }
#endif
#endif
#if (WDT_FEATURE_ENABLE == 1)
    if(BSP_GetPlatConfigItemValue(PLAT_CONFIG_ITEM_START_WDT))
    {
        BSP_WdtInit();
        WDT_Start();
    }
#endif
	slpManGetPMUSettings();				

	PMU_WakeupPadInit();
	NVIC_EnableIRQ(PadWakeup0_IRQn);//can
	NVIC_EnableIRQ(PadWakeup1_IRQn);//rx
	NVIC_EnableIRQ(PadWakeup2_IRQn);//lock
	NVIC_EnableIRQ(PadWakeup3_IRQn);//gsensor
	NVIC_EnableIRQ(PadWakeup4_IRQn);//gsensor
	NVIC_EnableIRQ(PadWakeup5_IRQn);//wakeup2
	CheckLockOutState();
	slpManStartWaitATTimer();

	CanSPIHandler(NULL,ARM_SPI_CPOL0_CPHA0,8,200000U);

	slpManAONIOPowerOn();
	PowerPinConfig(AON_IO);
	PowerPinConfig(NORMAL_IO);
	posGGAReset();
	GPSUsartHandler(9600);
	NetSocDisplay(LED_SOC_0,LED_TURN_ON);
	NetSocDisplay(LED_SOC_1,LED_TURN_ON);
	NetSocDisplay(LED_SOC_2,LED_TURN_ON);
	NetSocDisplay(LED_SOC_3,LED_TURN_ON);
	FaultDisplay(LED_TURN_ON);
}

/**
  \fn        void NVIC_WakeupIntHandler(void)
  \brief      NVIC wakeup interrupt handler
  \param     void
 */
void Pad0_WakeupIntHandler(void)
{
    if(slpManExtIntPreProcess(PadWakeup0_IRQn)==false)
    {
        return;
    }
#ifdef USING_PRINTF1
	printf("[%d]PadWakeup0_IRQn\r\n",__LINE__);
// #else	
//     ECOMM_TRACE(UNILOG_PLA_APP, pad0_Wk, P_SIG, 0, "PadWakeup0_IRQn");
#endif
	// CanTiggerEvt(1);
}

void Pad1_WakeupIntHandler(void)
{
    if(slpManExtIntPreProcess(PadWakeup1_IRQn)==false)
        return;
}

void Pad2_WakeupIntHandler(void)
{
     CheckLockOutState();
    if(slpManExtIntPreProcess(PadWakeup2_IRQn)==false)
        return;

}

void Pad3_WakeupIntHandler(void)
{
    if(slpManExtIntPreProcess(PadWakeup3_IRQn)==false)
        return;

    // add custom code below //
#ifdef USING_PRINTF1
	printf("[%d]PadWakeup3_IRQn\r\n",__LINE__);
// #else	
//     ECOMM_TRACE(UNILOG_PLA_APP, pad3_Wk, P_SIG, 0, "PadWakeup3_IRQn");
#endif

 	



}

void Pad4_WakeupIntHandler(void)
{
    if(slpManExtIntPreProcess(PadWakeup4_IRQn)==false)
        return;
    // add custom code below //
#ifdef USING_PRINTF1
	printf("[%d]PadWakeup3_IRQn\r\n",__LINE__);
// #else	

//     ECOMM_TRACE(UNILOG_PLA_APP, pad4_Wk, P_SIG, 0, "PadWakeup4_IRQn");
#endif

}

void Pad5_WakeupIntHandler(void)
{
    if(slpManExtIntPreProcess(PadWakeup5_IRQn)==false)
        return;
}