gpio_common.h

Go to the documentation of this file.

/** @addtogroup gpio_defines
 */
/*
 * This file is part of the libopencm3 project.
 *
 * Copyright (C) 2015 Kuldeep Singh Dhaka <kuldeepdhaka9@gmail.com>
 *
 * This library is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include <libopencm3/efm32/memorymap.h>
#include <libopencm3/cm3/common.h>
 
/**@{*/
 
#define GPIO_P(i)               (GPIO_BASE + (0x24 * (i)))
#define GPIO_PA                 GPIO_P(0)
#define GPIO_PB                 GPIO_P(1)
#define GPIO_PC                 GPIO_P(2)
#define GPIO_PD                 GPIO_P(3)
#define GPIO_PE                 GPIO_P(4)
#define GPIO_PF                 GPIO_P(5)
 
#define GPIO_P_CTRL(port)       MMIO32((port) + 0x00)
#define GPIO_PA_CTRL            GPIO_P_CTRL(GPIO_PA)
#define GPIO_PB_CTRL            GPIO_P_CTRL(GPIO_PB)
#define GPIO_PC_CTRL            GPIO_P_CTRL(GPIO_PC)
#define GPIO_PD_CTRL            GPIO_P_CTRL(GPIO_PD)
#define GPIO_PE_CTRL            GPIO_P_CTRL(GPIO_PE)
#define GPIO_PF_CTRL            GPIO_P_CTRL(GPIO_PF)
 
#define GPIO_P_CTRL_DRIVEMODE_SHIFT     (0)
#define GPIO_P_CTRL_DRIVEMODE_MASK      (0x03 << GPIO_P_CTRL_DRIVEMODE_SHIFT)
#define GPIO_P_CTRL_DRIVEMODE(v)        \
        (((v) << GPIO_P_CTRL_DRIVEMODE_SHIFT) & GPIO_P_CTRL_DRIVEMODE_MASK)
#define GPIO_P_CTRL_DRIVEMODE_STANDARD  0
#define GPIO_P_CTRL_DRIVEMODE_LOWEST    1
#define GPIO_P_CTRL_DRIVEMODE_HIGH      2
#define GPIO_P_CTRL_DRIVEMODE_LOW       3
 
/* NOTE: GPIO_MODE and GPIO_MODE_MASK is generic.
 * it is used with both GPIO_Px_MODEL and GPIO_Px_MODEH */
#define GPIO_P_MODE_MODEx_MASK(x)       (0x0F << (((x) & 0x7) * 4))
/* for mode: use GPIO_MODE_* */
#define GPIO_P_MODE_MODEx(x, mode)      \
        (((mode) << (((x) & 0x7) * 4)) & GPIO_P_MODE_MODEx_MASK(x))
 
#define GPIO_P_MODEL(port)      MMIO32((port) + 0x04)
#define GPIO_PA_MODEL           GPIO_P_MODEL(GPIO_PA)
#define GPIO_PB_MODEL           GPIO_P_MODEL(GPIO_PB)
#define GPIO_PC_MODEL           GPIO_P_MODEL(GPIO_PC)
#define GPIO_PD_MODEL           GPIO_P_MODEL(GPIO_PD)
#define GPIO_PE_MODEL           GPIO_P_MODEL(GPIO_PE)
 
#define GPIO_P_MODEL_MODEx_MASK(x)      GPIO_P_MODE_MODEx_MASK(x)
#define GPIO_P_MODEL_MODEx(x, mode)     GPIO_P_MODE_MODEx(x, mode)
 
#define GPIO_P_MODEL_MODE0_MASK         GPIO_P_MODEL_MODEx_MASK(0)
#define GPIO_P_MODEL_MODE0(mode)        GPIO_P_MODEL_MODEx(0, mode)
 
#define GPIO_P_MODEL_MODE1_MASK         GPIO_P_MODEL_MODEx_MASK(1)
#define GPIO_P_MODEL_MODE1(mode)        GPIO_P_MODEL_MODEx(1, mode)
 
#define GPIO_P_MODEL_MODE2_MASK         GPIO_P_MODEL_MODEx_MASK(2)
#define GPIO_P_MODEL_MODE2(mode)        GPIO_P_MODEL_MODEx(2, mode)
 
