adl_structures.h

Go to the documentation of this file.

//
// Copyright (c) 2016 - 2022 Advanced Micro Devices, Inc. All rights reserved.
//
// MIT LICENSE:
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in 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:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// 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
// AUTHORS 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 IN THE
// SOFTWARE.
 
 
#ifndef ADL_STRUCTURES_H_
#define ADL_STRUCTURES_H_
 
#include "adl_defines.h"
#include <stdbool.h>
typedef struct AdapterInfo
{
 
    int iSize;
    int iAdapterIndex;
    char strUDID[ADL_MAX_PATH];
    int iBusNumber;
    int iDeviceNumber;
    int iFunctionNumber;
    int iVendorID;
    char strAdapterName[ADL_MAX_PATH];
    char strDisplayName[ADL_MAX_PATH];
    int iPresent;
 
#if defined (_WIN32) || defined (_WIN64)
 
    int iExist;
    char strDriverPath[ADL_MAX_PATH];
    char strDriverPathExt[ADL_MAX_PATH];
    char strPNPString[ADL_MAX_PATH];
    int iOSDisplayIndex;
 
#endif /* (_WIN32) || (_WIN64) */
 
#if defined (LINUX)
 
    int iXScreenNum;
    int iDrvIndex;
    char strXScreenConfigName[ADL_MAX_PATH];
 
#endif /* (LINUX) */
} AdapterInfo, *LPAdapterInfo;
 
#if defined (LINUX)
typedef struct XScreenInfo
{
    int iXScreenNum;
    char strXScreenConfigName[ADL_MAX_PATH];
} XScreenInfo, *LPXScreenInfo;
#endif /* (LINUX) */
 
typedef struct ADLAdapterCaps
{
        int iAdapterID;
        int iNumControllers;
        int iNumDisplays;
        int iNumOverlays;
        int iNumOfGLSyncConnectors;
        int iCapsMask;
        int iCapsValue;
}ADLAdapterCaps;
 
typedef struct ADLMemoryInfo2
{
        long long iMemorySize;
        char strMemoryType[ADL_MAX_PATH];
        long long iMemoryBandwidth;
        long long iHyperMemorySize;
 
        long long iInvisibleMemorySize;
        long long iVisibleMemorySize;
} ADLMemoryInfo2, *LPADLMemoryInfo2;
 
typedef struct ADLMemoryInfo3
{
    long long iMemorySize;
    char strMemoryType[ADL_MAX_PATH];
    long long iMemoryBandwidth;
    long long iHyperMemorySize;
 
    long long iInvisibleMemorySize;
    long long iVisibleMemorySize;
    long long iVramVendorRevId;
} ADLMemoryInfo3, *LPADLMemoryInfo3;
 
typedef struct ADLMemoryInfoX4
{
    long long iMemorySize;
    char strMemoryType[ADL_MAX_PATH];
    long long iMemoryBandwidth;
    long long iHyperMemorySize;
 
    long long iInvisibleMemorySize;
    long long iVisibleMemorySize;
    long long iVramVendorRevId;
    long long iMemoryBandwidthX2;
    long long iMemoryBitRateX2;
 
} ADLMemoryInfoX4, *LPADLMemoryInfoX4;
 
// ADLvRamVendor Enumeration
enum ADLvRamVendors
{
    ADLvRamVendor_Unsupported = 0x0,
    ADLvRamVendor_SAMSUNG,
    ADLvRamVendor_INFINEON,
    ADLvRamVendor_ELPIDA,
    ADLvRamVendor_ETRON,
    ADLvRamVendor_NANYA,
    ADLvRamVendor_HYNIX,
    ADLvRamVendor_MOSEL,
    ADLvRamVendor_WINBOND,
    ADLvRamVendor_ESMT,
    ADLvRamVendor_MICRON = 0xF,
    ADLvRamVendor_Undefined
};
 
 
typedef struct ADLGcnInfo
{
        int CuCount; //Number of compute units on the ASIC.
        int TexCount; //Number of texture mapping units.
        int RopCount; //Number of Render backend Units.
        int ASICFamilyId; //Such SI, VI. See /inc/asic_reg/atiid.h for family ids
        int ASICRevisionId; //Such as Ellesmere, Fiji.   For example - VI family revision ids are stored in /inc/asic_reg/vi_id.h
}ADLGcnInfo;
 
typedef struct ADLVirtualSegmentSettingsOutput
{
        int                      virtualSegmentSupported;   // 1 - subsequent values are valid
        int                      virtualSegmentDefault;     //virtual segment default, 1: enable, 0: disable
        int                      virtualSegmentCurrent;     //virtual segment current, 1: enable, 0: disable
        int                      iMinSizeInMB;              //minimum value
        int                      iMaxSizeInMB;              //maximum value
        int                      icurrentSizeInMB;          //last configured otherwise same as factory default
        int                      idefaultSizeInMB;          //factory default
        int                      iMask;                     //fileds for extension in the future
        int                      iValue;                    //fileds for extension in the future
} ADLVirtualSegmentSettingsOutput;
 
typedef struct ADLChipSetInfo
{
        int iBusType;           
        int iBusSpeedType;      
        int iMaxPCIELaneWidth;  
        int iCurrentPCIELaneWidth;  
        int iSupportedAGPSpeeds;    
        int iCurrentAGPSpeed;       
} ADLChipSetInfo, *LPADLChipSetInfo;
 
typedef struct ADLMemoryInfo
{
    long long iMemorySize;
    char strMemoryType[ADL_MAX_PATH];
    long long iMemoryBandwidth;
} ADLMemoryInfo, *LPADLMemoryInfo;
 
typedef struct ADLMemoryRequired
{
    long long iMemoryReq;        
    int iType;                    
    int iDisplayFeatureValue;   
} ADLMemoryRequired, *LPADLMemoryRequired;
 
typedef struct ADLMemoryDisplayFeatures
{
    int iDisplayIndex;            
    int iDisplayFeatureValue;    
} ADLMemoryDisplayFeatures, *LPADLMemoryDisplayFeatures;
 
typedef struct ADLDDCInfo
{
    int  ulSize;
    int  ulSupportsDDC;
    int  ulManufacturerID;
    int  ulProductID;
    char cDisplayName[ADL_MAX_DISPLAY_NAME];
    int  ulMaxHResolution;
    int  ulMaxVResolution;
    int  ulMaxRefresh;
    int  ulPTMCx;
    int  ulPTMCy;
    int  ulPTMRefreshRate;
    int  ulDDCInfoFlag;
} ADLDDCInfo, *LPADLDDCInfo;
 
typedef struct ADLDDCInfo2
{
    int  ulSize;
    int  ulSupportsDDC;
    int  ulManufacturerID;
    int  ulProductID;
    char cDisplayName[ADL_MAX_DISPLAY_NAME];
    int  ulMaxHResolution;
    int  ulMaxVResolution;
    int  ulMaxRefresh;
    int  ulPTMCx;
    int  ulPTMCy;
    int  ulPTMRefreshRate;
    int  ulDDCInfoFlag;
    int bPackedPixelSupported;
    int iPanelPixelFormat;
    int  ulSerialID;
    int ulMinLuminanceData;
    int ulAvgLuminanceData;
    int ulMaxLuminanceData;
 
    int iSupportedTransferFunction;
 
    int iSupportedColorSpace;
 
    int iNativeDisplayChromaticityRedX;
    int iNativeDisplayChromaticityRedY;
    int iNativeDisplayChromaticityGreenX;
    int iNativeDisplayChromaticityGreenY;
    int iNativeDisplayChromaticityBlueX;
    int iNativeDisplayChromaticityBlueY;
    int iNativeDisplayChromaticityWhitePointX;
    int iNativeDisplayChromaticityWhitePointY;
    int iDiffuseScreenReflectance;
    int iSpecularScreenReflectance;
    int iSupportedHDR;
    int iFreesyncFlags;
 
    int ulMinLuminanceNoDimmingData;
 
    int ulMaxBacklightMaxLuminanceData;
    int ulMinBacklightMaxLuminanceData;
    int ulMaxBacklightMinLuminanceData;
    int ulMinBacklightMinLuminanceData;
 
    // Reserved for future use
    int iReserved[4];
} ADLDDCInfo2, *LPADLDDCInfo2;
 
typedef struct ADLGamma
{
    float fRed;
    float fGreen;
    float fBlue;
} ADLGamma, *LPADLGamma;
 
typedef struct ADLCustomMode
{
    int iFlags;
    int iModeWidth;
    int iModeHeight;
    int iBaseModeWidth;
    int iBaseModeHeight;
    int iRefreshRate;
} ADLCustomMode, *LPADLCustomMode;
 
