fsl_i2c.h

/*
 * Copyright (c) 2015, Freescale Semiconductor, Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * o Redistributions of source code must retain the above copyright notice, this list
 *   of conditions and the following disclaimer.
 *
 * o 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.
 *
 * o Neither the name of Freescale Semiconductor, Inc. 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 HOLDER 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.
 */
#ifndef _FSL_I2C_H_
#define _FSL_I2C_H_

#include "fsl_common.h"

/*******************************************************************************
 * Definitions
 ******************************************************************************/

#define FSL_I2C_DRIVER_VERSION (MAKE_VERSION(2, 0, 0)) 
#if (defined(FSL_FEATURE_I2C_HAS_START_STOP_DETECT) && FSL_FEATURE_I2C_HAS_START_STOP_DETECT || \
     defined(FSL_FEATURE_I2C_HAS_STOP_DETECT) && FSL_FEATURE_I2C_HAS_STOP_DETECT)
#define I2C_HAS_STOP_DETECT
#endif /* FSL_FEATURE_I2C_HAS_START_STOP_DETECT / FSL_FEATURE_I2C_HAS_STOP_DETECT */

enum _i2c_status
{
    kStatus_I2C_Busy = MAKE_STATUS(kStatusGroup_I2C, 0),            
    kStatus_I2C_Idle = MAKE_STATUS(kStatusGroup_I2C, 1),            
    kStatus_I2C_Nak = MAKE_STATUS(kStatusGroup_I2C, 2),             
    kStatus_I2C_ArbitrationLost = MAKE_STATUS(kStatusGroup_I2C, 3), 
    kStatus_I2C_Timeout = MAKE_STATUS(kStatusGroup_I2C, 4),         
};

enum _i2c_flags
{
    kI2C_ReceiveNakFlag = I2C_S_RXAK_MASK,       
    kI2C_IntPendingFlag = I2C_S_IICIF_MASK,      
    kI2C_TransferDirectionFlag = I2C_S_SRW_MASK, 
    kI2C_RangeAddressMatchFlag = I2C_S_RAM_MASK, 
    kI2C_ArbitrationLostFlag = I2C_S_ARBL_MASK,  
    kI2C_BusBusyFlag = I2C_S_BUSY_MASK,          
    kI2C_AddressMatchFlag = I2C_S_IAAS_MASK,     
    kI2C_TransferCompleteFlag = I2C_S_TCF_MASK,  
#ifdef I2C_HAS_STOP_DETECT
    kI2C_StopDetectFlag = I2C_FLT_STOPF_MASK << 8, 
#endif /* FSL_FEATURE_I2C_HAS_START_STOP_DETECT / FSL_FEATURE_I2C_HAS_STOP_DETECT */

#if defined(FSL_FEATURE_I2C_HAS_START_STOP_DETECT) && FSL_FEATURE_I2C_HAS_START_STOP_DETECT
    kI2C_StartDetectFlag = I2C_FLT_STARTF_MASK << 8, 
#endif                                               /* FSL_FEATURE_I2C_HAS_START_STOP_DETECT */
};

enum _i2c_interrupt_enable
{
    kI2C_GlobalInterruptEnable = I2C_C1_IICIE_MASK, 
#if defined(FSL_FEATURE_I2C_HAS_STOP_DETECT) && FSL_FEATURE_I2C_HAS_STOP_DETECT
    kI2C_StopDetectInterruptEnable = I2C_FLT_STOPIE_MASK, 
#endif                                                    /* FSL_FEATURE_I2C_HAS_STOP_DETECT */

#if defined(FSL_FEATURE_I2C_HAS_START_STOP_DETECT) && FSL_FEATURE_I2C_HAS_START_STOP_DETECT
    kI2C_StartStopDetectInterruptEnable = I2C_FLT_SSIE_MASK, 
#endif                                                       /* FSL_FEATURE_I2C_HAS_START_STOP_DETECT */
};

typedef enum _i2c_direction
{
    kI2C_Write = 0x0U, 
    kI2C_Read = 0x1U,  
} i2c_direction_t;

typedef enum _i2c_slave_address_mode
{
    kI2C_Address7bit = 0x0U, 
    kI2C_RangeMatch = 0X2U,  
} i2c_slave_address_mode_t;

enum _i2c_master_transfer_flags
{
    kI2C_TransferDefaultFlag = 0x0U,       
    kI2C_TransferNoStartFlag = 0x1U,       
    kI2C_TransferRepeatedStartFlag = 0x2U, 
    kI2C_TransferNoStopFlag = 0x4U,        
};

