/* ------------------------------------------
 * Copyright (c) 2016, 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 2016.05
 * \date 2014-06-17
 * \author Huaqi Fang(Huaqi.Fang@synopsys.com)
--------------------------------------------- */

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

#ifndef _DEVICE_HAL_GPIO_H_
#define _DEVICE_HAL_GPIO_H_

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

/**
 * \defgroup	DEVICE_HAL_GPIO_DEFDIR	GPIO Port Direction Definition
 * \ingroup	DEVICE_HAL_GPIO
 * \brief	Define macros to indicate gpio directions
 * @{
 */
/*
 * defines for gpio directions
 */
#define GPIO_DIR_INPUT				(0)		/*!< gpio works as input */
#define GPIO_DIR_OUTPUT				(1)		/*!< gpio works as output */
/** @} */

/**
 * \defgroup	DEVICE_HAL_GPIO_CTRLCMD		GPIO Device Control Commands
 * \ingroup	DEVICE_HAL_GPIO
 * \brief	Definitions for gpio control command, used in \ref dev_gpio::gpio_control "GPIO 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_NOSPT,	Control command is not supported or not valid
 * @{
 */
/**
 * Set the \ref dev_gpio_info::direction "direction" of masked bits of gpio port into \ref GPIO_DIR_INPUT "input"
 * - Param type : uint32_t
 * - Param usage : 1 in each bit will be masked.
 * - Return value explanation :
 */
#define GPIO_CMD_SET_BIT_DIR_INPUT			DEV_SET_SYSCMD(0)
/**
 * Set the \ref dev_gpio_info::direction "direction" of masked bits of gpio port into \ref GPIO_DIR_OUTPUT "output"
 * - Param type : uint32_t
 * - Param usage : 1 in each bit will be masked.
 * - Return value explanation :
 */
#define GPIO_CMD_SET_BIT_DIR_OUTPUT			DEV_SET_SYSCMD(1)
/**
 * Get \ref dev_gpio_info::direction "gpio port direction".
 * - Param type : uint32_t
 * - Param usage : 1 bit for 1 bit of gpio port, 0 for input, 1 for output
 * - Return value explanation :
 */
#define GPIO_CMD_GET_BIT_DIR				DEV_SET_SYSCMD(2)
/**
 * Set gpio interrupt configuration for each bit.
 * - Param type : \ref DEV_GPIO_INT_CFG *
 * - Param usage : store gpio interrupt configuration for each bit.
 * - Return value explanation :
 */
#define GPIO_CMD_SET_BIT_INT_CFG			DEV_SET_SYSCMD(3)
/**
 * Get gpio interrupt configuration for each bit.
 * - Param type : \ref DEV_GPIO_INT_CFG *
 * - Param usage : First set int_bit_mask in DEV_GPIO_INT_CFG structure to
 * the mask of which bit of GPIO you want to get. And the interrupt configuration
 * will be stored in the structure DEV_GPIO_INT_CFG, each bit stand for each bit of port.
 * - Return value explanation :
 */
#define GPIO_CMD_GET_BIT_INT_CFG			DEV_SET_SYSCMD(4)
/**
 * Set gpio service routine for each bit.
 * - Param type : \ref DEV_GPIO_BIT_ISR *
 * - Param usage : store gpio handler information for each bit, int handler's param will be DEV_GPIO *.
 * - Return value explanation :
 */
#define GPIO_CMD_SET_BIT_ISR				DEV_SET_SYSCMD(5)
/**
 * Get gpio service routine for each bit.
 * - Param type : \ref DEV_GPIO_BIT_ISR *
 * - Param usage : By passing int_bit_ofs in DEV_GPIO_BIT_ISR,
 * it will return interrupt handler for this bit and store it in int_bit_handler.
 * - Return value explanation :
 */
