ad_i2c.h

Go to the documentation of this file.

 
#ifndef AD_I2C_H_
#define AD_I2C_H_
 
#if dg_configI2C_ADAPTER
 
#include "ad.h"
#include "hw_i2c.h"
#if (HW_I2C_DMA_SUPPORT == 1)
#include "hw_dma.h"
#endif /* HW_I2C_DMA_SUPPORT */
#include "hw_gpio.h"
#include "osal.h"
#include "resmgmt.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifndef CONFIG_I2C_USE_ASYNC_TRANSACTIONS
#define CONFIG_I2C_USE_ASYNC_TRANSACTIONS       (1)
#endif
 
#ifndef CONFIG_I2C_USE_SYNC_TRANSACTIONS
#define CONFIG_I2C_USE_SYNC_TRANSACTIONS        (1)
#endif
 
#if (CONFIG_I2C_USE_SYNC_TRANSACTIONS == 0) && (CONFIG_I2C_USE_ASYNC_TRANSACTIONS == 0)
#error "At least one macro CONFIG_I2C_USE_SYNC_TRANSACTIONS or CONFIG_I2C_USE_ASYNC_TRANSACTIONS must be set."
#endif
 
#if (HW_I2C_SLAVE_SUPPORT == 1)
#if (CONFIG_I2C_USE_SYNC_TRANSACTIONS == 0)
        #error "CONFIG_I2C_USE_SYNC_TRANSACTIONS must be set if HW_I2C_SLAVE_SUPPORT is set."
#endif
#endif
 
#ifndef I2C_DEFAULT_CLK_CFG
        #define I2C_DEFAULT_CLK_CFG .i2c.clock_cfg = { 0, 0, 0, 0, 0, 0 }
#endif
 
/*
 * Data types definitions section
 */
 
typedef void *ad_i2c_handle_t;
 
typedef struct {
        ad_io_conf_t scl; 
        ad_io_conf_t sda; 
} ad_i2c_io_conf_t;
 
typedef struct {
        i2c_config i2c;                 
#if (HW_I2C_DMA_SUPPORT == 1)
        HW_DMA_CHANNEL dma_channel;     
#endif /* HW_I2C_DMA_SUPPORT */
} ad_i2c_driver_conf_t;
 
typedef struct {
        const HW_I2C_ID id;                   
        const ad_i2c_io_conf_t *io;           
        const ad_i2c_driver_conf_t *drv;      
} ad_i2c_controller_conf_t;
 
typedef enum {
        AD_I2C_ERROR_IO_CFG_INVALID      = -6,
        AD_I2C_ERROR_CONTROLLER_ABORT_FAIL = -5,
        AD_I2C_ERROR_TRANSFER_TIMEOUT = -4,
        AD_I2C_ERROR_CONTROLLER_BUSY = -3,
        AD_I2C_ERROR_DRIVER_CONF_INVALID = -2,
        AD_I2C_ERROR_HANDLE_INVALID      = -1,
        AD_I2C_ERROR_NONE                =  0,
} AD_I2C_ERROR;
 
typedef void (*ad_i2c_user_cb)(void *user_data, HW_I2C_ABORT_SOURCE error);
 
void ad_i2c_init(void);
 
ad_i2c_handle_t ad_i2c_open(const ad_i2c_controller_conf_t *conf);
 
int ad_i2c_reconfig(ad_i2c_handle_t p, const ad_i2c_driver_conf_t *conf);
 
int ad_i2c_close(ad_i2c_handle_t p, bool force);
 
int ad_i2c_io_config(HW_I2C_ID id, const ad_i2c_io_conf_t *io, AD_IO_CONF_STATE state);
 
#if CONFIG_I2C_USE_SYNC_TRANSACTIONS
 
int ad_i2c_write(ad_i2c_handle_t p, const uint8_t *wbuf, size_t wlen, uint8_t condition_flags);
 
