/* ------------------------------------------
 * Copyright (c) 2017, Synopsys, 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:

 * 1) Redistributions of source code must retain the above copyright notice, this
 * list of conditions and the following disclaimer.

 * 2) 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.

 * 3) Neither the name of the Synopsys, 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.
 *
 * \version 2017.03
 * \date 2014-06-16
 * \author Huaqi Fang(Huaqi.Fang@synopsys.com)
--------------------------------------------- */

/**
 * \defgroup	DEVICE_HAL_IIC	IIC Device HAL Interface
 * \ingroup	DEVICE_HAL_DEF
 * \brief	definitions for iic device hardware layer (\ref dev_iic.h)
 * \details	provide interfaces for iic driver to implement
 *  Here is a diagram for the iic interface.
 *
 *  \htmlonly
 *  <div class="imagebox">
 *      <div style="width: 600px">
 *          <img src="pic/dev_iic_hal.jpg" alt="IIC Device HAL Interface Diagram"/>
 *          <p>IIC Device HAL Interface Diagram</p>
 *      </div>
 *  </div>
 *  \endhtmlonly
 *
 * @{
 *
 * \file
 * \brief	iic device hardware layer definitions
 * \details	provide common definitions for iic device,
 * 	then software developer can develop iic driver
 * 	following this definitions, and the applications
 * 	can directly call this definition to realize functions
 */

#ifndef _DEVICE_HAL_IIC_H_
#define _DEVICE_HAL_IIC_H_

#include "device/device_hal/inc/dev_common.h"

/**
 * \defgroup	DEVICE_HAL_IIC_CFG	IIC Related Configurations
 * \ingroup	DEVICE_HAL_IIC
 * \brief	Macros for IIC device related configurations.
 * @{
 */
/** IIC Bus possible speed modes */
typedef enum iic_speed_mode {
	IIC_SPEED_STANDARD = 0,	/*!< Bidirectional, Standard-mode (Sm), with a bit rate up to 100 kbit/s */
	IIC_SPEED_FAST     = 1,	/*!< Bidirectional, Fast-mode (Fm), with a bit rate up to 400 kbit/s */
	IIC_SPEED_FASTPLUS = 2,	/*!< Bidirectional, Fast-mode Plus (Fm+), with a bit rate up to 1 Mbit/s */
	IIC_SPEED_HIGH     = 3,	/*!< Bidirectional, High-speed mode (Hs-mode), with a bit rate up to 3.4 Mbit/s */
	IIC_SPEED_ULTRA    = 4	/*!< Unidirectional(Write only), Ultra Fast-mode (UFm), with a bit rate up to 5 Mbit/s */
} IIC_SPEED_MODE;

/** IIC next Condition */
typedef enum iic_next_condtion {
	IIC_MODE_STOP    = 0,	/*!< Send a STOP condition after write/read operation */
	IIC_MODE_RESTART = 1	/*!< Send a RESTART condition after write/read operation */
} IIC_NEXT_CONDTION;

/** IIC Error State */
typedef enum iic_error_state {
	IIC_ERR_NONE       = 0,	/*!< Currently in iic device free state */
	IIC_ERR_LOST_BUS   = 1,	/*!< Master or slave lost bus during operation */
	IIC_ERR_ADDR_NOACK = 2,	/*!< Slave address is sent but not addressed by any slave devices */
	IIC_ERR_DATA_NOACK = 3,	/*!< Data in transfer is not acked when it should be acked */
	IIC_ERR_TIMEOUT    = 4,	/*!< Transfer timeout, no more data is received or sent */
	IIC_ERR_MSTSTOP    = 5,	/*!< Slave received a STOP condition from master device */
	IIC_ERR_UNDEF      = 6	/*!< Undefined error cases */
} IIC_ERROR_STATE;

