pinctrl.h

Go to the documentation of this file.

/*
 * Copyright (c) 2021 Nordic Semiconductor ASA
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_DRIVERS_PINCTRL_H_
#define ZEPHYR_INCLUDE_DRIVERS_PINCTRL_H_
 
#include <errno.h>
 
#include <zephyr/device.h>
#include <zephyr/devicetree.h>
#include <zephyr/devicetree/pinctrl.h>
#include <pinctrl_soc.h>
#include <zephyr/sys/util.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define PINCTRL_STATE_DEFAULT 0U
#define PINCTRL_STATE_SLEEP 1U
 
#define PINCTRL_STATE_PRIV_START 2U
 
struct pinctrl_state {
        const pinctrl_soc_pin_t *pins;
        uint8_t pin_cnt;
        uint8_t id;
};
 
struct pinctrl_dev_config {
#if defined(CONFIG_PINCTRL_STORE_REG) || defined(__DOXYGEN__)
        uintptr_t reg;
#endif /* defined(CONFIG_PINCTRL_STORE_REG) || defined(__DOXYGEN__) */
        const struct pinctrl_state *states;
        uint8_t state_cnt;
};
 
#define PINCTRL_REG_NONE 0U
 
#ifndef CONFIG_PM_DEVICE
#define PINCTRL_SKIP_SLEEP 1
#endif
 
#define Z_PINCTRL_STATE_ID(state_idx, node_id)                                 \
        _CONCAT(PINCTRL_STATE_,                                                \
                DT_PINCTRL_IDX_TO_NAME_UPPER_TOKEN(node_id, state_idx))
 
#define Z_PINCTRL_DEV_CONFIG_NAME(node_id) \
        _CONCAT(__pinctrl_dev_config, DEVICE_DT_NAME_GET(node_id))
 
#define Z_PINCTRL_STATES_NAME(node_id) \
        _CONCAT(__pinctrl_states, DEVICE_DT_NAME_GET(node_id))
 