typedef struct ADLGetClocksOUT
{
    long ulHighCoreClock;
    long ulHighMemoryClock;
    long ulHighVddc;
    long ulCoreMin;
    long ulCoreMax;
    long ulMemoryMin;
    long ulMemoryMax;
    long ulActivityPercent;
    long ulCurrentCoreClock;
    long ulCurrentMemoryClock;
    long ulReserved;
} ADLGetClocksOUT;
 
typedef struct ADLDisplayConfig
{
  long ulSize;
  long ulConnectorType;
  long ulDeviceData;
  long ulOverridedDeviceData;
  long ulReserved;
} ADLDisplayConfig;
 
typedef struct ADLDisplayID
{
    int iDisplayLogicalIndex;
 
    int iDisplayPhysicalIndex;
 
    int iDisplayLogicalAdapterIndex;
 
    int iDisplayPhysicalAdapterIndex;
} ADLDisplayID, *LPADLDisplayID;
 
typedef struct ADLDisplayInfo
{
    ADLDisplayID displayID;
 
    int  iDisplayControllerIndex;
 
    char strDisplayName[ADL_MAX_PATH];
 
    char strDisplayManufacturerName[ADL_MAX_PATH];
 
    int  iDisplayType;
 
    int  iDisplayOutputType;
 
    int  iDisplayConnector;
 
    int  iDisplayInfoMask;
 
    int  iDisplayInfoValue;
} ADLDisplayInfo, *LPADLDisplayInfo;
 
typedef struct ADLDisplayDPMSTInfo
{
    ADLDisplayID displayID;
 
    int    iTotalAvailableBandwidthInMpbs;
    int    iAllocatedBandwidthInMbps;
 
    // info from DAL DpMstSinkInfo
    char    strGlobalUniqueIdentifier[ADL_MAX_PATH];
 
    int        radLinkCount;
    int        iPhysicalConnectorID;
 
    char    rad[ADL_MAX_RAD_LINK_COUNT];
} ADLDisplayDPMSTInfo, *LPADLDisplayDPMSTInfo;
 
typedef struct ADLDisplayMode
{
   int  iPelsHeight;
   int  iPelsWidth;
   int  iBitsPerPel;
   int  iDisplayFrequency;
} ADLDisplayMode;
 
typedef struct ADLDetailedTiming
{
     int   iSize;
     short sTimingFlags;
     short sHTotal;
     short sHDisplay;
     short sHSyncStart;
     short sHSyncWidth;
     short sVTotal;
     short sVDisplay;
     short sVSyncStart;
     short sVSyncWidth;
     short sPixelClock;
     short sHOverscanRight;
     short sHOverscanLeft;
     short sVOverscanBottom;
     short sVOverscanTop;
     short sOverscan8B;
     short sOverscanGR;
} ADLDetailedTiming;
 
typedef struct ADLDisplayModeInfo
{
  int  iTimingStandard;
  int  iPossibleStandard;
  int  iRefreshRate;
  int  iPelsWidth;
  int  iPelsHeight;
  ADLDetailedTiming  sDetailedTiming;
} ADLDisplayModeInfo;
 
typedef struct ADLDisplayProperty
{
  int iSize;
  int iPropertyType;
  int iExpansionMode;
  int iSupport;
  int iCurrent;
  int iDefault;
} ADLDisplayProperty;
 
typedef struct ADLClockInfo
{
    int iCoreClock;
    int iMemoryClock;
} ADLClockInfo, *LPADLClockInfo;
 
typedef struct ADLI2C
{
    int iSize;
    int iLine;
    int iAddress;
    int iOffset;
    int iAction;
    int iSpeed;
    int iDataSize;
    char *pcData;
} ADLI2C;
 
typedef struct ADLDisplayEDIDData
{
  int iSize;
  int iFlag;
  int iEDIDSize;
  int iBlockIndex;
  char cEDIDData[ADL_MAX_EDIDDATA_SIZE];
  int iReserved[4];
}ADLDisplayEDIDData;
 
typedef struct ADLControllerOverlayInput
{
  int  iSize;
  int  iOverlayAdjust;
  int  iValue;
  int  iReserved;
} ADLControllerOverlayInput;
 
typedef struct ADLAdjustmentinfo
{
  int iDefault;
  int iMin;
  int iMax;
  int iStep;
} ADLAdjustmentinfo;
 
typedef struct ADLControllerOverlayInfo
{
  int                    iSize;
  ADLAdjustmentinfo        sOverlayInfo;
  int                    iReserved[3];
} ADLControllerOverlayInfo;
 
typedef struct ADLGLSyncModuleID
{
    int        iModuleID;
    int        iGlSyncGPUPort;
    int        iFWBootSectorVersion;
    int        iFWUserSectorVersion;
} ADLGLSyncModuleID , *LPADLGLSyncModuleID;
 
typedef struct ADLGLSyncPortCaps
{
    int        iPortType;
    int        iNumOfLEDs;
}ADLGLSyncPortCaps, *LPADLGLSyncPortCaps;
 
typedef struct ADLGLSyncGenlockConfig
{
    int        iValidMask;
    int        iSyncDelay;
    int        iFramelockCntlVector;
    int        iSignalSource;
    int        iSampleRate;
    int        iSyncField;
    int        iTriggerEdge;
    int        iScanRateCoeff;
}ADLGLSyncGenlockConfig, *LPADLGLSyncGenlockConfig;
 
typedef struct ADLGlSyncPortInfo
{
    int        iPortType;
    int        iNumOfLEDs;
    int        iPortState;
    int        iFrequency;
    int        iSignalType;
    int        iSignalSource;
} ADLGlSyncPortInfo, *LPADLGlSyncPortInfo;
 
typedef struct ADLGlSyncPortControl
{
    int        iPortType;
    int        iControlVector;
    int        iSignalSource;
} ADLGlSyncPortControl;
 
typedef struct ADLGlSyncMode
{
    int        iControlVector;
    int        iStatusVector;
    int        iGLSyncConnectorIndex;
} ADLGlSyncMode, *LPADLGlSyncMode;
 
typedef struct ADLGlSyncMode2
{
    int        iControlVector;
    int        iStatusVector;
    int        iGLSyncConnectorIndex;
    int        iDisplayIndex;
} ADLGlSyncMode2, *LPADLGlSyncMode2;
 
typedef struct  ADLInfoPacket
{
    char hb0;
    char hb1;
    char hb2;
    char sb[28];
}ADLInfoPacket;
 
typedef struct ADLAVIInfoPacket  //Valid user defined data/
{
   char bPB3_ITC;
   char bPB5;
}ADLAVIInfoPacket;
 
// Overdrive clock setting structure definition.
 
typedef struct ADLODClockSetting
{
    int iDefaultClock;
    int iCurrentClock;
    int iMaxClock;
    int iMinClock;
    int iRequestedClock;
    int iStepClock;
} ADLODClockSetting;
 
typedef struct ADLAdapterODClockInfo
{
    int iSize;
    int iFlags;
    ADLODClockSetting sMemoryClock;
    ADLODClockSetting sEngineClock;
} ADLAdapterODClockInfo;
 
typedef struct ADLAdapterODClockConfig
{
  int iSize;
  int iFlags;
  int iMemoryClock;
  int iEngineClock;
} ADLAdapterODClockConfig;
 
typedef struct ADLPMActivity
{
    int iSize;
    int iEngineClock;
    int iMemoryClock;
    int iVddc;
    int iActivityPercent;
    int iCurrentPerformanceLevel;
    int iCurrentBusSpeed;
    int iCurrentBusLanes;
    int iMaximumBusLanes;
    int iReserved;
} ADLPMActivity;
 
typedef struct ADLThermalControllerInfo
{
  int iSize;
  int iThermalDomain;
  int iDomainIndex;
  int iFlags;
} ADLThermalControllerInfo;
 
typedef struct ADLTemperature
{
  int iSize;
  int iTemperature;
} ADLTemperature;
 
typedef struct ADLFanSpeedInfo
{
  int iSize;
  int iFlags;
  int iMinPercent;
  int iMaxPercent;
  int iMinRPM;
  int iMaxRPM;
} ADLFanSpeedInfo;
 
typedef struct ADLFanSpeedValue
{
  int iSize;
  int iSpeedType;
  int iFanSpeed;
  int iFlags;
} ADLFanSpeedValue;
 
typedef struct ADLODParameterRange
{
  int iMin;
  int iMax;
  int iStep;
} ADLODParameterRange;
 