/** IIC Working State */
typedef enum iic_working_state {
	IIC_FREE  = 0,	/*!< Currently in iic device free state */
	IIC_IN_TX = 1,	/*!< Currently in iic master transmit state */
	IIC_IN_RX = 2	/*!< Currently in iic master receive state */
} IIC_WORKING_STATE;

/** IIC Addressing Mode */
typedef enum iic_address_mode {
	IIC_7BIT_ADDRESS  = 0,	/*!< Use 7bit address mode */
	IIC_10BIT_ADDRESS = 1	/*!< Use 10bit address mode */
} IIC_ADDRESS_MODE;

/** IIC Slave State */
typedef enum iic_slave_state {
	IIC_SLAVE_STATE_FREE     = 0,		/*!< None state, in free */
	IIC_SLAVE_STATE_START    = (1<<1),	/*!< Start or Restart condition, clear it when read */
	IIC_SLAVE_STATE_STOP     = (1<<2),	/*!< Stop condition, clear it when read */
	IIC_SLAVE_STATE_RD_REQ   = (1<<3),	/*!< Read request from master, this will trigger the slave transmit callback */
	IIC_SLAVE_STATE_RD_DONE  = (1<<4),	/*!< Read request done from master, clear it when read */
	IIC_SLAVE_STATE_WR_REQ   = (1<<5),	/*!< Write request from master, this will trigger the slave receive callback */
	IIC_SLAVE_STATE_GC_REQ   = (1<<6),	/*!< General call request from master */
	IIC_SLAVE_STATE_ERROR    = (1<<7)	/*!< Error, clear it when read */
} IIC_SLAVE_STATE;

/** 7bit IIC address mask */
#define IIC_7BIT_ADDRESS_MASK		(0x7F)
/** 10bit IIC address mask */
#define IIC_10BIT_ADDRESS_MASK		(0x3FF)
/** @} */

/**
 * \defgroup	DEVICE_HAL_IIC_CTRLCMD		IIC Device Control Commands
 * \ingroup	DEVICE_HAL_IIC
 * \brief	Definitions for iic control command, used in \ref dev_iic::iic_control "IIC IO Control"
 * \details	These commands defined here can be used in user code directly.
 * - Parameters Usage
 *   - For passing parameters like integer, just use uint32_t/int32_t to directly pass values
 *   - For passing parameters for a structure, please use pointer to pass values
 *   - For getting some data, please use pointer to store the return data
 * - Common Return Values
 *   - \ref E_OK,	Control device successfully
 *   - \ref E_CLSED,	Device is not opened
 *   - \ref E_OBJ,	Device object is not valid or not exists
 *   - \ref E_PAR,	Parameter is not valid for current control command
 *   - \ref E_SYS,	Control device failed, due to hardware issues such as device is disabled
 *   - \ref E_CTX,	Control device failed, due to different reasons like in transfer state
 *   - \ref E_NOSPT,	Control command is not supported or not valid
 * @{
 */

/** Define IIC control commands for common usage */
#define DEV_SET_IIC_SYSCMD(cmd)		DEV_SET_SYSCMD((cmd))
/** Define IIC control commands for master usage */
#define DEV_SET_IIC_MST_SYSCMD(cmd)	DEV_SET_SYSCMD(0x00004000|(cmd))
/** Define IIC control commands for slave usage */
#define DEV_SET_IIC_SLV_SYSCMD(cmd)	DEV_SET_SYSCMD(0x00008000|(cmd))

/* ++++ Common commands for IIC Device ++++ */
/**
 * Get \ref dev_iic_info::status "current device status"
 * - Param type : uint32_t *
 * - Param usage : store result of current status
 * - Return value explanation :
 */
#define IIC_CMD_GET_STATUS			DEV_SET_IIC_SYSCMD(0)
/**
 * Set \ref dev_iic_info::addr_mode "iic addressing mode".
 * - Param type : uint32_t
 * - Param usage : iic addressing mode, possible values can be found \ref IIC_ADDRESS_MODE "here"
 * - Return value explanation :
 */
