RP-01/cva_asw_m0146/src/main.c

/*
 * Copyright (c) 2022, Shenzhen CVA Innovation CO.,LTD
 * All rights reserved.
 *
 * Shenzhen CVA Innovation CO.,LTD (CVA chip) is supplying this file for use
 * exclusively with CVA's microcontroller products. This file can be freely
 * distributed within development tools that are supporting such microcontroller
 * products.
 *
 * THIS SOFTWARE IS PROVIDED "AS IS".  NO WARRANTIES, WHETHER EXPRESS, IMPLIED
 * OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE.
 * CVA SHALL NOT, IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL,
 * OR CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.
 */

/*! \brief a bootloader asw demo
 */

/*******************************************************************************
 * the includes
 ******************************************************************************/

#include <stdint.h>
#include <string.h>
#include "mcu.h"
#include "uds_user.h"
#include "TLE94x1.h"
#include "SEGGER_RTT.h"

/*******************************************************************************
 * the defines
 ******************************************************************************/
#define UDS_PHYS_RECV_MSG_ID (0x732)
#define UDS_FUNC_RECV_MSG_ID (0x7DF)
#define UDS_PHYS_RESP_MSG_ID (0x7B2)

#define APP_TX_TEST1_MSG_ID  (0x111)
#define APP_TX_TEST2_MSG_ID  (0x222)
#define APP_RX_TEST1_MSG_ID  (0x444)
#define APP_RX_TEST2_MSG_ID  (0x555)

#define UDS_RECV_BUF         (2056)
#define UDS_SEND_BUF         (512)
#define CAN_BUFF_MAX_NUM     (32)

#define CAN_DATA_BUFFER_SIZE (64u)
#define CAN_BUFFER_FIFO_SIZE (32u)

int64_t     Get_Cur_Time_Stamp(void);
static int8_t FlexCanBoot_TxMessage(uint32_t msgId, const uint8_t* pData, uint8_t size);

/* Indication value with boot loader request from asw */
#define ASW_BOOT_REQ_ACTIVE   (0x55AAAA55ul)
/* Asw code head id to show asw is not empty */
#define ASW_HEAD_MASK         (0xAABBCCDDul)

#define ASW_VECTOR_START_ADDR 0xc000ul

/*******************************************************************************
 * the typedefs
 ******************************************************************************/
typedef enum
{
    UDS_MSG_IDX_STD_RX_PHYS,
    UDS_MSG_IDX_STD_RX_FUNC,
    UDS_MSG_IDX_STD_RX_TEST1,
    UDS_MSG_IDX_STD_RX_TEST2,
    UDS_MSG_IDX_STD_TX_TEST1,
    UDS_MSG_IDX_STD_TX,
    UDS_MSG_IDX_STD_TEST1,
    UDS_MSG_IDX_STD_TEST2,

    UDS_MSG_IDX_NUM
} Uds_MsgIdIdxType;

typedef struct
{
    uint32_t id;
    uint8_t  data[CAN_DATA_BUFFER_SIZE];
    uint8_t  len;
    uint16_t timeStamp;
    uint32_t hrTimeStamp;
} FlexCan_FrameStructureType;

typedef struct
{
    FlexCan_FrameStructureType rxMsg[CAN_BUFFER_FIFO_SIZE];
    FlexCan_FrameStructureType txMsg[CAN_BUFFER_FIFO_SIZE];
    uint8_t                    wrIdx;
    uint8_t                    rdIdx;
} FlexCan_DataInfoType;

typedef struct
{
    uint32_t sAswHeader;
    uint8_t appBuildTime[12];
    uint8_t appBuildDate[16];
} app_CfgInfoType;

/*******************************************************************************
 * the globals
 ******************************************************************************/
