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_CAPABILITIESX2_GET)        (ADL_CONTEXT_HANDLE, int, ADLODNCapabilitiesX2*);
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*);
typedef int(*ADL2_OVERDRIVEN_SYSTEMCLOCKSX2_GET)        (ADL_CONTEXT_HANDLE, int, ADLODNPerformanceLevelsX2*);
typedef int(*ADL2_OVERDRIVEN_SYSTEMCLOCKSX2_SET)        (ADL_CONTEXT_HANDLE, int, ADLODNPerformanceLevelsX2*);
typedef int(*ADL2_OVERDRIVEN_MEMORYCLOCKSX2_GET)        (ADL_CONTEXT_HANDLE, int, ADLODNPerformanceLevelsX2*);
typedef int(*ADL2_OVERDRIVEN_MEMORYCLOCKSX2_SET)        (ADL_CONTEXT_HANDLE, int, ADLODNPerformanceLevelsX2*);

typedef int(*ADL2_OVERDRIVEN_MEMORYTIMINGLEVEL_GET) (ADL_CONTEXT_HANDLE context, int iAdapterIndex, int *lpSupport, int *lpCurrentValue, int *lpDefaultValue, int *lpNumberLevels, int **lppLevelList);
typedef int(*ADL2_OVERDRIVEN_MEMORYTIMINGLEVEL_SET) (ADL_CONTEXT_HANDLE context, int iAdapterIndex, int currentValue);
typedef int(*ADL2_OVERDRIVEN_ZERORPMFAN_GET) (ADL_CONTEXT_HANDLE context, int iAdapterIndex, int *lpSupport, int *lpCurrentValue, int *lpDefaultValue);
typedef int(*ADL2_OVERDRIVEN_ZERORPMFAN_SET) (ADL_CONTEXT_HANDLE context, int iAdapterIndex, int currentValue);

typedef int(*ADL2_OVERDRIVEN_SETTINGSEXT_GET) (ADL_CONTEXT_HANDLE context, int iAdapterIndex, int* lpOverdriveNExtCapabilities, int *lpNumberOfODNExtFeatures, ADLODNExtSingleInitSetting** lppInitSettingList, int** lppCurrentSettingList);
typedef int(*ADL2_OVERDRIVEN_SETTINGSEXT_SET) (ADL_CONTEXT_HANDLE context, int iAdapterIndex, int iNumberOfODNExtFeatures, int* itemValueValidList, int* lpItemValueList);

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_CAPABILITIESX2_GET ADL2_OverdriveN_CapabilitiesX2_Get = NULL;
ADL2_OVERDRIVEN_SYSTEMCLOCKSX2_GET ADL2_OverdriveN_SystemClocksX2_Get = NULL;
ADL2_OVERDRIVEN_SYSTEMCLOCKSX2_SET ADL2_OverdriveN_SystemClocksX2_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_MEMORYCLOCKSX2_GET ADL2_OverdriveN_MemoryClocksX2_Get = NULL;
ADL2_OVERDRIVEN_MEMORYCLOCKSX2_SET ADL2_OverdriveN_MemoryClocksX2_Set = NULL;
ADL2_OVERDRIVE_CAPS ADL2_Overdrive_Caps = NULL;
ADL2_OVERDRIVEN_TEMPERATURE_GET ADL2_OverdriveN_Temperature_Get = NULL;

ADL2_OVERDRIVEN_MEMORYTIMINGLEVEL_GET ADL2_OverdriveN_MemoryTimingLevel_Get = NULL;
ADL2_OVERDRIVEN_MEMORYTIMINGLEVEL_SET ADL2_OverdriveN_MemoryTimingLevel_Set = NULL;
ADL2_OVERDRIVEN_ZERORPMFAN_GET ADL2_OverdriveN_ZeroRPMFan_Get = NULL;
ADL2_OVERDRIVEN_ZERORPMFAN_SET ADL2_OverdriveN_ZeroRPMFan_Set = NULL;

ADL2_OVERDRIVEN_SETTINGSEXT_GET ADL2_OverdriveN_SettingsExt_Get = NULL;
ADL2_OVERDRIVEN_SETTINGSEXT_SET ADL2_OverdriveN_SettingsExt_Set = 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_CapabilitiesX2_Get = (ADL2_OVERDRIVEN_CAPABILITIESX2_GET)GetProcAddress(hDLL, "ADL2_OverdriveN_CapabilitiesX2_Get");
    ADL2_OverdriveN_SystemClocksX2_Get = (ADL2_OVERDRIVEN_SYSTEMCLOCKSX2_GET)GetProcAddress(hDLL, "ADL2_OverdriveN_SystemClocksX2_Get");
    ADL2_OverdriveN_SystemClocksX2_Set = (ADL2_OVERDRIVEN_SYSTEMCLOCKSX2_SET)GetProcAddress(hDLL, "ADL2_OverdriveN_SystemClocksX2_Set");
    ADL2_OverdriveN_MemoryClocksX2_Get = (ADL2_OVERDRIVEN_MEMORYCLOCKSX2_GET)GetProcAddress(hDLL, "ADL2_OverdriveN_MemoryClocksX2_Get");
    ADL2_OverdriveN_MemoryClocksX2_Set = (ADL2_OVERDRIVEN_MEMORYCLOCKSX2_SET)GetProcAddress(hDLL, "ADL2_OverdriveN_MemoryClocksX2_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");

    ADL2_OverdriveN_MemoryTimingLevel_Get = (ADL2_OVERDRIVEN_MEMORYTIMINGLEVEL_GET)GetProcAddress(hDLL, "ADL2_OverdriveN_MemoryTimingLevel_Get");
    ADL2_OverdriveN_MemoryTimingLevel_Set = (ADL2_OVERDRIVEN_MEMORYTIMINGLEVEL_SET)GetProcAddress(hDLL, "ADL2_OverdriveN_MemoryTimingLevel_Set");
    ADL2_OverdriveN_ZeroRPMFan_Get = (ADL2_OVERDRIVEN_ZERORPMFAN_GET)GetProcAddress(hDLL, "ADL2_OverdriveN_ZeroRPMFan_Get");
    ADL2_OverdriveN_ZeroRPMFan_Set = (ADL2_OVERDRIVEN_ZERORPMFAN_SET)GetProcAddress(hDLL, "ADL2_OverdriveN_ZeroRPMFan_Set");

    ADL2_OverdriveN_SettingsExt_Get = (ADL2_OVERDRIVEN_SETTINGSEXT_GET)GetProcAddress(hDLL, "ADL2_OverdriveN_SettingsExt_Get");
    ADL2_OverdriveN_SettingsExt_Set = (ADL2_OVERDRIVEN_SETTINGSEXT_SET)GetProcAddress(hDLL, "ADL2_OverdriveN_SettingsExt_Set");

    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_CapabilitiesX2_Get ||
        NULL == ADL2_OverdriveN_SystemClocksX2_Get ||
        NULL == ADL2_OverdriveN_SystemClocksX2_Set ||
        NULL == ADL2_OverdriveN_MemoryClocksX2_Get ||
        NULL == ADL2_OverdriveN_MemoryClocksX2_Set ||
        NULL == ADL2_OverdriveN_PerformanceStatus_Get ||
        NULL == ADL2_OverdriveN_FanControl_Get ||
        NULL == ADL2_OverdriveN_FanControl_Set ||
        NULL == ADL2_Overdrive_Caps ||
        NULL == ADL2_OverdriveN_MemoryTimingLevel_Get ||
        NULL == ADL2_OverdriveN_MemoryTimingLevel_Set ||
        NULL == ADL2_OverdriveN_ZeroRPMFan_Get ||
        NULL == ADL2_OverdriveN_ZeroRPMFan_Set ||
        NULL == ADL2_OverdriveN_SettingsExt_Get ||
        NULL == ADL2_OverdriveN_SettingsExt_Set
        )
    {
        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)
            {
                ADLODNCapabilitiesX2 overdriveCapabilities;
                memset(&overdriveCapabilities, 0, sizeof(ADLODNCapabilitiesX2));

                if (ADL_OK != ADL2_OverdriveN_CapabilitiesX2_Get(context, lpAdapterInfo[i].iAdapterIndex, &overdriveCapabilities))
                {
                    PRINTF("ADL2_OverdriveN_CapabilitiesX2_Get is failed\n");
                }
                else
                {
                    //performance levels info
                    ADLODNPerformanceLevelsX2 *odPerformanceLevels;

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

                    }

                    PRINTF("--------------------------------------------\n");
                    PRINTF(" ADL2_OverdriveN_SystemClocksX2_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].Clock Value : %d\n", i, odPerformanceLevels->aLevels[i].iClock);
                        PRINTF("odPerformanceLevels->aLevels[%d].Clock Editable : %d\n", i, (odPerformanceLevels->aLevels[i].iControl &  ADLODNDPMMaskType::ADL_ODN_DPM_CLOCK) == ADLODNDPMMaskType::ADL_ODN_DPM_CLOCK);
                        PRINTF("odPerformanceLevels->aLevels[%d].VDDC Value : %d\n", i, odPerformanceLevels->aLevels[i].iVddc);
                        PRINTF("odPerformanceLevels->aLevels[%d].VDDC Editable : %d\n", i, (odPerformanceLevels->aLevels[i].iControl &  ADLODNDPMMaskType::ADL_ODN_DPM_VDDC) == ADLODNDPMMaskType::ADL_ODN_DPM_VDDC);
                        PRINTF("odPerformanceLevels->aLevels[%d].DPM State Value : %d\n", i, odPerformanceLevels->aLevels[i].iEnabled);
                        PRINTF("odPerformanceLevels->aLevels[%d].DPM State Editable : %d\n\n", i, ((odPerformanceLevels->aLevels[i].iControl &  ADLODNDPMMaskType::ADL_ODN_DPM_MASK) == ADLODNDPMMaskType::ADL_ODN_DPM_MASK) && ((overdriveCapabilities.iFlags & ADL_ODN_MCLK_DPM_MASK_ENABLE) == ADL_ODN_MCLK_DPM_MASK_ENABLE));
                    }
                    PRINTF("---------------------------------------------\n");
                    if (NULL != performanceLevelsBuffer)
                        delete[] performanceLevelsBuffer;
                }
                break;
            }
        }
    }



    return 0;
}

