gpio.h

Go to the documentation of this file.

//###########################################################################
//
// FILE:   gpio.h
//
// TITLE:  C29x GPIO driver.
//
//###########################################################################
// //
//  Copyright: Copyright (C) Texas Instruments Incorporated
//  All rights reserved not granted herein.
//
//  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.
//
 
//###########################################################################
 
#ifndef GPIO_H
#define GPIO_H
 
//*****************************************************************************
//
// If building with a C++ compiler, make all of the definitions in this header
// have a C binding.
//
//*****************************************************************************
#ifdef __cplusplus
extern "C"
{
#endif
 
//*****************************************************************************
//
//
//*****************************************************************************
 
#include <stdbool.h>
#include <stdint.h>
#include "inc/hw_gpio.h"
#include "inc/hw_memmap.h"
#include "inc/hw_types.h"
#include "inc/hw_xint.h"
#include "inc/hw_asysctl.h"
#include "cpu.h"
#include "xbar.h"
#include "debug.h"
 
//*****************************************************************************
//
// Useful defines used within the driver functions to access gpio registers.
// Not intended for use by application code.
//
//*****************************************************************************
#define GPIO_CTRL_REGS_STEP      ((GPIO_O_GPBCTRL - GPIO_O_GPACTRL) / 4U)
#define GPIO_DATA_REGS_STEP      ((GPIO_O_GPBDAT - GPIO_O_GPADAT) / 4U)
#define GPIO_DATA_READ_REGS_STEP ((GPIO_O_GPBDAT_R - GPIO_O_GPADAT_R) / 4U)
 
#define GPIO_GPxCTRL_INDEX      (0U)
#define GPIO_GPxQSEL_INDEX      (1U)
#define GPIO_GPxMUX_INDEX       (3U)
#define GPIO_GPxPUD_INDEX       (6U)
#define GPIO_GPxINV_INDEX       (8U)
#define GPIO_GPxODR_INDEX       (9U)
#define GPIO_GPxAMSEL_INDEX     (10U)
#define GPIO_GPxGMUX_INDEX      (16U)
#define GPIO_GPxCSEL_INDEX      (20U)
#define GPIO_GPxLOCK_INDEX      (30U)
#define GPIO_GPxCR_INDEX        (31U)
 
#define GPIO_GPxDAT_INDEX       (0U)
#define GPIO_GPxSET_INDEX       (1U)
#define GPIO_GPxCLEAR_INDEX     (2U)
#define GPIO_GPxTOGGLE_INDEX    (3U)
#define GPIO_GPxDIR_INDEX       (4U)
 
#define GPIO_GPxDAT_R_INDEX     (0U)
 
#define GPIO_MUX_TO_GMUX        (GPIO_O_GPAGMUX1 - GPIO_O_GPAMUX1)
 
 
//*****************************************************************************
//
// Values that can be passed to GPIO_setPadConfig() as the pinType parameter
// and returned by GPIO_getPadConfig().
//
//*****************************************************************************
#define GPIO_PIN_TYPE_STD       0x0000U 
#define GPIO_PIN_TYPE_PULLUP    0x0001U 
#define GPIO_PIN_TYPE_INVERT    0x0002U 
#define GPIO_PIN_TYPE_OD        0x0004U 
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    GPIO_DIR_MODE_IN,                   
    GPIO_DIR_MODE_OUT                   
} GPIO_Direction;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    GPIO_INT_TYPE_FALLING_EDGE = 0x00,   
    GPIO_INT_TYPE_RISING_EDGE  = 0x04,   
    GPIO_INT_TYPE_BOTH_EDGES   = 0x0C    
} GPIO_IntType;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    GPIO_QUAL_SYNC,                     
    GPIO_QUAL_3SAMPLE,                  
    GPIO_QUAL_6SAMPLE,                  
    GPIO_QUAL_ASYNC                     
} GPIO_QualificationMode;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    GPIO_ANALOG_DISABLED,       
    GPIO_ANALOG_ENABLED         
} GPIO_AnalogMode;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    GPIO_CORE_CPU1,             
    GPIO_CORE_CPU2,             
    GPIO_CORE_CPU3,             
} GPIO_CoreSelect;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    GPIO_PORT_A = 0,                    
    GPIO_PORT_B = 1,                    
    GPIO_PORT_C = 2,                    
    GPIO_PORT_D = 3,                    
    GPIO_PORT_E = 4,                    
    GPIO_PORT_F = 5,                    
    GPIO_PORT_G = 6,                    
    GPIO_PORT_H = 7,                    
} GPIO_Port;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    GPIO_INT_XINT1 = 0,                     
    GPIO_INT_XINT2 = 2,                     
    GPIO_INT_XINT3 = 4,                     
    GPIO_INT_XINT4 = 6,                     
    GPIO_INT_XINT5 = 8                      
} GPIO_ExternalIntNum;
 
