mcu/driver/devdrv/gpio/src/drv_gpio.c

/*****************************************************************************
*  Copyright Statement:
*  --------------------
*  This software is protected by Copyright and the information contained
*  herein is confidential. The software may not be copied and the information
*  contained herein may not be used or disclosed except with the written
*  permission of MediaTek Inc. (C) 2012
*
*  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
*  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
*  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
*  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
*  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
*  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
*  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
*  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
*  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
*  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
*  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
*  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
*
*  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
*  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
*  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
*  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
*  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
*
*  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
*  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
*  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
*  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
*  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
*
*****************************************************************************/

/*******************************************************************************
 * Filename:
 * ---------
 *   drv_gpio.c
 *
 * Project:
 * --------
 *   TATAKA
 *
 * Description:
 * ------------
 *   Low level GPIO driver
 *
 * Author:
 * -------
 * -------
 *
 * ==========================================================================
 * $Log$
 *
 * 05 06 2022 yao.xue
 * [MOLY00851720] [FM350][MIPI][IO_Driving][clock speed][zontn.wang]The MIPI IO Driving strength and clock speed setting
 * modify GPIO IOCFG regbase.
 *
 * 11 16 2020 zhiqiang.yu
 * [MOLY00595491] [Colgin]MD GPIO DRV Patchback From T700 Branch
 * 	
 * 	.
 *
 * 11 11 2020 zhiqiang.yu
 * [MOLY00593568] [MT6877]Call For Check In MD GPIO Drv
 * 	
 * 	.
 *
 * 07 16 2020 zhiqiang.yu
 * [MOLY00546611] [MT6833]Call For Check In MD GPIO Driver
 * 	
 * 	.
 *
 * 01 21 2020 zhiqiang.yu
 * [MOLY00476172] [MT6853]Call For Check In GPIO Drv
 * 	
 * 	.
 *
 * 12 04 2019 zhiqiang.yu
 * [MOLY00463572] [MMRF] Ddie driving customization development
 * 	
 * 	.GPIO DRIVER
 *
 * 09 24 2019 zhiqiang.yu
 * [MOLY00443103] [MT6873]Check in md gpio driver
 * 	
 * 	.
 *
 * 06 18 2019 zhiqiang.yu
 * [MOLY00413533] [MT6297]Fix GPIO Drv build Warning about LTO
 * 	
 * 	.
 *
 * 12 07 2018 zhiqiang.yu
 * [MOLY00371362] [Pertus]check in gpio drv
 * 	
 * 	.fix build error
 *
 * 08 21 2018 zhiqiang.yu
 * [MOLY00347417] [MT6297][VMOLY]check in md gpio&eint drv
 * 	
 * 	.fix build error
 *
 * 08 02 2018 zhiqiang.yu
 * [MOLY00343825] [MT6779]Call For Check In,gpio driver
 * 	
 * 	.
 *
 * 04 03 2018 zhiqiang.yu
 * remove ownership@6290.
 *
 * 12 18 2017 zhiqiang.yu
 * [MOLY00296840] [EIGER]call for mt3967 gpio driver
 * 	
 * 	.
 *
 * 11 01 2017 zhiqiang.yu
 * [MOLY00244517] [MT6295M]fix build error,for gpio driver.patch back from LR12A.MP2.MT6295M.DEV.
 *
 * 10 30 2017 zhiqiang.yu
 * [MOLY00286048] [MT6765]check in gpio drv for MT6765.
 *
 * 08 24 2017 zhiqiang.yu
 * [MOLY00273500] [MT6771]check in md gpio driver
 * 	
 * 	.
 *
 * 06 12 2017 zhiqiang.yu
 * [MOLY00244007] [MT6739]check in gpio driver for zion
 * 	
 * 	.
 *
 * 11 16 2016 zhiqiang.yu
 * [MOLY00213576] [MT6763]eint&gpio driver check in.
 *
 * 02 22 2016 zhiqiang.yu
 * [MOLY00165689] Code Inspection and MSBB Scan
 * Fix high impact defect.
 *
 * 08 04 2015 zhiqiang.yu
 * [MOLY00135213] check in gpiodriver code for mt6797 project
 * .
 *
 * 07 22 2015 zhiqiang.yu
 * [MOLY00131033] enable sp set gpio mode funtion
 * 	<saved by Perforce>
 *
 * 06 17 2015 zhiqiang.yu
 * [MOLY00121904] checkin md eint code for mt6755
 * .
 *
 * 06 16 2015 zhiqiang.yu
 * [MOLY00121625] checkin md gpio code for mt6755
 * 	.
 *
 * 06 30 2014 chuanbo.liao
 * [MOLY00070787] [tk6291]fix 6291 build error
 * [6291]modify the EINT/GPIO base address
 *
 * 05 10 2013 da.wang
 * [MOLY00022149] [MT6290E1][TRUNK] Add GPIO driver API for Meta mode solution
 * Upload GPIO driver API for meta mode.
 *
 * 02 04 2013 da.wang
 * [MOLY00009904] [GPIO/EINT] Rename MT7280 to MT6290 on MOLY trunk
 * .rename GPIO/EINT related keywords MT7208 to MT6290 in MOLY
 ****************************************************************************/
#include "drv_comm.h"
#include "drv_gpio.h"
#include "kal_general_types.h"
#include "devdrv_ls.h"


//========================================================================
//  Global variable
//========================================================================   

#ifdef __CUST_NEW__
   #if defined(DRV_GPIO_8_MODES) || defined(DRV_GPIO_MODE_4BITS)
   extern const kal_uint32  gpio_mode_allowed[][8];
   #else //defined(DRV_GPIO_8_MODES) || defined(DRV_GPIO_MODE_4BITS)
