OverdriveN/OverdriveN.cpp

A C/C++ Sample Application for Windows (XP, Vista and above); 32bit and 64bit
Visual Studio 2012 solution file "OverdriveN.sln" is included in ADL SDK

#include <stdio.h>
#include <tchar.h>

 



#include <windows.h>
#include "..\..\include\adl_sdk.h"
#include "..\..\include\adl_structures.h"


#include <stdio.h>

// Comment out one of the two lines below to allow or supress diagnostic messages
// #define PRINTF
#define PRINTF printf

// Definitions of the used function pointers. Add more if you use other ADL APIs
typedef int ( *ADL_MAIN_CONTROL_CREATE )(ADL_MAIN_MALLOC_CALLBACK, int );
typedef int ( *ADL_MAIN_CONTROL_DESTROY )();
typedef int ( *ADL_FLUSH_DRIVER_DATA)(int);
typedef int (*ADL2_ADAPTER_ACTIVE_GET ) (ADL_CONTEXT_HANDLE, int, int* );

typedef int ( *ADL_ADAPTER_NUMBEROFADAPTERS_GET ) ( int* );
typedef int ( *ADL_ADAPTER_ADAPTERINFO_GET ) ( LPAdapterInfo, int );
typedef int ( *ADL_ADAPTERX2_CAPS) (int, int*);
typedef int ( *ADL2_OVERDRIVE_CAPS) (ADL_CONTEXT_HANDLE context, int iAdapterIndex, int * iSupported, int * iEnabled, int * iVersion);
typedef int ( *ADL2_OVERDRIVEN_CAPABILITIES_GET)        (ADL_CONTEXT_HANDLE, int, ADLODNCapabilities*);
typedef int ( *ADL2_OVERDRIVEN_SYSTEMCLOCKS_GET)        (ADL_CONTEXT_HANDLE, int, ADLODNPerformanceLevels*);
typedef int ( *ADL2_OVERDRIVEN_SYSTEMCLOCKS_SET)        (ADL_CONTEXT_HANDLE, int, ADLODNPerformanceLevels*);
typedef int ( *ADL2_OVERDRIVEN_MEMORYCLOCKS_GET)        (ADL_CONTEXT_HANDLE, int, ADLODNPerformanceLevels*);
typedef int ( *ADL2_OVERDRIVEN_MEMORYCLOCKS_SET)        (ADL_CONTEXT_HANDLE, int, ADLODNPerformanceLevels*);
typedef int ( *ADL2_OVERDRIVEN_PERFORMANCESTATUS_GET) (ADL_CONTEXT_HANDLE, int, ADLODNPerformanceStatus*);
typedef int ( *ADL2_OVERDRIVEN_FANCONTROL_GET) (ADL_CONTEXT_HANDLE, int, ADLODNFanControl*);
typedef int ( *ADL2_OVERDRIVEN_FANCONTROL_SET) (ADL_CONTEXT_HANDLE, int, ADLODNFanControl*);
typedef int ( *ADL2_OVERDRIVEN_POWERLIMIT_GET) (ADL_CONTEXT_HANDLE, int, ADLODNPowerLimitSetting*);
typedef int ( *ADL2_OVERDRIVEN_POWERLIMIT_SET) (ADL_CONTEXT_HANDLE, int, ADLODNPowerLimitSetting*);
typedef int ( *ADL2_OVERDRIVEN_TEMPERATURE_GET) (ADL_CONTEXT_HANDLE, int, int, int*);
HINSTANCE hDLL;

ADL_MAIN_CONTROL_CREATE          ADL_Main_Control_Create = NULL;
ADL_MAIN_CONTROL_DESTROY         ADL_Main_Control_Destroy = NULL;
ADL_ADAPTER_NUMBEROFADAPTERS_GET ADL_Adapter_NumberOfAdapters_Get = NULL;
ADL_ADAPTER_ADAPTERINFO_GET      ADL_Adapter_AdapterInfo_Get = NULL;
ADL_ADAPTERX2_CAPS ADL_AdapterX2_Caps = NULL;
ADL2_ADAPTER_ACTIVE_GET                         ADL2_Adapter_Active_Get=NULL;
ADL2_OVERDRIVEN_CAPABILITIES_GET ADL2_OverdriveN_Capabilities_Get = NULL;
ADL2_OVERDRIVEN_SYSTEMCLOCKS_GET ADL2_OverdriveN_SystemClocks_Get = NULL;
ADL2_OVERDRIVEN_SYSTEMCLOCKS_SET ADL2_OverdriveN_SystemClocks_Set = NULL;
ADL2_OVERDRIVEN_PERFORMANCESTATUS_GET ADL2_OverdriveN_PerformanceStatus_Get = NULL;
ADL2_OVERDRIVEN_FANCONTROL_GET ADL2_OverdriveN_FanControl_Get =NULL;
ADL2_OVERDRIVEN_FANCONTROL_SET ADL2_OverdriveN_FanControl_Set=NULL;
ADL2_OVERDRIVEN_POWERLIMIT_GET ADL2_OverdriveN_PowerLimit_Get =NULL;
ADL2_OVERDRIVEN_POWERLIMIT_SET ADL2_OverdriveN_PowerLimit_Set=NULL;
ADL2_OVERDRIVEN_MEMORYCLOCKS_GET ADL2_OverdriveN_MemoryClocks_Get = NULL;
ADL2_OVERDRIVEN_MEMORYCLOCKS_GET ADL2_OverdriveN_MemoryClocks_Set = NULL;
ADL2_OVERDRIVE_CAPS ADL2_Overdrive_Caps = NULL;
ADL2_OVERDRIVEN_TEMPERATURE_GET ADL2_OverdriveN_Temperature_Get = NULL;
// Memory allocation function
void* __stdcall ADL_Main_Memory_Alloc ( int iSize )
{
    void* lpBuffer = malloc ( iSize );
    return lpBuffer;
}

// Optional Memory de-allocation function
void __stdcall ADL_Main_Memory_Free ( void** lpBuffer )
{
    if ( NULL != *lpBuffer )
    {
        free ( *lpBuffer );
        *lpBuffer = NULL;
    }
}

ADL_CONTEXT_HANDLE context = NULL;

LPAdapterInfo   lpAdapterInfo = NULL;
int  iNumberAdapters;


