mux.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2026 NXP
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_DRIVERS_MUX_H_
#define ZEPHYR_INCLUDE_DRIVERS_MUX_H_

 
#include <errno.h>
#include <stddef.h>
 
#include <zephyr/types.h>
#include <zephyr/device.h>
#include <zephyr/devicetree.h>
#include <zephyr/devicetree/mux.h>
#include <zephyr/sys/util.h>
 
#ifdef __cplusplus
extern "C" {
#endif

struct mux_control {
        const uint32_t *cells;
        size_t len;
};

struct mux_state {
        const struct mux_control *control;
        uint32_t state;
};

 
#define Z_MUX_CTRL_DEFINE_BY_IDX(node_id, idx)                                                  \
        static const uint32_t Z_MUX_CTRL_CELLS_NAME(node_id, idx)[] = {                         \
                COND_CODE_1(IS_EQ(Z_MUX_PHA_NUM_CELLS(node_id, mux_controls, idx), 0),          \
                            (0),                                                                \
                            (DT_FOREACH_PHA_CELL_BY_IDX_SEP(node_id, mux_controls, idx,         \
                                                            Z_MUX_CELL_VAL, (,))))              \
        };                                                                                      \
        static const struct mux_control Z_MUX_CTRL_OBJ_NAME(node_id, idx) = {                   \
                .cells = Z_MUX_CTRL_CELLS_NAME(node_id, idx),                                   \
                .len = Z_MUX_PHA_NUM_CELLS(node_id, mux_controls, idx),                         \
        }
 
#define Z_MUX_STATE_DEFINE_BY_IDX(node_id, idx)                                                 \
        static const uint32_t Z_MUX_STATE_CELLS_NAME(node_id, idx)[] = {                        \
                COND_CODE_1(IS_EQ(Z_MUX_PHA_NUM_CELLS(node_id, mux_states, idx), 1),            \
                            (0),                                                                \
                            (Z_MUX_STATE_ADDRESSING_CELLS(node_id, idx)))                       \
        };                                                                                      \
        static const struct mux_control Z_MUX_STATE_CTRL_NAME(node_id, idx) = {                 \
                .cells = Z_MUX_STATE_CELLS_NAME(node_id, idx),                                  \
                .len = Z_MUX_PHA_NUM_CELLS(node_id, mux_states, idx) - 1,                       \
        };                                                                                      \
        static const struct mux_state Z_MUX_STATE_OBJ_NAME(node_id, idx) = {                    \
                .control = &Z_MUX_STATE_CTRL_NAME(node_id, idx),                                \
                .state = Z_MUX_STATE_LAST_CELL(node_id, idx),                                   \
        }


#define MUX_CONTROL_DT_SPEC_DEFINE_BY_IDX(node_id, idx) Z_MUX_CTRL_DEFINE_BY_IDX(node_id, idx)

#define MUX_CONTROL_DT_SPEC_DEFINE(node_id) MUX_CONTROL_DT_SPEC_DEFINE_BY_IDX(node_id, 0)

#define MUX_CONTROL_DT_SPEC_DEFINE_BY_NAME(node_id, name) \
        MUX_CONTROL_DT_SPEC_DEFINE_BY_IDX(node_id,        \
                DT_PHA_ELEM_IDX_BY_NAME(node_id, mux_controls, name))

#define MUX_STATE_DT_SPEC_DEFINE_BY_IDX(node_id, idx) Z_MUX_STATE_DEFINE_BY_IDX(node_id, idx)

#define MUX_STATE_DT_SPEC_DEFINE(node_id) MUX_STATE_DT_SPEC_DEFINE_BY_IDX(node_id, 0)

#define MUX_STATE_DT_SPEC_DEFINE_BY_NAME(node_id, name) \
        MUX_STATE_DT_SPEC_DEFINE_BY_IDX(node_id,        \
                DT_PHA_ELEM_IDX_BY_NAME(node_id, mux_states, name))

 
typedef int (*mux_control_set_fn)(const struct device *dev,
                                  const struct mux_control *control,
                                  uint32_t state);
 
typedef int (*mux_state_get_fn)(const struct device *dev,
                                const struct mux_control *control,
                                uint32_t *state);
 
typedef int (*mux_control_disconnect_fn)(const struct device *dev,
                                         const struct mux_control *control);


__subsystem struct mux_control_driver_api {
        mux_control_set_fn set;
        mux_state_get_fn get_state;
        mux_control_disconnect_fn disconnect;
};

__syscall int mux_control_set(const struct device *dev,
                              const struct mux_control *control,
                              uint32_t state);
 
static inline int z_impl_mux_control_set(const struct device *dev,
                                         const struct mux_control *control,
                                         uint32_t state)
{
        const struct mux_control_driver_api *api = DEVICE_API_GET(mux_control, dev);
 
        return api->set(dev, control, state);
}

__syscall int mux_state_apply(const struct device *dev,
                              const struct mux_state *mstate);
 
static inline int z_impl_mux_state_apply(const struct device *dev,
                                         const struct mux_state *mstate)
{
        const struct mux_control_driver_api *api = DEVICE_API_GET(mux_control, dev);
 
        return api->set(dev, mstate->control, mstate->state);
}

__syscall int mux_state_get(const struct device *dev,
                            const struct mux_control *control,
                            uint32_t *state);
 
static inline int z_impl_mux_state_get(const struct device *dev,
                                       const struct mux_control *control,
                                       uint32_t *state)
{
        const struct mux_control_driver_api *api = DEVICE_API_GET(mux_control, dev);
 
        if (api->get_state == NULL) {
                return -ENOSYS;
        }
 
        return api->get_state(dev, control, state);
}

__syscall int mux_control_disconnect(const struct device *dev,
                                     const struct mux_control *control);
 
static inline int z_impl_mux_control_disconnect(const struct device *dev,
                                                const struct mux_control *control)
{
        const struct mux_control_driver_api *api = DEVICE_API_GET(mux_control, dev);
 
        if (api->disconnect == NULL) {
                return -ENOSYS;
        }
 
        return api->disconnect(dev, control);
}
 
#ifdef __cplusplus
}
#endif

 
#include <zephyr/syscalls/mux.h>
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_MUX_H_ */