TivaGPIO.hxx

Go to the documentation of this file.

 
#ifndef _FREERTOS_DRIVERS_TI_TIVAGPIO_HXX_
#define _FREERTOS_DRIVERS_TI_TIVAGPIO_HXX_
 
#include "os/Gpio.hxx"
#include "driverlib/gpio.h"
#include "driverlib/pin_map.h"
#include "driverlib/sysctl.h"
#include "inc/hw_types.h"
#include "inc/hw_memmap.h"
#include "inc/hw_gpio.h"
#include "driverlib/rom_map.h"
 
#define DECL_PIN(NAME, PORT, NUM)                                              \
    static const auto NAME##_PERIPH = SYSCTL_PERIPH_GPIO##PORT;                \
    static const auto NAME##_BASE = GPIO_PORT##PORT##_BASE;                    \
    static const auto NAME##_PIN = GPIO_PIN_##NUM;                             \
 
#define DECL_HWPIN(NAME, PORT, NUM, CONFIG, Type)                              \
    DECL_PIN(NAME, PORT, NUM);                                                 \
    static void NAME##_SetPinType()                                            \
    {                                                                          \
        MAP_GPIOPinType##Type(NAME##_BASE, NAME##_PIN);                        \
    }                                                                          \
    static const auto NAME##_CONFIG = GPIO_P##PORT##NUM##_##CONFIG
 
template <class Defs, bool SAFE_VALUE> struct GpioOutputPin;
template <class Defs, uint32_t GPIO_PULL> struct GpioInputPin;
 
template <unsigned GPIO_BASE, unsigned GPIO_PIN> class TivaGpio : public Gpio
{
public:
    constexpr TivaGpio()
    {
    }
 
    void write(Value new_state) const OVERRIDE
    {
        *pin_address() = (new_state ? 0xff : 0);
    }
 
    void set() const OVERRIDE
    {
        *pin_address() = 0xff;
    }
 
    void clr() const OVERRIDE
    {
        *pin_address() = 0;
    }
 
    Value read() const OVERRIDE
    {
        return *pin_address() ? VHIGH : VLOW;
    }
 
    void set_direction(Direction dir) const OVERRIDE
    {
        if (dir == Direction::DOUTPUT)
        {
            GPIOPinTypeGPIOOutput(GPIO_BASE, GPIO_PIN);
        }
        else
        {
            GPIOPinTypeGPIOInput(GPIO_BASE, GPIO_PIN);
        }
    }
 
    Direction direction() const OVERRIDE
    {
        uint32_t mode = GPIODirModeGet(GPIO_BASE, GPIO_PIN);
        switch (mode)
        {
            default:
                HASSERT(0);
            case GPIO_DIR_MODE_IN:
                return Direction::DINPUT;
            case GPIO_DIR_MODE_OUT:
                return Direction::DOUTPUT;
        }
    }
 
private:
    template <class Defs> friend struct GpioShared;
    static const TivaGpio instance_;
 
    constexpr volatile uint8_t *pin_address() const
    {
        return reinterpret_cast<volatile uint8_t *>(
            GPIO_BASE + (((unsigned)GPIO_PIN) << 2));
    }
};
 
template <unsigned GPIO_BASE, unsigned GPIO_PIN>
const TivaGpio<GPIO_BASE, GPIO_PIN> TivaGpio<GPIO_BASE, GPIO_PIN>::instance_;
 