int initializeADL()
{
        
        // Load the ADL dll
        hDLL = LoadLibrary(TEXT("atiadlxx.dll"));
        if (hDLL == NULL)
        {
                // A 32 bit calling application on 64 bit OS will fail to LoadLibrary.
                // Try to load the 32 bit library (atiadlxy.dll) instead
                hDLL = LoadLibrary(TEXT("atiadlxy.dll"));
        }
        
        if (NULL == hDLL)
        {
                PRINTF("Failed to load ADL library\n");
                return FALSE;
        }
        ADL_Main_Control_Create = (ADL_MAIN_CONTROL_CREATE) GetProcAddress(hDLL,"ADL_Main_Control_Create");
        ADL_Main_Control_Destroy = (ADL_MAIN_CONTROL_DESTROY) GetProcAddress(hDLL,"ADL_Main_Control_Destroy");
        ADL_Adapter_NumberOfAdapters_Get = (ADL_ADAPTER_NUMBEROFADAPTERS_GET) GetProcAddress(hDLL,"ADL_Adapter_NumberOfAdapters_Get");
        ADL_Adapter_AdapterInfo_Get = (ADL_ADAPTER_ADAPTERINFO_GET) GetProcAddress(hDLL,"ADL_Adapter_AdapterInfo_Get");
        ADL_AdapterX2_Caps = (ADL_ADAPTERX2_CAPS) GetProcAddress( hDLL, "ADL_AdapterX2_Caps");
        ADL2_Adapter_Active_Get = (ADL2_ADAPTER_ACTIVE_GET)GetProcAddress(hDLL, "ADL2_Adapter_Active_Get");
        ADL2_OverdriveN_Capabilities_Get = (ADL2_OVERDRIVEN_CAPABILITIES_GET) GetProcAddress (hDLL, "ADL2_OverdriveN_Capabilities_Get");
        ADL2_OverdriveN_SystemClocks_Get = (ADL2_OVERDRIVEN_SYSTEMCLOCKS_GET) GetProcAddress (hDLL, "ADL2_OverdriveN_SystemClocks_Get");
        ADL2_OverdriveN_SystemClocks_Set = (ADL2_OVERDRIVEN_SYSTEMCLOCKS_SET) GetProcAddress (hDLL, "ADL2_OverdriveN_SystemClocks_Set");
        ADL2_OverdriveN_MemoryClocks_Get = (ADL2_OVERDRIVEN_MEMORYCLOCKS_GET) GetProcAddress (hDLL, "ADL2_OverdriveN_MemoryClocks_Get");
        ADL2_OverdriveN_MemoryClocks_Set = (ADL2_OVERDRIVEN_MEMORYCLOCKS_SET) GetProcAddress (hDLL, "ADL2_OverdriveN_MemoryClocks_Set");
        ADL2_OverdriveN_PerformanceStatus_Get = (ADL2_OVERDRIVEN_PERFORMANCESTATUS_GET) GetProcAddress (hDLL,"ADL2_OverdriveN_PerformanceStatus_Get");
        ADL2_OverdriveN_FanControl_Get = (ADL2_OVERDRIVEN_FANCONTROL_GET) GetProcAddress (hDLL, "ADL2_OverdriveN_FanControl_Get");
        ADL2_OverdriveN_FanControl_Set = (ADL2_OVERDRIVEN_FANCONTROL_SET) GetProcAddress (hDLL, "ADL2_OverdriveN_FanControl_Set");
        ADL2_OverdriveN_PowerLimit_Get = (ADL2_OVERDRIVEN_POWERLIMIT_GET) GetProcAddress (hDLL, "ADL2_OverdriveN_PowerLimit_Get");
        ADL2_OverdriveN_PowerLimit_Set = (ADL2_OVERDRIVEN_POWERLIMIT_SET) GetProcAddress (hDLL, "ADL2_OverdriveN_PowerLimit_Set");
        ADL2_OverdriveN_Temperature_Get = (ADL2_OVERDRIVEN_TEMPERATURE_GET) GetProcAddress (hDLL, "ADL2_OverdriveN_Temperature_Get");
        ADL2_Overdrive_Caps = (ADL2_OVERDRIVE_CAPS) GetProcAddress (hDLL, "ADL2_Overdrive_Caps");
        if ( NULL == ADL_Main_Control_Create ||
                 NULL == ADL_Main_Control_Destroy ||
                 NULL == ADL_Adapter_NumberOfAdapters_Get||
                 NULL == ADL_Adapter_AdapterInfo_Get ||
                 NULL == ADL_AdapterX2_Caps ||
                NULL == ADL2_Adapter_Active_Get ||
                NULL == ADL2_OverdriveN_Capabilities_Get || 
                NULL == ADL2_OverdriveN_SystemClocks_Get ||
                NULL == ADL2_OverdriveN_SystemClocks_Set ||
                NULL == ADL2_OverdriveN_MemoryClocks_Get ||
                NULL == ADL2_OverdriveN_MemoryClocks_Set ||
                NULL == ADL2_OverdriveN_PerformanceStatus_Get ||
                NULL == ADL2_OverdriveN_FanControl_Get ||
                NULL == ADL2_OverdriveN_FanControl_Set ||
                NULL == ADL2_Overdrive_Caps
                )
        {
                PRINTF("Failed to get ADL function pointers\n");
                return FALSE;
        }

        if (ADL_OK != ADL_Main_Control_Create(ADL_Main_Memory_Alloc, 1))
        {
                printf("Failed to initialize nested ADL2 context");
                return ADL_ERR;
        }
        
        return TRUE;
}

void deinitializeADL()
{
                
        ADL_Main_Control_Destroy();
        
        FreeLibrary(hDLL);


}

int printODNSCLKParameters()
{
        int  i, active = 0;;
        
        int iSupported,iEnabled,iVersion;
         

        // Repeat for all available adapters in the system
    for ( i = 0; i < iNumberAdapters; i++ )
    {
                if (lpAdapterInfo[ i ].iBusNumber > -1)
                {
                        ADL2_Overdrive_Caps(context,lpAdapterInfo[ i ].iAdapterIndex, &iSupported, &iEnabled, &iVersion);
                        if (iVersion == 7)
                        {
                                ADLODNCapabilities overdriveCapabilities;
                                memset(&overdriveCapabilities, 0, sizeof(ADLODNCapabilities));
    
                                if (ADL_OK != ADL2_OverdriveN_Capabilities_Get(context,lpAdapterInfo[ i ].iAdapterIndex, &overdriveCapabilities))
                                {
                                        PRINTF("ADL2_OverdriveN_Capabilities_Get is failed\n");                         
                                }
                                else
                                {
                                        //performance levels info
                                        ADLODNPerformanceLevels *odPerformanceLevels;

                                        int size = sizeof(ADLODNPerformanceLevels) + sizeof(ADLODNPerformanceLevel)* (overdriveCapabilities.iMaximumNumberOfPerformanceLevels - 1);
                                        void* performanceLevelsBuffer = new char[size];
                                        memset(performanceLevelsBuffer, 0, size);
                                        odPerformanceLevels = (ADLODNPerformanceLevels*)performanceLevelsBuffer;
                                        odPerformanceLevels->iSize = size;
                                        odPerformanceLevels->iNumberOfPerformanceLevels = overdriveCapabilities.iMaximumNumberOfPerformanceLevels;
                                        //get GPU clocks
                                        if (ADL_OK != ADL2_OverdriveN_SystemClocks_Get(context, lpAdapterInfo[ i ].iAdapterIndex, odPerformanceLevels))
                                        {
                                                PRINTF("ADL2_OverdriveN_GPUClocks_Get is failed\n");

                                        }

                                        PRINTF("--------------------------------------------\n");                                       
                                        PRINTF(" ADL2_OverdriveN_GPUClocks_Get Data\n");
                                        PRINTF("--------------------------------------------\n");                                       
                                        PRINTF("Number of Levels : %d \n" ,overdriveCapabilities.iMaximumNumberOfPerformanceLevels);
                                        PRINTF("Clocks: Minimum Range : %d, Maximum Range : %d, Step value: %d\n" ,overdriveCapabilities.sEngineClockRange.iMin,overdriveCapabilities.sEngineClockRange.iMax, overdriveCapabilities.sEngineClockRange.iStep);
                                        PRINTF("Voltage: Minimum Range : %d, Maximum Range : %d, Step value: %d\n" ,overdriveCapabilities.svddcRange.iMin,overdriveCapabilities.svddcRange.iMax, overdriveCapabilities.svddcRange.iStep);
                                        for (int i=0 ;i <overdriveCapabilities.iMaximumNumberOfPerformanceLevels;i++)
                                        {
                                                PRINTF("odPerformanceLevels->aLevels[%d].iClock : %d\n" , i, odPerformanceLevels->aLevels[i].iClock);
                                                PRINTF("odPerformanceLevels->aLevels[%d].iEnabled : %d\n", i, odPerformanceLevels->aLevels[i].iEnabled);
                                                PRINTF("odPerformanceLevels->aLevels[%d].iVddc : %d\n\n", i, odPerformanceLevels->aLevels[i].iVddc);    
                                        }                       
                                        PRINTF("---------------------------------------------\n");                                      
                                }                               
                                break;
                        }                       
                }                                       
        }

        
        
        return 0;
}