int setODNSCLKParameters(int level, 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)
            {
                ADLODNCapabilitiesX2 overdriveCapabilities;
                memset(&overdriveCapabilities, 0, sizeof(ADLODNCapabilitiesX2));

                if (ADL_OK != ADL2_OverdriveN_CapabilitiesX2_Get(context, lpAdapterInfo[i].iAdapterIndex, &overdriveCapabilities))
                {
                    PRINTF("ADL2_OverdriveN_CapabilitiesX2_Get is failed\n");
                }
                else
                {
                    //performance levels info
                    ADLODNPerformanceLevelsX2 *odPerformanceLevels;

                    int size = sizeof(ADLODNPerformanceLevelsX2) + sizeof(ADLODNPerformanceLevelX2)* (overdriveCapabilities.iMaximumNumberOfPerformanceLevels - 1);
                    void* performanceLevelsBuffer = new char[size];
                    memset(performanceLevelsBuffer, 0, size);
                    odPerformanceLevels = (ADLODNPerformanceLevelsX2*)performanceLevelsBuffer;
                    odPerformanceLevels->iSize = size;
                    odPerformanceLevels->iNumberOfPerformanceLevels = overdriveCapabilities.iMaximumNumberOfPerformanceLevels;
                    //get GPU clocks
                    if (ADL_OK != ADL2_OverdriveN_SystemClocksX2_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].iControl &  ADLODNDPMMaskType::ADL_ODN_DPM_CLOCK) == ADLODNDPMMaskType::ADL_ODN_DPM_CLOCK))
                        {
                            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;

                            //Fill iEnabled values properly.
                            for (int i = 0; i < overdriveCapabilities.iMaximumNumberOfPerformanceLevels; i++)
                            {
                                odPerformanceLevels->aLevels[i].iEnabled = odPerformanceLevels->aLevels[i].iEnabled > 0 ? 1 : 0;
                            }


                            if (ADL_OK != ADL2_OverdriveN_SystemClocksX2_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].iControl &  ADLODNDPMMaskType::ADL_ODN_DPM_VDDC) == ADLODNDPMMaskType::ADL_ODN_DPM_VDDC))
                        {
                            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;

                            //Fill iEnabled values properly.
                            for (int i = 0; i < overdriveCapabilities.iMaximumNumberOfPerformanceLevels; i++)
                            {
                                odPerformanceLevels->aLevels[i].iEnabled = odPerformanceLevels->aLevels[i].iEnabled > 0 ? 1 : 0;
                            }

                            if (ADL_OK != ADL2_OverdriveN_SystemClocksX2_Set(context, lpAdapterInfo[i].iAdapterIndex, odPerformanceLevels))
                            {
                                PRINTF("ADL2_OverdriveN_SystemClocksX2_Set is failed\n");
                            }
                            else
                            {
                                PRINTF("ADL2_OverdriveN_SystemClocksX2_Set is Success\n\n");
                                PRINTF("****** Driver Values: After Apply ******\n");
                                printODNSCLKParameters();
                            }
                        }
                    }
                    else if (feature == 3)
                    {
                        //Value parameter is reused as upper limit. level parameter treated as lower limit
                        if ((level > overdriveCapabilities.iMaximumNumberOfPerformanceLevels || level < 0) &&
                            (value > overdriveCapabilities.iMaximumNumberOfPerformanceLevels || value < 0))
                        {
                            PRINTF("Performance level should be less than : %d\n", overdriveCapabilities.iMaximumNumberOfPerformanceLevels);
                        }
                        else if (((odPerformanceLevels->aLevels[level].iControl &  ADLODNDPMMaskType::ADL_ODN_DPM_MASK) == ADLODNDPMMaskType::ADL_ODN_DPM_MASK) && ((overdriveCapabilities.iFlags & ADL_ODN_MCLK_DPM_MASK_ENABLE) == ADL_ODN_MCLK_DPM_MASK_ENABLE))
                        {
                            PRINTF("***** Driver Values: Before Apply ******\n");
                            printODNSCLKParameters();
                            //Fill iEnabled values properly.
                            for (int i = 0; i < overdriveCapabilities.iMaximumNumberOfPerformanceLevels; i++)
                            {
                                odPerformanceLevels->aLevels[i].iEnabled = i >= level && i <= value ? 1 : 0;
                            }
                            odPerformanceLevels->iMode = ADLODNControlType::ODNControlType_Manual;



                            if (ADL_OK != ADL2_OverdriveN_SystemClocksX2_Set(context, lpAdapterInfo[i].iAdapterIndex, odPerformanceLevels))
                            {
                                PRINTF("ADL2_OverdriveN_SystemClocksX2_Set is failed\n");
                            }
                            else
                            {
                                PRINTF("ADL2_OverdriveN_SystemClocksX2_Set is Success\n\n");
                                PRINTF("****** Driver Values: After Apply ******\n");
                                printODNSCLKParameters();
                            }
                        }
                        else
                        {
                            PRINTF("Performance level is not editable.\n");
                        }
                    }
                    if (NULL != performanceLevelsBuffer)
                        delete[] performanceLevelsBuffer;
                }
                break;
            }
        }
    }



    return 0;
}

