edac.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_DRIVERS_EDAC_H_
#define ZEPHYR_INCLUDE_DRIVERS_EDAC_H_
 
#include <errno.h>
 
#include <sys/types.h>
 
enum edac_error_type {
        EDAC_ERROR_TYPE_DRAM_COR = BIT(0),
        EDAC_ERROR_TYPE_DRAM_UC = BIT(1)
};
 
typedef void (*edac_notify_callback_f)(const struct device *dev, void *data);
 
__subsystem struct edac_driver_api {
        /* Error Injection API is disabled by default */
        int (*inject_set_param1)(const struct device *dev, uint64_t value);
        int (*inject_get_param1)(const struct device *dev, uint64_t *value);
        int (*inject_set_param2)(const struct device *dev, uint64_t value);
        int (*inject_get_param2)(const struct device *dev, uint64_t *value);
        int (*inject_set_error_type)(const struct device *dev, uint32_t value);
        int (*inject_get_error_type)(const struct device *dev, uint32_t *value);
        int (*inject_error_trigger)(const struct device *dev);
 
        /* Error Logging  API */
        int (*ecc_error_log_get)(const struct device *dev, uint64_t *value);
        int (*ecc_error_log_clear)(const struct device *dev);
        int (*parity_error_log_get)(const struct device *dev, uint64_t *value);
        int (*parity_error_log_clear)(const struct device *dev);
 
        /* Error stats API */
        int (*errors_cor_get)(const struct device *dev);
        int (*errors_uc_get)(const struct device *dev);
 
        /* Notification callback API */
        int (*notify_cb_set)(const struct device *dev,
                             edac_notify_callback_f cb);
};
 
static inline int edac_inject_set_param1(const struct device *dev,
                                         uint64_t value)
{
        const struct edac_driver_api *api =
                (const struct edac_driver_api *)dev->api;
 
        if (api->inject_set_param1 == NULL) {
                return -ENOSYS;
        }
 
        return api->inject_set_param1(dev, value);
}
 
static inline int edac_inject_get_param1(const struct device *dev,
                                         uint64_t *value)
{
        const struct edac_driver_api *api =
                (const struct edac_driver_api *)dev->api;
 
        if (api->inject_get_param1 == NULL) {
                return -ENOSYS;
        }
 
        return api->inject_get_param1(dev, value);
 
}
 
static inline int edac_inject_set_param2(const struct device *dev,
                                         uint64_t value)
{
        const struct edac_driver_api *api =
                (const struct edac_driver_api *)dev->api;
 
        if (api->inject_set_param2 == NULL) {
                return -ENOSYS;
        }
 
        return api->inject_set_param2(dev, value);
}
 
static inline int edac_inject_get_param2(const struct device *dev,
                                         uint64_t *value)
{
        const struct edac_driver_api *api =
                (const struct edac_driver_api *)dev->api;
 
        if (api->inject_get_param2 == NULL) {
                return -ENOSYS;
        }
 
        return api->inject_get_param2(dev, value);
}
 
static inline int edac_inject_set_error_type(const struct device *dev,
                                             uint32_t error_type)
{
        const struct edac_driver_api *api =
                (const struct edac_driver_api *)dev->api;
 
        if (api->inject_set_error_type == NULL) {
                return -ENOSYS;
        }
 
        return api->inject_set_error_type(dev, error_type);
}
 
static inline int edac_inject_get_error_type(const struct device *dev,
                                             uint32_t *error_type)
{
        const struct edac_driver_api *api =
                (const struct edac_driver_api *)dev->api;
 
        if (api->inject_get_error_type == NULL) {
                return -ENOSYS;
        }
 
        return api->inject_get_error_type(dev, error_type);
}
 
static inline int edac_inject_error_trigger(const struct device *dev)
{
        const struct edac_driver_api *api =
                (const struct edac_driver_api *)dev->api;
 
        if (api->inject_error_trigger == NULL) {
                return -ENOSYS;
        }
 
        return api->inject_error_trigger(dev);
}
 
 /* End of EDAC Optional Interfaces */
 
static inline int edac_ecc_error_log_get(const struct device *dev,
                                         uint64_t *value)
{
        const struct edac_driver_api *api =
                (const struct edac_driver_api *)dev->api;
 
        if (api->ecc_error_log_get == NULL) {
                return -ENOSYS;
        }
 
        return api->ecc_error_log_get(dev, value);
}
 
static inline int edac_ecc_error_log_clear(const struct device *dev)
{
        const struct edac_driver_api *api =
                (const struct edac_driver_api *)dev->api;
 
        if (api->ecc_error_log_clear == NULL) {
                return -ENOSYS;
        }
 
        return api->ecc_error_log_clear(dev);
}
 
static inline int edac_parity_error_log_get(const struct device *dev,
                                            uint64_t *value)
{
        const struct edac_driver_api *api =
                (const struct edac_driver_api *)dev->api;
 
        if (api->parity_error_log_get == NULL) {
                return -ENOSYS;
        }
 
        return api->parity_error_log_get(dev, value);
}
 
static inline int edac_parity_error_log_clear(const struct device *dev)
{
        const struct edac_driver_api *api =
                (const struct edac_driver_api *)dev->api;
 
        if (api->parity_error_log_clear == NULL) {
                return -ENOSYS;
        }
 
        return api->parity_error_log_clear(dev);
}
 
static inline int edac_errors_cor_get(const struct device *dev)
{
        const struct edac_driver_api *api =
                (const struct edac_driver_api *)dev->api;
 
        if (api->errors_cor_get == NULL) {
                return -ENOSYS;
        }
 
        return api->errors_cor_get(dev);
}
 
static inline int edac_errors_uc_get(const struct device *dev)
{
        const struct edac_driver_api *api =
                (const struct edac_driver_api *)dev->api;
 
        if (api->errors_uc_get == NULL) {
                return -ENOSYS;
        }
 
        return api->errors_uc_get(dev);
}
 
static inline int edac_notify_callback_set(const struct device *dev,
                                           edac_notify_callback_f cb)
{
        const struct edac_driver_api *api = (const struct edac_driver_api *)dev->api;
 
        if (api->notify_cb_set == NULL) {
                return -ENOSYS;
        }
 
        return api->notify_cb_set(dev, cb);
}
 
 
 /* End of EDAC Mandatory Interfaces */
 
 /* End of EDAC API */
 
#endif  /* ZEPHYR_INCLUDE_DRIVERS_EDAC_H_ */