blob: e54cfc601a480cb72ca7cb130750a887d76995e6 [file] [log] [blame]
/*
* Copyright (c) 2020 Intel Corporation
*
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @file
* @brief EDAC API header file
*/
#ifndef ZEPHYR_INCLUDE_DRIVERS_EDAC_H_
#define ZEPHYR_INCLUDE_DRIVERS_EDAC_H_
#include <errno.h>
#include <sys/types.h>
/**
* @defgroup edac EDAC API
* @since 2.5
* @version 0.8.0
* @ingroup io_interfaces
* @{
*/
/**
* @brief EDAC error type
*/
enum edac_error_type {
/** Correctable error type */
EDAC_ERROR_TYPE_DRAM_COR = BIT(0),
/** Uncorrectable error type */
EDAC_ERROR_TYPE_DRAM_UC = BIT(1)
};
/**
* @cond INTERNAL_HIDDEN
*
* For internal use only, skip these in public documentation.
*/
typedef void (*edac_notify_callback_f)(const struct device *dev, void *data);
/**
* @brief EDAC driver API
*
* This is the mandatory API any EDAC driver needs to expose.
*/
__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);
};
/**
* INTERNAL_HIDDEN @endcond
*/
/**
* @name Optional interfaces
* @{
*
* EDAC Optional Interfaces
*/
/**
* @brief Set injection parameter param1
*
* Set first error injection parameter value.
*
* @param dev Pointer to the device structure
* @param value First injection parameter
*
* @retval -ENOSYS if the optional interface is not implemented
* @retval 0 on success, other error code otherwise
*/
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);
}
/**
* @brief Get injection parameter param1
*
* Get first error injection parameter value.
*
* @param dev Pointer to the device structure
* @param value Pointer to the first injection parameter
*
* @retval -ENOSYS if the optional interface is not implemented
* @retval 0 on success, error code otherwise
*/
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);
}
/**
* @brief Set injection parameter param2
*
* Set second error injection parameter value.
*
* @param dev Pointer to the device structure
* @param value Second injection parameter
*
* @retval -ENOSYS if the optional interface is not implemented
* @retval 0 on success, error code otherwise
*/
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);
}
/**
* @brief Get injection parameter param2
*
* @param dev Pointer to the device structure
* @param value Pointer to the second injection parameter
*
* @retval -ENOSYS if the optional interface is not implemented
* @retval 0 on success, error code otherwise
*/
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);
}
/**
* @brief Set error type value
*
* Set the value of error type to be injected
*
* @param dev Pointer to the device structure
* @param error_type Error type value
*
* @retval -ENOSYS if the optional interface is not implemented
* @retval 0 on success, error code otherwise
*/
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);
}
/**
* @brief Get error type value
*
* Get the value of error type to be injected
*
* @param dev Pointer to the device structure
* @param error_type Pointer to error type value
*
* @retval -ENOSYS if the optional interface is not implemented
* @retval 0 on success, error code otherwise
*/
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);
}
/**
* @brief Set injection control
*
* Trigger error injection.
*
* @param dev Pointer to the device structure
*
* @retval -ENOSYS if the optional interface is not implemented
* @retval 0 on success, error code otherwise
*/
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 */
/**
* @name Mandatory interfaces
* @{
*
* EDAC Mandatory Interfaces
*/
/**
* @brief Get ECC Error Log
*
* Read value of ECC Error Log.
*
* @param dev Pointer to the device structure
* @param value Pointer to the ECC Error Log value
*
* @retval 0 on success, error code otherwise
* @retval -ENOSYS if the mandatory interface is not implemented
*/
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);
}
/**
* @brief Clear ECC Error Log
*
* Clear value of ECC Error Log.
*
* @param dev Pointer to the device structure
*
* @retval 0 on success, error code otherwise
* @retval -ENOSYS if the mandatory interface is not implemented
*/
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);
}
/**
* @brief Get Parity Error Log
*
* Read value of Parity Error Log.
*
* @param dev Pointer to the device structure
* @param value Pointer to the parity Error Log value
*
* @retval 0 on success, error code otherwise
* @retval -ENOSYS if the mandatory interface is not implemented
*/
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);
}
/**
* @brief Clear Parity Error Log
*
* Clear value of Parity Error Log.
*
* @param dev Pointer to the device structure
*
* @retval 0 on success, error code otherwise
* @retval -ENOSYS if the mandatory interface is not implemented
*/
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);
}
/**
* @brief Get number of correctable errors
*
* @param dev Pointer to the device structure
*
* @retval num Number of correctable errors
* @retval -ENOSYS if the mandatory interface is not implemented
*/
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);
}
/**
* @brief Get number of uncorrectable errors
*
* @param dev Pointer to the device structure
*
* @retval num Number of uncorrectable errors
* @retval -ENOSYS if the mandatory interface is not implemented
*/
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);
}
/**
* Register callback function for memory error exception
*
* This callback runs in interrupt context
*
* @param dev EDAC driver device to install callback
* @param cb Callback function pointer
*
* @retval 0 on success, error code otherwise
* @retval -ENOSYS if the mandatory interface is not implemented
*/
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_ */