//*****************************************************************************
//
// Prototypes for the APIs.
//
//*****************************************************************************
//*****************************************************************************
//
//
//*****************************************************************************
#ifdef DEBUG
static inline bool
GPIO_isPinValid(uint32_t pin)
{
    return(
           (pin <= 105U) || (pin == 127U)       || // GPIO
           ((pin >= 219U) && (pin <= 223U))     || // GPIO
           ((pin >= 160U) && (pin <= 213U))     || // AIO
           ((pin >= 224U) && (pin <= 249U))        // AGPIO
           );
}
#endif
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
GPIO_setInterruptType(GPIO_ExternalIntNum extIntNum, GPIO_IntType intType)
{
    //
    // Write the selected polarity to the appropriate register.
    //
    HWREGH(XINT_BASE + (uint16_t)extIntNum) =
        (uint16_t)((HWREGH(XINT_BASE + (uint16_t)extIntNum) & ~XINT_1CR_POLARITY_M) |
        (uint16_t)intType);
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline GPIO_IntType
GPIO_getInterruptType(GPIO_ExternalIntNum extIntNum)
{
    //
    // Read the selected polarity from the appropriate register.
    //
    return((GPIO_IntType)(HWREGH(XINT_BASE + (uint16_t)extIntNum) &
                          XINT_1CR_POLARITY_M));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
GPIO_enableInterrupt(GPIO_ExternalIntNum extIntNum)
{
    //
    // Set the enable bit for the specified interrupt.
    //
    HWREGH(XINT_BASE + (uint16_t)extIntNum) |= XINT_1CR_ENABLE;
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
GPIO_disableInterrupt(GPIO_ExternalIntNum extIntNum)
{
    //
    // Clear the enable bit for the specified interrupt
    //
    HWREGH(XINT_BASE + (uint16_t)extIntNum) &= (uint16_t)~XINT_1CR_ENABLE;
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline uint16_t
GPIO_getInterruptCounter(GPIO_ExternalIntNum extIntNum)
{
    ASSERT(extIntNum <= GPIO_INT_XINT3);
 
    //
    // Read the counter value from the appropriate register.
    //
    return((HWREGH(XINT_BASE + XINT_O_1CTR + (uint16_t)extIntNum)));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline uint32_t
GPIO_readPin(uint32_t pin)
{
    volatile uint32_t *gpioDataReg;
 
    //
    // Check the arguments.
    //
    ASSERT(GPIO_isPinValid(pin));
 
    gpioDataReg = (uint32_t *)((uintptr_t)GPIODATA_BASE) +
                  ((pin / 32U) * GPIO_DATA_REGS_STEP);
 
    return((gpioDataReg[GPIO_GPxDAT_INDEX] >> (pin % 32U)) & (uint32_t)0x1U);
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline uint32_t
GPIO_readPinDataRegister(uint32_t pin)
{
    volatile uint32_t *gpioDataReg;
 
    //
    // Check the arguments.
    //
    ASSERT(GPIO_isPinValid(pin));
 
    gpioDataReg = (uint32_t *)((uintptr_t)GPIODATAREAD_BASE) +
                  ((pin / 32U) * GPIO_DATA_READ_REGS_STEP);
 
    return((gpioDataReg[GPIO_GPxDAT_R_INDEX] >> (pin % 32U)) & (uint32_t)0x1U);
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
GPIO_writePin(uint32_t pin, uint32_t outVal)
{
    volatile uint32_t *gpioDataReg;
    uint32_t pinMask;
 
    //
    // Check the arguments.
    //
    ASSERT(GPIO_isPinValid(pin));
 
    gpioDataReg = (uint32_t *)((uintptr_t)GPIODATA_BASE) +
                  ((pin / 32U) * GPIO_DATA_REGS_STEP);
 
    pinMask = (uint32_t)1U << (pin % 32U);
 
    if(outVal == 0U)
    {
        gpioDataReg[GPIO_GPxCLEAR_INDEX] = pinMask;
    }
    else
    {
        gpioDataReg[GPIO_GPxSET_INDEX] = pinMask;
    }
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
GPIO_togglePin(uint32_t pin)
{
    volatile uint32_t *gpioDataReg;
 
    //
    // Check the arguments.
    //
    ASSERT(GPIO_isPinValid(pin));
 
    gpioDataReg = (uint32_t *)((uintptr_t)GPIODATA_BASE) +
                  ((pin / 32U) * GPIO_DATA_REGS_STEP);
 
    gpioDataReg[GPIO_GPxTOGGLE_INDEX] = (uint32_t)1U << (pin % 32U);
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline uint32_t
GPIO_readPortData(GPIO_Port port)
{
    volatile uint32_t *gpioDataReg;
 
    //
    // Get the starting address of the port's registers and return DATA.
    //
    gpioDataReg = (uint32_t *)((uintptr_t)GPIODATA_BASE) +
                  ((uint32_t)port * GPIO_DATA_REGS_STEP);
 
    return(gpioDataReg[GPIO_GPxDAT_INDEX]);
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline uint32_t
GPIO_readPortDataRegister(GPIO_Port port)
{
    volatile uint32_t *gpioDataReg;
 
    //
    // Get the starting address of the port's registers and return DATA.
    //
    gpioDataReg = (uint32_t *)((uintptr_t)GPIODATAREAD_BASE) +
                  ((uint32_t)port * GPIO_DATA_READ_REGS_STEP);
 
    return(gpioDataReg[GPIO_GPxDAT_R_INDEX]);
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
GPIO_writePortData(GPIO_Port port, uint32_t outVal)
{
    volatile uint32_t *gpioDataReg;
 
    //
    // Get the starting address of the port's registers and write to DATA.
    //
    gpioDataReg = (uint32_t *)((uintptr_t)GPIODATA_BASE) +
                  ((uint32_t)port * GPIO_DATA_REGS_STEP);
 
    gpioDataReg[GPIO_GPxDAT_INDEX] = outVal;
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
GPIO_setPortPins(GPIO_Port port, uint32_t pinMask)
{
    volatile uint32_t *gpioDataReg;
 
    //
    // Get the starting address of the port's registers and write to SET.
    //
    gpioDataReg = (uint32_t *)((uintptr_t)GPIODATA_BASE) +
                  ((uint32_t)port * GPIO_DATA_REGS_STEP);
 
    gpioDataReg[GPIO_GPxSET_INDEX] = pinMask;
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
GPIO_clearPortPins(GPIO_Port port, uint32_t pinMask)
{
    volatile uint32_t *gpioDataReg;
 
    //
    // Get the starting address of the port's registers and write to CLEAR.
    //
    gpioDataReg = (uint32_t *)((uintptr_t)GPIODATA_BASE) +
                  ((uint32_t)port * GPIO_DATA_REGS_STEP);
 
    gpioDataReg[GPIO_GPxCLEAR_INDEX] = pinMask;
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
GPIO_togglePortPins(GPIO_Port port, uint32_t pinMask)
{
    volatile uint32_t *gpioDataReg;
 
    //
    // Get the starting address of the port's registers and write to TOGGLE.
    //
    gpioDataReg = (uint32_t *)((uintptr_t)GPIODATA_BASE) +
                  ((uint32_t)port * GPIO_DATA_REGS_STEP);
 
    gpioDataReg[GPIO_GPxTOGGLE_INDEX] = pinMask;
}
 
//*****************************************************************************
//
//
//*****************************************************************************
__attribute__((section(".text.link2.GPIO_lockPortConfig")))
static inline void
GPIO_lockPortConfig(GPIO_Port port, uint32_t pinMask)
{
    volatile uint32_t *gpioDataReg;
 
    //
    // Get the starting address of the port's registers and write to the lock.
    //
    gpioDataReg = (uint32_t *)((uintptr_t)GPIOCTRL_BASE) +
                  ((uint32_t)port * GPIO_CTRL_REGS_STEP);
 
    gpioDataReg[GPIO_GPxLOCK_INDEX] |= pinMask;
}
 
//*****************************************************************************
//
//
//*****************************************************************************
__attribute__((section(".text.link2.GPIO_unlockPortConfig")))
static inline void
GPIO_unlockPortConfig(GPIO_Port port, uint32_t pinMask)
{
    volatile uint32_t *gpioDataReg;
 
    //
    // Get the starting address of the port's registers and write to the lock.
    //
    gpioDataReg = (uint32_t *)((uintptr_t)GPIOCTRL_BASE) +
                  ((uint32_t)port * GPIO_CTRL_REGS_STEP);
 
    gpioDataReg[GPIO_GPxLOCK_INDEX] &= ~pinMask;
}
 
//*****************************************************************************
//
//
//*****************************************************************************
__attribute__((section(".text.link2.GPIO_commitPortConfig")))
static inline void
GPIO_commitPortConfig(GPIO_Port port, uint32_t pinMask)
{
    volatile uint32_t *gpioDataReg;
 
    //
    // Get the starting address of the port's registers and write to the lock.
    //
    gpioDataReg = (uint32_t *)((uintptr_t)GPIOCTRL_BASE) +
                  ((uint32_t)port * GPIO_CTRL_REGS_STEP);
 
    gpioDataReg[GPIO_GPxCR_INDEX] |= pinMask;
}
 
//*****************************************************************************
//
//
//*****************************************************************************
extern void
GPIO_setDirectionMode(uint32_t pin, GPIO_Direction pinIO);
 
//*****************************************************************************
//
//
//*****************************************************************************
extern GPIO_Direction
GPIO_getDirectionMode(uint32_t pin);
 
//*****************************************************************************
//
//
//*****************************************************************************
__attribute__((section(".text.link2.GPIO_setInterruptPin")))
extern void
GPIO_setInterruptPin(uint32_t pin, GPIO_ExternalIntNum extIntNum);
 
//*****************************************************************************
//
//
//*****************************************************************************
__attribute__((section(".text.link2.GPIO_setPadConfig")))
extern void
GPIO_setPadConfig(uint32_t pin, uint32_t pinType);
 
//*****************************************************************************
//
//
//*****************************************************************************
extern uint32_t
GPIO_getPadConfig(uint32_t pin);
 
//*****************************************************************************
//
//
//*****************************************************************************
__attribute__((section(".text.link2.GPIO_setQualificationMode")))
extern void
GPIO_setQualificationMode(uint32_t pin, GPIO_QualificationMode qualification);
 
//*****************************************************************************
//
//
//*****************************************************************************
extern GPIO_QualificationMode
GPIO_getQualificationMode(uint32_t pin);
 
//*****************************************************************************
//
//
//*****************************************************************************
__attribute__((section(".text.link2.GPIO_setQualificationPeriod")))
extern void
GPIO_setQualificationPeriod(uint32_t pin, uint32_t divider);
 
//*****************************************************************************
//
//
//*****************************************************************************
__attribute__((section(".text.link2.GPIO_setControllerCore")))
extern void
GPIO_setControllerCore(uint32_t pin, GPIO_CoreSelect core);
 
//*****************************************************************************
//
//
//*****************************************************************************
__attribute__((section(".text.link2.GPIO_setAnalogMode")))
extern void
GPIO_setAnalogMode(uint32_t pin, GPIO_AnalogMode mode);
 
//*****************************************************************************
//
//
//*****************************************************************************
__attribute__((section(".text.link2.GPIO_setPinConfig")))
extern void
GPIO_setPinConfig(uint32_t pinConfig);
 
//*****************************************************************************
//
// Close the Doxygen group.
//
//*****************************************************************************
 
//*****************************************************************************
//
// Mark the end of the C bindings section for C++ compilers.
//
//*****************************************************************************
#ifdef __cplusplus
}
#endif
 
#endif //  GPIO_H