int printODNMCLKParameters()
{
    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)
            {
                ADLODNCapabilitiesX2 overdriveCapabilities;
                memset(&overdriveCapabilities, 0, sizeof(ADLODNCapabilitiesX2));

                if (ADL_OK != ADL2_OverdriveN_CapabilitiesX2_Get(context, lpAdapterInfo[i].iAdapterIndex, &overdriveCapabilities))
                {
                    PRINTF("ADL2_OverdriveN_CapabilitiesX2_Get is failed\n");
                }
                else
                {
                    //performance levels info
                    ADLODNPerformanceLevelsX2 *odPerformanceLevels;

                    int size = sizeof(ADLODNPerformanceLevelsX2) + sizeof(ADLODNPerformanceLevelX2)* (overdriveCapabilities.iMaximumNumberOfPerformanceLevels - 1);
                    void* performanceLevelsBuffer = new char[size];
                    memset(performanceLevelsBuffer, 0, size);
                    odPerformanceLevels = (ADLODNPerformanceLevelsX2*)performanceLevelsBuffer;
                    odPerformanceLevels->iSize = size;
                    odPerformanceLevels->iMode = 0; //current
                    odPerformanceLevels->iNumberOfPerformanceLevels = overdriveCapabilities.iMaximumNumberOfPerformanceLevels;

                    //get GPU clocks
                    if (ADL_OK != ADL2_OverdriveN_MemoryClocksX2_Get(context, lpAdapterInfo[i].iAdapterIndex, odPerformanceLevels))
                    {
                        PRINTF("ADL2_OverdriveN_MemoryClocksX2_Get is failed\n");

                    }
                    ADLODNPerformanceLevelsX2 *odPerformanceLevels_default;
                    void* performanceLevelsBuffer_default = new char[size];
                    memset(performanceLevelsBuffer_default, 0, size);
                    odPerformanceLevels_default = (ADLODNPerformanceLevelsX2*)performanceLevelsBuffer_default;
                    odPerformanceLevels_default->iSize = size;
                    odPerformanceLevels_default->iMode = 1; //Defaults
                    odPerformanceLevels_default->iNumberOfPerformanceLevels = overdriveCapabilities.iMaximumNumberOfPerformanceLevels;

                    //get GPU clocks
                    if (ADL_OK != ADL2_OverdriveN_MemoryClocksX2_Get(context, lpAdapterInfo[i].iAdapterIndex, odPerformanceLevels_default))
                    {
                        PRINTF("ADL2_OverdriveN_MemoryClocksX2_Get is failed\n");

                    }

                    PRINTF("-------------------------------------\n");
                    PRINTF("ADL2_OverdriveN_MemoryClocksX2_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("MCLK Minimum Range : %d, Maximum Range : %d, Step value: %d\n",
                            ((overdriveCapabilities.iFlags & ADLODNFeatureControl::ADL_ODN_MCLK_UNDERCLOCK_ENABLE) == ADLODNFeatureControl::ADL_ODN_MCLK_UNDERCLOCK_ENABLE) ? overdriveCapabilities.sMemoryClockRange.iMin : odPerformanceLevels_default->aLevels[i].iClock, overdriveCapabilities.sMemoryClockRange.iMax, overdriveCapabilities.sMemoryClockRange.iStep);
                        PRINTF("odPerformanceLevels->aLevels[%d].Clock Value : %d\n", i, odPerformanceLevels->aLevels[i].iClock);
                        PRINTF("odPerformanceLevels->aLevels[%d].Clock Editable : %d\n", i, (odPerformanceLevels->aLevels[i].iControl &  ADLODNDPMMaskType::ADL_ODN_DPM_CLOCK) == ADLODNDPMMaskType::ADL_ODN_DPM_CLOCK);

                        PRINTF("Voltage: Minimum Range : %d, Maximum Range : %d, Step value: %d\n", overdriveCapabilities.svddcRange.iMin, overdriveCapabilities.svddcRange.iMax, overdriveCapabilities.svddcRange.iStep);
                        PRINTF("odPerformanceLevels->aLevels[%d].VDDC Value : %d\n", i, odPerformanceLevels->aLevels[i].iVddc);
                        PRINTF("odPerformanceLevels->aLevels[%d].VDDC Editable : %d\n", i, (odPerformanceLevels->aLevels[i].iControl &  ADLODNDPMMaskType::ADL_ODN_DPM_VDDC) == ADLODNDPMMaskType::ADL_ODN_DPM_VDDC);

                        PRINTF("odPerformanceLevels->aLevels[%d].DPM State Value : %d\n", i, odPerformanceLevels->aLevels[i].iEnabled);
                        PRINTF("odPerformanceLevels->aLevels[%d].DPM State Editable : %d\n\n", i, ((odPerformanceLevels->aLevels[i].iControl &  ADLODNDPMMaskType::ADL_ODN_DPM_MASK) == ADLODNDPMMaskType::ADL_ODN_DPM_MASK) && ((overdriveCapabilities.iFlags & ADL_ODN_MCLK_DPM_MASK_ENABLE) == ADL_ODN_MCLK_DPM_MASK_ENABLE));

                    }
                    PRINTF("-------------------------------------\n");
                    if (NULL != performanceLevelsBuffer)
                        delete[] performanceLevelsBuffer;
                    if (NULL != performanceLevelsBuffer_default)
                        delete[] performanceLevelsBuffer_default;
                }
                break;
            }
        }
    }



    return 0;
}