int ad_i2c_write_with_to(ad_i2c_handle_t p, const uint8_t *wbuf, size_t wlen, uint8_t condition_flags, OS_TICK_TIME timeout);
 
int ad_i2c_read(ad_i2c_handle_t p, uint8_t *rbuf, size_t rlen, uint8_t condition_flags);
 
int ad_i2c_read_with_to(ad_i2c_handle_t p, uint8_t *rbuf, size_t rlen, uint8_t condition_flags, OS_TICK_TIME timeout);
 
int ad_i2c_write_read(ad_i2c_handle_t p, const uint8_t *wbuf, size_t wlen, uint8_t *rbuf,
                      size_t rlen, uint8_t condition_flags);
 
int ad_i2c_write_read_with_to(ad_i2c_handle_t p, const uint8_t *wbuf, size_t wlen, uint8_t *rbuf,
                      size_t rlen, uint8_t condition_flags, OS_TICK_TIME timeout);
#endif /* CONFIG_I2C_USE_SYNC_TRANSACTIONS */
 
void ad_i2c_wait_while_master_busy(ad_i2c_handle_t p);
 
#if CONFIG_I2C_USE_ASYNC_TRANSACTIONS
/*
 * The following macros are used to construct asynchronous transactions on I2C device.
 */
 
int ad_i2c_write_async(ad_i2c_handle_t p, const uint8_t *wbuf, size_t wlen,
                        ad_i2c_user_cb cb, void *user_data, uint8_t condition_flags);
 
int ad_i2c_read_async(ad_i2c_handle_t p, uint8_t *rbuf, size_t rlen, ad_i2c_user_cb cb,
                       void *user_data, uint8_t condition_flags);
 
int ad_i2c_write_read_async(ad_i2c_handle_t p, const uint8_t *wbuf, size_t wlen, uint8_t *rbuf,
                            size_t rlen, ad_i2c_user_cb cb, void *user_data,
                            uint8_t condition_flags);
 
#endif /* CONFIG_I2C_USE_ASYNC_TRANSACTIONS */
 
#if (HW_I2C_SLAVE_SUPPORT == 1)
 
typedef void (* ad_i2c_slave_event)(ad_i2c_handle_t p, void *user_data);
typedef void (* ad_i2c_slave_data_event)(ad_i2c_handle_t p, uint16_t len, bool success,
                                         void *user_data);
 
typedef struct {
        ad_i2c_slave_data_event data_sent;      
        ad_i2c_slave_data_event data_received;  
        ad_i2c_slave_event data_ready;          
        ad_i2c_slave_event read_request;        
} i2c_dev_slave_event_callbacks_t;
 
typedef enum {
        AD_I2C_SLAVE_STATE_STOPPED = 0,
 
        AD_I2C_SLAVE_STATE_INIT = 0x1,
 
        AD_I2C_SLAVE_STATE_READ_PENDING = 0x2,
 
        AD_I2C_SLAVE_STATE_WRITE_PENDING = 0x4,
} AD_I2C_SLAVE_STATE;
 
typedef struct {
        const i2c_dev_slave_event_callbacks_t *event_callbacks;
        void *user_data;                        
        const uint8_t *output_buffer;           
        uint16_t output_buffer_len;
        uint8_t *input_buffer;                  
        uint16_t input_buffer_len;
 
        AD_I2C_SLAVE_STATE state;
        OS_EVENT operation_done_event;
} i2c_slave_state_data_t;
 
int ad_i2c_start_slave(ad_i2c_handle_t p, const uint8_t *wbuf, uint16_t wlen, uint8_t *rbuf,
                       uint16_t rlen, const i2c_dev_slave_event_callbacks_t *events,
                       void *user_data);
 
int ad_i2c_stop_slave(ad_i2c_handle_t p);
 
void ad_i2c_clear_read_slave(ad_i2c_handle_t p);
 
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif /* dg_configI2C_ADAPTER */
 
#endif /* AD_I2C_H_ */