gpio.h

Go to the documentation of this file.

/*
 * Copyright (c) 2019-2020 Nordic Semiconductor ASA
 * Copyright (c) 2019 Piotr Mienkowski
 * Copyright (c) 2017 ARM Ltd
 * Copyright (c) 2015-2016 Intel Corporation.
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_DRIVERS_GPIO_H_
#define ZEPHYR_INCLUDE_DRIVERS_GPIO_H_
 
#include <errno.h>
 
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/slist.h>
#include <zephyr/tracing/tracing.h>
 
#include <zephyr/types.h>
#include <stddef.h>
#include <zephyr/device.h>
#include <zephyr/dt-bindings/gpio/gpio.h>
 
#ifdef __cplusplus
extern "C" {
#endif



#define GPIO_INPUT              BIT(16)

#define GPIO_OUTPUT             BIT(17)

#define GPIO_DISCONNECTED       0

 
/* Initializes output to a low state. */
#define GPIO_OUTPUT_INIT_LOW    BIT(18)
 
/* Initializes output to a high state. */
#define GPIO_OUTPUT_INIT_HIGH   BIT(19)
 
/* Initializes output based on logic level */
#define GPIO_OUTPUT_INIT_LOGICAL BIT(20)


#define GPIO_OUTPUT_LOW         (GPIO_OUTPUT | GPIO_OUTPUT_INIT_LOW)
#define GPIO_OUTPUT_HIGH        (GPIO_OUTPUT | GPIO_OUTPUT_INIT_HIGH)
#define GPIO_OUTPUT_INACTIVE    (GPIO_OUTPUT |                  \
                                 GPIO_OUTPUT_INIT_LOW |         \
                                 GPIO_OUTPUT_INIT_LOGICAL)

#define GPIO_OUTPUT_ACTIVE      (GPIO_OUTPUT |                  \
                                 GPIO_OUTPUT_INIT_HIGH |        \
                                 GPIO_OUTPUT_INIT_LOGICAL)



#define GPIO_INT_DISABLE               BIT(21)

 
/* Enables GPIO pin interrupt. */
#define GPIO_INT_ENABLE                BIT(22)
 
/* GPIO interrupt is sensitive to logical levels.
 *
 * This is a component flag that should be combined with other
 * `GPIO_INT_*` flags to produce a meaningful configuration.
 */
#define GPIO_INT_LEVELS_LOGICAL        BIT(23)
 
/* GPIO interrupt is edge sensitive.
 *
 * Note: by default interrupts are level sensitive.
 *
 * This is a component flag that should be combined with other
 * `GPIO_INT_*` flags to produce a meaningful configuration.
 */
#define GPIO_INT_EDGE                  BIT(24)
 
/* Trigger detection when input state is (or transitions to) physical low or
 * logical 0 level.
 *
 * This is a component flag that should be combined with other
 * `GPIO_INT_*` flags to produce a meaningful configuration.
 */
#define GPIO_INT_LOW_0                 BIT(25)
 
/* Trigger detection on input state is (or transitions to) physical high or
 * logical 1 level.
 *
 * This is a component flag that should be combined with other
 * `GPIO_INT_*` flags to produce a meaningful configuration.
 */
#define GPIO_INT_HIGH_1                BIT(26)
 
#ifdef CONFIG_GPIO_ENABLE_DISABLE_INTERRUPT
/* Disable/Enable interrupt functionality without changing other interrupt
 * related register, such as clearing the pending register.
 *
 * This is a component flag that should be combined with `GPIO_INT_ENABLE` or
 * `GPIO_INT_DISABLE` flags to produce a meaningful configuration.
 */
#define GPIO_INT_ENABLE_DISABLE_ONLY   BIT(27)
#endif /* CONFIG_GPIO_ENABLE_DISABLE_INTERRUPT */
 
#define GPIO_INT_MASK                  (GPIO_INT_DISABLE | \
                                        GPIO_INT_ENABLE | \
                                        GPIO_INT_LEVELS_LOGICAL | \
                                        GPIO_INT_EDGE | \
                                        GPIO_INT_LOW_0 | \
                                        GPIO_INT_HIGH_1)


#define GPIO_INT_EDGE_RISING           (GPIO_INT_ENABLE | \
                                        GPIO_INT_EDGE | \
                                        GPIO_INT_HIGH_1)

#define GPIO_INT_EDGE_FALLING          (GPIO_INT_ENABLE | \
                                        GPIO_INT_EDGE | \
                                        GPIO_INT_LOW_0)

#define GPIO_INT_EDGE_BOTH             (GPIO_INT_ENABLE | \
                                        GPIO_INT_EDGE | \
                                        GPIO_INT_LOW_0 | \
                                        GPIO_INT_HIGH_1)

#define GPIO_INT_LEVEL_LOW             (GPIO_INT_ENABLE | \
                                        GPIO_INT_LOW_0)

#define GPIO_INT_LEVEL_HIGH            (GPIO_INT_ENABLE | \
                                        GPIO_INT_HIGH_1)

