#include "os_config.h"

#include "regmap.h"

#include "c_def.h"
#include "debug.h"

#include "hw_gpio.h"

#include "flash_boot.h"


/*
#undef TX_DISABLE
#undef TX_RESTORE
#define TX_DISABLE
#define TX_RESTORE
*/


#undef static
#undef __inline__

__inline__ void gpio0_SetOutput_level(U32 mask,U8 level) __attribute__ ((section (".internal_ram_1_text")));

__inline__ void gpio0_MUX_select(U32 mask, U8 select)
{
	TX_INTERRUPT_SAVE_AREA;
	
	TX_DISABLE;

	switch(select)
	{
		case MUX_SEL_GPIO_INPUT:
			REG_GPIO0_FUNC &= ~mask;
	    	REG_GPIO3_FUNC &= ~mask;
			
			REG_GPIO0_DOE &= ~mask;
			REG_GPIO0_IE  |=  mask;
			break;
			
		case MUX_SEL_GPIO_OUTPUT:
			REG_GPIO0_FUNC &= ~mask;
	    	REG_GPIO3_FUNC &= ~mask;

		    REG_GPIO0_IE  &= ~mask;
			REG_GPIO0_DOE |=  mask;
			break;
			
		case MUX_SEL_FUNCTION1:
			REG_GPIO0_FUNC |= mask;
			break;
			
		case MUX_SEL_FUNCTION2:
			REG_GPIO0_FUNC &= ~mask;
			REG_GPIO3_FUNC |= mask;
			break;
			
		default:
			DBG_Assert(FALSE);
			break;
	}

	TX_RESTORE;
}

__inline__ void gpio0_SetOutput_level(U32 mask,U8 level)
{
	TX_INTERRUPT_SAVE_AREA;
	
	TX_DISABLE;
	
	if (level == GPIO_LOW)
	{
		REG_GPIO0_DOUT &= ~mask;
	}
	else
	{
		REG_GPIO0_DOUT |= mask;
	}
	
	TX_RESTORE;
}

__inline__ U32 gpio0_input_level_read(U32 mask)
{
	U32 tmp;
	
	tmp = (!(!(REG_GPIO0_DIN & mask)));
	//tmp = (REG_GPIO0_DIN & mask);
	return tmp;
}

__inline__ void gpio0_interrupt_set(U32 mask,U8 enable,U8 Trigger_type,U8 Trigger_level)
{
	TX_INTERRUPT_SAVE_AREA;
	
	TX_DISABLE;
	
	if (enable)
	{
		REG_GPIO0_INTST |= mask; //clear
		
		REG_GPIO0_INTEN |= mask;

		if (Trigger_type == TRIGGER_LEVEL)
		{
			//trigger by levle
			REG_GPIO0_INTTP0 |= mask;
		}
		else
		{
			//trigger by edge
			REG_GPIO0_INTTP0 &= ~mask;
		}
		
		if (Trigger_level == GPIO_INT_RISING_EDGE)
		{
			//rising or high
			REG_GPIO0_INTTP1 |= mask;
		}
		else
		{
			//falling or low
			REG_GPIO0_INTTP1 &= ~mask;

		}
		
	}
	else
	{
		REG_GPIO0_INTEN &= ~mask;
	}
	TX_RESTORE;
}

__inline__ U32 gpio0_interrupt_st_groud_read(void)
{
	U32 st;
	TX_INTERRUPT_SAVE_AREA;
	
	TX_DISABLE;
	
	st = REG_GPIO0_INTST;
	REG_GPIO0_INTST = st;        //clear int

	TX_RESTORE;
	
	return st;
}

__inline__ U32 gpio0_interrupt_st_mask_read(U32 mask)
{
	U32 st;
	TX_INTERRUPT_SAVE_AREA;
	
	TX_DISABLE;

	st = (REG_GPIO0_INTST & mask);
	REG_GPIO0_INTST = st;        //clear int
	st = !(!st);

	TX_RESTORE;
	
	return st;
}