typedef struct ADLODParameters
{
  int iSize;
  int iNumberOfPerformanceLevels;
  int iActivityReportingSupported;
  int iDiscretePerformanceLevels;
  int iReserved;
  ADLODParameterRange sEngineClock;
  ADLODParameterRange sMemoryClock;
  ADLODParameterRange sVddc;
} ADLODParameters;
 
typedef struct ADLODPerformanceLevel
{
  int iEngineClock;
  int iMemoryClock;
  int iVddc;
} ADLODPerformanceLevel;
 
typedef struct ADLODPerformanceLevels
{
  int iSize;
  int iReserved;
  ADLODPerformanceLevel aLevels [1];
} ADLODPerformanceLevels;
 
typedef struct ADLCrossfireComb
{
  int iNumLinkAdapter;
  int iAdaptLink[3];
} ADLCrossfireComb;
 
typedef struct ADLCrossfireInfo
{
  int iErrorCode;
  int iState;
  int iSupported;
} ADLCrossfireInfo;
 
typedef struct ADLBiosInfo
{
    char strPartNumber[ADL_MAX_PATH];    
    char strVersion[ADL_MAX_PATH];        
    char strDate[ADL_MAX_PATH];        
} ADLBiosInfo, *LPADLBiosInfo;
 
typedef struct ADLAdapterLocation
{
    int iBus;
    int iDevice;
    int iFunction;
} ADLAdapterLocation,ADLBdf;
 
typedef struct ADLVersionsInfo
{
    char strDriverVer[ADL_MAX_PATH];
    char strCatalystVersion[ADL_MAX_PATH];
    char strCatalystWebLink[ADL_MAX_PATH];
} ADLVersionsInfo, *LPADLVersionsInfo;
 
typedef struct ADLVersionsInfoX2
{
    char strDriverVer[ADL_MAX_PATH];
    char strCatalystVersion[ADL_MAX_PATH];
    char strCrimsonVersion[ADL_MAX_PATH];
    char strCatalystWebLink[ADL_MAX_PATH];
} ADLVersionsInfoX2, *LPADLVersionsInfoX2;
 
typedef struct ADLMVPUCaps
{
  int iSize;
  int iAdapterCount;
  int iPossibleMVPUMasters;
  int iPossibleMVPUSlaves;
  char cAdapterPath[ADL_DL_MAX_MVPU_ADAPTERS][ADL_DL_MAX_REGISTRY_PATH];
} ADLMVPUCaps;
 
typedef struct ADLMVPUStatus
{
  int iSize;
  int iActiveAdapterCount;
  int iStatus;
  ADLAdapterLocation aAdapterLocation[ADL_DL_MAX_MVPU_ADAPTERS];
} ADLMVPUStatus;
 
// Displays Manager structures
 
typedef struct ADLActivatableSource
{
    int iAdapterIndex;
    int iNumActivatableSources;
    int iActivatableSourceMask;
    int iActivatableSourceValue;
} ADLActivatableSource, *LPADLActivatableSource;
 
 
typedef struct ADLMode
{
    int iAdapterIndex;
    ADLDisplayID displayID;
    int iXPos;
    int iYPos;
    int iXRes;
    int iYRes;
    int iColourDepth;
    float fRefreshRate;
    int iOrientation;
    int iModeFlag;
    int iModeMask;
    int iModeValue;
} ADLMode, *LPADLMode;
 
typedef struct ADLDisplayTarget
{
    ADLDisplayID displayID;
 
    int iDisplayMapIndex;
 
    int  iDisplayTargetMask;
 
    int  iDisplayTargetValue;
} ADLDisplayTarget, *LPADLDisplayTarget;
 
typedef struct tagADLBezelTransientMode
{
    int iAdapterIndex;
 
    int iSLSMapIndex;
 
    int iSLSModeIndex;
 
    ADLMode displayMode;
 
    int  iNumBezelOffset;
 
    int  iFirstBezelOffsetArrayIndex;
 
    int  iSLSBezelTransientModeMask;
 
    int  iSLSBezelTransientModeValue;
} ADLBezelTransientMode, *LPADLBezelTransientMode;
 
typedef struct ADLAdapterDisplayCap
{
    int iAdapterIndex;
    int  iAdapterDisplayCapMask;
    int  iAdapterDisplayCapValue;
} ADLAdapterDisplayCap, *LPADLAdapterDisplayCap;
 
typedef struct ADLDisplayMap
{
    int iDisplayMapIndex;
 
    ADLMode displayMode;
 
    int iNumDisplayTarget;
 
    int iFirstDisplayTargetArrayIndex;
 
     int  iDisplayMapMask;
 
    int  iDisplayMapValue;
} ADLDisplayMap, *LPADLDisplayMap;
 
typedef struct ADLPossibleMap
{
    int iIndex;
    int iAdapterIndex;
    int iNumDisplayMap;
    ADLDisplayMap* displayMap;
    int iNumDisplayTarget;
    ADLDisplayTarget* displayTarget;
} ADLPossibleMap, *LPADLPossibleMap;
 
typedef struct ADLPossibleMapping
{
    int iDisplayIndex;                
    int iDisplayControllerIndex;    
    int iDisplayMannerSupported;    
} ADLPossibleMapping, *LPADLPossibleMapping;
 
typedef struct ADLPossibleMapResult
{
    int iIndex;
    // The bit mask identifies the number of bits   PossibleMapResult is currently using. It will be the sum all the bit definitions defined in ADL_DISPLAY_POSSIBLEMAPRESULT_VALID.
    int iPossibleMapResultMask;
    int iPossibleMapResultValue;
} ADLPossibleMapResult, *LPADLPossibleMapResult;
 
typedef struct ADLSLSGrid
{
    int iAdapterIndex;
 
    int  iSLSGridIndex;
 
    int  iSLSGridRow;
 
    int  iSLSGridColumn;
 
    int  iSLSGridMask;
 
    int  iSLSGridValue;
} ADLSLSGrid, *LPADLSLSGrid;
 
typedef struct    ADLSLSMap
{
    int iAdapterIndex;
 
    int iSLSMapIndex;
 
    ADLSLSGrid grid;
 
    int  iSurfaceMapIndex;
 
     int iOrientation;
 
    int  iNumSLSTarget;
 
    int  iFirstSLSTargetArrayIndex;
 
    int  iNumNativeMode;
 
    int  iFirstNativeModeArrayIndex;
 
    int  iNumBezelMode;
 
    int  iFirstBezelModeArrayIndex;
 
    int  iNumBezelOffset;
 
    int  iFirstBezelOffsetArrayIndex;
 
    int  iSLSMapMask;
 
    int  iSLSMapValue;
} ADLSLSMap, *LPADLSLSMap;
 
typedef struct ADLSLSOffset
{
    int iAdapterIndex;
 
    int iSLSMapIndex;
 
    ADLDisplayID displayID;
 
    int iBezelModeIndex;
 
    int iBezelOffsetX;
 
    int iBezelOffsetY;
 
    int iDisplayWidth;
 
    int iDisplayHeight;
 
    int iBezelOffsetMask;
 
    int  iBezelffsetValue;
} ADLSLSOffset, *LPADLSLSOffset;
 
typedef struct ADLSLSMode
{
    int iAdapterIndex;
 
    int iSLSMapIndex;
 
    int iSLSModeIndex;
 
    ADLMode displayMode;
 
    int iSLSNativeModeMask;
 
    int iSLSNativeModeValue;
} ADLSLSMode, *LPADLSLSMode;
 
typedef struct ADLPossibleSLSMap
{
    int iSLSMapIndex;
 
    int iNumSLSMap;
 
    ADLSLSMap* lpSLSMap;
 
    int iNumSLSTarget;
 
    ADLDisplayTarget* lpDisplayTarget;
} ADLPossibleSLSMap, *LPADLPossibleSLSMap;
 
typedef struct ADLSLSTarget
{
    int iAdapterIndex;
 
    int iSLSMapIndex;
 
    ADLDisplayTarget displayTarget;
 
    int iSLSGridPositionX;
 
    int iSLSGridPositionY;
 
    ADLMode viewSize;
 
    int iSLSTargetMask;
 
    int iSLSTargetValue;
} ADLSLSTarget, *LPADLSLSTarget;
 
typedef struct ADLBezelOffsetSteppingSize
{
    int iAdapterIndex;
 
    int iSLSMapIndex;
 
    int iBezelOffsetSteppingSizeX;
 
    int iBezelOffsetSteppingSizeY;
 
    int iBezelOffsetSteppingSizeMask;
 
    int iBezelOffsetSteppingSizeValue;
} ADLBezelOffsetSteppingSize, *LPADLBezelOffsetSteppingSize;
 
typedef struct ADLSLSOverlappedMode
{
    ADLMode SLSMode;
    int iNumSLSTarget;
    int iFirstTargetArrayIndex;
}ADLSLSTargetOverlap, *LPADLSLSTargetOverlap;
 