#define GPIO_INT_EDGE_TO_INACTIVE      (GPIO_INT_ENABLE | \
                                        GPIO_INT_LEVELS_LOGICAL | \
                                        GPIO_INT_EDGE | \
                                        GPIO_INT_LOW_0)

#define GPIO_INT_EDGE_TO_ACTIVE        (GPIO_INT_ENABLE | \
                                        GPIO_INT_LEVELS_LOGICAL | \
                                        GPIO_INT_EDGE | \
                                        GPIO_INT_HIGH_1)

#define GPIO_INT_LEVEL_INACTIVE        (GPIO_INT_ENABLE | \
                                        GPIO_INT_LEVELS_LOGICAL | \
                                        GPIO_INT_LOW_0)

#define GPIO_INT_LEVEL_ACTIVE          (GPIO_INT_ENABLE | \
                                        GPIO_INT_LEVELS_LOGICAL | \
                                        GPIO_INT_HIGH_1)


#define GPIO_DIR_MASK           (GPIO_INPUT | GPIO_OUTPUT)

typedef uint32_t gpio_port_pins_t;

typedef uint32_t gpio_port_value_t;

typedef uint8_t gpio_pin_t;

typedef uint16_t gpio_dt_flags_t;

typedef uint32_t gpio_flags_t;

struct gpio_dt_spec {
        const struct device *port;
        gpio_pin_t pin;
        gpio_dt_flags_t dt_flags;
};

#define GPIO_DT_SPEC_GET_BY_IDX(node_id, prop, idx)                            \
        {                                                                      \
                .port = DEVICE_DT_GET(DT_GPIO_CTLR_BY_IDX(node_id, prop, idx)),\
                .pin = DT_GPIO_PIN_BY_IDX(node_id, prop, idx),                 \
                .dt_flags = DT_GPIO_FLAGS_BY_IDX(node_id, prop, idx),          \
        }

#define GPIO_DT_SPEC_GET_BY_IDX_OR(node_id, prop, idx, default_value)   \
        COND_CODE_1(DT_PROP_HAS_IDX(node_id, prop, idx),                \
                    (GPIO_DT_SPEC_GET_BY_IDX(node_id, prop, idx)),      \
                    (default_value))

#define GPIO_DT_SPEC_GET(node_id, prop) \
        GPIO_DT_SPEC_GET_BY_IDX(node_id, prop, 0)

#define GPIO_DT_SPEC_GET_OR(node_id, prop, default_value) \
        GPIO_DT_SPEC_GET_BY_IDX_OR(node_id, prop, 0, default_value)

#define GPIO_DT_SPEC_INST_GET_BY_IDX(inst, prop, idx) \
        GPIO_DT_SPEC_GET_BY_IDX(DT_DRV_INST(inst), prop, idx)

#define GPIO_DT_SPEC_INST_GET_BY_IDX_OR(inst, prop, idx, default_value)         \
        COND_CODE_1(DT_PROP_HAS_IDX(DT_DRV_INST(inst), prop, idx),              \
                    (GPIO_DT_SPEC_GET_BY_IDX(DT_DRV_INST(inst), prop, idx)),    \
                    (default_value))

#define GPIO_DT_SPEC_INST_GET(inst, prop) \
        GPIO_DT_SPEC_INST_GET_BY_IDX(inst, prop, 0)

#define GPIO_DT_SPEC_INST_GET_OR(inst, prop, default_value) \
        GPIO_DT_SPEC_INST_GET_BY_IDX_OR(inst, prop, 0, default_value)
 
/*
 * @cond INTERNAL_HIDDEN
 */

#define Z_GPIO_GEN_BITMASK_COND(node_id, prop, off_idx, sz_idx)              \
        COND_CODE_1(DT_PROP_HAS_IDX(node_id, prop, off_idx),                 \
                (COND_CODE_0(DT_PROP_BY_IDX(node_id, prop, sz_idx),          \
                        (0),                                                 \
                        (GENMASK64(DT_PROP_BY_IDX(node_id, prop, off_idx) +  \
                                DT_PROP_BY_IDX(node_id, prop, sz_idx) - 1,   \
                                DT_PROP_BY_IDX(node_id, prop, off_idx))))    \
                ), (0))

#define Z_GPIO_GEN_RESERVED_RANGES_COND(odd_it, node_id)                      \
        COND_CODE_1(DT_PROP_HAS_IDX(node_id, gpio_reserved_ranges, odd_it),   \
                (Z_GPIO_GEN_BITMASK_COND(node_id,                             \
                        gpio_reserved_ranges,                                 \
                        GET_ARG_N(odd_it, Z_SPARSE_LIST_EVEN_NUMBERS),        \
                        odd_it)),                                             \
                (0))