int setODNSCLKParameters(int level, int feature, int value)
{
        int i, active = 0;;
        int iSupported,iEnabled,iVersion;
        
        
        // Obtain the number of adapters for the system
    if ( ADL_OK != ADL_Adapter_NumberOfAdapters_Get ( &iNumberAdapters ) )
        {
               PRINTF("Cannot get the number of adapters!\n");
                   return 0;
        }

    if ( 0 < iNumberAdapters )
    {
        lpAdapterInfo = (LPAdapterInfo)malloc ( sizeof (AdapterInfo) * iNumberAdapters );
        memset ( lpAdapterInfo,'\0', sizeof (AdapterInfo) * iNumberAdapters );

        // Get the AdapterInfo structure for all adapters in the system
        ADL_Adapter_AdapterInfo_Get (lpAdapterInfo, sizeof (AdapterInfo) * iNumberAdapters);
    }

        // Repeat for all available adapters in the system
    for ( i = 0; i < iNumberAdapters; i++ )
    {
                if (lpAdapterInfo[ i ].iBusNumber > -1)
                {
                        ADL2_Overdrive_Caps(context,lpAdapterInfo[ i ].iAdapterIndex, &iSupported, &iEnabled, &iVersion);
                        if (iVersion == 7)
                        {
                                ADLODNCapabilities overdriveCapabilities;
                                memset(&overdriveCapabilities, 0, sizeof(ADLODNCapabilities));
    
                                if (ADL_OK != ADL2_OverdriveN_Capabilities_Get(context,lpAdapterInfo[ i ].iAdapterIndex, &overdriveCapabilities))
                                {
                                        PRINTF("ADL2_OverdriveN_Capabilities_Get is failed\n");                         
                                }
                                else
                                {
                                        //performance levels info
                                        ADLODNPerformanceLevels *odPerformanceLevels;

                                        int size = sizeof(ADLODNPerformanceLevels) + sizeof(ADLODNPerformanceLevel)* (overdriveCapabilities.iMaximumNumberOfPerformanceLevels - 1);
                                        void* performanceLevelsBuffer = new char[size];
                                        memset(performanceLevelsBuffer, 0, size);
                                        odPerformanceLevels = (ADLODNPerformanceLevels*)performanceLevelsBuffer;
                                        odPerformanceLevels->iSize = size;
                                        odPerformanceLevels->iNumberOfPerformanceLevels = overdriveCapabilities.iMaximumNumberOfPerformanceLevels;
                                        //get GPU clocks
                                        if (ADL_OK != ADL2_OverdriveN_SystemClocks_Get(context, lpAdapterInfo[ i ].iAdapterIndex, odPerformanceLevels))
                                        {
                                                PRINTF("ADL2_OverdriveN_GPUClocks_Get is failed\n");

                                        }

                                        if (feature == 1)
                                        {
                                                if (!(overdriveCapabilities.sEngineClockRange.iMin <= value && overdriveCapabilities.sEngineClockRange.iMax >= value))
                                                {
                                                        PRINTF("Clock range should be in Min : %d, Max : %d, Step : %d\n" ,overdriveCapabilities.sEngineClockRange.iMin,overdriveCapabilities.sEngineClockRange.iMax, overdriveCapabilities.sEngineClockRange.iStep);                   
                                                }
                                                else if (level > overdriveCapabilities.iMaximumNumberOfPerformanceLevels || level < 0)
                                                {
                                                        PRINTF("Performance level should be less than : %d\n" ,overdriveCapabilities.iMaximumNumberOfPerformanceLevels);                        
                                                }
                                                else if (odPerformanceLevels->aLevels[level].iEnabled == 0)
                                                {
                                                        PRINTF("Performance level (%d) is disabled\n" ,level);                  
                                                }
                                                else
                                                {
                                                        PRINTF ("***** Driver Values: Before Apply ******\n");
                                                        printODNSCLKParameters();
                                                        odPerformanceLevels->aLevels[level].iClock = value;                                                     
                                                        odPerformanceLevels->iMode = ADLODNControlType::ODNControlType_Manual;
                                                        
                                                        if (ADL_OK != ADL2_OverdriveN_SystemClocks_Set(context,lpAdapterInfo[ i ].iAdapterIndex, odPerformanceLevels))
                                                        {
                                                                PRINTF("ADL2_OverdriveN_SystemClocks_Set is failed\n");
                                                        }
                                                        else
                                                        {
                                                                PRINTF("ADL2_OverdriveN_SystemClocks_Set is Success\n\n");
                                                                PRINTF ("****** Driver Values: After Apply ******\n");
                                                                printODNSCLKParameters();
                                                        }
                                                }
                                        }
                                        else if (feature == 2)
                                        {
                                                if (!(overdriveCapabilities.svddcRange.iMin <= value && overdriveCapabilities.svddcRange.iMax >= value))
                                                {
                                                        PRINTF("Clock range should be in Min : %d, Max : %d, Step : %d\n" ,overdriveCapabilities.svddcRange.iMin,overdriveCapabilities.svddcRange.iMax, overdriveCapabilities.svddcRange.iStep);                        
                                                }
                                                else if (level > overdriveCapabilities.iMaximumNumberOfPerformanceLevels || level < 0)
                                                {
                                                        PRINTF("Performance level should be less than : %d\n" ,overdriveCapabilities.iMaximumNumberOfPerformanceLevels);                        
                                                }
                                                else if (odPerformanceLevels->aLevels[level].iEnabled == 0)
                                                {
                                                        PRINTF("Performance level (%d) is disabled\n" ,level);                  
                                                }
                                                else
                                                {
                                                        PRINTF ("***** Driver Values: Before Apply ******\n");
                                                        printODNSCLKParameters();
                                                        odPerformanceLevels->aLevels[level].iVddc = value;                                                      
                                                        odPerformanceLevels->iMode = ADLODNControlType::ODNControlType_Manual;
                                                        
                                                        if (ADL_OK != ADL2_OverdriveN_SystemClocks_Set(context,lpAdapterInfo[ i ].iAdapterIndex, odPerformanceLevels))
                                                        {
                                                                PRINTF("ADL2_OverdriveN_SystemClocks_Set is failed\n");
                                                        }
                                                        else
                                                        {
                                                                PRINTF("ADL2_OverdriveN_SystemClocks_Set is Success\n\n");
                                                                PRINTF ("****** Driver Values: After Apply ******\n");
                                                                printODNSCLKParameters();
                                                        }
                                                }                               
                                        }                                               
                                }
                                break;
                        }
                }                                       
        }

        
        
        return 0;
}