extern const kal_uint32  gpio_mode_allowed[][4];
   #endif //defined(DRV_GPIO_8_MODES) || defined(DRV_GPIO_MODE_4BITS)
extern const kal_uint32  gpio_dir_out_allowed[];
extern const kal_uint32  gpio_dir_in_allowed[];
extern const kal_uint16  gpo_mode_allowed[];
extern kal_uint32  gpio_check_for_write[];
extern kal_uint32  gpio_check_for_read[];
extern kal_uint16  gpo_check_for_write[];
extern kal_bool   gpio_debug_enable;
#endif /* __CUST_NEW__ */

#if 0
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
#endif

//========================================================================
/**
 *  @brief     get direction register value of pin
 *  @param  gpio_pin :  The GPIO pin to be read.
 *  @return   return the direction register value of gpio_pin
 *		      0:                 the direction of gpio is input
 *            1:                 the direction of gpio is output
 *            GPIO_FAIL:   gpio_pin is out of range
 */
kal_int32 gpio_get_dir_value (gpio_pin_e gpio_pin)
{
#if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992)
	unsigned long pos;
	unsigned long bit;
	unsigned long data;

	if (gpio_pin>GPIO_PIN_MAX)
	{
		GPIO_ERR("The gpio pin is out of range of MAX num (%d) !!!!", GPIO_PIN_MAX);
		return GPIO_FAIL;
	}	

	pos = gpio_pin/32;
	bit = gpio_pin%32;

	data = DRV_Reg32((GPIO_DIR1 + pos*0x10));

	return ((data&(1<<bit))?1:0);	

#endif
}

// ----------------------------------------------------------
/**
 *  @brief	Set GPIO_DIR input or output
 *  @param  gpio_pin :  The GPIO pin to be set.
 *  @param  direction : The direction to be set in gpio_pin.
 *  					1: set as output pin
 *					0: set as input pin
 *  @return  GPIO_OK : set successful,  GPIO_FAIL : set failed
 */
static kal_int32 _GPIO_Set_Direction(gpio_pin_e gpio_pin, kal_uint32 direction)
{
#if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992)
	unsigned long pos;
	unsigned long bit;
	//unsigned long data;

	if (gpio_pin>GPIO_PIN_MAX)
	{
		GPIO_ERR("The gpio pin is out of range of MAX num (%d) !!!!", GPIO_PIN_MAX);
		return GPIO_FAIL;
	}	

	pos = gpio_pin/32;
	bit = gpio_pin%32;
	if (direction == GPIO_AS_OUTPUT)
		DRV_WriteReg32(GPIO_DIR_SET(pos),1<<bit);
	else
		DRV_WriteReg32(GPIO_DIR_CLR(pos),1<<bit);

	return GPIO_OK; 

#endif
}



//========================================================================
/*-----------------------------------------------------------------------*
*  @brief  Read the input value of the gpio pin.
*  @param  gpio_pin :   The pin which to read value.
*  @param  *value	   :	The variable to save value read from the pin, will be 0 or 1.
*  @return GPIO_OK :   get successful,  GPIO_FAIL : get failed
*-----------------------------------------------------------------------*/
kal_int32 GPIO_READ_INPUT_VALUE (gpio_pin_e gpio_pin, kal_uint32 *value)
{
#if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992)
	unsigned long pos;
	unsigned long bit;
	unsigned long data;

	if (gpio_pin>GPIO_PIN_MAX)
	{
		GPIO_ERR("The gpio pin is out of range of MAX num (%d) !!!!", GPIO_PIN_MAX);
		return GPIO_FAIL;
	}	

	pos = gpio_pin/32;
	bit = gpio_pin%32;
	data = DRV_Reg32((GPIO_DIN1 + pos*0x10));
	*value=((data&(1<<bit))?1:0);

	return GPIO_OK; 

#endif
}




// ----------------------------------------------------------
/**
 *  @brief	Enable or Disable GPIO_PULLEN specific pin
 *  @param  gpio_pin :  The GPIO pin to be set.
 *  @param  pullen : set 1 to enable pull up/down in gpio_pin.
 *  @return  GPIO_OK : set successful,  GPIO_FAIL : set failed
 */
kal_int32 _GPIO_Set_Pullen(gpio_pin_e gpio_pin, kal_uint32 pullen)  
{
#if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992)
	return GPIO_FAIL;	
#else
	return GPIO_FAIL;
#endif
}

// ----------------------------------------------------------
/**
 *  @brief	Set GPIO_PULLSEL to pull-up or pull-down
 *  @param  gpio_pin :  The GPIO pin to be set.
 *  @param  updown : set GPIO_PULL_UP to set gpio_pin in pull-up. set GPIO_PULL_DOWN to set gpio_pin pull_down.
 *  @return  GPIO_OK : set successful,  GPIO_FAIL : set failed
 */
kal_int32 _GPIO_Set_Pullsel(gpio_pin_e gpio_pin, kal_uint32 updown)
{
#if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992)
	return GPIO_FAIL;	
#else
	return GPIO_FAIL;
#endif
}


/**
*  @brief  Set pin direction as an output pin.
*  @param  gpio_pin : The pin which to be set direction to output pin.
*  @return GPIO_OK : set successful,  GPIO_FAIL : set failed
*/
kal_int32 GPIO_SET_DIRECT_OUTPUT (gpio_pin_e gpio_pin)
{
	if (gpio_pin>GPIO_PIN_MAX)
	{
		GPIO_ERR("The gpio pin is out of range of MAX num (%d) !!!!", GPIO_PIN_MAX);
		return GPIO_FAIL;
	}
	
	if (GPIO_FAIL == _GPIO_Set_Pullen(gpio_pin, GPIO_DISABLE) )
	{	return GPIO_FAIL; }
		
	if (GPIO_FAIL == _GPIO_Set_Direction(gpio_pin, GPIO_AS_OUTPUT) )
	{	return GPIO_FAIL; }

	return GPIO_OK;
}