#define GPIO_DT_RESERVED_RANGES_NGPIOS(node_id, ngpios)                        \
        ((gpio_port_pins_t)                                                    \
        COND_CODE_1(DT_NODE_HAS_PROP(node_id, gpio_reserved_ranges),           \
                (GENMASK64(BITS_PER_LONG_LONG - 1, ngpios)                     \
                | FOR_EACH_FIXED_ARG(Z_GPIO_GEN_RESERVED_RANGES_COND,          \
                        (|),                                                   \
                        node_id,                                               \
                        LIST_DROP_EMPTY(Z_SPARSE_LIST_ODD_NUMBERS))),          \
                (0)))

#define GPIO_DT_RESERVED_RANGES(node_id)                                       \
        GPIO_DT_RESERVED_RANGES_NGPIOS(node_id, DT_PROP(node_id, ngpios))

#define GPIO_DT_INST_RESERVED_RANGES_NGPIOS(inst, ngpios)                      \
                GPIO_DT_RESERVED_RANGES_NGPIOS(DT_DRV_INST(inst), ngpios)

#define GPIO_DT_INST_RESERVED_RANGES(inst)                                     \
                GPIO_DT_RESERVED_RANGES(DT_DRV_INST(inst))

#define GPIO_DT_PORT_PIN_MASK_NGPIOS_EXC(node_id, ngpios)                      \
        ((gpio_port_pins_t)                                                    \
        COND_CODE_0(ngpios,                                                    \
                (0),                                                           \
                (COND_CODE_1(DT_NODE_HAS_PROP(node_id, gpio_reserved_ranges),  \
                        ((GENMASK64(ngpios - 1, 0) &                           \
                        ~GPIO_DT_RESERVED_RANGES_NGPIOS(node_id, ngpios))),    \
                        (GENMASK64(ngpios - 1, 0)))                            \
                )                                                              \
        ))

#define GPIO_DT_INST_PORT_PIN_MASK_NGPIOS_EXC(inst, ngpios)     \
                GPIO_DT_PORT_PIN_MASK_NGPIOS_EXC(DT_DRV_INST(inst), ngpios)

#define GPIO_MAX_PINS_PER_PORT (sizeof(gpio_port_pins_t) * __CHAR_BIT__)

struct gpio_driver_config {
        gpio_port_pins_t port_pin_mask;
};

struct gpio_driver_data {
        gpio_port_pins_t invert;
};
 
struct gpio_callback;

typedef void (*gpio_callback_handler_t)(const struct device *port,
                                        struct gpio_callback *cb,
                                        gpio_port_pins_t pins);

struct gpio_callback {
        sys_snode_t node;

        gpio_callback_handler_t handler;

        gpio_port_pins_t pin_mask;
};

 
/* Used by driver api function pin_interrupt_configure, these are defined
 * in terms of the public flags so we can just mask and pass them
 * through to the driver api
 */
enum gpio_int_mode {
        GPIO_INT_MODE_DISABLED = GPIO_INT_DISABLE,
        GPIO_INT_MODE_LEVEL = GPIO_INT_ENABLE,
        GPIO_INT_MODE_EDGE = GPIO_INT_ENABLE | GPIO_INT_EDGE,
#ifdef CONFIG_GPIO_ENABLE_DISABLE_INTERRUPT
        GPIO_INT_MODE_DISABLE_ONLY = GPIO_INT_DISABLE | GPIO_INT_ENABLE_DISABLE_ONLY,
        GPIO_INT_MODE_ENABLE_ONLY = GPIO_INT_ENABLE | GPIO_INT_ENABLE_DISABLE_ONLY,
#endif /* CONFIG_GPIO_ENABLE_DISABLE_INTERRUPT */
};
 
enum gpio_int_trig {
        /* Trigger detection when input state is (or transitions to)
         * physical low. (Edge Falling or Active Low)
         */
        GPIO_INT_TRIG_LOW = GPIO_INT_LOW_0,
        /* Trigger detection when input state is (or transitions to)
         * physical high. (Edge Rising or Active High) */
        GPIO_INT_TRIG_HIGH = GPIO_INT_HIGH_1,
        /* Trigger detection on pin rising or falling edge. */
        GPIO_INT_TRIG_BOTH = GPIO_INT_LOW_0 | GPIO_INT_HIGH_1,
        /* Trigger a system wakeup. */
        GPIO_INT_TRIG_WAKE = GPIO_INT_WAKEUP,
        /* Trigger a system wakeup when input state is (or transitions to)
         * physical low. (Edge Falling or Active Low)
         */
        GPIO_INT_TRIG_WAKE_LOW = GPIO_INT_LOW_0 | GPIO_INT_WAKEUP,
        /* Trigger a system wakeup when input state is (or transitions to)
         * physical high. (Edge Rising or Active High)
         */
        GPIO_INT_TRIG_WAKE_HIGH = GPIO_INT_HIGH_1 | GPIO_INT_WAKEUP,
        /* Trigger a system wakeup on pin rising or falling edge. */
        GPIO_INT_TRIG_WAKE_BOTH = GPIO_INT_LOW_0 | GPIO_INT_HIGH_1 | GPIO_INT_WAKEUP,
};
 