#define IIC_CMD_SET_ADDR_MODE			DEV_SET_IIC_SYSCMD(1)
/**
 * Set \ref dev_iic_cbs::tx_cb "iic transmit success callback" function
 * when all required bytes are transmitted for interrupt method
 * - Param type : \ref DEV_CALLBACK * or NULL
 * - Param usage : transmit success callback function for iic
 * - Return value explanation :
 */
#define IIC_CMD_SET_TXCB			DEV_SET_IIC_SYSCMD(2)
/**
 * Set \ref dev_iic_cbs::rx_cb "iic receive success callback" function
 * when all required bytes are received for interrupt method
 * - Param type : \ref DEV_CALLBACK * or NULL
 * - Param usage : receive success callback function for iic
 * - Return value explanation :
 */
#define IIC_CMD_SET_RXCB			DEV_SET_IIC_SYSCMD(3)
/**
 * Set \ref dev_iic_cbs::err_cb "iic transfer error callback" function
 * when something error happened for interrupt method
 * - Param type : \ref DEV_CALLBACK * or NULL
 * - Param usage : transfer error callback function for iic
 * - Return value explanation :
 */
#define IIC_CMD_SET_ERRCB			DEV_SET_IIC_SYSCMD(4)
/**
 * Set buffer for interrupt transmit, and it will set \ref dev_iic_info::tx_buf "tx_buf".
 * - IIC master mode use case  \n
 *    For master mode, if you set tx buffer to NULL, when tx interrupt is enabled and entered into tx interrupt,
 * it will automatically disable the tx interrupt, so when you want to transfer something, you need to set the
 * tx buffer to Non-NULL and enable tx interrupt, when the tx buffer is sent, it will disable the tx interrupt
 * and call tx callback function if available.
 * - IIC slave mode use case   \n
 *    For slave mode, the tx buffer is not used, only tx callback function is used, and if tx callback is not set,
 * then it will automatically disable the tx interrupt, if tx callback is set, it will call the tx callback function
 * and you need to write or read in the tx callback function, to avoid meaningless waiting, you can use control command
 * \ref IIC_CMD_GET_TXAVAIL to get how many bytes space existing in transmit fifo, and use iic_write to send the available
 * bytes.
 * - Param type : DEV_BUFFER * or NULL
 * - Param usage : buffer structure pointer, if param is NULL, then it will set tx_buf to NULL
 * - Return value explanation :
 */
#define IIC_CMD_SET_TXINT_BUF			DEV_SET_IIC_SYSCMD(5)
/**
 * Set buffer for interrupt receive, and it will set \ref dev_iic_info::rx_buf "rx_buf"
 * - IIC master mode use case  \n
 *   Similar to \ref IIC_CMD_SET_TXINT_BUF
 * - IIC slave mode use case   \n
 *   Similiar to \ref IIC_CMD_SET_TXINT_BUF
 * - Param type : DEV_BUFFER * or NULL
 * - Param usage : buffer structure pointer, if param is NULL, then it will set rx_buf to NULL
 * - Return value explanation :
 */
#define IIC_CMD_SET_RXINT_BUF			DEV_SET_IIC_SYSCMD(6)
/**
 * Enable or disable transmit interrupt,
 * for master mode, only one of tx and rx interrupt can be enabled,
 * if tx interrupt is enabled, then rx interrupt can't be changed.
 * - Param type : uint32_t
 * - Param usage : enable(none-zero) or disable(zero) flag
 * - Return value explanation :
 */
#define IIC_CMD_SET_TXINT			DEV_SET_IIC_SYSCMD(7)
/**
 * Enable or disable receive interrupt,
 * for master mode, only one of tx and rx interrupt can be enabled,
 * if rx interrupt is enabled, then tx interrupt can't be changed.
 * - Param type : uint32_t
 * - Param usage : enable(none-zero) or disable(zero) flag
 * - Return value explanation :
 */