int printODNMCLKParameters()
{
        int i, active = 0;;
        int iSupported,iEnabled,iVersion;
        

        // Obtain the number of adapters for the system
    if ( ADL_OK != ADL_Adapter_NumberOfAdapters_Get ( &iNumberAdapters ) )
        {
               PRINTF("Cannot get the number of adapters!\n");
                   return 0;
        }

    if ( 0 < iNumberAdapters )
    {
        lpAdapterInfo = (LPAdapterInfo)malloc ( sizeof (AdapterInfo) * iNumberAdapters );
        memset ( lpAdapterInfo,'\0', sizeof (AdapterInfo) * iNumberAdapters );

        // Get the AdapterInfo structure for all adapters in the system
        ADL_Adapter_AdapterInfo_Get (lpAdapterInfo, sizeof (AdapterInfo) * iNumberAdapters);
    }

        // Repeat for all available adapters in the system
    for ( i = 0; i < iNumberAdapters; i++ )
    {
                
                        if (lpAdapterInfo[ i ].iBusNumber > -1)
                        {
                                ADL2_Overdrive_Caps(context,lpAdapterInfo[ i ].iAdapterIndex, &iSupported, &iEnabled, &iVersion);
                        if (iVersion == 7)
                        {
                                 ADLODNCapabilities overdriveCapabilities;
                                memset(&overdriveCapabilities, 0, sizeof(ADLODNCapabilities));
    
                                if (ADL_OK != ADL2_OverdriveN_Capabilities_Get(context,lpAdapterInfo[ i ].iAdapterIndex, &overdriveCapabilities))
                                {
                                                PRINTF("ADL2_OverdriveN_Capabilities_Get is failed\n");                         
                                        }
                                else
                                {
                                        //performance levels info
                                        ADLODNPerformanceLevels *odPerformanceLevels;

                                        int size = sizeof(ADLODNPerformanceLevels) + sizeof(ADLODNPerformanceLevel)* (overdriveCapabilities.iMaximumNumberOfPerformanceLevels - 1);
                                        void* performanceLevelsBuffer = new char[size];
                                        memset(performanceLevelsBuffer, 0, size);
                                        odPerformanceLevels = (ADLODNPerformanceLevels*)performanceLevelsBuffer;
                                        odPerformanceLevels->iSize = size;
                                        odPerformanceLevels->iMode = 0; //current
                                        odPerformanceLevels->iNumberOfPerformanceLevels = overdriveCapabilities.iMaximumNumberOfPerformanceLevels;
                                        
                                        //get GPU clocks
                                        if (ADL_OK != ADL2_OverdriveN_MemoryClocks_Get(context, lpAdapterInfo[ i ].iAdapterIndex, odPerformanceLevels))
                                        {
                                                PRINTF("ADL2_OverdriveN_GPUClocks_Get is failed\n");

                                        }
                                        ADLODNPerformanceLevels *odPerformanceLevels_default;
                                        void* performanceLevelsBuffer_default = new char[size];
                                        memset(performanceLevelsBuffer_default, 0, size);
                                        odPerformanceLevels_default = (ADLODNPerformanceLevels*)performanceLevelsBuffer_default;
                                        odPerformanceLevels_default->iSize = size;
                                        odPerformanceLevels_default->iMode = 1; //Defaults
                                        odPerformanceLevels_default->iNumberOfPerformanceLevels = overdriveCapabilities.iMaximumNumberOfPerformanceLevels;
                                        
                                        //get GPU clocks
                                        if (ADL_OK != ADL2_OverdriveN_MemoryClocks_Get(context, lpAdapterInfo[ i ].iAdapterIndex, odPerformanceLevels_default))
                                        {
                                                PRINTF("ADL2_OverdriveN_GPUClocks_Get is failed\n");

                                        }

                                        PRINTF("-------------------------------------\n");                                      
                                        PRINTF("ADL2_OverdriveN_MemoryClocks_Get Data\n");
                                        PRINTF("-------------------------------------\n");
                                        PRINTF("Number of Levels : %d\n" ,overdriveCapabilities.iMaximumNumberOfPerformanceLevels);
                                        //PRINTF("Minimum Range : %d, Maximum Range : %d, Step value: %d\n" ,overdriveCapabilities.sMemoryClockRange.iMin,overdriveCapabilities.sMemoryClockRange.iMax, overdriveCapabilities.sMemoryClockRange.iStep);
                                        //PRINTF("Voltage: Minimum Range : %d, Maximum Range : %d, Step value: %d\n" ,overdriveCapabilities.svddcRange.iMin,overdriveCapabilities.svddcRange.iMax, overdriveCapabilities.svddcRange.iStep);
                                        
                                        for (int i=0 ;i <overdriveCapabilities.iMaximumNumberOfPerformanceLevels;i++)
                                        {
                                                PRINTF("odPerformanceLevels->aLevels[%d].iClock : %d\n" , i, odPerformanceLevels->aLevels[i].iClock);
                                                PRINTF("MCLK Minimum Range : %d, Maximum Range : %d, Step value: %d\n" ,odPerformanceLevels_default->aLevels[i].iClock,odPerformanceLevels_default->aLevels[i].iClock + 5000, overdriveCapabilities.sMemoryClockRange.iStep);                           
                                                PRINTF("odPerformanceLevels->aLevels[%d].iEnabled : %d\n", i, odPerformanceLevels->aLevels[i].iEnabled);
                                                PRINTF("odPerformanceLevels->aLevels[%d].iVddc : %d\n", i, odPerformanceLevels->aLevels[i].iVddc);      
                                                PRINTF("Voltage: Minimum Range : %d, Maximum Range : %d, Step value: %d\n\n" ,overdriveCapabilities.svddcRange.iMin,overdriveCapabilities.svddcRange.iMax, overdriveCapabilities.svddcRange.iStep);
                                
                                        }       
                                        PRINTF("-------------------------------------\n");                                      
                                        
                                }
                                break;
                        }                       
                        }       
        }

        
        
        return 0;
}

int setODNMCLKParameters(int level, int feature, int value)
{
        int i, active = 0;;
        int iSupported,iEnabled,iVersion;
        
        
        // Obtain the number of adapters for the system
    if ( ADL_OK != ADL_Adapter_NumberOfAdapters_Get ( &iNumberAdapters ) )
        {
               PRINTF("Cannot get the number of adapters!\n");
                   return 0;
        }

    if ( 0 < iNumberAdapters )
    {
        lpAdapterInfo = (LPAdapterInfo)malloc ( sizeof (AdapterInfo) * iNumberAdapters );
        memset ( lpAdapterInfo,'\0', sizeof (AdapterInfo) * iNumberAdapters );

        // Get the AdapterInfo structure for all adapters in the system
        ADL_Adapter_AdapterInfo_Get (lpAdapterInfo, sizeof (AdapterInfo) * iNumberAdapters);
    }

        // Repeat for all available adapters in the system
    for ( i = 0; i < iNumberAdapters; i++ )
    {
                if (lpAdapterInfo[ i ].iBusNumber > -1)
                {
                        ADL2_Overdrive_Caps(context,lpAdapterInfo[ i ].iAdapterIndex, &iSupported, &iEnabled, &iVersion);
                        if (iVersion == 7)
                        {
                                ADLODNCapabilities overdriveCapabilities;
                                memset(&overdriveCapabilities, 0, sizeof(ADLODNCapabilities));
    
                                if (ADL_OK != ADL2_OverdriveN_Capabilities_Get(context,lpAdapterInfo[ i ].iAdapterIndex, &overdriveCapabilities))
                                {
                                        PRINTF("ADL2_OverdriveN_Capabilities_Get is failed\n");                         
                                }
                                else
                                {
                                        //performance levels info
                                        ADLODNPerformanceLevels *odPerformanceLevels;

                                        int size = sizeof(ADLODNPerformanceLevels) + sizeof(ADLODNPerformanceLevel)* (overdriveCapabilities.iMaximumNumberOfPerformanceLevels - 1);
                                        void* performanceLevelsBuffer = new char[size];
                                        memset(performanceLevelsBuffer, 0, size);
                                        odPerformanceLevels = (ADLODNPerformanceLevels*)performanceLevelsBuffer;
                                        odPerformanceLevels->iSize = size;
                                        odPerformanceLevels->iNumberOfPerformanceLevels = overdriveCapabilities.iMaximumNumberOfPerformanceLevels;
                                        //get GPU clocks
                                        if (ADL_OK != ADL2_OverdriveN_MemoryClocks_Get(context, lpAdapterInfo[ i ].iAdapterIndex, odPerformanceLevels))
                                        {
                                                PRINTF("ADL2_OverdriveN_MemoryClocks_Get is failed\n");

                                        }

                                        if (feature == 1)
                                        {
                                                if (!(overdriveCapabilities.sMemoryClockRange.iMin <= value && overdriveCapabilities.sMemoryClockRange.iMax >= value))
                                                {
                                                        PRINTF("Clock range should be in Min : %d, Max : %d, Step : %d\n" ,overdriveCapabilities.sMemoryClockRange.iMin,overdriveCapabilities.sMemoryClockRange.iMax, overdriveCapabilities.sMemoryClockRange.iStep);                   
                                                }
                                                else if (level > overdriveCapabilities.iMaximumNumberOfPerformanceLevels || level < 0)
                                                {
                                                        PRINTF("Performance level should be less than : %d\n" ,overdriveCapabilities.iMaximumNumberOfPerformanceLevels);                        
                                                }
                                                else if (odPerformanceLevels->aLevels[level].iEnabled == 0)
                                                {
                                                        PRINTF("Performance level (%d) is disabled\n" ,level);                  
                                                }
                                                else
                                                {
                                                        PRINTF ("***** Driver Values: Before Apply ******\n");
                                                        printODNMCLKParameters();
                                                        odPerformanceLevels->aLevels[level].iClock = value;                                                     
                                                        odPerformanceLevels->iMode = ADLODNControlType::ODNControlType_Manual;
                                                        
                                                        if (ADL_OK != ADL2_OverdriveN_MemoryClocks_Set(context,lpAdapterInfo[ i ].iAdapterIndex, odPerformanceLevels))
                                                        {
                                                                PRINTF("ADL2_OverdriveN_MemoryClocks_Set is failed\n");
                                                        }
                                                        else
                                                        {
                                                                PRINTF("ADL2_OverdriveN_MemoryClocks_Set is Success\n\n");
                                                                PRINTF ("****** Driver Values: After Apply ******\n");
                                                                printODNMCLKParameters();
                                                        }
                                                }
                                        }
                                        else if (feature == 2)
                                        {
                                                if (!(overdriveCapabilities.svddcRange.iMin <= value && overdriveCapabilities.svddcRange.iMax >= value))
                                                {
                                                        PRINTF("Clock range should be in Min : %d, Max : %d, Step : %d\n" ,overdriveCapabilities.svddcRange.iMin,overdriveCapabilities.svddcRange.iMax, overdriveCapabilities.svddcRange.iStep);                        
                                                }
                                                else if (level > overdriveCapabilities.iMaximumNumberOfPerformanceLevels || level < 0)
                                                {
                                                        PRINTF("Performance level should be less than : %d\n" ,overdriveCapabilities.iMaximumNumberOfPerformanceLevels);                        
                                                }
                                                else if (odPerformanceLevels->aLevels[level].iEnabled == 0)
                                                {
                                                        PRINTF("Performance level (%d) is disabled\n" ,level);                  
                                                }
                                                else
                                                {
                                                        PRINTF ("***** Driver Values: Before Apply ******\n");
                                                        printODNMCLKParameters();
                                                        odPerformanceLevels->aLevels[level].iVddc = value;                                                      
                                                        odPerformanceLevels->iMode = ADLODNControlType::ODNControlType_Manual;
                                                        
                                                        if (ADL_OK != ADL2_OverdriveN_MemoryClocks_Set(context,lpAdapterInfo[ i ].iAdapterIndex, odPerformanceLevels))
                                                        {
                                                                PRINTF("ADL2_OverdriveN_MemoryClocks_Set is failed\n");
                                                        }
                                                        else
                                                        {
                                                                PRINTF("ADL2_OverdriveN_MemoryClocks_Set is Success\n\n");
                                                                PRINTF ("****** Driver Values: After Apply ******\n");
                                                                printODNMCLKParameters();
                                                        }
                                                }                               
                                        }                                               
                                }
                                break;
                        }
                }                                       
        }

                
        return 0;
}