__subsystem struct gpio_driver_api {
        int (*pin_configure)(const struct device *port, gpio_pin_t pin,
                             gpio_flags_t flags);
#ifdef CONFIG_GPIO_GET_CONFIG
        int (*pin_get_config)(const struct device *port, gpio_pin_t pin,
                              gpio_flags_t *flags);
#endif
        int (*port_get_raw)(const struct device *port,
                            gpio_port_value_t *value);
        int (*port_set_masked_raw)(const struct device *port,
                                   gpio_port_pins_t mask,
                                   gpio_port_value_t value);
        int (*port_set_bits_raw)(const struct device *port,
                                 gpio_port_pins_t pins);
        int (*port_clear_bits_raw)(const struct device *port,
                                   gpio_port_pins_t pins);
        int (*port_toggle_bits)(const struct device *port,
                                gpio_port_pins_t pins);
        int (*pin_interrupt_configure)(const struct device *port,
                                       gpio_pin_t pin,
                                       enum gpio_int_mode mode,
                                       enum gpio_int_trig trig);
        int (*manage_callback)(const struct device *port,
                               struct gpio_callback *cb,
                               bool set);
        uint32_t (*get_pending_int)(const struct device *dev);
#ifdef CONFIG_GPIO_GET_DIRECTION
        int (*port_get_direction)(const struct device *port, gpio_port_pins_t map,
                                  gpio_port_pins_t *inputs, gpio_port_pins_t *outputs);
#endif /* CONFIG_GPIO_GET_DIRECTION */
};


static inline bool gpio_is_ready_dt(const struct gpio_dt_spec *spec)
{
        /* Validate port is ready */
        return device_is_ready(spec->port);
}

__syscall int gpio_pin_interrupt_configure(const struct device *port,
                                           gpio_pin_t pin,
                                           gpio_flags_t flags);
 
static inline int z_impl_gpio_pin_interrupt_configure(const struct device *port,
                                                      gpio_pin_t pin,
                                                      gpio_flags_t flags)
{
        const struct gpio_driver_api *api = DEVICE_API_GET(gpio, port);
        __unused const struct gpio_driver_config *const cfg =
                (const struct gpio_driver_config *)port->config;
        const struct gpio_driver_data *const data =
                (const struct gpio_driver_data *)port->data;
        enum gpio_int_trig trig;
        enum gpio_int_mode mode;
        int ret;
 
        SYS_PORT_TRACING_FUNC_ENTER(gpio_pin, interrupt_configure, port, pin, flags);
 
        if (api->pin_interrupt_configure == NULL) {
                SYS_PORT_TRACING_FUNC_EXIT(gpio_pin, interrupt_configure, port, pin, -ENOSYS);
                return -ENOSYS;
        }
 
        __ASSERT((flags & (GPIO_INT_DISABLE | GPIO_INT_ENABLE))
                 != (GPIO_INT_DISABLE | GPIO_INT_ENABLE),
                 "Cannot both enable and disable interrupts");
 
        __ASSERT((flags & (GPIO_INT_DISABLE | GPIO_INT_ENABLE)) != 0U,
                 "Must either enable or disable interrupts");
 
        __ASSERT(((flags & GPIO_INT_ENABLE) == 0) ||
                 ((flags & GPIO_INT_EDGE) != 0) ||
                 ((flags & (GPIO_INT_LOW_0 | GPIO_INT_HIGH_1)) !=
                  (GPIO_INT_LOW_0 | GPIO_INT_HIGH_1)),
                 "Only one of GPIO_INT_LOW_0, GPIO_INT_HIGH_1 can be "
                 "enabled for a level interrupt.");
 
#ifdef CONFIG_GPIO_ENABLE_DISABLE_INTERRUPT
#define GPIO_INT_ENABLE_DISABLE_ONLY_VALUE  GPIO_INT_ENABLE_DISABLE_ONLY
#else
#define GPIO_INT_ENABLE_DISABLE_ONLY_VALUE  0
#endif /* CONFIG_GPIO_ENABLE_DISABLE_INTERRUPT */
 
        __ASSERT(((flags & GPIO_INT_ENABLE) == 0) ||
                         ((flags & (GPIO_INT_LOW_0 | GPIO_INT_HIGH_1)) != 0) ||
                         (flags & GPIO_INT_ENABLE_DISABLE_ONLY_VALUE) != 0,
                 "At least one of GPIO_INT_LOW_0, GPIO_INT_HIGH_1 has to be enabled.");
#undef GPIO_INT_ENABLE_DISABLE_ONLY_VALUE
        __ASSERT((cfg->port_pin_mask & (gpio_port_pins_t)BIT(pin)) != 0U,
                 "Unsupported pin");
 
        if (((flags & GPIO_INT_LEVELS_LOGICAL) != 0) &&
            ((data->invert & (gpio_port_pins_t)BIT(pin)) != 0)) {
                /* Invert signal bits */
                flags ^= (GPIO_INT_LOW_0 | GPIO_INT_HIGH_1);
        }
 
        trig = (enum gpio_int_trig)(flags & (GPIO_INT_LOW_0 | GPIO_INT_HIGH_1 | GPIO_INT_WAKEUP));
#ifdef CONFIG_GPIO_ENABLE_DISABLE_INTERRUPT
        mode = (enum gpio_int_mode)(flags & (GPIO_INT_EDGE | GPIO_INT_DISABLE | GPIO_INT_ENABLE |
                                             GPIO_INT_ENABLE_DISABLE_ONLY));
#else
        mode = (enum gpio_int_mode)(flags & (GPIO_INT_EDGE | GPIO_INT_DISABLE | GPIO_INT_ENABLE));
#endif /* CONFIG_GPIO_ENABLE_DISABLE_INTERRUPT */
 
        ret = api->pin_interrupt_configure(port, pin, mode, trig);
        SYS_PORT_TRACING_FUNC_EXIT(gpio_pin, interrupt_configure, port, pin, ret);
        return ret;
}