typedef struct ADLPXConfigCaps
{
    int iAdapterIndex;
 
    int  iPXConfigCapMask;
 
    int  iPXConfigCapValue;
} ADLPXConfigCaps, *LPADLPXConfigCaps;
 
typedef enum ADLPxType
{
        //Not AMD related PX/HG or not PX or HG at all
        ADL_PX_NONE = 0,
        //A+A PX
        ADL_SWITCHABLE_AMDAMD = 1,
        // A+A HG
        ADL_HG_AMDAMD = 2,
        //A+I PX
        ADL_SWITCHABLE_AMDOTHER = 3,
        //A+I HG
        ADL_HG_AMDOTHER = 4,
}ADLPxType;
 
typedef struct ADLApplicationData
{
    char strPathName[ADL_MAX_PATH];
    char strFileName[ADL_APP_PROFILE_FILENAME_LENGTH];
    char strTimeStamp[ADL_APP_PROFILE_TIMESTAMP_LENGTH];
    char strVersion[ADL_APP_PROFILE_VERSION_LENGTH];
}ADLApplicationData;
 
typedef struct ADLApplicationDataX2
{
    wchar_t strPathName[ADL_MAX_PATH];
    wchar_t strFileName[ADL_APP_PROFILE_FILENAME_LENGTH];
    wchar_t strTimeStamp[ADL_APP_PROFILE_TIMESTAMP_LENGTH];
    wchar_t strVersion[ADL_APP_PROFILE_VERSION_LENGTH];
}ADLApplicationDataX2;
 
typedef struct ADLApplicationDataX3
{
    wchar_t strPathName[ADL_MAX_PATH];
    wchar_t strFileName[ADL_APP_PROFILE_FILENAME_LENGTH];
    wchar_t strTimeStamp[ADL_APP_PROFILE_TIMESTAMP_LENGTH];
    wchar_t strVersion[ADL_APP_PROFILE_VERSION_LENGTH];
    //Application Process id
    unsigned int iProcessId;
}ADLApplicationDataX3;
 
typedef struct PropertyRecord
{
    char strName [ADL_APP_PROFILE_PROPERTY_LENGTH];
    ADLProfilePropertyType eType;
    int iDataSize;
    unsigned char uData[1];
}PropertyRecord;
 
typedef struct ADLApplicationProfile
{
    int iCount;
    PropertyRecord record[1];
}ADLApplicationProfile;
 
typedef struct ADLPowerControlInfo
{
int iMinValue;
int iMaxValue;
int iStepValue;
 } ADLPowerControlInfo;
 
typedef struct ADLControllerMode
{
    int iModifiers;
 
    int iViewPositionCx;
 
    int iViewPositionCy;
 
    int iViewPanLockLeft;
 
    int iViewPanLockRight;
 
    int iViewPanLockTop;
 
    int iViewPanLockBottom;
 
    int iViewResolutionCx;
 
    int iViewResolutionCy;
}ADLControllerMode;
 
typedef struct ADLDisplayIdentifier
{
    long ulDisplayIndex;
 
    long ulManufacturerId;
 
    long ulProductId;
 
    long ulSerialNo;
} ADLDisplayIdentifier;
 
typedef struct ADLOD6ParameterRange
{
    int     iMin;
    int     iMax;
    int     iStep;
} ADLOD6ParameterRange;
 
typedef struct ADLOD6Capabilities
{
    int     iCapabilities;
    int     iSupportedStates;
    int     iNumberOfPerformanceLevels;
    ADLOD6ParameterRange     sEngineClockRange;
    ADLOD6ParameterRange     sMemoryClockRange;
 
    int     iExtValue;
    int     iExtMask;
} ADLOD6Capabilities;
 
typedef struct ADLOD6PerformanceLevel
{
    int iEngineClock;
    int iMemoryClock;
} ADLOD6PerformanceLevel;
 
typedef struct ADLOD6StateInfo
{
    int     iNumberOfPerformanceLevels;
 
    int     iExtValue;
    int     iExtMask;
 
    ADLOD6PerformanceLevel aLevels [1];
} ADLOD6StateInfo;
 
typedef struct ADLOD6CurrentStatus
{
    int     iEngineClock;
    int     iMemoryClock;
    int     iActivityPercent;
    int     iCurrentPerformanceLevel;
    int     iCurrentBusSpeed;
    int     iCurrentBusLanes;
    int     iMaximumBusLanes;
 
    int     iExtValue;
    int     iExtMask;
} ADLOD6CurrentStatus;
 
typedef struct ADLOD6ThermalControllerCaps
{
    int     iCapabilities;
    int     iFanMinPercent;
    int     iFanMaxPercent;
    int     iFanMinRPM;
    int     iFanMaxRPM;
 
    int     iExtValue;
    int     iExtMask;
} ADLOD6ThermalControllerCaps;
 
typedef struct ADLOD6FanSpeedInfo
{
    int     iSpeedType;
    int     iFanSpeedPercent;
    int        iFanSpeedRPM;
 
    int     iExtValue;
    int     iExtMask;
} ADLOD6FanSpeedInfo;
 
typedef struct ADLOD6FanSpeedValue
{
    int     iSpeedType;
    int     iFanSpeed;
 
    int     iExtValue;
    int     iExtMask;
} ADLOD6FanSpeedValue;
 
typedef struct ADLOD6PowerControlInfo
{
    int     iMinValue;
    int     iMaxValue;
    int     iStepValue;
 
    int     iExtValue;
    int     iExtMask;
} ADLOD6PowerControlInfo;
 
typedef struct ADLOD6VoltageControlInfo
{
    int     iMinValue;
    int     iMaxValue;
    int     iStepValue;
 
    int     iExtValue;
    int     iExtMask;
} ADLOD6VoltageControlInfo;
 
typedef struct ADLECCData
{
    // Single error count - count of errors that can be corrected
    int iSec;
    // Double error detect - count of errors that cannot be corrected
    int iDed;
} ADLECCData;
 
typedef void *ADL_CONTEXT_HANDLE;
 
typedef void *ADL_FRAME_DURATION_HANDLE;
 
typedef struct ADLDisplayModeX2
{
   int  iWidth;
   int  iHeight;
   int  iScanType;
   int  iRefreshRate;
   int  iTimingStandard;
} ADLDisplayModeX2;
 
typedef enum ADLAppProcessState
{
        APP_PROC_INVALID = 0,          // Invalid Application
        APP_PROC_PREMPTION = 1,          // The Application is being set up for Process Creation
        APP_PROC_CREATION = 2,          // The Application's Main Process is created by the OS
        APP_PROC_READ = 3,          // The Application's Data is ready to be read
        APP_PROC_WAIT = 4,          // The Application is waiting for Timeout or Notification to Resume
        APP_PROC_RUNNING = 5,          // The Application is running
        APP_PROC_TERMINATE = 6           // The Application is about to terminate
}ADLAppProcessState;
 
typedef enum ADLAppInterceptionListType
{
        ADL_INVALID_FORMAT = 0,
        ADL_IMAGEFILEFORMAT = 1,
        ADL_ENVVAR = 2
}ADLAppInterceptionListType;
 
typedef struct ADLAppInterceptionInfo
{
        wchar_t                     AppName[ADL_MAX_PATH]; // the file name of the application or env var
        unsigned int                ProcessId;
        ADLAppInterceptionListType  AppFormat;
        ADLAppProcessState          AppState;
} ADLAppInterceptionInfo;
 
typedef enum ADL_AP_DATABASE // same as _SHARED_AP_DATABASE in "inc/shared/shared_escape.h"
{
        ADL_AP_DATABASE__SYSTEM,
        ADL_AP_DATABASE__USER,
        ADL_AP_DATABASE__OEM
} ADL_AP_DATABASE;
 
typedef struct ADLAppInterceptionInfoX2
{
        wchar_t                     AppName[ADL_MAX_PATH]; // the file name of the application or env var
        unsigned int                ProcessId;
        unsigned int                WaitForResumeNeeded;
        wchar_t                     CommandLine[ADL_MAX_PATH]; // The command line on app start/stop event
        ADLAppInterceptionListType  AppFormat;
        ADLAppProcessState          AppState;
} ADLAppInterceptionInfoX2;
 
typedef struct ADLAppInterceptionInfoX3
{
    wchar_t                     AppName[ADL_MAX_PATH]; // the file name of the application or env var
    unsigned int                ProcessId;
    unsigned int                WaitForResumeNeeded;
    unsigned int                RayTracingStatus; // returns the Ray Tracing status if it is enabled atleast once in session.
    wchar_t                     CommandLine[ADL_MAX_PATH]; // The command line on app start/stop event
    ADLAppInterceptionListType  AppFormat;
    ADLAppProcessState          AppState;
} ADLAppInterceptionInfoX3;
 
