mbox.h

Go to the documentation of this file.

/*
 * Copyright (c) 2021 Carlo Caione <ccaione@baylibre.com>
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_DRIVERS_MBOX_H_
#define ZEPHYR_INCLUDE_DRIVERS_MBOX_H_
 
#include <errno.h>
#include <stdint.h>
#include <stdlib.h>
 
#include <zephyr/device.h>
#include <zephyr/devicetree.h>
 
#ifdef __cplusplus
extern "C" {
#endif


typedef uint32_t mbox_channel_id_t;

struct mbox_msg {
        const void *data;
        size_t size;
};

struct mbox_dt_spec {
        const struct device *dev;
        mbox_channel_id_t channel_id;
};

#define MBOX_DT_SPEC_GET(node_id, name)                                        \
        {                                                                      \
                .dev = DEVICE_DT_GET(DT_MBOX_CTLR_BY_NAME(node_id, name)),     \
                .channel_id = DT_MBOX_CHANNEL_BY_NAME(node_id, name),          \
        }

#define MBOX_DT_SPEC_INST_GET(inst, name)                                      \
        MBOX_DT_SPEC_GET(DT_DRV_INST(inst), name)


typedef void (*mbox_callback_t)(const struct device *dev,
                                mbox_channel_id_t channel_id, void *user_data,
                                struct mbox_msg *data);

typedef int (*mbox_send_t)(const struct device *dev,
                           mbox_channel_id_t channel_id,
                           const struct mbox_msg *msg);

typedef int (*mbox_mtu_get_t)(const struct device *dev);

typedef int (*mbox_register_callback_t)(const struct device *dev,
                                        mbox_channel_id_t channel_id,
                                        mbox_callback_t cb, void *user_data);

typedef int (*mbox_set_enabled_t)(const struct device *dev,
                                  mbox_channel_id_t channel_id, bool enabled);

typedef uint32_t (*mbox_max_channels_get_t)(const struct device *dev);

__subsystem struct mbox_driver_api {
        mbox_send_t send;
        mbox_register_callback_t register_callback;
        mbox_mtu_get_t mtu_get;
        mbox_max_channels_get_t max_channels_get;
        mbox_set_enabled_t set_enabled;
};


static inline bool mbox_is_ready_dt(const struct mbox_dt_spec *spec)
{
        return device_is_ready(spec->dev);
}

__syscall int mbox_send(const struct device *dev, mbox_channel_id_t channel_id,
                        const struct mbox_msg *msg);
 
static inline int z_impl_mbox_send(const struct device *dev,
                                   mbox_channel_id_t channel_id,
                                   const struct mbox_msg *msg)
{
        const struct mbox_driver_api *api = DEVICE_API_GET(mbox, dev);
 
        if (api->send == NULL) {
                return -ENOSYS;
        }
 
        return api->send(dev, channel_id, msg);
}

static inline int mbox_send_dt(const struct mbox_dt_spec *spec,
                               const struct mbox_msg *msg)
{
        return mbox_send(spec->dev, spec->channel_id, msg);
}

static inline int mbox_register_callback(const struct device *dev,
                                         mbox_channel_id_t channel_id,
                                         mbox_callback_t cb,
                                         void *user_data)
{
        const struct mbox_driver_api *api = DEVICE_API_GET(mbox, dev);
 
        if (api->register_callback == NULL) {
                return -ENOSYS;
        }
 
        return api->register_callback(dev, channel_id, cb, user_data);
}

static inline int mbox_register_callback_dt(const struct mbox_dt_spec *spec,
                                            mbox_callback_t cb, void *user_data)
{
        return mbox_register_callback(spec->dev, spec->channel_id, cb,
                                      user_data);
}

__syscall int mbox_mtu_get(const struct device *dev);
 
static inline int z_impl_mbox_mtu_get(const struct device *dev)
{
        const struct mbox_driver_api *api = DEVICE_API_GET(mbox, dev);
 
        if (api->mtu_get == NULL) {
                return -ENOSYS;
        }
 
        return api->mtu_get(dev);
}

static inline int mbox_mtu_get_dt(const struct mbox_dt_spec *spec)
{
        return mbox_mtu_get(spec->dev);
}

__syscall int mbox_set_enabled(const struct device *dev,
                               mbox_channel_id_t channel_id, bool enabled);
 
static inline int z_impl_mbox_set_enabled(const struct device *dev,
                                          mbox_channel_id_t channel_id,
                                          bool enabled)
{
        const struct mbox_driver_api *api = DEVICE_API_GET(mbox, dev);
 
        if (api->set_enabled == NULL) {
                return -ENOSYS;
        }
 
        return api->set_enabled(dev, channel_id, enabled);
}

static inline int mbox_set_enabled_dt(const struct mbox_dt_spec *spec,
                                      bool enabled)
{
        return mbox_set_enabled(spec->dev, spec->channel_id, enabled);
}

__syscall uint32_t mbox_max_channels_get(const struct device *dev);
 
static inline uint32_t z_impl_mbox_max_channels_get(const struct device *dev)
{
        const struct mbox_driver_api *api = DEVICE_API_GET(mbox, dev);
 
        if (api->max_channels_get == NULL) {
                return -ENOSYS;
        }
 
        return api->max_channels_get(dev);
}

static inline int mbox_max_channels_get_dt(const struct mbox_dt_spec *spec)
{
        return mbox_max_channels_get(spec->dev);
}

 
#ifdef __cplusplus
}
#endif
 
#include <zephyr/syscalls/mbox.h>
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_MBOX_H_ */