int setODNMCLKParameters(int level, 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)
            {
                ADLODNCapabilitiesX2 overdriveCapabilities;
                memset(&overdriveCapabilities, 0, sizeof(ADLODNCapabilitiesX2));

                if (ADL_OK != ADL2_OverdriveN_CapabilitiesX2_Get(context, lpAdapterInfo[i].iAdapterIndex, &overdriveCapabilities))
                {
                    PRINTF("ADL2_OverdriveN_CapabilitiesX2_Get is failed\n");
                }
                else
                {
                    //performance levels info
                    ADLODNPerformanceLevelsX2 *odPerformanceLevels;

                    int size = sizeof(ADLODNPerformanceLevelsX2) + sizeof(ADLODNPerformanceLevelX2)* (overdriveCapabilities.iMaximumNumberOfPerformanceLevels - 1);
                    void* performanceLevelsBuffer = new char[size];
                    memset(performanceLevelsBuffer, 0, size);
                    odPerformanceLevels = (ADLODNPerformanceLevelsX2*)performanceLevelsBuffer;
                    odPerformanceLevels->iSize = size;
                    odPerformanceLevels->iNumberOfPerformanceLevels = overdriveCapabilities.iMaximumNumberOfPerformanceLevels;
                    //get GPU clocks
                    if (ADL_OK != ADL2_OverdriveN_MemoryClocksX2_Get(context, lpAdapterInfo[i].iAdapterIndex, odPerformanceLevels))
                    {
                        PRINTF("ADL2_OverdriveN_MemoryClocksX2_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].iControl &  ADLODNDPMMaskType::ADL_ODN_DPM_CLOCK) == ADLODNDPMMaskType::ADL_ODN_DPM_CLOCK))
                        {
                            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;
                            //Fill iEnabled values properly.
                            for (int i = 0; i < overdriveCapabilities.iMaximumNumberOfPerformanceLevels; i++)
                            {
                                odPerformanceLevels->aLevels[i].iEnabled = odPerformanceLevels->aLevels[i].iEnabled > 0 ? 1 : 0;
                            }
                            if (ADL_OK != ADL2_OverdriveN_MemoryClocksX2_Set(context, lpAdapterInfo[i].iAdapterIndex, odPerformanceLevels))
                            {
                                PRINTF("ADL2_OverdriveN_MemoryClocksX2_Set is failed\n");
                            }
                            else
                            {
                                PRINTF("ADL2_OverdriveN_MemoryClocksX2_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].iControl &  ADLODNDPMMaskType::ADL_ODN_DPM_VDDC) == ADLODNDPMMaskType::ADL_ODN_DPM_VDDC))
                        {
                            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;
                            //Fill iEnabled values properly.
                            for (int i = 0; i < overdriveCapabilities.iMaximumNumberOfPerformanceLevels; i++)
                            {
                                odPerformanceLevels->aLevels[i].iEnabled = odPerformanceLevels->aLevels[i].iEnabled > 0 ? 1 : 0;
                            }
                            if (ADL_OK != ADL2_OverdriveN_MemoryClocksX2_Set(context, lpAdapterInfo[i].iAdapterIndex, odPerformanceLevels))
                            {
                                PRINTF("ADL2_OverdriveN_MemoryClocksX2_Set is failed\n");
                            }
                            else
                            {
                                PRINTF("ADL2_OverdriveN_MemoryClocksX2_Set is Success\n\n");
                                PRINTF("****** Driver Values: After Apply ******\n");
                                printODNMCLKParameters();
                            }
                        }
                    }
                    else if (feature == 3)
                    {
                        //Value parameter is reused as upper limit. level parameter treated as lower limit
                        if ((level > overdriveCapabilities.iMaximumNumberOfPerformanceLevels || level < 0) &&
                            (value > overdriveCapabilities.iMaximumNumberOfPerformanceLevels || value < 0))
                        {
                            PRINTF("Performance level should be less than : %d\n", overdriveCapabilities.iMaximumNumberOfPerformanceLevels);
                        }
                        else if (((odPerformanceLevels->aLevels[level].iControl &  ADLODNDPMMaskType::ADL_ODN_DPM_MASK) == ADLODNDPMMaskType::ADL_ODN_DPM_MASK) && ((overdriveCapabilities.iFlags & ADL_ODN_MCLK_DPM_MASK_ENABLE) == ADL_ODN_MCLK_DPM_MASK_ENABLE))
                        {
                            PRINTF("***** Driver Values: Before Apply ******\n");
                            printODNSCLKParameters();
                            for (int i = 0; i < overdriveCapabilities.iMaximumNumberOfPerformanceLevels; i++)
                            {
                                odPerformanceLevels->aLevels[i].iEnabled = i >= level && i <= value ? 1 : 0;
                            }
                            odPerformanceLevels->iMode = ADLODNControlType::ODNControlType_Manual;

                            if (ADL_OK != ADL2_OverdriveN_MemoryClocksX2_Set(context, lpAdapterInfo[i].iAdapterIndex, odPerformanceLevels))
                            {
                                PRINTF("ADL2_OverdriveN_MemoryClocksX2_Set is failed\n");
                            }
                            else
                            {
                                PRINTF("ADL2_OverdriveN_MemoryClocksX2_Set is Success\n\n");
                                PRINTF("****** Driver Values: After Apply ******\n");
                                printODNMCLKParameters();
                            }
                        }
                        else
                        {
                            PRINTF("Performance level is not editable.\n");
                        }
                    }
                    if (NULL != performanceLevelsBuffer)
                        delete[] performanceLevelsBuffer;
                }
                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)
            {
                ADLODNCapabilitiesX2 overdriveCapabilities;
                memset(&overdriveCapabilities, 0, sizeof(ADLODNCapabilitiesX2));

                if (ADL_OK != ADL2_OverdriveN_CapabilitiesX2_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");
                    if (((overdriveCapabilities.iFlags & ADL_ODN_FAN_SPEED_MIN) == ADL_ODN_FAN_SPEED_MIN) || ((overdriveCapabilities.iFlags & ADL_ODN_FAN_SPEED_TARGET) == ADL_ODN_FAN_SPEED_TARGET))
                    {
                        PRINTF("-------- FAN (Min Fan Limit & Fan Target Speed) ---------\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("-----------------------------------------\n");
                    }
                    if ((overdriveCapabilities.iFlags & ADL_ODN_ACOUSTIC_LIMIT_SCLK) == ADL_ODN_ACOUSTIC_LIMIT_SCLK)
                    {
                        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("-----------------------------------------\n");
                    }
                    if ((overdriveCapabilities.iFlags & ADL_ODN_TEMPERATURE_FAN_MAX) == ADL_ODN_TEMPERATURE_FAN_MAX)
                    {
                        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("-----------------------------------------\n");
                    }
                    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)
            {
                ADLODNCapabilitiesX2 overdriveCapabilities;
                memset(&overdriveCapabilities, 0, sizeof(ADLODNCapabilitiesX2));

                if (ADL_OK != ADL2_OverdriveN_CapabilitiesX2_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 && (overdriveCapabilities.iFlags & ADL_ODN_FAN_SPEED_MIN) == ADL_ODN_FAN_SPEED_MIN)
                                odNFanControl.iMinFanLimit = value;
                            else if (feature == 2 && (overdriveCapabilities.iFlags & ADL_ODN_FAN_SPEED_TARGET) == ADL_ODN_FAN_SPEED_TARGET)
                                odNFanControl.iTargetFanSpeed = value;
                            else
                            {
                                PRINTF("ADL2_OverdriveN_FanControl_Set in this feature is not support!\n");
                                break;
                            }

                            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 && (overdriveCapabilities.iFlags & ADL_ODN_ACOUSTIC_LIMIT_SCLK) == ADL_ODN_ACOUSTIC_LIMIT_SCLK)
                    {
                        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 && (overdriveCapabilities.iFlags & ADL_ODN_TEMPERATURE_FAN_MAX) == ADL_ODN_TEMPERATURE_FAN_MAX)
                    {
                        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();
                            }
                        }
                    }
                    else
                    {
                        PRINTF("ADL2_OverdriveN_FanControl_Set in this feature is not support!\n");
                        break;
                    }
                }
                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)
            {
                ADLODNCapabilitiesX2 overdriveCapabilities;
                memset(&overdriveCapabilities, 0, sizeof(ADLODNCapabilitiesX2));

                if (ADL_OK != ADL2_OverdriveN_CapabilitiesX2_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)
            {
                ADLODNCapabilitiesX2 overdriveCapabilities;
                memset(&overdriveCapabilities, 0, sizeof(ADLODNCapabilitiesX2));

                if (ADL_OK != ADL2_OverdriveN_CapabilitiesX2_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 printODNTIMINGLEVELParameters()
{
    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)
            {
                int support, currentValue, defaultValue, numberLevels;
                int *levelList = NULL;

                if (ADL_OK != ADL2_OverdriveN_MemoryTimingLevel_Get(context, lpAdapterInfo[i].iAdapterIndex, &support, &currentValue, &defaultValue, &numberLevels, &levelList))
                {
                    PRINTF("ADL2_OverdriveN_MemoryTimingLevel_Get is failed\n");
                }
                else
                {
                    PRINTF("ADL2_OverdriveN_MemoryTimingLevel_Get Data\n");
                    PRINTF("-------------------------------------------------\n");
                    PRINTF("Memory Timing Level support : %d\n", support);
                    PRINTF("Current value : %d\n", currentValue);
                    PRINTF("Default value : %d\n", defaultValue);
                    PRINTF("Number Levels : %d\n", numberLevels);
                    for (int i = 0; i != numberLevels; ++i)
                        PRINTF("List %d: %d\n", i, levelList[i]);
                    PRINTF("-------------------------------------------------\n");

                    //cleanup the memory
                    if (NULL != levelList)
                        ADL_Main_Memory_Free((void**)&levelList);

                }
                break;
            }
        }
    }

    return ret;
}

int setODNTIMINGLEVELParameters(int level_)
{

    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)
            {
                if (ADL_OK != ADL2_OverdriveN_MemoryTimingLevel_Set(context, lpAdapterInfo[i].iAdapterIndex, level_))
                {
                    PRINTF("ADL2_OverdriveN_MemoryTimingLevel_Set is failed\n");
                }
                else
                {
                    PRINTF("ADL2_OverdriveN_MemoryTimingLevel_Set is Success\n\n");
                    PRINTF("****** Driver Values: After Apply ******\n");
                    printODNTIMINGLEVELParameters();
                }
            }
        }
    }
    return ret;
}