static inline int gpio_pin_interrupt_configure_dt(const struct gpio_dt_spec *spec,
                                                  gpio_flags_t flags)
{
        return gpio_pin_interrupt_configure(spec->port, spec->pin,
                                            flags | (spec->dt_flags & GPIO_INT_WAKEUP));
}

__syscall int gpio_pin_configure(const struct device *port,
                                 gpio_pin_t pin,
                                 gpio_flags_t flags);
 
static inline int z_impl_gpio_pin_configure(const struct device *port,
                                            gpio_pin_t pin,
                                            gpio_flags_t flags)
{
        const struct gpio_driver_api *api = DEVICE_API_GET(gpio, port);
        __unused const struct gpio_driver_config *const cfg =
                (const struct gpio_driver_config *)port->config;
        struct gpio_driver_data *data =
                (struct gpio_driver_data *)port->data;
        int ret;
 
        SYS_PORT_TRACING_FUNC_ENTER(gpio_pin, configure, port, pin, flags);
 
        __ASSERT((flags & GPIO_INT_MASK) == 0,
                 "Interrupt flags are not supported");
 
        __ASSERT((flags & (GPIO_PULL_UP | GPIO_PULL_DOWN)) !=
                 (GPIO_PULL_UP | GPIO_PULL_DOWN),
                 "Pull Up and Pull Down should not be enabled simultaneously");
 
        __ASSERT(!((flags & GPIO_INPUT) && !(flags & GPIO_OUTPUT) && (flags & GPIO_SINGLE_ENDED)),
                 "Input cannot be enabled for 'Open Drain', 'Open Source' modes without Output");
 
        __ASSERT_NO_MSG((flags & GPIO_SINGLE_ENDED) != 0 ||
                        (flags & GPIO_LINE_OPEN_DRAIN) == 0);
 
        __ASSERT((flags & (GPIO_OUTPUT_INIT_LOW | GPIO_OUTPUT_INIT_HIGH)) == 0
                 || (flags & GPIO_OUTPUT) != 0,
                 "Output needs to be enabled to be initialized low or high");
 
        __ASSERT((flags & (GPIO_OUTPUT_INIT_LOW | GPIO_OUTPUT_INIT_HIGH))
                 != (GPIO_OUTPUT_INIT_LOW | GPIO_OUTPUT_INIT_HIGH),
                 "Output cannot be initialized low and high");
 
        if (((flags & GPIO_OUTPUT_INIT_LOGICAL) != 0)
            && ((flags & (GPIO_OUTPUT_INIT_LOW | GPIO_OUTPUT_INIT_HIGH)) != 0)
            && ((flags & GPIO_ACTIVE_LOW) != 0)) {
                flags ^= GPIO_OUTPUT_INIT_LOW | GPIO_OUTPUT_INIT_HIGH;
        }
 
        flags &= ~GPIO_OUTPUT_INIT_LOGICAL;
 
        __ASSERT((cfg->port_pin_mask & (gpio_port_pins_t)BIT(pin)) != 0U,
                 "Unsupported pin");
 
        if ((flags & GPIO_ACTIVE_LOW) != 0) {
                data->invert |= (gpio_port_pins_t)BIT(pin);
        } else {
                data->invert &= ~(gpio_port_pins_t)BIT(pin);
        }
 
        ret = api->pin_configure(port, pin, flags);
        SYS_PORT_TRACING_FUNC_EXIT(gpio_pin, configure, port, pin, ret);
        return ret;
}

static inline int gpio_pin_configure_dt(const struct gpio_dt_spec *spec,
                                        gpio_flags_t extra_flags)
{
        return gpio_pin_configure(spec->port,
                                  spec->pin,
                                  spec->dt_flags | extra_flags);
}

__syscall int gpio_port_get_direction(const struct device *port, gpio_port_pins_t map,
                                      gpio_port_pins_t *inputs, gpio_port_pins_t *outputs);
 