#define GPIO_CMD_GET_BIT_ISR				DEV_SET_SYSCMD(6)
/**
 * Enable gpio interrupt of the masked bits.
 * - Param type : uint32_t
 * - Param usage : 1 in each bit will be masked.
 * - Return value explanation :
 */
#define GPIO_CMD_ENA_BIT_INT				DEV_SET_SYSCMD(7)
/**
 * Disable gpio interrupt of the masked bits.
 * - Param type : uint32_t
 * - Param usage : 1 in each bit will be masked.
 * - Return value explanation :
 */
#define GPIO_CMD_DIS_BIT_INT				DEV_SET_SYSCMD(8)
/**
 * Get \ref dev_gpio_info::method "gpio interrupt enable status".
 * - Param type : uint32_t *
 * - Param usage : 1 bit for 1 bit of gpio port, 0 for poll, 1 for interrupt
 * - Return value explanation :
 */
#define GPIO_CMD_GET_BIT_MTHD				DEV_SET_SYSCMD(9)
/* @} */

/**
 * \defgroup	DEVICE_HAL_GPIO_INT_CFG_SET	GPIO Device Int Configuration Settings
 * \ingroup	DEVICE_HAL_GPIO
 * \brief	definition of gpio interrupt type
 * @{
 */

/* GPIO Mask Defintions */
/** Mask none bits of the max 32bits */
#define GPIO_BITS_MASK_NONE			(0)
/** Mask all bits of the max 32bits */
#define GPIO_BITS_MASK_ALL			(0XFFFFFFFF)

/* GPIO Interrupt Type Related Definitions */

/** Level sensitive interrupt type for 1 bit */
#define GPIO_INT_LEVEL_TRIG			(0)
/** Edge sensitive interrupt type for 1 bit */
#define GPIO_INT_EDGE_TRIG			(1)
/** Level sensitive interrupt type for all 32 bits */
#define GPIO_INT_LEVEL_TRIG_ALL			(0)
/** Edge sensitive interrupt type for all 32 bits */
#define GPIO_INT_EDGE_TRIG_ALL			(0XFFFFFFFF)

/* For bit settings */
/** Set bit interrupt type of gpio into level sensitive */
#define GPIO_INT_BIT_LEVEL_TRIG(bit_ofs)	(GPIO_INT_LEVEL_TRIG<<(bit_ofs))
/** Set bit interrupt type of gpio into edge sensitive */
#define GPIO_INT_BIT_EDGE_TRIG(bit_ofs)		(GPIO_INT_EDGE_TRIG<<(bit_ofs))
/* For bits settings */
/** Set interrupt type of masked bits of gpio into level sensitive */
#define GPIO_INT_BITS_LEVEL_TRIG(bit_mask)	(GPIO_INT_LEVEL_TRIG_ALL&(bit_mask))
/** Set bit interrupt type of gpio into edge sensitive */
#define GPIO_INT_BITS_EDGE_TRIG(bit_mask)	(GPIO_INT_EDGE_TRIG_ALL&(bit_mask))

/* GPIO Interrupt Polarity Related Definitions */

/** GPIO Interrupt polarity type enum */
typedef enum gpio_int_polarity {
	/* Polarity for 1 bit */
	GPIO_INT_ACTIVE_LOW   = 0, /*!< Active low for level-sensitive interrupt for 1 bit */
	GPIO_INT_FALLING_EDGE = 0, /*!< Falling-edge for edge-sensitive interrupt for 1 bit */
	GPIO_INT_ACTIVE_HIGH =  1, /*!< Active high for level-sensitive interrupt for 1 bit */
	GPIO_INI_RISING_EDGE = 1, /*!< Rising-edge for edge-sensitive interrupt for 1 bit */
	/* Polartiy for all 32 bits */
	GPIO_INT_ACTIVE_LOW_ALL   = 0, /*!< Active low for level-sensitive interrupt for all bits */
	GPIO_INT_FALLING_EDGE_ALL = 0, /*!< Falling-edge for edge-sensitive interrupt for all bits */
	GPIO_INT_ACTIVE_HIGH_ALL =  0XFFFFFFFF, /*!< Active high for level-sensitive interrupt for all bits */
	GPIO_INI_RISING_EDGE_ALL = 0XFFFFFFFF /*!< Rising-edge for edge-sensitive interrupt for all bits */
} GPIO_INT_POLARITY;