//========================================================================
/**
*  @brief  Set pin direction as an input pin.
*  @param  gpio_pin	   :	The pin which want to be set.
*  @param  pull_en	   :   GPIO_ENABLE or GPIO_DISABLE, Set if pull-up/down function is enable. 
*  @param  pull_updown  :   GPIO_PULL_UP / GPIO_PULL_DOWN, it works only when pull_en is enable.
*  @return GPIO_OK : set successful,  GPIO_FAIL : set failed
*/
kal_int32 GPIO_SET_DIRECT_INPUT (gpio_pin_e gpio_pin, kal_uint32 pull_en, kal_uint32 pull_updown)
{
	if (gpio_pin>GPIO_PIN_MAX)
	{
		GPIO_ERR("The gpio pin is out of range of MAX num (%d) !!!!", GPIO_PIN_MAX);
		return GPIO_FAIL;
	}	
				/* Step-1 Check GPIO_Mode to make sure the pin can be uesed as GPIO*/
				//_GPIO_ShareMode_Chk(gpio_pin);

				/* Step-2 set the pull-up/down */
				// When input, the pullen could be set as required
				// If the pullen is set, the pullsel should be set.
	if (GPIO_FAIL == _GPIO_Set_Pullen(gpio_pin, pull_en) )
	{	return GPIO_FAIL; }

				/* Step-3 set the pull-up/down when gpio is input*/
	if (GPIO_FAIL == _GPIO_Set_Pullsel(gpio_pin, pull_updown) )
	{	return GPIO_FAIL; }

				/* Step-4 set the direction to input*/
	if (GPIO_FAIL == _GPIO_Set_Direction(gpio_pin, GPIO_AS_INPUT) )
	{	return GPIO_FAIL; }		
	
	
		return GPIO_OK;
}
	

//========================================================================
/**
*  @brief  set the data inversion parameter of the gpio pin.
*  @param  gpio_pin :	The pin which is to be set data inversion.
*  @param  inversion:	The value to be set, will be 0 or 1.
*					0: disable data inversion
					1: enable data inversion
*  @return GPIO_OK :   set successful,  GPIO_FAIL : set failed
*/
kal_int32 gpio_set_data_inversion(gpio_pin_e gpio_pin, kal_uint32 inversion)
{
#if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992)	
	return GPIO_FAIL;	
#else
	return GPIO_FAIL;
#endif
}



//========================================================================
/**
*  @brief  Write the output value of the gpio pin. It only work when the pin is an output pin.
*  @param  gpio_pin :	The pin which to be set output value.
*  @param  value	   :	The value which want to be set, can be 0 or 1.
*  @return GPIO_OK :   set successful,  GPIO_FAIL : set failed
*/
kal_int32 GPIO_WRITE_OUTPUT_VALUE (gpio_pin_e gpio_pin, kal_uint32 value)
{
#if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992)	
	unsigned long pos;
	unsigned long bit;
	//unsigned long data;

	if (gpio_pin>GPIO_PIN_MAX)
	{
		GPIO_ERR("The gpio pin is out of range of MAX num (%d) !!!!", GPIO_PIN_MAX);
		return GPIO_FAIL;
	}	

	pos = gpio_pin/32;
	bit = gpio_pin%32;
	if (value == GPIO_OUTPUT_HIGH)
		DRV_WriteReg32(GPIO_DOUT_SET(pos),1<<bit);
	else
		DRV_WriteReg32(GPIO_DOUT_CLR(pos),1<<bit);

	return GPIO_OK;	
#endif
}


/*-----------------------------------------------------------------------*
* FUNCTION                                                            
*	GPIO_ReadIO
*
* DESCRIPTION                                                           
*   	This function is to read data from one GPIO pin
*
* CALLS  
*	Read data from one GPIO pin
*
* PARAMETERS
*	port: pin number
*	
* RETURNS
*	1 or 0
*
* GLOBALS AFFECTED
*   external_global
*-----------------------------------------------------------------------*/
char GPIO_ReadIO(kal_int16 port)
{
#if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992)
	kal_uint32 input_val = 0;
	if(GPIO_READ_INPUT_VALUE((gpio_pin_e)port, &input_val) != GPIO_OK)
	{
		GPIO_ERR("\tGPIO_ReadIO: read the value of port[%d] failed!! ",port);
	}
	return (char)input_val;
#endif
}


/*
* FUNCTION                                                            
*	GPIO_WriteIO
*
* DESCRIPTION                                                           
*   	This function is to write data to one GPIO port
*
* CALLS  
*	Write data to one GPIO port
*
* PARAMETERS
*	data: KAL_TRUE(1) or KAL_FALSE(0)
*	port: gpio pin number
*	
* RETURNS
*	None
*
* GLOBALS AFFECTED
*   external_global        
*/
void GPIO_WriteIO(char data, kal_int16 port)
{
#if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992)	
	GPIO_WRITE_OUTPUT_VALUE((gpio_pin_e)port,data);
#endif
}
#if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992)	
#define MAX_GPIO_MODE_PER_REG 8
#define GPIO_MODE_BITS  4
#endif
void GPIO_ModeSetup(kal_uint16 pin, kal_uint16 conf_data)
{
#if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992)	
#if defined(__FPGA__) && defined(MT6295M)

#else
	unsigned long pos;
	unsigned long bit;
	unsigned long data;
	unsigned long mask = (1L << GPIO_MODE_BITS)-1;
	unsigned long offset;

	pos = pin/MAX_GPIO_MODE_PER_REG;
	bit = pin%MAX_GPIO_MODE_PER_REG;

	offset = GPIO_MODE_BITS*bit;
	
	data = DRV_Reg32(GPIO_MODE(pos));
	data &= ~(mask << offset);
	data |= (conf_data << offset);
	//to avoid possible race condition with AP,use SET/CLR reg to setup MODE register
	DRV_WriteReg32(GPIO_MODE_CLR(pos),(mask << (GPIO_MODE_BITS*bit)));
	DRV_WriteReg32(GPIO_MODE_SET(pos),data);
#endif	
#endif	
}

