smbus.h

/* --COPYRIGHT--,BSD
 * Copyright (c) 2023, Texas Instruments Incorporated
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * *  Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * *  Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * *  Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE COPYRIGHT OWNER OR
 * CONTRIBUTORS 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.
 * --/COPYRIGHT--*/
#ifndef __SMBUS_H__
#define __SMBUS_H__

//*****************************************************************************
//
//
//*****************************************************************************

//*****************************************************************************
//
// If building with a C++ compiler, make all of the definitions in this header
// have a C binding.
//
//*****************************************************************************
#ifdef __cplusplus
extern "C"
{
#endif

//
// Include files
//
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>

#include <ti/devices/msp/msp.h>
#include <ti/driverlib/driverlib.h>
#include <ti/driverlib/m0p/dl_core.h>

//*****************************************************************************
// defines
//*****************************************************************************

//*****************************************************************************
//
//
//*****************************************************************************
#define SMB_PEC_SUPPORTED (1)


//*****************************************************************************
//
//
//*****************************************************************************
#define SMB_CRC8_USE_LOOKUP_TABLE (1)

//*****************************************************************************
//
//
//*****************************************************************************
#define SMB_MAX_PAYLOAD_SIZE                    (255)

//*****************************************************************************
//
//
//*****************************************************************************
#define SMB_MAX_PACKET_SIZE                     (SMB_MAX_PAYLOAD_SIZE + 3)

//*****************************************************************************
//
//
//*****************************************************************************
#define RESPONSE_NTR                             0x00

//*****************************************************************************
//
//
//*****************************************************************************
#define SMBUS_RET_OK                            (1)

//*****************************************************************************
//
//
//*****************************************************************************
#define SMBUS_RET_ERROR                         (-1)

//*****************************************************************************
// typedefs
//*****************************************************************************

//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    SMBus_Stop_After_Transfer = 0,
    SMBus_No_Stop_After_Transfer
} SMBus_Stop;

//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    SMBus_Start_Before_Transfer = 0,
    SMBus_No_Start_Before_Transfer
} SMBus_Start;

//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    SMBus_Auto_Ack_Last_Byte = 0,
    SMBus_No_Auto_Ack_Last_Byte
} SMBus_Auto_Ack;

//*****************************************************************************
//
//
//*****************************************************************************
typedef union
{
    //*****************************************************************************
    //
    //
    //*****************************************************************************
    struct
    {
        uint8_t pecEn      : 1;  
        uint8_t swackEn    : 1;  
        uint8_t intEn      : 1;  
        uint8_t phyEn      : 1;  
        uint8_t controller     : 1;  
        uint8_t reserved2  : 3;  
    } bits;
    //*****************************************************************************
    //
    //
    //*****************************************************************************
    struct
    {
        uint8_t writeBits  : 1; 
        uint8_t reserved   : 7; 
    } writeableBits;
    uint8_t u8byte;
} SMBus_Ctrl;

//*****************************************************************************
//
//
//*****************************************************************************
typedef struct
{
    I2C_Regs*  SMBus_Phy_i2cBase;  
    SMBus_Stop SMBus_Phy_stop;     
} SMBus_Phy;

//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    SMBus_NwkState_Idle = 0,              
    SMBus_NwkState_RX,                    
    SMBus_NwkState_TX,                    
    SMBus_NwkState_TXQuickCMD,            
    SMBus_NwkState_TX_Resp,               
    SMBus_NwkState_TX_Block,              
    SMBus_NwkState_RX_Block_Byte_Count,   
    SMBus_NwkState_RX_Block_Payload,      
    SMBus_NwkState_Ending,                
    SMBus_NwkState_Error                  
} SMBus_NwkState;

/****************************************************************************** */

//
//
//*****************************************************************************
typedef struct
{
    volatile SMBus_NwkState eState;       
    uint8_t currentAddr;                  
    uint8_t currentCmd;                   
    uint16_t rxIndex;
    uint16_t rxLen;
    uint16_t rxSize;
    uint8_t *rxBuffPtr;                   
    uint16_t txIndex;
    uint16_t txLen;
    uint8_t *txBuffPtr;                   
    uint8_t *recByteTxPtr;                
    uint16_t txSize;
#if (SMB_PEC_SUPPORTED == 1)

    uint8_t pec;                          
#endif
} SMBus_Nwk;