#define IIC_CMD_SET_RXINT			DEV_SET_IIC_SYSCMD(8)
/**
 * Abort current interrupt transmit operation if tx interrupt enabled,
 * it will disable transmit interrupt, and set \ref DEV_IN_TX_ABRT
 * in \ref dev_iic_info::status "status" variable,
 * and call the transmit callback function, when tx callback is finished,
 * it will clear \ref DEV_IN_TX_ABRT and return
 * - Param type : NULL
 * - Param usage :
 * - Return value explanation :
 */
#define IIC_CMD_ABORT_TX			DEV_SET_IIC_SYSCMD(9)
/**
 * Abort current interrupt receive operation if rx interrupt enabled,
 * it will disable receive interrupt, and set \ref DEV_IN_TX_ABRT
 * in \ref dev_iic_info::status "status" variable,
 * and call the receive callback function, when rx callback is finished,
 * it will clear \ref DEV_IN_TX_ABRT and return
 * - Param type : NULL
 * - Param usage :
 * - Return value explanation :
 */
#define IIC_CMD_ABORT_RX			DEV_SET_IIC_SYSCMD(10)
/**
 * Do a software reset for IIC device, it will stop current transfer,
 * and clear error state and bring device to normal state, set next condition to STOP
 * - Param type : NULL
 * - Param usage :
 * - Return value explanation :
 */
#define IIC_CMD_RESET				DEV_SET_IIC_SYSCMD(11)
/**
 * Flush iic device transmit buffer or fifo
 * - Param type : NULL
 * - Param usage :
 * - Return value explanation :
 */
#define IIC_CMD_FLUSH_TX			DEV_SET_IIC_SYSCMD(12)
/**
 * Flush iic device receive buffer or fifo
 * - Param type : NULL
 * - Param usage :
 * - Return value explanation :
 */
#define IIC_CMD_FLUSH_RX			DEV_SET_IIC_SYSCMD(13)
/**
 * Enable iic device
 * - Param type : NULL
 * - Param usage : param is not required
 * - Return value explanation :
 */
#define IIC_CMD_ENA_DEV				DEV_SET_IIC_SYSCMD(14)
/**
 * Disable iic device, when device is disabled,
 * only \ref IIC_CMD_ENA_DEV, \ref IIC_CMD_DIS_DEV,
 * \ref IIC_CMD_GET_STATUS and \ref IIC_CMD_RESET
 * commands can be executed, other commands will return \ref E_SYS
 * - Param type : NULL
 * - Param usage : param is not required
 * - Return value explanation :
 */
#define IIC_CMD_DIS_DEV				DEV_SET_IIC_SYSCMD(15)
/**
 * Get how many bytes space in iic are available to transmit,
 * this can be used in interrupt callback functions,
 * cooperate with \ref dev_iic::iic_write "iic_write" API to realize non-blocked write
 * - Param type : int32_t *
 * - Param usage : store the write available bytes, > 0 for available bytes, 0 for not available
 * - Return value explaination :
 */
#define IIC_CMD_GET_TXAVAIL			DEV_SET_IIC_SYSCMD(16)
/**
 * Get how many bytes in iic are available to receive,
 * this can be used in interrupt callback functions,
 * cooperate with \ref dev_iic::iic_read "iic_read" API to realize non-blocked read
 * - Param type : int32_t *
 * - Param usage : store the read available bytes, > 0 for available bytes, 0 for not available
 * - Return value explanation :
 */
#define IIC_CMD_GET_RXAVAIL			DEV_SET_IIC_SYSCMD(17)

/* ++++ Master only commands for IIC Device ++++ */
/**
 * Set \ref dev_iic_info::speed_mode "iic speed mode".
 * - Param type : uint32_t
 * - Param usage : iic speed mode, possible values can be found \ref IIC_SPEED_MODE "here",
 * and if passing mode is not supported, it will choose a lower supported speed mode
 * - Return value explanation :
 */