/* For bit settings */
/** Set bit polarity of gpio into active low */
#define GPIO_INT_BIT_POL_ACT_LOW(bit_ofs)	(GPIO_INT_ACTIVE_LOW<<(bit_ofs))
/** Set bit polarity of gpio into active high */
#define GPIO_INT_BIT_POL_ACT_HIGH(bit_ofs)	(GPIO_INT_ACTIVE_HIGH<<(bit_ofs))
/** Set bit polarity of gpio into falling edge */
#define GPIO_INT_BIT_POL_FALL_EDGE(bit_ofs)	(GPIO_INT_FALLING_EDGE<<(bit_ofs))
/** Set bit polarity of gpio into rising edge */
#define GPIO_INT_BIT_POL_RISE_EDGE(bit_ofs)	(GPIO_INI_RISING_EDGE<<(bit_ofs))

/* For bits settings */
/** Set polarity of masked bits of gpio into active low */
#define GPIO_INT_BITS_POL_ACT_LOW(bit_mask)	(GPIO_INT_ACTIVE_LOW_ALL&(bit_mask))
/** Set polarity of masked bits of gpio into active high */
#define GPIO_INT_BITS_POL_ACT_HIGH(bit_mask)	(GPIO_INT_ACTIVE_HIGH_ALL&(bit_mask))
/** Set polarity of masked bits of gpio into falling edge */
#define GPIO_INT_BITS_POL_FALL_EDGE(bit_mask)	(GPIO_INT_FALLING_EDGE_ALL&(bit_mask))
/** Set polarity of masked bits of gpio into rising edge */
#define GPIO_INT_BITS_POL_RISE_EDGE(bit_mask)	(GPIO_INI_RISING_EDGE_ALL&(bit_mask))

/* GPIO Interrupt Debounce Related Definitions */

/* For bit settings */
/** Disable debounce circuitry for 1 bit */
#define GPIO_INT_NO_DEBOUNCE			(0)
/** Enable debounce circuitry for 1 bit */
#define GPIO_INT_DEBOUNCE			(1)

/* For bits settings */
/** Disable debounce circuitry for all bits */
#define GPIO_INT_NO_DEBOUNCE_ALL		(0)
/** Enable debounce circuitry for all bits */
#define GPIO_INT_DEBOUNCE_ALL			(0XFFFFFFFF)

/* For bit settings */
/** Set bit interrupt debounce of gpio into enabled */
#define GPIO_INT_BIT_ENA_DEBOUNCE(bit_ofs)	(GPIO_INT_DEBOUNCE<<(bit_ofs))
/** Set bit interrupt debounce of gpio into disabled */
#define GPIO_INT_BIT_DIS_DEBOUNCE(bit_ofs)	(GPIO_INT_NO_DEBOUNCE<<(bit_ofs))
/* For bits settings */
/** Set bit interrupt debounce of gpio into enabled */
#define GPIO_INT_BITS_ENA_DEBOUNCE(bit_mask)	(GPIO_INT_DEBOUNCE_ALL&(bit_mask))
/** Set bit interrupt debounce of gpio into disabled */
#define GPIO_INT_BITS_DIS_DEBOUNCE(bit_mask)	(GPIO_INT_NO_DEBOUNCE_ALL&(bit_mask))