McuType                      mcu;
volatile uint32_t            gSystick1msEvent = 0, gSystick1msCnt = 0, gTestRunCnt = 0, gTestIoEn = 0, gSysTick1sCnt = 0;
uint32_t                     gCpuClockFrequency       = 0;
int64_t                      timer_1ms                = 0;
uint8_t                      udsSendBuf[UDS_SEND_BUF] = {0};
uint8_t                      udsRecvBuf[UDS_RECV_BUF] = {0};
UdsType                      udsObj;
FlexCan_DataInfoType         flexCan_DataInfo;
FlexCanDrv_ControllerCfgType flexCanCfg;
FlexCanDrvType*              flexCanDrv_DemoObj;
uint8_t                      flexCanBoot_EnhanceRxFFCnt = 0;
uint8_t                      txMsgBuf[8]                = {0};
uint8_t                      aswVersion                 = 1;

Uds_ParamsType udsParam = {
    .isotpParams.framePadding = true,
    .isotpParams.blockSize    = 0,
    .isotpParams.recvPhysId   = UDS_PHYS_RECV_MSG_ID,
    .isotpParams.recvFuncId   = UDS_FUNC_RECV_MSG_ID,
    .isotpParams.sendid       = UDS_PHYS_RESP_MSG_ID,
    .isotpParams.sendBuf      = udsSendBuf,
    .isotpParams.sendBufSize  = UDS_SEND_BUF,
    .isotpParams.recvBuf      = udsRecvBuf,
    .isotpParams.recvBufSize  = UDS_RECV_BUF,
    .isotpParams.debug        = NULL,
    .isotpParams.sendCanMsg   = FlexCanBoot_TxMessage,
    .isotpParams.getTimeMs    = Get_Cur_Time_Stamp,
    .p2Server_ms              = 50,
    .p2xServer_10ms           = 500,
    .s3Server_ms              = 5000,
};

const FlexCanDrv_MsgCfgType msgCfgObj[UDS_MSG_IDX_NUM] = {
    {UDS_MSG_IDX_STD_RX_PHYS,  1, UDS_PHYS_RECV_MSG_ID, false, FLEXCANDRV_MSGTYPE_RX, DLC_BYTE_8, false, true,  0xFFFFFFFF}, /* CAN_MSGOBJ_STD_RX_PHYS */
    {UDS_MSG_IDX_STD_RX_FUNC,  1, UDS_FUNC_RECV_MSG_ID, false, FLEXCANDRV_MSGTYPE_RX, DLC_BYTE_8, false, true,  0xFFFFFFFF}, /* CAN_MSGOBJ_STD_RX_FUNC */
    {UDS_MSG_IDX_STD_RX_TEST1, 1, APP_RX_TEST1_MSG_ID,  false, FLEXCANDRV_MSGTYPE_RX, DLC_BYTE_8, false, true,  0xFFFFFFFF}, /* CAN_MSGOBJ_STD_RX_FUNC */
    {UDS_MSG_IDX_STD_RX_TEST2, 1, APP_RX_TEST2_MSG_ID,  false, FLEXCANDRV_MSGTYPE_RX, DLC_BYTE_8, false, true,  0xFFFFFFFF}, /* CAN_MSGOBJ_STD_RX_FUNC */
    {UDS_MSG_IDX_STD_TX,       1, UDS_PHYS_RESP_MSG_ID, false, FLEXCANDRV_MSGTYPE_TX, DLC_BYTE_8, false, false, 0xFFFFFFFF}, /* CAN_MSGOBJ_STD_TX */
    {UDS_MSG_IDX_STD_TEST1,    1, APP_TX_TEST1_MSG_ID,  false, FLEXCANDRV_MSGTYPE_TX, DLC_BYTE_8, false, false, 0xFFFFFFFF}, /* CAN_MSGOBJ_STD_TX */
    {UDS_MSG_IDX_STD_TEST2,    1, APP_TX_TEST2_MSG_ID,  false, FLEXCANDRV_MSGTYPE_TX, DLC_BYTE_8, false, false, 0xFFFFFFFF}, /* CAN_MSGOBJ_STD_TX */
};

#pragma location = ".bss.no_init"
static uint32_t sAswBoot_Req;

#pragma location = ".asw_header"
__root const app_CfgInfoType app_inif = {
    .sAswHeader = ASW_HEAD_MASK,//0x00010400
    .appBuildTime = __TIME__,//0x00010404
    .appBuildDate = __DATE__,//0x00010410
};



