fsl_lpi2c.h

Go to the documentation of this file.

/*
 * Copyright (c) 2015, Freescale Semiconductor, Inc.
 * Copyright 2016-2020 NXP
 * All rights reserved.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */
#ifndef _FSL_LPI2C_H_
#define _FSL_LPI2C_H_
 
#include <stddef.h>
#include "fsl_device_registers.h"
#include "fsl_common.h"
 
/*******************************************************************************
 * Definitions
 ******************************************************************************/
 
#define FSL_LPI2C_DRIVER_VERSION (MAKE_VERSION(2, 1, 11))
 
#ifndef I2C_RETRY_TIMES
#define I2C_RETRY_TIMES 0U /* Define to zero means keep waiting until the flag is assert/deassert. */
#endif
 
enum
{
    kStatus_LPI2C_Busy = MAKE_STATUS(kStatusGroup_LPI2C, 0), 
    kStatus_LPI2C_Idle = MAKE_STATUS(kStatusGroup_LPI2C, 1), 
    kStatus_LPI2C_Nak  = MAKE_STATUS(kStatusGroup_LPI2C, 2), 
    kStatus_LPI2C_FifoError       = MAKE_STATUS(kStatusGroup_LPI2C, 3), 
    kStatus_LPI2C_BitError        = MAKE_STATUS(kStatusGroup_LPI2C, 4), 
    kStatus_LPI2C_ArbitrationLost = MAKE_STATUS(kStatusGroup_LPI2C, 5), 
    kStatus_LPI2C_PinLowTimeout =
        MAKE_STATUS(kStatusGroup_LPI2C, 6), 
    kStatus_LPI2C_NoTransferInProgress =
        MAKE_STATUS(kStatusGroup_LPI2C, 7), 
    kStatus_LPI2C_DmaRequestFail = MAKE_STATUS(kStatusGroup_LPI2C, 8), 
    kStatus_LPI2C_Timeout        = MAKE_STATUS(kStatusGroup_LPI2C, 9), 
};
 
enum
{
    kLPI2C_MasterTxReadyFlag         = LPI2C_MSR_TDF_MASK,  
    kLPI2C_MasterRxReadyFlag         = LPI2C_MSR_RDF_MASK,  
    kLPI2C_MasterEndOfPacketFlag     = LPI2C_MSR_EPF_MASK,  
    kLPI2C_MasterStopDetectFlag      = LPI2C_MSR_SDF_MASK,  
    kLPI2C_MasterNackDetectFlag      = LPI2C_MSR_NDF_MASK,  
    kLPI2C_MasterArbitrationLostFlag = LPI2C_MSR_ALF_MASK,  
    kLPI2C_MasterFifoErrFlag         = LPI2C_MSR_FEF_MASK,  
    kLPI2C_MasterPinLowTimeoutFlag   = LPI2C_MSR_PLTF_MASK, 
    kLPI2C_MasterDataMatchFlag       = LPI2C_MSR_DMF_MASK,  
    kLPI2C_MasterBusyFlag            = LPI2C_MSR_MBF_MASK,  
    kLPI2C_MasterBusBusyFlag         = LPI2C_MSR_BBF_MASK   
};
 
typedef enum _lpi2c_direction
{
    kLPI2C_Write = 0U, 
    kLPI2C_Read  = 1U  
} lpi2c_direction_t;
 
typedef enum _lpi2c_master_pin_config
{
    kLPI2C_2PinOpenDrain  = 0x0U, 
    kLPI2C_2PinOutputOnly = 0x1U, 
    kLPI2C_2PinPushPull   = 0x2U, 
    kLPI2C_4PinPushPull   = 0x3U, 
    kLPI2C_2PinOpenDrainWithSeparateSlave =
        0x4U, 
    kLPI2C_2PinOutputOnlyWithSeparateSlave =
        0x5U, 
    kLPI2C_2PinPushPullWithSeparateSlave =
        0x6U, 
    kLPI2C_4PinPushPullWithInvertedOutput = 0x7U 
} lpi2c_master_pin_config_t;
 
typedef enum _lpi2c_host_request_source
{
    kLPI2C_HostRequestExternalPin  = 0x0U, 
    kLPI2C_HostRequestInputTrigger = 0x1U, 
} lpi2c_host_request_source_t;
 