#define IIC_CMD_MST_SET_SPEED_MODE		DEV_SET_IIC_MST_SYSCMD(0)
/**
 * Set next condition for following transmit or receive operation.
 * For example, you can change next condition before iic_read or iic_write,
 * then in iic_read/iic_write operation, it will send a STOP/RESTART condition
 * after the last byte of this operation. For interrupt, this is similar.
 * - Param type : uint32_t
 * - Param usage : next condition can be \ref IIC_NEXT_CONDTION
 * - Return value explanation :
 */
#define IIC_CMD_MST_SET_NEXT_COND		DEV_SET_IIC_MST_SYSCMD(1)
/**
 * Set target slave device address for selecting slave device
 * - Param type : uint32_t
 * - Param usage : target slave address value
 * - Return value explanation :
 */
#define IIC_CMD_MST_SET_TAR_ADDR		DEV_SET_IIC_MST_SYSCMD(2)


/* ++++ Slave only commands for IIC Device ++++ */
/**
 * Set slave address when working as slave iic device
 * - Param type : uint32_t
 * - Param usage : slave address value
 * - Return value explanation :
 */
#define IIC_CMD_SLV_SET_SLV_ADDR		DEV_SET_IIC_SLV_SYSCMD(0)
/**
 * Get \ref iic_slave_state "slave state" when working as slave iic device
 * - Param type : uint32_t *
 * - Param usage : slave state
 * - Return value explanation :
 */
#define IIC_CMD_SLV_GET_SLV_STATE		DEV_SET_IIC_SLV_SYSCMD(1)

/** @} */

/**
 * \defgroup	DEVICE_HAL_IIC_CALLBACK	IIC Interrupt callback functions
 * \ingroup	DEVICE_HAL_IIC
 * \brief	callback function structure for IIC device
 * @{
 */
typedef struct dev_iic_cbs {
	DEV_CALLBACK tx_cb;	/*!< iic data transmit success required bytes callback */
	DEV_CALLBACK rx_cb;	/*!< iic data receive success required bytes callback */
	DEV_CALLBACK err_cb;	/*!< iic error callback */
} DEV_IIC_CBS, *DEV_IIC_CBS_PTR;
/** @} */

/**
 * \defgroup	DEVICE_HAL_IIC_DEVSTRUCT	IIC Device Structure
 * \ingroup	DEVICE_HAL_IIC
 * \brief	contains definitions of iic device structure.
 * \details	this structure will be used in user implemented code, which was called
 *     Device Driver Implement Layer for iic to realize in user code.
 * @{
 */
/**
 * \brief	iic information struct definition
 * \details	informations about iic open state, working state,
 * 	baurate, iic registers, working method, interrupt number
 */
typedef struct dev_iic_info {
	void *iic_ctrl;		/*!< iic control related pointer, implemented by bsp developer, and this should be set during iic object implementation */
	uint32_t opn_cnt;	/*!< iic open count, open it will increase 1, close it will decrease 1, 0 for close, >0 for open */
	uint32_t status;	/*!< current working status, refer to \ref DEVICE_HAL_COMMON_DEVSTATUS, this should be \ref DEV_ENABLED for first open */
	uint32_t mode;		/*!< current working mode, which can be \ref DEV_MASTER_MODE "master mode" or \ref DEV_SLAVE_MODE "slave mode" */
	uint32_t speed_mode;	/*!< current working \ref IIC_SPEED_MODE "iic speed mode" */
	uint32_t cur_state;	/*!< \ref IIC_WORKING_STATE "current working state for iic device", this should be \ref IIC_FREE for first open */
	uint32_t err_state;	/*!< \ref IIC_ERROR_STATE "current error state for iic device", this should be \ref IIC_ERR_NONE for first open */
	uint32_t addr_mode;	/*!< \ref IIC_ADDRESS_MODE "current addressing mode", this should be \ref IIC_7BIT_ADDRESS for first open */
	uint32_t slv_addr;	/*!< slave address when working as slave iic device, this should be 0 for first open */
	uint32_t tar_addr;	/*!< target slave device address when addressing that slave device, this should be 0 for first open */
	uint32_t next_cond;	/*!< \ref IIC_NEXT_CONDTION "next condition for master transmit or receive", \
					possible values are STOP or RESTART, it should be STOP for first open */
	DEV_BUFFER tx_buf;	/*!< transmit buffer via interrupt, this should be all zero for first open */
	DEV_BUFFER rx_buf;	/*!< receive buffer via interrupt, this should be all zero for first open */
	DEV_IIC_CBS iic_cbs;	/*!< iic callbacks, for both master and slave mode, this should be all NULL for first open */
	void *extra;		/*!< a extra pointer to get hook to applications which should not used by bsp developer,
					this should be NULL for first open and you can \ref DEV_IIC_INFO_SET_EXTRA_OBJECT "set"
					or \ref DEV_IIC_INFO_GET_EXTRA_OBJECT "get" the extra information pointer */
} DEV_IIC_INFO, * DEV_IIC_INFO_PTR;

