Пример #1
0
uint8 RDA_bt_SerialCommTxByte(uint8 data) /* return 0 --> ack */
{
	int32 i;
	uint8 temp_value = 0;
	for(i=7; (i>=0)&&(i<=7); i--)
	{
		GPIO_WriteIO( 0, RDA5868_SCL); /* low */
		DELAY(DURATION_LOW);
		if(i==7)GPIO_InitIO(1,RDA5868_SDA);
		DELAY(DURATION_LOW);

		GPIO_WriteIO(((data>>i)&0x01), RDA5868_SDA);
		DELAY(DURATION_LOW/2);
		GPIO_WriteIO( 1, RDA5868_SCL); /* high */
		DELAY(DURATION_HIGH);
	}
	GPIO_WriteIO(0, RDA5868_SCL); /* low */
	DELAY(DURATION_LOW);
	GPIO_InitIO(0,RDA5868_SDA);/* input  */
	DELAY(DURATION_LOW/2);
	GPIO_WriteIO(1, RDA5868_SCL); /* high */
	DELAY(DURATION_HIGH);
	temp_value = GPIO_ReadIO(RDA5868_SDA);
	GPIO_WriteIO(0, RDA5868_SCL); /* low */
	DELAY(DURATION_LOW);
	return temp_value;
}
Пример #2
0
kal_uint8 SerialCommTxByte(kal_uint8 addr, kal_uint8 data)
{
   kal_int16 i;
   GPIO_WriteIO(1, LE);
   GPIO_InitIO(1,SDA);
   for(i=8; --i>=0;){
      GPIO_WriteIO( 0, SCL);
      GPIO_WriteIO(data&0x01, SDA);
      data >>= 1;
      I2C_DUMMY_DELAY(5);
      GPIO_WriteIO( 1, SCL);
      I2C_DUMMY_DELAY(5);
   }
   for(i=8; --i>=0;){
      GPIO_WriteIO( 0, SCL);
      GPIO_WriteIO(addr&0x01, SDA);
      addr >>= 1;
      I2C_DUMMY_DELAY(5);
      GPIO_WriteIO( 1, SCL);
      I2C_DUMMY_DELAY(5);
   }
   GPIO_InitIO(0,SDA);
   GPIO_WriteIO(0, LE);
   I2C_DUMMY_DELAY(10);
}
Пример #3
0
void RDA_bt_SerialCommRxByte(uint8 *data, uint8 ack)
{
	int32 i;
	uint32 dataCache;

	dataCache = 0;
	for(i=7; (i>=0)&&(i<=7); i--)
	{
		GPIO_WriteIO(0, RDA5868_SCL);
		DELAY(DURATION_LOW);
		if(i==7)GPIO_InitIO(0,RDA5868_SDA);
		DELAY(DURATION_LOW);
		GPIO_WriteIO(1, RDA5868_SCL);
		DELAY(DURATION_HIGH);
		dataCache |= (GPIO_ReadIO(RDA5868_SDA)<<i);
		DELAY(DURATION_LOW/2);
	}

	GPIO_WriteIO(0, RDA5868_SCL);
	DELAY(DURATION_LOW);
	GPIO_InitIO(1,RDA5868_SDA);
	GPIO_WriteIO(ack, RDA5868_SDA);
	DELAY(DURATION_LOW/2);
	GPIO_WriteIO(1, RDA5868_SCL);
	DELAY(DURATION_HIGH);
	GPIO_WriteIO(0, RDA5868_SCL); /* low */
	DELAY(DURATION_LOW);
	*data = (uint8)dataCache;
}
Пример #4
0
kal_uint8 SerialCommRxByte(kal_uint8 addr, kal_uint8 *data)
{
   kal_int16 i;
   kal_uint16 dataRead=0;
   *data = 0;
   GPIO_WriteIO(1, LE);
   GPIO_InitIO(1,SDA);
   for(i=8; --i>=0;){
      GPIO_WriteIO( 0, SCL);
      GPIO_WriteIO(addr&0x01, SDA);
      GPIO_WriteIO(1, SCL);
      addr >>= 1;
      I2C_DUMMY_DELAY(5);
   }
   GPIO_InitIO(0,SDA);
   GPIO_WriteIO(0, LE);
   for(i=0; i<8; i++){
      GPIO_WriteIO( 0, SCL);
      I2C_DUMMY_DELAY(5);
      GPIO_WriteIO( 1, SCL);
      dataRead = GPIO_ReadIO(SDA);
      *data |= (dataRead << i);
   }
   I2C_DUMMY_DELAY(10);
}
Пример #5
0
void SerialCommInit(void)
{
   GPIO_ModeSetup(SCL,0);
   GPIO_ModeSetup(SDA,0);
   GPIO_ModeSetup(BUSENABLE,0);
   GPIO_InitIO(1,SCL);
   GPIO_InitIO(1,BUSENABLE);
}
Пример #6
0
void SerialCommPullLow(void)
{
   GPIO_ModeSetup(SCL,0);
   GPIO_ModeSetup(SDA,0);
   GPIO_InitIO(1,SDA);
   GPIO_InitIO(1,SCL);
   GPIO_WriteIO(0,SCL);
   GPIO_WriteIO(0,SDA);
}
Пример #7
0
void SerialCommInit(void)
{
   GPIO_ModeSetup(SCL,0);
   GPIO_ModeSetup(SDA,0);
   GPIO_ModeSetup(LE,0);
   GPIO_InitIO(1,SCL);
   GPIO_InitIO(1,LE);
   GPIO_WriteIO(1,SCL);
   GPIO_InitIO(0,SDA);
   GPIO_WriteIO(0,LE);
}
Пример #8
0
void RDA_bt_SerialCommInit(void)
{
	GPIO_ModeSetup(RDA5868_SCL,0);
	GPIO_ModeSetup(RDA5868_SDA,0);
	
	GPIO_InitIO(1,RDA5868_SCL);
	GPIO_InitIO(1,RDA5868_SDA);
	
	GPIO_WriteIO(1,RDA5868_SCL);
	GPIO_WriteIO(1,RDA5868_SDA);   
	DELAY(DURATION_LOW); 
}
Пример #9
0
void HorseRace_PowerOff(void) 
{ 
        GPIO_ModeSetup(gpio_horserace_latch_pin,0); 
        GPIO_ModeSetup(gpio_horserace_sdin_pin, 0); 
        GPIO_ModeSetup(gpio_horserace_clk_pin, 0); 

        GPIO_InitIO(1, gpio_horserace_latch_pin); 
        GPIO_InitIO(1, gpio_horserace_sdin_pin); 
        GPIO_InitIO(1, gpio_horserace_clk_pin); 

        GPIO_WriteIO(0, gpio_horserace_sdin_pin);/*输入数据*/ 
        GPIO_WriteIO(0, gpio_horserace_clk_pin);/*时钟*/ 
        GPIO_WriteIO(0, gpio_horserace_latch_pin);/*锁存*/     
} 
Пример #10
0
uint8 SerialCommTxByte(uint8 data) /* return 0 --> ack */
{
    int32 i;

    for(i=7; i>=0; i--) {
        GPIO_WriteIO( 0, SCL); /* low */
        /* The bus operates at a maximum clock frequency of 400 kHz */
        if(i==7)GPIO_InitIO(1,SDA);  // dummy
        GPIO_WriteIO(((data>>i)&0x01), SDA);
        GPIO_WriteIO( 1, SCL); /* high */
    }
    GPIO_WriteIO(0, SCL); /* low */
    GPIO_InitIO(0,SDA);
    GPIO_WriteIO(1, SCL); /* high */
    return GPIO_ReadIO(SDA);
}
Пример #11
0
void SerialCommStart(void) /* start or re-start */
{
    GPIO_WriteIO(0,SCL);
    GPIO_InitIO(1,SDA);
    GPIO_WriteIO(1,SDA);
    GPIO_WriteIO(1,SCL);
    GPIO_WriteIO(0,SDA);   /* start condition */
}
Пример #12
0
void SerialCommStop(void)
{
    GPIO_WriteIO(0,SCL);
    GPIO_InitIO(1,SDA);
    GPIO_WriteIO(0,SDA);
    GPIO_WriteIO(1,SCL);
    GPIO_WriteIO(1,SDA); /* stop condition */
}
Пример #13
0
void SerialCommStart(void) /* start or re-start */
{
   GPIO_WriteIO(1,BUSENABLE);  /* bus enabled */
   GPIO_WriteIO(0,SCL);
   GPIO_InitIO(1,SDA);
   GPIO_WriteIO(1,SDA);
   GPIO_WriteIO(1,SCL);
   GPIO_WriteIO(0,SDA);   /* start condition */
}
Пример #14
0
void SerialCommRxByte(uint8 *data, uint8 ack)
{
    int32 i;
    uint32 dataCache;

    dataCache = 0;
    for(i=7; i>=0; i--) {
        GPIO_WriteIO(0, SCL);
        if(i==7)GPIO_InitIO(0,SDA);
        GPIO_WriteIO(1, SCL);
        dataCache |= (GPIO_ReadIO(SDA)<<i);
    }
    GPIO_WriteIO(0, SCL);
    GPIO_InitIO(1,SDA);
    GPIO_WriteIO(ack, SDA);
    GPIO_WriteIO(1, SCL);
    *data = (uint8)dataCache;
}
Пример #15
0
void SerialCommStop(void)
{
   GPIO_WriteIO(0,SCL);
   GPIO_InitIO(1,SDA);
   GPIO_WriteIO(0,SDA);
   GPIO_WriteIO(1,SCL);
   GPIO_WriteIO(1,SDA); /* stop condition */
   GPIO_WriteIO(0,BUSENABLE); /* bus disabled */
}
Пример #16
0
/******************************************************************************
* Function:
*	GPSLocateVibSensorStart
*
* Usage:
*	Start vibration sensor monitor
*
* Parameters:
*	None
*
* Return:
*	None
******************************************************************************/
void GPSLocateVibSensorStart(void)
{
	kal_bool bResult;
	kal_uint8 SilenceThreshold;

	if (gGPSVibSensorTimer != NULL)
	{
		//has already started, do nothing
		return;
	}
	bResult = GPSLocateNvramReadRecord(
				GPS_NVRAM_RECID_VIBSENSOR_POLLINGINTERVAL,
				&gGPSVibSensorPollingInterval,
				sizeof(kal_uint8)
				);
	if (bResult != KAL_TRUE)
	{
		return;
	}
	bResult = GPSLocateNvramReadRecord(
				GPS_NVRAM_RECID_VIBSENSOR_SILENCETHRESHOLD,
				&SilenceThreshold,
				sizeof(kal_uint8)
				);
	if (bResult != KAL_TRUE)
	{
		return;
	}
	/*
	NOTE: 
		unit of SilenceThreshold is minute
		unit of gGPSVibSensorPollingInterval is 50ms
		so, the following convert is needed.
	*/
	gGPSVibSensorSilenceThreshold = (SilenceThreshold*60*1000)/(gGPSVibSensorPollingInterval*50);
	gGPSVibSensorTimer = GPSAppTimer_Create(
								GENERAL_GPSAPP_TIMERID,
								GPSLocateVibSensorExpireProc,
								gGPSVibSensorPollingInterval*KAL_TICKS_50_MSEC,
								gGPSVibSensorPollingInterval*KAL_TICKS_50_MSEC,
								KAL_TRUE
								);
	/*
	Configurate GPIO: input, pull-up/down disable
	*/
	GPIO_ModeSetup(GPS_VIBRATION_SENSOR_GPIO, 0);
	GPIO_InitIO(INPUT, GPS_VIBRATION_SENSOR_GPIO);
	GPIO_PullenSetup(GPS_VIBRATION_SENSOR_GPIO, KAL_FALSE);
	//get the initial IO value
	gGPSVibSensorPreviousIOValue = GPIO_ReadIO(GPS_VIBRATION_SENSOR_GPIO);
	//initialize the state
	gGPSVibSensorCurrState = GPSLOCATE_VIBSENSORSTATUS_SILENCE;
	//initialize silence counter
	gSilenceCounter = 0;
}
Пример #17
0
/* Stop sequence of I2C

   SDA       ¢z¢w¢w
       ¢w¢w¢w¢}
   SCL     ¢z¢w¢w¢w
       ¢w¢w¢}
*/
void SerialCommStop(void)
{
    GPIO_InitIO(OUTPUT,SDA);
    GPIO_WriteIO(0,SCL);
    I2C_DUMMY_DELAY(I2C_DELAY);
    GPIO_WriteIO(0,SDA);
    I2C_DUMMY_DELAY(I2C_DELAY);
    GPIO_WriteIO(1,SCL);
    I2C_DUMMY_DELAY(I2C_DELAY);
    GPIO_WriteIO(1,SDA);
    I2C_DUMMY_DELAY(I2C_DELAY);
}
Пример #18
0
/* Start sequence of I2C

   SDA ¢w¢w¢{
           ¢|¢w¢w
   SCL ¢w¢w¢w¢{
             ¢|¢w¢w
*/
void SerialCommStart(void) /* Prepare the SDA and SCL for sending/receiving */
{
    GPIO_InitIO(OUTPUT,SDA);
    GPIO_WriteIO(1,SDA);
    I2C_DUMMY_DELAY(I2C_DELAY);
    GPIO_WriteIO(1,SCL);
    I2C_DUMMY_DELAY(I2C_DELAY);
    GPIO_WriteIO(0,SDA);
    I2C_DUMMY_DELAY(I2C_DELAY);
    GPIO_WriteIO(0,SCL);
    I2C_DUMMY_DELAY(I2C_DELAY);
}
Пример #19
0
void SerialCommRxByte(kal_uint8 *data, kal_uint8 ack)
{
   kal_int16 i;
   kal_uint32 dataCache;
   dataCache = 0;
   GPIO_InitIO(0,SDA);
   for(i=8; --i>=0;){
      dataCache <<= 1;
      GPIO_WriteIO(1, SCL);
      I2C_DUMMY_DELAY(5);
      dataCache |= GPIO_ReadIO(SDA);
      GPIO_WriteIO(0, SCL);
      I2C_DUMMY_DELAY(5);
   }
   GPIO_InitIO(1,SDA);
   GPIO_WriteIO(ack, SDA);
   I2C_DUMMY_DELAY(5);
   GPIO_WriteIO(1, SCL);
   *data = (kal_uint8)dataCache;
   GPIO_WriteIO(0, SCL);
}
Пример #20
0
void RDA_bt_SerialCommStart(void) /* start or re-start */
{
   GPIO_InitIO(1,RDA5868_SDA);
   GPIO_WriteIO(1,RDA5868_SDA);
   GPIO_WriteIO(1,RDA5868_SCL);
   
   DELAY(DURATION_START_1);
   GPIO_WriteIO(0,RDA5868_SDA);   
   DELAY(DURATION_START_2);
   GPIO_WriteIO(0,RDA5868_SCL);
   DELAY(DURATION_START_3);/* start condition */
}
Пример #21
0
void RDA_bt_SerialCommStop(void)
{
   GPIO_WriteIO(0,RDA5868_SCL);
   DELAY(DURATION_LOW);
   GPIO_InitIO(1,RDA5868_SDA);
   GPIO_WriteIO(0,RDA5868_SDA);
   DELAY(DURATION_STOP_1);
   GPIO_WriteIO(1,RDA5868_SCL);
   DELAY(DURATION_STOP_2);
   GPIO_WriteIO(1,RDA5868_SDA); /* stop condition */
   DELAY(DURATION_STOP_3);
}
Пример #22
0
/*************************************************************************
* FUNCTION
*	serial_init
*
* DESCRIPTION
*	This function initializes serial interface.
*
* PARAMETERS
*  None
* RETURNS
*	None
*
* GLOBALS AFFECTED
*
*************************************************************************/
void serial_init(void) 
{ 
   kal_uint16 delay;
	kal_int16 x, y;
   
	GPIO_WriteIO(0,SPI_CS_PIN);
   GPIO_ModeSetup(SPI_DIN_PIN,  0x0);
   GPIO_ModeSetup(SPI_CLK_PIN,  0x0);
   GPIO_ModeSetup(SPI_DOUT_PIN, 0x0); 
   GPIO_ModeSetup(SPI_CS_PIN,   0x0);
   GPIO_ModeSetup(SPI_BUSY_PIN, 0x0);  
   GPIO_InitIO(OUTPUT,SPI_DIN_PIN); 
   GPIO_InitIO(OUTPUT,SPI_CLK_PIN);
   GPIO_InitIO(INPUT,SPI_DOUT_PIN);
   GPIO_InitIO(OUTPUT,SPI_CS_PIN);
   GPIO_InitIO(INPUT,SPI_BUSY_PIN);
   GPIO_WriteIO(0,SPI_CS_PIN);
   
   /*AR7643 needs this, so weird*/
   for(delay=0;delay<1000;delay++){};   
   //tp_read_adc(&x, &y);
}
Пример #23
0
void SerialCommRxByte(uint8 *data, uint8 ack)
{
   int32 i;
   uint32 dataCache;

   dataCache = 0;
   for(i=7; i>=0; i--){
      GPIO_WriteIO(0, SCL);
      if(i==7)GPIO_InitIO(0,SDA);
      { // For EV200 only, solve a hardware bug
      	kal_int32 cnt;  // dummy for_loop
      	for(cnt=0; cnt<20; cnt++);
      }
      GPIO_WriteIO(1, SCL);
      dataCache |= (GPIO_ReadIO(SDA)<<i);
   }
   GPIO_WriteIO(0, SCL);
   GPIO_InitIO(1,SDA);
   GPIO_WriteIO(ack, SDA);
   GPIO_WriteIO(1, SCL);
   *data = (uint8)dataCache;
}
Пример #24
0
void SerialCommRxByte(unsigned  char *data, unsigned char ack)
{
   int i;
   unsigned int dataCache;
   dataCache = 0;
   GPIO_InitIO(INPUT,SDA);
   for(i=8; --i>=0;){
      dataCache <<= 1;
      I2C_DUMMY_DELAY(I2C_DELAY);
      GPIO_WriteIO(1, SCL);
      I2C_DUMMY_DELAY(I2C_DELAY);
      dataCache |= GPIO_ReadIO(SDA);
      GPIO_WriteIO(0, SCL);
      I2C_DUMMY_DELAY(I2C_DELAY);
   }
   GPIO_InitIO(OUTPUT,SDA);
   GPIO_WriteIO(ack, SDA);
   I2C_DUMMY_DELAY(I2C_DELAY);
   GPIO_WriteIO(1, SCL);
   I2C_DUMMY_DELAY(I2C_DELAY);
   GPIO_WriteIO(0, SCL);
   I2C_DUMMY_DELAY(I2C_DELAY);
   *data = (unsigned char)dataCache;
}
Пример #25
0
unsigned int SerialCommTxByte(unsigned char data) /* return 0 --> ack */
{
    int i, ack;
    
    GPIO_InitIO(OUTPUT,SDA);

    for(i=8; --i>0;){
        GPIO_WriteIO((data>>i)&0x01, SDA);
        I2C_DUMMY_DELAY(I2C_DELAY);
        GPIO_WriteIO( 1, SCL); /* high */
        I2C_DUMMY_DELAY(I2C_DELAY);
        GPIO_WriteIO( 0, SCL); /* low */
        I2C_DUMMY_DELAY(I2C_DELAY);
    }
    GPIO_WriteIO((data>>i)&0x01, SDA);
    I2C_DUMMY_DELAY(I2C_DELAY);
    GPIO_WriteIO( 1, SCL); /* high */
    I2C_DUMMY_DELAY(I2C_DELAY);
    GPIO_WriteIO( 0, SCL); /* low */
    I2C_DUMMY_DELAY(I2C_DELAY);
    
    GPIO_WriteIO(0, SDA);
    I2C_DUMMY_DELAY(I2C_DELAY);
    GPIO_InitIO(INPUT,SDA);
    I2C_DUMMY_DELAY(I2C_DELAY);
    GPIO_WriteIO(1, SCL);
    I2C_DUMMY_DELAY(I2C_DELAY);
    ack = GPIO_ReadIO(SDA); /// ack 1: error , 0:ok
    GPIO_WriteIO(0, SCL);
    I2C_DUMMY_DELAY(I2C_DELAY);
    
    if(ack==1)
        return 0;
    else
        return 1;  
}
Пример #26
0
kal_uint8 SerialCommTxByte(kal_uint8 data) /* return 0 --> ack */
{
   kal_int16 i, ack;
   GPIO_InitIO(1,SDA);
   for(i=8; --i>0;){
      GPIO_WriteIO((data>>i)&0x01, SDA);
      I2C_DUMMY_DELAY(5);
      GPIO_WriteIO( 1, SCL); /* high */
      I2C_DUMMY_DELAY(5);
      GPIO_WriteIO( 0, SCL); /* low */
      I2C_DUMMY_DELAY(5);
   }
   GPIO_WriteIO((data>>i)&0x01, SDA);
   I2C_DUMMY_DELAY(5);
   GPIO_WriteIO( 1, SCL); /* high */
   I2C_DUMMY_DELAY(5);
   GPIO_WriteIO( 0, SCL); /* low */

   GPIO_InitIO(0,SDA);
   GPIO_WriteIO(1, SCL);
   I2C_DUMMY_DELAY(5);
   ack = GPIO_ReadIO(SDA); /// ack
   GPIO_WriteIO(0, SCL);
}
Пример #27
0
void irda_switch_to_sir(void)
{
	#if defined(__IRDA_VISHAY_6102__)
	/*Vishay 6614*/
   #ifndef __CUST_NEW__
   GPIO_ModeSetup(IRDA_GPIO_MODE_SWITCH, 0);
   GPIO_InitIO(OUTPUT, IRDA_GPIO_MODE_SWITCH);   	
   #endif /* __CUST_NEW__ */
	GPIO_WriteIO(0, IRDA_GPIO_MODE_SWITCH);			
	#elif defined(__IRDA_AGILENT_3220__)||defined(__IRDA_VISHAY_6614__)	
		
	
   DRV_WriteReg(IR_TRANSCEIVER_PDN,0x1);   
   irda_delay(irda_test_delay);
   DRV_WriteReg(IR_TRANSCEIVER_PDN,0x5);   
   irda_delay(irda_test_delay);
   DRV_WriteReg(IR_TRANSCEIVER_PDN,0x4);         
   irda_delay(irda_test_delay);
   DRV_WriteReg(IR_TRANSCEIVER_PDN,0x0);
   #endif
}	
Пример #28
0
/******************************************************************************
* Function:
*	GPSLocateVibSensorInit
*
* Usage:
*	Init vibration sensor monitor
*
* Parameters:
*	None
*
* Return:
*	None
******************************************************************************/
void GPSLocateVibSensorInit(void)
{
#if 0
	/*
	Configurate GPIO: input, pull-up/down disable
	*/
	GPIO_ModeSetup(GPS_VIBRATION_SENSOR_GPIO, 0);
	GPIO_InitIO(INPUT, GPS_VIBRATION_SENSOR_GPIO);
	GPIO_PullenSetup(GPS_VIBRATION_SENSOR_GPIO, KAL_FALSE);
	// config gpio 31 as above because of eint 1 is connect to gpio 31 as a temp solution
#endif

	EINT_Set_HW_Debounce(GPS_VIBSENSOR_EINT_NO, 1);
	gbCurrentPolarity = KAL_FALSE;
	EINT_Registration(GPS_VIBSENSOR_EINT_NO, 
					KAL_TRUE, 
					gbCurrentPolarity, 
					GPSLocateVibSensorHISR, 
					KAL_TRUE
					);
	//Mask this EINT after registration, unmask it before using it
	EINT_Mask(GPS_VIBSENSOR_EINT_NO);
}
Пример #29
0
void SerialCommInit(void)
{
    GPIO_ModeSetup(SCL,0);
    GPIO_ModeSetup(SDA,0);
    GPIO_InitIO(OUTPUT,SCL);
}
/*
* FUNCTION                                                            
*	GPIO_init
*
* DESCRIPTION                                                           
*   	This function is to initialize the GPIO pins as all GPIO,
*	and configure them as output.
*
* CALLS  
*	None
*
* PARAMETERS
*	None
*	
* RETURNS
*	None
*
* GLOBALS AFFECTED
*   external_global
*/
void GPIO_init(void)
{

#ifdef __CUST_NEW__
   GPIO_setting_init();

//for LED and 15_segment init
#if defined(__MTK_TARGET__) && defined(DRV_GPIO_FOR_LED_AND_15_SEGMENT)

GPIO_ModeSetup(61, 0);//set mode 0
GPIO_ModeSetup(62, 0);
GPIO_ModeSetup(63, 0);
GPIO_ModeSetup(64, 0);
GPIO_ModeSetup(65, 0);
GPIO_ModeSetup(66, 0);

GPIO_InitIO(1, 61);//set direction output
GPIO_InitIO(1, 62);
GPIO_InitIO(1, 63);
GPIO_InitIO(1, 64);
GPIO_InitIO(1, 65);
GPIO_InitIO(1, 66);

GPIO_WriteIO(0, 61); //set output 1
GPIO_WriteIO(1, 62);
GPIO_WriteIO(1, 63);
GPIO_WriteIO(1, 64);
GPIO_WriteIO(1, 65);
GPIO_WriteIO(0, 66);
#endif

#else /* __CUST_NEW__ */
   DRV_WriteReg(GPIO_MODE1,0x4000);
   DRV_WriteReg(GPIO_MODE2,0x5a55);
   DRV_WriteReg(GPIO_MODE3,0x5555);
   DRV_WriteReg(GPIO_MODE4,0x1555);
   //DRV_WriteReg(GPIO_MODE5,0x5555);
   //DRV_WriteReg(GPIO_MODE6,0x0055);
   //DRV_WriteReg(GPIO_MODE7,0x1505);

   // Add by GuoXin for MT6268A init boot (Should be removed after boot ready)
   // Set Bit[9..8] = 0x01, GPIO_52, UART2 RX
   // Set Bit[11..10] = 0x01, GPIO_53, UART2 TX
   DRV_WriteReg(GPIO_MODE7,0x0555);
   /* set GPIO for LCD */
   //*(volatile kal_uint16 *)0x84021a00 = 0x01460;
   DRV_WriteReg(GPIO_MODEB,0x01460);
   
   // Add by Morse for MT6268A Testing
   // Set Bit[13..12] = 0x01, GPIO_93, UART3 RX
   // Set Bit[11..10] = 0x01, GPIO_94, UART3 TX
   DRV_WriteReg(GPIO_MODEC,0x1540);

#ifdef  __BTMODULE_RFMD3500__ //add by shine, 2006/06/17
   GPIO_InitIO(1, 2);  // set GPIO2 as the output
   GPIO_InitIO(1, 3);  // set GPIO2 as the output
   GPIO_WriteIO(0,2);
   GPIO_WriteIO(0,3);
#endif

#ifdef __OTG_ENABLE__
   /* GPIO84 is for USB 20 IP drive chagre pump */
   GPIO_ModeSetup(84, 1);
#endif	/*__USB_ENABLE__*/

#endif /* __CUST_NEW__ */

}