int printODNFANParameters()
{
        int i, active = 0;;
        int iSupported,iEnabled,iVersion;
                 
        // Repeat for all available adapters in the system
    for ( i = 0; i < iNumberAdapters; i++ )
    {
                if (lpAdapterInfo[ i ].iBusNumber > -1)
                {
                        ADL2_Overdrive_Caps(context,lpAdapterInfo[ i ].iAdapterIndex, &iSupported, &iEnabled, &iVersion);
                        if (iVersion == 7)
                        {
                                ADLODNCapabilities overdriveCapabilities;
                                memset(&overdriveCapabilities, 0, sizeof(ADLODNCapabilities));
    
                                if (ADL_OK != ADL2_OverdriveN_Capabilities_Get(context,lpAdapterInfo[ i ].iAdapterIndex, &overdriveCapabilities))
                                {
                                        PRINTF("ADL2_OverdriveN_Capabilities_Get is failed\n");                         
                                }
                                ADLODNFanControl odNFanControl;
                                memset(&odNFanControl, 0, sizeof(ADLODNFanControl));
                                
                                if (ADL_OK != ADL2_OverdriveN_FanControl_Get(context,lpAdapterInfo[ i ].iAdapterIndex, &odNFanControl))
                                {
                                        PRINTF("ADL2_OverdriveN_FanControl_Get is failed\n");
                                }
                                else
                                {
                                        PRINTF("-----------------------------------------\n");                                  
                                        PRINTF("ADL2_OverdriveN_FanControl_Get Data\n");
                                        PRINTF("-----------------------------------------\n");
                                        PRINTF("Min : %d, Max : %d, Step : %d\n" ,overdriveCapabilities.fanSpeed.iMin,overdriveCapabilities.fanSpeed.iMax, overdriveCapabilities.fanSpeed.iStep);                               
                                        PRINTF("odNFanControl.iFanControlMode : %d\n" , odNFanControl.iFanControlMode);
                                        PRINTF("odNFanControl.iMinFanLimit : %d\n" , odNFanControl.iMinFanLimit);                                       
                                        PRINTF("odNFanControl.iTargetFanSpeed : %d\n" , odNFanControl.iTargetFanSpeed);
                                        
                                        PRINTF ("-------- FAN (Min performance) ---------\n");
                                        PRINTF("Min : %d, Max : %d, Step : %d\n" ,overdriveCapabilities.minimumPerformanceClock.iMin,overdriveCapabilities.minimumPerformanceClock.iMax, overdriveCapabilities.minimumPerformanceClock.iStep);                          
                                        PRINTF("odNFanControl.iMinPerformanceClock : %d\n" , odNFanControl.iMinPerformanceClock);
                                        
                                        PRINTF ("--------- FAN (Target Temp) -----------\n");
                                        PRINTF("Min : %d, Max : %d, Step : %d\n" ,overdriveCapabilities.fanTemperature.iMin,overdriveCapabilities.fanTemperature.iMax, overdriveCapabilities.fanTemperature.iStep);                                                                     
                                        PRINTF("odNFanControl.iTargetTemperature : %d\n" , odNFanControl.iTargetTemperature);
                                        
                                        PRINTF("---------Fan Current Speed--------------\n");
                                        PRINTF("odNFanControl.iCurrentFanSpeed : %d\n" , odNFanControl.iCurrentFanSpeed);
                                        PRINTF("odNFanControl.iCurrentFanSpeedMode : %d\n" , odNFanControl.iCurrentFanSpeedMode);
                                        PRINTF("-----------------------------------------\n");                                  
                                        
                                }
                                break;
                        }                       
                }                                               
        }

        
        return 0;
}

int setODNFANParameters(int feature, int value)
{
        int  i, active = 0;;
        int iSupported,iEnabled,iVersion;
        

        // Repeat for all available adapters in the system
    for ( i = 0; i < iNumberAdapters; i++ )
    {
                if (lpAdapterInfo[ i ].iBusNumber > -1)
                {
                        ADL2_Overdrive_Caps(context,lpAdapterInfo[ i ].iAdapterIndex, &iSupported, &iEnabled, &iVersion);
                        if (iVersion == 7)
                        {
                                ADLODNCapabilities overdriveCapabilities;
                                memset(&overdriveCapabilities, 0, sizeof(ADLODNCapabilities));
    
                                if (ADL_OK != ADL2_OverdriveN_Capabilities_Get(context,lpAdapterInfo[ i ].iAdapterIndex, &overdriveCapabilities))
                                {
                                        PRINTF("ADL2_OverdriveN_Capabilities_Get is failed\n");                         
                                }
                                ADLODNFanControl odNFanControl;
                                memset(&odNFanControl, 0, sizeof(ADLODNFanControl));
                                
                                if (ADL_OK != ADL2_OverdriveN_FanControl_Get(context,lpAdapterInfo[ i ].iAdapterIndex, &odNFanControl))
                                {
                                        PRINTF("ADL2_OverdriveN_FanControl_Get is failed\n");
                                }
                                else
                                {
                                        if (feature == 1 || feature == 2)
                                        {
                                                if (!(overdriveCapabilities.fanSpeed.iMin <= value && overdriveCapabilities.fanSpeed.iMax >= value))
                                                {
                                                        PRINTF("Min & Target Fan speed range should be in Min : %d, Max : %d, Step : %d\n" ,overdriveCapabilities.fanSpeed.iMin,overdriveCapabilities.fanSpeed.iMax, overdriveCapabilities.fanSpeed.iStep);                                                                             
                                                }       
                                                else
                                                {
                                                        PRINTF ("***** Driver Values: Before Apply ******\n");
                                                        printODNFANParameters();
                                                        odNFanControl.iMode = ADLODNControlType::ODNControlType_Manual;
                                                        if (feature == 1) 
                                                                odNFanControl.iMinFanLimit = value;
                                                        else
                                                                odNFanControl.iTargetFanSpeed = value;

                                                        if (ADL_OK != ADL2_OverdriveN_FanControl_Set(context,lpAdapterInfo[ i ].iAdapterIndex, &odNFanControl))
                                                        {
                                                                PRINTF("ADL2_OverdriveN_FanControl_Set is failed\n");
                                                        }
                                                        else
                                                        {
                                                                PRINTF("ADL2_OverdriveN_FanControl_Set is Success\n\n");
                                                                PRINTF ("****** Driver Values: After Apply ******\n");
                                                                printODNFANParameters();
                                                        }                                                       
                                                }
                                        }
                                        else if (feature == 3)
                                        {
                                                if (!(overdriveCapabilities.minimumPerformanceClock.iMin <= value && overdriveCapabilities.minimumPerformanceClock.iMax >= value))
                                                {
                                                        PRINTF("Minimum performance range should be in Min : %d, Max : %d, Step : %d\n" ,overdriveCapabilities.minimumPerformanceClock.iMin,overdriveCapabilities.minimumPerformanceClock.iMax, overdriveCapabilities.minimumPerformanceClock.iStep);                   
                                                }       
                                                else
                                                {
                                                        PRINTF ("***** Driver Values: Before Apply ******\n");
                                                        printODNFANParameters();
                                                        odNFanControl.iMode = ADLODNControlType::ODNControlType_Manual;
                                                        odNFanControl.iMinPerformanceClock = value;
                                                        if (ADL_OK != ADL2_OverdriveN_FanControl_Set(context,lpAdapterInfo[ i ].iAdapterIndex, &odNFanControl))
                                                        {
                                                                PRINTF("ADL2_OverdriveN_FanControl_Set is failed\n");
                                                        }
                                                        else
                                                        {
                                                                PRINTF("ADL2_OverdriveN_FanControl_Set is Success\n\n");
                                                                PRINTF ("****** Driver Values: After Apply ******\n");
                                                                printODNFANParameters();
                                                        }
                                                }
                                        }       
                                        else if (feature == 4)
                                        {
                                                if (!(overdriveCapabilities.fanTemperature.iMin <= value && overdriveCapabilities.fanTemperature.iMax >= value))
                                                {
                                                        PRINTF("fanTemperature range should be in Min : %d, Max : %d, Step : %d\n" ,overdriveCapabilities.fanTemperature.iMin,overdriveCapabilities.fanTemperature.iMax, overdriveCapabilities.fanTemperature.iStep);                   
                                                }       
                                                else
                                                {
                                                        PRINTF ("***** Driver Values: Before Apply ******\n");
                                                        printODNFANParameters();                                                        
                                                        odNFanControl.iMode = ADLODNControlType::ODNControlType_Manual;
                                                        odNFanControl.iTargetTemperature = value;
                                                        if (ADL_OK != ADL2_OverdriveN_FanControl_Set(context,lpAdapterInfo[ i ].iAdapterIndex, &odNFanControl))
                                                        {
                                                                PRINTF("ADL2_OverdriveN_FanControl_Set is failed\n");
                                                        }
                                                        else
                                                        {
                                                                PRINTF("ADL2_OverdriveN_FanControl_Set is Success\n\n");
                                                                PRINTF ("****** Driver Values: After Apply ******\n");
                                                                printODNFANParameters();
                                                        }                                                       
                                                }
                                        }       
                                }
                                break;
                        }               
                }                                               
        }

        
        
        return 0;
}