typedef enum _i2c_slave_transfer_event
{
    kI2C_SlaveAddressMatchEvent = 0x01U, 
    kI2C_SlaveTransmitEvent = 0x02U,     
    kI2C_SlaveReceiveEvent = 0x04U,      
    kI2C_SlaveTransmitAckEvent = 0x08U,  
#if defined(FSL_FEATURE_I2C_HAS_START_STOP_DETECT) && FSL_FEATURE_I2C_HAS_START_STOP_DETECT
    kI2C_SlaveRepeatedStartEvent = 0x10U, 
#endif
    kI2C_SlaveCompletionEvent = 0x20U, 
    kI2C_SlaveAllEvents = kI2C_SlaveAddressMatchEvent | kI2C_SlaveTransmitEvent | kI2C_SlaveReceiveEvent |
#if defined(FSL_FEATURE_I2C_HAS_START_STOP_DETECT) && FSL_FEATURE_I2C_HAS_START_STOP_DETECT
                          kI2C_SlaveRepeatedStartEvent |
#endif
                          kI2C_SlaveCompletionEvent,
} i2c_slave_transfer_event_t;

typedef struct _i2c_master_config
{
    bool enableMaster; 
#if defined(FSL_FEATURE_I2C_HAS_HIGH_DRIVE_SELECTION) && FSL_FEATURE_I2C_HAS_HIGH_DRIVE_SELECTION
    bool enableHighDrive; 
#endif
#if defined(FSL_FEATURE_I2C_HAS_STOP_HOLD_OFF) && FSL_FEATURE_I2C_HAS_STOP_HOLD_OFF
    bool enableStopHold; 
#endif
    uint32_t baudRate_Bps;     
    uint8_t glitchFilterWidth; 
} i2c_master_config_t;

typedef struct _i2c_slave_config
{
    bool enableSlave;       
    bool enableGeneralCall; 
    bool enableWakeUp;      
#if defined(FSL_FEATURE_I2C_HAS_HIGH_DRIVE_SELECTION) && FSL_FEATURE_I2C_HAS_HIGH_DRIVE_SELECTION
    bool enableHighDrive; 
#endif
    bool enableBaudRateCtl; 
    uint16_t slaveAddress;  
    uint16_t upperAddress;  
    i2c_slave_address_mode_t addressingMode; 
} i2c_slave_config_t;

typedef struct _i2c_master_handle i2c_master_handle_t;

typedef void (*i2c_master_transfer_callback_t)(I2C_Type *base,
                                               i2c_master_handle_t *handle,
                                               status_t status,
                                               void *userData);

typedef struct _i2c_slave_handle i2c_slave_handle_t;

typedef struct _i2c_master_transfer
{
    uint32_t flags;            
    uint8_t slaveAddress;      
    i2c_direction_t direction; 
    uint32_t subaddress;       
    uint8_t subaddressSize;    
    uint8_t *volatile data;    
    volatile size_t dataSize;  
} i2c_master_transfer_t;

struct _i2c_master_handle
{
    i2c_master_transfer_t transfer;                    
    size_t transferSize;                               
    uint8_t state;                                     
    i2c_master_transfer_callback_t completionCallback; 
    void *userData;                                    
};

typedef struct _i2c_slave_transfer
{
    i2c_slave_transfer_event_t event; 
    uint8_t *volatile data;           
    volatile size_t dataSize;         
    status_t completionStatus;        
    size_t transferredCount;          
} i2c_slave_transfer_t;

typedef void (*i2c_slave_transfer_callback_t)(I2C_Type *base, i2c_slave_transfer_t *xfer, void *userData);

struct _i2c_slave_handle
{
    bool isBusy;                            
    i2c_slave_transfer_t transfer;          
    uint32_t eventMask;                     
    i2c_slave_transfer_callback_t callback; 
    void *userData;                         
};

/*******************************************************************************
 * API
 ******************************************************************************/

