Can.h

Go to the documentation of this file.

/*
*
* Copyright (c) 2019 Texas Instruments Incorporated
*
* All rights reserved not granted herein.
*
* Limited License.
*
* Texas Instruments Incorporated grants a world-wide, royalty-free, non-exclusive
* license under copyrights and patents it now or hereafter owns or controls to make,
* have made, use, import, offer to sell and sell ("Utilize") this software subject to the
* terms herein.  With respect to the foregoing patent license, such license is granted
* solely to the extent that any such patent is necessary to Utilize the software alone.
* The patent license shall not apply to any combinations which include this software,
* other than combinations with devices manufactured by or for TI ("TI Devices").
* No hardware patent is licensed hereunder.
*
* Redistributions must preserve existing copyright notices and reproduce this license
* (including the above copyright notice and the disclaimer and (if applicable) source
* code license limitations below) in the documentation and/or other materials provided
* with the distribution
*
* Redistribution and use in binary form, without modification, are permitted provided
* that the following conditions are met:
*
* *       No reverse engineering, decompilation, or disassembly of this software is
* permitted with respect to any software provided in binary form.
*
* *       any redistribution and use are licensed by TI for use only with TI Devices.
*
* *       Nothing shall obligate TI to provide you with source code for the software
* licensed and provided to you in object code.
*
* If software source code is provided to you, modification and redistribution of the
* source code are permitted provided that the following conditions are met:
*
* *       any redistribution and use of the source code, including any resulting derivative
* works, are licensed by TI for use only with TI Devices.
*
* *       any redistribution and use of any object code compiled from the source code
* and any resulting derivative works, are licensed by TI for use only with TI Devices.
*
* Neither the name of Texas Instruments Incorporated nor the names of its suppliers
*
* may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* DISCLAIMER.
*
* THIS SOFTWARE IS PROVIDED BY TI AND TI'S LICENSORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL TI AND TI'S LICENSORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/

/*
 * Below are the global design requirements which are met by this CAN
 * driver which can't be mapped to a particular source ID
 */

/*
 * Design: MCAL-6059,MCAL-5955,MCAL-6022,MCAL-5977,MCAL-6046,MCAL-6127,MCAL-6081,MCAL-5921,MCAL-5987,MCAL-6005,MCAL-5970
 */

#ifndef CAN_H_
#define CAN_H_

/* ========================================================================== */
/*                             Include Files                                  */
/* ========================================================================== */
/*
 * Design: MCAL-5993,MCAL-6004,MCAL-6075,MCAL-5904,MCAL-5980,MCAL-6098
 */
#include "Std_Types.h"
#include "ComStack_Types.h"
#include "Can_GeneralTypes.h"
#include "Can_Cfg.h"

/*
 * Design: MCAL-6106,MCAL-6144
 */
#include "Os.h"

