amdsmi.h Source File

amdsmi.h Source File#

AMD SMI: amdsmi.h Source File
 /*
  * =============================================================================
  * The University of Illinois/NCSA
  * Open Source License (NCSA)
  *
  * Copyright (c) 2022, Advanced Micro Devices, Inc.
  * All rights reserved.
  *
  * Developed by:
  *
  *                 AMD Research and AMD ROC Software Development
  *
  *                 Advanced Micro Devices, Inc.
  *
  *                 www.amd.com
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to
  * deal with the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
  *
  *  - Redistributions of source code must retain the above copyright notice,
  *    this list of conditions and the following disclaimers.
  *  - Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimers in
  *    the documentation and/or other materials provided with the distribution.
  *  - Neither the names of <Name of Development Group, Name of Institution>,
  *    nor the names of its contributors may be used to endorse or promote
  *    products derived from this Software without specific prior written
  *    permission.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  * THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  * DEALINGS WITH THE SOFTWARE.
  *
  */
 #ifndef INCLUDE_AMDSMI_H_
 #define INCLUDE_AMDSMI_H_
  
 #include <stdlib.h>
 #include <stdbool.h>
 #ifdef __cplusplus
 extern "C" {
 #include <cstdint>
 #else
 #include <stdint.h>
 #endif  // __cplusplus
  
 typedef enum {
   AMDSMI_INIT_ALL_DEVICES = 0x0,           // Default option
   AMDSMI_INIT_AMD_CPUS = (1 << 0),
   AMDSMI_INIT_AMD_GPUS = (1 << 1),
   AMDSMI_INIT_NON_AMD_CPUS = (1 << 2),
   AMDSMI_INIT_NON_AMD_GPUS = (1 << 3)
 } amdsmi_init_flags_t;
  
 /* Maximum size definitions AMDSMI */
 #define AMDSMI_MAX_MM_IP_COUNT        8
 #define AMDSMI_MAX_DATE_LENGTH        32 
 #define AMDSMI_MAX_STRING_LENGTH          64
 #define AMDSMI_NORMAL_STRING_LENGTH      32
 #define AMDSMI_MAX_DEVICES            32
 #define AMDSMI_MAX_NAME           32
 #define AMDSMI_MAX_DRIVER_VERSION_LENGTH 80
 #define AMDSMI_PRODUCT_NAME_LENGTH 128
 #define AMDSMI_MAX_CONTAINER_TYPE    2
  
 #define AMDSMI_GPU_UUID_SIZE 38
  
 /* string format */
 #define AMDSMI_TIME_FORMAT "%02d:%02d:%02d.%03d"
 #define AMDSMI_DATE_FORMAT "%04d-%02d-%02d:%02d:%02d:%02d.%03d"
  
 #define AMDSMI_LIB_VERSION_YEAR 23
  
 #define AMDSMI_LIB_VERSION_MAJOR 1
  
 #define AMDSMI_LIB_VERSION_MINOR 1
  
 #define AMDSMI_LIB_VERSION_RELEASE 0
  
 #define AMDSMI_LIB_VERSION_CREATE_STRING(YEAR, MAJOR, MINOR, RELEASE) (#YEAR "." #MAJOR "." #MINOR "." #RELEASE)
 #define AMDSMI_LIB_VERSION_EXPAND_PARTS(YEAR_STR, MAJOR_STR, MINOR_STR, RELEASE_STR) AMDSMI_LIB_VERSION_CREATE_STRING(YEAR_STR, MAJOR_STR, MINOR_STR, RELEASE_STR)
 #define AMDSMI_LIB_VERSION_STRING AMDSMI_LIB_VERSION_EXPAND_PARTS(AMDSMI_LIB_VERSION_YEAR, AMDSMI_LIB_VERSION_MAJOR, AMDSMI_LIB_VERSION_MINOR, AMDSMI_LIB_VERSION_RELEASE)
  
 typedef enum {
   AMDSMI_MM_UVD,
   AMDSMI_MM_VCE,
   AMDSMI_MM_VCN,
   AMDSMI_MM__MAX
 } amdsmi_mm_ip_t;
  
 typedef enum {
     CONTAINER_LXC,
     CONTAINER_DOCKER,
 } amdsmi_container_types_t;
  
 typedef void *amdsmi_device_handle;
 typedef void *amdsmi_socket_handle;
  
 typedef enum {
   UNKNOWN = 0,
   AMD_GPU,
   AMD_CPU,
   NON_AMD_GPU,
   NON_AMD_CPU
 } device_type_t;
  
 // Please avoid status codes that are multiples of 256 (256, 512, etc..)
 // Return values in the shell get modulo 256 applied, meaning any multiple of 256 ends up as 0
 typedef enum {
     AMDSMI_STATUS_SUCCESS = 0,  
     // Library usage errors
     AMDSMI_STATUS_INVAL = 1,  
     AMDSMI_STATUS_NOT_SUPPORTED = 2,  
     AMDSMI_STATUS_NOT_YET_IMPLEMENTED = 3,  
     AMDSMI_STATUS_FAIL_LOAD_MODULE = 4,  
     AMDSMI_STATUS_FAIL_LOAD_SYMBOL = 5,  
     AMDSMI_STATUS_DRM_ERROR = 6,  
     AMDSMI_STATUS_API_FAILED = 7,  
     AMDSMI_STATUS_TIMEOUT = 8,  
     AMDSMI_STATUS_RETRY = 9,  
     AMDSMI_STATUS_NO_PERM = 10,  
     AMDSMI_STATUS_INTERRUPT = 11,  
     AMDSMI_STATUS_IO = 12,  
     AMDSMI_STATUS_ADDRESS_FAULT = 13,  
     AMDSMI_STATUS_FILE_ERROR = 14,  
     AMDSMI_STATUS_OUT_OF_RESOURCES = 15,  
     AMDSMI_STATUS_INTERNAL_EXCEPTION = 16,  
     AMDSMI_STATUS_INPUT_OUT_OF_BOUNDS = 17,  
     AMDSMI_STATUS_INIT_ERROR = 18,  
     AMDSMI_STATUS_REFCOUNT_OVERFLOW = 19,  
     // Device related errors
     AMDSMI_STATUS_BUSY = 30,  
     AMDSMI_STATUS_NOT_FOUND = 31,  
     AMDSMI_STATUS_NOT_INIT = 32,  
     AMDSMI_STATUS_NO_SLOT = 33,  
     // Data and size errors
     AMDSMI_STATUS_NO_DATA = 40,  
     AMDSMI_STATUS_INSUFFICIENT_SIZE = 41,  
     AMDSMI_STATUS_UNEXPECTED_SIZE = 42,  
     AMDSMI_STATUS_UNEXPECTED_DATA = 43,  
     // General errors
     AMDSMI_STATUS_MAP_ERROR = 0xFFFFFFFE,  
     AMDSMI_STATUS_UNKNOWN_ERROR = 0xFFFFFFFF,  
 } amdsmi_status_t;
  
 typedef enum {
     CLK_TYPE_SYS = 0x0,   
     CLK_TYPE_FIRST = CLK_TYPE_SYS,
     CLK_TYPE_GFX = CLK_TYPE_SYS,
     CLK_TYPE_DF,  
     CLK_TYPE_DCEF,   
     CLK_TYPE_SOC,
     CLK_TYPE_MEM,
     CLK_TYPE_PCIE,
     CLK_TYPE_VCLK0,
     CLK_TYPE_VCLK1,
     CLK_TYPE_DCLK0,
     CLK_TYPE_DCLK1,
     CLK_TYPE__MAX = CLK_TYPE_DCLK1
 } amdsmi_clk_type_t;
  
 typedef enum {
     TEMPERATURE_TYPE_EDGE,
     TEMPERATURE_TYPE_FIRST = TEMPERATURE_TYPE_EDGE,
     TEMPERATURE_TYPE_JUNCTION,
     TEMPERATURE_TYPE_VRAM,
     TEMPERATURE_TYPE_HBM_0,
     TEMPERATURE_TYPE_HBM_1,
     TEMPERATURE_TYPE_HBM_2,
     TEMPERATURE_TYPE_HBM_3,
     TEMPERATURE_TYPE_PLX,
     TEMPERATURE_TYPE__MAX = TEMPERATURE_TYPE_PLX
 } amdsmi_temperature_type_t;
  
 typedef enum {
     FW_ID_SMU = 1,
     FW_ID_FIRST = FW_ID_SMU,
     FW_ID_CP_CE,
     FW_ID_CP_PFP,
     FW_ID_CP_ME,
     FW_ID_CP_MEC_JT1,
     FW_ID_CP_MEC_JT2,
     FW_ID_CP_MEC1,
     FW_ID_CP_MEC2,
     FW_ID_RLC,
     FW_ID_SDMA0,
     FW_ID_SDMA1,
     FW_ID_SDMA2,
     FW_ID_SDMA3,
     FW_ID_SDMA4,
     FW_ID_SDMA5,
     FW_ID_SDMA6,
     FW_ID_SDMA7,
     FW_ID_VCN,
     FW_ID_UVD,
     FW_ID_VCE,
     FW_ID_ISP,
     FW_ID_DMCU_ERAM, /*eRAM*/
     FW_ID_DMCU_ISR,  /*ISR*/
     FW_ID_RLC_RESTORE_LIST_GPM_MEM,
     FW_ID_RLC_RESTORE_LIST_SRM_MEM,
     FW_ID_RLC_RESTORE_LIST_CNTL,
     FW_ID_RLC_V,
     FW_ID_MMSCH,
     FW_ID_PSP_SYSDRV,
     FW_ID_PSP_SOSDRV,
     FW_ID_PSP_TOC,
     FW_ID_PSP_KEYDB,
     FW_ID_DFC,
     FW_ID_PSP_SPL,
     FW_ID_DRV_CAP,
     FW_ID_MC,
     FW_ID_PSP_BL,
     FW_ID_CP_PM4,
     FW_ID_ASD,
     FW_ID_TA_RAS,
     FW_ID_XGMI,
     FW_ID_RLC_SRLG,
     FW_ID_RLC_SRLS,
     FW_ID_SMC,
     FW_ID_DMCU,
     FW_ID__MAX
 } amdsmi_fw_block_t;
  
 typedef struct {
     uint64_t lower_bound;      
     uint64_t upper_bound;      
     uint64_t reserved[2];
 } amdsmi_range_t;
  
 typedef struct {
   uint8_t xgmi_lanes;
   uint64_t xgmi_hive_id;
   uint64_t xgmi_node_id;
   uint32_t index;
   uint32_t reserved[9];
 } amdsmi_xgmi_info_t;
  
 typedef struct {
   struct {
     uint32_t gfxip_major;
     uint32_t gfxip_minor;
     uint16_t gfxip_cu_count;
     uint32_t reserved[5];
   } gfx;
   struct {
     uint8_t mm_ip_count;
     uint8_t mm_ip_list[AMDSMI_MAX_MM_IP_COUNT];
     uint32_t reserved[5];
   } mm;
  
   bool ras_supported;
   uint8_t max_vf_num;
   uint32_t gfx_ip_count;
   uint32_t dma_ip_count;
   uint32_t reserved[5];
 } amdsmi_gpu_caps_t;
  
 typedef struct {
   uint32_t vram_total;
   uint32_t vram_used;
 } amdsmi_vram_info_t;
  
 typedef struct {
     amdsmi_range_t supported_freq_range;
     amdsmi_range_t current_freq_range;
     uint32_t reserved[8];
 } amdsmi_frequency_range_t;
  
 typedef union {
   struct {
     uint64_t function_number : 3;
     uint64_t device_number : 5;
     uint64_t bus_number : 8;
     uint64_t domain_number : 48;
   };
   uint64_t as_uint;
 } amdsmi_bdf_t;
  
 typedef struct {
   uint64_t power_cap;
   uint64_t default_power_cap;
   uint64_t dpm_cap;
   uint64_t min_power_cap;
   uint64_t max_power_cap;
   uint64_t reserved[3];
 } amdsmi_power_cap_info_t;
  
 typedef struct {
   char    name[AMDSMI_MAX_STRING_LENGTH];
   uint32_t vbios_version;
   char    build_date[AMDSMI_MAX_DATE_LENGTH];
   char    part_number[AMDSMI_MAX_STRING_LENGTH];
   char    vbios_version_string[AMDSMI_NORMAL_STRING_LENGTH];
   uint32_t reserved[15];
 } amdsmi_vbios_info_t;
  
 typedef struct {
   uint8_t num_fw_info;
   struct {
     amdsmi_fw_block_t fw_id;
     uint64_t fw_version;
     uint64_t reserved[2];
   } fw_info_list[FW_ID__MAX];
   uint32_t reserved[7];
 } amdsmi_fw_info_t;
  
 typedef struct {
   char  market_name[AMDSMI_MAX_STRING_LENGTH];
   uint32_t family; 
   uint32_t vendor_id;   //< Use 32 bit to be compatible with other platform.
   uint32_t subvendor_id;   //< The subsystem vendor id
   uint64_t device_id;   //< The unique id of a GPU
   uint32_t rev_id;
   char asic_serial[AMDSMI_NORMAL_STRING_LENGTH];
 } amdsmi_asic_info_t;
  
 typedef struct {
   uint64_t serial_number;
   bool  is_master;
   char  model_number[AMDSMI_NORMAL_STRING_LENGTH];
   char  product_serial[AMDSMI_NORMAL_STRING_LENGTH];
   char  fru_id[AMDSMI_NORMAL_STRING_LENGTH];
   char  product_name[AMDSMI_PRODUCT_NAME_LENGTH];
   char  manufacturer_name[AMDSMI_NORMAL_STRING_LENGTH];
 } amdsmi_board_info_t;
  
 typedef struct {
   uint32_t average_socket_power;
   uint64_t energy_accumulator;      // v1 mod. (32->64)
   uint32_t voltage_gfx;   // GFX voltage measurement in mV
   uint32_t voltage_soc;  // SOC voltage measurement in mV
   uint32_t voltage_mem;  // MEM voltage measurement in mV
   uint32_t power_limit;  // The power limit;
   uint32_t reserved[9];
 } amdsmi_power_measure_t;
  
 typedef struct {
   uint32_t cur_clk;
   uint32_t avg_clk;
   uint32_t min_clk;
   uint32_t max_clk;
   uint32_t reserved[4];
 } amdsmi_clk_measure_t;
  
 typedef struct {
   uint32_t gfx_activity;
   uint32_t umc_activity;
   uint32_t mm_activity[AMDSMI_MAX_MM_IP_COUNT];
   uint32_t reserved[6];
 } amdsmi_engine_usage_t;
  
 typedef uint32_t amdsmi_process_handle;
  
 typedef struct {
     char                  name[AMDSMI_NORMAL_STRING_LENGTH];
     amdsmi_process_handle pid;
     uint64_t              mem; 
     struct {
         uint64_t gfx;
         uint64_t compute;
         uint64_t dma;
         uint64_t enc;
         uint64_t dec;
     } engine_usage; 
   struct {
     uint64_t gtt_mem;
     uint64_t cpu_mem;
     uint64_t vram_mem;
   } memory_usage; 
   char container_name[AMDSMI_NORMAL_STRING_LENGTH];
   uint32_t reserved[10];
 } amdsmi_proc_info_t;
  
 #define AMDSMI_MAX_NUM_FREQUENCIES 32
  
 #define AMDSMI_MAX_FAN_SPEED 255
  
 #define AMDSMI_NUM_VOLTAGE_CURVE_POINTS 3
 typedef enum {
   AMDSMI_DEV_PERF_LEVEL_AUTO = 0,       
   AMDSMI_DEV_PERF_LEVEL_FIRST = AMDSMI_DEV_PERF_LEVEL_AUTO,
  
   AMDSMI_DEV_PERF_LEVEL_LOW,              
   AMDSMI_DEV_PERF_LEVEL_HIGH,             
   AMDSMI_DEV_PERF_LEVEL_MANUAL,           
   AMDSMI_DEV_PERF_LEVEL_STABLE_STD,       
   AMDSMI_DEV_PERF_LEVEL_STABLE_PEAK,      
   AMDSMI_DEV_PERF_LEVEL_STABLE_MIN_MCLK,  
   AMDSMI_DEV_PERF_LEVEL_STABLE_MIN_SCLK,  
   AMDSMI_DEV_PERF_LEVEL_DETERMINISM,      
  
   AMDSMI_DEV_PERF_LEVEL_LAST = AMDSMI_DEV_PERF_LEVEL_DETERMINISM,
  
   AMDSMI_DEV_PERF_LEVEL_UNKNOWN = 0x100   
 } amdsmi_dev_perf_level_t;
  
 typedef enum {
   AMDSMI_SW_COMP_FIRST = 0x0,
  
   AMDSMI_SW_COMP_DRIVER = AMDSMI_SW_COMP_FIRST,    
  
   AMDSMI_SW_COMP_LAST = AMDSMI_SW_COMP_DRIVER
 } amdsmi_sw_component_t;
  
 typedef uintptr_t amdsmi_event_handle_t;
  
 typedef enum {
   AMDSMI_EVNT_GRP_XGMI = 0,         
   AMDSMI_EVNT_GRP_XGMI_DATA_OUT = 10,  
   AMDSMI_EVNT_GRP_INVALID = 0xFFFFFFFF
 } amdsmi_event_group_t;
  
 typedef enum {
   AMDSMI_EVNT_FIRST = AMDSMI_EVNT_GRP_XGMI,
  
   AMDSMI_EVNT_XGMI_FIRST = AMDSMI_EVNT_GRP_XGMI,
   AMDSMI_EVNT_XGMI_0_NOP_TX = AMDSMI_EVNT_XGMI_FIRST,  
   AMDSMI_EVNT_XGMI_0_REQUEST_TX,                    
   AMDSMI_EVNT_XGMI_0_RESPONSE_TX,                   
  
   // ie, Throughput = BEATS/time_running 10^9  bytes/sec
   AMDSMI_EVNT_XGMI_0_BEATS_TX,
   AMDSMI_EVNT_XGMI_1_NOP_TX,                        
   AMDSMI_EVNT_XGMI_1_REQUEST_TX,                        
   AMDSMI_EVNT_XGMI_1_RESPONSE_TX,                   
   AMDSMI_EVNT_XGMI_1_BEATS_TX,                      
  
   AMDSMI_EVNT_XGMI_LAST = AMDSMI_EVNT_XGMI_1_BEATS_TX,   // 5
  
   AMDSMI_EVNT_XGMI_DATA_OUT_FIRST = AMDSMI_EVNT_GRP_XGMI_DATA_OUT,  // 10
  
   /*
    * @brief Events in the AMDSMI_EVNT_GRP_XGMI_DATA_OUT group measure
    * the number of beats sent on an XGMI link. Each beat represents
    * 32 bytes. AMDSMI_EVNT_XGMI_DATA_OUT_n represents the number of
    * outbound beats (each representing 32 bytes) on link n.<br><br>
    *
    * XGMI throughput can be calculated by multiplying a event
    * such as ::AMDSMI_EVNT_XGMI_DATA_OUT_n by 32 and dividing by
    * the time for which event collection occurred,
    * ::amdsmi_counter_value_t.time_running (which is in nanoseconds). To get
    * bytes per second, multiply this value by 10<sup>9</sup>.<br>
    * <br>
    * Throughput = BEATS/time_running * 10<sup>9</sup>  (bytes/second)<br>
    */
   // ie, Throughput = BEATS/time_running 10^9  bytes/sec
   AMDSMI_EVNT_XGMI_DATA_OUT_0 = AMDSMI_EVNT_XGMI_DATA_OUT_FIRST,
   AMDSMI_EVNT_XGMI_DATA_OUT_1,   
   AMDSMI_EVNT_XGMI_DATA_OUT_2,   
   AMDSMI_EVNT_XGMI_DATA_OUT_3,   
   AMDSMI_EVNT_XGMI_DATA_OUT_4,   
   AMDSMI_EVNT_XGMI_DATA_OUT_5,   
   AMDSMI_EVNT_XGMI_DATA_OUT_LAST = AMDSMI_EVNT_XGMI_DATA_OUT_5,
  
   AMDSMI_EVNT_LAST = AMDSMI_EVNT_XGMI_DATA_OUT_LAST,
 } amdsmi_event_type_t;
  
 typedef enum {
   AMDSMI_CNTR_CMD_START = 0,  
   AMDSMI_CNTR_CMD_STOP,       
 } amdsmi_counter_command_t;
  
 typedef struct {
   uint64_t value;            
   uint64_t time_enabled;     
   uint64_t time_running;     
 } amdsmi_counter_value_t;
  
 typedef enum {
   AMDSMI_EVT_NOTIF_VMFAULT = 1,  
   AMDSMI_EVT_NOTIF_FIRST = AMDSMI_EVT_NOTIF_VMFAULT,
   AMDSMI_EVT_NOTIF_THERMAL_THROTTLE = 2,
   AMDSMI_EVT_NOTIF_GPU_PRE_RESET = 3,
   AMDSMI_EVT_NOTIF_GPU_POST_RESET = 4,
  
   AMDSMI_EVT_NOTIF_LAST = AMDSMI_EVT_NOTIF_GPU_POST_RESET
 } amdsmi_evt_notification_type_t;
  
 #define AMDSMI_EVENT_MASK_FROM_INDEX(i) (1ULL << ((i) - 1))
  
 #define MAX_EVENT_NOTIFICATION_MSG_SIZE 64
  
 typedef struct {
     amdsmi_device_handle device_handle;        
     amdsmi_evt_notification_type_t event;     
     char message[MAX_EVENT_NOTIFICATION_MSG_SIZE];  
 } amdsmi_evt_notification_data_t;
  
 typedef enum {
   AMDSMI_TEMP_CURRENT = 0x0,   
   AMDSMI_TEMP_FIRST = AMDSMI_TEMP_CURRENT,
  
   AMDSMI_TEMP_MAX,             
   AMDSMI_TEMP_MIN,             
   AMDSMI_TEMP_MAX_HYST,        
   AMDSMI_TEMP_MIN_HYST,        
   AMDSMI_TEMP_CRITICAL,        
   AMDSMI_TEMP_CRITICAL_HYST,   
   AMDSMI_TEMP_EMERGENCY,       
   AMDSMI_TEMP_EMERGENCY_HYST,  
   AMDSMI_TEMP_CRIT_MIN,        
   AMDSMI_TEMP_CRIT_MIN_HYST,   
   AMDSMI_TEMP_OFFSET,          
   AMDSMI_TEMP_LOWEST,          
   AMDSMI_TEMP_HIGHEST,         
  
   AMDSMI_TEMP_LAST = AMDSMI_TEMP_HIGHEST
 } amdsmi_temperature_metric_t;
  
 typedef enum {
   AMDSMI_VOLT_CURRENT = 0x0,               
  
   AMDSMI_VOLT_FIRST = AMDSMI_VOLT_CURRENT,
   AMDSMI_VOLT_MAX,                         
   AMDSMI_VOLT_MIN_CRIT,                    
   AMDSMI_VOLT_MIN,                         
   AMDSMI_VOLT_MAX_CRIT,                    
   AMDSMI_VOLT_AVERAGE,                     
   AMDSMI_VOLT_LOWEST,                      
   AMDSMI_VOLT_HIGHEST,                     
  
   AMDSMI_VOLT_LAST = AMDSMI_VOLT_HIGHEST
 } amdsmi_voltage_metric_t;
  
 typedef enum {
   AMDSMI_VOLT_TYPE_FIRST = 0,
  
   AMDSMI_VOLT_TYPE_VDDGFX = AMDSMI_VOLT_TYPE_FIRST,  
   AMDSMI_VOLT_TYPE_LAST = AMDSMI_VOLT_TYPE_VDDGFX,
   AMDSMI_VOLT_TYPE_INVALID = 0xFFFFFFFF            
 } amdsmi_voltage_type_t;
  
 typedef enum {
   AMDSMI_PWR_PROF_PRST_CUSTOM_MASK = 0x1,        
   AMDSMI_PWR_PROF_PRST_VIDEO_MASK = 0x2,         
   AMDSMI_PWR_PROF_PRST_POWER_SAVING_MASK = 0x4,  
   AMDSMI_PWR_PROF_PRST_COMPUTE_MASK = 0x8,       
   AMDSMI_PWR_PROF_PRST_VR_MASK = 0x10,           
  
   AMDSMI_PWR_PROF_PRST_3D_FULL_SCR_MASK = 0x20,
   AMDSMI_PWR_PROF_PRST_BOOTUP_DEFAULT = 0x40,    
   AMDSMI_PWR_PROF_PRST_LAST = AMDSMI_PWR_PROF_PRST_BOOTUP_DEFAULT,
  
   AMDSMI_PWR_PROF_PRST_INVALID = 0xFFFFFFFFFFFFFFFF
 } amdsmi_power_profile_preset_masks_t;
  
 typedef enum {
   AMDSMI_GPU_BLOCK_INVALID =   0x0000000000000000,  
   AMDSMI_GPU_BLOCK_FIRST =     0x0000000000000001,
  
   AMDSMI_GPU_BLOCK_UMC = AMDSMI_GPU_BLOCK_FIRST,      
   AMDSMI_GPU_BLOCK_SDMA =      0x0000000000000002,  
   AMDSMI_GPU_BLOCK_GFX =       0x0000000000000004,  
   AMDSMI_GPU_BLOCK_MMHUB =     0x0000000000000008,  
   AMDSMI_GPU_BLOCK_ATHUB =     0x0000000000000010,  
   AMDSMI_GPU_BLOCK_PCIE_BIF =  0x0000000000000020,  
   AMDSMI_GPU_BLOCK_HDP =       0x0000000000000040,  
   AMDSMI_GPU_BLOCK_XGMI_WAFL = 0x0000000000000080,  
   AMDSMI_GPU_BLOCK_DF =        0x0000000000000100,  
   AMDSMI_GPU_BLOCK_SMN =       0x0000000000000200,  
   AMDSMI_GPU_BLOCK_SEM =       0x0000000000000400,  
   AMDSMI_GPU_BLOCK_MP0 =       0x0000000000000800,  
   AMDSMI_GPU_BLOCK_MP1 =       0x0000000000001000,  
   AMDSMI_GPU_BLOCK_FUSE =      0x0000000000002000,  
  
   AMDSMI_GPU_BLOCK_LAST = AMDSMI_GPU_BLOCK_FUSE,       
   AMDSMI_GPU_BLOCK_RESERVED =  0x8000000000000000
 } amdsmi_gpu_block_t;
  
 typedef enum {
   AMDSMI_RAS_ERR_STATE_NONE = 0,   
   AMDSMI_RAS_ERR_STATE_DISABLED,   
   AMDSMI_RAS_ERR_STATE_PARITY,     
   AMDSMI_RAS_ERR_STATE_SING_C,     
   AMDSMI_RAS_ERR_STATE_MULT_UC,    
   AMDSMI_RAS_ERR_STATE_POISON,     
   AMDSMI_RAS_ERR_STATE_ENABLED,    
  
   AMDSMI_RAS_ERR_STATE_LAST = AMDSMI_RAS_ERR_STATE_ENABLED,
   AMDSMI_RAS_ERR_STATE_INVALID = 0xFFFFFFFF
 } amdsmi_ras_err_state_t;
  
 typedef enum {
   AMDSMI_MEM_TYPE_FIRST = 0,
  
   AMDSMI_MEM_TYPE_VRAM = AMDSMI_MEM_TYPE_FIRST,  
   AMDSMI_MEM_TYPE_VIS_VRAM,                    
   AMDSMI_MEM_TYPE_GTT,                         
  
   AMDSMI_MEM_TYPE_LAST = AMDSMI_MEM_TYPE_GTT
 } amdsmi_memory_type_t;
  
 typedef enum {
   AMDSMI_FREQ_IND_MIN = 0,  
   AMDSMI_FREQ_IND_MAX = 1,  
   AMDSMI_FREQ_IND_INVALID = 0xFFFFFFFF  
 } amdsmi_freq_ind_t;
  
 typedef enum {
   AMDSMI_XGMI_STATUS_NO_ERRORS = 0,
   AMDSMI_XGMI_STATUS_ERROR,
   AMDSMI_XGMI_STATUS_MULTIPLE_ERRORS,
 } amdsmi_xgmi_status_t;
  
 typedef uint64_t amdsmi_bit_field_t;
  
 typedef enum {
   AMDSMI_MEM_PAGE_STATUS_RESERVED = 0,  
   AMDSMI_MEM_PAGE_STATUS_PENDING,       
   AMDSMI_MEM_PAGE_STATUS_UNRESERVABLE   
 } amdsmi_memory_page_status_t;
  
 typedef enum {
   AMDSMI_IOLINK_TYPE_UNDEFINED      = 0,          
   AMDSMI_IOLINK_TYPE_PCIEXPRESS     = 1,          
   AMDSMI_IOLINK_TYPE_XGMI           = 2,          
   AMDSMI_IOLINK_TYPE_NUMIOLINKTYPES,              
   AMDSMI_IOLINK_TYPE_SIZE           = 0xFFFFFFFF  
 } AMDSMI_IO_LINK_TYPE;
  
 typedef enum {
   AMDSMI_UTILIZATION_COUNTER_FIRST = 0,
   AMDSMI_COARSE_GRAIN_GFX_ACTIVITY  = AMDSMI_UTILIZATION_COUNTER_FIRST,
   AMDSMI_COARSE_GRAIN_MEM_ACTIVITY,    
   AMDSMI_UTILIZATION_COUNTER_LAST = AMDSMI_COARSE_GRAIN_MEM_ACTIVITY
 } AMDSMI_UTILIZATION_COUNTER_TYPE;
  
 typedef struct {
   AMDSMI_UTILIZATION_COUNTER_TYPE type;   
   uint64_t value;                       
 } amdsmi_utilization_counter_t;
  
 typedef struct {
   uint64_t page_address;                  
   uint64_t page_size;                     
   amdsmi_memory_page_status_t status;       
 } amdsmi_retired_page_record_t;
  
 #define AMDSMI_MAX_NUM_POWER_PROFILES (sizeof(amdsmi_bit_field_t) * 8)
  
 typedef struct {
     amdsmi_bit_field_t available_profiles;
  
     amdsmi_power_profile_preset_masks_t current;
  
     uint32_t num_profiles;
 } amdsmi_power_profile_status_t;
  
 typedef struct {
     uint32_t num_supported;
  
     uint32_t current;
  
     uint64_t frequency[AMDSMI_MAX_NUM_FREQUENCIES];
 } amdsmi_frequencies_t;
  
 typedef struct {
     amdsmi_frequencies_t transfer_rate;
  
     uint32_t lanes[AMDSMI_MAX_NUM_FREQUENCIES];
 } amdsmi_pcie_bandwidth_t;
  
 typedef struct {
     uint32_t major;     
     uint32_t minor;     
     uint32_t patch;     
     const char *build;  
     uint32_t reserved[4];
 } amdsmi_version_t;
  
 typedef struct {
     uint64_t frequency;      
     uint64_t voltage;        
 } amdsmi_od_vddc_point_t;
  
 typedef struct {
     amdsmi_range_t freq_range;  
     amdsmi_range_t volt_range;  
 } amdsmi_freq_volt_region_t;
  
 typedef struct {
     amdsmi_od_vddc_point_t vc_points[AMDSMI_NUM_VOLTAGE_CURVE_POINTS];
 } amdsmi_od_volt_curve_t;
  
 typedef struct {
   amdsmi_range_t curr_sclk_range;          
   amdsmi_range_t curr_mclk_range;          
   amdsmi_range_t sclk_freq_limits;         
   amdsmi_range_t mclk_freq_limits;         
  
   amdsmi_od_volt_curve_t curve;
   uint32_t num_regions;                
 } amdsmi_od_volt_freq_data_t;
  
 typedef struct {
   // TODO(amd) Doxygen documents
   uint16_t      structure_size;
   uint8_t       format_revision;
   uint8_t       content_revision;
 } amd_metrics_table_header_t;
  
 // Below is the assumed version of gpu_metric data on the device. If the device
 // is using this version, we can read data directly into amdsmi_gpu_metrics_t.
 // If the device is using an older format, a conversion of formats will be
 // required.
 // DGPU targets have a format version of 1. APU targets have a format version of
 // 2. Currently, only version 1 (DGPU) gpu_metrics is supported.
 #define AMDSMI_GPU_METRICS_API_FORMAT_VER 1
 // The content version increments when gpu_metrics is extended with new and/or
 // existing field sizes are changed.
 #define AMDSMI_GPU_METRICS_API_CONTENT_VER_1 1
 #define AMDSMI_GPU_METRICS_API_CONTENT_VER_2 2
 #define AMDSMI_GPU_METRICS_API_CONTENT_VER_3 3
  
 // This should match NUM_HBM_INSTANCES
 #define AMDSMI_NUM_HBM_INSTANCES 4
  
 // Unit conversion factor for HBM temperatures
 #define CENTRIGRADE_TO_MILLI_CENTIGRADE 1000
  
 typedef struct {
 // TODO(amd) Doxygen documents
   amd_metrics_table_header_t common_header;
  
 /* Temperature */
   uint16_t      temperature_edge;
   uint16_t      temperature_hotspot;
   uint16_t      temperature_mem;
   uint16_t      temperature_vrgfx;
   uint16_t      temperature_vrsoc;
   uint16_t      temperature_vrmem;
  
 /* Utilization */
   uint16_t      average_gfx_activity;
   uint16_t      average_umc_activity;  // memory controller
   uint16_t      average_mm_activity;   // UVD or VCN
  
 /* Power/Energy */
   uint16_t      average_socket_power;
   uint64_t      energy_accumulator;      // v1 mod. (32->64)
  
 /* Driver attached timestamp (in ns) */
   uint64_t      system_clock_counter;   // v1 mod. (moved from top of struct)
  
 /* Average clocks */
   uint16_t      average_gfxclk_frequency;
   uint16_t      average_socclk_frequency;
   uint16_t      average_uclk_frequency;
   uint16_t      average_vclk0_frequency;
   uint16_t      average_dclk0_frequency;
   uint16_t      average_vclk1_frequency;
   uint16_t      average_dclk1_frequency;
  
 /* Current clocks */
   uint16_t      current_gfxclk;
   uint16_t      current_socclk;
   uint16_t      current_uclk;
   uint16_t      current_vclk0;
   uint16_t      current_dclk0;
   uint16_t      current_vclk1;
   uint16_t      current_dclk1;
  
 /* Throttle status */
   uint32_t      throttle_status;
  
 /* Fans */
   uint16_t      current_fan_speed;
  
 /* Link width/speed */
   uint16_t       pcie_link_width;  // v1 mod.(8->16)
   uint16_t       pcie_link_speed;  // in 0.1 GT/s; v1 mod. (8->16)
  
   uint16_t       padding;          // new in v1
  
   uint32_t       gfx_activity_acc;   // new in v1
   uint32_t       mem_actvity_acc;     // new in v1
   uint16_t       temperature_hbm[AMDSMI_NUM_HBM_INSTANCES];  // new in v1
 } amdsmi_gpu_metrics_t;
  
 typedef struct {
     uint64_t correctable_count;            
     uint64_t uncorrectable_count;          
     uint64_t reserved[2];
 } amdsmi_error_count_t;
  
 typedef struct {
     uint16_t pcie_lanes;
     uint32_t pcie_speed;
     uint32_t reserved[6];
 } amdsmi_pcie_info_t;
 typedef struct {
     uint32_t process_id;      
     uint32_t pasid;           
     uint64_t vram_usage;      
     uint64_t sdma_usage;      
     uint32_t cu_occupancy;    
 } amdsmi_process_info_t;
  
 typedef struct amdsmi_func_id_iter_handle * amdsmi_func_id_iter_handle_t;
  
 #define AMDSMI_DEFAULT_VARIANT 0xFFFFFFFFFFFFFFFF
  
 typedef union {
         uint64_t id;           
         const char *name;      
         union {
             amdsmi_memory_type_t memory_type;
             amdsmi_temperature_metric_t temp_metric;
             amdsmi_event_type_t evnt_type;
             amdsmi_event_group_t evnt_group;
             amdsmi_clk_type_t clk_type;
             amdsmi_fw_block_t fw_block;
             amdsmi_gpu_block_t gpu_block_type;
         };
 } amdsmi_func_id_value_t;
  
 /*****************************************************************************/
 amdsmi_status_t amdsmi_init(uint64_t init_flags);
  
 amdsmi_status_t amdsmi_shut_down(void);
  
 /*****************************************************************************/
 amdsmi_status_t amdsmi_get_socket_handles(uint32_t *socket_count,
                 amdsmi_socket_handle* socket_handles);
  
 amdsmi_status_t amdsmi_get_socket_info(
                 amdsmi_socket_handle socket_handle,
                 char *name, size_t len);
  
 amdsmi_status_t amdsmi_get_device_handles(amdsmi_socket_handle socket_handle,
                                     uint32_t *device_count,
                                     amdsmi_device_handle* device_handles);
  
 amdsmi_status_t amdsmi_get_device_type(amdsmi_device_handle device_handle,
               device_type_t* device_type);
  
 amdsmi_status_t amdsmi_get_device_handle_from_bdf(amdsmi_bdf_t bdf, amdsmi_device_handle* device_handle);
  
 /*****************************************************************************/
 amdsmi_status_t amdsmi_dev_get_id(amdsmi_device_handle device_handle, uint16_t *id);
  
 amdsmi_status_t amdsmi_dev_get_vendor_name(amdsmi_device_handle device_handle, char *name,
                                                                   size_t len);
  
 amdsmi_status_t amdsmi_dev_get_vram_vendor(amdsmi_device_handle device_handle, char *brand,
                                                                 uint32_t len);
  
 amdsmi_status_t amdsmi_dev_get_subsystem_id(amdsmi_device_handle device_handle, uint16_t *id);
  
 amdsmi_status_t
 amdsmi_dev_get_subsystem_name(amdsmi_device_handle device_handle, char *name, size_t len);
  
 amdsmi_status_t
 amdsmi_dev_get_drm_render_minor(amdsmi_device_handle device_handle, uint32_t *minor);
  
 /*****************************************************************************/
 amdsmi_status_t
 amdsmi_dev_get_pci_bandwidth(amdsmi_device_handle device_handle, amdsmi_pcie_bandwidth_t *bandwidth);
  
 amdsmi_status_t amdsmi_dev_get_pci_id(amdsmi_device_handle device_handle, uint64_t *bdfid);
  
 amdsmi_status_t amdsmi_topo_get_numa_affinity(amdsmi_device_handle device_handle, uint32_t *numa_node);
  
 amdsmi_status_t amdsmi_dev_get_pci_throughput(amdsmi_device_handle device_handle, uint64_t *sent,
                                     uint64_t *received, uint64_t *max_pkt_sz);
  
 amdsmi_status_t  amdsmi_dev_get_pci_replay_counter(amdsmi_device_handle device_handle,
                                                            uint64_t *counter);
  
 /*****************************************************************************/
 amdsmi_status_t  amdsmi_dev_set_pci_bandwidth(amdsmi_device_handle device_handle, uint64_t bw_bitmask);
  
 /*****************************************************************************/
 amdsmi_status_t
 amdsmi_dev_get_power_ave(amdsmi_device_handle device_handle, uint32_t sensor_ind, uint64_t *power);
  
 amdsmi_status_t
 amdsmi_dev_get_energy_count(amdsmi_device_handle device_handle, uint64_t *power,
                           float *counter_resolution, uint64_t *timestamp);
  
 /*****************************************************************************/
 amdsmi_status_t
  amdsmi_dev_set_power_cap(amdsmi_device_handle device_handle, uint32_t sensor_ind, uint64_t cap);
  
 amdsmi_status_t
  amdsmi_dev_set_power_profile(amdsmi_device_handle device_handle, uint32_t reserved,
                                    amdsmi_power_profile_preset_masks_t profile);
  
 /*****************************************************************************/
 amdsmi_status_t
 amdsmi_dev_get_memory_total(amdsmi_device_handle device_handle, amdsmi_memory_type_t mem_type,
                                                              uint64_t *total);
  
 amdsmi_status_t
 amdsmi_dev_get_memory_usage(amdsmi_device_handle device_handle, amdsmi_memory_type_t mem_type,
                                                               uint64_t *used);
  
 amdsmi_status_t
 amdsmi_get_bad_page_info(amdsmi_device_handle device_handle, uint32_t *num_pages, amdsmi_retired_page_record_t *info);
  
 amdsmi_status_t
 amdsmi_get_ras_block_features_enabled(amdsmi_device_handle device_handle, amdsmi_gpu_block_t block,
                                                                   amdsmi_ras_err_state_t *state);
  
 amdsmi_status_t
 amdsmi_dev_get_memory_busy_percent(amdsmi_device_handle device_handle, uint32_t *busy_percent);
  
 amdsmi_status_t
 amdsmi_dev_get_memory_reserved_pages(amdsmi_device_handle device_handle, uint32_t *num_pages,
                                          amdsmi_retired_page_record_t *records);
  
 amdsmi_status_t amdsmi_dev_get_fan_rpms(amdsmi_device_handle device_handle, uint32_t sensor_ind,
                                                               int64_t *speed);
  
 amdsmi_status_t amdsmi_dev_get_fan_speed(amdsmi_device_handle device_handle,
                                         uint32_t sensor_ind, int64_t *speed);
  
 amdsmi_status_t amdsmi_dev_get_fan_speed_max(amdsmi_device_handle device_handle,
                                     uint32_t sensor_ind, uint64_t *max_speed);
  
 amdsmi_status_t  amdsmi_dev_get_temp_metric(amdsmi_device_handle device_handle,
                       amdsmi_temperature_type_t sensor_type,
                       amdsmi_temperature_metric_t metric, int64_t *temperature);
  
 amdsmi_status_t  amdsmi_dev_get_volt_metric(amdsmi_device_handle device_handle,
                                amdsmi_voltage_type_t sensor_type,
                               amdsmi_voltage_metric_t metric, int64_t *voltage);
  
 /*****************************************************************************/
 amdsmi_status_t amdsmi_dev_reset_fan(amdsmi_device_handle device_handle, uint32_t sensor_ind);
  
 amdsmi_status_t amdsmi_dev_set_fan_speed(amdsmi_device_handle device_handle,
       uint32_t sensor_ind, uint64_t speed);
  
 /*****************************************************************************/
 amdsmi_status_t
 amdsmi_dev_get_busy_percent(amdsmi_device_handle device_handle, uint32_t *busy_percent);
  
 amdsmi_status_t
 amdsmi_get_utilization_count(amdsmi_device_handle device_handle,
                 amdsmi_utilization_counter_t utilization_counters[],
                 uint32_t count,
                 uint64_t *timestamp);
  
 amdsmi_status_t amdsmi_get_pcie_link_status(amdsmi_device_handle device_handle, amdsmi_pcie_info_t *info);
  
 amdsmi_status_t amdsmi_get_pcie_link_caps(amdsmi_device_handle device_handle, amdsmi_pcie_info_t *info);
  
 amdsmi_status_t amdsmi_dev_get_perf_level(amdsmi_device_handle device_handle,
                                                  amdsmi_dev_perf_level_t *perf);
  
 amdsmi_status_t
 amdsmi_set_perf_determinism_mode(amdsmi_device_handle device_handle, uint64_t clkvalue);
  
 amdsmi_status_t amdsmi_dev_get_overdrive_level(amdsmi_device_handle device_handle, uint32_t *od);
  
 amdsmi_status_t  amdsmi_dev_get_gpu_clk_freq(amdsmi_device_handle device_handle,
                              amdsmi_clk_type_t clk_type, amdsmi_frequencies_t *f);
  
 amdsmi_status_t amdsmi_dev_reset_gpu(amdsmi_device_handle device_handle);
  
 amdsmi_status_t  amdsmi_dev_get_od_volt_info(amdsmi_device_handle device_handle,
                                                amdsmi_od_volt_freq_data_t *odv);
  
 amdsmi_status_t  amdsmi_dev_get_gpu_metrics_info(amdsmi_device_handle device_handle,
                                             amdsmi_gpu_metrics_t *pgpu_metrics);
  
 amdsmi_status_t amdsmi_dev_set_clk_range(amdsmi_device_handle device_handle, uint64_t minclkvalue,
                                        uint64_t maxclkvalue,
                                        amdsmi_clk_type_t clkType);
  
 amdsmi_status_t  amdsmi_dev_set_od_clk_info(amdsmi_device_handle device_handle, amdsmi_freq_ind_t level,
                                        uint64_t clkvalue,
                                        amdsmi_clk_type_t clkType);
  
 amdsmi_status_t  amdsmi_dev_set_od_volt_info(amdsmi_device_handle device_handle, uint32_t vpoint,
                                         uint64_t clkvalue, uint64_t voltvalue);
  
 amdsmi_status_t  amdsmi_dev_get_od_volt_curve_regions(amdsmi_device_handle device_handle,
                       uint32_t *num_regions, amdsmi_freq_volt_region_t *buffer);
  
 amdsmi_status_t
  amdsmi_dev_get_power_profile_presets(amdsmi_device_handle device_handle, uint32_t sensor_ind,
                                          amdsmi_power_profile_status_t *status);
  
 /*****************************************************************************/
 amdsmi_status_t
  amdsmi_dev_set_perf_level(amdsmi_device_handle device_handle, amdsmi_dev_perf_level_t perf_lvl);
  
 amdsmi_status_t
  amdsmi_dev_set_perf_level_v1(amdsmi_device_handle device_handle, amdsmi_dev_perf_level_t perf_lvl);
  
 amdsmi_status_t  amdsmi_dev_set_overdrive_level(amdsmi_device_handle device_handle, uint32_t od);
  
 amdsmi_status_t  amdsmi_dev_set_overdrive_level_v1(amdsmi_device_handle device_handle, uint32_t od);
  
 amdsmi_status_t  amdsmi_dev_set_clk_freq(amdsmi_device_handle device_handle,
                              amdsmi_clk_type_t clk_type, uint64_t freq_bitmask);
  
 /*****************************************************************************/
 amdsmi_status_t
 amdsmi_get_version(amdsmi_version_t *version);
  
 amdsmi_status_t
 amdsmi_get_version_str(amdsmi_sw_component_t component, char *ver_str,
                                                                 uint32_t len);
  
 /*****************************************************************************/
 amdsmi_status_t  amdsmi_dev_get_ecc_count(amdsmi_device_handle device_handle,
                               amdsmi_gpu_block_t block, amdsmi_error_count_t *ec);
  
 amdsmi_status_t  amdsmi_dev_get_ecc_enabled(amdsmi_device_handle device_handle,
                                                     uint64_t *enabled_blocks);
  
 amdsmi_status_t  amdsmi_dev_get_ecc_status(amdsmi_device_handle device_handle, amdsmi_gpu_block_t block,
                                                   amdsmi_ras_err_state_t *state);
  
 amdsmi_status_t
 amdsmi_status_string(amdsmi_status_t status, const char **status_string);
  
 /*****************************************************************************/
 amdsmi_status_t
 amdsmi_dev_counter_group_supported(amdsmi_device_handle device_handle, amdsmi_event_group_t group);
  
 amdsmi_status_t
 amdsmi_dev_create_counter(amdsmi_device_handle device_handle, amdsmi_event_type_t type,
                                             amdsmi_event_handle_t *evnt_handle);
  
 amdsmi_status_t
 amdsmi_dev_destroy_counter(amdsmi_event_handle_t evnt_handle);
  
 amdsmi_status_t
 amdsmi_control_counter(amdsmi_event_handle_t evt_handle,
                                   amdsmi_counter_command_t cmd, void *cmd_args);
  
 amdsmi_status_t
 amdsmi_read_counter(amdsmi_event_handle_t evt_handle,
                     amdsmi_counter_value_t *value);
  
 amdsmi_status_t
  amdsmi_counter_get_available_counters(amdsmi_device_handle device_handle,
                                  amdsmi_event_group_t grp, uint32_t *available);
  
 /*****************************************************************************/
 amdsmi_status_t
 amdsmi_get_compute_process_info(amdsmi_process_info_t *procs, uint32_t *num_items);
  
 amdsmi_status_t
 amdsmi_get_compute_process_info_by_pid(uint32_t pid, amdsmi_process_info_t *proc);
  
 amdsmi_status_t
 amdsmi_get_compute_process_gpus(uint32_t pid, uint32_t *dv_indices,
                                                        uint32_t *num_devices);
  
 /*****************************************************************************/
 amdsmi_status_t
 amdsmi_dev_xgmi_error_status(amdsmi_device_handle device_handle, amdsmi_xgmi_status_t *status);
  
 amdsmi_status_t
 amdsmi_dev_reset_xgmi_error(amdsmi_device_handle device_handle);
  
 /*****************************************************************************/
 amdsmi_status_t
 amdsmi_topo_get_numa_node_number(amdsmi_device_handle device_handle, uint32_t *numa_node);
  
 amdsmi_status_t
 amdsmi_topo_get_link_weight(amdsmi_device_handle device_handle_src, amdsmi_device_handle device_handle_dst,
                           uint64_t *weight);
  
 amdsmi_status_t
  amdsmi_get_minmax_bandwidth(amdsmi_device_handle device_handle_src, amdsmi_device_handle device_handle_dst,
                           uint64_t *min_bandwidth, uint64_t *max_bandwidth);
  
 amdsmi_status_t
 amdsmi_topo_get_link_type(amdsmi_device_handle device_handle_src,
                         amdsmi_device_handle device_handle_dst,
                         uint64_t *hops, AMDSMI_IO_LINK_TYPE *type);
  
 amdsmi_status_t
 amdsmi_is_P2P_accessible(amdsmi_device_handle device_handle_src, amdsmi_device_handle device_handle_dst,
                        bool *accessible);
  
 /*****************************************************************************/
 amdsmi_status_t
 amdsmi_dev_open_supported_func_iterator(amdsmi_device_handle device_handle,
                                           amdsmi_func_id_iter_handle_t *handle);
  
 amdsmi_status_t
 amdsmi_dev_open_supported_variant_iterator(amdsmi_func_id_iter_handle_t obj_h,
                                         amdsmi_func_id_iter_handle_t *var_iter);
  
 amdsmi_status_t
 amdsmi_next_func_iter(amdsmi_func_id_iter_handle_t handle);
  
 amdsmi_status_t
 amdsmi_dev_close_supported_func_iterator(amdsmi_func_id_iter_handle_t *handle);
  
 amdsmi_status_t
 amdsmi_get_func_iter_value(amdsmi_func_id_iter_handle_t handle,
                                                  amdsmi_func_id_value_t *value);
  
 /*****************************************************************************/
 amdsmi_status_t
 amdsmi_init_event_notification(amdsmi_device_handle device_handle);
  
 amdsmi_status_t
  amdsmi_set_event_notification_mask(amdsmi_device_handle device_handle, uint64_t mask);
  
 amdsmi_status_t
  amdsmi_get_event_notification(int timeout_ms,
                      uint32_t *num_elem, amdsmi_evt_notification_data_t *data);
  
 amdsmi_status_t amdsmi_stop_event_notification(amdsmi_device_handle device_handle);
  
 amdsmi_status_t
 amdsmi_get_device_bdf(amdsmi_device_handle device_handle, amdsmi_bdf_t *bdf);
  
 amdsmi_status_t
 amdsmi_get_device_uuid(amdsmi_device_handle device_handle, unsigned int *uuid_length, char *uuid);
  
 /*****************************************************************************/
 amdsmi_status_t
 amdsmi_get_driver_version(amdsmi_device_handle device_handle, int *length, char *version);
  
 /*****************************************************************************/
 amdsmi_status_t
 amdsmi_get_asic_info(amdsmi_device_handle device_handle, amdsmi_asic_info_t *info);
  
 amdsmi_status_t
 amdsmi_get_board_info(amdsmi_device_handle device_handle, amdsmi_board_info_t *info);
  
 amdsmi_status_t
 amdsmi_get_power_cap_info(amdsmi_device_handle device_handle, uint32_t sensor_ind,
           amdsmi_power_cap_info_t *info);
  
 amdsmi_status_t
 amdsmi_get_xgmi_info(amdsmi_device_handle device_handle, amdsmi_xgmi_info_t *info);
  
 amdsmi_status_t
 amdsmi_get_caps_info(amdsmi_device_handle device_handle, amdsmi_gpu_caps_t *info);
  
 /*****************************************************************************/
 amdsmi_status_t
 amdsmi_get_fw_info(amdsmi_device_handle device_handle, amdsmi_fw_info_t *info);
  
 amdsmi_status_t
 amdsmi_get_vbios_info(amdsmi_device_handle device_handle, amdsmi_vbios_info_t *info);
  
 /*****************************************************************************/
 amdsmi_status_t
 amdsmi_get_gpu_activity(amdsmi_device_handle device_handle, amdsmi_engine_usage_t *info);
  
 amdsmi_status_t
 amdsmi_get_power_measure(amdsmi_device_handle device_handle, amdsmi_power_measure_t *info);
  
 amdsmi_status_t
 amdsmi_get_clock_measure(amdsmi_device_handle device_handle, amdsmi_clk_type_t clk_type, amdsmi_clk_measure_t *info);
  
 amdsmi_status_t
 amdsmi_get_vram_usage(amdsmi_device_handle device_handle, amdsmi_vram_info_t *info);
  
 /*****************************************************************************/
 amdsmi_status_t
 amdsmi_get_target_frequency_range(amdsmi_device_handle device_handle, amdsmi_clk_type_t clk_type, amdsmi_frequency_range_t *range);
  
 /*****************************************************************************/
 amdsmi_status_t
 amdsmi_get_process_list(amdsmi_device_handle device_handle, amdsmi_process_handle *list, uint32_t *max_processes);
  
 amdsmi_status_t
 amdsmi_get_process_info(amdsmi_device_handle device_handle, amdsmi_process_handle process, amdsmi_proc_info_t *info);
  
 /*****************************************************************************/
 amdsmi_status_t
 amdsmi_get_ecc_error_count(amdsmi_device_handle device_handle, amdsmi_error_count_t *ec);
  
 #ifdef __cplusplus
 }
 #endif  // __cplusplus
 #endif  // INCLUDE_AMDSMI_H_