typedef enum _lpi2c_host_request_polarity
{
    kLPI2C_HostRequestPinActiveLow  = 0x0U, 
    kLPI2C_HostRequestPinActiveHigh = 0x1U  
} lpi2c_host_request_polarity_t;
 
typedef struct _lpi2c_master_config
{
    bool enableMaster;                   
    bool enableDoze;                     
    bool debugEnable;                    
    bool ignoreAck;                      
    lpi2c_master_pin_config_t pinConfig; 
    uint32_t baudRate_Hz;                
    uint32_t busIdleTimeout_ns;          
    uint32_t pinLowTimeout_ns;           
    uint8_t sdaGlitchFilterWidth_ns;     
    uint8_t sclGlitchFilterWidth_ns;     
    struct
    {
        bool enable;                            
        lpi2c_host_request_source_t source;     
        lpi2c_host_request_polarity_t polarity; 
    } hostRequest;                              
} lpi2c_master_config_t;
 
typedef enum _lpi2c_data_match_config_mode
{
    kLPI2C_MatchDisabled       = 0x0U, 
    kLPI2C_1stWordEqualsM0OrM1 = 0x2U, 
    kLPI2C_AnyWordEqualsM0OrM1 = 0x3U, 
    kLPI2C_1stWordEqualsM0And2ndWordEqualsM1 =
        0x4U, 
    kLPI2C_AnyWordEqualsM0AndNextWordEqualsM1 =
        0x5U, 
    kLPI2C_1stWordAndM1EqualsM0AndM1 =
        0x6U, 
    kLPI2C_AnyWordAndM1EqualsM0AndM1 =
        0x7U 
} lpi2c_data_match_config_mode_t;
 
typedef struct _lpi2c_match_config
{
    lpi2c_data_match_config_mode_t matchMode; 
    bool rxDataMatchOnly; 
    uint32_t match0;      
    uint32_t match1;      
} lpi2c_data_match_config_t;
 
/* Forward declaration of the transfer descriptor and handle typedefs. */
typedef struct _lpi2c_master_transfer lpi2c_master_transfer_t;
typedef struct _lpi2c_master_handle lpi2c_master_handle_t;
 
typedef void (*lpi2c_master_transfer_callback_t)(LPI2C_Type *base,
                                                 lpi2c_master_handle_t *handle,
                                                 status_t completionStatus,
                                                 void *userData);
 
enum _lpi2c_master_transfer_flags
{
    kLPI2C_TransferDefaultFlag       = 0x00U, 
    kLPI2C_TransferNoStartFlag       = 0x01U, 
    kLPI2C_TransferRepeatedStartFlag = 0x02U, 
    kLPI2C_TransferNoStopFlag        = 0x04U, 
};
 
struct _lpi2c_master_transfer
{
    uint32_t flags;        
    uint16_t slaveAddress; 
    lpi2c_direction_t direction; 
    uint32_t subaddress;         
    size_t subaddressSize;       
    void *data;                  
    size_t dataSize;             
};
 
struct _lpi2c_master_handle
{
    uint8_t state;                                       
    uint16_t remainingBytes;                             
    uint8_t *buf;                                        
    uint16_t commandBuffer[7];                           
    lpi2c_master_transfer_t transfer;                    
    lpi2c_master_transfer_callback_t completionCallback; 
    void *userData;                                      
};
 
enum _lpi2c_slave_flags
{
    kLPI2C_SlaveTxReadyFlag             = LPI2C_SSR_TDF_MASK,  
    kLPI2C_SlaveRxReadyFlag             = LPI2C_SSR_RDF_MASK,  
    kLPI2C_SlaveAddressValidFlag        = LPI2C_SSR_AVF_MASK,  
    kLPI2C_SlaveTransmitAckFlag         = LPI2C_SSR_TAF_MASK,  
    kLPI2C_SlaveRepeatedStartDetectFlag = LPI2C_SSR_RSF_MASK,  
    kLPI2C_SlaveStopDetectFlag          = LPI2C_SSR_SDF_MASK,  
    kLPI2C_SlaveBitErrFlag              = LPI2C_SSR_BEF_MASK,  
    kLPI2C_SlaveFifoErrFlag             = LPI2C_SSR_FEF_MASK,  
    kLPI2C_SlaveAddressMatch0Flag       = LPI2C_SSR_AM0F_MASK, 
    kLPI2C_SlaveAddressMatch1Flag       = LPI2C_SSR_AM1F_MASK, 
    kLPI2C_SlaveGeneralCallFlag         = LPI2C_SSR_GCF_MASK,  
    kLPI2C_SlaveBusyFlag                = LPI2C_SSR_SBF_MASK,  
    kLPI2C_SlaveBusBusyFlag             = LPI2C_SSR_BBF_MASK,  
};
 