template<class Defs> struct GpioShared : public Defs {
public:
    using Defs::GPIO_PERIPH;
    using Defs::GPIO_BASE;
    using Defs::GPIO_PIN;
 
    static void unlock()
    {
        MAP_SysCtlPeripheralEnable(GPIO_PERIPH);
        MAP_SysCtlDelay(26);
        HWREG(GPIO_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY;
        HWREG(GPIO_BASE + GPIO_O_CR) |= GPIO_PIN;
        HWREG(GPIO_BASE + GPIO_O_LOCK) = 0;
    }
    static void lock()
    {
        MAP_SysCtlPeripheralEnable(GPIO_PERIPH);
        HWREG(GPIO_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY;
        HWREG(GPIO_BASE + GPIO_O_CR) &= ~GPIO_PIN;
        HWREG(GPIO_BASE + GPIO_O_LOCK) = 0;
    }  
 
    static void set(bool value)
    {
        HWREGB(ptr_address()) = value ? 0xff : 0;
    }
    static bool get()
    {
        return HWREGB(ptr_address()) != 0;
    }
    static void toggle()
    {
        set(!get());
    }
 
    static constexpr uint32_t ptr_address()
    {
        return GPIO_BASE + (((unsigned)GPIO_PIN) << 2);
    }
 
    static constexpr const Gpio *instance()
    {
        return &TivaGpio<GPIO_BASE, GPIO_PIN>::instance_;
    }
};
 
template <class Defs, bool SAFE_VALUE>
struct GpioOutputPin : public GpioShared<Defs>
{
public:
    using Defs::GPIO_PERIPH;
    using Defs::GPIO_BASE;
    using Defs::GPIO_PIN;
    using GpioShared<Defs>::set;
    static void hw_init()
    {
        MAP_SysCtlPeripheralEnable(GPIO_PERIPH);
        MAP_GPIOPinTypeGPIOOutput(GPIO_BASE, GPIO_PIN);
        set(SAFE_VALUE);
    }
    static void hw_set_to_safe()
    {
        hw_init();
    }
 
    static bool is_output()
    {
        return true;
    }
};
 
template <class Defs>
struct GpioOutputSafeLow : public GpioOutputPin<Defs, false>
{
};
 
template <class Defs>
struct GpioOutputSafeHigh : public GpioOutputPin<Defs, true>
{
};
 
template <class Defs, bool SAFE_VALUE> struct GpioOutputOD : public GpioOutputPin<Defs, SAFE_VALUE>
{
public:
    using Defs::GPIO_PERIPH;
    using Defs::GPIO_BASE;
    using Defs::GPIO_PIN;
    static void hw_init()
    {
        GpioOutputPin<Defs, SAFE_VALUE>::hw_init();
        MAP_GPIOPadConfigSet(
            GPIO_BASE, GPIO_PIN, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_OD);
    }
};
 
template <class Defs>
using GpioOutputODSafeLow = GpioOutputOD<Defs, false>;
 
template <class Defs>
using GpioOutputODSafeHigh = GpioOutputOD<Defs, true>;
 
 
template <class Defs> struct LedPin : public GpioOutputPin<Defs, false>
{
public:
    using Defs::GPIO_PERIPH;
    using Defs::GPIO_BASE;
    using Defs::GPIO_PIN;
    static void hw_init()
    {
        GpioOutputPin<Defs, false>::hw_init();
        MAP_GPIOPadConfigSet(
            GPIO_BASE, GPIO_PIN, GPIO_STRENGTH_8MA_SC, GPIO_PIN_TYPE_STD);
    }
};
 
#define GPIO_PIN(NAME, BaseClass, PORT, NUM)                                   \
    struct NAME##Defs                                                          \
    {                                                                          \
        DECL_PIN(GPIO, PORT, NUM);                                             \
    };                                                                         \
    typedef BaseClass<NAME##Defs> NAME##_Pin
 
template <class Defs, uint32_t GPIO_PULL>
struct GpioInputPin : public GpioShared<Defs>
{
public:
    using Defs::GPIO_PERIPH;
    using Defs::GPIO_BASE;
    using Defs::GPIO_PIN;
    static void hw_init()
    {
        MAP_SysCtlPeripheralEnable(GPIO_PERIPH);
        MAP_GPIOPinTypeGPIOInput(GPIO_BASE, GPIO_PIN);
        MAP_GPIOPadConfigSet(GPIO_BASE, GPIO_PIN, GPIO_STRENGTH_2MA, GPIO_PULL);
    }
    static void hw_set_to_safe()
    {
        hw_init();
    }
    static bool is_output()
    {
        return false;
    }
};
 
template <class Defs>
struct GpioInputPU : public GpioInputPin<Defs, GPIO_PIN_TYPE_STD_WPU>
{
};
 
template <class Defs>
struct GpioInputPD : public GpioInputPin<Defs, GPIO_PIN_TYPE_STD_WPD>
{
};
 
template <class Defs>
struct GpioInputNP : public GpioInputPin<Defs, GPIO_PIN_TYPE_STD>
{
};
 
template <class Defs> struct GpioInputOutputPin : public GpioShared<Defs>
{
public:
    using Defs::GPIO_PERIPH;
    using Defs::GPIO_BASE;
    using Defs::GPIO_PIN;
    static void hw_init()
    {
        MAP_SysCtlPeripheralEnable(GPIO_PERIPH);
        MAP_GPIOPinTypeGPIOInput(GPIO_BASE, GPIO_PIN);
        MAP_GPIOPadConfigSet(GPIO_BASE, GPIO_PIN, GPIO_STRENGTH_2MA,
             GPIO_PIN_TYPE_STD);
    }
    static void hw_set_to_safe()
    {
        hw_init();
    }
    static void set_direction(Gpio::Direction direction)
    {
        MAP_GPIODirModeSet(GPIO_BASE, GPIO_PIN,
            direction == Gpio::Direction::DINPUT ?
            GPIO_DIR_MODE_IN : GPIO_DIR_MODE_OUT);
    }
    static bool is_output()
    {
        return (MAP_GPIODirModeGet(GPIO_BASE, GPIO_PIN) == GPIO_DIR_MODE_OUT);
    }
};
 
template <class Defs> struct GpioADCPin : public Defs
{
    using Defs::GPIO_PERIPH;
    using Defs::GPIO_BASE;
    using Defs::GPIO_PIN;
    static void hw_init()
    {
        MAP_SysCtlPeripheralEnable(GPIO_PERIPH);
        MAP_GPIODirModeSet(GPIO_BASE, GPIO_PIN, GPIO_DIR_MODE_HW);
        MAP_GPIOPadConfigSet(
            GPIO_BASE, GPIO_PIN, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_ANALOG);
    }
    static void hw_set_to_safe()
    {
        hw_init();
    }
};
 
template <class Defs> struct GpioUSBAPin : public Defs
{
    using Defs::GPIO_PERIPH;
    using Defs::GPIO_BASE;
    using Defs::GPIO_PIN;
    static void hw_init()
    {
        MAP_SysCtlPeripheralEnable(GPIO_PERIPH);
        MAP_GPIOPinTypeUSBAnalog(GPIO_BASE, GPIO_PIN);
    }
    static void hw_set_to_safe()
    {
        hw_init();
    }
};
 
template <class Defs> struct GpioHwPin : public GpioShared<Defs>
{
    using Defs::GPIO_PERIPH;
    using Defs::GPIO_BASE;
    using Defs::GPIO_PIN;
    using Defs::GPIO_CONFIG;
    using Defs::GPIO_SetPinType;
 
    static void hw_init()
    {
        MAP_SysCtlPeripheralEnable(GPIO_PERIPH);
        MAP_GPIOPinConfigure(GPIO_CONFIG);
        set_hw();
    }
 
    static void hw_set_to_safe()
    {
        hw_init();
    }
 
    static void set_hw()
    {
        Defs::GPIO_SetPinType();
    }
 
    static void set_output()
    {
        MAP_GPIOPinTypeGPIOOutput(GPIO_BASE, GPIO_PIN);
        MAP_GPIOPadConfigSet(
            GPIO_BASE, GPIO_PIN, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD);
    }
 
    static void set_input(uint32_t drive_type = GPIO_PIN_TYPE_STD)
    {
        MAP_GPIOPinTypeGPIOInput(GPIO_BASE, GPIO_PIN);
        MAP_GPIOPadConfigSet(
            GPIO_BASE, GPIO_PIN, GPIO_STRENGTH_2MA, drive_type);
    }
};
 
#define GPIO_HWPIN(NAME, BaseClass, PORT, NUM, CONFIG, TYPE)                   \
    struct NAME##Defs                                                          \
    {                                                                          \
        DECL_HWPIN(GPIO, PORT, NUM, CONFIG, TYPE);                             \
    };                                                                         \
    typedef BaseClass<NAME##Defs> NAME##_Pin
 
#endif //_FREERTOS_DRIVERS_TI_TIVAGPIO_HXX_