/*
* FUNCTION                                                            
*	GPIO_InitIO
*
* DESCRIPTION                                                           
*   	This function is to initialize one GPIO pin as INPUT or OUTPUT
*
* CALLS  
*	Initialize one GPIO pin as INPUT or OUTPUT
*
* PARAMETERS
*	direction: INPUT or OUTPUT
*	port: pin number
*	
* RETURNS
*	None
*
* GLOBALS AFFECTED
*   external_global
*/
void GPIO_InitIO(char direction, kal_int16 port)
{
#if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992)	
	if(GPIO_OUTPUT == direction)
	{
		_GPIO_Set_Direction((gpio_pin_e)port,GPIO_OUTPUT);
	}
	else
	{
		_GPIO_Set_Direction((gpio_pin_e)port,GPIO_INPUT);
	}

#endif
}

char GPIO_ReturnMode(kal_int16 port)
{
#if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992)	
#if defined(__FPGA__) && defined(MT6295M)
	return GPIO_FAIL;
#else
	unsigned long pos;
	unsigned long bit;
	unsigned long data;
	unsigned long mask = (1L << GPIO_MODE_BITS)-1;
	unsigned long offset;

	pos = port/MAX_GPIO_MODE_PER_REG;
	bit = port%MAX_GPIO_MODE_PER_REG;

	offset = GPIO_MODE_BITS*bit;
	
	data = DRV_Reg32(GPIO_MODE(pos));
	data = (data >> offset)&mask;
	return (char)data;
#endif	
#else
	return GPIO_FAIL;
#endif	
}

/*
* FUNCTION                                                            
*	GPIO_ReturnDir
*
* DESCRIPTION                                                           
*   	This function is to report GPIO direction value
*
* CALLS  
*	Report GPIO direction value accoding to input pin
*
* PARAMETERS
*	GPIO pin 
*	
* RETURNS
*	GPIO direction value
*
* GLOBALS AFFECTED
*   external_global
*/
char GPIO_ReturnDir(kal_int16 port)
{
#if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992)	
	return gpio_get_dir_value(port);
#endif
}

/*
* FUNCTION                                                            
*	GPIO_ReturnDout
*
* DESCRIPTION                                                           
*   	This function is to report GPIO output value
*
* CALLS  
*	Report GPIO output value accoding to input pin
*
* PARAMETERS
*	GPIO pin 
*	
* RETURNS
*	GPIO output value
*
* GLOBALS AFFECTED
*   external_global
*/
char GPIO_ReturnDout(kal_int16 port)
{
#if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992)	
	return GPIO_FAIL;
#endif
}


/*
* FUNCTION                                                            
*	GPIO_PullenSetup
*
* DESCRIPTION                                                           
*   	This function is to enable or disable the pull up/down of the related GPIO pin.
*		You can not decide to pull up or down, it is set inside the chip.
*		And, the setting is different from pin by pin.
*
* PARAMETERS
*	pin : gpio pin number range from 0~63
*	enable: enable the pull up/down
*	
* RETURNS
*	None
*
* GLOBALS AFFECTED
*
*/
void GPIO_PullenSetup(kal_uint16 pin, kal_bool enable)
{
	#ifdef __CUST_NEW__  
	pin &= (~GPIO_MAGIC_NUM);
	#endif
	_GPIO_Set_Pullen(pin,enable);
}

/*
* FUNCTION                                                            
*	GPIO_PullSelSetup
*
* DESCRIPTION                                                           
*   	This function is to select pull up/down of the related GPIO pin.
*
* PARAMETERS
*	pin : gpio pin number range from 0~63
*	enable: enable the pull up/down
*	
* RETURNS
*	None
*
* GLOBALS AFFECTED
*
*/
void GPIO_PullSelSetup(kal_uint16 pin, kal_bool pull_up)
{
	#ifdef __CUST_NEW__  
	pin &= (~GPIO_MAGIC_NUM);
	#endif
	_GPIO_Set_Pullsel(pin,pull_up);
}

/*
* FUNCTION                                                            
*	GPIO_DinvSetup
*
* DESCRIPTION                                                           
*   	This function is to enable data invert of the related GPIO pin
*
* PARAMETERS
*	pin : gpio pin number range from 0~63
*	enable: enable the data inversion
*	
* RETURNS
*	None
*
* GLOBALS AFFECTED
*
*/
void GPIO_DinvSetup(kal_uint16 pin, kal_bool enable)
{
	#ifdef __CUST_NEW__  
	pin &= (~GPIO_MAGIC_NUM);
	#endif
	gpio_set_data_inversion(pin,enable);
}

/*
* FUNCTION                                                            
*	GPIO_SetDebugMode
*
* DESCRIPTION                                                           
*  This function is to set GPIO HW debug mode
*  currently MT6290 not support this function
*
* CALLS  
*	set GPIO HW debug mode
*
* PARAMETERS
*	enable   - KAL_TRUE: turn on the debug mode
*             KAL_FALSE: turn off the debug mode
*	
* RETURNS
*	None
*
* GLOBALS AFFECTED
*   external_global
*/
void GPIO_SetDebugMode(kal_bool enable)
{
	//not support in MT6290
}

#ifdef __CUST_NEW__