#define GPIO_P_MODEL_MODE3_MASK         GPIO_P_MODEL_MODEx_MASK(3)
#define GPIO_P_MODEL_MODE3(mode)        GPIO_P_MODEL_MODEx(3, mode)
 
#define GPIO_P_MODEL_MODE4_MASK         GPIO_P_MODEL_MODEx_MASK(4)
#define GPIO_P_MODEL_MODE4(mode)        GPIO_P_MODEL_MODEx(4, mode)
 
#define GPIO_P_MODEL_MODE5_MASK         GPIO_P_MODEL_MODEx_MASK(5)
#define GPIO_P_MODEL_MODE5(mode)        GPIO_P_MODEL_MODEx(5, mode)
 
#define GPIO_P_MODEL_MODE6_MASK         GPIO_P_MODEL_MODEx_MASK(6)
#define GPIO_P_MODEL_MODE6(mode)        GPIO_P_MODEL_MODEx(6, mode)
 
#define GPIO_P_MODEL_MODE7_MASK         GPIO_P_MODEL_MODEx_MASK(7)
#define GPIO_P_MODEL_MODE7(mode)        GPIO_P_MODEL_MODEx(7, mode)
 
#define GPIO_P_MODEH(port)              MMIO32((port) + 0x08)
#define GPIO_PA_MODEH                   GPIO_P_MODEH(GPIO_PA)
#define GPIO_PB_MODEH                   GPIO_P_MODEH(GPIO_PB)
#define GPIO_PC_MODEH                   GPIO_P_MODEH(GPIO_PC)
#define GPIO_PD_MODEH                   GPIO_P_MODEH(GPIO_PD)
#define GPIO_PE_MODEH                   GPIO_P_MODEH(GPIO_PE)
 
/* note: (x - 8) is because for MODEH, MODE8 refers to offset 0 */
#define GPIO_P_MODEH_MODEx_MASK(x)      GPIO_P_MODE_MODEx_MASK((x) - 8)
#define GPIO_P_MODEH_MODEx(x, mode)     GPIO_P_MODE_MODEx((x) - 8, mode)
 
#define GPIO_P_MODEH_MODE8_MASK         GPIO_P_MODEH_MODEx_MASK(8)
#define GPIO_P_MODEH_MODE8(mode)        GPIO_P_MODEH_MODEx(8, mode)
 
#define GPIO_P_MODEH_MODE9_MASK         GPIO_P_MODEH_MODEx_MASK(9)
#define GPIO_P_MODEH_MODE9(mode)        GPIO_P_MODEH_MODEx(9, mode)
 
#define GPIO_P_MODEH_MODE10_MASK        GPIO_P_MODEH_MODEx_MASK(10)
#define GPIO_P_MODEH_MODE10(mode)       GPIO_P_MODEH_MODEx(10, mode)
 
#define GPIO_P_MODEH_MODE11_MASK        GPIO_P_MODEH_MODEx_MASK(11)
#define GPIO_P_MODEH_MODE11(mode)       GPIO_P_MODEH_MODEx(11, mode)
 
#define GPIO_P_MODEH_MODE12_MASK        GPIO_P_MODEH_MODEx_MASK(12)
#define GPIO_P_MODEH_MODE12(mode)       GPIO_P_MODEH_MODEx(12, mode)
 
#define GPIO_P_MODEH_MODE13_MASK        GPIO_P_MODEH_MODEx_MASK(13)
#define GPIO_P_MODEH_MODE13(mode)       GPIO_P_MODEH_MODEx(13, mode)
 
#define GPIO_P_MODEH_MODE14_MASK        GPIO_P_MODEH_MODEx_MASK(14)
#define GPIO_P_MODEH_MODE14(mode)       GPIO_P_MODEH_MODEx(14, mode)
 
#define GPIO_P_MODEH_MODE15_MASK        GPIO_P_MODEH_MODEx_MASK(15)
#define GPIO_P_MODEH_MODE15(mode)       GPIO_P_MODEH_MODEx(15, mode)
 
#define GPIO_P_DOUT(port)               MMIO32((port) + 0x0C)
#define GPIO_PA_DOUT                    GPIO_P_DOUT(GPIO_PA)
#define GPIO_PB_DOUT                    GPIO_P_DOUT(GPIO_PB)
#define GPIO_PC_DOUT                    GPIO_P_DOUT(GPIO_PC)
#define GPIO_PD_DOUT                    GPIO_P_DOUT(GPIO_PD)
#define GPIO_PE_DOUT                    GPIO_P_DOUT(GPIO_PE)
 