#define Z_PINCTRL_STATE_PINS_NAME(state_idx, node_id) \
        _CONCAT(__pinctrl_state_pins_ ## state_idx, DEVICE_DT_NAME_GET(node_id))
 
#define Z_PINCTRL_SKIP_STATE(state_idx, node_id)                               \
        _CONCAT(PINCTRL_SKIP_,                                                 \
                DT_PINCTRL_IDX_TO_NAME_UPPER_TOKEN(node_id, state_idx))
 
#define Z_PINCTRL_STATE_PINS_DEFINE(state_idx, node_id)                        \
        COND_CODE_1(Z_PINCTRL_SKIP_STATE(state_idx, node_id), (),              \
        (static const pinctrl_soc_pin_t                                        \
        Z_PINCTRL_STATE_PINS_NAME(state_idx, node_id)[] =                      \
        Z_PINCTRL_STATE_PINS_INIT(node_id, pinctrl_ ## state_idx)))
 
#define Z_PINCTRL_STATE_INIT(state_idx, node_id)                               \
        COND_CODE_1(Z_PINCTRL_SKIP_STATE(state_idx, node_id), (),              \
        ({                                                                     \
                .id = Z_PINCTRL_STATE_ID(state_idx, node_id),                  \
                .pins = Z_PINCTRL_STATE_PINS_NAME(state_idx, node_id),         \
                .pin_cnt = ARRAY_SIZE(Z_PINCTRL_STATE_PINS_NAME(state_idx,     \
                                                                node_id))      \
        }))
 
#define Z_PINCTRL_STATES_DEFINE(node_id)                                       \
        static const struct pinctrl_state                                      \
        Z_PINCTRL_STATES_NAME(node_id)[] = {                                   \
                LISTIFY(DT_NUM_PINCTRL_STATES(node_id),                        \
                             Z_PINCTRL_STATE_INIT, (,), node_id)               \
        };
 
#ifdef CONFIG_PINCTRL_STORE_REG
#define Z_PINCTRL_DEV_CONFIG_INIT(node_id)                                     \
        {                                                                      \
                .reg = DT_REG_ADDR(node_id),                                   \
                .states = Z_PINCTRL_STATES_NAME(node_id),                      \
                .state_cnt = ARRAY_SIZE(Z_PINCTRL_STATES_NAME(node_id)),       \
        }
#else
#define Z_PINCTRL_DEV_CONFIG_INIT(node_id)                                     \
        {                                                                      \
                .states = Z_PINCTRL_STATES_NAME(node_id),                      \
                .state_cnt = ARRAY_SIZE(Z_PINCTRL_STATES_NAME(node_id)),       \
        }
#endif
 
#ifdef CONFIG_PINCTRL_NON_STATIC
#define Z_PINCTRL_DEV_CONFIG_STATIC
#else
#define Z_PINCTRL_DEV_CONFIG_STATIC static
#endif
 
#ifdef CONFIG_PINCTRL_DYNAMIC
#define Z_PINCTRL_DEV_CONFIG_CONST
#else
#define Z_PINCTRL_DEV_CONFIG_CONST const
#endif
 
#if defined(CONFIG_PINCTRL_NON_STATIC) || defined(__DOXYGEN__)
#define PINCTRL_DT_DEV_CONFIG_DECLARE(node_id)                                 \
        extern Z_PINCTRL_DEV_CONFIG_CONST struct pinctrl_dev_config            \
        Z_PINCTRL_DEV_CONFIG_NAME(node_id)
#endif /* defined(CONFIG_PINCTRL_NON_STATIC) || defined(__DOXYGEN__) */
 
#define PINCTRL_DT_DEFINE(node_id)                                             \
        LISTIFY(DT_NUM_PINCTRL_STATES(node_id),                                \
                     Z_PINCTRL_STATE_PINS_DEFINE, (;), node_id);               \
        Z_PINCTRL_STATES_DEFINE(node_id)                                       \
        Z_PINCTRL_DEV_CONFIG_STATIC Z_PINCTRL_DEV_CONFIG_CONST                 \
        struct pinctrl_dev_config Z_PINCTRL_DEV_CONFIG_NAME(node_id) =         \
        Z_PINCTRL_DEV_CONFIG_INIT(node_id)
 
#define PINCTRL_DT_INST_DEFINE(inst) PINCTRL_DT_DEFINE(DT_DRV_INST(inst))
 
#define PINCTRL_DT_DEV_CONFIG_GET(node_id) &Z_PINCTRL_DEV_CONFIG_NAME(node_id)
 
#define PINCTRL_DT_INST_DEV_CONFIG_GET(inst) \
        PINCTRL_DT_DEV_CONFIG_GET(DT_DRV_INST(inst))
 
int pinctrl_lookup_state(const struct pinctrl_dev_config *config, uint8_t id,
                         const struct pinctrl_state **state);
 
int pinctrl_configure_pins(const pinctrl_soc_pin_t *pins, uint8_t pin_cnt,
                           uintptr_t reg);
 
static inline int pinctrl_apply_state_direct(
        const struct pinctrl_dev_config *config,
        const struct pinctrl_state *state)
{
        uintptr_t reg;
 
#ifdef CONFIG_PINCTRL_STORE_REG
        reg = config->reg;
#else
        ARG_UNUSED(config);
        reg = PINCTRL_REG_NONE;
#endif
 
        return pinctrl_configure_pins(state->pins, state->pin_cnt, reg);
}
 
static inline int pinctrl_apply_state(const struct pinctrl_dev_config *config,
                                      uint8_t id)
{
        int ret;
        const struct pinctrl_state *state;
 
        ret = pinctrl_lookup_state(config, id, &state);
        if (ret < 0) {
                return ret;
        }
 
        return pinctrl_apply_state_direct(config, state);
}
 
#if defined(CONFIG_PINCTRL_DYNAMIC) || defined(__DOXYGEN__)
#define PINCTRL_DT_STATE_PINS_DEFINE(node_id, prop)                            \
        static const pinctrl_soc_pin_t prop ## _pins[] =                       \
        Z_PINCTRL_STATE_PINS_INIT(node_id, prop);                              \
 
#define PINCTRL_DT_STATE_INIT(prop, state)                                     \
        {                                                                      \
                .id = state,                                                   \
                .pins = prop ## _pins,                                         \
                .pin_cnt = ARRAY_SIZE(prop ## _pins)                           \
        }
 
int pinctrl_update_states(struct pinctrl_dev_config *config,
                          const struct pinctrl_state *states,
                          uint8_t state_cnt);
 
#else
static inline int pinctrl_update_states(
        struct pinctrl_dev_config *config,
        const struct pinctrl_state *states, uint8_t state_cnt)
{
        ARG_UNUSED(config);
        ARG_UNUSED(states);
        ARG_UNUSED(state_cnt);
        return -ENOSYS;
}
#endif /* defined(CONFIG_PINCTRL_DYNAMIC) || defined(__DOXYGEN__) */
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_PINCTRL_H_ */