/*
* FUNCTION                                                            
*	GPIO_InitIO_FAST
*
* DESCRIPTION                                                           
*   	This function is to initialize one GPIO pin as INPUT or OUTPUT. 
*  Note that it's for fast access without debug checking and only exists
*  when __CUST_NEW__ is defined.
*
* CALLS  
*	Initialize one GPIO pin as INPUT or OUTPUT
*
* PARAMETERS
*	direction: INPUT or OUTPUT
*	port: pin number
*	
* RETURNS
*	None
*
* GLOBALS AFFECTED
*   external_global
*/
void GPIO_InitIO_FAST(char direction, kal_int16 port)
{
	 #ifdef __GPIO_FAST_DEBUB__
   if (gpio_debug_enable == KAL_TRUE)
   {
      if (direction == 0)
      {
      #ifdef __GPIO_CHECK_WARNING__
         if (!kal_if_lisr()) {
            if (!((gpio_dir_in_allowed[(kal_uint8)port>>5]) & (1 << (port & 0x1f))))
            {
               kal_int32 ret;
             system_print("GPIO WARNING!! GPIO_InitIO_FAST: Direction Input is not allowed!");
             ret = sprintf(buff, "pin=%d", port);
             system_print(buff);
            }
         }
      #elif defined(__GPIO_CHECK_ASSERT__)
         ASSERT((gpio_dir_in_allowed[(kal_uint8)port>>5]) & (1 << (port & 0x1f)));
		#endif  /* __GPIO_CHECK_WARNING__ */
      }
      else
      {
      #ifdef __GPIO_CHECK_WARNING__
         if (!kal_if_lisr()) {
            if (!((gpio_dir_out_allowed[(kal_uint8)port>>5]) & (1 << (port & 0x1f))))
            {
               kal_int32 ret;
             system_print("GPIO WARNING!! GPIO_InitIO_FAST: Direction Output is not allowed!");
             ret = sprintf(buff, "pin=%d", port);
             system_print(buff);
            }
         }
      #elif defined(__GPIO_CHECK_ASSERT__)
         ASSERT((gpio_dir_out_allowed[(kal_uint8)port>>5]) & (1 << (port & 0x1f)));
		#endif  /* __GPIO_CHECK_WARNING__ */
      }
	  gpio_check_for_write[(kal_uint8)port>>5] |= (1 << (port & 0x1f));
	  gpio_check_for_read[(kal_uint8)port>>5] |= (1 << (port & 0x1f));
   }
   #endif /* __GPIO_FAST_DEBUB__ */

   #ifdef __CUST_NEW__   	
   port &= (~GPIO_MAGIC_NUM);
   #endif /* __CUST_NEW__ */
	if(GPIO_OUTPUT == direction)
	{
		GPIO_SET_DIRECT_OUTPUT((gpio_pin_e)port);
	}
	else
	{
		_GPIO_Set_Direction((gpio_pin_e)port,GPIO_INPUT);
	}
}

/*
* FUNCTION                                                            
*	GPIO_WriteIO_FAST
*
* DESCRIPTION                                                           
*   	This function is to write data to one GPIO port
*  Note that it's for fast access without debug checking and only exists
*  when __CUST_NEW__ is defined.
*
* CALLS  
*	Write data to one GPIO port
*
* PARAMETERS
*	data: KAL_TRUE(1) or KAL_FALSE(0)
*	port: gpio pin number
*	
* RETURNS
*	None
*
* GLOBALS AFFECTED
*   external_global        
*/
void GPIO_WriteIO_FAST(char data, kal_int16 port)
{
   #ifdef __GPIO_FAST_DEBUB__
   if ((gpio_debug_enable == KAL_TRUE) && 
	   (gpio_check_for_write[(kal_uint8)port>>5] & (1 << (port & 0x1f))))
   {

      #ifdef __GPIO_CHECK_WARNING__
      if (!kal_if_lisr()) {
         kal_uint16 mode;
         mode = GPIO_ReturnMode(port);
         if (mode != 0)
         {
            kal_int32 ret;
          system_print("GPIO WARNING!! GPIO_WriteIO_FAST: mode is not correct.");
          ret = sprintf(buff, "pin=%d, mode=%d", port, mode);
          system_print(buff);
         }
      #elif defined(__GPIO_CHECK_ASSERT__)
         ASSERT(GPIO_ReturnMode(port) == 0);
		#endif  /* __GPIO_CHECK_WARNING__ */
      }
      #ifdef __GPIO_CHECK_WARNING__
      if (!kal_if_lisr()) {
         char dir;
         dir = GPIO_ReturnDir(port);
         if (dir != 1)
         {
            kal_int32 ret;
          system_print("GPIO WARNING!! GPIO_WriteIO_FAST: direction is not correct.");
          ret = sprintf(buff, "pin=%d, direction=%d", port, dir);
          system_print(buff);
         }
      }
      #elif defined(__GPIO_CHECK_ASSERT__)
      ASSERT(GPIO_ReturnDir(port) == 1);
		#endif  /* __GPIO_CHECK_WARNING__ */
	  gpio_check_for_write[(kal_uint8)port>>5] &= (~(1 << (port & 0x1f)));
   }
   #endif /* __GPIO_FAST_DEBUB__ */

   	#ifdef __CUST_NEW__  
	port &= (~GPIO_MAGIC_NUM);
	#endif
	GPIO_WRITE_OUTPUT_VALUE((gpio_pin_e)port,data);

}