typedef struct ADLPropertyRecordCreate
{
        wchar_t * strPropertyName;
        ADLProfilePropertyType eType;
        // Value of the property
        wchar_t * strPropertyValue;
} ADLPropertyRecordCreate;
 
typedef struct ADLApplicationRecord
{
    wchar_t * strTitle;
    wchar_t * strPathName;
    wchar_t * strFileName;
    wchar_t * strVersion;
    wchar_t * strNotes;
    wchar_t * strArea;
    wchar_t * strProfileName;
    // Source where this application record come from
    ADL_AP_DATABASE recordSource;
} ADLApplicationRecord;
 
typedef struct ADLOD6CapabilitiesEx
{
    int iCapabilities;
    int iSupportedStates;
    ADLOD6ParameterRange sEngineClockPercent;
    ADLOD6ParameterRange sMemoryClockPercent;
    ADLOD6ParameterRange sPowerControlPercent;
    int iExtValue;
    int iExtMask;
} ADLOD6CapabilitiesEx;
 
typedef struct ADLOD6StateEx
{
    int iEngineClockPercent;
    int iMemoryClockPercent;
    int iPowerControlPercent;
    int iExtValue;
    int iExtMask;
} ADLOD6StateEx;
 
typedef struct ADLOD6MaxClockAdjust
{
    int iEngineClockMax;
    int iMemoryClockMax;
    int iExtValue;
    int iExtMask;
} ADLOD6MaxClockAdjust;
 
typedef struct ADLConnectorInfo
{
    int iConnectorIndex;
    int iConnectorId;
    int iSlotIndex;
    int iType;
    int iOffset;
    int iLength;
} ADLConnectorInfo;
 
typedef struct ADLBracketSlotInfo
{
    int iSlotIndex;
    int iLength;
    int iWidth;
} ADLBracketSlotInfo;
 
typedef struct ADLMSTRad
{
    int iLinkNumber;
    char rad[ADL_MAX_RAD_LINK_COUNT];
} ADLMSTRad;
 
typedef struct ADLDevicePort
{
    int iConnectorIndex;
    ADLMSTRad aMSTRad;
} ADLDevicePort;
 
typedef struct ADLSupportedConnections
{
    int iSupportedConnections;
    int iSupportedProperties[ADL_MAX_CONNECTION_TYPES];
} ADLSupportedConnections;
 
typedef struct ADLConnectionState
{
    int iEmulationStatus;
    int iEmulationMode;
    int iDisplayIndex;
} ADLConnectionState;
 
typedef struct ADLConnectionProperties
{
    //Bit vector. Represents actual properties. Supported properties for specific connection type. \ref define_connection_properties
    int iValidProperties;
    //Bitrate(in MHz). Could be used for MST branch, DP or DP active dongle. \ref define_linkrate_constants
    int iBitrate;
    //Number of lanes in DP connection. \ref define_lanecount_constants
    int iNumberOfLanes;
    //Color depth(in bits). \ref define_colordepth_constants
    int iColorDepth;
    //3D capabilities. It could be used for some dongles. For instance: alternate framepack. Value of this property is bit vector.
    int iStereo3DCaps;
    int iOutputBandwidth;
} ADLConnectionProperties;
 
typedef struct ADLConnectionData
{
    int iConnectionType;
    ADLConnectionProperties aConnectionProperties;
    int iNumberofPorts;
    int iActiveConnections;
    int iDataSize;
    char EdidData[ADL_MAX_DISPLAY_EDID_DATA_SIZE];
} ADLConnectionData;
 
typedef struct ADLAdapterCapsX2
{
    int iAdapterID;
    int iNumControllers;
    int iNumDisplays;
    int iNumOverlays;
    int iNumOfGLSyncConnectors;
    int iCapsMask;
    int iCapsValue;
    int iNumConnectors;
}ADLAdapterCapsX2;
 
typedef enum ADL_ERROR_RECORD_SEVERITY
{
    ADL_GLOBALLY_UNCORRECTED  = 1,
    ADL_LOCALLY_UNCORRECTED   = 2,
    ADL_DEFFERRED             = 3,
    ADL_CORRECTED             = 4
}ADL_ERROR_RECORD_SEVERITY;
 
typedef union _ADL_ECC_EDC_FLAG
{
    struct
    {
        unsigned int isEccAccessing        : 1;
        unsigned int reserved              : 31;
    }bits;
    unsigned int u32All;
}ADL_ECC_EDC_FLAG;
 
typedef struct ADLErrorRecord
{
    // Severity of error
    ADL_ERROR_RECORD_SEVERITY Severity;
 
    // Is the counter valid?
    int  countValid;
 
    // Counter value, if valid
    unsigned int count;
 
    // Is the location information valid?
    int locationValid;
 
    // Physical location of error
    unsigned int CU; // CU number on which error occurred, if known
    char StructureName[32]; // e.g. LDS, TCC, etc.
 
    // Time of error record creation (e.g. time of query, or time of poison interrupt)
    char tiestamp[32];
 
    unsigned int padding[3];
}ADLErrorRecord;
 
typedef enum ADL_EDC_BLOCK_ID
{
    ADL_EDC_BLOCK_ID_SQCIS = 1,
    ADL_EDC_BLOCK_ID_SQCDS = 2,
    ADL_EDC_BLOCK_ID_SGPR  = 3,
    ADL_EDC_BLOCK_ID_VGPR  = 4,
    ADL_EDC_BLOCK_ID_LDS   = 5,
    ADL_EDC_BLOCK_ID_GDS   = 6,
    ADL_EDC_BLOCK_ID_TCL1  = 7,
    ADL_EDC_BLOCK_ID_TCL2  = 8
}ADL_EDC_BLOCK_ID;
 
typedef enum ADL_ERROR_INJECTION_MODE
{
    ADL_ERROR_INJECTION_MODE_SINGLE      = 1,
    ADL_ERROR_INJECTION_MODE_MULTIPLE    = 2,
    ADL_ERROR_INJECTION_MODE_ADDRESS     = 3
}ADL_ERROR_INJECTION_MODE;
 
typedef union _ADL_ERROR_PATTERN
{
    struct
    {
        unsigned long  EccInjVector         :  16;
        unsigned long  EccInjEn             :  9;
        unsigned long  EccBeatEn            :  4;
        unsigned long  EccChEn              :  4;
        unsigned long  reserved             :  31;
    } bits;
    unsigned long long u64Value;
} ADL_ERROR_PATTERN;
 
typedef struct ADL_ERROR_INJECTION_DATA
{
    unsigned long long errorAddress;
    ADL_ERROR_PATTERN errorPattern;
}ADL_ERROR_INJECTION_DATA;
 
typedef struct ADLErrorInjection
{
    ADL_EDC_BLOCK_ID blockId;
    ADL_ERROR_INJECTION_MODE errorInjectionMode;
}ADLErrorInjection;
 
typedef struct ADLErrorInjectionX2
{
    ADL_EDC_BLOCK_ID blockId;
    ADL_ERROR_INJECTION_MODE errorInjectionMode;
    ADL_ERROR_INJECTION_DATA errorInjectionData;
}ADLErrorInjectionX2;
 
typedef struct ADLFreeSyncCap
{
    int iCaps;
    int iMinRefreshRateInMicroHz;
    int iMaxRefreshRateInMicroHz;
    unsigned char ucLabelIndex;
    char cReserved[3];
    int iReserved[4];
} ADLFreeSyncCap;
 
typedef struct ADLDceSettings
{
    DceSettingsType type;                       // Defines which structure is in the union below
    union
    {
        struct
        {
            bool qualityDetectionEnabled;
        } HdmiLq;
        struct
        {
            DpLinkRate linkRate;                // Read-only
            unsigned int numberOfActiveLanes;   // Read-only
            unsigned int numberofTotalLanes;    // Read-only
            int relativePreEmphasis;            // Allowable values are -2 to +2
            int relativeVoltageSwing;           // Allowable values are -2 to +2
            int persistFlag;
        } DpLink;
        struct
        {
            bool linkProtectionEnabled;         // Read-only
        } Protection;
    } Settings;
    int iReserved[15];
} ADLDceSettings;
 
typedef struct ADLGraphicCoreInfo
{
    int iGCGen;
 
    union
    {
        int iNumCUs;
        int iNumWGPs;
    };
 
    union
    {
        int iNumPEsPerCU;
        int iNumPEsPerWGP;
    };
 
    int iNumSIMDs;
 
    int iNumROPs;
 
    int iReserved[11];
}ADLGraphicCoreInfo;
 