__inline__ void gpio1_MUX_select(U32 mask, U8 select)
{
	TX_INTERRUPT_SAVE_AREA;
	
	TX_DISABLE;

	switch(select)
	{
		case MUX_SEL_GPIO_INPUT:
			REG_GPIO1_FUNC &= ~mask;
			
			REG_GPIO1_DOE &= ~mask;
		    REG_GPIO1_IE  |=  mask;
			break;
			
		case MUX_SEL_GPIO_OUTPUT:
			REG_GPIO1_FUNC &= ~mask;

		    REG_GPIO1_IE  &= ~mask;
			REG_GPIO1_DOE |=  mask;
			break;
			
		case MUX_SEL_FUNCTION1:
			REG_GPIO1_FUNC |= mask;
			break;
		
		case MUX_SEL_FUNCTION2:
			REG_GPIO2_FUNC &= ~mask;
			break;

		default:
			DBG_Assert(FALSE);
			break;
	}

	TX_RESTORE;
}

__inline__ void gpio1_SetOutput_level(U32 mask,U8 level)
{
	TX_INTERRUPT_SAVE_AREA;
	
	TX_DISABLE;
	
	if (level == GPIO_LOW)
	{
		REG_GPIO1_DOUT &= ~mask;
	}
	else
	{
		REG_GPIO1_DOUT |= mask;
	}
	
	TX_RESTORE;
}

__inline__ U32 gpio1_input_level_read(U32 mask)
{
	U32 tmp;
	
	tmp = (!(!(REG_GPIO1_DIN & mask)));
	//tmp = (REG_GPIO1_DIN & mask);
	return tmp;
}

__inline__ void gpio1_interrupt_set(U32 mask,U8 enable,U8 Trigger_type,U8 Trigger_level)
{
	TX_INTERRUPT_SAVE_AREA;
	
	TX_DISABLE;
	
	if (enable)
	{
		REG_GPIO1_INTST |= mask; //clear
		
		REG_GPIO1_INTEN |= mask;

		if (Trigger_type == TRIGGER_LEVEL)
		{
			//trigger by levle
			REG_GPIO1_INTTP0 |= mask;
		}
		else
		{
			//trigger by edge
			REG_GPIO1_INTTP0 &= ~mask;
		}
		
		if (Trigger_level == GPIO_INT_RISING_EDGE)
		{
			//rising or high
			REG_GPIO1_INTTP1 |= mask;
		}
		else
		{
			//falling or low
			REG_GPIO1_INTTP1 &= ~mask;

		}
		
	}
	else
	{
		REG_GPIO1_INTEN &= ~mask;
	}
	TX_RESTORE;
}

__inline__ U32 gpio1_interrupt_st_groud_read(void)
{
	U32 st;
	TX_INTERRUPT_SAVE_AREA;
	
	TX_DISABLE;
	
	st = REG_GPIO1_INTST;
	REG_GPIO1_INTST = st;        //clear int

	TX_RESTORE;
	
	return st;
}

__inline__ U32 gpio1_interrupt_st_mask_read(U32 mask)
{
	U32 st;
	TX_INTERRUPT_SAVE_AREA;
	
	TX_DISABLE;

	st = (REG_GPIO1_INTST & mask);
	REG_GPIO1_INTST = st;        //clear int
	st = !(!st);

	TX_RESTORE;
	
	return st;
}

__inline__ void gpio2_MUX_select(U32 mask, U8 select)
{
	TX_INTERRUPT_SAVE_AREA;
	
	TX_DISABLE;

	switch(select)
	{
		case MUX_SEL_GPIO_INPUT:
			REG_GPIO2_FUNC &= ~mask;
	    	REG_GPIO3_FUNC &= ~(mask<<16);
			
			REG_GPIO2_DOE &= ~mask;
		    REG_GPIO2_IE  |=  mask;
			break;
			
		case MUX_SEL_GPIO_OUTPUT:
			REG_GPIO2_FUNC &= ~mask;
	    	REG_GPIO3_FUNC &= ~(mask<<16);

		    REG_GPIO2_IE  &= ~mask;
			REG_GPIO2_DOE |=  mask;
			break;
			
		case MUX_SEL_FUNCTION1:
			REG_GPIO2_FUNC |= mask;
			break;
			
		case MUX_SEL_FUNCTION2:
#ifdef BOOT_FROM_FLASH
			if (mask >= (1<<15))//2[15]
			{
				REG_GPIO2_FUNC |= mask;
			}
			else
#endif
			{
				REG_GPIO2_FUNC &= ~mask;
		        REG_GPIO3_FUNC |= (mask<<16);	
			}
			break;
			
		default:
			DBG_Assert(FALSE);
			break;
	}

	TX_RESTORE;
}