int printODNTEMPParameters()
{
        
        int  i, active = 0;;
        int iSupported,iEnabled,iVersion;
        int ret = 0;
        // Repeat for all available adapters in the system
    for ( i = 0; i < iNumberAdapters; i++ )
    {
                if (lpAdapterInfo[ i ].iBusNumber > -1)
                {
                        ADL2_Overdrive_Caps(context,lpAdapterInfo[ i ].iAdapterIndex, &iSupported, &iEnabled, &iVersion);
                        if (iVersion == 7)
                        {
                                ADLODNCapabilities overdriveCapabilities;
                                memset(&overdriveCapabilities, 0, sizeof(ADLODNCapabilities));
    
                                if (ADL_OK != ADL2_OverdriveN_Capabilities_Get(context,lpAdapterInfo[ i ].iAdapterIndex, &overdriveCapabilities))
                                {
                                        PRINTF("ADL2_OverdriveN_Capabilities_Get is failed\n");                         
                                }

                                ADLODNPowerLimitSetting odNPowerControl;
                                memset(&odNPowerControl, 0, sizeof(ADLODNPowerLimitSetting));
                                
                                if (ADL_OK != ADL2_OverdriveN_PowerLimit_Get(context,lpAdapterInfo[ i ].iAdapterIndex, &odNPowerControl))
                                {
                                        PRINTF("ADL2_OverdriveN_PowerLimit_Get is failed\n");
                                }
                                else
                                {
                                        int temp;
                                        ADL2_OverdriveN_Temperature_Get(context,lpAdapterInfo[ i ].iAdapterIndex,1, &temp);
                                        PRINTF("-------------------------------------------------\n");                                  
                                        PRINTF("ADL2_OverdriveN_PowerLimit_Get Data\n");
                                        PRINTF("-------------------------------------------------\n");
                                        PRINTF("odNPowerControl.iMode : %d\n" , odNPowerControl.iMode);
                                        PRINTF("Current temperature : %d\n", temp);
                                        PRINTF ("------------------   POWER   --------------------\n");
                                        PRINTF("Min : %d, Max : %d, Step : %d\n" ,overdriveCapabilities.powerTuneTemperature.iMin,overdriveCapabilities.powerTuneTemperature.iMax, overdriveCapabilities.powerTuneTemperature.iStep);                                                                                                           
                                        PRINTF("odNPowerControl.iMaxOperatingTemperature : %d\n" , odNPowerControl.iMaxOperatingTemperature);
                                        PRINTF ("----------------- TDP LIMITS --------------------\n");
                                        PRINTF("Min : %d, Max : %d, Step : %d\n" ,overdriveCapabilities.power.iMin,overdriveCapabilities.power.iMax, overdriveCapabilities.power.iStep);                                                                                                                
                                        PRINTF("odNPowerControl.iTDPLimit : %d\n" , odNPowerControl.iTDPLimit);
                                        PRINTF("-------------------------------------------------\n");                                  
                                        
                                }
                                break;
                        }                       
                }
        }

        return ret;
}

int setODNTEMPParameters(int feature, int value)
{

        int  i, active = 0;;
        int iSupported,iEnabled,iVersion;       
        int ret = 0;

        // Repeat for all available adapters in the system
    for ( i = 0; i < iNumberAdapters; i++ )
    {
                if (lpAdapterInfo[ i ].iBusNumber > -1)
                {
                        ADL2_Overdrive_Caps(context,lpAdapterInfo[ i ].iAdapterIndex, &iSupported, &iEnabled, &iVersion);
                        if (iVersion == 7)
                        {
                                ADLODNCapabilities overdriveCapabilities;
                                memset(&overdriveCapabilities, 0, sizeof(ADLODNCapabilities));
    
                                if (ADL_OK != ADL2_OverdriveN_Capabilities_Get(context,lpAdapterInfo[ i ].iAdapterIndex, &overdriveCapabilities))
                                {
                                        PRINTF("ADL2_OverdriveN_Capabilities_Get is failed\n");                         
                                }
                                ADLODNPowerLimitSetting odNPowerControl;
                                memset(&odNPowerControl, 0, sizeof(ADLODNPowerLimitSetting));
                                
                                if (ADL_OK != ADL2_OverdriveN_PowerLimit_Get(context,lpAdapterInfo[ i ].iAdapterIndex, &odNPowerControl))
                                {
                                        PRINTF("ADL2_OverdriveN_PowerLimit_Get is failed\n");
                                }
                                else
                                {
                                        if (feature == 1)
                                        {
                                                if (!(overdriveCapabilities.powerTuneTemperature.iMin <= value && overdriveCapabilities.powerTuneTemperature.iMax >= value))
                                                {
                                                        PRINTF("Maximum OP Temp range should be in Min : %d, Max : %d, Step : %d\n" ,overdriveCapabilities.powerTuneTemperature.iMin,overdriveCapabilities.powerTuneTemperature.iMax, overdriveCapabilities.powerTuneTemperature.iStep);                        
                                                }       
                                                else
                                                {
                                                        PRINTF ("****** Driver Values: Before Apply ******\n");
                                                        printODNTEMPParameters();
                                                        odNPowerControl.iMode = ADLODNControlType::ODNControlType_Manual;
                                                        odNPowerControl.iMaxOperatingTemperature = value;
                                                        if (ADL_OK != ADL2_OverdriveN_PowerLimit_Set(context,lpAdapterInfo[ i ].iAdapterIndex, &odNPowerControl))
                                                        {
                                                                PRINTF("ADL2_OverdriveN_PowerLimit_Set is failed\n");
                                                        }
                                                        else
                                                        {
                                                                PRINTF("ADL2_OverdriveN_PowerLimit_Set is Success\n\n");
                                                                PRINTF ("****** Driver Values: After Apply ******\n");
                                                                printODNTEMPParameters();
                                                        }
                                                }
                                        }
                                        else if (feature == 2)
                                        {
                                                if (!(overdriveCapabilities.power.iMin <= value && overdriveCapabilities.power.iMax >= value))
                                                {
                                                        PRINTF("TDP Limit range should be in Min : %d, Max : %d, Step : %d\n" ,overdriveCapabilities.power.iMin,overdriveCapabilities.power.iMax, overdriveCapabilities.power.iStep);                   
                                                }       
                                                else
                                                {
                                                        PRINTF ("****** Driver Values: Before Apply ******\n");
                                                        printODNTEMPParameters();
                                                        odNPowerControl.iMode = ADLODNControlType::ODNControlType_Manual;
                                                        odNPowerControl.iTDPLimit = value;
                                                        if (ADL_OK != ADL2_OverdriveN_PowerLimit_Set(context,lpAdapterInfo[ i ].iAdapterIndex, &odNPowerControl))
                                                        {
                                                                PRINTF("ADL2_OverdriveN_PowerLimit_Set is failed\n");
                                                        }
                                                        else
                                                        {
                                                                PRINTF("ADL2_OverdriveN_PowerLimit_Set is Success\n\n");
                                                                PRINTF ("****** Driver Values: After Apply ******\n");
                                                                printODNTEMPParameters();
                                                        }
                                                }
                                        }                               
                                }
                                break;
                        }               
                }
        }
        return ret;
        
}

