igsc_lib.h

Go to the documentation of this file.

/*
 * SPDX-License-Identifier: Apache-2.0
 * Copyright (C) 2019-2024 Intel Corporation
 */

 
#ifndef __IGSC_LIB_H__
#define __IGSC_LIB_H__
 
#ifdef __cplusplus
extern "C" {
#endif

#ifndef IN
#define IN
#endif /* IN */
#ifndef OUT
#define OUT
#endif /* OUT */
 
#if defined (_WIN32) || defined (_WIN64)
  #ifndef IGSC_DLL
    #define IGSC_EXPORT
  #else /* IGSC_DLL */
    #ifdef IGSC_DLL_EXPORTS
      #define IGSC_EXPORT __declspec(dllexport)
    #else
      #define IGSC_EXPORT __declspec(dllimport)
    #endif
  #endif /* IGSC_DLL */
#else
  #ifndef IGSC_DLL
    #define IGSC_EXPORT
  #else /* IGSC_DLL */
    #ifdef IGSC_DLL_EXPORTS
      #define IGSC_EXPORT __attribute__((__visibility__("default")))
    #else
      #define IGSC_EXPORT
    #endif
  #endif /* IGSC_DLL */
#endif
 
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
 
#ifndef BIT
#define BIT(x) (1U << (x))
#endif /* BIT */
 
#ifndef UNUSED_VAR
#define UNUSED_VAR(_v) (void)_v
#endif

#ifdef __linux__
typedef int igsc_handle_t;
#define IGSC_INVALID_DEVICE_HANDLE (-1)
#else /* __linux__ */
typedef void *igsc_handle_t;
#define IGSC_INVALID_DEVICE_HANDLE ((void *)0)
#endif /* __linux__ */

enum igsc_log_level_type {
    IGSC_LOG_LEVEL_ERROR = 0, 
    IGSC_LOG_LEVEL_DEBUG = 1, 
    IGSC_LOG_LEVEL_TRACE = 2, 
    IGSC_LOG_LEVEL_MAX   = 3, 
};

IGSC_EXPORT
void igsc_set_log_level(unsigned int log_level);

IGSC_EXPORT
unsigned int igsc_get_log_level(void);

enum igsc_image_type {
    IGSC_IMAGE_TYPE_UNKNOWN = 0, 
    IGSC_IMAGE_TYPE_GFX_FW,      
    IGSC_IMAGE_TYPE_OPROM,       
    IGSC_IMAGE_TYPE_OPROM_CODE,  
    IGSC_IMAGE_TYPE_OPROM_DATA,  
    IGSC_IMAGE_TYPE_FW_DATA,     
};

struct igsc_fw_version {
    char       project[4]; 
    uint16_t   hotfix;     
    uint16_t   build;      
};

struct igsc_ifr_bin_version {
    uint16_t   major;      
    uint16_t   minor;      
    uint16_t   hotfix;     
    uint16_t   build;      
};

struct igsc_psc_version {
    uint32_t   date;        
    uint32_t   cfg_version; 
};
 
#define IGSC_MAX_OEM_VERSION_LENGTH 256

struct igsc_oem_version {
    uint16_t length; 
    uint8_t  version[IGSC_MAX_OEM_VERSION_LENGTH];  
};
 
#define IGSC_MAX_OEM_SN_LENGTH 512

struct igsc_oem_serial_number {
    uint16_t length; 
    uint8_t  sn[IGSC_MAX_OEM_SN_LENGTH];  
};

enum igsc_version_compare_result {
    IGSC_VERSION_ERROR = 0,          
    IGSC_VERSION_NOT_COMPATIBLE = 1, 
    IGSC_VERSION_NEWER = 2,          
    IGSC_VERSION_EQUAL = 3,          
    IGSC_VERSION_OLDER = 4,          
};

enum igsc_fwdata_version_compare_result {
    IGSC_FWDATA_VERSION_REJECT_VCN = 0,                    
    IGSC_FWDATA_VERSION_REJECT_OEM_MANUF_DATA_VERSION = 1, 
    IGSC_FWDATA_VERSION_REJECT_DIFFERENT_PROJECT = 2,      
    IGSC_FWDATA_VERSION_ACCEPT = 3,                        
    IGSC_FWDATA_VERSION_OLDER_VCN = 4,                     
    IGSC_FWDATA_VERSION_REJECT_WRONG_FORMAT = 5,           
    IGSC_FWDATA_VERSION_REJECT_ARB_SVN = 6,                
};

struct igsc_fwdata_version {
    uint32_t oem_manuf_data_version; 
    uint16_t major_version;           
    uint16_t major_vcn;              
};
 
#define IGSC_FWDATA_FORMAT_VERSION_1 0x1
#define IGSC_FWDATA_FORMAT_VERSION_2 0x2
 
#define IGSC_FWDATA_FITB_VALID_MASK 0x1

struct igsc_fwdata_version2 {
    uint32_t format_version;         
    uint32_t oem_manuf_data_version; 
    uint32_t oem_manuf_data_version_fitb; 
    uint16_t major_version;          
    uint16_t major_vcn;              
    uint32_t flags;                  
    uint32_t data_arb_svn;           
    uint32_t data_arb_svn_fitb;      
};

#define IGSC_OPROM_VER_SIZE 8
struct igsc_oprom_version {
    uint8_t version[IGSC_OPROM_VER_SIZE]; 
};

enum igsc_oprom_type {
    IGSC_OPROM_NONE = 0,     
    IGSC_OPROM_DATA = 0x01,  
    IGSC_OPROM_CODE = 0x02,  
};

struct igsc_oprom_device_info {
  uint16_t subsys_vendor_id; 
  uint16_t subsys_device_id; 
};

struct igsc_oprom_device_info_4ids {
  uint16_t vendor_id;        
  uint16_t device_id;        
  uint16_t subsys_vendor_id; 
  uint16_t subsys_device_id; 
};

struct igsc_fwdata_device_info {
  uint16_t vendor_id; 
  uint16_t device_id; 
  uint16_t subsys_vendor_id; 
  uint16_t subsys_device_id; 
};

struct igsc_oprom_image;

struct igsc_fwdata_image;
 

struct igsc_device_iterator;

#define IGSC_INFO_NAME_SIZE 256

struct igsc_device_info {
    char name[IGSC_INFO_NAME_SIZE];  
 
    uint16_t domain;                 
    uint8_t  bus;                    
    uint8_t  dev;                    
    uint8_t  func;                   
 
    uint16_t device_id;              
    uint16_t vendor_id;              
    uint16_t subsys_device_id;       
    uint16_t subsys_vendor_id;       
};

#define IGSC_ERROR_BASE              0x0000U                
#define IGSC_SUCCESS                 (IGSC_ERROR_BASE + 0)  
#define IGSC_ERROR_INTERNAL          (IGSC_ERROR_BASE + 1)  
#define IGSC_ERROR_NOMEM             (IGSC_ERROR_BASE + 2)  
#define IGSC_ERROR_INVALID_PARAMETER (IGSC_ERROR_BASE + 3)  
#define IGSC_ERROR_DEVICE_NOT_FOUND  (IGSC_ERROR_BASE + 4)  
#define IGSC_ERROR_BAD_IMAGE         (IGSC_ERROR_BASE + 5)  
#define IGSC_ERROR_PROTOCOL          (IGSC_ERROR_BASE + 6)  
#define IGSC_ERROR_BUFFER_TOO_SMALL  (IGSC_ERROR_BASE + 7)  
#define IGSC_ERROR_INVALID_STATE     (IGSC_ERROR_BASE + 8)  
#define IGSC_ERROR_NOT_SUPPORTED     (IGSC_ERROR_BASE + 9)  
#define IGSC_ERROR_INCOMPATIBLE      (IGSC_ERROR_BASE + 10) 
#define IGSC_ERROR_TIMEOUT           (IGSC_ERROR_BASE + 11) 
#define IGSC_ERROR_PERMISSION_DENIED (IGSC_ERROR_BASE + 12) 
#define IGSC_ERROR_BUSY              (IGSC_ERROR_BASE + 13) 

#define IGSC_HW_CONFIG_BLOB_SIZE 48

struct igsc_hw_config {
    uint32_t format_version;
    uint8_t blob[IGSC_HW_CONFIG_BLOB_SIZE];
};

struct igsc_subsystem_ids {
    uint16_t ssvid;
    uint16_t ssdid;
};

#define IGSC_MAX_IMAGE_SIZE (8*1024*1024) /* 8M */
 
struct igsc_lib_ctx;

struct igsc_device_handle {
    struct igsc_lib_ctx *ctx; 
};


IGSC_EXPORT
uint32_t igsc_get_last_firmware_status(IN struct igsc_device_handle *handle);

IGSC_EXPORT
const char *igsc_translate_firmware_status(IN uint32_t firmware_status);
 
#define IGSC_MAX_FW_STATUS_INDEX 5

IGSC_EXPORT
int igsc_read_fw_status_reg(IN struct igsc_device_handle *handle,
                            IN uint32_t fwsts_index,
                            OUT uint32_t *fwsts_value);

typedef void (*igsc_log_func_t)(enum igsc_log_level_type log_level, const char* fmt, ...);

IGSC_EXPORT
void igsc_set_log_callback_func(IN igsc_log_func_t log_callback_f);

IGSC_EXPORT
igsc_log_func_t igsc_get_log_callback_func(void);

IGSC_EXPORT
int igsc_device_init_by_device(IN OUT struct igsc_device_handle *handle,
                               IN const char *device_path);

int igsc_device_init_by_handle(IN OUT struct igsc_device_handle *handle,
                               IN igsc_handle_t dev_handle);

IGSC_EXPORT
int igsc_device_init_by_device_info(IN OUT struct igsc_device_handle *handle,
                                    IN const struct igsc_device_info *dev_info);

IGSC_EXPORT
int igsc_device_get_device_info(IN  struct igsc_device_handle *handle,
                                OUT struct igsc_device_info *dev_info);
 

IGSC_EXPORT
int igsc_device_update_device_info(IN  struct igsc_device_handle *handle,
                                   OUT struct igsc_device_info *dev_info);

IGSC_EXPORT
int igsc_device_close(IN OUT struct igsc_device_handle *handle);

IGSC_EXPORT
int igsc_device_fw_version(IN  struct igsc_device_handle *handle,
                           OUT struct igsc_fw_version *version);

IGSC_EXPORT
int igsc_image_fw_version(IN  const uint8_t *buffer,
                          IN  uint32_t buffer_len,
                          OUT struct igsc_fw_version *version);

IGSC_EXPORT
int igsc_device_hw_config(IN  struct igsc_device_handle *handle,
                          OUT struct igsc_hw_config *hw_config);

IGSC_EXPORT
int igsc_device_subsystem_ids(IN struct  igsc_device_handle *handle,
                              OUT struct igsc_subsystem_ids *ssids);

IGSC_EXPORT
int igsc_image_hw_config(IN  const uint8_t *buffer,
                         IN  uint32_t buffer_len,
                         OUT struct igsc_hw_config *hw_config);

IGSC_EXPORT
int igsc_hw_config_compatible(IN const struct igsc_hw_config *image_hw_config,
                              IN const struct igsc_hw_config *device_hw_config);
IGSC_EXPORT
int igsc_hw_config_to_string(IN const struct igsc_hw_config *hw_config,
                             IN char *buf, IN size_t length);

typedef void (*igsc_progress_func_t)(uint32_t sent, uint32_t total, void *ctx);

IGSC_EXPORT int
igsc_device_fw_update(IN  struct igsc_device_handle *handle,
                      IN  const uint8_t *buffer,
                      IN  const uint32_t buffer_len,
                      IN  igsc_progress_func_t progress_f,
                      IN  void *ctx);
 
/* flags with which the update should be performed */
struct igsc_fw_update_flags {
    uint32_t  force_update     : 1;
    uint32_t  reserved         : 31;
};

IGSC_EXPORT int
igsc_device_fw_update_ex(IN  struct igsc_device_handle *handle,
                         IN  const uint8_t *buffer,
                         IN  const uint32_t buffer_len,
                         IN  igsc_progress_func_t progress_f,
                         IN  void *ctx,
                         IN  struct igsc_fw_update_flags flags);

IGSC_EXPORT int
igsc_iaf_psc_update(IN struct igsc_device_handle *handle,
                    IN const uint8_t *buffer,
                    IN const uint32_t buffer_len,
                    IN igsc_progress_func_t progress_f,
                    IN void *ctx);

IGSC_EXPORT int
igsc_device_fwdata_update(IN  struct igsc_device_handle *handle,
                          IN  const uint8_t *buffer,
                          IN  const uint32_t buffer_len,
                          IN  igsc_progress_func_t progress_f,
                          IN  void *ctx);

IGSC_EXPORT int
igsc_device_fwdata_image_update(IN  struct igsc_device_handle *handle,
                                IN  struct igsc_fwdata_image *img,
                                IN  igsc_progress_func_t progress_f,
                                IN  void *ctx);

IGSC_EXPORT
int igsc_image_fwdata_init(IN OUT struct igsc_fwdata_image **img,
                           IN const uint8_t *buffer,
                           IN uint32_t buffer_len);

IGSC_EXPORT
int igsc_device_fwdata_version(IN  struct igsc_device_handle *handle,
                               OUT struct igsc_fwdata_version *version);

IGSC_EXPORT
int igsc_device_fwdata_version2(IN  struct igsc_device_handle* handle,
    OUT struct igsc_fwdata_version2* version);

IGSC_EXPORT
int igsc_image_fwdata_version(IN struct igsc_fwdata_image *img,
                              OUT struct igsc_fwdata_version *version);

IGSC_EXPORT
int igsc_image_fwdata_version2(IN struct igsc_fwdata_image* img,
    OUT struct igsc_fwdata_version2* version);

IGSC_EXPORT
uint8_t igsc_fwdata_version_compare(IN struct igsc_fwdata_version *image_ver,
                                    IN struct igsc_fwdata_version *device_ver);

IGSC_EXPORT
uint8_t igsc_fwdata_version_compare2(IN struct igsc_fwdata_version2* image_ver,
                                     IN struct igsc_fwdata_version2* device_ver);

IGSC_EXPORT
int igsc_image_fwdata_count_devices(IN struct igsc_fwdata_image *img,
                                    OUT uint32_t *count);

IGSC_EXPORT
int igsc_image_fwdata_supported_devices(IN struct igsc_fwdata_image *img,
                                        OUT struct igsc_fwdata_device_info *devices,
                                        IN OUT uint32_t *count);
IGSC_EXPORT
int igsc_image_fwdata_match_device(IN struct igsc_fwdata_image *img,
                                   IN struct igsc_device_info *device);
IGSC_EXPORT
int igsc_image_fwdata_iterator_reset(IN struct igsc_fwdata_image *img);

IGSC_EXPORT
int igsc_image_fwdata_iterator_next(IN struct igsc_fwdata_image *img,
                                    OUT struct igsc_fwdata_device_info *device);

IGSC_EXPORT
int igsc_image_fwdata_release(IN struct igsc_fwdata_image *img);

IGSC_EXPORT
uint8_t igsc_fw_version_compare(IN struct igsc_fw_version *image_ver,
                                IN struct igsc_fw_version *device_ver);

IGSC_EXPORT
int igsc_device_oprom_version(IN struct igsc_device_handle *handle,
                              IN uint32_t oprom_type,
                              OUT struct igsc_oprom_version *version);

IGSC_EXPORT
int igsc_device_oprom_update(IN  struct igsc_device_handle *handle,
                             IN  uint32_t oprom_type,
                             IN  struct igsc_oprom_image *img,
                             IN  igsc_progress_func_t progress_f,
                             IN  void *ctx);

IGSC_EXPORT
int igsc_image_oprom_init(IN OUT struct igsc_oprom_image **img,
                          IN const uint8_t *buffer,
                          IN uint32_t buffer_len);

IGSC_EXPORT
int igsc_image_oprom_version(IN struct igsc_oprom_image *img,
                             IN enum igsc_oprom_type type,
                             OUT struct igsc_oprom_version *version);

IGSC_EXPORT
int igsc_image_oprom_type(IN struct igsc_oprom_image *img,
                          IN  uint32_t *oprom_type);

IGSC_EXPORT
int igsc_image_oprom_count_devices(IN struct igsc_oprom_image *img,
                                   OUT uint32_t *count);

IGSC_EXPORT
int igsc_image_oprom_supported_devices(IN struct igsc_oprom_image *img,
                                       OUT struct igsc_oprom_device_info *devices,
                                       IN OUT uint32_t *count);
IGSC_EXPORT
int igsc_image_oprom_match_device(IN struct igsc_oprom_image *img,
                                  IN enum igsc_oprom_type request_type,
                                  IN struct igsc_device_info *device);
IGSC_EXPORT
int igsc_image_oprom_iterator_reset(IN struct igsc_oprom_image *img);

IGSC_EXPORT
int igsc_image_oprom_iterator_next(IN struct igsc_oprom_image *img,
                                   OUT struct igsc_oprom_device_info *device);

IGSC_EXPORT
int igsc_image_oprom_count_devices_typed(IN struct igsc_oprom_image *img,
                                         IN uint32_t request_type,
                                         OUT uint32_t *count);

IGSC_EXPORT
int igsc_image_oprom_supported_devices_typed(IN struct igsc_oprom_image *img,
                                             IN uint32_t request_type,
                                             OUT struct igsc_oprom_device_info_4ids *devices,
                                             IN OUT uint32_t *count);
IGSC_EXPORT
int igsc_image_oprom_iterator_reset_typed(IN struct igsc_oprom_image *img,
                                          IN uint32_t request_type);

IGSC_EXPORT
int igsc_image_oprom_iterator_next_typed(IN struct igsc_oprom_image *img,
                                         IN uint32_t request_type,
                                         OUT struct igsc_oprom_device_info_4ids *device);

IGSC_EXPORT
int igsc_image_oprom_has_4ids_extension(IN struct igsc_oprom_image *img,
                                        IN uint32_t request_type,
                                        OUT bool *has_4ids_extension);

IGSC_EXPORT
int igsc_image_oprom_has_2ids_extension(IN struct igsc_oprom_image *img,
                                        OUT bool *has_2ids_extension);

IGSC_EXPORT
int igsc_image_oprom_code_devid_enforced(IN struct igsc_hw_config *hw_config,
                                         OUT bool *devid_enforced);

IGSC_EXPORT
int igsc_image_oprom_release(IN struct igsc_oprom_image *img);

IGSC_EXPORT
uint8_t igsc_oprom_version_compare(const struct igsc_oprom_version *image_ver,
                                   const struct igsc_oprom_version *device_ver);
IGSC_EXPORT
int igsc_image_get_type(IN const uint8_t *buffer,
                        IN const uint32_t buffer_len,
                        OUT uint8_t *type);


IGSC_EXPORT
int igsc_device_iterator_create(struct igsc_device_iterator **iter);

IGSC_EXPORT
int igsc_device_iterator_next(struct igsc_device_iterator *iter,
                              struct igsc_device_info *info);

IGSC_EXPORT
void igsc_device_iterator_destroy(struct igsc_device_iterator *iter);


enum igsc_ifr_tiles {
    IGSC_IFR_TILE_0 = 0x0001,
    IGSC_IFR_TILE_1 = 0x0002,
};

enum igsc_supported_ifr_tests {
    IGSC_IFR_SUPPORTED_TEST_SCAN  = 0x00000001,
    IGSC_IFR_SUPPORTED_TEST_ARRAY = 0x00000002,
};

enum igsc_ifr_repairs {
    IGSC_IFR_REPAIR_DSS_EN = 0x00000001,
    IGSC_IFR_REPAIR_ARRAY  = 0x00000002,
};

enum ifr_test_run_status {
    IFR_TEST_STATUS_SUCCESS = 0,           
    IFR_TEST_STATUS_PASSED_WITH_REPAIR,    
    IFR_TEST_STATUS_PASSED_WITH_RECOVERY,  
    IFR_TEST_STATUS_SUBSLICE_FAILURE,      
    IFR_TEST_STATUS_NON_SUBSLICE_FAILURE,  
    IFR_TEST_STATUS_ERROR,                 
};

IGSC_EXPORT
int igsc_ifr_get_status(IN  struct igsc_device_handle *handle,
                        OUT uint8_t   *result,
                        OUT uint32_t  *supported_tests,
                        OUT uint32_t  *ifr_applied,
                        OUT uint8_t   *tiles_num);

IGSC_EXPORT
int igsc_ifr_run_test(IN struct igsc_device_handle *handle,
                      IN uint8_t   test_type,
                      IN uint8_t   tiles,
                      OUT uint8_t  *result,
                      OUT uint8_t  *run_status,
                      OUT uint32_t *error_code);


struct igsc_gfsp_tile_mem_err {
    uint32_t corr_err;   
    uint32_t uncorr_err; 
};

struct igsc_gfsp_mem_err {
    uint32_t num_of_tiles;                  
    struct igsc_gfsp_tile_mem_err errors[]; 
};

IGSC_EXPORT
int igsc_gfsp_count_tiles(IN  struct igsc_device_handle *handle,
                          OUT uint32_t *max_num_of_tiles);

IGSC_EXPORT
int igsc_gfsp_memory_errors(IN struct igsc_device_handle *handle,
                            IN OUT struct igsc_gfsp_mem_err *tiles);

enum igsc_ifr_pending_reset {
    IGSC_IFR_PENDING_RESET_NONE = 0,    
    IGSC_IFR_PENDING_RESET_SHALLOW = 1, 
    IGSC_IFR_PENDING_RESET_DEEP = 2,    
};

enum igsc_ifr_array_scan_test_status_mask {
    IGSC_ARRAY_SCAN_STATUS_TEST_EXECUTION_MASK = BIT(0), 
    IGSC_ARRAY_SCAN_STATUS_TEST_RESULT_MASK =    BIT(1), 
    IGSC_ARRAY_SCAN_STATUS_FOUND_HW_ERROR_MASK = BIT(2), 
    IGSC_ARRAY_SCAN_STATUS_HW_REPAIR_MASK =      BIT(3), 
};
 
enum igsc_ifr_array_scan_extended_status {
    IGSC_IFR_EXT_STS_PASSED = 0,                         
    IGSC_IFR_EXT_STS_SHALLOW_RST_PENDING = 1,            
    IGSC_IFR_EXT_STS_DEEP_RST_PENDING = 2,               
    IGSC_IFR_EXT_STS_NO_REPAIR_NEEDED = 3,               
    IGSC_IFR_EXT_STS_REPAIRED_ARRAY = 4,                 
    IGSC_IFR_EXT_STS_REPAIRED_SUBSLICE = 5,              
    IGSC_IFR_EXT_STS_REPAIRED_ARRAY_SUBSLICE = 6,        
    IGSC_IFR_EXT_STS_REPAIRED_ARRAY_FAULTY_SUBSLICE = 7, 
    IGSC_IFR_EXT_STS_REPAIR_NOT_SUPPORTED = 8,           
    IGSC_IFR_EXT_STS_NO_RESORCES = 9,                    
    IGSC_IFR_EXT_STS_NON_SUBSLICE_IN_ARRAY = 10,         
    IGSC_IFR_EXT_STS_NON_SUBSLICE_IN_SCAN = 11,          
    IGSC_IFR_EXT_STS_TEST_ERROR = 12,                    
};

IGSC_EXPORT
int igsc_ifr_run_array_scan_test(IN struct igsc_device_handle *handle,
                                 OUT uint32_t *status,
                                 OUT uint32_t *extended_status,
                                 OUT uint32_t *pending_reset,
                                 OUT uint32_t *error_code);

IGSC_EXPORT
int igsc_ifr_run_mem_ppr_test(IN struct igsc_device_handle *handle,
                              OUT uint32_t *status,
                              OUT uint32_t *pending_reset,
                              OUT uint32_t *error_code);

enum igsc_ifr_supported_tests_masks {
   IGSC_IFR_SUPPORTED_TESTS_ARRAY_AND_SCAN = BIT(0), 
   IGSC_IFR_SUPPORTED_TESTS_MEMORY_PPR =     BIT(1), 
};

enum igsc_ifr_hw_capabilities_masks {
    IGSC_IRF_HW_CAPABILITY_IN_FIELD_REPAIR = BIT(0),     
    IGSC_IRF_HW_CAPABILITY_FULL_EU_MODE_SWITCH = BIT(1), 
};

enum igsc_ifr_previous_errors_masks {
    IGSC_IFR_PREV_ERROR_DSS_ERR_ARR_STS_PKT =         BIT(0), 
    IGSC_IFR_PREV_ERROR_NON_DSS_ERR_ARR_STS_PKT =     BIT(1), 
    IGSC_IFR_PREV_ERROR_DSS_REPAIRABLE_PKT =          BIT(2), 
    IGSC_IFR_PREV_ERROR_DSS_UNREPAIRABLE_PKT =        BIT(3), 
    IGSC_IFR_PREV_ERROR_NON_DSS_REPAIRABLE_PKT =      BIT(4), 
    IGSC_IFR_PREV_ERROR_NON_DSS_UNREPAIRABLE_PKT =    BIT(5), 
    IGSC_IFR_PREV_ERROR_DSS_ERR_SCAN_STS_PKT =        BIT(6), 
    IGSC_IFR_PREV_ERROR_NON_DSS_ERR_SCAN_STS_PKT =    BIT(7), 
    IGSC_IFR_PREV_ERROR_NOT_ENOUGH_SPARE_DSS =        BIT(8), 
    IGSC_IFR_PREV_ERROR_MIS_DSS_STS_PKT_ON_ARR =      BIT(9), 
    IGSC_IFR_PREV_ERROR_MIS_NON_DSS_STS_PKT_ON_ARR =  BIT(10), 
    IGSC_IFR_PREV_ERROR_MIS_DSS_STS_PKT_ON_SCAN =     BIT(11), 
    IGSC_IFR_PREV_ERROR_MIS_NON_DSS_STS_PKT_ON_SCAN = BIT(12), 
    IGSC_IFR_PREV_ERROR_DSS_ENG_DONE_CLR_IN_ARR =     BIT(13), 
    IGSC_IFR_PREV_ERROR_NON_DSS_ENG_DONE_CLR_IN_ARR = BIT(14), 
    IGSC_IFR_PREV_ERROR_UNEXPECTED =                  BIT(31), 
};

enum igsc_ifr_repairs_mask {
    IGSC_IFR_REPAIRS_MASK_DSS_EN_REPAIR = BIT(0), 
    IGSC_IFR_REPAIRS_MASK_ARRAY_REPAIR =  BIT(1), 
    IGSC_IFR_REPAIRS_MASK_FAILURE =       BIT(2), 
};

IGSC_EXPORT
int igsc_ifr_get_status_ext(IN  struct igsc_device_handle *handle,
                            OUT uint32_t *supported_tests,
                            OUT uint32_t *hw_capabilities,
                            OUT uint32_t *ifr_applied,
                            OUT uint32_t *prev_errors,
                            OUT uint32_t *pending_reset);

IGSC_EXPORT
int igsc_ifr_count_tiles(IN  struct igsc_device_handle *handle,
                         OUT uint16_t *supported_tiles);

IGSC_EXPORT
int igsc_ifr_get_tile_repair_info(IN  struct igsc_device_handle *handle,
                                  IN uint16_t tile_idx,
                                  OUT uint16_t *used_array_repair_entries,
                                  OUT uint16_t *available_array_repair_entries,
                                  OUT uint16_t *failed_dss);
IGSC_EXPORT
int igsc_ecc_config_set(IN  struct igsc_device_handle *handle,
                        IN  uint8_t req_ecc_state,
                        OUT uint8_t *cur_ecc_state,
                        OUT uint8_t *pen_ecc_state);

IGSC_EXPORT
int igsc_ecc_config_get(IN  struct igsc_device_handle *handle,
                        OUT uint8_t *cur_ecc_state,
                        OUT uint8_t *pen_ecc_state);

IGSC_EXPORT
int igsc_device_oem_version(IN  struct igsc_device_handle *handle,
                            OUT struct igsc_oem_version *version);

IGSC_EXPORT
int igsc_device_oem_serial_number(IN  struct igsc_device_handle *handle,
                                  OUT struct igsc_oem_serial_number *sn);

IGSC_EXPORT
int igsc_device_ifr_bin_version(IN  struct igsc_device_handle *handle,
                                OUT struct igsc_ifr_bin_version *version);

IGSC_EXPORT
int igsc_device_psc_version(IN  struct igsc_device_handle *handle,
                            OUT struct igsc_psc_version *version);
 
enum igsc_gfsp_health_indicators {
    IGSC_HEALTH_INDICATOR_HEALTHY = 0,
    IGSC_HEALTH_INDICATOR_DEGRADED = 1,
    IGSC_HEALTH_INDICATOR_CRITICAL = 2,
    IGSC_HEALTH_INDICATOR_REPLACE  = 3
};

IGSC_EXPORT
int igsc_gfsp_get_health_indicator(IN struct igsc_device_handle *handle,
                                   OUT uint8_t *health_indicator);

IGSC_EXPORT
int igsc_gfsp_heci_cmd(struct igsc_device_handle *handle, uint32_t gfsp_cmd,
                       uint8_t* in_buffer, size_t in_buffer_size,
                       uint8_t* out_buffer, size_t out_buffer_size,
                       size_t *actual_out_buffer_size);

enum csc_late_binding_flags {
    CSC_LATE_BINDING_FLAGS_IS_PERSISTENT_MASK = 0x1,
};

enum csc_late_binding_type {
    CSC_LATE_BINDING_TYPE_INVALID = 0,
    CSC_LATE_BINDING_TYPE_FAN_TABLE = 1,
    CSC_LATE_BINDING_TYPE_VR_CONFIG = 2,
    CSC_LATE_BINDING_TYPE_OCODE = 3,
    CSC_LATE_BINDING_TYPE_DGDIAG = 4,
};

enum csc_late_binding_status {
    CSC_LATE_BINDING_STATUS_SUCCESS           = 0,
    CSC_LATE_BINDING_STATUS_4ID_MISMATCH      = 1,
    CSC_LATE_BINDING_STATUS_ARB_FAILURE       = 2,
    CSC_LATE_BINDING_STATUS_GENERAL_ERROR     = 3,
    CSC_LATE_BINDING_STATUS_INVALID_PARAMS    = 4,
    CSC_LATE_BINDING_STATUS_INVALID_SIGNATURE = 5,
    CSC_LATE_BINDING_STATUS_INVALID_PAYLOAD   = 6,
    CSC_LATE_BINDING_STATUS_TIMEOUT           = 7,
    CSC_LATE_BINDING_STATUS_BUFFER_TOO_SMALL                      = 8,
    CSC_LATE_BINDING_STATUS_INTERNAL_ERROR                        = 9,
    CSC_LATE_BINDING_STATUS_INVALID_FPT_TABLE                     = 10,
    CSC_LATE_BINDING_STATUS_SIGNED_PAYLOAD_VERIFICATION_ERROR     = 11,
    CSC_LATE_BINDING_STATUS_SIGNED_PAYLOAD_INVALID_CPD            = 12,
    CSC_LATE_BINDING_STATUS_SIGNED_PAYLOAD_FW_VERSION_MISMATCH    = 13,
    CSC_LATE_BINDING_STATUS_SIGNED_PAYLOAD_INVALID_MANIFEST       = 14,
    CSC_LATE_BINDING_STATUS_SIGNED_PAYLOAD_INVALID_HASH           = 15,
    CSC_LATE_BINDING_STATUS_SIGNED_PAYLOAD_BINDING_TYPE_MISMATCH  = 16,
    CSC_LATE_BINDING_STATUS_SIGNED_PAYLOAD_HANDLE_SVN_FAILED      = 17,
    CSC_LATE_BINDING_STATUS_DESTINATION_MBOX_FAILURE              = 18,
    CSC_LATE_BINDING_STATUS_MISSING_LOADING_PATCH                 = 19,
    CSC_LATE_BINDING_STATUS_INVALID_COMMAND                       = 20,
    CSC_LATE_BINDING_STATUS_INVALID_HECI_HEADER                   = 21,
    CSC_LATE_BINDING_STATUS_IP_ERROR_START                        = 0x80000000,
};

enum csc_late_binding_svn_source {
    CSC_LATE_BINDING_SVN_SOURCE_SPI = 0,
    CSC_LATE_BINDING_SVN_SOURCE_KEY_MANIFEST = 1,
};

IGSC_EXPORT
int igsc_device_update_late_binding_config(IN struct igsc_device_handle *handle,
                                           IN uint32_t type, /* enum csc_late_binding_type */
                                           IN uint32_t flags, /* enum csc_late_binding_flags */
                                           IN uint8_t *payload, IN size_t payload_size,
                                           OUT uint32_t *status); /* enum csc_late_binding_status */

IGSC_EXPORT
int igsc_device_update_late_binding_config2(IN struct igsc_device_handle* handle,
    IN uint32_t type, /* enum csc_late_binding_type */
    IN uint32_t flags, /* enum csc_late_binding_flags */
    IN uint8_t* payload, IN size_t payload_size,
    OUT uint32_t* status); /* enum csc_late_binding_status */

IGSC_EXPORT
int igsc_device_get_late_binding_info(IN struct  igsc_device_handle* handle,
    IN uint32_t type, /* enum csc_late_binding_type */
    OUT uint32_t* svn_source,
    OUT uint32_t* min_svn,
    OUT uint32_t* status); /* enum csc_late_binding_status */

IGSC_EXPORT
int igsc_device_commit_arb_svn(IN struct  igsc_device_handle *handle, uint8_t *fw_error);

IGSC_EXPORT
int igsc_device_get_min_allowed_arb_svn(IN struct igsc_device_handle *handle,
                                        OUT uint8_t *min_allowed_svn);



enum igsc_ppr_test_status_mask {
    IGSC_PPR_STATUS_TEST_EXECUTED_MASK = 0x1,
    IGSC_PPR_STATUS_TEST_SUCCESS_MASK = 0x2,
    IGSC_PPR_STATUS_FOUND_HW_ERROR_MASK = 0x4,
    IGSC_PPR_STATUS_HW_ERROR_REPAIRED_MASK = 0x8,
};

struct igsc_device_mbist_ppr_status {
    uint32_t mbist_test_status;           
    uint32_t num_of_ppr_fuses_used_by_fw; 
    uint32_t num_of_remaining_ppr_fuses;  
};

struct igsc_ppr_status {
    uint8_t  boot_time_memory_correction_pending; 
    uint8_t  ppr_mode;                            
    uint8_t  test_run_status;                     
    uint8_t  reserved;
    uint32_t ras_ppr_applied;                     
    uint32_t mbist_completed;                     
    uint32_t num_devices;                         
    struct   igsc_device_mbist_ppr_status device_mbist_ppr_status[]; 
};

IGSC_EXPORT
int igsc_memory_ppr_devices(IN struct igsc_device_handle *handle,
                            OUT uint32_t *device_count);

IGSC_EXPORT
int igsc_memory_ppr_status(IN struct  igsc_device_handle *handle,
                           OUT struct igsc_ppr_status *ppr_status);

#ifdef __cplusplus
}
#endif
#endif /* __IGSC_LIB_H__ */