#ifdef CONFIG_GPIO_GET_DIRECTION
static inline int z_impl_gpio_port_get_direction(const struct device *port, gpio_port_pins_t map,
                                                 gpio_port_pins_t *inputs,
                                                 gpio_port_pins_t *outputs)
{
        const struct gpio_driver_api *api = DEVICE_API_GET(gpio, port);
        int ret;
 
        SYS_PORT_TRACING_FUNC_ENTER(gpio_port, get_direction, port, map, inputs, outputs);
 
        if (api->port_get_direction == NULL) {
                SYS_PORT_TRACING_FUNC_EXIT(gpio_port, get_direction, port, -ENOSYS);
                return -ENOSYS;
        }
 
        ret = api->port_get_direction(port, map, inputs, outputs);
        SYS_PORT_TRACING_FUNC_EXIT(gpio_port, get_direction, port, ret);
        return ret;
}
#endif /* CONFIG_GPIO_GET_DIRECTION */

static inline int gpio_pin_is_input(const struct device *port, gpio_pin_t pin)
{
        int rv;
        gpio_port_pins_t pins;
        __unused const struct gpio_driver_config *cfg =
                (const struct gpio_driver_config *)port->config;
 
        __ASSERT((cfg->port_pin_mask & (gpio_port_pins_t)BIT(pin)) != 0U, "Unsupported pin");
 
        rv = gpio_port_get_direction(port, BIT(pin), &pins, NULL);
        if (rv < 0) {
                return rv;
        }
 
        return (int)!!((gpio_port_pins_t)BIT(pin) & pins);
}

static inline int gpio_pin_is_input_dt(const struct gpio_dt_spec *spec)
{
        return gpio_pin_is_input(spec->port, spec->pin);
}

static inline int gpio_pin_is_output(const struct device *port, gpio_pin_t pin)
{
        int rv;
        gpio_port_pins_t pins;
        __unused const struct gpio_driver_config *cfg =
                (const struct gpio_driver_config *)port->config;
 
        __ASSERT((cfg->port_pin_mask & (gpio_port_pins_t)BIT(pin)) != 0U, "Unsupported pin");
 
        rv = gpio_port_get_direction(port, BIT(pin), NULL, &pins);
        if (rv < 0) {
                return rv;
        }
 
        return (int)!!((gpio_port_pins_t)BIT(pin) & pins);
}

static inline int gpio_pin_is_output_dt(const struct gpio_dt_spec *spec)
{
        return gpio_pin_is_output(spec->port, spec->pin);
}

__syscall int gpio_pin_get_config(const struct device *port, gpio_pin_t pin,
                                  gpio_flags_t *flags);
 
#ifdef CONFIG_GPIO_GET_CONFIG
static inline int z_impl_gpio_pin_get_config(const struct device *port,
                                             gpio_pin_t pin,
                                             gpio_flags_t *flags)
{
        const struct gpio_driver_api *api = DEVICE_API_GET(gpio, port);
        int ret;
 
        SYS_PORT_TRACING_FUNC_ENTER(gpio_pin, get_config, port, pin, *flags);
 
        if (api->pin_get_config == NULL) {
                SYS_PORT_TRACING_FUNC_EXIT(gpio_pin, get_config, port, pin, -ENOSYS);
                return -ENOSYS;
        }
 
        ret = api->pin_get_config(port, pin, flags);
        SYS_PORT_TRACING_FUNC_EXIT(gpio_pin, get_config, port, pin, ret);
        return ret;
}
#endif

static inline int gpio_pin_get_config_dt(const struct gpio_dt_spec *spec,
                                        gpio_flags_t *flags)
{
        return gpio_pin_get_config(spec->port, spec->pin, flags);
}

__syscall int gpio_port_get_raw(const struct device *port,
                                gpio_port_value_t *value);
 
static inline int z_impl_gpio_port_get_raw(const struct device *port, gpio_port_value_t *value)
{
        const struct gpio_driver_api *api = DEVICE_API_GET(gpio, port);
        int ret;
 
        SYS_PORT_TRACING_FUNC_ENTER(gpio_port, get_raw, port, value);
 
        ret = api->port_get_raw(port, value);
        SYS_PORT_TRACING_FUNC_EXIT(gpio_port, get_raw, port, ret);
        return ret;
}

static inline int gpio_port_get(const struct device *port,
                                gpio_port_value_t *value)
{
        const struct gpio_driver_data *const data =
                        (const struct gpio_driver_data *)port->data;
        int ret;
 
        ret = gpio_port_get_raw(port, value);
        if (ret == 0) {
                *value ^= data->invert;
        }
 
        return ret;
}

__syscall int gpio_port_set_masked_raw(const struct device *port,
                                       gpio_port_pins_t mask,
                                       gpio_port_value_t value);
 
static inline int z_impl_gpio_port_set_masked_raw(const struct device *port,
                                                  gpio_port_pins_t mask,
                                                  gpio_port_value_t value)
{
        const struct gpio_driver_api *api = DEVICE_API_GET(gpio, port);
        int ret;
 
        SYS_PORT_TRACING_FUNC_ENTER(gpio_port, set_masked_raw, port, mask, value);
 
        ret = api->port_set_masked_raw(port, mask, value);
        SYS_PORT_TRACING_FUNC_EXIT(gpio_port, set_masked_raw, port, ret);
        return ret;
}