int printODNActivity()
{
        
        int   i, active = 0;;
        int iSupported,iEnabled,iVersion;
        int ret = 0;

        // Repeat for all available adapters in the system
    for ( i = 0; i < iNumberAdapters; i++ )
    {
                if (lpAdapterInfo[ i ].iBusNumber > -1)
                {
                        ADL2_Overdrive_Caps(context,lpAdapterInfo[ i ].iAdapterIndex, &iSupported, &iEnabled, &iVersion);
                        if (iVersion == 7)
                        {
                                ADLODNCapabilities overdriveCapabilities;
                                memset(&overdriveCapabilities, 0, sizeof(ADLODNCapabilities));
    
                                if (ADL_OK != ADL2_OverdriveN_Capabilities_Get(context,lpAdapterInfo[ i ].iAdapterIndex, &overdriveCapabilities))
                                {
                                        PRINTF("ADL2_OverdriveN_Capabilities_Get is failed\n");                         
                                }

                                ADLODNPerformanceStatus odNPerformanceStatus;
                                memset(&odNPerformanceStatus, 0, sizeof(ADLODNPerformanceStatus));
                                
                                if (ADL_OK != ADL2_OverdriveN_PerformanceStatus_Get(context,lpAdapterInfo[ i ].iAdapterIndex, &odNPerformanceStatus))
                                {
                                        PRINTF("ADL2_OverdriveN_PerformanceStatus_Get is failed\n");
                                }
                                else
                                {
                                        PRINTF("-------------------------------------------------\n");                                  
                                        PRINTF("ADL2_OverdriveN_PerformanceStatus_Get Data\n");
                                        PRINTF("-------------------------------------------------\n");
                                        PRINTF("odNPerformanceStatus.iCoreClock : %d\n" , odNPerformanceStatus.iCoreClock);
                                        PRINTF("odNPerformanceStatus.iCurrentBusLanes : %d\n" , odNPerformanceStatus.iCurrentBusLanes);
                                        PRINTF("odNPerformanceStatus.iCurrentBusSpeed : %d\n" , odNPerformanceStatus.iCurrentBusSpeed);
                                        PRINTF("odNPerformanceStatus.iCurrentCorePerformanceLevel : %d\n" , odNPerformanceStatus.iCurrentCorePerformanceLevel);
                                        PRINTF("odNPerformanceStatus.iCurrentDCEFPerformanceLevel : %d\n" , odNPerformanceStatus.iCurrentDCEFPerformanceLevel);
                                        PRINTF("odNPerformanceStatus.iCurrentGFXPerformanceLevel : %d\n" , odNPerformanceStatus.iCurrentGFXPerformanceLevel);
                                        PRINTF("odNPerformanceStatus.iCurrentMemoryPerformanceLevel : %d\n" , odNPerformanceStatus.iCurrentMemoryPerformanceLevel);
                                        PRINTF("odNPerformanceStatus.iDCEFClock : %d\n" , odNPerformanceStatus.iDCEFClock);
                                        PRINTF("odNPerformanceStatus.iGFXClock : %d\n" , odNPerformanceStatus.iGFXClock);
                                        PRINTF("odNPerformanceStatus.iGPUActivityPercent : %d\n" , odNPerformanceStatus.iGPUActivityPercent);
                                        PRINTF("odNPerformanceStatus.iMaximumBusLanes : %d\n" , odNPerformanceStatus.iMaximumBusLanes);
                                        PRINTF("odNPerformanceStatus.iMemoryClock : %d\n" , odNPerformanceStatus.iMemoryClock);
                                        PRINTF("odNPerformanceStatus.iUVDClock : %d\n" , odNPerformanceStatus.iUVDClock);
                                        PRINTF("odNPerformanceStatus.iUVDPerformanceLevel : %d\n" , odNPerformanceStatus.iUVDPerformanceLevel);
                                        PRINTF("odNPerformanceStatus.iVCEClock : %d\n" , odNPerformanceStatus.iVCEClock);
                                        PRINTF("odNPerformanceStatus.iVCEPerformanceLevel : %d\n" , odNPerformanceStatus.iVCEPerformanceLevel);
                                        PRINTF("odNPerformanceStatus.iVDDC : %d\n" , odNPerformanceStatus.iVDDC);
                                        PRINTF("odNPerformanceStatus.iVDDCI : %d\n" , odNPerformanceStatus.iVDDCI);                                     
                                        PRINTF("-------------------------------------------------\n");                                  
                                        
                                }
                                break;
                        }                       
                }
        }

        return ret;
}