/** GPIO interrupt configuration */
typedef struct dev_gpio_int_cfg {
	uint32_t int_bit_mask;		/*!< interrupt bit mask for gpio */
	uint32_t int_bit_type;		/*!< \ref GPIO_INT_LEVEL_TRIG "level sensitive" or \ref GPIO_INT_EDGE_TRIG "edge sensitive" for each gpio bit */
	uint32_t int_bit_polarity;	/*!< active high or low, refer to \ref GPIO_INT_POLARITY for each gpio bit */
	uint32_t int_bit_debounce;	/*!< \ref GPIO_INT_DEBOUNCE "enable" or \ref GPIO_INT_NO_DEBOUNCE "disable" debounce logic for each gpio bit */
} DEV_GPIO_INT_CFG, * DEV_GPIO_INT_CFG_PTR;

/** Default interrupt configuration for all gpio bits */
static const DEV_GPIO_INT_CFG gpio_int_cfg_default = \
	{GPIO_BITS_MASK_ALL, GPIO_INT_LEVEL_TRIG_ALL, \
		GPIO_INT_ACTIVE_LOW_ALL, GPIO_INT_NO_DEBOUNCE_ALL};

/** GPIO interrupt handler or Interrupt Service Routine(ISR) */
typedef void (*DEV_GPIO_HANDLER) (void *ptr);

/** interrupt handler for each port bit */
typedef struct dev_gpio_bit_isr {
	uint32_t int_bit_ofs;			/*!< int bit offset */
	DEV_GPIO_HANDLER int_bit_handler;	/*!< interrupt handler */
} DEV_GPIO_BIT_ISR, * DEV_GPIO_BIT_ISR_PTR;
/* @} */

/**
 * \defgroup	DEVICE_HAL_GPIO_DEVSTRUCT	GPIO Device Interface Definition
 * \ingroup	DEVICE_HAL_GPIO
 * \brief	contains definitions of gpio device structure.
 * \details	This structure will be used in user implemented code, which was called
 *     \ref DEVICE_IMPL "Device Driver Implement Layer" for gpio to use in implementation code.
 *     Application developer should use the GPIO API provided here to access to GPIO devices.
 *     BSP developer should follow the API definition to implement GPIO device drivers.
 * @{
 */
/**
 * \brief	gpio information struct definition
 * \details	informations about gpio open count, working status
 * 	gpio registers and control block, gpio io direction and interrupt/poll for each bit of gpio
 * \note	Only available for gpio with max 32bits
 */
typedef struct dev_gpio_info {
	void *gpio_ctrl;	/*!< gpio control related pointer, implemented by bsp developer, and this should be set during gpio object implementation */
	uint32_t opn_cnt;	/*!< gpio open count, open it will increase 1, close it will decrease 1, 0 for close, >0 for open */
	uint32_t direction;	/*!< each bit direction of this GPIO, default all \ref GPIO_DIR_INPUT "input" for first open */
	uint32_t method;	/*!< int/poll method for each bit of GPIO, 0 for poll, 1 for interrupt, default all \ref DEV_POLL_METHOD "poll" 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_GPIO_INFO_SET_EXTRA_OBJECT "set"
					or \ref DEV_GPIO_INFO_GET_EXTRA_OBJECT "get" the extra information pointer */
} DEV_GPIO_INFO, * DEV_GPIO_INFO_PTR;
/** Set extra information pointer of gpio info */
#define DEV_GPIO_INFO_SET_EXTRA_OBJECT(gpio_info_ptr, extra_info)	(gpio_info_ptr)->extra = (void *)(extra_info)
/** Get extra information pointer of gpio info */
#define DEV_GPIO_INFO_GET_EXTRA_OBJECT(gpio_info_ptr)			((gpio_info_ptr)->extra)

/** Method of all gpio bits set to poll */
#define DEV_GPIO_BITS_MTHD_POLL			(0)
/** Method of all gpio bits set to interrupt */
#define DEV_GPIO_BITS_MTHD_INTERRUPT		(0xFFFFFFFF)
/** Default method of all gpio bits should be poll for first open */
#define DEV_GPIO_BITS_MTHD_DEFAULT		(DEV_GPIO_BITS_MTHD_POLL)

