CC3200GPIO.hxx

Go to the documentation of this file.

 
#ifndef _FREERTOS_DRIVERS_TI_CC3200GPIO_HXX_
#define _FREERTOS_DRIVERS_TI_CC3200GPIO_HXX_
 
#include "os/Gpio.hxx"
#include "inc/hw_types.h"
#include "inc/hw_ints.h"
#include "driverlib/gpio.h"
#include "driverlib/prcm.h"
#include "inc/hw_memmap.h"
#include "driverlib/rom_map.h"
 
 
#define DECL_PIN(NAME, PORT, NUM)                           \
    static const auto NAME##_PERIPH = PRCM_GPIO##PORT;      \
    static const auto NAME##_BASE = GPIO##PORT##_BASE; \
    static const auto NAME##_PIN = GPIO_PIN_##NUM; \
    static const auto NAME##_INT = INT_GPIO##PORT
    
 
template <class Defs, bool SAFE_VALUE> struct GpioOutputPin;
template <class Defs> struct GpioInputPin;
 
template <unsigned GPIO_BASE, unsigned GPIO_PIN> class CC3200Gpio : public Gpio
{
public:
    constexpr CC3200Gpio()
    {
    }
 
    void write(Value new_state) const OVERRIDE
    {
        *pin_address() = (new_state ? 0xff : 0);
        __asm__ volatile("dsb" : : : "memory");
    }
 
    void set() const OVERRIDE
    {
        *pin_address() = 0xff;
        __asm__ volatile("dsb" : : : "memory");
    }
 
    void clr() const OVERRIDE
    {
        *pin_address() = 0;
        __asm__ volatile("dsb" : : : "memory");
    }
 
    Value read() const OVERRIDE
    {
        return *pin_address() ? VHIGH : VLOW;
    }
 
    void set_direction(Direction dir) const OVERRIDE
    {
        if (dir == Direction::DOUTPUT)
        {
            MAP_GPIODirModeSet(GPIO_BASE, GPIO_PIN, GPIO_DIR_MODE_OUT);
        }
        else
        {
            MAP_GPIODirModeSet(GPIO_BASE, GPIO_PIN, GPIO_DIR_MODE_IN);
        }
    }
 
    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, bool SAFE_VALUE> friend struct GpioOutputPin;
    template <class Defs> friend struct GpioInputPin;
    static const CC3200Gpio 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 CC3200Gpio<GPIO_BASE, GPIO_PIN> CC3200Gpio<GPIO_BASE, GPIO_PIN>::instance_;
 
template <class Defs, bool SAFE_VALUE> struct GpioOutputPin : public Defs
{
public:
    using Defs::GPIO_PERIPH;
    using Defs::GPIO_BASE;
    using Defs::GPIO_PIN;
    static void hw_init()
    {
        MAP_PRCMPeripheralClkEnable(GPIO_PERIPH, PRCM_RUN_MODE_CLK);
        MAP_GPIODirModeSet(GPIO_BASE, GPIO_PIN, GPIO_DIR_MODE_OUT);
        set(SAFE_VALUE);
    }
    static void hw_set_to_safe()
    {
        hw_init();
    }
    static void __attribute__((always_inline)) set(bool value)
    {
        volatile uint8_t *ptr = reinterpret_cast<uint8_t *>(
            GPIO_BASE + (((unsigned)GPIO_PIN) << 2));
        *ptr = value ? 0xff : 0;
        __asm__ volatile("dsb" : : : "memory");
    }
    static bool __attribute__((always_inline)) get()
    {
        const volatile uint8_t *ptr = reinterpret_cast<const uint8_t *>(
            GPIO_BASE + (((unsigned)GPIO_PIN) << 2));
        return *ptr;
    }
    static void __attribute__((always_inline)) toggle()
    {
        set(!get());
    }
 
    static constexpr const Gpio *instance()
    {
        return &CC3200Gpio<GPIO_BASE, GPIO_PIN>::instance_;
    }
 
    static bool is_output()
    {
        return true;
    }
};
 
template <class Defs>
struct GpioOutputSafeLow : public GpioOutputPin<Defs, false>
{
};
 
template <class Defs>
struct GpioOutputSafeHigh : public GpioOutputPin<Defs, true>
{
};
 
#define GPIO_PIN(NAME, BaseClass, PORT, NUM)                                   \
    struct NAME##Defs                                                          \
    {                                                                          \
        DECL_PIN(GPIO, PORT, NUM);                                             \
    };                                                                         \
    typedef BaseClass<NAME##Defs> NAME##_Pin
 
template <class Defs> struct GpioInputPin : public Defs
{
public:
    using Defs::GPIO_PERIPH;
    using Defs::GPIO_BASE;
    using Defs::GPIO_PIN;
    static void hw_init()
    {
        MAP_PRCMPeripheralClkEnable(GPIO_PERIPH, PRCM_RUN_MODE_CLK);
        MAP_GPIODirModeSet(GPIO_BASE, GPIO_PIN, GPIO_DIR_MODE_IN);
    }
    static void hw_set_to_safe()
    {
        hw_init();
    }
    static bool get()
    {
        const volatile uint8_t *ptr = reinterpret_cast<const uint8_t *>(
            GPIO_BASE + (((unsigned)GPIO_PIN) << 2));
        return *ptr;
    }
    static bool is_output()
    {
        return false;
    }
    static constexpr const Gpio *instance()
    {
        return &CC3200Gpio<GPIO_BASE, GPIO_PIN>::instance_;
    }
};
 
template <class Defs> struct GpioInputOutputPin : public Defs
{
public:
    using Defs::GPIO_PERIPH;
    using Defs::GPIO_BASE;
    using Defs::GPIO_PIN;
    static void hw_init()
    {
        MAP_PRCMPeripheralClkEnable(GPIO_PERIPH, PRCM_RUN_MODE_CLK);
        MAP_GPIODirModeSet(GPIO_BASE, GPIO_PIN, GPIO_DIR_MODE_IN);
    }
    static void hw_set_to_safe()
    {
        hw_init();
    }
    static void __attribute__((always_inline)) set(bool value)
    {
        volatile uint8_t *ptr = reinterpret_cast<uint8_t *>(
            GPIO_BASE + (((unsigned)GPIO_PIN) << 2));
        *ptr = value ? 0xff : 0;
        __asm__ volatile("dsb" : : : "memory");
    }
    static bool __attribute__((always_inline)) get()
    {
        const volatile uint8_t *ptr = reinterpret_cast<const uint8_t *>(
            GPIO_BASE + (((unsigned)GPIO_PIN) << 2));
        return *ptr;
    }
    static void __attribute__((always_inline)) toggle()
    {
        set(!get());
    }
 
    static constexpr const Gpio *instance()
    {
        return &CC3200Gpio<GPIO_BASE, GPIO_PIN>::instance_;
    }
 
    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);
    }
};
 
#endif //_FREERTOS_DRIVERS_TI_CC3200GPIO_HXX_