#if defined(__cplusplus)
extern "C" {
#endif /*_cplusplus. */

void I2C_MasterInit(I2C_Type *base, const i2c_master_config_t *masterConfig, uint32_t srcClock_Hz);

void I2C_SlaveInit(I2C_Type *base, const i2c_slave_config_t *slaveConfig);

void I2C_MasterDeinit(I2C_Type *base);

void I2C_SlaveDeinit(I2C_Type *base);

void I2C_MasterGetDefaultConfig(i2c_master_config_t *masterConfig);

void I2C_SlaveGetDefaultConfig(i2c_slave_config_t *slaveConfig);

static inline void I2C_Enable(I2C_Type *base, bool enable)
{
    if (enable)
    {
        base->C1 |= I2C_C1_IICEN_MASK;
    }
    else
    {
        base->C1 &= ~I2C_C1_IICEN_MASK;
    }
}

/* @} */

uint32_t I2C_MasterGetStatusFlags(I2C_Type *base);

static inline uint32_t I2C_SlaveGetStatusFlags(I2C_Type *base)
{
    return I2C_MasterGetStatusFlags(base);
}

static inline void I2C_MasterClearStatusFlags(I2C_Type *base, uint32_t statusMask)
{
/* Must clear the STARTF / STOPF bits prior to clearing IICIF */
#if defined(FSL_FEATURE_I2C_HAS_START_STOP_DETECT) && FSL_FEATURE_I2C_HAS_START_STOP_DETECT
    if (statusMask & kI2C_StartDetectFlag)
    {
        /* Shift the odd-ball flags back into place. */
        base->FLT |= (uint8_t)(statusMask >> 8U);
    }
#endif

#ifdef I2C_HAS_STOP_DETECT
    if (statusMask & kI2C_StopDetectFlag)
    {
        /* Shift the odd-ball flags back into place. */
        base->FLT |= (uint8_t)(statusMask >> 8U);
    }
#endif

    base->S = (uint8_t)statusMask;
}

static inline void I2C_SlaveClearStatusFlags(I2C_Type *base, uint32_t statusMask)
{
    I2C_MasterClearStatusFlags(base, statusMask);
}

/* @} */

void I2C_EnableInterrupts(I2C_Type *base, uint32_t mask);

void I2C_DisableInterrupts(I2C_Type *base, uint32_t mask);

#if defined(FSL_FEATURE_I2C_HAS_DMA_SUPPORT) && FSL_FEATURE_I2C_HAS_DMA_SUPPORT

static inline void I2C_EnableDMA(I2C_Type *base, bool enable)
{
    if (enable)
    {
        base->C1 |= I2C_C1_DMAEN_MASK;
    }
    else
    {
        base->C1 &= ~I2C_C1_DMAEN_MASK;
    }
}

#endif /* FSL_FEATURE_I2C_HAS_DMA_SUPPORT */

static inline uint32_t I2C_GetDataRegAddr(I2C_Type *base)
{
    return (uint32_t)(&(base->D));
}

/* @} */
void I2C_MasterSetBaudRate(I2C_Type *base, uint32_t baudRate_Bps, uint32_t srcClock_Hz);

status_t I2C_MasterStart(I2C_Type *base, uint8_t address, i2c_direction_t direction);

status_t I2C_MasterStop(I2C_Type *base);

status_t I2C_MasterRepeatedStart(I2C_Type *base, uint8_t address, i2c_direction_t direction);

status_t I2C_MasterWriteBlocking(I2C_Type *base, const uint8_t *txBuff, size_t txSize);

status_t I2C_MasterReadBlocking(I2C_Type *base, uint8_t *rxBuff, size_t rxSize);

status_t I2C_SlaveWriteBlocking(I2C_Type *base, const uint8_t *txBuff, size_t txSize);

void I2C_SlaveReadBlocking(I2C_Type *base, uint8_t *rxBuff, size_t rxSize);

status_t I2C_MasterTransferBlocking(I2C_Type *base, i2c_master_transfer_t *xfer);

/* @} */

void I2C_MasterTransferCreateHandle(I2C_Type *base,
                                    i2c_master_handle_t *handle,
                                    i2c_master_transfer_callback_t callback,
                                    void *userData);

status_t I2C_MasterTransferNonBlocking(I2C_Type *base, i2c_master_handle_t *handle, i2c_master_transfer_t *xfer);

status_t I2C_MasterTransferGetCount(I2C_Type *base, i2c_master_handle_t *handle, size_t *count);

void I2C_MasterTransferAbort(I2C_Type *base, i2c_master_handle_t *handle);

void I2C_MasterTransferHandleIRQ(I2C_Type *base, void *i2cHandle);

void I2C_SlaveTransferCreateHandle(I2C_Type *base,
                                   i2c_slave_handle_t *handle,
                                   i2c_slave_transfer_callback_t callback,
                                   void *userData);

status_t I2C_SlaveTransferNonBlocking(I2C_Type *base, i2c_slave_handle_t *handle, uint32_t eventMask);

void I2C_SlaveTransferAbort(I2C_Type *base, i2c_slave_handle_t *handle);

status_t I2C_SlaveTransferGetCount(I2C_Type *base, i2c_slave_handle_t *handle, size_t *count);

void I2C_SlaveTransferHandleIRQ(I2C_Type *base, void *i2cHandle);

/* @} */
#if defined(__cplusplus)
}
#endif /*_cplusplus. */

#endif /* _FSL_I2C_H_*/