int resetODSettings()
{
        
        int i, active = 0;;
        int iSupported,iEnabled,iVersion;
        int ret = 0;
        // Repeat for all available adapters in the system
    for ( i = 0; i < iNumberAdapters; i++ )
    {
                if (lpAdapterInfo[ i ].iBusNumber > -1)
                {
                        ADL2_Overdrive_Caps(context,lpAdapterInfo[ i ].iAdapterIndex, &iSupported, &iEnabled, &iVersion);
                        if (iVersion == 7)
                        {
                                ADLODNCapabilities overdriveCapabilities;
                                memset(&overdriveCapabilities, 0, sizeof(ADLODNCapabilities));
    
                                if (ADL_OK != ADL2_OverdriveN_Capabilities_Get(context,lpAdapterInfo[ i ].iAdapterIndex, &overdriveCapabilities))
                                {
                                        PRINTF("ADL2_OverdriveN_Capabilities_Get is failed\n");                         
                                }

                                //performance levels info
                                ADLODNPerformanceLevels *odPerformanceLevels;

                                int size = sizeof(ADLODNPerformanceLevels) + sizeof(ADLODNPerformanceLevel)* (overdriveCapabilities.iMaximumNumberOfPerformanceLevels - 1);
                                void* performanceLevelsBuffer = new char[size];
                                memset(performanceLevelsBuffer, 0, size);
                                odPerformanceLevels = (ADLODNPerformanceLevels*)performanceLevelsBuffer;
                                odPerformanceLevels->iSize = size;
                                odPerformanceLevels->iNumberOfPerformanceLevels = overdriveCapabilities.iMaximumNumberOfPerformanceLevels;
                                //GPU clocks reset
                                if (ADL_OK != ADL2_OverdriveN_SystemClocks_Get(context, lpAdapterInfo[ i ].iAdapterIndex, odPerformanceLevels))
                                {
                                        PRINTF("ADL2_OverdriveN_GPUClocks_Get is failed\n");
                                }
                                else
                                {
                                        odPerformanceLevels->iMode = ADLODNControlType::ODNControlType_Default;
                                        if (ADL_OK != ADL2_OverdriveN_SystemClocks_Set(context, lpAdapterInfo[ i ].iAdapterIndex, odPerformanceLevels))
                                        {
                                                PRINTF("ADL2_OverdriveN_SystemClocks_Set is failed\n");
                                        }
                                        printODNSCLKParameters();
                                }

                                //Mem clocks reset
                                if (ADL_OK != ADL2_OverdriveN_MemoryClocks_Get(context, lpAdapterInfo[ i ].iAdapterIndex, odPerformanceLevels))
                                {
                                        PRINTF("ADL2_OverdriveN_MemoryClocks_Get is failed\n");
                                }
                                else
                                {
                                        odPerformanceLevels->iMode = ADLODNControlType::ODNControlType_Default;
                                        if (ADL_OK != ADL2_OverdriveN_MemoryClocks_Set(context, lpAdapterInfo[ i ].iAdapterIndex, odPerformanceLevels))
                                        {
                                                PRINTF("ADL2_OverdriveN_MemoryClocks_Set is failed\n");
                                        }
                                        printODNMCLKParameters();
                                }

                                //Fan Reset
                                ADLODNFanControl odNFanControl;
                                memset(&odNFanControl, 0, sizeof(ADLODNFanControl));
                                
                                if (ADL_OK != ADL2_OverdriveN_FanControl_Get(context,lpAdapterInfo[ i ].iAdapterIndex, &odNFanControl))
                                {
                                        PRINTF("ADL2_OverdriveN_FanControl_Get is failed\n");
                                }
                                else
                                {
                                        odNFanControl.iMode = ADLODNControlType::ODNControlType_Auto;
                                        if (ADL_OK != ADL2_OverdriveN_FanControl_Set(context,lpAdapterInfo[ i ].iAdapterIndex, &odNFanControl))
                                        {
                                                PRINTF("ADL2_OverdriveN_FanControl_Set is failed\n");
                                        }
                                        printODNFANParameters();
                                }

                                //Temp Reset
                                ADLODNPowerLimitSetting odNPowerControl;
                                memset(&odNPowerControl, 0, sizeof(ADLODNPowerLimitSetting));
                                
                                if (ADL_OK != ADL2_OverdriveN_PowerLimit_Get(context,lpAdapterInfo[ i ].iAdapterIndex, &odNPowerControl))
                                {
                                        PRINTF("ADL2_OverdriveN_PowerLimit_Get is failed\n");
                                }
                                else
                                {
                                        odNPowerControl.iMode = ADLODNControlType::ODNControlType_Auto;
                                        if (ADL_OK != ADL2_OverdriveN_PowerLimit_Set(context,lpAdapterInfo[ i ].iAdapterIndex, &odNPowerControl))
                                        {
                                                PRINTF("ADL2_OverdriveN_PowerLimit_Set is failed\n");
                                        }
                                        printODNTEMPParameters();
                                }
                                break;
                        }               
                }
        }

        return ret;
}

int main(int argc, char* argv[])
{
//      Sleep(30000);

        if (initializeADL())
        {
                if (argc > 1)
                {        


                        // Obtain the number of adapters for the system
                        if (ADL_OK != ADL_Adapter_NumberOfAdapters_Get(&iNumberAdapters))
                        {
                                PRINTF("Cannot get the number of adapters!\n");
                                return 0;
                        }

                        if (0 < iNumberAdapters)
                        {
                                lpAdapterInfo = (LPAdapterInfo)malloc(sizeof (AdapterInfo)* iNumberAdapters);
                                memset(lpAdapterInfo, '\0', sizeof (AdapterInfo)* iNumberAdapters);

                                // Get the AdapterInfo structure for all adapters in the system
                                ADL_Adapter_AdapterInfo_Get(lpAdapterInfo, sizeof (AdapterInfo)* iNumberAdapters);
                        }

                        switch (*(argv[1]))
                        {
                                case 'g':
                                        if (argc == 2)
                                                printODNSCLKParameters();
                                        else if (argc == 5)
                                                setODNSCLKParameters(atoi(argv[2]), atoi(argv[3]), atoi(argv[4]));
                                        else 
                                                printf ("signature of SClock Set (ODNEXT.exe g X Y Z); X - Level, Y - (1: Clock, 2: Voltage), Z - Expected value should be in min max range");
                                        break;                          
                                case 'm':
                                        if (argc == 2)
                                                printODNMCLKParameters();
                                        else if (argc == 5)
                                                setODNMCLKParameters(atoi(argv[2]), atoi(argv[3]), atoi(argv[4]));
                                        else 
                                                printf ("signature of Memory Set (ODNEXT.exe m X Y Z); X - Level, Y - (1: Clock, 2: Voltage), Z - Expected value should be in min max range");
                                        break;
                                        break;
                                case 'f':
                                        if (argc == 2)
                                                printODNFANParameters();
                                        else if (argc == 4)
                                                setODNFANParameters(atoi(argv[2]), atoi(argv[3]));
                                        else 
                                                printf ("signature of Fan Set (ODNEXT.exe f X Y); X - (1: Minimum Fan Speed, 2: Target Fan Speed, 3: Minimum Performance, 4: Target Temp), Y - Expected value should be in min max range");
                                        break;
                                case 't':
                                        if (argc == 2)
                                                printODNTEMPParameters();
                                        else if (argc == 4)
                                                setODNTEMPParameters(atoi(argv[2]), atoi(argv[3]));
                                        else 
                                                printf ("signature of Tempareture Set (ODNEXT.exe t X Y); X - (1: Maximum OP Temperature, 2: TDP LIMIT), Y - Expected value should be in min max range");
                                        break;
                                case 'a':
                                        printODNActivity();
                                        break;
                                case 'r':
                                        resetODSettings();
                                        break;                          
                                default:
                                        printf ("Available command line parameters: f- Fan, g-GPU clocks, t-temp, m-Memory Clocks, a- Activity, r-reset \n ");
                                        printf ("SClocks Get :  ODNEXT.exe g\n");
                                        printf ("SClocks Set :  ODNEXT.exe g X Y Z; X - Level, Y - (1: Clock, 2: Voltage), Z - Expected value should be in min max range \n");
                                        printf ("MClocks Get :  ODNEXT.exe m\n");
                                        printf ("MClocks Set :  ODNEXT.exe m X Y Z; X - Level, Y - (1: Clock, 2: Voltage), Z - Expected value should be in min max range\n");
                                        printf ("FAN Get :  ODNEXT.exe f\n");
                                        printf ("FAN Set :  ODNEXT.exe f X Y; X - (1: Minimum Fan Speed, 2: Target Fan Speed, 3: Minimum Performance, 4: Target Temp), Y - Expected value should be in min max range\n");
                                        printf ("Temp Get :  ODNEXT.exe t\n");
                                        printf ("Temp Set :  ODNEXT.exe t X Y ; X - (1: Maximum OP Temperature, 2: TDP LIMIT), Y - Expected value should be in min max range\n");
                                        printf ("Activity Get :  ODNEXT.exe a\n");
                                        printf ("OD Reset :  ODNEXT.exe r\n");
                                        break;
                        }



                }
                else
                {
                                        printf ("Available command line parameters: f- Fan, g-GPU clocks, t-temp, m-Memory Clocks, a- Activity, r-reset \n");
                                        printf ("SClocks Get :  ODNEXT.exe g\n");
                                        printf ("SClocks Set :  ODNEXT.exe g X Y Z; X - Level, Y - (1: Clock, 2: Voltage), Z - Expected value should be in min max range \n");
                                        printf ("MClocks Get :  ODNEXT.exe m\n");
                                        printf ("MClocks Set :  ODNEXT.exe m X Y Z; X - Level, Y - (1: Clock, 2: Voltage), Z - Expected value should be in min max range\n");
                                        printf ("FAN Get :  ODNEXT.exe f\n");
                                        printf ("FAN Set :  ODNEXT.exe f X Y; X - (1: Minimum Fan Speed, 2: Target Fan Speed, 3: Minimum Performance, 4: Target Temp), Y - Expected value should be in min max range\n");
                                        printf ("Temp Get :  ODNEXT.exe t\n");
                                        printf ("Temp Set :  ODNEXT.exe t X Y ; X - (1: Maximum OP Temperature, 2: TDP LIMIT), Y - Expected value should be in min max range\n");
                                        printf ("Activity Get :  ODNEXT.exe a\n");
                                        printf ("OD Reset :  ODNEXT.exe r\n");
                }


                ADL_Main_Memory_Free((void**)&lpAdapterInfo);

                deinitializeADL();
        }


        return 0;
}

Copyright © 2009-2016 Advanced Micro Devices, Inc. All rights reserved.