typedef enum _lpi2c_slave_address_match
{
    kLPI2C_MatchAddress0                = 0U, 
    kLPI2C_MatchAddress0OrAddress1      = 2U, 
    kLPI2C_MatchAddress0ThroughAddress1 = 6U, 
} lpi2c_slave_address_match_t;
 
typedef struct _lpi2c_slave_config
{
    bool enableSlave;                             
    uint8_t address0;                             
    uint8_t address1;                             
    lpi2c_slave_address_match_t addressMatchMode; 
    bool filterDozeEnable;                        
    bool filterEnable;                            
    bool enableGeneralCall;                       
    struct
    {
        bool enableAck;     
        bool enableTx;      
        bool enableRx;      
        bool enableAddress; 
    } sclStall;
    bool ignoreAck;                   
    bool enableReceivedAddressRead;   
    uint32_t sdaGlitchFilterWidth_ns; 
    uint32_t sclGlitchFilterWidth_ns; 
    uint32_t dataValidDelay_ns;       
    uint32_t clockHoldTime_ns;        
} lpi2c_slave_config_t;
 
typedef enum _lpi2c_slave_transfer_event
{
    kLPI2C_SlaveAddressMatchEvent = 0x01U,  
    kLPI2C_SlaveTransmitEvent     = 0x02U,  
    kLPI2C_SlaveReceiveEvent = 0x04U,       
    kLPI2C_SlaveTransmitAckEvent   = 0x08U, 
    kLPI2C_SlaveRepeatedStartEvent = 0x10U, 
    kLPI2C_SlaveCompletionEvent    = 0x20U, 
    kLPI2C_SlaveAllEvents = kLPI2C_SlaveAddressMatchEvent | kLPI2C_SlaveTransmitEvent | kLPI2C_SlaveReceiveEvent |
                            kLPI2C_SlaveTransmitAckEvent | kLPI2C_SlaveRepeatedStartEvent | kLPI2C_SlaveCompletionEvent,
} lpi2c_slave_transfer_event_t;
 
typedef struct _lpi2c_slave_transfer
{
    lpi2c_slave_transfer_event_t event; 
    uint8_t receivedAddress;            
    uint8_t *data;                      
    size_t dataSize;                    
    status_t completionStatus; 
    size_t transferredCount;   
} lpi2c_slave_transfer_t;
 
/* Forward declaration. */
typedef struct _lpi2c_slave_handle lpi2c_slave_handle_t;
 
typedef void (*lpi2c_slave_transfer_callback_t)(LPI2C_Type *base, lpi2c_slave_transfer_t *transfer, void *userData);
 
struct _lpi2c_slave_handle
{
    lpi2c_slave_transfer_t transfer;          
    bool isBusy;                              
    bool wasTransmit;                         
    uint32_t eventMask;                       
    uint32_t transferredCount;                
    lpi2c_slave_transfer_callback_t callback; 
    void *userData;                           
};
 
/*******************************************************************************
 * API
 ******************************************************************************/
 