typedef struct ADLODNParameterRange
{
    int     iMode;
    int     iMin;
    int     iMax;
    int     iStep;
    int     iDefault;
} ADLODNParameterRange;
 
typedef struct ADLODNCapabilities
{
    int     iMaximumNumberOfPerformanceLevels;
    ADLODNParameterRange     sEngineClockRange;
    ADLODNParameterRange     sMemoryClockRange;
    ADLODNParameterRange     svddcRange;
    ADLODNParameterRange     power;
    ADLODNParameterRange     powerTuneTemperature;
    ADLODNParameterRange     fanTemperature;
    ADLODNParameterRange     fanSpeed;
    ADLODNParameterRange     minimumPerformanceClock;
} ADLODNCapabilities;
 
typedef struct ADLODNCapabilitiesX2
{
    int     iMaximumNumberOfPerformanceLevels;
    int iFlags;
    ADLODNParameterRange     sEngineClockRange;
    ADLODNParameterRange     sMemoryClockRange;
    ADLODNParameterRange     svddcRange;
    ADLODNParameterRange     power;
    ADLODNParameterRange     powerTuneTemperature;
    ADLODNParameterRange     fanTemperature;
    ADLODNParameterRange     fanSpeed;
    ADLODNParameterRange     minimumPerformanceClock;
    ADLODNParameterRange throttleNotificaion;
    ADLODNParameterRange autoSystemClock;
} ADLODNCapabilitiesX2;
 
typedef struct ADLODNPerformanceLevel
{
    int iClock;
    int iVddc;
    int iEnabled;
} ADLODNPerformanceLevel;
 
typedef struct ADLODNPerformanceLevels
{
    int iSize;
    //Automatic/manual
    int iMode;
    int iNumberOfPerformanceLevels;
    ADLODNPerformanceLevel aLevels[1];
} ADLODNPerformanceLevels;
 
typedef struct ADLODNFanControl
{
    int iMode;
    int iFanControlMode;
    int iCurrentFanSpeedMode;
    int iCurrentFanSpeed;
    int iTargetFanSpeed;
    int iTargetTemperature;
    int iMinPerformanceClock;
    int iMinFanLimit;
} ADLODNFanControl;
 
typedef struct ADLODNPowerLimitSetting
{
    int iMode;
    int iTDPLimit;
    int iMaxOperatingTemperature;
} ADLODNPowerLimitSetting;
 
typedef struct ADLODNPerformanceStatus
{
    int iCoreClock;
    int iMemoryClock;
    int iDCEFClock;
    int iGFXClock;
    int iUVDClock;
    int iVCEClock;
    int iGPUActivityPercent;
    int iCurrentCorePerformanceLevel;
    int iCurrentMemoryPerformanceLevel;
    int iCurrentDCEFPerformanceLevel;
    int iCurrentGFXPerformanceLevel;
    int iUVDPerformanceLevel;
    int iVCEPerformanceLevel;
    int iCurrentBusSpeed;
    int iCurrentBusLanes;
    int iMaximumBusLanes;
    int iVDDC;
    int iVDDCI;
} ADLODNPerformanceStatus;
 
typedef struct ADLODNPerformanceLevelX2
{
    int iClock;
    int iVddc;
    int iEnabled;
    int iControl;
} ADLODNPerformanceLevelX2;
 
typedef struct ADLODNPerformanceLevelsX2
{
    int iSize;
    //Automatic/manual
    int iMode;
    int iNumberOfPerformanceLevels;
    ADLODNPerformanceLevelX2 aLevels[1];
} ADLODNPerformanceLevelsX2;
 
typedef enum ADLODNCurrentPowerType
{
    ODN_GPU_TOTAL_POWER = 0,
    ODN_GPU_PPT_POWER,
    ODN_GPU_SOCKET_POWER,
    ODN_GPU_CHIP_POWER
} ADLODNCurrentPowerType;
 
// in/out: CWDDEPM_CURRENTPOWERPARAMETERS
typedef struct ADLODNCurrentPowerParameters
{
    int   size;
    ADLODNCurrentPowerType   powerType;
    int  currentPower;
} ADLODNCurrentPowerParameters;
 
//ODN Ext range data structure
typedef struct ADLODNExtSingleInitSetting
{
        int mode;
        int minValue;
        int maxValue;
        int step;
        int defaultValue;
} ADLODNExtSingleInitSetting;
 
//OD8 Ext range data structure
typedef struct ADLOD8SingleInitSetting
{
    int featureID;
    int minValue;
    int maxValue;
    int defaultValue;
} ADLOD8SingleInitSetting;
 
typedef struct ADLOD8InitSetting
{
    int count;
    int overdrive8Capabilities;
    ADLOD8SingleInitSetting  od8SettingTable[OD8_COUNT];
} ADLOD8InitSetting;
 
typedef struct ADLOD8CurrentSetting
{
    int count;
    int Od8SettingTable[OD8_COUNT];
} ADLOD8CurrentSetting;
 
 
typedef struct ADLOD8SingleSetSetting
{
    int value;
    int requested;      // 0 - default , 1 - requested
    int reset;          // 0 - do not reset , 1 - reset setting back to default
} ADLOD8SingleSetSetting;
 
typedef struct ADLOD8SetSetting
{
    int count;
    ADLOD8SingleSetSetting  od8SettingTable[OD8_COUNT];
} ADLOD8SetSetting;
 
typedef struct ADLSingleSensorData
{
    int supported;
    int  value;
} ADLSingleSensorData;
 
typedef struct ADLPMLogDataOutput
{
    int size;
    ADLSingleSensorData sensors[ADL_PMLOG_MAX_SENSORS];
}ADLPMLogDataOutput;
 
typedef struct ADLPPLogSettings
{
    int BreakOnAssert;
    int BreakOnWarn;
    int LogEnabled;
    int LogFieldMask;
    int LogDestinations;
    int LogSeverityEnabled;
    int LogSourceMask;
    int PowerProfilingEnabled;
    int PowerProfilingTimeInterval;
}ADLPPLogSettings;
 
typedef struct ADLFPSSettingsOutput
{
    int ulSize;
    int bACFPSEnabled;
    int bDCFPSEnabled;
    int ulACFPSCurrent;
    int ulDCFPSCurrent;
    int ulACFPSMaximum;
    int ulACFPSMinimum;
    int ulDCFPSMaximum;
    int ulDCFPSMinimum;
} ADLFPSSettingsOutput;
 
typedef struct ADLFPSSettingsInput
{
    int ulSize;
    int bGlobalSettings;
    int ulACFPSCurrent;
    int ulDCFPSCurrent;
    int ulReserved[6];
} ADLFPSSettingsInput;
 
enum { ADL_PMLOG_MAX_SUPPORTED_SENSORS = 256 };
 
typedef struct ADLPMLogSupportInfo
{
    unsigned short usSensors[ADL_PMLOG_MAX_SUPPORTED_SENSORS];
    int ulReserved[16];
} ADLPMLogSupportInfo;
 
typedef struct ADLPMLogStartInput
{
    unsigned short usSensors[ADL_PMLOG_MAX_SUPPORTED_SENSORS];
    unsigned long ulSampleRate;
    int ulReserved[15];
} ADLPMLogStartInput;
 
typedef struct ADLPMLogData
{
    unsigned int ulVersion;
    unsigned int ulActiveSampleRate;
    unsigned long long ulLastUpdated;
    unsigned int ulValues[ADL_PMLOG_MAX_SUPPORTED_SENSORS][2];
    unsigned int ulReserved[256];
} ADLPMLogData;
 
typedef struct ADLPMLogStartOutput
{
    union
    {
        void* pLoggingAddress;
        unsigned long long ptr_LoggingAddress;
    };
    int ulReserved[14];
} ADLPMLogStartOutput;
 
