bbram.h

Go to the documentation of this file.

/*
 * Copyright (c) 2021 Google Inc
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_DRIVERS_BBRAM_H
#define ZEPHYR_INCLUDE_DRIVERS_BBRAM_H
 
#include <errno.h>
 
#include <zephyr/device.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef int (*bbram_api_check_invalid_t)(const struct device *dev);
 
typedef int (*bbram_api_check_standby_power_t)(const struct device *dev);
 
typedef int (*bbram_api_check_power_t)(const struct device *dev);
 
typedef int (*bbram_api_get_size_t)(const struct device *dev, size_t *size);
 
typedef int (*bbram_api_read_t)(const struct device *dev, size_t offset, size_t size,
                              uint8_t *data);
 
typedef int (*bbram_api_write_t)(const struct device *dev, size_t offset, size_t size,
                               const uint8_t *data);
 
__subsystem struct bbram_driver_api {
        bbram_api_check_invalid_t check_invalid;
        bbram_api_check_standby_power_t check_standby_power;
        bbram_api_check_power_t check_power;
        bbram_api_get_size_t get_size;
        bbram_api_read_t read;
        bbram_api_write_t write;
};
 
__syscall int bbram_check_invalid(const struct device *dev);
 
static inline int z_impl_bbram_check_invalid(const struct device *dev)
{
        const struct bbram_driver_api *api =
                (const struct bbram_driver_api *)dev->api;
 
        if (!api->check_invalid) {
                return -ENOTSUP;
        }
 
        return api->check_invalid(dev);
}
 
__syscall int bbram_check_standby_power(const struct device *dev);
 
static inline int z_impl_bbram_check_standby_power(const struct device *dev)
{
        const struct bbram_driver_api *api =
                (const struct bbram_driver_api *)dev->api;
 
        if (!api->check_standby_power) {
                return -ENOTSUP;
        }
 
        return api->check_standby_power(dev);
}
 
__syscall int bbram_check_power(const struct device *dev);
 
static inline int z_impl_bbram_check_power(const struct device *dev)
{
        const struct bbram_driver_api *api =
                (const struct bbram_driver_api *)dev->api;
 
        if (!api->check_power) {
                return -ENOTSUP;
        }
 
        return api->check_power(dev);
}
 
__syscall int bbram_get_size(const struct device *dev, size_t *size);
 
static inline int z_impl_bbram_get_size(const struct device *dev, size_t *size)
{
        const struct bbram_driver_api *api =
                (const struct bbram_driver_api *)dev->api;
 
        if (!api->get_size) {
                return -ENOTSUP;
        }
 
        return api->get_size(dev, size);
}
 
__syscall int bbram_read(const struct device *dev, size_t offset, size_t size,
                         uint8_t *data);
 
static inline int z_impl_bbram_read(const struct device *dev, size_t offset,
                                    size_t size, uint8_t *data)
{
        const struct bbram_driver_api *api =
                (const struct bbram_driver_api *)dev->api;
 
        if (!api->read) {
                return -ENOTSUP;
        }
 
        return api->read(dev, offset, size, data);
}
 
__syscall int bbram_write(const struct device *dev, size_t offset, size_t size,
                          const uint8_t *data);
 
static inline int z_impl_bbram_write(const struct device *dev, size_t offset,
                                     size_t size, const uint8_t *data)
{
        const struct bbram_driver_api *api =
                (const struct bbram_driver_api *)dev->api;
 
        if (!api->write) {
                return -ENOTSUP;
        }
 
        return api->write(dev, offset, size, data);
}
 
int bbram_emul_set_invalid(const struct device *dev, bool is_invalid);
 
int bbram_emul_set_standby_power_state(const struct device *dev, bool failure);
 
int bbram_emul_set_power_state(const struct device *dev, bool failure);
 
#ifdef __cplusplus
}
#endif
 
#include <zephyr/syscalls/bbram.h>
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_BBRAM_H */