__inline__ void gpio2_SetOutput_level(U32 mask,U8 level)
{
	TX_INTERRUPT_SAVE_AREA;
	
	TX_DISABLE;
	
	if (level == GPIO_LOW)
	{
		REG_GPIO2_DOUT &= ~mask;
	}
	else
	{
		REG_GPIO2_DOUT |= mask;
	}
	
	TX_RESTORE;
}

__inline__ U32 gpio2_input_level_read(U32 mask)
{
	U32 tmp;
	
	tmp = (!(!(REG_GPIO2_DIN & mask)));
	//tmp = (REG_GPIO2_DIN & mask);
	return tmp;
}

__inline__ void gpio2_interrupt_set(U32 mask,U8 enable,U8 Trigger_type,U8 Trigger_level)
{
	TX_INTERRUPT_SAVE_AREA;
	
	TX_DISABLE;
	
	if (enable)
	{
		REG_GPIO2_INTST |= mask; //clear
		
		REG_GPIO2_INTEN |= mask;

		if (Trigger_type == TRIGGER_LEVEL)
		{
			//trigger by levle
			REG_GPIO2_INTTP0 |= mask;
		}
		else
		{
			//trigger by edge
			REG_GPIO2_INTTP0 &= ~mask;
		}
		
		if (Trigger_level == GPIO_INT_RISING_EDGE)
		{
			//rising or high
			REG_GPIO2_INTTP1 |= mask;
		}
		else
		{
			//falling or low
			REG_GPIO2_INTTP1 &= ~mask;

		}
		
	}
	else
	{
		REG_GPIO2_INTEN &= ~mask;
	}
	TX_RESTORE;
}

__inline__ U32 gpio2_interrupt_st_groud_read(void)
{
	U32 st;
	TX_INTERRUPT_SAVE_AREA;
	
	TX_DISABLE;
	
	st = REG_GPIO2_INTST;
	REG_GPIO2_INTST = st;        //clear int

	TX_RESTORE;
	
	return st;
}

__inline__ U32 gpio2_interrupt_st_mask_read(U32 mask)
{
	U32 st;
	TX_INTERRUPT_SAVE_AREA;
	
	TX_DISABLE;

	st = (REG_GPIO2_INTST & mask);
	REG_GPIO2_INTST = st;        //clear int
	st = !(!st);

	TX_RESTORE;
	
	return st;
}


#if 0
/********gpio_index->GPIO_INDEX   con-> GPIOMUX_SEL ************/
void app_gpio_MUXfunction_select(U32 gpio_index, U8 con)
{
	if (gpio_index < GPIO_MAX_INDEX)
	{
		U8 gpio_group = gpio_index>>5;
		//TX_INTERRUPT_SAVE_AREA;

		//TX_DISABLE;
		switch (gpio_group)
		{
			case GPIO_GROUP0:
				gpio0_MUX_select(1<<gpio_index, con);
				break;

			case GPIO_GROUP1:
				gpio_index -= 32;
				gpio1_MUX_select(1<<gpio_index, con);
				break;

			case GPIO_GROUP2:
				gpio_index -= 64;
				gpio2_MUX_select(1<<gpio_index, con);
				break;
				
			default:
				DBG_Assert(FALSE);
				break;
		}	
		//TX_RESTORE;
	}
}