static inline int gpio_port_set_masked(const struct device *port,
                                       gpio_port_pins_t mask,
                                       gpio_port_value_t value)
{
        const struct gpio_driver_data *const data =
                        (const struct gpio_driver_data *)port->data;
 
        value ^= data->invert;
 
        return gpio_port_set_masked_raw(port, mask, value);
}

__syscall int gpio_port_set_bits_raw(const struct device *port,
                                     gpio_port_pins_t pins);
 
static inline int z_impl_gpio_port_set_bits_raw(const struct device *port,
                                                gpio_port_pins_t pins)
{
        const struct gpio_driver_api *api = DEVICE_API_GET(gpio, port);
        int ret;
 
        SYS_PORT_TRACING_FUNC_ENTER(gpio_port, set_bits_raw, port, pins);
 
        ret = api->port_set_bits_raw(port, pins);
        SYS_PORT_TRACING_FUNC_EXIT(gpio_port, set_bits_raw, port, ret);
        return ret;
}

static inline int gpio_port_set_bits(const struct device *port,
                                     gpio_port_pins_t pins)
{
        return gpio_port_set_masked(port, pins, pins);
}

__syscall int gpio_port_clear_bits_raw(const struct device *port,
                                       gpio_port_pins_t pins);
 
static inline int z_impl_gpio_port_clear_bits_raw(const struct device *port,
                                                  gpio_port_pins_t pins)
{
        const struct gpio_driver_api *api = DEVICE_API_GET(gpio, port);
        int ret;
 
        SYS_PORT_TRACING_FUNC_ENTER(gpio_port, clear_bits_raw, port, pins);
 
        ret = api->port_clear_bits_raw(port, pins);
        SYS_PORT_TRACING_FUNC_EXIT(gpio_port, clear_bits_raw, port, ret);
        return ret;
}

static inline int gpio_port_clear_bits(const struct device *port,
                                       gpio_port_pins_t pins)
{
        return gpio_port_set_masked(port, pins, 0);
}

__syscall int gpio_port_toggle_bits(const struct device *port,
                                    gpio_port_pins_t pins);
 
static inline int z_impl_gpio_port_toggle_bits(const struct device *port,
                                               gpio_port_pins_t pins)
{
        const struct gpio_driver_api *api = DEVICE_API_GET(gpio, port);
        int ret;
 
        SYS_PORT_TRACING_FUNC_ENTER(gpio_port, toggle_bits, port, pins);
 
        ret = api->port_toggle_bits(port, pins);
        SYS_PORT_TRACING_FUNC_EXIT(gpio_port, toggle_bits, port, ret);
        return ret;
}

static inline int gpio_port_set_clr_bits_raw(const struct device *port,
                                             gpio_port_pins_t set_pins,
                                             gpio_port_pins_t clear_pins)
{
        __ASSERT((set_pins & clear_pins) == 0, "Set and Clear pins overlap");
 
        return gpio_port_set_masked_raw(port, set_pins | clear_pins, set_pins);
}

static inline int gpio_port_set_clr_bits(const struct device *port,
                                         gpio_port_pins_t set_pins,
                                         gpio_port_pins_t clear_pins)
{
        __ASSERT((set_pins & clear_pins) == 0, "Set and Clear pins overlap");
 
        return gpio_port_set_masked(port, set_pins | clear_pins, set_pins);
}

static inline int gpio_pin_get_raw(const struct device *port, gpio_pin_t pin)
{
        __unused const struct gpio_driver_config *const cfg =
                (const struct gpio_driver_config *)port->config;
        gpio_port_value_t value;
        int ret;
 
        __ASSERT((cfg->port_pin_mask & (gpio_port_pins_t)BIT(pin)) != 0U,
                 "Unsupported pin");
 
        ret = gpio_port_get_raw(port, &value);
        if (ret == 0) {
                ret = (value & (gpio_port_pins_t)BIT(pin)) != 0 ? 1 : 0;
        }
 
        return ret;
}

static inline int gpio_pin_get(const struct device *port, gpio_pin_t pin)
{
        __unused const struct gpio_driver_config *const cfg =
                (const struct gpio_driver_config *)port->config;
        gpio_port_value_t value;
        int ret;
 
        __ASSERT((cfg->port_pin_mask & (gpio_port_pins_t)BIT(pin)) != 0U,
                 "Unsupported pin");
 
        ret = gpio_port_get(port, &value);
        if (ret == 0) {
                ret = (value & (gpio_port_pins_t)BIT(pin)) != 0 ? 1 : 0;
        }
 
        return ret;
}

static inline int gpio_pin_get_dt(const struct gpio_dt_spec *spec)
{
        return gpio_pin_get(spec->port, spec->pin);
}

