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 ); } } }