/********gpio_index->GPIO_INDEX   level-> GPIO_LEVEL ************/
void app_gpio_output_level_set(U32 gpio_index, U8 level)
{
	if (gpio_index < GPIO_MAX_INDEX)
	{
		U8 gpio_group = gpio_index>>5;

		switch (gpio_group)
		{
			case GPIO_GROUP0:
				gpio0_SetOutput_level(1<<gpio_index, level);
				break;

			case GPIO_GROUP1:
				gpio_index -= 32;
				gpio1_SetOutput_level(1<<gpio_index, level);
				break;

			case GPIO_GROUP2:
				gpio_index -= 64;
				gpio2_SetOutput_level(1<<gpio_index, level);
				break;
			default:
				DBG_Assert(FALSE);
				break;
		}
	}	
}

/********gpio_index->GPIO_INDEX   return GPIO_LEVEL (TRUE(HIGH) FALSE(LOW)) ************/
U32 app_gpio_input_level_read(U32 gpio_index)
{
	if (gpio_index < GPIO_MAX_INDEX)
	{
		U8 gpio_group = gpio_index>>5;
		U32 temp;

		switch (gpio_group)
		{
			case GPIO_GROUP0:
				temp = gpio0_input_level_read(1<<gpio_index);
				break;
				
			case GPIO_GROUP1:
				gpio_index -= 32;
				temp = gpio1_input_level_read(1<<gpio_index);
				break;
					
			case GPIO_GROUP2:
				gpio_index -= 64;
				temp = gpio2_input_level_read(1<<gpio_index);
				break;
			default:
				DBG_Assert(FALSE);
				break;
		}

		return temp;
	}
	return -1;	
}

/********gpio_index->GPIO_INDEX   enable->int onpen close    
Trigger_type->GPIO_INT_TRIGGER_TYPE  Trigger_level->GPIO_INT_TRIGGER_LEVEL************/
void app_gpio_interrupt_set(U32 gpio_index,U8 enable,U8 Trigger_type,U8 Trigger_level)
{
	if (gpio_index < GPIO_MAX_INDEX)
	{
		U8 gpio_group = gpio_index>>5;

		switch (gpio_group)
		{
			case GPIO_GROUP0:
				gpio0_interrupt_set(1<<gpio_index,enable,Trigger_type,Trigger_level);
				break;
				
			case GPIO_GROUP1:
				gpio_index -= 32;
				gpio1_interrupt_set(1<<gpio_index,enable,Trigger_type,Trigger_level);
				break;
					
			case GPIO_GROUP2:
				gpio_index -= 64;
				gpio2_interrupt_set(1<<gpio_index,enable,Trigger_type,Trigger_level);
				break;
			default:
				DBG_Assert(FALSE);
				break;
		}
	}	
}

/********gpio_index->GPIO_INDEX return gpio_index int status and clear************/
U32 app_gpio_interrupt_st_read_use_index(U32 gpio_index)
{
	if (gpio_index < GPIO_MAX_INDEX)
	{
		U8 gpio_group = gpio_index>>5;
		U32 temp;

		switch (gpio_group)
		{
			case GPIO_GROUP0:
				temp = gpio0_interrupt_st_mask_read(1<<gpio_index);
				break;
				
			case GPIO_GROUP1:
				gpio_index -= 32;
				temp = gpio1_interrupt_st_mask_read(1<<gpio_index);
				break;
					
			case GPIO_GROUP2:
				gpio_index -= 64;
				temp = gpio2_interrupt_st_mask_read(1<<gpio_index);
				break;
			default:
				temp = 0;
				DBG_Assert(FALSE);
				break;
		}

		return temp;
	}
	return -1;	
}

/********gpio_group->GPIO_GROUP   return gpio_group all int status and clear ************/
U32 app_gpio_interrupt_st_read_use_groud(U8 gpio_group)
{
	U32 temp;

	switch (gpio_group)
	{
		case GPIO_GROUP0:
			temp = gpio0_interrupt_st_groud_read();
			break;
			
		case GPIO_GROUP1:
			temp = gpio1_interrupt_st_groud_read();
			break;
				
		case GPIO_GROUP2:
			temp = gpio2_interrupt_st_groud_read();
			break;
		default:
			temp = 0;
			DBG_Assert(FALSE);
			break;
	}

	return temp;
}

#endif