static inline int gpio_pin_set_raw(const struct device *port, gpio_pin_t pin,
                                   int value)
{
        __unused const struct gpio_driver_config *const cfg =
                (const struct gpio_driver_config *)port->config;
        int ret;
 
        __ASSERT((cfg->port_pin_mask & (gpio_port_pins_t)BIT(pin)) != 0U,
                 "Unsupported pin");
 
        if (value != 0) {
                ret = gpio_port_set_bits_raw(port, (gpio_port_pins_t)BIT(pin));
        } else {
                ret = gpio_port_clear_bits_raw(port, (gpio_port_pins_t)BIT(pin));
        }
 
        return ret;
}

static inline int gpio_pin_set(const struct device *port, gpio_pin_t pin,
                               int value)
{
        __unused const struct gpio_driver_config *const cfg =
                (const struct gpio_driver_config *)port->config;
        const struct gpio_driver_data *const data =
                        (const struct gpio_driver_data *)port->data;
 
        __ASSERT((cfg->port_pin_mask & (gpio_port_pins_t)BIT(pin)) != 0U,
                 "Unsupported pin");
 
        if (data->invert & (gpio_port_pins_t)BIT(pin)) {
                value = (value != 0) ? 0 : 1;
        }
 
        return gpio_pin_set_raw(port, pin, value);
}

static inline int gpio_pin_set_dt(const struct gpio_dt_spec *spec, int value)
{
        return gpio_pin_set(spec->port, spec->pin, value);
}

static inline int gpio_pin_toggle(const struct device *port, gpio_pin_t pin)
{
        __unused const struct gpio_driver_config *const cfg =
                (const struct gpio_driver_config *)port->config;
 
        __ASSERT((cfg->port_pin_mask & (gpio_port_pins_t)BIT(pin)) != 0U,
                 "Unsupported pin");
 
        return gpio_port_toggle_bits(port, (gpio_port_pins_t)BIT(pin));
}

static inline int gpio_pin_toggle_dt(const struct gpio_dt_spec *spec)
{
        return gpio_pin_toggle(spec->port, spec->pin);
}

static inline void gpio_init_callback(struct gpio_callback *callback,
                                      gpio_callback_handler_t handler,
                                      gpio_port_pins_t pin_mask)
{
        SYS_PORT_TRACING_FUNC_ENTER(gpio, init_callback, callback, handler, pin_mask);
 
        __ASSERT(callback, "Callback pointer should not be NULL");
        __ASSERT(handler, "Callback handler pointer should not be NULL");
 
        callback->handler = handler;
        callback->pin_mask = pin_mask;
 
        SYS_PORT_TRACING_FUNC_EXIT(gpio, init_callback, callback);
}

static inline int gpio_add_callback(const struct device *port,
                                    struct gpio_callback *callback)
{
        const struct gpio_driver_api *api = DEVICE_API_GET(gpio, port);
        int ret;
 
        SYS_PORT_TRACING_FUNC_ENTER(gpio, add_callback, port, callback);
 
        if (api->manage_callback == NULL) {
                SYS_PORT_TRACING_FUNC_EXIT(gpio, add_callback, port, -ENOSYS);
                return -ENOSYS;
        }
 
        ret = api->manage_callback(port, callback, true);
        SYS_PORT_TRACING_FUNC_EXIT(gpio, add_callback, port, ret);
        return ret;
}

static inline int gpio_add_callback_dt(const struct gpio_dt_spec *spec,
                                       struct gpio_callback *callback)
{
        return gpio_add_callback(spec->port, callback);
}

static inline int gpio_remove_callback(const struct device *port,
                                       struct gpio_callback *callback)
{
        const struct gpio_driver_api *api = DEVICE_API_GET(gpio, port);
        int ret;
 
        SYS_PORT_TRACING_FUNC_ENTER(gpio, remove_callback, port, callback);
 
        if (api->manage_callback == NULL) {
                SYS_PORT_TRACING_FUNC_EXIT(gpio, remove_callback, port, -ENOSYS);
                return -ENOSYS;
        }
 
        ret = api->manage_callback(port, callback, false);
        SYS_PORT_TRACING_FUNC_EXIT(gpio, remove_callback, port, ret);
        return ret;
}

static inline int gpio_remove_callback_dt(const struct gpio_dt_spec *spec,
                                          struct gpio_callback *callback)
{
        return gpio_remove_callback(spec->port, callback);
}

__syscall int gpio_get_pending_int(const struct device *dev);
 
static inline int z_impl_gpio_get_pending_int(const struct device *dev)
{
        const struct gpio_driver_api *api = DEVICE_API_GET(gpio, dev);
        int ret;
 
        SYS_PORT_TRACING_FUNC_ENTER(gpio, get_pending_int, dev);
 
        if (api->get_pending_int == NULL) {
                SYS_PORT_TRACING_FUNC_EXIT(gpio, get_pending_int, dev, -ENOSYS);
                return -ENOSYS;
        }
 
        ret = api->get_pending_int(dev);
        SYS_PORT_TRACING_FUNC_EXIT(gpio, get_pending_int, dev, ret);
        return ret;
}

 
#ifdef __cplusplus
}
#endif
 
#include <zephyr/syscalls/gpio.h>
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_GPIO_H_ */