/** Set extra information pointer of iic info */
#define DEV_IIC_INFO_SET_EXTRA_OBJECT(iic_info_ptr, extra_info)		(iic_info_ptr)->extra = (void *)(extra_info)
/** Get extra information pointer of iic info */
#define DEV_IIC_INFO_GET_EXTRA_OBJECT(iic_info_ptr)			((iic_info_ptr)->extra)

/**
 * \brief	iic device interface definition
 * \details	define iic device interface, like iic information structure,
 * 	fuctions to get iic info, open/close/control iic, send/receive data by iic
 * \note	all this details are implemented by user in user porting code
 */
typedef struct dev_iic {
	DEV_IIC_INFO iic_info;					/*!< iic device information */
	int32_t (*iic_open) (uint32_t mode, uint32_t param);	/*!< open iic device in master/slave mode, \
									when in master mode, param stands for speed mode, \
									when in slave mode, param stands for slave address */
	int32_t (*iic_close) (void);				/*!< close iic device */
	int32_t (*iic_control) (uint32_t ctrl_cmd, void *param);/*!< control iic device */
	int32_t (*iic_write) (const void *data, uint32_t len);	/*!< send data by iic device (blocking method) */
	int32_t (*iic_read) (void *data, uint32_t len);		/*!< read data from iic device (blocking method) */
} DEV_IIC, * DEV_IIC_PTR;

/**
 * \fn		int32_t (* dev_iic::iic_open) (uint32_t mode, uint32_t param)
 * \details	open an iic device with selected mode (master or slave) with defined \ref param
 * \param[in]	mode	working mode (\ref DEV_MASTER_MODE "master" or \ref DEV_SLAVE_MODE "slave")
 * \param[in]	param	When mode is \ref DEV_MASTER_MODE, param stands for \ref dev_iic_info::speed_mode "speed mode",
 * 			when mode is \ref DEV_SLAVE_MODE, param stands for \ref dev_iic_info::slv_addr "slave device 7bit address"
 * \retval	E_OK	Open successfully without any issues
 * \retval	E_OPNED	If device was opened before with different parameters,
 *			then just increase the \ref dev_iic_info::opn_cnt "opn_cnt" and return \ref E_OPNED
 * \retval	E_OBJ	Device object is not valid
 * \retval	E_SYS	Device is opened for different mode before, if you want to open it with different mode, you need to fully close it first.
 * \retval	E_PAR	Parameter is not valid
 * \retval	E_NOSPT	Open settings are not supported
 */

/**
 * \fn		int32_t (* dev_iic::iic_close) (void)
 * \details	close an iic device, just decrease the \ref dev_iic_info::opn_cnt "opn_cnt",
 *      if \ref dev_iic_info::opn_cnt "opn_cnt" equals 0, then close the device
 * \retval	E_OK	Close successfully without any issues(including scenario that device is already closed)
 * \retval	E_OPNED	Device is still opened, the device \ref dev_iic_info::opn_cnt "opn_cnt" decreased by 1
 * \retval	E_OBJ	Device object is not valid
 */