typedef struct ADLPMLogSensorLimits
{
    int SensorLimits[ADL_PMLOG_MAX_SENSORS][2]; //index 0: min, 1: max
} ADLPMLogSensorLimits;
 
 
typedef struct ADLRASGetErrorCountsInput
{
    unsigned int                Reserved[16];
} ADLRASGetErrorCountsInput;
 
 
typedef struct ADLRASGetErrorCountsOutput
{
    unsigned int                CorrectedErrors;    // includes both DRAM and SRAM ECC
    unsigned int                UnCorrectedErrors;  // includes both DRAM and SRAM ECC
    unsigned int                Reserved[14];
} ADLRASGetErrorCountsOutput;
 
 
typedef struct ADLRASGetErrorCounts
{
    unsigned int                InputSize;
    ADLRASGetErrorCountsInput   Input;
    unsigned int                OutputSize;
    ADLRASGetErrorCountsOutput  Output;
} ADLRASGetErrorCounts;
 
 
typedef struct ADLRASResetErrorCountsInput
{
    unsigned int                Reserved[8];
} ADLRASResetErrorCountsInput;
 
 
typedef struct ADLRASResetErrorCountsOutput
{
    unsigned int                Reserved[8];
} ADLRASResetErrorCountsOutput;
 
 
typedef struct ADLRASResetErrorCounts
{
    unsigned int                    InputSize;
    ADLRASResetErrorCountsInput     Input;
    unsigned int                    OutputSize;
    ADLRASResetErrorCountsOutput    Output;
} ADLRASResetErrorCounts;
 
 
typedef struct ADLRASErrorInjectonInput
{
    unsigned long long Address;
    ADL_RAS_INJECTION_METHOD Value;
    ADL_RAS_BLOCK_ID BlockId;
    ADL_RAS_ERROR_TYPE InjectErrorType;
    ADL_MEM_SUB_BLOCK_ID SubBlockIndex;
    unsigned int padding[9];
} ADLRASErrorInjectonInput;
 
 
typedef struct ADLRASErrorInjectionOutput
{
    unsigned int ErrorInjectionStatus;
    unsigned int padding[15];
} ADLRASErrorInjectionOutput;
 
 
typedef struct ADLRASErrorInjection
{
    unsigned int                           InputSize;
    ADLRASErrorInjectonInput               Input;
    unsigned int                           OutputSize;
    ADLRASErrorInjectionOutput             Output;
} ADLRASErrorInjection;
 
typedef struct ADLSGApplicationInfo
{
    wchar_t strFileName[ADL_MAX_PATH];
    wchar_t strFilePath[ADL_MAX_PATH];
    wchar_t strVersion[ADL_MAX_PATH];
    long long int timeStamp;
    unsigned int iProfileExists;
    unsigned int iGPUAffinity;
    ADLBdf GPUBdf;
} ADLSGApplicationInfo;
 
enum { ADLPreFlipPostProcessingInfoInvalidLUTIndex = 0xFFFFFFFF };
 
enum ADLPreFlipPostProcessingLUTAlgorithm
{
    ADLPreFlipPostProcessingLUTAlgorithm_Default = 0,
    ADLPreFlipPostProcessingLUTAlgorithm_Full,
    ADLPreFlipPostProcessingLUTAlgorithm_Approximation
};
 
typedef struct ADLPreFlipPostProcessingInfo
{
    int ulSize;
    int bEnabled;
    int ulSelectedLUTIndex;
    int ulSelectedLUTAlgorithm;
    int ulReserved[12];
} ADLPreFlipPostProcessingInfo;
 
typedef struct ADL_ERROR_REASON
{
    int boost; //ON, when boost is Enabled
    int delag; //ON, when delag is Enabled
    int chill; //ON, when chill is Enabled
    int proVsr; //ON, when proVsr is Enabled
}ADL_ERROR_REASON;
 
typedef struct ADL_ERROR_REASON2
{
    int boost; //ON, when boost is Enabled
    int delag; //ON, when delag is Enabled
    int chill; //ON, when chill is Enabled
    int proVsr; //ON, when proVsr is Enabled
    int upscale; //ON, when RSR is Enabled
}ADL_ERROR_REASON2;
 
typedef struct ADL_DELAG_NOTFICATION_REASON
{
        int HotkeyChanged; //Set when Hotkey value is changed
        int GlobalEnableChanged; //Set when Global enable value is changed
        int GlobalLimitFPSChanged; //Set when Global enable value is changed
}ADL_DELAG_NOTFICATION_REASON;
 
typedef struct ADL_DELAG_SETTINGS
{
        int Hotkey; // Hotkey value
        int GlobalEnable; //Global enable value
        int GlobalLimitFPS; //Global Limit FPS
        int GlobalLimitFPS_MinLimit; //Gloabl Limit FPS slider min limit value
        int GlobalLimitFPS_MaxLimit; //Gloabl Limit FPS slider max limit value
        int GlobalLimitFPS_Step; //Gloabl Limit FPS step  value
}ADL_DELAG_SETTINGS;
 
typedef struct ADL_BOOST_NOTFICATION_REASON
{
        int HotkeyChanged; //Set when Hotkey value is changed
        int GlobalEnableChanged; //Set when Global enable value is changed
        int GlobalMinResChanged; //Set when Global min resolution value is changed
}ADL_BOOST_NOTFICATION_REASON;
 
typedef struct ADL_BOOST_SETTINGS
{
        int Hotkey; // Hotkey value
        int GlobalEnable; //Global enable value
        int GlobalMinRes; //Gloabl Min Resolution value
        int GlobalMinRes_MinLimit; //Gloabl Min Resolution slider min limit value
        int GlobalMinRes_MaxLimit; //Gloabl Min Resolution slider max limit value
        int GlobalMinRes_Step; //Gloabl Min Resolution step  value
}ADL_BOOST_SETTINGS;
 
 
typedef struct ADL_PROVSR_NOTFICATION_REASON
{
        int HotkeyChanged; //Set when Hotkey value is changed
        int GlobalEnableChanged; //Set when Global enable value is changed
}ADL_PROVSR_NOTFICATION_REASON;
 
typedef struct ADL_PROVSR_SETTINGS
{
        int Hotkey; // Hotkey value
        int GlobalEnable; //Global enable value
}ADL_PROVSR_SETTINGS;
 
typedef struct ADL_IMAGE_BOOST_NOTFICATION_REASON
{
    int HotkeyChanged; //Set when Hotkey value is changed
    int GlobalEnableChanged; //Set when Global enable value is changed
}ADL_IMAGE_BOOST_NOTFICATION_REASON;
 
typedef struct ADL_IMAGE_BOOST_SETTINGS
{
    int Hotkey; // Hotkey value
    int GlobalEnable; //Global enable value
}ADL_IMAGE_BOOST_SETTINGS;
 
 
typedef struct ADL_RIS_NOTFICATION_REASON
{
        unsigned int GlobalEnableChanged; //Set when Global enable value is changed
        unsigned int GlobalSharpeningDegreeChanged; //Set when Global sharpening Degree value is changed
}ADL_RIS_NOTFICATION_REASON;
 
typedef struct ADL_RIS_SETTINGS
{
        int GlobalEnable; //Global enable value
        int GlobalSharpeningDegree; //Global sharpening value
        int GlobalSharpeningDegree_MinLimit; //Gloabl sharpening slider min limit value
        int GlobalSharpeningDegree_MaxLimit; //Gloabl sharpening slider max limit value
        int GlobalSharpeningDegree_Step; //Gloabl sharpening step  value
}ADL_RIS_SETTINGS;
 
typedef struct ADL_CHILL_NOTFICATION_REASON
{
        int HotkeyChanged; //Set when Hotkey value is changed
        int GlobalEnableChanged; //Set when Global enable value is changed
        int GlobalMinFPSChanged; //Set when Global min FPS value is changed
        int GlobalMaxFPSChanged; //Set when Global max FPS value is changed
}ADL_CHILL_NOTFICATION_REASON;
 
typedef struct ADL_CHILL_SETTINGS
{
        int Hotkey; // Hotkey value
        int GlobalEnable; //Global enable value
        int GlobalMinFPS; //Global Min FPS value
        int GlobalMaxFPS; //Global Max FPS value
        int GlobalFPS_MinLimit; //Gloabl FPS slider min limit value
        int GlobalFPS_MaxLimit; //Gloabl FPS slider max limit value
        int GlobalFPS_Step; //Gloabl FPS Slider step  value
}ADL_CHILL_SETTINGS;
 
typedef struct ADL_DRIVERUPSCALE_NOTFICATION_REASON
{
    int ModeOverrideEnabledChanged;     //Set when Global min resolution value is changed
    int GlobalEnabledChanged;           //Set when Global enable value is changed
}ADL_DRIVERUPSCALE_NOTFICATION_REASON;
 
typedef struct ADL_DRIVERUPSCALE_SETTINGS
{
    int ModeOverrideEnabled;
    int GlobalEnabled;
}ADL_DRIVERUPSCALE_SETTINGS;
 
typedef struct ADL_RADEON_LED_COLOR_CONFIG
{
        unsigned short R : 8; // Red Value
        unsigned short G : 8; // Green Value
        unsigned short B : 8; // Blue Value
}ADL_RADEON_LED_COLOR_CONFIG;
 