#define GPIO_P_DOUTSET(port)            MMIO32((port) + 0x10)
#define GPIO_PA_DOUTSET                 GPIO_P_DOUTSET(GPIO_PA)
#define GPIO_PB_DOUTSET                 GPIO_P_DOUTSET(GPIO_PB)
#define GPIO_PC_DOUTSET                 GPIO_P_DOUTSET(GPIO_PC)
#define GPIO_PD_DOUTSET                 GPIO_P_DOUTSET(GPIO_PD)
#define GPIO_PE_DOUTSET                 GPIO_P_DOUTSET(GPIO_PE)
 
#define GPIO_P_DOUTCLR(port)            MMIO32((port) + 0x14)
#define GPIO_PA_DOUTCLR                 GPIO_P_DOUTCLR(GPIO_PA)
#define GPIO_PB_DOUTCLR                 GPIO_P_DOUTCLR(GPIO_PB)
#define GPIO_PC_DOUTCLR                 GPIO_P_DOUTCLR(GPIO_PC)
#define GPIO_PD_DOUTCLR                 GPIO_P_DOUTCLR(GPIO_PD)
#define GPIO_PE_DOUTCLR                 GPIO_P_DOUTCLR(GPIO_PE)
 
#define GPIO_P_DOUTTGL(port)            MMIO32((port) + 0x18)
#define GPIO_PA_DOUTTGL                 GPIO_P_DOUTTGL(GPIO_PA)
#define GPIO_PB_DOUTTGL                 GPIO_P_DOUTTGL(GPIO_PB)
#define GPIO_PC_DOUTTGL                 GPIO_P_DOUTTGL(GPIO_PC)
#define GPIO_PD_DOUTTGL                 GPIO_P_DOUTTGL(GPIO_PD)
#define GPIO_PE_DOUTTGL                 GPIO_P_DOUTTGL(GPIO_PE)
 
#define GPIO_P_DIN(port)                MMIO32((port) + 0x1C)
#define GPIO_PA_DIN                     GPIO_P_DIN(GPIO_PA)
#define GPIO_PB_DIN                     GPIO_P_DIN(GPIO_PB)
#define GPIO_PC_DIN                     GPIO_P_DIN(GPIO_PC)
#define GPIO_PD_DIN                     GPIO_P_DIN(GPIO_PD)
#define GPIO_PE_DIN                     GPIO_P_DIN(GPIO_PE)
 
#define GPIO_P_PINLOCKN(port)           MMIO32((port) + 0x20)
#define GPIO_PA_PINLOCKN                GPIO_P_PINLOCKN(GPIO_PA)
#define GPIO_PB_PINLOCKN                GPIO_P_PINLOCKN(GPIO_PB)
#define GPIO_PC_PINLOCKN                GPIO_P_PINLOCKN(GPIO_PC)
#define GPIO_PD_PINLOCKN                GPIO_P_PINLOCKN(GPIO_PD)
#define GPIO_PE_PINLOCKN                GPIO_P_PINLOCKN(GPIO_PE)
 
#define GPIO_EXTIPSELL                  MMIO32(GPIO_BASE + 0x100)
#define GPIO_EXTIPSELH                  MMIO32(GPIO_BASE + 0x104)
#define GPIO_EXTIRISE                   MMIO32(GPIO_BASE + 0x108)
#define GPIO_EXTIFALL                   MMIO32(GPIO_BASE + 0x10C)
#define GPIO_IEN                        MMIO32(GPIO_BASE + 0x110)
#define GPIO_IF                         MMIO32(GPIO_BASE + 0x114)
#define GPIO_IFS                        MMIO32(GPIO_BASE + 0x118)
#define GPIO_IFC                        MMIO32(GPIO_BASE + 0x11C)
#define GPIO_ROUTE                      MMIO32(GPIO_BASE + 0x120)
#define GPIO_INSENSE                    MMIO32(GPIO_BASE + 0x124)
#define GPIO_LOCK                       MMIO32(GPIO_BASE + 0x128)
#define GPIO_CTRL                       MMIO32(GPIO_BASE + 0x12C)
#define GPIO_CMD                        MMIO32(GPIO_BASE + 0x130)
#define GPIO_EM4WUEN                    MMIO32(GPIO_BASE + 0x134)
#define GPIO_EM4WUPOL                   MMIO32(GPIO_BASE + 0x138)
#define GPIO_EM4WUCAUSE                 MMIO32(GPIO_BASE + 0x13C)
 
