include/gpio/portmux_gpio.h

Go to the documentation of this file.

#ifndef GPIO_PORTMUX_GPIO_H_INCLUDED
#define GPIO_PORTMUX_GPIO_H_INCLUDED

#include <gpio/portmux_gpio_regs.h>

typedef uint32_t        pin_mask_t;

typedef unsigned int    gpio_pin_t;

#define PORTMUX_GPIO_VER(major, minor)  (((major) << 8) | (minor))

/*
 * Portmux API starts here. See the Portmux-overview page for more
 * information
 */

enum portmux_function {
        PORTMUX_FUNC_A,
        PORTMUX_FUNC_B,
        PORTMUX_FUNC_C,
        PORTMUX_FUNC_D,
};

#define PORTMUX_DIR_INPUT       (0 << 0)
#define PORTMUX_DIR_OUTPUT      (1 << 0)
#define PORTMUX_INIT_LOW        (0 << 1)
#define PORTMUX_INIT_HIGH       (1 << 1)
#define PORTMUX_PULL_UP         (1 << 2)
#define PORTMUX_PULL_DOWN       (2 << 2)
#define PORTMUX_BUSKEEPER       (3 << 2)
#define PORTMUX_DRIVE_MIN       (0 << 4)
#define PORTMUX_DRIVE_LOW       (1 << 4)
#define PORTMUX_DRIVE_HIGH      (2 << 4)
#define PORTMUX_DRIVE_MAX       (3 << 4)
#define PORTMUX_OPEN_DRAIN      (1 << 6)

extern void portmux_select_peripheral(void *port, pin_mask_t pin_mask,
                enum portmux_function func, unsigned long flags);
extern void portmux_select_gpio(void *port, pin_mask_t pin_mask,
                unsigned long flags);

/* Portmux/GPIO conversion */
static inline void *gpio_pin_to_port(gpio_pin_t pin)
{
        return (void *)(GPIO_BASE + (pin >> 5) * 0x100);
}

static inline pin_mask_t gpio_pin_to_mask(gpio_pin_t pin)
{
        return 1U << (pin & 0x1f);
}

static inline void portmux_select_gpio_pin(gpio_pin_t pin, unsigned long flags)
{
        portmux_select_gpio(gpio_pin_to_port(pin), gpio_pin_to_mask(pin), flags);
}

/* Internal helper functions */

static inline void gpio_set_value_inline(gpio_pin_t pin, bool value)
{
        pin_mask_t pin_mask = gpio_pin_to_mask(pin);
        void *port = gpio_pin_to_port(pin);

        if (value)
                gpio_write_reg(port, OVRS, pin_mask);
        else
                gpio_write_reg(port, OVRC, pin_mask);
}

static inline bool gpio_get_value_inline(gpio_pin_t pin)
{
        return (gpio_read_reg(gpio_pin_to_port(pin), PVR) >> (pin & 0x1f)) & 1;
}

extern void gpio_set_value_noninline(gpio_pin_t pin, bool value);
extern bool gpio_get_value_noninline(gpio_pin_t pin);

/* GPIO API starts here */

__always_inline static void gpio_set_value(gpio_pin_t pin, bool value)
{
        if (is_constant(pin))
                gpio_set_value_inline(pin, value);
        else
                gpio_set_value_noninline(pin, value);
}

__always_inline static bool gpio_get_value(gpio_pin_t pin)
{
        if (is_constant(pin))
                return gpio_get_value_inline(pin);
        else
                return gpio_get_value_noninline(pin);
}

static inline uint32_t gpio_get_int_flag(gpio_pin_t pin)
{
        void *port = gpio_pin_to_port(pin);

        return gpio_read_reg(port, IFR) & gpio_pin_to_mask(pin);
}

static inline uint32_t gpio_int_is_pending(gpio_pin_t pin)
{
        void *port = gpio_pin_to_port(pin);
        pin_mask_t pin_mask = gpio_pin_to_mask(pin);

        return gpio_read_reg(port, IER) & gpio_read_reg(port, IFR) & pin_mask;
}

static inline void gpio_clear_int_flag(gpio_pin_t pin)
{
        gpio_write_reg(gpio_pin_to_port(pin), IFRC, gpio_pin_to_mask(pin));
}

static inline bool gpio_get_int_mask(gpio_pin_t pin)
{
        void *port = gpio_pin_to_port(pin);

        return gpio_read_reg(port, IER) & gpio_pin_to_mask(pin);
}

static inline void gpio_enable_interrupt(gpio_pin_t pin)
{
        gpio_write_reg(gpio_pin_to_port(pin), IERS, gpio_pin_to_mask(pin));
}

static inline void gpio_disable_interrupt(gpio_pin_t pin)
{
        gpio_write_reg(gpio_pin_to_port(pin), IERC, gpio_pin_to_mask(pin));
}

/*
 * Called if one of the portmux functions were called with a
 * non-existent ID. If the ID is always constant, it should get
 * eliminated by link-time gc.
 */
extern void __portmux_error_bad_id(const char *periph_type, unsigned int id);

/*
 * This should be undefined to give a link error when the ID is
 * constant and non-existent.
 */
extern void portmux_error_bad_constant_id(const char *, unsigned int);

static inline void portmux_error_bad_id(const char *periph_type,
                unsigned int id)
{
        if (is_constant(id))
                portmux_error_bad_constant_id(periph_type, id);
        else
                __portmux_error_bad_id(periph_type, id);
}

#endif /* GPIO_PORTMUX_GPIO_H_INCLUDED */

---