typedef struct ADL_RADEON_LED_PATTERN_CONFIG_GENERIC
{
        short brightness : 8; // Brightness of LED
        short speed : 8; // Speed of LED pattern
        bool directionCounterClockWise; //Direction of LED Pattern
        ADL_RADEON_LED_COLOR_CONFIG colorConfig; // RGB value of LED pattern
        char morseCodeText[ADL_RADEON_LED_MAX_MORSE_CODE]; // Morse Code user input for Morse Code LED pattern
        char morseCodeTextOutPut[ADL_RADEON_LED_MAX_MORSE_CODE]; // Driver set output representation of Morse Code
        int  morseCodeTextOutPutLen; // Length of Morse Code output
}ADL_RADEON_LED_PATTERN_CONFIG_GENERIC;
 
typedef struct ADL_RADEON_LED_CUSTOM_LED_CONFIG
{
        short brightness : 8; // Brightness of LED
        ADL_RADEON_LED_COLOR_CONFIG colorConfig[ADL_RADEON_LED_MAX_LED_ROW_ON_GRID][ADL_RADEON_LED_MAX_LED_COLUMN_ON_GRID]; // Full grid array representation of Radeon LED to be populated by user
}ADL_RADEON_LED_CUSTOM_GRID_LED_CONFIG;
 
typedef struct ADL_RADEON_LED_PATTERN_CONFIG
{
        ADL_RADEON_USB_LED_BAR_CONTROLS control; //Requested LED pattern
 
    union
    {
                ADL_RADEON_LED_PATTERN_CONFIG_GENERIC genericPararmeters; //Requested pattern configuration settings
                ADL_RADEON_LED_CUSTOM_GRID_LED_CONFIG customGridConfig; //Requested custom grid configuration settings
    };
}ADL_RADEON_LED_PATTERN_CONFIG;
 
typedef struct AdapterInfoX2
{
 
    int iSize;
    int iAdapterIndex;
    char strUDID[ADL_MAX_PATH];
    int iBusNumber;
    int iDeviceNumber;
    int iFunctionNumber;
    int iVendorID;
    char strAdapterName[ADL_MAX_PATH];
    char strDisplayName[ADL_MAX_PATH];
    int iPresent;
    int iExist;
    char strDriverPath[ADL_MAX_PATH];
    char strDriverPathExt[ADL_MAX_PATH];
    char strPNPString[ADL_MAX_PATH];
    int iOSDisplayIndex;
    int iInfoMask;
    int iInfoValue;
} AdapterInfoX2, *LPAdapterInfoX2;
 
 
typedef  struct ADLGamutReference
{
    int      iGamutRef;
}ADLGamutReference;
 
 
typedef struct ADLGamutInfo
{
    int    SupportedGamutSpace;
 
    int    SupportedWhitePoint;
} ADLGamutInfo;
 
 
typedef struct ADLPoint
{
    int          iX;
    int          iY;
} ADLPoint;
 
typedef struct ADLGamutCoordinates
{
    ADLPoint      Red;
    ADLPoint      Green;
    ADLPoint      Blue;
} ADLGamutCoordinates;
 
 
typedef  struct ADLGamutData
{
    int        iFeature;
 
    int         iPredefinedGamut;
 
    int         iPredefinedWhitePoint;
 
    ADLPoint             CustomWhitePoint;
 
    ADLGamutCoordinates  CustomGamut;
} ADLGamutData;
 
typedef struct ADLDetailedTimingX2
{
    int   iSize;
    int sTimingFlags;
    int sHTotal;
    int sHDisplay;
    int sHSyncStart;
    int sHSyncWidth;
    int sVTotal;
    int sVDisplay;
    int sVSyncStart;
    int sVSyncWidth;
    int sPixelClock;
    short sHOverscanRight;
    short sHOverscanLeft;
    short sVOverscanBottom;
    short sVOverscanTop;
    short sOverscan8B;
    short sOverscanGR;
} ADLDetailedTimingX2;
 
typedef struct ADLDisplayModeInfoX2
{
    int  iTimingStandard;
    int  iPossibleStandard;
    int  iRefreshRate;
    int  iPelsWidth;
    int  iPelsHeight;
    ADLDetailedTimingX2  sDetailedTiming;
} ADLDisplayModeInfoX2;
 
typedef struct ADLI2CLargePayload
{
    int iSize;
    int iLine;
    int iAddress;
    int iOffset;
    int iAction;
    int iSpeed;
    int iFlags;
    int iDataSize;
    char *pcData;
} ADLI2CLargePayload;
 
#define ADL_FEATURE_NAME_LENGTH         16
 
typedef struct ADLFeatureName
{
    char FeatureName[ADL_FEATURE_NAME_LENGTH];
}       ADLFeatureName, *LPADLFeatureName;
 
typedef struct ADLFeatureCaps
{
    ADLFeatureName      Name;
    //  char strFeatureName[ADL_FEATURE_NAME_LENGTH];
 
    int  iGroupID;
 
    int  iVisualID;
 
    int iPageID;
 
    int iFeatureMask;
 
    int  iFeatureProperties;
 
    int  iControlType;
 
    int  iControlStyle;
 
    int  iAdjustmentType;
 
    int  iAdjustmentStyle;
 
    int bDefault;
 
    int iMin;
 
    int iMax;
 
    int iStep;
 
    int iDefault;
 
    float fMin;
 
    float fMax;
 
    float fStep;
 
    float fDefault;
 
    int EnumMask;
} ADLFeatureCaps, *LPADLFeatureCaps;
 
typedef struct ADLFeatureValues
{
    ADLFeatureName      Name;
    //  char strFeatureName[ADL_FEATURE_NAME_LENGTH];
 
    int bCurrent;
 
    int iCurrent;
 
    float fCurrent;
 
    int EnumStates;
} ADLFeatureValues, *LPADLFeatureValues;
 
 
typedef struct ADLHDCPSettings
{
        int iHDCPProtectionVersion; // Version, starting from 1
        int iHDCPCaps; //Caps used to ensure at least one protection scheme is supported, 1 is HDCP1X and 2 is HDCP22
        int iAllowAll; //Allow all is true, disable all is false
        int iHDCPVale;
        int iHDCPMask;
} ADLHDCPSettings;
 
 
typedef struct ADLMantleAppInfo
{
        int   apiVersion;
        long   driverVersion;
        long   vendorId;
        long   deviceId;
        int     gpuType;
        char     gpuName[256];
        int     maxMemRefsPerSubmission;
        long long virtualMemPageSize;
        long long maxInlineMemoryUpdateSize;
        long     maxBoundDescriptorSets;
        long     maxThreadGroupSize;
        long  long timestampFrequency;
        long     multiColorTargetClears;
}ADLMantleAppInfo, *LPADLMantleAppInfo;
 
typedef struct ADLSDIData
{
        int iSDIState;
        int iSizeofSDISegment;
} ADLSDIData, *LPADLSDIData;
 
 
typedef struct ADL_FRTCPRO_Settings
{
    int DefaultState;              //The default status for FRTC pro
    int CurrentState;              //The current enable/disable status for FRTC pro
    unsigned int DefaultValue;     //The default FPS value for FRTC pro.
    unsigned int CurrentValue;      //The current FPS value for FRTC pro.
    unsigned int maxSupportedFps;      //The max value for FRTC pro.
    unsigned int minSupportedFps;      //The min value for FRTC pro.
}ADL_FRTCPRO_Settings, *LPADLFRTCProSettings;
 
typedef struct ADL_FRTCPRO_CHANGED_REASON
{
    int StateChanged;               // FRTCPro state changed
    int ValueChanged;               // FRTCPro value changed
}ADL_FRTCPRO_CHANGED_REASON;
 
typedef struct ADL_DL_DISPLAY_MODE
{
    int  iPelsHeight;                      // Vertical resolution (in pixels).
    int  iPelsWidth;                       // Horizontal resolution (in pixels).
    int  iBitsPerPel;                      // Color depth.
    int  iDisplayFrequency;                // Refresh rate.
} ADL_DL_DISPLAY_MODE;
 
typedef union _ADLDCESupport
{
    struct
    {
        unsigned int PrePhasis : 1;
        unsigned int voltageSwing : 1;
        unsigned int reserved : 30;
    }bits;
    unsigned int u32All;
}ADLDCESupport;
 
typedef struct ADLSmartShiftSettings
{
        int iMinRange;
        int iMaxRange;
        int iDefaultMode; //Refer to CWDDEPM_ODN_CONTROL_TYPE
        int iDefaultValue;
        int iCurrentMode;
        int iCurrentValue;
    int iFlags; //refer to define_smartshift_bits
}ADLSmartShiftSettings, *LPADLSmartShiftSettings;
#endif /* ADL_STRUCTURES_H_ */