#if defined(__cplusplus)
extern "C" {
#endif
 
 
void LPI2C_MasterGetDefaultConfig(lpi2c_master_config_t *masterConfig);
 
void LPI2C_MasterInit(LPI2C_Type *base, const lpi2c_master_config_t *masterConfig, uint32_t sourceClock_Hz);
 
void LPI2C_MasterDeinit(LPI2C_Type *base);
 
void LPI2C_MasterConfigureDataMatch(LPI2C_Type *base, const lpi2c_data_match_config_t *config);
 
/* Not static so it can be used from fsl_lpi2c_edma.c. */
status_t LPI2C_MasterCheckAndClearError(LPI2C_Type *base, uint32_t status);
 
/* Not static so it can be used from fsl_lpi2c_edma.c. */
status_t LPI2C_CheckForBusyBus(LPI2C_Type *base);
 
static inline void LPI2C_MasterReset(LPI2C_Type *base)
{
    base->MCR = LPI2C_MCR_RST_MASK;
    base->MCR = 0;
}
 
static inline void LPI2C_MasterEnable(LPI2C_Type *base, bool enable)
{
    base->MCR = (base->MCR & ~LPI2C_MCR_MEN_MASK) | LPI2C_MCR_MEN(enable);
}
 
 
static inline uint32_t LPI2C_MasterGetStatusFlags(LPI2C_Type *base)
{
    return base->MSR;
}
 
static inline void LPI2C_MasterClearStatusFlags(LPI2C_Type *base, uint32_t statusMask)
{
    base->MSR = statusMask;
}
 
 
static inline void LPI2C_MasterEnableInterrupts(LPI2C_Type *base, uint32_t interruptMask)
{
    base->MIER |= interruptMask;
}
 
static inline void LPI2C_MasterDisableInterrupts(LPI2C_Type *base, uint32_t interruptMask)
{
    base->MIER &= ~interruptMask;
}
 
static inline uint32_t LPI2C_MasterGetEnabledInterrupts(LPI2C_Type *base)
{
    return base->MIER;
}
 
 
static inline void LPI2C_MasterEnableDMA(LPI2C_Type *base, bool enableTx, bool enableRx)
{
    base->MDER = LPI2C_MDER_TDDE(enableTx) | LPI2C_MDER_RDDE(enableRx);
}
 
static inline uint32_t LPI2C_MasterGetTxFifoAddress(LPI2C_Type *base)
{
    return (uint32_t)&base->MTDR;
}
 
static inline uint32_t LPI2C_MasterGetRxFifoAddress(LPI2C_Type *base)
{
    return (uint32_t)&base->MRDR;
}
 
 
static inline void LPI2C_MasterSetWatermarks(LPI2C_Type *base, size_t txWords, size_t rxWords)
{
    base->MFCR = LPI2C_MFCR_TXWATER(txWords) | LPI2C_MFCR_RXWATER(rxWords);
}
 
static inline void LPI2C_MasterGetFifoCounts(LPI2C_Type *base, size_t *rxCount, size_t *txCount)
{
    if (NULL != txCount)
    {
        *txCount = (base->MFSR & LPI2C_MFSR_TXCOUNT_MASK) >> LPI2C_MFSR_TXCOUNT_SHIFT;
    }
    if (NULL != rxCount)
    {
        *rxCount = (base->MFSR & LPI2C_MFSR_RXCOUNT_MASK) >> LPI2C_MFSR_RXCOUNT_SHIFT;
    }
}
 
 
void LPI2C_MasterSetBaudRate(LPI2C_Type *base, uint32_t sourceClock_Hz, uint32_t baudRate_Hz);
 
static inline bool LPI2C_MasterGetBusIdleState(LPI2C_Type *base)
{
    return ((base->MSR & LPI2C_MSR_BBF_MASK) >> LPI2C_MSR_BBF_SHIFT) == 1U ? true : false;
}
 
status_t LPI2C_MasterStart(LPI2C_Type *base, uint8_t address, lpi2c_direction_t dir);
 
static inline status_t LPI2C_MasterRepeatedStart(LPI2C_Type *base, uint8_t address, lpi2c_direction_t dir)
{
    return LPI2C_MasterStart(base, address, dir);
}
 
status_t LPI2C_MasterSend(LPI2C_Type *base, void *txBuff, size_t txSize);
 
status_t LPI2C_MasterReceive(LPI2C_Type *base, void *rxBuff, size_t rxSize);
 
status_t LPI2C_MasterStop(LPI2C_Type *base);
 
status_t LPI2C_MasterTransferBlocking(LPI2C_Type *base, lpi2c_master_transfer_t *transfer);
 
 
void LPI2C_MasterTransferCreateHandle(LPI2C_Type *base,
                                      lpi2c_master_handle_t *handle,
                                      lpi2c_master_transfer_callback_t callback,
                                      void *userData);
 
status_t LPI2C_MasterTransferNonBlocking(LPI2C_Type *base,
                                         lpi2c_master_handle_t *handle,
                                         lpi2c_master_transfer_t *transfer);
 
status_t LPI2C_MasterTransferGetCount(LPI2C_Type *base, lpi2c_master_handle_t *handle, size_t *count);
 
void LPI2C_MasterTransferAbort(LPI2C_Type *base, lpi2c_master_handle_t *handle);
 
 
void LPI2C_MasterTransferHandleIRQ(LPI2C_Type *base, lpi2c_master_handle_t *handle);
 
 
void LPI2C_SlaveGetDefaultConfig(lpi2c_slave_config_t *slaveConfig);
 
void LPI2C_SlaveInit(LPI2C_Type *base, const lpi2c_slave_config_t *slaveConfig, uint32_t sourceClock_Hz);
 
void LPI2C_SlaveDeinit(LPI2C_Type *base);
 
static inline void LPI2C_SlaveReset(LPI2C_Type *base)
{
    base->SCR = LPI2C_SCR_RST_MASK;
    base->SCR = 0;
}
 
static inline void LPI2C_SlaveEnable(LPI2C_Type *base, bool enable)
{
    base->SCR = (base->SCR & ~LPI2C_SCR_SEN_MASK) | LPI2C_SCR_SEN(enable);
}
 
 
static inline uint32_t LPI2C_SlaveGetStatusFlags(LPI2C_Type *base)
{
    return base->SSR;
}
 
static inline void LPI2C_SlaveClearStatusFlags(LPI2C_Type *base, uint32_t statusMask)
{
    base->SSR = statusMask;
}
 
 
static inline void LPI2C_SlaveEnableInterrupts(LPI2C_Type *base, uint32_t interruptMask)
{
    base->SIER |= interruptMask;
}
 
static inline void LPI2C_SlaveDisableInterrupts(LPI2C_Type *base, uint32_t interruptMask)
{
    base->SIER &= ~interruptMask;
}
 
static inline uint32_t LPI2C_SlaveGetEnabledInterrupts(LPI2C_Type *base)
{
    return base->SIER;
}
 
 
static inline void LPI2C_SlaveEnableDMA(LPI2C_Type *base, bool enableAddressValid, bool enableRx, bool enableTx)
{
    base->SDER = (base->SDER & ~(LPI2C_SDER_AVDE_MASK | LPI2C_SDER_RDDE_MASK | LPI2C_SDER_TDDE_MASK)) |
                 LPI2C_SDER_AVDE(enableAddressValid) | LPI2C_SDER_RDDE(enableRx) | LPI2C_SDER_TDDE(enableTx);
}
 
 
static inline bool LPI2C_SlaveGetBusIdleState(LPI2C_Type *base)
{
    return ((base->SSR & LPI2C_SSR_BBF_MASK) >> LPI2C_SSR_BBF_SHIFT) == 1U ? true : false;
}
 
static inline void LPI2C_SlaveTransmitAck(LPI2C_Type *base, bool ackOrNack)
{
    base->STAR = LPI2C_STAR_TXNACK(!ackOrNack);
}
 
static inline uint32_t LPI2C_SlaveGetReceivedAddress(LPI2C_Type *base)
{
    return base->SASR & LPI2C_SASR_RADDR_MASK;
}
 
status_t LPI2C_SlaveSend(LPI2C_Type *base, void *txBuff, size_t txSize, size_t *actualTxSize);
 
status_t LPI2C_SlaveReceive(LPI2C_Type *base, void *rxBuff, size_t rxSize, size_t *actualRxSize);
 
 
void LPI2C_SlaveTransferCreateHandle(LPI2C_Type *base,
                                     lpi2c_slave_handle_t *handle,
                                     lpi2c_slave_transfer_callback_t callback,
                                     void *userData);
 
status_t LPI2C_SlaveTransferNonBlocking(LPI2C_Type *base, lpi2c_slave_handle_t *handle, uint32_t eventMask);
 
status_t LPI2C_SlaveTransferGetCount(LPI2C_Type *base, lpi2c_slave_handle_t *handle, size_t *count);
 
void LPI2C_SlaveTransferAbort(LPI2C_Type *base, lpi2c_slave_handle_t *handle);
 
 
void LPI2C_SlaveTransferHandleIRQ(LPI2C_Type *base, lpi2c_slave_handle_t *handle);
 
#if defined(__cplusplus)
}
#endif
 
#endif /* _FSL_LPI2C_H_ */