espi_saf.h

Go to the documentation of this file.

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

 
#ifndef ZEPHYR_INCLUDE_ESPI_SAF_H_
#define ZEPHYR_INCLUDE_ESPI_SAF_H_
 
#include <zephyr/sys/__assert.h>
#include <zephyr/types.h>
#include <zephyr/device.h>
 
#ifdef __cplusplus
extern "C" {
#endif


 

 


enum espi_taf_event {
        ESPI_TAF_EVENT_NO_REQUEST = 0,
        ESPI_TAF_EVENT_HOST_REQUEST,
        ESPI_TAF_EVENT_EC0_REQUEST,
        ESPI_TAF_EVENT_MAX_REQUEST,
};
 
struct espi_saf_hw_cfg;
struct espi_saf_flash_cfg;
struct espi_saf_pr;

struct espi_saf_cfg {
        uint8_t nflash_devices;
        struct espi_saf_hw_cfg hwcfg;
        struct espi_saf_flash_cfg *flash_cfgs;
};

struct espi_saf_packet {
        uint32_t flash_addr;
        uint8_t *buf;
        uint32_t len;
};
 
/*
 *defined in espi.h
 * struct espi_callback
 * typedef void (*espi_callback_handler_t)()
 */

typedef int (*espi_saf_api_config)(const struct device *dev,
                                   const struct espi_saf_cfg *cfg);
 
typedef int (*espi_saf_api_set_protection_regions)(
                                const struct device *dev,
                                const struct espi_saf_protection *pr);
 
typedef int (*espi_saf_api_activate)(const struct device *dev);
 
typedef bool (*espi_saf_api_get_channel_status)(const struct device *dev);
 
typedef int (*espi_saf_api_flash_read)(const struct device *dev,
                                       struct espi_saf_packet *pckt);
typedef int (*espi_saf_api_flash_write)(const struct device *dev,
                                        struct espi_saf_packet *pckt);
typedef int (*espi_saf_api_flash_erase)(const struct device *dev,
                                        struct espi_saf_packet *pckt);
typedef int (*espi_saf_api_flash_unsuccess)(const struct device *dev,
                                        struct espi_saf_packet *pckt);
/* Callbacks and traffic intercept */
typedef int (*espi_saf_api_manage_callback)(const struct device *dev,
                                            struct espi_callback *callback,
                                            bool set);
 
__subsystem struct espi_saf_driver_api {
        espi_saf_api_config config;
        espi_saf_api_set_protection_regions set_protection_regions;
        espi_saf_api_activate activate;
        espi_saf_api_get_channel_status get_channel_status;
        espi_saf_api_flash_read flash_read;
        espi_saf_api_flash_write flash_write;
        espi_saf_api_flash_erase flash_erase;
        espi_saf_api_flash_unsuccess flash_unsuccess;
        espi_saf_api_manage_callback manage_callback;
};


__syscall int espi_saf_config(const struct device *dev,
                              const struct espi_saf_cfg *cfg);
 
static inline int z_impl_espi_saf_config(const struct device *dev,
                                         const struct espi_saf_cfg *cfg)
{
        return DEVICE_API_GET(espi_saf, dev)->config(dev, cfg);
}

__syscall int espi_saf_set_protection_regions(
                                const struct device *dev,
                                const struct espi_saf_protection *pr);
 
static inline int z_impl_espi_saf_set_protection_regions(
                                        const struct device *dev,
                                        const struct espi_saf_protection *pr)
{
        return DEVICE_API_GET(espi_saf, dev)->set_protection_regions(dev, pr);
}

__syscall int espi_saf_activate(const struct device *dev);
 
static inline int z_impl_espi_saf_activate(const struct device *dev)
{
        return DEVICE_API_GET(espi_saf, dev)->activate(dev);
}

__syscall bool espi_saf_get_channel_status(const struct device *dev);
 
static inline bool z_impl_espi_saf_get_channel_status(
                                        const struct device *dev)
{
        return DEVICE_API_GET(espi_saf, dev)->get_channel_status(dev);
}

__syscall int espi_saf_flash_read(const struct device *dev,
                                  struct espi_saf_packet *pckt);
 
static inline int z_impl_espi_saf_flash_read(const struct device *dev,
                                             struct espi_saf_packet *pckt)
{
        const struct espi_saf_driver_api *api = DEVICE_API_GET(espi_saf, dev);
 
        if (!api->flash_read) {
                return -ENOTSUP;
        }
 
        return api->flash_read(dev, pckt);
}

__syscall int espi_saf_flash_write(const struct device *dev,
                                   struct espi_saf_packet *pckt);
 
static inline int z_impl_espi_saf_flash_write(const struct device *dev,
                                              struct espi_saf_packet *pckt)
{
        const struct espi_saf_driver_api *api = DEVICE_API_GET(espi_saf, dev);
 
        if (!api->flash_write) {
                return -ENOTSUP;
        }
 
        return api->flash_write(dev, pckt);
}

__syscall int espi_saf_flash_erase(const struct device *dev,
                                   struct espi_saf_packet *pckt);
 
static inline int z_impl_espi_saf_flash_erase(const struct device *dev,
                                              struct espi_saf_packet *pckt)
{
        const struct espi_saf_driver_api *api = DEVICE_API_GET(espi_saf, dev);
 
        if (!api->flash_erase) {
                return -ENOTSUP;
        }
 
        return api->flash_erase(dev, pckt);
}

__syscall int espi_saf_flash_unsuccess(const struct device *dev,
                                       struct espi_saf_packet *pckt);
 
static inline int z_impl_espi_saf_flash_unsuccess(const struct device *dev,
                                                  struct espi_saf_packet *pckt)
{
        const struct espi_saf_driver_api *api = DEVICE_API_GET(espi_saf, dev);
 
        if (!api->flash_unsuccess) {
                return -ENOTSUP;
        }
 
        return api->flash_unsuccess(dev, pckt);
}


static inline void espi_saf_init_callback(struct espi_callback *callback,
                                          espi_callback_handler_t handler,
                                          enum espi_bus_event evt_type)
{
        __ASSERT(callback, "Callback pointer should not be NULL");
        __ASSERT(handler, "Callback handler pointer should not be NULL");
 
        callback->handler = handler;
        callback->evt_type = evt_type;
}

static inline int espi_saf_add_callback(const struct device *dev,
                                        struct espi_callback *callback)
{
        const struct espi_saf_driver_api *api = DEVICE_API_GET(espi_saf, dev);
 
        if (!api->manage_callback) {
                return -ENOTSUP;
        }
 
        return api->manage_callback(dev, callback, true);
}

static inline int espi_saf_remove_callback(const struct device *dev,
                                           struct espi_callback *callback)
{
        const struct espi_saf_driver_api *api = DEVICE_API_GET(espi_saf, dev);
 
        if (!api->manage_callback) {
                return -ENOTSUP;
        }
 
        return api->manage_callback(dev, callback, false);
}
 
#ifdef __cplusplus
}
#endif

#include <zephyr/syscalls/espi_saf.h>
#endif /* ZEPHYR_INCLUDE_ESPI_SAF_H_ */