/**
 * \brief	gpio device interface definition
 * \details	define gpio device interface, like gpio information structure,
 * 	fuctions to open/close/control gpio, write or read data via gpio
 * \note	all this details are implemented by user in user porting code
 */
typedef struct dev_gpio {
	DEV_GPIO_INFO gpio_info;		/*!< gpio device information */
	int32_t (*gpio_open) (uint32_t dir);	/*!< open gpio device with pre-defined gpio direction */
	int32_t (*gpio_close) (void);		/*!< close gpio device */
	int32_t (*gpio_control) (uint32_t ctrl_cmd, void *param);	/*!< control gpio device */
	int32_t (*gpio_write) (uint32_t val, uint32_t mask);	/*!< write gpio device with val, only write the masked bits */
	int32_t (*gpio_read) (uint32_t *val, uint32_t mask);	/*!< read gpio device val, only read the masked bits */
} DEV_GPIO, * DEV_GPIO_PTR;

/**
 * \fn		int32_t (* dev_gpio::gpio_open) (uint32_t dir)
 * \details	Open a gpio device with pre-defined io direction.
 * \param[in]	dir	gpio direction for each bit
 * \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_gpio_info::opn_cnt "opn_cnt" and return \ref E_OPNED
 * \retval	E_OBJ	Device object is not valid
 * \retval	E_PAR	Parameter is not valid
 * \retval	E_NOSPT	Open settings are not supported
 */

/**
 * \fn		int32_t (* dev_gpio::gpio_close) (void)
 * \details	Close an gpio device, just decrease the \ref dev_gpio_info::opn_cnt "opn_cnt",
 *      if \ref dev_gpio_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_gpio_info::opn_cnt "opn_cnt" decreased by 1
 * \retval	E_OBJ	Device object is not valid
 */

/**
 * \fn		int32_t (* dev_gpio::gpio_control) (uint32_t ctrl_cmd, void *param)
 * \details	Control an gpio device by \ref ctrl_cmd, with passed \ref param.
 * 	you can control gpio device using predefined gpio control commands defined using \ref DEV_SET_SYSCMD
 * 	(which must be implemented by bsp developer), such as \ref GPIO_CMD_SET_BIT_DIR_INPUT
 * 	"change masked gpio direction to input", and \ref DEVICE_HAL_GPIO_CTRLCMD "more".
 * 	And you can also control gpio device using your own specified commands defined using \ref DEV_SET_USRCMD,
 * 	but these specified commands should be defined in your own gpio device driver implementation.
 * \param[in]		ctrl_cmd	\ref DEVICE_HAL_GPIO_CTRLCMD "control command", to change or get some thing related to gpio
 * \param[in,out]	param		parameters that maybe argument of the command, or return values of the command
 * \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
 * \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, such as interrupt is not supported
 */

/**
 * \fn		int32_t (* dev_gpio::gpio_write) (uint32_t val, uint32_t mask)
 * \details	Write gpio with \ref val, and only change the masked bits of gpio.
 * \param[in]	val	the data that need to write to gpio
 * \param[in]	mask	gpio bit mask
 * \retval	E_OK	Write gpio with specified value successfully
 * \retval	E_OBJ	Device object is not valid or not exists
 * \retval	E_PAR	Parameter is not valid
 */

/**
 * \fn		int32_t (* dev_gpio::gpio_read) (uint32_t *val, uint32_t mask)
 * \details	Read the masked gpio value
 * \param[out]	val	pointer to data need to read from gpio
 * \param[in]	mask	gpio bit mask
 * \retval	E_OK	Read gpio data successfully
 * \retval	E_OBJ	Device object is not valid or not exists
 * \retval	E_PAR	Parameter is not valid
 */

/** @} */

#ifdef __cplusplus
extern "C" {
#endif

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

#ifdef __cplusplus
}
#endif

/** @} */
#endif /* _DEVICE_HAL_GPIO_H_ */