int printODNZERORPMParameters()
{
    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)
            {
                int support, currentValue, defaultValue;
                if (ADL_OK != ADL2_OverdriveN_ZeroRPMFan_Get(context, lpAdapterInfo[i].iAdapterIndex, &support, &currentValue, &defaultValue))
                {
                    PRINTF("ADL2_OverdriveN_ZeroRPMFan_Get is failed\n");
                }
                else
                {
                    PRINTF("ADL2_OverdriveN_ZeroRPMFan_Get Data\n");
                    PRINTF("-------------------------------------------------\n");
                    PRINTF("Zero PRM Fan support : %d\n", support);
                    PRINTF("Current value : %d\n", currentValue);
                    PRINTF("Default value : %d\n", defaultValue);
                }
                break;
            }
        }
    }

    return ret;
}

int setODNZERORPMParameters(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)
            {
                if (ADL_OK != ADL2_OverdriveN_ZeroRPMFan_Set(context, lpAdapterInfo[i].iAdapterIndex, value_))
                {
                    PRINTF("ADL2_OverdriveN_ZeroRPMFan_Set is failed\n");
                }
                else
                {
                    PRINTF("ADL2_OverdriveN_ZeroRPMFan_Set is Success\n\n");
                    PRINTF("****** Driver Values: After Apply ******\n");
                    printODNZERORPMParameters();
                }
            }
        }
    }
    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)
            {
                ADLODNCapabilitiesX2 overdriveCapabilities;
                memset(&overdriveCapabilities, 0, sizeof(ADLODNCapabilitiesX2));

                if (ADL_OK != ADL2_OverdriveN_CapabilitiesX2_Get(context, lpAdapterInfo[i].iAdapterIndex, &overdriveCapabilities))
                {
                    PRINTF("ADL2_OverdriveN_CapabilitiesX2_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)
            {
                ADLODNCapabilitiesX2 overdriveCapabilities;
                memset(&overdriveCapabilities, 0, sizeof(ADLODNCapabilitiesX2));

                if (ADL_OK != ADL2_OverdriveN_CapabilitiesX2_Get(context, lpAdapterInfo[i].iAdapterIndex, &overdriveCapabilities))
                {
                    PRINTF("ADL2_OverdriveN_CapabilitiesX2_Get is failed\n");
                }

                //performance levels info
                ADLODNPerformanceLevelsX2 *odPerformanceLevels;

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

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

                    if (ADL_OK != ADL2_OverdriveN_MemoryClocksX2_Set(context, lpAdapterInfo[i].iAdapterIndex, odPerformanceLevels))
                    {
                        PRINTF("ADL2_OverdriveN_MemoryClocksX2_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();
                }
                if (NULL != performanceLevelsBuffer)
                    delete[] performanceLevelsBuffer;
                break;
            }
        }
    }

    return ret;
}

int ODNSettingExtGet()
{
    int iSupported, iEnabled, iVersion;
    int i, ret = 1;
    for (i = 0; i < iNumberAdapters; i++)
    {
        if (lpAdapterInfo[i].iBusNumber > -1)
        {
            ADLODNCapabilitiesX2 overdriveCapabilities;
            memset(&overdriveCapabilities, 0, sizeof(ADLODNCapabilitiesX2));
            ret = ADL2_OverdriveN_CapabilitiesX2_Get(context, lpAdapterInfo[i].iAdapterIndex, &overdriveCapabilities);
            if (NULL != ADL2_OverdriveN_SettingsExt_Get)
            {
                int overdriveNExtCapabilities;
                int numberOfODNExtFeatures = ODN_COUNT;
                ADLODNExtSingleInitSetting* lpInitSettingList = NULL;
                int* lpCurrentSettingList = NULL;
                ret = ADL2_OverdriveN_SettingsExt_Get(context, lpAdapterInfo[i].iAdapterIndex, &overdriveNExtCapabilities, &numberOfODNExtFeatures, &lpInitSettingList, &lpCurrentSettingList);
                if (ADL_OK != ret)
                {
                    PRINTF("ADL2_OverdriveN_SettingsExt_Get is failed\n");
                }
                else
                {
                    PRINTF("ADL2_OverdriveN_SettingsExt_Get is Success\n\n");
                    PRINTF("****** Driver Values: After Apply ******\n");
                    PRINTF("ADL_ODN_PARAMETER_AC_TIMING = 0******Memory timing\n");
                    PRINTF("ADL_ODN_PARAMETER_FAN_ZERO_RPM_CONTROL = 1******Zero RPM\n");
                    PRINTF("ADL_ODN_PARAMETER_AUTO_UV_ENGINE = 2******Auto UV Engine\n");
                    PRINTF("ADL_ODN_PARAMETER_AUTO_OC_ENGINE = 3******Auto OC ingine\n");
                    PRINTF("ADL_ODN_PARAMETER_AUTO_OC_MEMORY = 4******Auto OC memory\n");
                    PRINTF("The follwoing is Fan curve temperature and speed:\n");
                    PRINTF("ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_1 = 5\n");
                    PRINTF("ADL_ODN_PARAMETER_FAN_CURVE_SPEED_1 = 6\n");
                    PRINTF("ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_2 = 7\n");
                    PRINTF("ADL_ODN_PARAMETER_FAN_CURVE_SPEED_2 = 8\n");
                    PRINTF("ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_3 = 9\n");
                    PRINTF("ADL_ODN_PARAMETER_FAN_CURVE_SPEED_3 = 10\n");
                    PRINTF("ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_4 = 11\n");
                    PRINTF("ADL_ODN_PARAMETER_FAN_CURVE_SPEED_4 = 12\n");
                    PRINTF("ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_5 = 13\n");
                    PRINTF("ADL_ODN_PARAMETER_FAN_CURVE_SPEED_5 = 14 \n");
                    for (int j = 0; j < numberOfODNExtFeatures; j++)
                    {
                        PRINTF("******numberOfODNExtFeatures:%d******\n", j);
                        if (overdriveCapabilities.iFlags & (ADLODNExtSettingId)j == (ADLODNExtSettingId)j)
                        {
                            PRINTF("Support this feature;\n");
                            PRINTF("lpCurrentSettingList Value : %d\n", lpCurrentSettingList[j]);
                            PRINTF("lpInitSettingList.defaultValue : %d\n", lpInitSettingList[j].defaultValue);
                            PRINTF("lpInitSettingList.maxValue : %d\n", lpInitSettingList[j].maxValue);
                            PRINTF("lpInitSettingList.minValue : %d\n", lpInitSettingList[j].minValue);
                        }
                        else
                        {
                            PRINTF("Not Support this featureID\n");
                        }
                    }
                }
                ADL_Main_Memory_Free((void**)&lpInitSettingList);
                ADL_Main_Memory_Free((void**)&lpCurrentSettingList);
                return ADL_OK;
            }
        }
    }
    return ret;
}

int ODNSettingExtSet(int itemId, int value)
{
    //int iSupported, iEnabled, iVersion;
    int i, ret = ADL_FALSE;
    for (i = 0; i < iNumberAdapters; i++)
    {
        if (lpAdapterInfo[i].iBusNumber > -1)
        {
            //ADL2_Overdrive_Caps(context, lpAdapterInfo[i].iAdapterIndex, &iSupported, &iEnabled, &iVersion);
            //OD Capabilities
            ADLODNCapabilitiesX2 overdriveCapabilities;
            memset(&overdriveCapabilities, 0, sizeof(ADLODNCapabilitiesX2));
            ret = ADL2_OverdriveN_CapabilitiesX2_Get(context, lpAdapterInfo[i].iAdapterIndex, &overdriveCapabilities);
            if (NULL != ADL2_OverdriveN_SettingsExt_Get && NULL != ADL2_OverdriveN_SettingsExt_Set)
            {
                int overdriveNExtCapabilities;
                int numberOfODNExtFeatures = ODN_COUNT;
                ADLODNExtSingleInitSetting* lpInitSettingList = NULL;
                int* lpCurrentSettingList = NULL;
                int itemValueValidList[ODN_COUNT];
                int itemValueList[ODN_COUNT];
                int ret = ADL2_OverdriveN_SettingsExt_Get(context, lpAdapterInfo[i].iAdapterIndex, &overdriveNExtCapabilities, &numberOfODNExtFeatures, &lpInitSettingList, &lpCurrentSettingList);
                if (ADL_OK != ret)
                {
                    PRINTF("ADL2_OverdriveN_SettingsExt_Get is failed\n");
                }
                else
                {
                    PRINTF("ADL2_OverdriveN_SettingsExt_Get is Success\n\n");
                    for (int j = 0; j < numberOfODNExtFeatures; j++)
                    {
                        itemValueValidList[j] = 0;
                    }
                    ODNSettingExtGet();
                    if (ADL_ODN_PARAMETER_AC_TIMING == itemId && (overdriveCapabilities.iFlags & ADL_ODN_PARAMETER_AC_TIMING) == ADL_ODN_PARAMETER_AC_TIMING)
                    {
                        if (!(lpInitSettingList[ADL_ODN_PARAMETER_AC_TIMING].minValue <= value && lpInitSettingList[ADL_ODN_PARAMETER_AC_TIMING].maxValue >= value))
                        {
                            PRINTF("ODN value range should be in Min : %d, Max : %d\n", lpInitSettingList[ADL_ODN_PARAMETER_AC_TIMING].minValue <= value, lpInitSettingList[ADL_ODN_PARAMETER_AC_TIMING].maxValue <= value);
                            ret = ADL_ERR;
                        }
                        else
                        {
                            itemValueValidList[itemId] = 1;
                            itemValueList[itemId] = value;
                            ret = ADL2_OverdriveN_SettingsExt_Set(context, lpAdapterInfo[i].iAdapterIndex, numberOfODNExtFeatures, itemValueValidList, itemValueList);

                            if (ADL_OK != ret)
                            {
                                PRINTF("ADL2_OverdriveN_SettingsExt_Set is failed\n");
                            }
                            else
                            {
                                PRINTF("ADL2_OverdriveN_SettingsExt_Set is Success\n\n");
                            }
                        }
                    }
                    else if (ADL_ODN_PARAMETER_FAN_ZERO_RPM_CONTROL == itemId && (overdriveCapabilities.iFlags & ADL_ODN_PARAMETER_FAN_ZERO_RPM_CONTROL) == ADL_ODN_PARAMETER_FAN_ZERO_RPM_CONTROL)
                    {
                        if (!(lpInitSettingList[ADL_ODN_PARAMETER_FAN_ZERO_RPM_CONTROL].minValue <= value && lpInitSettingList[ADL_ODN_PARAMETER_FAN_ZERO_RPM_CONTROL].maxValue >= value))
                        {
                            PRINTF("ODN value range should be in Min : %d, Max : %d\n", lpInitSettingList[ADL_ODN_PARAMETER_FAN_ZERO_RPM_CONTROL].minValue <= value, lpInitSettingList[ADL_ODN_PARAMETER_FAN_ZERO_RPM_CONTROL].maxValue <= value);
                            ret = ADL_ERR;
                        }
                        else
                        {
                            itemValueValidList[itemId] = 1;
                            itemValueList[itemId] = value;
                            ret = ADL2_OverdriveN_SettingsExt_Set(context, lpAdapterInfo[i].iAdapterIndex, numberOfODNExtFeatures, itemValueValidList, itemValueList);

                            if (ADL_OK != ret)
                            {
                                PRINTF("ADL2_OverdriveN_SettingsExt_Set is failed\n");
                            }
                            else
                            {
                                PRINTF("ADL2_OverdriveN_SettingsExt_Set is Success\n\n");
                            }
                        }
                    }
                    else if (ADL_ODN_PARAMETER_AUTO_UV_ENGINE == itemId && (overdriveCapabilities.iFlags & ADL_ODN_PARAMETER_AUTO_UV_ENGINE) == ADL_ODN_PARAMETER_AUTO_UV_ENGINE)
                    {
                        if (!(lpInitSettingList[ADL_ODN_PARAMETER_AUTO_UV_ENGINE].minValue <= value && lpInitSettingList[ADL_ODN_PARAMETER_AUTO_UV_ENGINE].maxValue >= value))
                        {
                            PRINTF("ODN value range should be in Min : %d, Max : %d\n", lpInitSettingList[ADL_ODN_PARAMETER_AUTO_UV_ENGINE].minValue <= value, lpInitSettingList[ADL_ODN_PARAMETER_AUTO_UV_ENGINE].maxValue <= value);
                            ret = ADL_ERR;
                        }
                        else
                        {
                            itemValueValidList[itemId] = 1;
                            itemValueList[itemId] = value;
                            ret = ADL2_OverdriveN_SettingsExt_Set(context, lpAdapterInfo[i].iAdapterIndex, numberOfODNExtFeatures, itemValueValidList, itemValueList);

                            if (ADL_OK != ret)
                            {
                                PRINTF("ADL2_OverdriveN_SettingsExt_Set is failed\n");
                            }
                            else
                            {
                                PRINTF("ADL2_OverdriveN_SettingsExt_Set is Success\n\n");
                            }
                        }
                    }
                    else if (ADL_ODN_PARAMETER_AUTO_OC_ENGINE == itemId && (overdriveCapabilities.iFlags & ADL_ODN_PARAMETER_AUTO_OC_ENGINE) == ADL_ODN_PARAMETER_AUTO_OC_ENGINE)
                    {
                        if (!(lpInitSettingList[ADL_ODN_PARAMETER_AUTO_OC_ENGINE].minValue <= value && lpInitSettingList[ADL_ODN_PARAMETER_AUTO_OC_ENGINE].maxValue >= value))
                        {
                            PRINTF("ODN value range should be in Min : %d, Max : %d\n", lpInitSettingList[ADL_ODN_PARAMETER_AUTO_OC_ENGINE].minValue <= value, lpInitSettingList[ADL_ODN_PARAMETER_AUTO_OC_ENGINE].maxValue <= value);
                            ret = ADL_ERR;
                        }
                        else
                        {
                            itemValueValidList[itemId] = 1;
                            itemValueList[itemId] = value;
                            ret = ADL2_OverdriveN_SettingsExt_Set(context, lpAdapterInfo[i].iAdapterIndex, numberOfODNExtFeatures, itemValueValidList, itemValueList);

                            if (ADL_OK != ret)
                            {
                                PRINTF("ADL2_OverdriveN_SettingsExt_Set is failed\n");
                            }
                            else
                            {
                                PRINTF("ADL2_OverdriveN_SettingsExt_Set is Success\n\n");
                            }
                        }
                    }
                    else if (((overdriveCapabilities.iFlags & ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_1) == ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_1) ||
                        ((overdriveCapabilities.iFlags & ADL_ODN_PARAMETER_FAN_CURVE_SPEED_1) == ADL_ODN_PARAMETER_FAN_CURVE_SPEED_1) ||
                        ((overdriveCapabilities.iFlags & ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_2) == ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_2) ||
                        ((overdriveCapabilities.iFlags & ADL_ODN_PARAMETER_FAN_CURVE_SPEED_2) == ADL_ODN_PARAMETER_FAN_CURVE_SPEED_2) ||
                        ((overdriveCapabilities.iFlags & ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_3) == ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_3) ||
                        ((overdriveCapabilities.iFlags & ADL_ODN_PARAMETER_FAN_CURVE_SPEED_3) == ADL_ODN_PARAMETER_FAN_CURVE_SPEED_3) ||
                        ((overdriveCapabilities.iFlags & ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_4) == ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_4) ||
                        ((overdriveCapabilities.iFlags & ADL_ODN_PARAMETER_FAN_CURVE_SPEED_4) == ADL_ODN_PARAMETER_FAN_CURVE_SPEED_4) ||
                        ((overdriveCapabilities.iFlags & ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_5) == ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_5) ||
                        ((overdriveCapabilities.iFlags & ADL_ODN_PARAMETER_FAN_CURVE_SPEED_5) == ADL_ODN_PARAMETER_FAN_CURVE_SPEED_5))
                    {
                        if (ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_1 == itemId)
                        {
                            if (!(lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_1].minValue <= value && lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_1].maxValue >= value))
                            {
                                PRINTF("ODN value range should be in Min : %d, Max : %d\n", lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_1].minValue <= value, lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_1].maxValue <= value);
                                ret = ADL_ERR;
                            }
                            else
                            {
                                itemValueValidList[itemId] = 1;
                                itemValueList[itemId] = value;
                                ret = ADL2_OverdriveN_SettingsExt_Set(context, lpAdapterInfo[i].iAdapterIndex, numberOfODNExtFeatures, itemValueValidList, itemValueList);

                                if (ADL_OK != ret)
                                {
                                    PRINTF("ADL2_OverdriveN_SettingsExt_Set is failed\n");
                                }
                                else
                                {
                                    PRINTF("ADL2_OverdriveN_SettingsExt_Set is Success\n\n");
                                }
                            }
                        }
                        else if (ADL_ODN_PARAMETER_FAN_CURVE_SPEED_1 == itemId)
                        {
                            if (!(lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_SPEED_1].minValue <= value && lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_SPEED_1].maxValue >= value))
                            {
                                PRINTF("ODN value range should be in Min : %d, Max : %d\n", lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_SPEED_1].minValue <= value, lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_SPEED_1].maxValue <= value);
                                ret = ADL_ERR;
                            }
                            else
                            {
                                itemValueValidList[itemId] = 1;
                                itemValueList[itemId] = value;
                                ret = ADL2_OverdriveN_SettingsExt_Set(context, lpAdapterInfo[i].iAdapterIndex, numberOfODNExtFeatures, itemValueValidList, itemValueList);

                                if (ADL_OK != ret)
                                {
                                    PRINTF("ADL2_OverdriveN_SettingsExt_Set is failed\n");
                                }
                                else
                                {
                                    PRINTF("ADL2_OverdriveN_SettingsExt_Set is Success\n\n");
                                }
                            }
                        }
                        else if (ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_2 == itemId)
                        {
                            if (!(lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_2].minValue <= value && lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_2].maxValue >= value))
                            {
                                PRINTF("ODN value range should be in Min : %d, Max : %d\n", lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_2].minValue <= value, lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_2].maxValue <= value);
                                ret = ADL_ERR;
                            }
                            else
                            {
                                itemValueValidList[itemId] = 1;
                                itemValueList[itemId] = value;
                                ret = ADL2_OverdriveN_SettingsExt_Set(context, lpAdapterInfo[i].iAdapterIndex, numberOfODNExtFeatures, itemValueValidList, itemValueList);

                                if (ADL_OK != ret)
                                {
                                    PRINTF("ADL2_OverdriveN_SettingsExt_Set is failed\n");
                                }
                                else
                                {
                                    PRINTF("ADL2_OverdriveN_SettingsExt_Set is Success\n\n");
                                }
                            }
                        }
                        else if (ADL_ODN_PARAMETER_FAN_CURVE_SPEED_2 == itemId)
                        {
                            if (!(lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_SPEED_2].minValue <= value && lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_SPEED_2].maxValue >= value))
                            {
                                PRINTF("ODN value range should be in Min : %d, Max : %d\n", lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_SPEED_2].minValue <= value, lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_SPEED_2].maxValue <= value);
                                ret = ADL_ERR;
                            }
                            else
                            {
                                itemValueValidList[itemId] = 1;
                                itemValueList[itemId] = value;
                                ret = ADL2_OverdriveN_SettingsExt_Set(context, lpAdapterInfo[i].iAdapterIndex, numberOfODNExtFeatures, itemValueValidList, itemValueList);

                                if (ADL_OK != ret)
                                {
                                    PRINTF("ADL2_OverdriveN_SettingsExt_Set is failed\n");
                                }
                                else
                                {
                                    PRINTF("ADL2_OverdriveN_SettingsExt_Set is Success\n\n");
                                }
                            }
                        }
                        else if (ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_3 == itemId)
                        {
                            if (!(lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_3].minValue <= value && lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_3].maxValue >= value))
                            {
                                PRINTF("ODN value range should be in Min : %d, Max : %d\n", lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_3].minValue <= value, lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_3].maxValue <= value);
                                ret = ADL_ERR;
                            }
                            else
                            {
                                itemValueValidList[itemId] = 1;
                                itemValueList[itemId] = value;
                                ret = ADL2_OverdriveN_SettingsExt_Set(context, lpAdapterInfo[i].iAdapterIndex, numberOfODNExtFeatures, itemValueValidList, itemValueList);

                                if (ADL_OK != ret)
                                {
                                    PRINTF("ADL2_OverdriveN_SettingsExt_Set is failed\n");
                                }
                                else
                                {
                                    PRINTF("ADL2_OverdriveN_SettingsExt_Set is Success\n\n");
                                }
                            }
                        }
                        else if (ADL_ODN_PARAMETER_FAN_CURVE_SPEED_3 == itemId)
                        {
                            if (!(lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_SPEED_3].minValue <= value && lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_SPEED_3].maxValue >= value))
                            {
                                PRINTF("ODN value range should be in Min : %d, Max : %d\n", lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_SPEED_3].minValue <= value, lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_SPEED_3].maxValue <= value);
                                ret = ADL_ERR;
                            }
                            else
                            {
                                itemValueValidList[itemId] = 1;
                                itemValueList[itemId] = value;
                                ret = ADL2_OverdriveN_SettingsExt_Set(context, lpAdapterInfo[i].iAdapterIndex, numberOfODNExtFeatures, itemValueValidList, itemValueList);

                                if (ADL_OK != ret)
                                {
                                    PRINTF("ADL2_OverdriveN_SettingsExt_Set is failed\n");
                                }
                                else
                                {
                                    PRINTF("ADL2_OverdriveN_SettingsExt_Set is Success\n\n");
                                }
                            }
                        }
                        else if (ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_4 == itemId)
                        {
                            if (!(lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_4].minValue <= value && lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_4].maxValue >= value))
                            {
                                PRINTF("ODN value range should be in Min : %d, Max : %d\n", lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_4].minValue <= value, lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_4].maxValue <= value);
                                ret = ADL_ERR;
                            }
                            else
                            {
                                itemValueValidList[itemId] = 1;
                                itemValueList[itemId] = value;
                                ret = ADL2_OverdriveN_SettingsExt_Set(context, lpAdapterInfo[i].iAdapterIndex, numberOfODNExtFeatures, itemValueValidList, itemValueList);

                                if (ADL_OK != ret)
                                {
                                    PRINTF("ADL2_OverdriveN_SettingsExt_Set is failed\n");
                                }
                                else
                                {
                                    PRINTF("ADL2_OverdriveN_SettingsExt_Set is Success\n\n");
                                }
                            }
                        }
                        else if (ADL_ODN_PARAMETER_FAN_CURVE_SPEED_4 == itemId)
                        {
                            if (!(lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_SPEED_4].minValue <= value && lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_SPEED_4].maxValue >= value))
                            {
                                PRINTF("ODN value range should be in Min : %d, Max : %d\n", lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_SPEED_4].minValue <= value, lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_SPEED_4].maxValue <= value);
                                ret = ADL_ERR;
                            }
                            else
                            {
                                itemValueValidList[itemId] = 1;
                                itemValueList[itemId] = value;
                                ret = ADL2_OverdriveN_SettingsExt_Set(context, lpAdapterInfo[i].iAdapterIndex, numberOfODNExtFeatures, itemValueValidList, itemValueList);

                                if (ADL_OK != ret)
                                {
                                    PRINTF("ADL2_OverdriveN_SettingsExt_Set is failed\n");
                                }
                                else
                                {
                                    PRINTF("ADL2_OverdriveN_SettingsExt_Set is Success\n\n");
                                }
                            }
                        }
                        else if (ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_5 == itemId)
                        {
                            if (!(lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_5].minValue <= value && lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_5].maxValue >= value))
                            {
                                PRINTF("ODN value range should be in Min : %d, Max : %d\n", lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_5].minValue <= value, lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_TEMPERATURE_5].maxValue <= value);
                                ret = ADL_ERR;
                            }
                            else
                            {
                                itemValueValidList[itemId] = 1;
                                itemValueList[itemId] = value;
                                ret = ADL2_OverdriveN_SettingsExt_Set(context, lpAdapterInfo[i].iAdapterIndex, numberOfODNExtFeatures, itemValueValidList, itemValueList);

                                if (ADL_OK != ret)
                                {
                                    PRINTF("ADL2_OverdriveN_SettingsExt_Set is failed\n");
                                }
                                else
                                {
                                    PRINTF("ADL2_OverdriveN_SettingsExt_Set is Success\n\n");
                                }
                            }
                        }
                        else if (ADL_ODN_PARAMETER_FAN_CURVE_SPEED_5 == itemId)
                        {
                            if (!(lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_SPEED_5].minValue <= value && lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_SPEED_5].maxValue >= value))
                            {
                                PRINTF("ODN value range should be in Min : %d, Max : %d\n", lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_SPEED_5].minValue <= value, lpInitSettingList[ADL_ODN_PARAMETER_FAN_CURVE_SPEED_5].maxValue <= value);
                                ret = ADL_ERR;
                            }
                            else
                            {
                                itemValueValidList[itemId] = 1;
                                itemValueList[itemId] = value;
                                ret = ADL2_OverdriveN_SettingsExt_Set(context, lpAdapterInfo[i].iAdapterIndex, numberOfODNExtFeatures, itemValueValidList, itemValueList);

                                if (ADL_OK != ret)
                                {
                                    PRINTF("ADL2_OverdriveN_SettingsExt_Set is failed\n");
                                }
                                else
                                {
                                    PRINTF("ADL2_OverdriveN_SettingsExt_Set is Success\n\n");
                                }
                            }
                        }
                        else
                            PRINTF("Found no corresponding Item\n");
                    }
                    else
                    {
                        PRINTF("ADL2_OverdriveN_SettingsExt_Set Found no corresponding Item\n");
                        ret = ADL_ERR;
                    }
                }
                ODNSettingExtGet();
                ADL_Main_Memory_Free((void**)&lpInitSettingList);
                ADL_Main_Memory_Free((void**)&lpCurrentSettingList);
                return ADL_OK;
            }
        }
    }
    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, 3: DPM state), 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, 3: DPM state), 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;
            case 'l':
                if (argc == 2)
                    printODNTIMINGLEVELParameters();
                else if (argc == 3)
                    setODNTIMINGLEVELParameters(atoi(argv[2]));
                else
                    printf("signature of Memory Timing Level Set (ODNEXT.exe l X); X - Expected Levle");
                break;
            case 'z':
                if (argc == 2)
                    printODNZERORPMParameters();
                else if (argc == 3)
                    setODNZERORPMParameters(atoi(argv[2]));
                else
                    printf("signature of Zero RPM Fan Set (ODNEXT.exe z X); X - Expected Zero RPM value");
                break;
            case 'e':
                if (argc == 2)
                    ODNSettingExtGet();
                else if (argc == 4)
                    ODNSettingExtSet(atoi(argv[2]), atoi(argv[3]));
                else
                    printf("signature of ODN Setting Ext_Get (ODNEXT.exe e X); X - Expected Levle");
                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, 3: DPM state), 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, 3: DPM state), 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, 3: DPM state), 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, 3: DPM state), 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.