/* mask is performed so that can be used with L and H */
#define GPIO_EXTIPSEL_MASK(n)           (0x7 << ((n) & 0xF))
#define GPIO_EXTIPSEL_PORTMASK(n, v)    ((v) << ((n) & 0xF))
#define GPIO_EXTIPSEL_PORTA             0x0
#define GPIO_EXTIPSEL_PORTB             0x1
#define GPIO_EXTIPSEL_PORTC             0x2
#define GPIO_EXTIPSEL_PORTD             0x3
#define GPIO_EXTIPSEL_PORTE             0x4
#define GPIO_EXTIPSEL_PORTF             0x5
 
#define GPIO_ROUTE_SWCLKPEN             (1 << 0)
#define GPIO_ROUTE_SWDIOPEN             (1 << 1)
#define GPIO_ROUTE_SWOPEN               (1 << 3)
 
#define GPIO_ROUTE_SWLOCATION_SHIFT     (8)
#define GPIO_ROUTE_SWLOCATION_MASK      (0x3 << GPIO_ROUTE_SWLOCATION_SHIFT)
#define GPIO_ROUTE_SWLOCATION(v)        \
        (((v) << GPIO_ROUTE_SWLOCATION_SHIFT) & GPIO_ROUTE_SWLOCATION_MASK)
 
#define GPIO_ROUTE_TCLKPEN              (1 << 12)
#define GPIO_ROUTE_TD0PEN               (1 << 13)
#define GPIO_ROUTE_TD1PEN               (1 << 14)
#define GPIO_ROUTE_TD2PEN               (1 << 15)
#define GPIO_ROUTE_TD3PEN               (1 << 16)
 
#define GPIO_ROUTE_ETMLOCATION_SHIFT    (24)
#define GPIO_ROUTE_ETMLOCATION_MASK     (0x3 << GPIO_ROUTE_ETMLOCATION_SHIFT)
#define GPIO_ROUTE_ETMLOCATION(v)       \
        (((v) << GPIO_ROUTE_ETMLOCATION_SHIFT) & GPIO_ROUTE_ETMLOCATION_MASK)
#define GPIO_ROUTE_ETMLOCATION_LOCx(x)  GPIO_ROUTE_ETMLOCATION(x)
#define GPIO_ROUTE_ETMLOCATION_LOC0     0
#define GPIO_ROUTE_ETMLOCATION_LOC1     1
#define GPIO_ROUTE_ETMLOCATION_LOC2     2
#define GPIO_ROUTE_ETMLOCATION_LOC3     3
 
#define GPIO_INSENSE_INT                (1 << 0)
#define GPIO_INSENSE_PRS                (1 << 1)
 
#define GPIO_LOCK_LOCKKEY_SHIFT         (0)
#define GPIO_LOCK_LOCKKEY_MASK          (0xFFFF << GPIO_LOCK_LOCKKEY_SHIFT)
#define GPIO_LOCK_LOCKKEY_UNLOCKED      (0x0000 << GPIO_LOCK_LOCKKEY_SHIFT)
#define GPIO_LOCK_LOCKKEY_LOCKED        (0x0001 << GPIO_LOCK_LOCKKEY_SHIFT)
#define GPIO_LOCK_LOCKKEY_LOCK          (0x0000 << GPIO_LOCK_LOCKKEY_SHIFT)
#define GPIO_LOCK_LOCKKEY_UNLOCK        (0xA534 << GPIO_LOCK_LOCKKEY_SHIFT)
 
#define GPIO_CTRL_EM4RET                (1 << 0)
 
#define GPIO_CMD_EM4WUCLR               (1 << 0)
 