/*
* FUNCTION                                                            
*	GPIO_ReadIO_FAST
*
* DESCRIPTION                                                           
*   	This function is to read data from one GPIO pin.
*  Note that it's for fast access without debug checking and only exists
*  when __CUST_NEW__ is defined.
*
* CALLS  
*	Read data from one GPIO pin
*
* PARAMETERS
*	port: pin number
*	
* RETURNS
*	1 or 0
*
* GLOBALS AFFECTED
*   external_global
*/
char GPIO_ReadIO_FAST(kal_int16 port)
{
	kal_uint32 input_val;

   #ifdef __GPIO_FAST_DEBUB__
   if ((gpio_debug_enable == KAL_TRUE) && 
	   (gpio_check_for_read[(kal_uint8)port>>5] & (1 << (port & 0x1f))))
   {
      #ifdef __GPIO_CHECK_WARNING__
      if (!kal_if_lisr()) {
         kal_uint16 mode;
         char dir;
         mode = GPIO_ReturnMode(port);
         dir = GPIO_ReturnDir(port);
         if ((mode != 0) || (dir != 0))
         {
            kal_int32 ret;
          system_print("GPIO WARNING!! GPIO_ReadIO_FAST: mode or direction is not correct.");
          ret = sprintf(buff, "pin=%d, mode=%d, direction=%d", port, mode, dir);
          system_print(buff);
         }
      }
      #elif defined(__GPIO_CHECK_ASSERT__)
      ASSERT(GPIO_ReturnMode(port) == 0);
      ASSERT(GPIO_ReturnDir(port) == 0);
		#endif  /* __GPIO_CHECK_WARNING__ */
	  gpio_check_for_read[(kal_uint8)port>>5] &= (~(1 << (port & 0x1f)));
   }
   #endif /* __GPIO_FAST_DEBUB__ */

   #ifdef __CUST_NEW__   	
   port &= (~GPIO_MAGIC_NUM);
   #endif /* __CUST_NEW__ */
   
	if(GPIO_READ_INPUT_VALUE((gpio_pin_e)port, &input_val) != GPIO_OK)
	{
		GPIO_ERR("\tGPIO_ReadIO: read the value of port[%d] failed!! ",port);
	}
	return (char)input_val;
}


#endif

//#pragma arm section code = "INTERNCODE"
/*
* FUNCTION                                                            
*	GPIO_WriteIO_FAST2
*
* DESCRIPTION                                                           
*   	This function is to write data to one GPIO port
*  Note that it's for faster access without debug checking.
*
* CALLS  
*	Write data to one GPIO port
*
* PARAMETERS
*	data: KAL_TRUE(1) or KAL_FALSE(0)
*	no: no = port/16; port: GPIO port number
*	remainder_shift: remainder_shift = 1<<(port%16);
*
* RETURNS
*	None
*
* GLOBALS AFFECTED
*   external_global        
*/
void DEVDRV_LS_INTERNCODE GPIO_WriteIO_FAST2(char data, kal_uint16 no, kal_uint16 remainder_shift)
{
	kal_uint32 gpio_pin,shift_bit;

   #if defined(__CUST_NEW__)&&defined(__GPIO_FAST_DEBUB__)
   if ((gpio_debug_enable == KAL_TRUE) && 
	   (gpio_check_for_write[(kal_uint8)port>>5] & (1 << (port & 0x1f))))
   {
      kal_int16 port;
      kal_uint16 index;

      for (index = 0; index < 16; index++)
      {
         if (remainder_shift & (1 << index))
            break;
      }
      port = (kal_int16)((no<<4)+(index&0x000f));

      #ifdef __GPIO_CHECK_WARNING__
      if (!kal_if_lisr()) {
         kal_uint16 mode;
         mode = GPIO_ReturnMode(port);
         if (mode != 0)
         {
            kal_int32 ret;
          system_print("GPIO WARNING!! GPIO_WriteIO_FAST: mode is not correct.");
          ret = sprintf(buff, "pin=%d, mode=%d", port, mode);
          system_print(buff);
         }

      #elif defined(__GPIO_CHECK_ASSERT__)
         ASSERT(GPIO_ReturnMode(port) == 0);
		#endif  /* __GPIO_CHECK_WARNING__ */
      }
      #ifdef __GPIO_CHECK_WARNING__
      if (!kal_if_lisr()) {
         char dir;
         dir = GPIO_ReturnDir(port);
         if (dir != 1)
         {
            kal_int32 ret;
          system_print("GPIO WARNING!! GPIO_WriteIO_FAST: direction is not correct.");
          ret = sprintf(buff, "pin=%d, direction=%d", port, dir);
          system_print(buff);
         }
      }
      #elif defined(__GPIO_CHECK_ASSERT__)
      ASSERT(GPIO_ReturnDir(port) == 1);
		#endif  /* __GPIO_CHECK_WARNING__ */
	  gpio_check_for_write[(kal_uint8)port>>5] &= (~(1 << (port & 0x1f)));
   }
   #endif /* __GPIO_FAST_DEBUB__ */
   
  for (shift_bit = 0; shift_bit < 16; shift_bit++)
  {
     if (remainder_shift & (1 << shift_bit))
        break;
  }
  gpio_pin = (kal_int16)((no<<4)+(shift_bit&0x000f));
  
  GPIO_WRITE_OUTPUT_VALUE((gpio_pin_e)gpio_pin,data);

}

//#pragma arm section code


/*conf_data = 0~3*/
void GPO_ModeSetup(kal_uint16 pin, kal_uint16 conf_dada)
{
	//not support in MT6290
}


/*
* FUNCTION                                                            
*	GPI_O_WriteIO
*
* DESCRIPTION                                                           
*   	This function is to write data to one GPO pin
*
* CALLS  
*	Write data to one GPO pin
*
* PARAMETERS
*	data: KAL_TRUE(1) or KAL_FALSE(0)
*	port: gpo pin number
*	
* RETURNS
*	None
*
* GLOBALS AFFECTED
*   external_global
*/

void GPO_WriteIO(char data,kal_int16 port)
{
	//not support in MT6290
}