/**
 * \fn		int32_t (* dev_iic::iic_control) (uint32_t ctrl_cmd, void *param)
 * \details	control an iic device by \ref ctrl_cmd, with passed \ref param.
 * 	you can control iic device using predefined iic control commands defined using \ref DEV_SET_SYSCMD
 * 	(which must be implemented by bsp developer), such as \ref IIC_CMD_SET_SPEED "set iic speed mode",
 * 	\ref IIC_CMD_FLUSH_TX "flush tx" and \ref DEVICE_HAL_IIC_CTRLCMD "more".
 * 	And you can also control iic device using your own specified commands defined using \ref DEV_SET_USRCMD,
 * 	but these specified commands should be defined in your own iic device driver implementation.
 * \param[in]		ctrl_cmd	\ref DEVICE_HAL_IIC_CTRLCMD "control command", to change or get some thing related to iic
 * \param[in,out]	param		parameters that maybe argument of the command,
 * 					or return values of the command, must not be NULL
 * \retval	E_OK	Control device successfully
 * \retval	E_CLSED	Device is not opened
 * \retval	E_OBJ	Device object is not valid or not exists
 * \retval	E_PAR	Parameter is not valid for current control command
 * \retval	E_SYS	Control device failed, due to hardware issues, such as device is disabled
 * \retval	E_CTX	Control device failed, due to different reasons like in transfer state
 * \retval	E_NOSPT	Control command is not supported or not valid
 */

/**
 * \fn		int32_t (* dev_iic::iic_write) (const void *data, uint32_t len)
 * \details	send \ref data through iic with defined \ref len to slave device which slave address is \ref slv_addr.
 * \param[in]	data	pointer to data need to send by iic
 * \param[in]	len	length of data to be sent
 * \retval	>0	Byte count that was successfully sent for poll method,
 * 			it might can't send that much due to \ref \ref dev_iic_info::err_state "different error state".
 * \retval	E_OBJ	Device object is not valid or not exists
 * \retval	E_PAR	Parameter is not valid
 * \retval	E_CTX	Device is still in transfer state
 * \retval	E_SYS	Can't write data to hardware due to hardware issues, such as device is disabled
 */

/**
 * \fn		int32_t (* dev_iic::iic_read) (void *data, uint32_t len)
 * \details	receive \ref data of defined \ref len through iic from slave device which slave address is \ref slv_addr.
 * \param[out]	data	pointer to data need to received by iic
 * \param[in]	len	length of data to be received
 * \retval	>0	Byte count that was successfully received for poll method,
 * 			it might can't send that much due to \ref \ref dev_iic_info::err_state "different error state".
 * \retval	E_OBJ	Device object is not valid or not exists
 * \retval	E_CTX	Device is still in transfer state
 * \retval	E_PAR	Parameter is not valid
 * \retval	E_SYS	Can't receive data from hardware due to hardware issues, such as device is disabled
 */
/** @} */

#ifdef __cplusplus
extern "C" {
#endif

/**
 * \brief	get an \ref dev_iic "iic device" by iic device id.
 * 	For how to use iic device hal refer to \ref DEVICE_HAL_IIC_DEVSTRUCT "Functions in iic device structure"
 * \param[in]	iic_id	id of iic, defined by user
 * \retval	!NULL	pointer to an \ref dev_iic "iic device structure"
 * \retval	NULL	failed to find the iic device by \ref iic_id
 * \note	need to implemented by user in user code
 */
extern DEV_IIC_PTR iic_get_dev(int32_t iic_id);

#ifdef __cplusplus
}
#endif

/** @} */
#endif /* _DEVICE_HAL_IIC_H_ */