#define GPIO_EM4WUEN_EM4WUEN_A0         (1 << 0)
#define GPIO_EM4WUEN_EM4WUEN_A6         (1 << 1)
#define GPIO_EM4WUEN_EM4WUEN_C9         (1 << 2)
#define GPIO_EM4WUEN_EM4WUEN_F1         (1 << 3)
#define GPIO_EM4WUEN_EM4WUEN_F2         (1 << 4)
#define GPIO_EM4WUEN_EM4WUEN_E13        (1 << 5)
 
#define GPIO_EM4WUPOL_EM4WUPOL_A0       (1 << 0)
#define GPIO_EM4WUPOL_EM4WUPOL_A6       (1 << 1)
#define GPIO_EM4WUPOL_EM4WUPOL_C9       (1 << 2)
#define GPIO_EM4WUPOL_EM4WUPOL_F1       (1 << 3)
#define GPIO_EM4WUPOL_EM4WUPOL_F2       (1 << 4)
#define GPIO_EM4WUPOL_EM4WUPOL_E13      (1 << 5)
 
#define GPIO0                           (1 << 0)
#define GPIO1                           (1 << 1)
#define GPIO2                           (1 << 2)
#define GPIO3                           (1 << 3)
#define GPIO4                           (1 << 4)
#define GPIO5                           (1 << 5)
#define GPIO6                           (1 << 6)
#define GPIO7                           (1 << 7)
#define GPIO8                           (1 << 8)
#define GPIO9                           (1 << 9)
#define GPIO10                          (1 << 10)
#define GPIO11                          (1 << 11)
#define GPIO12                          (1 << 12)
#define GPIO13                          (1 << 13)
#define GPIO14                          (1 << 14)
#define GPIO15                          (1 << 15)
#define GPIO_ALL                        (0xFFFF)
 
/* These are the acceptable mode values.
 *   (+ readable counterparts)
 *  do not confuse GPIO_MODE_* for GPIO_P_MODE_MODEx.
 */
enum gpio_mode {
        GPIO_MODE_DISABLE = 0,
        GPIO_MODE_INPUT,
        GPIO_MODE_INPUT_PULL,
        GPIO_MODE_INPUT_PULL_FILTER,
        GPIO_MODE_PUSH_PULL,
        GPIO_MODE_PUSH_PULL_DRIVE,
        GPIO_MODE_WIRED_OR,
        GPIO_MODE_WIRED_OR_PULL_DOWN,
        GPIO_MODE_WIRED_AND,
        GPIO_MODE_WIRED_AND_FILTER,
        GPIO_MODE_WIRED_AND_PULLUP,
        GPIO_MODE_WIRED_AND_PULLUP_FILTER,
        GPIO_MODE_WIRED_AND_DRIVE,
        GPIO_MODE_WIRED_AND_DRIVE_FILTER,
        GPIO_MODE_WIRED_AND_DRIVE_PULLUP,
        GPIO_MODE_WIRED_AND_DRIVE_PULLUP_FILTER
};
 
/* for readability. */
enum gpio_drive_strength {
        GPIO_STRENGTH_STANDARD = 0,
        GPIO_STRENGTH_LOWEST,
        GPIO_STRENGTH_HIGH,
        GPIO_STRENGTH_LOW
};
 
/* for readability */
#define GPIOA GPIO_PA
#define GPIOB GPIO_PB
#define GPIOC GPIO_PC
#define GPIOD GPIO_PD
#define GPIOE GPIO_PE
#define GPIOF GPIO_PF
 
/* --- Function prototypes ------------------------------------------------- */
 
BEGIN_DECLS
 
void gpio_enable_lock(void);
void gpio_disable_lock(void);
bool gpio_get_lock_flag(void);
 
void gpio_set_drive_strength(uint32_t gpio_port,
                enum gpio_drive_strength driver_stength);
void gpio_mode_setup(uint32_t gpio_port, enum gpio_mode mode, uint16_t gpios);
 
void gpio_set(uint32_t gpio_port, uint16_t gpios);
void gpio_clear(uint32_t gpio_port, uint16_t gpios);
uint16_t gpio_get(uint32_t gpio_port, uint16_t gpios);
void gpio_toggle(uint32_t gpio_port, uint16_t gpios);
uint16_t gpio_port_read(uint32_t gpio_port);
void gpio_port_write(uint32_t gpio_port, uint16_t data);
 
void gpio_port_config_lock(uint32_t gpio_port, uint16_t gpios);
 
END_DECLS
 
/**@}*/