/*
* FUNCTION                                                            
*	GPO_ReturnDout
*
* DESCRIPTION                                                           
*   	This function is to report GPO output value
*
* CALLS  
*	Report GPO output value accoding to input pin
*
* PARAMETERS
*	GPO pin 
*	
* RETURNS
*	GPO output value
*
* GLOBALS AFFECTED
*   external_global
*/
char GPO_ReturnDout(kal_int16 port)
{
	return 0;
}


/*
* FUNCTION                                                            
*	GPO_ReturnMode
*
* DESCRIPTION                                                           
*   	This function is to report GPO mode value
*
* CALLS  
*	Report GPO mode value accoding to input pin
*
* PARAMETERS
*	GPO pin 
*	
* RETURNS
*	GPO mode value
*
* GLOBALS AFFECTED
*   external_global
*/
char GPO_ReturnMode(kal_int16 port)
{
	return 0;
}


/**
*  @brief  set gpio ownership register
*  @param  pin_num  : the gpio pin to set ownerhsip
*  @param  ownership : the ownership register bit value to set ,it should be 0~1
*                                    0: set ownership to MD
*                                    1: set ownership to AP
*  @return GPIO_OK :	set successful,  GPIO_FAIL : set failed
*/
kal_int32 gpio_set_ownership(kal_uint32 pin_num,kal_uint32 ownership)
{
    return GPIO_FAIL;
}
#if defined(MT6885)
#define DRIVING_SETTING_GPIO_NUM  8
#define DRIVING_GEAR_NUM 2
const gpio_driving_gear_t gpio_driving_gear[DRIVING_GEAR_NUM]=
{
	{
	    0x07,
	    0x08,
	    {
		    {0x00,2},	
		    {0x01,4},	
		    {0x02,6},	
		    {0x03,8},	
		    {0x04,10},	
		    {0x05,12},	
		    {0x06,14},	
		    {0x07,16}	
	    }
    },
};