//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    SMBus_ErrorCode_NoError = 0,   
    SMBus_ErrorCode_Packet,        
    SMBus_ErrorCode_Cmd            
} SMBus_ErrorCode;

//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    SMBus_State_OK = 0,                 
    SMBus_State_DataSizeError,          
    SMBus_State_PECError,               
    SMBus_State_TimeOutError,           
    SMBus_State_Target_FirstByte,        
    SMBus_State_Target_ByteReceived,     
    SMBus_State_Target_QCMD,             
    SMBus_State_Target_CmdComplete,      
    SMBus_State_Target_Error,            
    SMBus_State_Target_NotReady,         
    SMBus_State_Target_NTR,              
    SMBus_State_Controller_ArbLost,         
    SMBus_State_Controller_NACK,            
    SMBus_State_Controller_Error,           
    SMBus_State_Unknown
} SMBus_State;

/****************************************************************************** */

//
//
//*****************************************************************************
typedef union
{
    //*****************************************************************************
    //
    //
    //*****************************************************************************
    struct
    {
        uint8_t pecErr      : 1;    
        uint8_t toErr       : 1;    
        uint8_t packErr     : 1;    
        uint8_t packOvrErr  : 1;    
        uint8_t byteOvrErr  : 1;    
        uint8_t cmdErr      : 1;    
        uint8_t reserved    : 2;    
    } bits;
    uint8_t u8byte;
} SMBus_Status;

//*****************************************************************************
//
//
//*****************************************************************************
typedef struct
{
    SMBus_Phy phy;                  
    SMBus_Nwk nwk;                  
    SMBus_Ctrl ctrl;                
    SMBus_Status status;            
    SMBus_State state;              
    uint8_t ownTargetAddr;           
} SMBus;

//*****************************************************************************
// globals
//*****************************************************************************

//*****************************************************************************
// Public functions called by applications
//*****************************************************************************
//*****************************************************************************
//
//
//
//
//
//*****************************************************************************
extern void SMBus_processDone(SMBus *smbus);

//*****************************************************************************
//
//
//
//
//*****************************************************************************
extern uint16_t SMBus_getRxPayloadAvailable(SMBus *smbus);

//*****************************************************************************
//
//
//
//
//*****************************************************************************
extern SMBus_State SMBus_getState(SMBus *smbus);

#if (SMB_PEC_SUPPORTED == 1)
//*****************************************************************************
//
//
//
//
//*****************************************************************************
extern void SMBus_enablePEC(SMBus *smbus);
//*****************************************************************************
//
//
//
//
//*****************************************************************************
extern void SMBus_disablePEC(SMBus *smbus);
#endif

//*****************************************************************************
//
//
//
//
//
//*****************************************************************************
extern void SMBus_targetInit(SMBus *smbus, I2C_Regs *i2cAddr);

//*****************************************************************************
//
//
//
//
//
//*****************************************************************************
extern void SMBus_targetEnableInt(SMBus *smbus);

//*****************************************************************************
//
//
//
//
//
//*****************************************************************************
extern SMBus_State SMBus_targetProcessInt(SMBus *smbus);

//*****************************************************************************
//
//
//
//
//
//*****************************************************************************
extern void SMBus_controllerReset(SMBus *smbus);

//*****************************************************************************
//
//
//
//
//*****************************************************************************
extern void SMBus_targetSetAddress(SMBus *smbus,
                                  uint8_t targetAddr);

//*****************************************************************************
//
//
//
//
//*****************************************************************************
extern void SMBus_targetSetRxBuffer(SMBus *smbus,
                                   uint8_t *data,
                                   uint16_t size);

//*****************************************************************************
//
//
//
//
//*****************************************************************************
extern void SMBus_targetSetTxBuffer(SMBus *smbus,
                                   uint8_t *data,
                                   uint16_t size);