/*******************************************************************************
 * the functions
 ******************************************************************************/

void Asw_SetBootloaderRequest(void)
{
    sAswBoot_Req = ASW_BOOT_REQ_ACTIVE;
}

int64_t Get_Cur_Time_Stamp(void)
{
    return timer_1ms;
}

void SysTick_Handler(void)
{
    gSystick1msEvent++;
    timer_1ms++;
    Uds_Tick(&udsObj);
}

void CAN0_ERxFIFO_Handler(void)
{
    if(FlexCanDrv_GetEnhanceRxFFIsrFlag(flexCanDrv_DemoObj, FLEXCANDRV_ENHANCERXFF_ISR_SRC_DAIE) == true)
    {
        if(FlexCanDrv_GetEnhanceRxFFIsFull(flexCanDrv_DemoObj) == false)
        {
        }

        if(FlexCanDrv_GetEnhanceRxFFIsEmpty(flexCanDrv_DemoObj) == false)
        {
            FlexCanDrv_MsgObjType rxMsgObj;

            flexCanBoot_EnhanceRxFFCnt = FlexCanDrv_GetEnhanceRxFFMsgNums(flexCanDrv_DemoObj);

            if(flexCanBoot_EnhanceRxFFCnt > 0)
            {
                FlexCanDrv_GetEnhanceRxFifoMsg(flexCanDrv_DemoObj, &rxMsgObj);
                memcpy(flexCan_DataInfo.rxMsg[flexCan_DataInfo.wrIdx].data, rxMsgObj.data, rxMsgObj.dlc);
                flexCan_DataInfo.rxMsg[flexCan_DataInfo.wrIdx].id  = rxMsgObj.msgId;
                flexCan_DataInfo.rxMsg[flexCan_DataInfo.wrIdx].len = rxMsgObj.dlc;
                flexCan_DataInfo.wrIdx++;
                if(flexCan_DataInfo.wrIdx >= CAN_BUFFER_FIFO_SIZE)
                {
                    flexCan_DataInfo.wrIdx = 0;
                }
            }
        }
    }

    if(FlexCanDrv_GetEnhanceRxFFIsrFlag(flexCanDrv_DemoObj, FLEXCANDRV_ENHANCERXFF_ISR_SRC_WMMIE) == true)
    {
        FlexCanDrv_ClearEnhanceRxFFIsrFlag(flexCanDrv_DemoObj, FLEXCANDRV_ENHANCERXFF_ISR_SRC_WMMIE);
    }

    if(FlexCanDrv_GetEnhanceRxFFIsrFlag(flexCanDrv_DemoObj, FLEXCANDRV_ENHANCERXFF_ISR_SRC_OVFIE) == true)
    {
        FlexCanDrv_ClearEnhanceRxFFIsrFlag(flexCanDrv_DemoObj, FLEXCANDRV_ENHANCERXFF_ISR_SRC_OVFIE);
    }

    if(FlexCanDrv_GetEnhanceRxFFIsrFlag(flexCanDrv_DemoObj, FLEXCANDRV_ENHANCERXFF_ISR_SRC_UFWIE) == true)
    {
        FlexCanDrv_ClearEnhanceRxFFIsrFlag(flexCanDrv_DemoObj, FLEXCANDRV_ENHANCERXFF_ISR_SRC_UFWIE);
    }
}

bool FlexCanBoot_ReadoutMsg(FlexCan_FrameStructureType* pRxMsgObj)
{
    bool ret = false;

    if(flexCan_DataInfo.wrIdx != flexCan_DataInfo.rdIdx)
    {
        memcpy(pRxMsgObj, &flexCan_DataInfo.rxMsg[flexCan_DataInfo.rdIdx], sizeof(FlexCan_FrameStructureType));
        flexCan_DataInfo.rdIdx++;
        if(flexCan_DataInfo.rdIdx >= CAN_BUFFER_FIFO_SIZE)
        {
            flexCan_DataInfo.rdIdx = 0;
        }

        ret = true;
    }

    return ret;
}

