| //***************************************************************************** |
| // |
| // gpio.c |
| // |
| // Driver for the GPIO module. |
| // |
| // Copyright (C) 2014 Texas Instruments Incorporated - http://www.ti.com/ |
| // |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions |
| // are met: |
| // |
| // Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // |
| // Redistributions in binary form must reproduce the above copyright |
| // notice, this list of conditions and the following disclaimer in the |
| // documentation and/or other materials provided with the |
| // distribution. |
| // |
| // Neither the name of Texas Instruments Incorporated nor the names of |
| // its contributors may be used to endorse or promote products derived |
| // from this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| // |
| //***************************************************************************** |
| |
| //***************************************************************************** |
| // |
| //! \addtogroup GPIO_General_Purpose_InputOutput_api |
| //! @{ |
| // |
| //***************************************************************************** |
| |
| #include "inc/hw_types.h" |
| #include "inc/hw_gpio.h" |
| #include "inc/hw_ints.h" |
| #include "inc/hw_memmap.h" |
| #include "inc/hw_common_reg.h" |
| #include "debug.h" |
| #include "gpio.h" |
| #include "interrupt.h" |
| |
| |
| //***************************************************************************** |
| // |
| //! \internal |
| //! Checks a GPIO base address. |
| //! |
| //! \param ulPort is the base address of the GPIO port. |
| //! |
| //! This function determines if a GPIO port base address is valid. |
| //! |
| //! \return Returns \b true if the base address is valid and \b false |
| //! otherwise. |
| // |
| //***************************************************************************** |
| #ifdef DEBUG |
| static tBoolean |
| GPIOBaseValid(unsigned long ulPort) |
| { |
| return((ulPort == GPIOA0_BASE) || |
| (ulPort == GPIOA1_BASE) || |
| (ulPort == GPIOA2_BASE) || |
| (ulPort == GPIOA3_BASE) || |
| (ulPort == GPIOA4_BASE)); |
| } |
| #endif |
| |
| //***************************************************************************** |
| // |
| //! \internal |
| //! Gets the GPIO interrupt number. |
| //! |
| //! \param ulPort is the base address of the GPIO port. |
| //! |
| //! Given a GPIO base address, returns the corresponding interrupt number. |
| //! |
| //! \return Returns a GPIO interrupt number, or -1 if \e ulPort is invalid. |
| // |
| //***************************************************************************** |
| static long |
| GPIOGetIntNumber(unsigned long ulPort) |
| { |
| unsigned int ulInt; |
| |
| // |
| // Determine the GPIO interrupt number for the given module. |
| // |
| switch(ulPort) |
| { |
| case GPIOA0_BASE: |
| { |
| ulInt = INT_GPIOA0; |
| break; |
| } |
| |
| case GPIOA1_BASE: |
| { |
| ulInt = INT_GPIOA1; |
| break; |
| } |
| |
| case GPIOA2_BASE: |
| { |
| ulInt = INT_GPIOA2; |
| break; |
| } |
| |
| case GPIOA3_BASE: |
| { |
| ulInt = INT_GPIOA3; |
| break; |
| } |
| |
| default: |
| { |
| return(-1); |
| } |
| } |
| |
| // |
| // Return GPIO interrupt number. |
| // |
| return(ulInt); |
| } |
| |
| //***************************************************************************** |
| // |
| //! Sets the direction and mode of the specified pin(s). |
| //! |
| //! \param ulPort is the base address of the GPIO port |
| //! \param ucPins is the bit-packed representation of the pin(s). |
| //! \param ulPinIO is the pin direction and/or mode. |
| //! |
| //! This function will set the specified pin(s) on the selected GPIO port |
| //! as either an input or output under software control, or it will set the |
| //! pin to be under hardware control. |
| //! |
| //! The parameter \e ulPinIO is an enumerated data type that can be one of |
| //! the following values: |
| //! |
| //! - \b GPIO_DIR_MODE_IN |
| //! - \b GPIO_DIR_MODE_OUT |
| //! |
| //! where \b GPIO_DIR_MODE_IN specifies that the pin will be programmed as |
| //! a software controlled input, \b GPIO_DIR_MODE_OUT specifies that the pin |
| //! will be programmed as a software controlled output. |
| //! |
| //! The pin(s) are specified using a bit-packed byte, where each bit that is |
| //! set identifies the pin to be accessed, and where bit 0 of the byte |
| //! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. |
| //! |
| //! \note GPIOPadConfigSet() must also be used to configure the corresponding |
| //! pad(s) in order for them to propagate the signal to/from the GPIO. |
| //! |
| //! \return None. |
| // |
| //***************************************************************************** |
| void |
| GPIODirModeSet(unsigned long ulPort, unsigned char ucPins, |
| unsigned long ulPinIO) |
| { |
| // |
| // Check the arguments. |
| // |
| ASSERT(GPIOBaseValid(ulPort)); |
| ASSERT((ulPinIO == GPIO_DIR_MODE_IN) || (ulPinIO == GPIO_DIR_MODE_OUT)); |
| |
| // |
| // Set the pin direction and mode. |
| // |
| HWREG(ulPort + GPIO_O_GPIO_DIR) = ((ulPinIO & 1) ? |
| (HWREG(ulPort + GPIO_O_GPIO_DIR) | ucPins) : |
| (HWREG(ulPort + GPIO_O_GPIO_DIR) & ~(ucPins))); |
| } |
| |
| //***************************************************************************** |
| // |
| //! Gets the direction and mode of a pin. |
| //! |
| //! \param ulPort is the base address of the GPIO port. |
| //! \param ucPin is the pin number. |
| //! |
| //! This function gets the direction and control mode for a specified pin on |
| //! the selected GPIO port. The pin can be configured as either an input or |
| //! output under software control, or it can be under hardware control. The |
| //! type of control and direction are returned as an enumerated data type. |
| //! |
| //! \return Returns one of the enumerated data types described for |
| //! GPIODirModeSet(). |
| // |
| //***************************************************************************** |
| unsigned long |
| GPIODirModeGet(unsigned long ulPort, unsigned char ucPin) |
| { |
| unsigned long ulDir; |
| |
| // |
| // Check the arguments. |
| // |
| ASSERT(GPIOBaseValid(ulPort)); |
| ASSERT(ucPin < 8); |
| |
| // |
| // Convert from a pin number to a bit position. |
| // |
| ucPin = 1 << ucPin; |
| |
| // |
| // Return the pin direction and mode. |
| // |
| ulDir = HWREG(ulPort + GPIO_O_GPIO_DIR); |
| return(((ulDir & ucPin) ? 1 : 0)); |
| } |
| |
| //***************************************************************************** |
| // |
| //! Sets the interrupt type for the specified pin(s). |
| //! |
| //! \param ulPort is the base address of the GPIO port. |
| //! \param ucPins is the bit-packed representation of the pin(s). |
| //! \param ulIntType specifies the type of interrupt trigger mechanism. |
| //! |
| //! This function sets up the various interrupt trigger mechanisms for the |
| //! specified pin(s) on the selected GPIO port. |
| //! |
| //! The parameter \e ulIntType is an enumerated data type that can be one of |
| //! the following values: |
| //! |
| //! - \b GPIO_FALLING_EDGE |
| //! - \b GPIO_RISING_EDGE |
| //! - \b GPIO_BOTH_EDGES |
| //! - \b GPIO_LOW_LEVEL |
| //! - \b GPIO_HIGH_LEVEL |
| //! |
| //! The pin(s) are specified using a bit-packed byte, where each bit that is |
| //! set identifies the pin to be accessed, and where bit 0 of the byte |
| //! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. |
| //! |
| //! \note In order to avoid any spurious interrupts, the user must |
| //! ensure that the GPIO inputs remain stable for the duration of |
| //! this function. |
| //! |
| //! \return None. |
| // |
| //***************************************************************************** |
| void |
| GPIOIntTypeSet(unsigned long ulPort, unsigned char ucPins, |
| unsigned long ulIntType) |
| { |
| // |
| // Check the arguments. |
| // |
| ASSERT(GPIOBaseValid(ulPort)); |
| ASSERT((ulIntType == GPIO_FALLING_EDGE) || |
| (ulIntType == GPIO_RISING_EDGE) || (ulIntType == GPIO_BOTH_EDGES) || |
| (ulIntType == GPIO_LOW_LEVEL) || (ulIntType == GPIO_HIGH_LEVEL)); |
| |
| // |
| // Set the pin interrupt type. |
| // |
| HWREG(ulPort + GPIO_O_GPIO_IBE) = ((ulIntType & 1) ? |
| (HWREG(ulPort + GPIO_O_GPIO_IBE) | ucPins) : |
| (HWREG(ulPort + GPIO_O_GPIO_IBE) & ~(ucPins))); |
| HWREG(ulPort + GPIO_O_GPIO_IS) = ((ulIntType & 2) ? |
| (HWREG(ulPort + GPIO_O_GPIO_IS) | ucPins) : |
| (HWREG(ulPort + GPIO_O_GPIO_IS) & ~(ucPins))); |
| HWREG(ulPort + GPIO_O_GPIO_IEV) = ((ulIntType & 4) ? |
| (HWREG(ulPort + GPIO_O_GPIO_IEV) | ucPins) : |
| (HWREG(ulPort + GPIO_O_GPIO_IEV) & ~(ucPins))); |
| } |
| |
| //***************************************************************************** |
| // |
| //! Gets the interrupt type for a pin. |
| //! |
| //! \param ulPort is the base address of the GPIO port. |
| //! \param ucPin is the pin number. |
| //! |
| //! This function gets the interrupt type for a specified pin on the selected |
| //! GPIO port. The pin can be configured as a falling edge, rising edge, or |
| //! both edge detected interrupt, or it can be configured as a low level or |
| //! high level detected interrupt. The type of interrupt detection mechanism |
| //! is returned as an enumerated data type. |
| //! |
| //! \return Returns one of the enumerated data types described for |
| //! GPIOIntTypeSet(). |
| // |
| //***************************************************************************** |
| unsigned long |
| GPIOIntTypeGet(unsigned long ulPort, unsigned char ucPin) |
| { |
| unsigned long ulIBE, ulIS, ulIEV; |
| |
| // |
| // Check the arguments. |
| // |
| ASSERT(GPIOBaseValid(ulPort)); |
| ASSERT(ucPin < 8); |
| |
| // |
| // Convert from a pin number to a bit position. |
| // |
| ucPin = 1 << ucPin; |
| |
| // |
| // Return the pin interrupt type. |
| // |
| ulIBE = HWREG(ulPort + GPIO_O_GPIO_IBE); |
| ulIS = HWREG(ulPort + GPIO_O_GPIO_IS); |
| ulIEV = HWREG(ulPort + GPIO_O_GPIO_IEV); |
| return(((ulIBE & ucPin) ? 1 : 0) | ((ulIS & ucPin) ? 2 : 0) | |
| ((ulIEV & ucPin) ? 4 : 0)); |
| } |
| |
| //***************************************************************************** |
| // |
| //! Enables the specified GPIO interrupts. |
| //! |
| //! \param ulPort is the base address of the GPIO port. |
| //! \param ulIntFlags is the bit mask of the interrupt sources to enable. |
| //! |
| //! This function enables the indicated GPIO interrupt sources. Only the |
| //! sources that are enabled can be reflected to the processor interrupt; |
| //! disabled sources have no effect on the processor. |
| //! |
| //! The \e ulIntFlags parameter is the logical OR of any of the following: |
| //! |
| //! - \b GPIO_INT_DMA - interrupt due to GPIO triggered DMA Done |
| //! - \b GPIO_INT_PIN_0 - interrupt due to activity on Pin 0. |
| //! - \b GPIO_INT_PIN_1 - interrupt due to activity on Pin 1. |
| //! - \b GPIO_INT_PIN_2 - interrupt due to activity on Pin 2. |
| //! - \b GPIO_INT_PIN_3 - interrupt due to activity on Pin 3. |
| //! - \b GPIO_INT_PIN_4 - interrupt due to activity on Pin 4. |
| //! - \b GPIO_INT_PIN_5 - interrupt due to activity on Pin 5. |
| //! - \b GPIO_INT_PIN_6 - interrupt due to activity on Pin 6. |
| //! - \b GPIO_INT_PIN_7 - interrupt due to activity on Pin 7. |
| //! |
| //! \return None. |
| // |
| //***************************************************************************** |
| void |
| GPIOIntEnable(unsigned long ulPort, unsigned long ulIntFlags) |
| { |
| // |
| // Check the arguments. |
| // |
| ASSERT(GPIOBaseValid(ulPort)); |
| |
| // |
| // Enable the interrupts. |
| // |
| HWREG(ulPort + GPIO_O_GPIO_IM) |= ulIntFlags; |
| } |
| |
| //***************************************************************************** |
| // |
| //! Disables the specified GPIO interrupts. |
| //! |
| //! \param ulPort is the base address of the GPIO port. |
| //! \param ulIntFlags is the bit mask of the interrupt sources to disable. |
| //! |
| //! This function disables the indicated GPIO interrupt sources. Only the |
| //! sources that are enabled can be reflected to the processor interrupt; |
| //! disabled sources have no effect on the processor. |
| //! |
| //! The \e ulIntFlags parameter is the logical OR of any of the following: |
| //! |
| //! - \b GPIO_INT_DMA - interrupt due to GPIO triggered DMA Done |
| //! - \b GPIO_INT_PIN_0 - interrupt due to activity on Pin 0. |
| //! - \b GPIO_INT_PIN_1 - interrupt due to activity on Pin 1. |
| //! - \b GPIO_INT_PIN_2 - interrupt due to activity on Pin 2. |
| //! - \b GPIO_INT_PIN_3 - interrupt due to activity on Pin 3. |
| //! - \b GPIO_INT_PIN_4 - interrupt due to activity on Pin 4. |
| //! - \b GPIO_INT_PIN_5 - interrupt due to activity on Pin 5. |
| //! - \b GPIO_INT_PIN_6 - interrupt due to activity on Pin 6. |
| //! - \b GPIO_INT_PIN_7 - interrupt due to activity on Pin 7. |
| //! |
| //! \return None. |
| // |
| //***************************************************************************** |
| void |
| GPIOIntDisable(unsigned long ulPort, unsigned long ulIntFlags) |
| { |
| // |
| // Check the arguments. |
| // |
| ASSERT(GPIOBaseValid(ulPort)); |
| |
| // |
| // Disable the interrupts. |
| // |
| HWREG(ulPort + GPIO_O_GPIO_IM) &= ~(ulIntFlags); |
| } |
| |
| //***************************************************************************** |
| // |
| //! Gets interrupt status for the specified GPIO port. |
| //! |
| //! \param ulPort is the base address of the GPIO port. |
| //! \param bMasked specifies whether masked or raw interrupt status is |
| //! returned. |
| //! |
| //! If \e bMasked is set as \b true, then the masked interrupt status is |
| //! returned; otherwise, the raw interrupt status will be returned. |
| //! |
| //! \return Returns the current interrupt status, enumerated as a bit field of |
| //! values described in GPIOIntEnable(). |
| // |
| //***************************************************************************** |
| long |
| GPIOIntStatus(unsigned long ulPort, tBoolean bMasked) |
| { |
| // |
| // Check the arguments. |
| // |
| ASSERT(GPIOBaseValid(ulPort)); |
| |
| // |
| // Return the interrupt status. |
| // |
| if(bMasked) |
| { |
| return(HWREG(ulPort + GPIO_O_GPIO_MIS)); |
| } |
| else |
| { |
| return(HWREG(ulPort + GPIO_O_GPIO_RIS)); |
| } |
| } |
| |
| //***************************************************************************** |
| // |
| //! Clears the interrupt for the specified pin(s). |
| //! |
| //! \param ulPort is the base address of the GPIO port. |
| //! \param ulIntFlags is a bit mask of the interrupt sources to be cleared. |
| //! |
| //! Clears the interrupt for the specified pin(s). |
| //! |
| //! The \e ulIntFlags parameter has the same definition as the \e ulIntFlags |
| //! parameter to GPIOIntEnable(). |
| //! |
| //! |
| //! \return None. |
| // |
| //***************************************************************************** |
| void |
| GPIOIntClear(unsigned long ulPort, unsigned long ulIntFlags) |
| { |
| // |
| // Check the arguments. |
| // |
| ASSERT(GPIOBaseValid(ulPort)); |
| |
| // |
| // Clear the interrupts. |
| // |
| HWREG(ulPort + GPIO_O_GPIO_ICR) = ulIntFlags; |
| } |
| |
| //***************************************************************************** |
| // |
| //! Registers an interrupt handler for a GPIO port. |
| //! |
| //! \param ulPort is the base address of the GPIO port. |
| //! \param pfnIntHandler is a pointer to the GPIO port interrupt handling |
| //! function. |
| //! |
| //! This function will ensure that the interrupt handler specified by |
| //! \e pfnIntHandler is called when an interrupt is detected from the selected |
| //! GPIO port. This function will also enable the corresponding GPIO interrupt |
| //! in the interrupt controller; individual pin interrupts and interrupt |
| //! sources must be enabled with GPIOIntEnable(). |
| //! |
| //! \sa IntRegister() for important information about registering interrupt |
| //! handlers. |
| //! |
| //! \return None. |
| // |
| //***************************************************************************** |
| void |
| GPIOIntRegister(unsigned long ulPort, void (*pfnIntHandler)(void)) |
| { |
| // |
| // Check the arguments. |
| // |
| ASSERT(GPIOBaseValid(ulPort)); |
| |
| // |
| // Get the interrupt number associated with the specified GPIO. |
| // |
| ulPort = GPIOGetIntNumber(ulPort); |
| |
| // |
| // Register the interrupt handler. |
| // |
| IntRegister(ulPort, pfnIntHandler); |
| |
| // |
| // Enable the GPIO interrupt. |
| // |
| IntEnable(ulPort); |
| } |
| |
| //***************************************************************************** |
| // |
| //! Removes an interrupt handler for a GPIO port. |
| //! |
| //! \param ulPort is the base address of the GPIO port. |
| //! |
| //! This function will unregister the interrupt handler for the specified |
| //! GPIO port. This function will also disable the corresponding |
| //! GPIO port interrupt in the interrupt controller; individual GPIO interrupts |
| //! and interrupt sources must be disabled with GPIOIntDisable(). |
| //! |
| //! \sa IntRegister() for important information about registering interrupt |
| //! handlers. |
| //! |
| //! \return None. |
| // |
| //***************************************************************************** |
| void |
| GPIOIntUnregister(unsigned long ulPort) |
| { |
| // |
| // Check the arguments. |
| // |
| ASSERT(GPIOBaseValid(ulPort)); |
| |
| // |
| // Get the interrupt number associated with the specified GPIO. |
| // |
| ulPort = GPIOGetIntNumber(ulPort); |
| |
| // |
| // Disable the GPIO interrupt. |
| // |
| IntDisable(ulPort); |
| |
| // |
| // Unregister the interrupt handler. |
| // |
| IntUnregister(ulPort); |
| } |
| |
| //***************************************************************************** |
| // |
| //! Reads the values present of the specified pin(s). |
| //! |
| //! \param ulPort is the base address of the GPIO port. |
| //! \param ucPins is the bit-packed representation of the pin(s). |
| //! |
| //! The values at the specified pin(s) are read, as specified by \e ucPins. |
| //! Values are returned for both input and output pin(s), and the value |
| //! for pin(s) that are not specified by \e ucPins are set to 0. |
| //! |
| //! The pin(s) are specified using a bit-packed byte, where each bit that is |
| //! set identifies the pin to be accessed, and where bit 0 of the byte |
| //! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. |
| //! |
| //! \return Returns a bit-packed byte providing the state of the specified |
| //! pin, where bit 0 of the byte represents GPIO port pin 0, bit 1 represents |
| //! GPIO port pin 1, and so on. Any bit that is not specified by \e ucPins |
| //! is returned as a 0. Bits 31:8 should be ignored. |
| // |
| //***************************************************************************** |
| long |
| GPIOPinRead(unsigned long ulPort, unsigned char ucPins) |
| { |
| // |
| // Check the arguments. |
| // |
| ASSERT(GPIOBaseValid(ulPort)); |
| |
| // |
| // Return the pin value(s). |
| // |
| return(HWREG(ulPort + (GPIO_O_GPIO_DATA + (ucPins << 2)))); |
| } |
| |
| //***************************************************************************** |
| // |
| //! Writes a value to the specified pin(s). |
| //! |
| //! \param ulPort is the base address of the GPIO port. |
| //! \param ucPins is the bit-packed representation of the pin(s). |
| //! \param ucVal is the value to write to the pin(s). |
| //! |
| //! Writes the corresponding bit values to the output pin(s) specified by |
| //! \e ucPins. Writing to a pin configured as an input pin has no effect. |
| //! |
| //! The pin(s) are specified using a bit-packed byte, where each bit that is |
| //! set identifies the pin to be accessed, and where bit 0 of the byte |
| //! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. |
| //! |
| //! \return None. |
| // |
| //***************************************************************************** |
| void |
| GPIOPinWrite(unsigned long ulPort, unsigned char ucPins, unsigned char ucVal) |
| { |
| // |
| // Check the arguments. |
| // |
| ASSERT(GPIOBaseValid(ulPort)); |
| |
| // |
| // Write the pins. |
| // |
| HWREG(ulPort + (GPIO_O_GPIO_DATA + (ucPins << 2))) = ucVal; |
| } |
| |
| //***************************************************************************** |
| // |
| //! Enables a GPIO port as a trigger to start a DMA transaction. |
| //! |
| //! \param ulPort is the base address of the GPIO port. |
| //! |
| //! This function enables a GPIO port to be used as a trigger to start a uDMA |
| //! transaction. The GPIO pin will still generate interrupts if the interrupt is |
| //! enabled for the selected pin. |
| //! |
| //! \return None. |
| // |
| //***************************************************************************** |
| void |
| GPIODMATriggerEnable(unsigned long ulPort) |
| { |
| // |
| // Check the arguments. |
| // |
| ASSERT(GPIOBaseValid(ulPort)); |
| |
| // |
| // Set the pin as a DMA trigger. |
| // |
| if(ulPort == GPIOA0_BASE) |
| { |
| HWREG(COMMON_REG_BASE + COMMON_REG_O_APPS_GPIO_TRIG_EN) |= 0x1; |
| } |
| else if(ulPort == GPIOA1_BASE) |
| { |
| HWREG(COMMON_REG_BASE + COMMON_REG_O_APPS_GPIO_TRIG_EN) |= 0x2; |
| } |
| else if(ulPort == GPIOA2_BASE) |
| { |
| HWREG(COMMON_REG_BASE + COMMON_REG_O_APPS_GPIO_TRIG_EN) |= 0x4; |
| } |
| else if(ulPort == GPIOA3_BASE) |
| { |
| HWREG(COMMON_REG_BASE + COMMON_REG_O_APPS_GPIO_TRIG_EN) |= 0x8; |
| } |
| } |
| |
| //***************************************************************************** |
| // |
| //! Disables a GPIO port as a trigger to start a DMA transaction. |
| //! |
| //! \param ulPort is the base address of the GPIO port. |
| //! |
| //! This function disables a GPIO port to be used as a trigger to start a uDMA |
| //! transaction. This function can be used to disable this feature if it was |
| //! enabled via a call to GPIODMATriggerEnable(). |
| //! |
| //! \return None. |
| // |
| //***************************************************************************** |
| void |
| GPIODMATriggerDisable(unsigned long ulPort) |
| { |
| // |
| // Check the arguments. |
| // |
| ASSERT(GPIOBaseValid(ulPort)); |
| |
| // |
| // Set the pin as a DMA trigger. |
| // |
| if(ulPort == GPIOA0_BASE) |
| { |
| HWREG(COMMON_REG_BASE + COMMON_REG_O_APPS_GPIO_TRIG_EN) &= ~0x1; |
| } |
| else if(ulPort == GPIOA1_BASE) |
| { |
| HWREG(COMMON_REG_BASE + COMMON_REG_O_APPS_GPIO_TRIG_EN) &= ~0x2; |
| } |
| else if(ulPort == GPIOA2_BASE) |
| { |
| HWREG(COMMON_REG_BASE + COMMON_REG_O_APPS_GPIO_TRIG_EN) &= ~0x4; |
| } |
| else if(ulPort == GPIOA3_BASE) |
| { |
| HWREG(COMMON_REG_BASE + COMMON_REG_O_APPS_GPIO_TRIG_EN) &= ~0x8; |
| } |
| } |
| |
| |
| // |
| // Close the Doxygen group. |
| //! @} |
| // |
| //***************************************************************************** |