//*****************************************************************************
//
//
//
//
//
//*****************************************************************************
extern void SMBus_targetReportError(SMBus *smbus,
                                   SMBus_ErrorCode errorCode);

//*****************************************************************************
//
//
//
//
//*****************************************************************************
extern uint8_t SMBus_targetGetCommand(SMBus *smbus);

//*****************************************************************************
//
//
//
//
//*****************************************************************************
extern uint8_t SMBus_targetClearStatusReg(SMBus *smbus,
                                         uint8_t val);

//*****************************************************************************
//
//
//
//
//*****************************************************************************
extern uint8_t SMBus_targetWriteCtrlReg(SMBus *smbus,
                                       uint8_t val);


//*****************************************************************************
//
//
//
//
// \return  None
//
//*****************************************************************************
extern void SMBus_controllerInit(SMBus *smbus,
                             I2C_Regs *i2cAddr,
                             uint32_t busClk);

//*****************************************************************************
//
//
//
//
//
//*****************************************************************************
extern void SMBus_controllerEnableInt(SMBus *smbus);

//*****************************************************************************
//
//
//
//
//
//*****************************************************************************
extern SMBus_State SMBus_controllerProcessInt(SMBus *smbus);


//*****************************************************************************
//
//
//
//
//
//*****************************************************************************
extern int8_t SMBus_controllerProcessCall(SMBus *smbus,
                                      uint8_t targetAddr,
                                      uint8_t command,
                                      uint8_t *txData,
                                      uint8_t *rxData);

//*****************************************************************************
//
//
//
//
//
//
//*****************************************************************************
extern int8_t SMBus_controllerProcessCallBlock(SMBus *smbus,
                                           uint8_t targetAddr,
                                           uint8_t command,
                                           uint8_t *txData,
                                           uint8_t txSize,
                                           uint8_t *rxData);

//*****************************************************************************
//
//
//
//
//
//*****************************************************************************
extern int8_t SMBus_controllerSendByte(SMBus *smbus,
                                   uint8_t targetAddr,
                                   uint8_t txData);

//*****************************************************************************
//
//
//
//
//
//*****************************************************************************
extern int8_t SMBus_controllerReceiveByte(SMBus *smbus,
                                      uint8_t targetAddr,
                                      uint8_t *rxData);

//*****************************************************************************
//
//
//
//
//
//
//*****************************************************************************
extern int8_t SMBus_controllerReadBlock(SMBus *smbus,
                                    uint8_t targetAddr,
                                    uint8_t command,
                                    uint8_t *rxData);

//*****************************************************************************
//
//
//
//
//
//
//*****************************************************************************
extern int8_t SMBus_controllerWriteBlock(SMBus *smbus,
                                     uint8_t targetAddr,
                                     uint8_t command,
                                     uint8_t *txData,
                                     uint16_t txSize);

//*****************************************************************************
//
//
//
//
//
//
//*****************************************************************************
extern int8_t SMBus_controllerReadByteWord(SMBus *smbus,
                                       uint8_t targetAddr,
                                       uint8_t command,
                                       uint8_t *rxData,
                                       uint8_t rxSize);

//*****************************************************************************
//
//
//
//
//*****************************************************************************
extern int8_t SMBus_controllerWriteByteWord(SMBus *smbus,
                                        uint8_t targetAddr,
                                        uint8_t command,
                                        uint8_t *txData,
                                        uint8_t txSize);

//*****************************************************************************
//
//
//
//
//
//*****************************************************************************
extern int8_t SMBus_controllerQuickCommand(SMBus *smbus,
                                       uint8_t targetAddr,
                                       bool write);

//*****************************************************************************
//
//
//
//
//*****************************************************************************
extern int8_t SMBus_controllerWaitUntilDone(SMBus *smbus,
                                        int32_t timeout);

//*****************************************************************************
//
// Mark the end of the C bindings section for C++ compilers.
//
//*****************************************************************************
#ifdef __cplusplus
}
#endif

//*****************************************************************************
//
// Close the Doxygen group.
//
//*****************************************************************************

#endif //__SMBUS_H__