static int8_t FlexCanBoot_TxMessage(uint32_t msgId, const uint8_t* pData, uint8_t size)
{
    FlexCanDrv_MsgObjType txMsgObj;
    uint8_t               msgIdx = 0, i = 0;

    for(i = 0; i < flexCanCfg.msgNum; i++)
    {
        if(msgId == flexCanCfg.msgCfg[i].msgId)
        {
            msgIdx = i;
            break;
        }
    }

    txMsgObj.msgBufId = flexCanCfg.msgCfg[msgIdx].msgBufId;
    txMsgObj.dlc      = size;
    txMsgObj.msgId    = flexCanCfg.msgCfg[msgIdx].msgId;
    memcpy(&txMsgObj.data[0], pData, size);

    FlexCanDrv_SetTxMsg(flexCanDrv_DemoObj, &txMsgObj);
    /* transmit standard CAN Tx message */
    FlexCanDrv_TransmitMsg(flexCanDrv_DemoObj, &txMsgObj);

    return 0;
}

void FlexCanBoot_Init(void)
{
    uint32_t busClockFreq = 0;

    flexCanDrv_DemoObj = &mcu.flexCanDrv0;

    /* set PTE4 as MUX 5 - CAN0.RX */
    PinsDrv_SetMuxModeSel(&mcu.ptb, 0, PINSDRV_MUX_ALT5);

    /* set PTE5 as MUX 5 - CAN0.TX */
    PinsDrv_SetMuxModeSel(&mcu.ptb, 1, PINSDRV_MUX_ALT5);

    flexCanCfg.clkSrc               = FLEXCANDRV_CLKSRC_CHICLK;
    flexCanCfg.fdEnable             = false;
    flexCanCfg.fdISOEnable          = false;
    flexCanCfg.enhancefifoEnable    = true;
    flexCanCfg.msgBufDataLenSel     = FLEXCANDRV_MB_SIZE_BYTE_8;
    flexCanCfg.individualMaskEnable = true;

    if(flexCanCfg.clkSrc == FLEXCANDRV_CLKSRC_CHICLK)
    {
        ClockDrv_GetFreq(&mcu.clockDrv, CLOCKDRV_APB, &busClockFreq);
    }
    else
    {
        ClockDrv_GetFreq(&mcu.clockDrv, CLOCKDRV_SOSC_DIV2, &busClockFreq);
    }

    if(flexCanCfg.fdEnable == true)
    {
        FlexCanDrv_BitTimingCalc(&flexCanCfg.fdBitTiming,
                                 busClockFreq, /* module clock source: 16M */
                                 2000000,      /* baudrate: 2M */
                                 7500,         /* sample point: 75% */
                                 2000,         /* SJW: 20% */
                                 1);           /* FD bit timing */
    }

    FlexCanDrv_BitTimingCalc(&flexCanCfg.bitTiming,
                             busClockFreq, /* module clock source: 16M */
                             500000,       /* baudrate: 500K */
                             7500,         /* sample point: 75% */
                             2500,         /* SJW: 20% */
                             0);           /* classic CAN bit timing */

    /* initialize CAN module */
    FlexCanDrv_Configure(flexCanDrv_DemoObj, &flexCanCfg);

    /* enable enhance rx fifo interrupt */
    FlexCanDrv_SetEnhanceRxFFIsr(flexCanDrv_DemoObj, FLEXCANDRV_ENHANCERXFF_ISR_SRC_DAIE, true);
    IrqDrv_EnableIrq(CAN0_ERxFIFO_IRQn);
}