#ifdef __cplusplus
extern "C"
{
#endif

/* ========================================================================== */
/*                           Macros & Typedefs                                */
/* ========================================================================== */

#define CAN_SW_MAJOR_VERSION             (2U)

#define CAN_SW_MINOR_VERSION             (0U)

/* @} */
#define CAN_SW_PATCH_VERSION             (0U)

#define CAN_AR_RELEASE_MAJOR_VERSION     (4U)

#define CAN_AR_RELEASE_MINOR_VERSION     (3U)

/* @} */
#define CAN_AR_RELEASE_REVISION_VERSION  (1U)

/* Global Macros */
#define CAN_VENDOR_ID   (44U)

#define CAN_MODULE_ID   (80U)

#define CAN_INSTANCE_ID (0U)
/* @} */

#define CAN_UNINIT   ((uint8)0U)

#define CAN_READY    ((uint8)1U)
/* @} */

#define CAN_INIT_ID                  (0x00U)

#define CAN_MAINFCT_WRITE_ID         (0x01U)

#define CAN_SETCTR_ID                (0x03U)

#define CAN_DIINT_ID                 (0x04U)

#define CAN_ENINT_ID                 (0x05U)

#define CAN_WRITE_ID                 (0x06U)

#define CAN_VERSION_ID               (0x07U)

#define CAN_MAINFCT_READ_ID          (0x08U)

#define CAN_MAINFCT_BO_ID            (0x09U)

#define CAN_MAINFCT_WU_ID            (0x0AU)

#define CAN_CKWAKEUP_ID              (0x0BU)

#define CAN_MAINFCT_MODE_ID          (0x0CU)

#define CAN_SETBAUDRATE_ID           (0x0FU)

#define CAN_DEINIT_ID                (0x10U)

#define CAN_GETCTRERRST_ID           (0x11U)

#define CAN_GETCTRMODE_ID            (0x12U)

#define CAN_LOOPBACK_ID              (0x20U)

#define CAN_RXPROCESS_ID             (0x21U)

/* @} */

#ifndef CAN_E_PARAM_POINTER
#define CAN_E_PARAM_POINTER          (0x01U)

#endif
#ifndef CAN_E_PARAM_HANDLE
#define CAN_E_PARAM_HANDLE           (0x02U)

#endif
#ifndef CAN_E_PARAM_DLC
#define CAN_E_PARAM_DLC              (0x03U)

#endif
#ifndef CAN_E_PARAM_CONTROLLER
#define CAN_E_PARAM_CONTROLLER       (0x04U)

#endif
#ifndef CAN_E_UNINIT
#define CAN_E_UNINIT                 (0x05U)

#endif
#ifndef CAN_E_TRANSITION
#define CAN_E_TRANSITION             (0x06U)

#endif
#ifndef CAN_E_DATALOST
#define CAN_E_DATALOST               (0x07U)

#endif
#ifndef CAN_E_PARAM_BAUDRATE
#define CAN_E_PARAM_BAUDRATE         (0x08U)

#endif
#ifndef CAN_E_ICOM_CONFIG_INVALID
#define CAN_E_ICOM_CONFIG_INVALID    (0x09U)

#endif
#ifndef CAN_E_INIT_FAILED
#define CAN_E_INIT_FAILED            (0x0AU)

#endif
/* @} */

#define  CAN_CFG_ID_0     (0x01U)

#define  CAN_CFG_ID_1     (0x02U)

#define  CAN_CFG_ID_2     (0x04U)

#define  CAN_CFG_ID_3     (0x08U)

#define  CAN_CFG_ID_4     (0x10U)

#define  CAN_CFG_ID_5     (0x20U)

#define  CAN_CFG_ID_6     (0x40U)
/* @} */

#define  MIXED_MODE_MB_ID     (2U)
/* @} */

#if (STD_ON == CAN_SAFETY_DIAGNOSTIC)

#define MCAN_ERR_TYPE_PEA_ERROR    (1U)

#define MCAN_ERR_TYPE_TOO_ERROR    (2U)
/* @} */

#define MCAN_LSB_BIT_SET           (1U)
/* @} */
#endif /* (STD_ON == CAN_SAFETY_DIAGNOSTIC) */

/* ========================================================================== */
/*                         Structures and Enums                               */
/* ========================================================================== */
typedef enum
{
    CAN_MAILBOX_DIRECTION_RX = 0x0U,
    CAN_MAILBOX_DIRECTION_TX = 0x1U
} Can_MailBoxDirectionType;

typedef enum
{
    CAN_FULL = 0x0U,
    CAN_BASIC = 0x1U
} Can_HandleType;

typedef enum
{
    CAN_TX_RX_PROCESSING_INTERRUPT = 0x0U,
    CAN_TX_RX_PROCESSING_MIXED = 0x1U,
    CAN_TX_RX_PROCESSING_POLLING = 0x2U
} Can_TxRxProcessingType;

#if (STD_ON == CAN_SAFETY_DIAGNOSTIC)

typedef enum
{
    CAN_IRQ_NO_INTR_EVENT  = 0U,
    CAN_IRQ_INTR_STUFF_EVENT = 1U,
    CAN_IRQ_INTR_FORM_EVENT  = 2U,
    CAN_IRQ_INTR_ACK_EVENT   = 3U,
    CAN_IRQ_INTR_BIT1_EVENT  = 4U,
    CAN_IRQ_INTR_BIT0_EVENT  = 5U,
    CAN_IRQ_INTR_CRC_EVENT = 6U,
    CAN_IRQ_INTR_TOO_EVENT = 7U,
    CAN_IRQ_STATUS_READ_FAIL = 8U,
} Can_IrqStatusType;
#endif /* (STD_ON == CAN_SAFETY_DIAGNOSTIC) */

typedef uint8 CanControllerState_Type;

typedef uint32 Can_InterruptMask_Type;

typedef struct Can_MaskStruct
{
    uint32 MaskValue;
}Can_MaskType;

typedef struct Can_HwFilterStruct
{
    Can_IdType               IDValue;
    uint32                   Mask;
}Can_HwFilterType;

typedef struct Can_FdBaudConfigStruct
{
    uint16 Baud;
    uint8  PropSeg;
    uint8  Pseg1;
    uint8  Pseg2;
    uint8  Sjw;
    uint16 TimingValues;
    uint16 BrpValue;
    uint16 TrcvCompDelay;
    boolean BrsSwitch;
}Can_FdBaudConfigType;

typedef struct Can_BaudConfigStruct
{
    uint16 Baud;
    uint8  PropSeg;
    uint8  Pseg1;
    uint8  Pseg2;
    uint8  Sjw;
    uint16  TimingValues;
    uint16 BrpValue;
    Can_FdBaudConfigType  BaudFdRateConfig;
}Can_BaudConfigType;

typedef struct Can_ControllerStruct
{
    Can_BaudConfigType    *DefaultBaud;
    Can_BaudConfigType  **BaudRateConfigList;
}Can_ControllerType;

typedef struct Can_ControllerStruct_PC
{
    uint8                     ControllerId;
    boolean                   CntrActive;
    uint32                    CntrAddr;
    Can_TxRxProcessingType    RxProcessingType;
    Can_TxRxProcessingType    TxProcessingType;
    boolean                   BusOffProcessingInterrupt;
    Can_ControllerInstance    CanControllerInst;
    boolean                   CanFDModeEnabled;
}Can_ControllerType_PC;

typedef struct Can_MailboxStruct
{
    uint8                    CanHandleType;
    uint32                   MBIdType;
    Can_HwHandleType         HwHandle;
    uint32                   CanHwObjectCount;
    Can_MailBoxDirectionType MBDir;
    const Can_ControllerType_PC    *Controller;
    Can_HwFilterType         **HwFilterList;
    uint32                   HwFilterCnt;
    uint8                    CanFdPaddingValue;
    boolean                  CanHardwareObjectUsesPolling;
}Can_MailboxType;

typedef struct Can_MailboxStruct_PC
{
    uint16                   CanObjectId;
}Can_MailboxType_PC;

typedef struct
{
    uint32  Reserved;
}Can_DmaPrms;

/*
 * Design: MCAL-5980
 */
typedef struct Can_ConfigType_s
{
    Can_ControllerType **CanControllerList;
    uint8                CanMaxControllerCount;
    Can_MailboxType    **MailBoxList;
    uint32               MaxMbCnt;
    uint32               MaxBaudConfigID[CAN_MAX_CONTROLLER];
    Can_DmaPrms          *DmaPrms;
}Can_ConfigType;

#if (STD_ON == CAN_REGISTER_READBACK_API)

typedef struct
{
    uint32 CanReadBackRegPID;
    uint32 CanReadBackRegSTAT;
    uint32 CanReadBackRegCREL;
    uint32 CanReadBackRegENDN;
    uint32 CanReadBackRegCTRL;
    uint32 CanReadBackRegDBTP;
    uint32 CanReadBackRegRWD;
    uint32 CanReadBackRegCCCR;
    uint32 CanReadBackRegNBTP;
    uint32 CanReadBackRegTDCR;
    uint32 CanReadBackRegGFC;
    uint32 CanReadBackRegSIDFC;
    uint32 CanReadBackRegXIDFC;
    uint32 CanReadBackRegRXF0C;
    uint32 CanReadBackRegRXBC;
    uint32 CanReadBackRegRXF1C;
    uint32 CanReadBackRegTXBC;
    uint32 CanReadBackRegTXESC;
    uint32 CanReadBackRegTXEFC;
} Can_RegisterReadbackType;
#endif /* (STD_ON == CAN_REGISTER_READBACK_API) */

/* @} */

/* ========================================================================== */
/*                          Function Declarations                             */
/* ========================================================================== */

#if (CAN_VERSION_INFO_API == STD_ON)

FUNC(void,
     CAN_CODE) Can_GetVersionInfo(P2VAR(Std_VersionInfoType, AUTOMATIC,
                                        CAN_APPL_DATA) VersionInfo);
#endif

FUNC(void, CAN_CODE) Can_Init(P2CONST(Can_ConfigType, AUTOMATIC,
                                    CAN_PBCFG) CfgPtr);

FUNC(Std_ReturnType, CAN_CODE) Can_SetControllerMode(
    uint8 Controller, Can_ControllerStateType Transition);

FUNC(Std_ReturnType, CAN_CODE) Can_Write(Can_HwHandleType Hth,
    const Can_PduType *PduInfo);

FUNC(void, CAN_CODE) Can_DisableControllerInterrupts(uint8 Controller);

FUNC(void, CAN_CODE) Can_EnableControllerInterrupts(uint8 Controller);

/* polling functions (always available for non polled systems also)*/

FUNC(void, CAN_CODE) Can_MainFunction_Write(void);

FUNC(void, CAN_CODE) Can_MainFunction_BusOff(void);

FUNC(void, CAN_CODE) Can_MainFunction_Read(void);

FUNC(void, CAN_CODE) Can_MainFunction_Wakeup(void);

FUNC(void, CAN_CODE) Can_MainFunction_Mode(void);

/* Baud rate functions */
FUNC(Std_ReturnType, CAN_CODE) Can_SetBaudrate(uint8 Controller,
                                               uint16 BaudRateConfigID);

#if (CAN_LOOPBACK_ENABLE == STD_ON)

FUNC(Std_ReturnType, CAN_CODE) Can_TestLoopBackModeEnable(uint8 Controller,
                                                          uint8 Mode);

FUNC(Std_ReturnType, CAN_CODE) Can_TestLoopBackModeDisable(uint8 Controller,
                                                           uint8 Mode);
#endif

#if (STD_ON == CAN_REGISTER_READBACK_API)

Std_ReturnType Can_RegisterReadback(VAR(uint8, AUTOMATIC)Controller,
                    P2VAR(Can_RegisterReadbackType, AUTOMATIC,
                                    CAN_APPL_DATA) RegRbPtr);
#endif

#if (STD_ON == CAN_SAFETY_DIAGNOSTIC)

Std_ReturnType Can_EnableIntr(VAR(uint8, AUTOMATIC)Controller,
                    VAR(uint8, AUTOMATIC)CanErrVar);

Std_ReturnType Can_DisableIntr(VAR(uint8, AUTOMATIC)Controller,
                    VAR(uint8, AUTOMATIC)CanErrVar);

Can_IrqStatusType Can_GetIntrStatus(VAR(uint8, AUTOMATIC)Controller);

Std_ReturnType Can_ClearIntrStatus(VAR(uint8, AUTOMATIC)Controller);
#endif /* (STD_ON == CAN_SAFETY_DIAGNOSTIC) */

FUNC(void, CAN_CODE) Can_IntISR_Fun(Can_ControllerInstance CanInstanceID);


FUNC(void, CAN_CODE) Can_IntISR_Function(Can_ControllerInstance CanInstanceID,uint32 baseAddr);

FUNC(void, CAN_CODE) Can_DeInit(void);

FUNC(Std_ReturnType, CAN_CODE) Can_GetControllerMode(uint8 Controller,
    Can_ControllerStateType* ControllerModePtr);

FUNC(Std_ReturnType, CAN_CODE) Can_GetControllerErrorState
    (uint8 ControllerId, Can_ErrorStateType* ErrorStatePtr);

#ifdef __cplusplus
}
#endif

#endif /* CAN_H_ end file*/
/*  End of File: Can.h */

/* @} */