const drv_gpio_driving_priv_t drv_gpio_driving_priv[DRIVING_SETTING_GPIO_NUM]=
{
  {1,57,0, 6, 0xC1E20000},
  {1,58,0, 9, 0xC1E20000},
  {1,59,0,12, 0xC1E20000},
  {1,60,0,15, 0xC1E20000},
  {1,85,0,12, 0xC1E70000},
  {1,86,0,15, 0xC1E70000},
  {1,87,0, 6, 0xC1E70000},
  {1,88,0, 9, 0xC1E70000}
};
#endif
#if defined(MT6873)
#define DRIVING_SETTING_GPIO_NUM  8
#define DRIVING_GEAR_NUM 1
const gpio_driving_gear_t gpio_driving_gear[DRIVING_GEAR_NUM]=
{
	{
	    0x07,
	    0x08,
	    {
		    {0x00,2},	
		    {0x01,4},	
		    {0x02,6},	
		    {0x03,8},	
		    {0x04,10},	
		    {0x05,12},	
		    {0x06,14},	
		    {0x07,16}
	    }
    },
};
const drv_gpio_driving_priv_t drv_gpio_driving_priv[DRIVING_SETTING_GPIO_NUM]=
{
  {1,57,0,24, 0xC1D30010},
  {1,58,0,24, 0xC1D30010},
  {1,59,0,27, 0xC1D30010},
  {1,60,0,27, 0xC1D30010},
  {1,85,0,21, 0xC1D30010},
  {1,86,0,21, 0xC1D30010},
  {1,87,0,18, 0xC1D30010},
  {1,88,0,18, 0xC1D30010}
};
#endif
#if defined(MT6853)
#define DRIVING_SETTING_GPIO_NUM  8
#define DRIVING_GEAR_NUM 1
const gpio_driving_gear_t gpio_driving_gear[DRIVING_GEAR_NUM]=
{
	{
	    0x07,
	    0x08,
	    {
		    {0x00,2},	
		    {0x01,4},	
		    {0x02,6},	
		    {0x03,8},	
		    {0x04,10},	
		    {0x05,12},	
		    {0x06,14},	
		    {0x07,16}
	    }
    },
};
const drv_gpio_driving_priv_t drv_gpio_driving_priv[DRIVING_SETTING_GPIO_NUM]=
{
  {1,162,0,24, 0xC1D30000},
  {1,163,0,24, 0xC1D30000},
  {1,164,0,27, 0xC1D30000},
  {1,165,0,27, 0xC1D30000},
  {1,188,0,21, 0xC1D30000},
  {1,189,0,21, 0xC1D30000},
  {1,190,0,18, 0xC1D30000},
  {1,191,0,18, 0xC1D30000}
};
#endif
#if defined(MT6833)
#define DRIVING_SETTING_GPIO_NUM  8
#define DRIVING_GEAR_NUM 1
const gpio_driving_gear_t gpio_driving_gear[DRIVING_GEAR_NUM]=
{
	{
	    0x07,
	    0x08,
	    {
		    {0x00,2},	
		    {0x01,4},	
		    {0x02,6},	
		    {0x03,8},	
		    {0x04,10},	
		    {0x05,12},	
		    {0x06,14},	
		    {0x07,16}
	    }
    },
};
const drv_gpio_driving_priv_t drv_gpio_driving_priv[DRIVING_SETTING_GPIO_NUM]=
{
  {1,162,0,3,  0xC1D10030},
  {1,163,0,3,  0xC1D10030},
  {1,164,0,6,  0xC1D10030},
  {1,165,0,6,  0xC1D10030},
  {1,188,0,0,  0xC1D10030},
  {1,189,0,0,  0xC1D10030},
  {1,190,0,27, 0xC1D10020},
  {1,191,0,27, 0xC1D10020}
};
#endif
#if defined(MT6877)
#define DRIVING_SETTING_GPIO_NUM  8
#define DRIVING_GEAR_NUM 1
const gpio_driving_gear_t gpio_driving_gear[DRIVING_GEAR_NUM]=
{
	{
	    0x07,
	    0x08,
	    {
		    {0x00,2},	
		    {0x01,4},	
		    {0x02,6},	
		    {0x03,8},	
		    {0x04,10},	
		    {0x05,12},	
		    {0x06,14},	
		    {0x07,16}
	    }
    },
};
const drv_gpio_driving_priv_t drv_gpio_driving_priv[DRIVING_SETTING_GPIO_NUM]=
{
  {1,66,0, 3, 0xC1D30010},
  {1,67,0, 3, 0xC1D30010},
  {1,68,0, 0, 0xC1D30010},
  {1,69,0, 0, 0xC1D30010},
  {1,82,0,27, 0xC1D30000},
  {1,83,0,27, 0xC1D30000},
  {1,84,0,24, 0xC1D30000},
  {1,85,0,24, 0xC1D30000}
};
#endif
#if defined(CHIP10992)
#define DRIVING_SETTING_GPIO_NUM  8
#define DRIVING_GEAR_NUM 1
const gpio_driving_gear_t gpio_driving_gear[DRIVING_GEAR_NUM]=
{
	{
	    0x07,
	    0x08,
	    {
		    {0x00,2},	
		    {0x01,4},	
		    {0x02,6},	
		    {0x03,8},	
		    {0x04,10},	
		    {0x05,12},	
		    {0x06,14},	
		    {0x07,16}
	    }
    },
};
const drv_gpio_driving_priv_t drv_gpio_driving_priv[DRIVING_SETTING_GPIO_NUM]=
{
  {1,138,0,3, 0xC1D20000},
  {1,139,0,3, 0xC1D20000},
  {1,140,0,0, 0xC1D20000},
  {1,141,0,0, 0xC1D20000},
  {1,164,0,18, 0xC1C10010},
  {1,165,0,18, 0xC1C10010},
  {1,166,0,21, 0xC1C10010},
  {1,167,0,21, 0xC1C10010}
};
#endif
/**
*  @brief  set the drive parameter of the gpio pin.
*  @param  gpio_pin :	The pin which is to set drive.
*  @param  drive:         the value of drive parameter to set, it should be 0~3
*  @return GPIO_OK :   set successful,  GPIO_FAIL : set failed
*/
kal_int32 gpio_set_drive(gpio_pin_e gpio_pin,kal_uint32 drive)
{
#if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MERCURY)	
	return GPIO_FAIL;
#elif defined(MT6885)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992)
   kal_uint8 temp0,temp1;
   kal_uint8 result = 0;
   const drv_gpio_driving_priv_t *pGpio_driving_priv;
   for(temp0=0;temp0<DRIVING_SETTING_GPIO_NUM;temp0++)
   {
   	  if(drv_gpio_driving_priv[temp0].valid)
   	  {
   	     pGpio_driving_priv = (drv_gpio_driving_priv + temp0);
   	  	 if(drv_gpio_driving_priv[temp0].gpio_num==gpio_pin)
   	  	 {
   	  	 	  for(temp1=0;temp1<gpio_driving_gear[pGpio_driving_priv->driving_gear].gear_cnt;temp1++)
   	  	 	  {
	   	  	   	  if((gpio_driving_gear[pGpio_driving_priv->driving_gear].gear_mapping[temp1][1])==drive)
	   	  	   	  {
	   	  	   	    DRV_WriteReg32((pGpio_driving_priv->addr+8),
	   	  	   	                  ((gpio_driving_gear[pGpio_driving_priv->driving_gear].mask) << (pGpio_driving_priv->offset)));
	   	  	   	    DRV_WriteReg32((pGpio_driving_priv->addr+4),
	   	  	   	                  ((gpio_driving_gear[pGpio_driving_priv->driving_gear].gear_mapping[temp1][0]) << (pGpio_driving_priv->offset)));
	   	  	   	    result = 1;
	   	  	   	    break;
	              }   	  	    
   	  	    }
   	  	 }
   	  }
   	}
    if(result==1)
    	  return GPIO_OK;
    else
    	  return GPIO_FAIL;
#else
  return GPIO_FAIL;
#endif
}


//========================================================================
/**
 *  @brief     get drive register value of pin
 *  @param  gpio_pin :  The GPIO pin to be read.
 *  @return   return the drive register value of pin, it should be 0x0~0x3.
 *		      if gpio_pin is out of range, the return value will be GPIO_FAIL
 */
kal_int32 gpio_get_drive_value(gpio_pin_e gpio_pin)
{
#if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992)	
	return GPIO_FAIL;
#endif
}



/**
*  @brief  set gpio ownership register
*  @param  pin_num  : the gpio pin to set ownerhsip
*  @param  ownership : the ownership register bit value to set ,it should be 0~1
*                                    0: set ownership to MD
*                                    1: set ownership to AP
*  @return GPIO_OK :	set successful,  GPIO_FAIL : set failed
*/
kal_int32 gpio_get_ownership(kal_uint32 pin_num)
{
	return GPIO_FAIL;
}

void GPIO_MetaModeInit(void)
{
}

kal_int32 GPIO_GetMetaMode(void)
{
#if defined(MT6763)||defined(MT6739)||defined(MT6771)|| defined(MT6765)|| defined(MT6295M)|| defined(MT3967)|| defined(MT6779)||defined(MT6297)||defined(MT6885)||defined(MERCURY)||defined(MT6873)||defined(MT6853)||defined(MT6833)||defined(MT6877)||defined(CHIP10992)	
	return GPIO_FAIL;
#endif
}