BOOL AD7466_Driver::Uninitialize()
{
AD7466_CONFIG* Config = &g_AD7466_Config;
// disable the CS for the ADC and bring it high (inactive)
CPU_GPIO_EnableInputPin( Config->SPI_Config.DeviceCS, FALSE, NULL, GPIO_INT_NONE, RESISTOR_PULLUP );
// disable the ADMUX GPIO output control lines, and leave it inactive
CPU_GPIO_EnableInputPin( Config->ADMUX_EN_L_GPIO_PIN, FALSE, NULL, GPIO_INT_NONE, RESISTOR_PULLUP );
CPU_GPIO_EnableInputPin( Config->ADMUX_A0_GPIO_PIN, FALSE, NULL, GPIO_INT_NONE, RESISTOR_PULLUP );
CPU_GPIO_EnableInputPin( Config->ADMUX_A1_GPIO_PIN, FALSE, NULL, GPIO_INT_NONE, RESISTOR_PULLUP );
return TRUE;
}
BOOL GPIO_BUTTON_Driver::Initialize()
{
NATIVE_PROFILE_PAL_BUTTONS();
GPIO_BUTTON_CONFIG* Config = &g_GPIO_BUTTON_Config;
HAL_CONFIG_BLOCK::ApplyConfig( Config->GetDriverName(), Config, sizeof(GPIO_BUTTON_CONFIG) );
// reset button fifo queue
g_GPIO_BUTTON_Driver.m_ButtonFifo.Initialize();
// Buttons down, read as a 0 on the pins, and up buttons read as a 1,
// for simplicity, we invert that notion when reading the pins
// if we start up with keys pressed, store them as such
// do all buttons
GPIO_HW_TO_HAL_MAPPING* Mapping = &Config->Mapping[0 ];
GPIO_HW_TO_HAL_MAPPING* MappingEnd = &Config->Mapping[GPIO_BUTTON_CONFIG::c_COUNT];
for(; Mapping < MappingEnd; Mapping++)
{
GPIO_PIN hw = Mapping->m_HW;
if(hw != GPIO_PIN_NONE)
{
CPU_GPIO_EnableInputPin( hw, TRUE, ISR, GPIO_INT_EDGE_BOTH, RESISTOR_PULLUP );
if(!CPU_GPIO_GetPinState( hw ))
{
Buttons_RegisterStateChange( Mapping->m_HAL, 0 );
}
}
}
return TRUE;
}
int ENC28J60_Driver::Open( ENC28J60_DRIVER_CONFIG* config, int index )
{
NATIVE_PROFILE_HAL_DRIVERS_ETHERNET();
int use_default_multicast = 1;
if(config == NULL) return -1;
memset(&g_ENC28J60_Driver.m_currentDhcpSession, 0, sizeof(g_ENC28J60_Driver.m_currentDhcpSession));
/* Enable the CHIP SELECT pin */
if (CPU_GPIO_EnableInputPin (config->SPI_Config.DeviceCS,
FALSE,
NULL,
GPIO_INT_NONE,
RESISTOR_PULLUP) == FALSE)
{
return -1;
}
/* Open the interface first */
g_ENC28J60_Driver.m_interfaceNumber = xn_interface_open_config(ENC28J60_DEVICE,
index, /* minor_number */
0, /* ioaddress */
0, /* irq value */
0 /* mem_address) */
);
if (g_ENC28J60_Driver.m_interfaceNumber == -1)
{
return -1;
}
if(index == 0) // default debugger port is index 0
{
if (xn_interface_opt(g_ENC28J60_Driver.m_interfaceNumber,
IO_DEFAULT_MCAST,
(RTP_PFCCHAR)&use_default_multicast,
sizeof(int)) == -1)
{
/* Failed to set the default multicast interface */
}
}
/* Enable the INTERRUPT pin */
if (CPU_GPIO_EnableInputPin2(config->INT_Pin,
FALSE, /* Glitch filter enable */
(GPIO_INTERRUPT_SERVICE_ROUTINE) &enc28j60_pre_interrupt, /* ISR */
0, /* minor number */
GPIO_INT_EDGE_LOW , /* Interrupt edge */
RESISTOR_PULLUP) == FALSE) /* Resistor State */
{
return -1;
}
return g_ENC28J60_Driver.m_interfaceNumber;
}
BOOL CPU_SPI_Xaction_Stop(const SPI_CONFIGURATION& Configuration)
{
LPC_SSP_T *spi = SPI_REG(Configuration.SPI_mod);
while (SPI_Busy(spi)); // wait for completion
if(Configuration.CS_Hold_uSecs)
{
HAL_Time_Sleep_MicroSeconds_InterruptEnabled(Configuration.CS_Hold_uSecs);
}
CPU_GPIO_SetPinState(Configuration.DeviceCS, !Configuration.CS_Active);
GPIO_RESISTOR res = RESISTOR_PULLDOWN;
if (Configuration.MSK_IDLE) res = RESISTOR_PULLUP;
GPIO_PIN msk, miso, mosi;
CPU_SPI_GetPins(Configuration.SPI_mod, msk, miso, mosi);
CPU_GPIO_EnableInputPin(msk, FALSE, NULL, GPIO_INT_NONE, res);
CPU_GPIO_EnableInputPin(miso, FALSE, NULL, GPIO_INT_NONE, RESISTOR_PULLDOWN);
CPU_GPIO_EnableInputPin(mosi, FALSE, NULL, GPIO_INT_NONE, RESISTOR_PULLDOWN);
SPI_Disable(spi); // Disable SPI
return TRUE;
}
BOOL MC9328MXL_SPI_Driver::Initialize()
{
NATIVE_PROFILE_HAL_PROCESSOR_SPI();
// Start by disabling the modules, since it does not happen on reset
for (int i=0; i<MC9328MXL_SPI::c_MAX_SPI; i++)
{
if(g_MC9328MXL_SPI_Driver.m_initialized[i] == FALSE)
{
MC9328MXL::SPI(i).CONTROLREG &= (~MC9328MXL_SPI::CONTROLREG_SPIEN); //Disable SPI Module, don't care the other bit.
g_MC9328MXL_SPI_Driver.m_initialized[i] = TRUE;
}
}
// set up the GPIOs, always set them in the right state, as some other peripheral could have stolen them
// should not put the SPI pins to any state, as it is unknown what user has connected it to.
// put pins as in input would be the safest state.
// SPI 1
CPU_GPIO_EnableInputPin( MC9328MXL_SPI::c_SPI1_SCLK, FALSE, NULL, GPIO_INT_NONE, RESISTOR_PULLUP );
CPU_GPIO_EnableInputPin( MC9328MXL_SPI::c_SPI1_MISO, FALSE, NULL, GPIO_INT_NONE, RESISTOR_PULLUP );
CPU_GPIO_EnableInputPin( MC9328MXL_SPI::c_SPI1_MOSI, FALSE, NULL, GPIO_INT_NONE, RESISTOR_PULLUP );
#if !defined(PLATFORM_ARM_MC9328MXS)
// SPI 2
CPU_GPIO_EnableInputPin( MC9328MXL_SPI::c_SPI2_SCLK, FALSE, NULL, GPIO_INT_NONE, RESISTOR_PULLUP );
CPU_GPIO_EnableInputPin( MC9328MXL_SPI::c_SPI2_MISO, FALSE, NULL, GPIO_INT_NONE, RESISTOR_PULLUP );
CPU_GPIO_EnableInputPin( MC9328MXL_SPI::c_SPI2_MOSI, FALSE, NULL, GPIO_INT_NONE, RESISTOR_PULLUP );
#endif
return TRUE;
}
BOOL GPIO_BUTTON_Driver::Uninitialize()
{
NATIVE_PROFILE_PAL_BUTTONS();
GPIO_BUTTON_CONFIG* Config = &g_GPIO_BUTTON_Config;
GPIO_HW_TO_HAL_MAPPING* Mapping = &Config->Mapping[0 ];
GPIO_HW_TO_HAL_MAPPING* MappingEnd = &Config->Mapping[GPIO_BUTTON_CONFIG::c_COUNT];
for(; Mapping < MappingEnd; Mapping++)
{
if(Mapping->m_HW != GPIO_PIN_NONE)
{
CPU_GPIO_EnableInputPin( Mapping->m_HW, FALSE, NULL, GPIO_INT_NONE, RESISTOR_PULLUP );
}
}
return TRUE;
}
BOOL AT91_SPI_Driver::Initialize()
{
NATIVE_PROFILE_HAL_PROCESSOR_SPI();
// Power Management Controller
AT91_PMC &pmc = AT91::PMC();
// Start by disabling the modules, since it does not happen on reset
for(int i = 0; i < AT91_SPI::c_MAX_SPI; i++)
{
if(g_AT91_SPI_Driver.m_initialized[i] == FALSE)
{
AT91_SPI &spi = AT91::SPI(i);
spi.SPI_CR |= AT91_SPI::SPI_CR_DISABLE_SPI; //Disable SPI Module, don't care the other bit.
g_AT91_SPI_Driver.m_initialized[i] = TRUE;
}
}
pmc.EnablePeriphClock(AT91C_ID_SPI0);
#if (AT91C_MAX_SPI == 2)
pmc.EnablePeriphClock(AT91C_ID_SPI1);
#endif
// set up the GPIOs, always set them in the right state, as some other peripheral could have stolen them
// should not put the SPI pins to any state, as it is unknown what user has connected it to.
// put pins as in input would be the safest state.
// SPI 0
CPU_GPIO_EnableInputPin(AT91_SPI0_SCLK, FALSE, NULL, GPIO_INT_NONE, RESISTOR_PULLUP);
CPU_GPIO_EnableInputPin(AT91_SPI0_MOSI, FALSE, NULL, GPIO_INT_NONE, RESISTOR_PULLUP);
CPU_GPIO_EnableInputPin(AT91_SPI0_MISO, FALSE, NULL, GPIO_INT_NONE, RESISTOR_PULLUP);
#if (AT91C_MAX_SPI == 2)
// SPI 1
CPU_GPIO_EnableInputPin(AT91_SPI1_SCLK, FALSE, NULL, GPIO_INT_NONE, RESISTOR_PULLUP);
CPU_GPIO_EnableInputPin(AT91_SPI1_MOSI, FALSE, NULL, GPIO_INT_NONE, RESISTOR_PULLUP);
CPU_GPIO_EnableInputPin(AT91_SPI1_MISO, FALSE, NULL, GPIO_INT_NONE, RESISTOR_PULLUP);
#endif
return TRUE;
}
void Piezo_Driver::Uninitialize()
{
g_Piezo_Driver.m_ToneDone .Abort();
g_Piezo_Driver.m_ToneRelease.Abort();
{
GLOBAL_LOCK(irq);
EmptyQueue();
//
// This purges the currently playing tone.
//
StartNext();
}
bool fEnabled = INTERRUPTS_ENABLED_STATE();
if(!fEnabled) ENABLE_INTERRUPTS();
ToneRelease( NULL );
if(!fEnabled) DISABLE_INTERRUPTS();
// restore the hardware to proper default state
for(int i = 0; i < 2; i++)
{
PWM_CONFIG* PWM_Config = &g_pPIEZO_Config->PWM_Config[i];
if(PWM_Config->PWM_Output.Pin != GPIO_PIN_NONE)
{
CPU_GPIO_EnableInputPin( PWM_Config->PWM_Output.Pin, FALSE, NULL, GPIO_INT_NONE, RESISTOR_PULLDOWN );
}
}
}
BOOL MC9328MXL_SPI_Driver::Xaction_Stop( const SPI_CONFIGURATION& Configuration )
{
NATIVE_PROFILE_HAL_PROCESSOR_SPI();
if(g_MC9328MXL_SPI_Driver.m_Enabled[Configuration.SPI_mod])
{
UINT32 index = Configuration.SPI_mod;
MC9328MXL_SPI & SPI = MC9328MXL::SPI(index);
// we should have cleared the last TBF on the last RBF true setting
// we should never bring CS inactive with the shifter busy
ASSERT( SPI.TransmitBufferEmpty());
ASSERT( SPI.ReceiveBufferEmpty ());
ASSERT( SPI.ShiftBufferEmpty ());
if(Configuration.CS_Hold_uSecs)
{
HAL_Time_Sleep_MicroSeconds_InterruptEnabled( Configuration.CS_Hold_uSecs );
}
// avoid noise drawing excess power on a floating line by putting this in pulldown
#if defined(PLATFORM_ARM_MC9328MXS)
CPU_GPIO_EnableInputPin( MC9328MXL_SPI::c_SPI1_MISO, FALSE, NULL, GPIO_INT_NONE, RESISTOR_PULLUP );
#else
if (index == MC9328MXL_SPI::c_SPI1)
{
CPU_GPIO_EnableInputPin( MC9328MXL_SPI::c_SPI1_MISO, FALSE, NULL, GPIO_INT_NONE, RESISTOR_PULLUP );
}
else
{
CPU_GPIO_EnableInputPin( MC9328MXL_SPI::c_SPI2_MISO, FALSE, NULL, GPIO_INT_NONE, RESISTOR_PULLUP );
}
#endif
// next, bring the CS to the proper inactive state
if((Configuration.DeviceCS != MC9328MXL_GPIO::c_Pin_None) && (Configuration.DeviceCS != MC9328MXL_SPI::c_SPI1_SS))
{
CPU_GPIO_SetPinState( Configuration.DeviceCS, !Configuration.CS_Active );
}
// make sure that we don't trigger the SS pin for LCD on the iMXS board, this may change if Freescale change their circuitry
// can remove if not use on imxs platform
// be safe, as LCD SPI access will use this function as well, set it back to Output
#if (HARDWARE_BOARD_TYPE >= HARDWARE_BOARD_i_MXS_DEMO_REV_V1_2)
CPU_GPIO_EnableOutputPin( MC9328MXL_SPI::c_SPI1_SS, TRUE );
#endif
// put pins in output low state when not in use to avoid noise since clock stop and reset will cause these to become inputs
#if defined(PLATFORM_ARM_MC9328MXS)
CPU_GPIO_EnableOutputPin( MC9328MXL_SPI::c_SPI1_SCLK, FALSE );
CPU_GPIO_EnableOutputPin( MC9328MXL_SPI::c_SPI1_MOSI, FALSE );
#else
if (index == MC9328MXL_SPI::c_SPI1)
{
CPU_GPIO_EnableOutputPin( MC9328MXL_SPI::c_SPI1_SCLK, FALSE );
CPU_GPIO_EnableOutputPin( MC9328MXL_SPI::c_SPI1_MOSI, FALSE );
}
else
{
CPU_GPIO_EnableOutputPin( MC9328MXL_SPI::c_SPI2_SCLK, FALSE );
CPU_GPIO_EnableOutputPin( MC9328MXL_SPI::c_SPI2_MOSI, FALSE );
}
#endif
// off SPI module
SPI.CONTROLREG &= ~SPI.CONTROLREG_SPIEN;
g_MC9328MXL_SPI_Driver.m_Enabled[Configuration.SPI_mod] = FALSE;
}
else
{
lcd_printf("\fSPI Collision 4\r\n");
HARD_BREAKPOINT();
return FALSE;
}
return TRUE;
}
BOOL MC9328MXL_SPI_Driver::Xaction_Start( const SPI_CONFIGURATION& Configuration )
{
NATIVE_PROFILE_HAL_PROCESSOR_SPI();
if(!g_MC9328MXL_SPI_Driver.m_Enabled[Configuration.SPI_mod])
{
g_MC9328MXL_SPI_Driver.m_Enabled[Configuration.SPI_mod] = TRUE;
UINT32 index = Configuration.SPI_mod;
MC9328MXL_SPI & SPI = MC9328MXL::SPI(index);
// make sure we didn't start one in the middle of an existing transaction
if( SPI.CONTROLREG & SPI.CONTROLREG_SPIEN )
{
lcd_printf("\fSPI Collision 1\r\n");
hal_printf("\fSPI Collision 1\r\n");
HARD_BREAKPOINT();
return FALSE;
}
// first build the mode register
SPI.CONTROLREG = MC9328MXL_SPI::ConfigurationToMode( Configuration );
// LCD Controller needs to have Pulse mode enabled
#if (HARDWARE_BOARD_TYPE >= HARDWARE_BOARD_i_MXS_DEMO_REV_V1_2)
if(Configuration.DeviceCS == MC9328MXL_SPI::c_SPI1_SS)
{
SPI.PERIODREG = 2;
SPI.CONTROLREG |= MC9328MXL_SPI::CONTROLREG_SSCTL_PULSE; // Pulse SS between bursts
// set the SSPOL to active lo as it is force at the ConfigurationMOde to not trigger SS for other SPI operation
SPI.CONTROLREG &= (~MC9328MXL_SPI::CONTROLREG_SSPOL_HIGH); // Pulse SS between bursts
CPU_GPIO_DisablePin( MC9328MXL_SPI::c_SPI1_SS,RESISTOR_DISABLED, 0, GPIO_ALT_PRIMARY);
}
#endif
SPI.CONTROLREG |= MC9328MXL_SPI::CONTROLREG_SPIEN;
#if (SPI_LOOP_BACK)
// for spi testing
SPI.TESTREG |= SPI.TESTREG_LBC;
#endif
// everything should be clean and idle
ASSERT( SPI.TransmitBufferEmpty());
ASSERT( SPI.ReceiveBufferEmpty());
ASSERT( SPI.ShiftBufferEmpty ());
// make sure not trigger the SS pin for the LCD when doing any SPI activity.
// but we can have LCD SPI activity, if so, we want the SS be able to drive
#if (HARDWARE_BOARD_TYPE >= HARDWARE_BOARD_i_MXS_DEMO_REV_V1_2)
if(Configuration.DeviceCS != MC9328MXL_SPI::c_SPI1_SS)
{
CPU_GPIO_EnableInputPin( MC9328MXL_SPI::c_SPI1_SS, FALSE, NULL, GPIO_INT_NONE, RESISTOR_PULLUP );
}
#endif
#if defined(PLATFORM_ARM_MC9328MXS)
// make sure that we don't trigger the SS pin for LCD
CPU_GPIO_DisablePin( MC9328MXL_SPI::c_SPI1_SCLK, RESISTOR_DISABLED, 0, GPIO_ALT_PRIMARY);
CPU_GPIO_DisablePin( MC9328MXL_SPI::c_SPI1_MOSI, RESISTOR_DISABLED, 0, GPIO_ALT_PRIMARY);
#else // MC9328MXL
if (index == MC9328MXL_SPI::c_SPI1)
{
// allow peripheral control of pins
CPU_GPIO_DisablePin( MC9328MXL_SPI::c_SPI1_SCLK, RESISTOR_DISABLED, 0, GPIO_ALT_PRIMARY);
CPU_GPIO_DisablePin( MC9328MXL_SPI::c_SPI1_MOSI, RESISTOR_DISABLED, 0, GPIO_ALT_PRIMARY);
}
else
{
// SPI2 need to set to Alternate function - AIN
CPU_GPIO_DisablePin(MC9328MXL_SPI::c_SPI2_SCLK, RESISTOR_DISABLED, MC9328MXL_GPIO::DDIR__OUT, GPIO_ALT_MODE_1);
CPU_GPIO_DisablePin(MC9328MXL_SPI::c_SPI2_MOSI, RESISTOR_DISABLED, MC9328MXL_GPIO::DDIR__OUT, GPIO_ALT_MODE_1);
}
#endif
// first set CS active as soon as clock and data pins are in proper initial state
if((Configuration.DeviceCS != MC9328MXL_GPIO::c_Pin_None) && (Configuration.DeviceCS != MC9328MXL_SPI::c_SPI1_SS))
{
CPU_GPIO_EnableOutputPin( Configuration.DeviceCS, Configuration.CS_Active );
}
#if defined(PLATFORM_ARM_MC9328MXS)
CPU_GPIO_DisablePin( MC9328MXL_SPI::c_SPI1_MISO, RESISTOR_DISABLED, 0, GPIO_ALT_PRIMARY );
#else
if (index == MC9328MXL_SPI::c_SPI1)
{
CPU_GPIO_DisablePin( MC9328MXL_SPI::c_SPI1_MISO, RESISTOR_DISABLED, 0, GPIO_ALT_PRIMARY );
}
else
{
// set AOUT mode for MISO for SPI 2
CPU_GPIO_DisablePin(MC9328MXL_SPI::c_SPI2_MISO, RESISTOR_DISABLED,MC9328MXL_GPIO::DDIR__IN ,GPIO_ALT_MODE_4);
MC9328MXL::SC().FMCR |= MC9328MXL_SC::FMCR__SPI2_RXD_SEL;
}
#endif
if(Configuration.CS_Setup_uSecs)
{
HAL_Time_Sleep_MicroSeconds_InterruptEnabled( Configuration.CS_Setup_uSecs );
}
}
else
{
lcd_printf( "\fSPI Collision 3\r\n" );
HARD_BREAKPOINT();
return FALSE;
}
return TRUE;
}
int ENC28J60_LWIP_Driver::Open( ENC28J60_LWIP_DRIVER_CONFIG* config, int index )
{
NATIVE_PROFILE_HAL_DRIVERS_ETHERNET();
/* Network interface variables */
struct ip_addr ipaddr, netmask, gw;
struct netif *pNetIF;
int len;
const SOCK_NetworkConfiguration *iface;
if(config == NULL) return -1;
iface = &g_NetworkConfig.NetworkInterfaces[index];
if(0 == (iface->flags & SOCK_NETWORKCONFIGURATION_FLAGS_DHCP))
{
ipaddr.addr = iface->ipaddr;
gw.addr = iface->gateway;
netmask.addr = iface->subnetmask;
}
else
{
/* Set network address variables - this will be set by either DHCP or when the configuration is applied */
IP4_ADDR(&gw , 0, 0, 0, 0);
IP4_ADDR(&ipaddr , 0, 0, 0, 0);
IP4_ADDR(&netmask, 255, 255, 255, 0);
}
len = g_ENC28J60_NetIF.hwaddr_len;
if(len == 0 || iface->macAddressLen < len)
{
len = iface->macAddressLen;
g_ENC28J60_NetIF.hwaddr_len = len;
}
memcpy(g_ENC28J60_NetIF.hwaddr, iface->macAddressBuffer, len);
pNetIF = netif_add( &g_ENC28J60_NetIF, &ipaddr, &netmask, &gw, NULL, enc28j60_ethhw_init, ethernet_input );
netif_set_default( pNetIF );
LwipNetworkStatus = enc28j60_get_link_status(&config->SPI_Config);
/* Initialize the continuation routine for the driver interrupt and receive */
InitContinuations( pNetIF );
/* Enable the INTERRUPT pin */
if (CPU_GPIO_EnableInputPin2(config->INT_Pin,
FALSE, /* Glitch filter enable */
(GPIO_INTERRUPT_SERVICE_ROUTINE) &enc28j60_lwip_pre_interrupt, /* ISR */
&g_ENC28J60_NetIF, /* minor number */
GPIO_INT_EDGE_LOW , /* Interrupt edge */
RESISTOR_PULLUP) == FALSE) /* Resistor State */
{
return -1;
}
/* Enable the CHIP SELECT pin */
if (CPU_GPIO_EnableInputPin (config->SPI_Config.DeviceCS,
FALSE,
NULL,
GPIO_INT_NONE,
RESISTOR_PULLUP) == FALSE)
{
return -1;
}
return g_ENC28J60_NetIF.num;
}
void PXA271_USART_Driver::ProtectPins( int comPort, BOOL on )
{
struct PXA271_USART_CONFIG* Config = &g_PXA271_USART_Config;
if(comPort < 0 || comPort >= TOTAL_USART_PORT)
return;
USART_PORT_INFO& USART_port = All_USART_ports[comPort];
GLOBAL_LOCK(irq);
if(on)
{
if(!USART_port.PinsProtected)
{
USART_port.PinsProtected = TRUE;
RxBufferFullInterruptEnable( comPort, FALSE );
if(Config->RxProtectInput)
{
CPU_GPIO_EnableInputPin( USART_port.RXD_Pin, FALSE, NULL, GPIO_INT_NONE, Config->RxProtectResistor );
}
else
{
CPU_GPIO_EnableOutputPin( USART_port.RXD_Pin, Config->RxProtectOutputValue );
}
TxBufferEmptyInterruptEnable( comPort, FALSE );
if(Config->TxProtectInput)
{
CPU_GPIO_EnableInputPin( USART_port.TXD_Pin, FALSE, NULL, GPIO_INT_NONE, Config->TxProtectResistor );
}
else
{
CPU_GPIO_EnableOutputPin( USART_port.TXD_Pin, Config->TxProtectOutputValue );
}
if(USART_port.CTS_Pin_used)
{
if(Config->CTSProtectInput)
{
CPU_GPIO_EnableInputPin( USART_port.CTS_Pin, FALSE, NULL, GPIO_INT_NONE, Config->CTSProtectResistor );
}
else
{
CPU_GPIO_EnableOutputPin( USART_port.CTS_Pin, Config->CTSProtectOutputValue );
}
}
if(USART_port.RTS_Pin_used)
{
if(Config->RTSProtectInput)
{
CPU_GPIO_EnableInputPin( USART_port.RTS_Pin, FALSE, NULL, GPIO_INT_NONE, Config->RTSProtectResistor );
}
else
{
CPU_GPIO_EnableOutputPin( USART_port.RTS_Pin, Config->RTSProtectOutputValue );
}
}
}
}
else
{
if(USART_port.PinsProtected)
{
USART_port.PinsProtected = FALSE;
CPU_GPIO_DisablePin( USART_port.TXD_Pin, RESISTOR_DISABLED, PXA271_GPIO::GPDR__DIR_OUT, USART_port.TXD_Pin_function );
TxBufferEmptyInterruptEnable( comPort, TRUE );
CPU_GPIO_DisablePin( USART_port.RXD_Pin, RESISTOR_DISABLED, PXA271_GPIO::GPDR__DIR_IN, USART_port.RXD_Pin_function );
RxBufferFullInterruptEnable( comPort, TRUE );
if(USART_port.CTS_Pin_used)
CPU_GPIO_DisablePin( USART_port.CTS_Pin, RESISTOR_DISABLED, PXA271_GPIO::GPDR__DIR_IN, USART_port.CTS_Pin_function );
if(USART_port.RTS_Pin_used)
CPU_GPIO_DisablePin( USART_port.RTS_Pin, RESISTOR_DISABLED, PXA271_GPIO::GPDR__DIR_OUT, USART_port.RTS_Pin_function );
}
}
}