int main(void)
{
    uint32_t tTcr       = 0;
    FlexCan_FrameStructureType rxMsg;
    IrqDrv_DisableGlobalInterrupt();

    /* Setup the clock */
    ClockDrv_ModuleClkConfigType clockConfig;

    /* Initialize all MCU drivers: flash drv included */
    Mcu_Init(&mcu);

    SEGGER_RTT_Init();
    
    SEGGER_RTT_printf(0,"sAswBoot_Req = %x\n",sAswBoot_Req);
    SEGGER_RTT_printf(0,"-----clock_INIT-----\n");

    WdgDrv_Disable(&mcu.wdgDrv);

    /* Enable the clock for all ports */
    clockConfig.gating = true;
    ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_PORTA, &clockConfig);
    ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_PORTB, &clockConfig);
    ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_PORTC, &clockConfig);
    ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_PORTD, &clockConfig);
    ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_PORTE, &clockConfig);

    /* Setup the Pll div2 clock */
    clockConfig.gating = true;
    clockConfig.source = CLOCKDRV_PLL;
    clockConfig.div    = 1;
    ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_PLL_DIV2, &clockConfig);
    

    /* Setup the FIRC2 div2 clock */
    clockConfig.gating = true;
    clockConfig.source = CLOCKDRV_FIRC;
    clockConfig.div    = 1;
    ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_FIRC_DIV2, &clockConfig);

    ClockDrv_GetFreq(&mcu.clockDrv, CLOCKDRV_CORE, &gCpuClockFrequency);

    /* Setup the SPI clock */
    clockConfig.gating = true;
    clockConfig.source = CLOCKDRV_PLL_DIV2;
    ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_SPI2, &clockConfig);

    
    tTcr = SpiReg_GetTcr((const SpiRegType *)&mcu.spiDrv2.reg);

    SpiDrv_SetPrescaler(&tTcr,0x03);
    SEGGER_RTT_printf(0,"-----SPI_INIT-----\n");
    SBC_SPI_INIT();

    /* CAN init */
    memset(&flexCan_DataInfo, 0, sizeof(flexCan_DataInfo));
    memset(&flexCanCfg, 0, sizeof(flexCanCfg));
    SEGGER_RTT_printf(0,"-----FlexCanDrv_INIT-----\n");
    /* get CAN controller default configuration */
    FlexCanDrv_GetDefaultCfg(&flexCanCfg);

    flexCanCfg.msgNum = sizeof(msgCfgObj) / sizeof(FlexCanDrv_MsgCfgType);
    flexCanCfg.msgCfg = msgCfgObj;

    FlexCanBoot_Init();

    /* UDS init */
    Uds_UserInit(&udsObj, &udsParam);
    /* Set system tick clock, 1ms event */
    
    SysTick_Config(gCpuClockFrequency / 1000u);
    IrqDrv_EnableIrq(SysTick_IRQn);

    PinsDrv_WritePin(&mcu.ptd, 3, 0);
    PinsDrv_WritePin(&mcu.pta, 17, 0);

    IrqDrv_EnableGlobalInterrupt();
    SEGGER_RTT_printf(0,"-----init success-----\n");
    while(1)
    {
        if(gSystick1msEvent > 0u)
        {
            if(udsObj.session == UDS_SESSION_PROGRAMMING)
            {
                Asw_SetBootloaderRequest();
                ResetDrv_SoftwareResetModule(&mcu.resetDrv, RESETDRV_SWRESET_SYS);
            }

            gSystick1msEvent--;
            gSystick1msCnt++;
            gSysTick1sCnt++;
            if (gSystick1msCnt % 10 == 0)
            {
                SBC_WD_Trigger();
            }
            
            if(gSystick1msCnt % 200 == 0)
            {
                uint8_t txMsgBuf[8]={0};
                txMsgBuf[0]    = aswVersion;
                txMsgBuf[3]    = gSysTick1sCnt & 0xFF;

                FlexCanBoot_TxMessage(APP_TX_TEST1_MSG_ID, txMsgBuf, 8);
            }
            if (gSystick1msCnt >= 5000)
            {
                gSystick1msCnt = 0;
                SEGGER_RTT_printf(0,"app running\n");
            }
            

            /* Handler user routine */
            if(FlexCanBoot_ReadoutMsg(&rxMsg) == true)
            {
                if((rxMsg.id == UDS_PHYS_RECV_MSG_ID) || (rxMsg.id == UDS_FUNC_RECV_MSG_ID))
                {
                    IsoTp_HandleIncomingCanMsg(&udsObj.isotp, rxMsg.id, rxMsg.data, rxMsg.len);
                }
                else
                {

                }
            }

            Uds_Run(&udsObj);
        }
    }
}