ipm.h

Go to the documentation of this file.

/*
 * Copyright (c) 2015 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_DRIVERS_IPM_H_
#define ZEPHYR_INCLUDE_DRIVERS_IPM_H_

 
#include <zephyr/kernel.h>
#include <zephyr/device.h>
 
#ifdef __cplusplus
extern "C" {
#endif

typedef void (*ipm_callback_t)(const struct device *ipmdev, void *user_data,
                               uint32_t id, volatile void *data);


typedef int (*ipm_send_t)(const struct device *ipmdev, int wait, uint32_t id,
                          const void *data, int size);

typedef int (*ipm_max_data_size_get_t)(const struct device *ipmdev);

typedef uint32_t (*ipm_max_id_val_get_t)(const struct device *ipmdev);

typedef void (*ipm_register_callback_t)(const struct device *port,
                                        ipm_callback_t cb,
                                        void *user_data);

typedef int (*ipm_set_enabled_t)(const struct device *ipmdev, int enable);

typedef void (*ipm_complete_t)(const struct device *ipmdev);

__subsystem struct ipm_driver_api {
        ipm_send_t send;
        ipm_register_callback_t register_callback;
        ipm_max_data_size_get_t max_data_size_get;
        ipm_max_id_val_get_t max_id_val_get;
        ipm_set_enabled_t set_enabled;
#if defined(CONFIG_IPM_CALLBACK_ASYNC) || defined(__DOXYGEN__)
        ipm_complete_t complete;
#endif
};


__syscall int ipm_send(const struct device *ipmdev, int wait, uint32_t id,
                       const void *data, int size);
 
static inline int z_impl_ipm_send(const struct device *ipmdev, int wait,
                                  uint32_t id,
                                  const void *data, int size)
{
        const struct ipm_driver_api *api =
                (const struct ipm_driver_api *)ipmdev->api;
 
        return api->send(ipmdev, wait, id, data, size);
}

static inline void ipm_register_callback(const struct device *ipmdev,
                                         ipm_callback_t cb, void *user_data)
{
        const struct ipm_driver_api *api =
                (const struct ipm_driver_api *)ipmdev->api;
 
        api->register_callback(ipmdev, cb, user_data);
}

__syscall int ipm_max_data_size_get(const struct device *ipmdev);
 
static inline int z_impl_ipm_max_data_size_get(const struct device *ipmdev)
{
        const struct ipm_driver_api *api =
                (const struct ipm_driver_api *)ipmdev->api;
 
        return api->max_data_size_get(ipmdev);
}
 

__syscall uint32_t ipm_max_id_val_get(const struct device *ipmdev);
 
static inline uint32_t z_impl_ipm_max_id_val_get(const struct device *ipmdev)
{
        const struct ipm_driver_api *api =
                (const struct ipm_driver_api *)ipmdev->api;
 
        return api->max_id_val_get(ipmdev);
}

__syscall int ipm_set_enabled(const struct device *ipmdev, int enable);
 
static inline int z_impl_ipm_set_enabled(const struct device *ipmdev,
                                         int enable)
{
        const struct ipm_driver_api *api =
                (const struct ipm_driver_api *)ipmdev->api;
 
        return api->set_enabled(ipmdev, enable);
}

__syscall void ipm_complete(const struct device *ipmdev);
 
static inline void z_impl_ipm_complete(const struct device *ipmdev)
{
#ifdef CONFIG_IPM_CALLBACK_ASYNC
        const struct ipm_driver_api *api =
                (const struct ipm_driver_api *)ipmdev->api;
 
        if (api->complete != NULL) {
                api->complete(ipmdev);
        }
#endif
}
 
#ifdef __cplusplus
}
#endif

 
#include <zephyr/syscalls/ipm.h>
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_IPM_H_ */