src/ext_ADL.c

   1 /**
   2  * Author......: Jens Steube <jens.steube@gmail.com>
   3  * License.....: MIT
   4  */
   5
   6 #include <ext_ADL.h>
   7
   8 int adl_init (ADL_PTR *adl)
   9 {
  10   if (!adl) return (-1);
  11
  12   memset (adl, 0, sizeof (ADL_PTR));
  13
  14   #ifdef _WIN
  15   if (!(adl->lib = hc_dlopen ("atiadlxx.dll")))
  16   {
  17     adl->lib = hc_dlopen ("atiadlxy.dll");
  18   }
  19   #elif _POSIX
  20   adl->lib = hc_dlopen ("libatiadlxx.so", RTLD_NOW);
  21   #endif
  22
  23   if (!adl->lib)
  24   {
  25     if (data.quiet == 0)
  26       log_info ("WARNING: load ADL library failed, proceed without ADL HWMon enabled.");
  27
  28     return (-1);
  29   }
  30
  31   HC_LOAD_FUNC(adl, ADL_Main_Control_Destroy, ADL_MAIN_CONTROL_DESTROY, ADL, 0)
  32   HC_LOAD_FUNC(adl, ADL_Main_Control_Create, ADL_MAIN_CONTROL_CREATE, ADL, 0)
  33   HC_LOAD_FUNC(adl, ADL_Adapter_NumberOfAdapters_Get, ADL_ADAPTER_NUMBEROFADAPTERS_GET, ADL, 0)
  34   HC_LOAD_FUNC(adl, ADL_Adapter_AdapterInfo_Get, ADL_ADAPTER_ADAPTERINFO_GET, ADL, 0)
  35   HC_LOAD_FUNC(adl, ADL_Display_DisplayInfo_Get, ADL_DISPLAY_DISPLAYINFO_GET, ADL, 0)
  36   HC_LOAD_FUNC(adl, ADL_Adapter_ID_Get, ADL_ADAPTER_ID_GET, ADL, 0)
  37   HC_LOAD_FUNC(adl, ADL_Adapter_VideoBiosInfo_Get, ADL_ADAPTER_VIDEOBIOSINFO_GET, ADL, 0)
  38   HC_LOAD_FUNC(adl, ADL_Overdrive5_ThermalDevices_Enum, ADL_OVERDRIVE5_THERMALDEVICES_ENUM, ADL, 0)
  39   HC_LOAD_FUNC(adl, ADL_Overdrive5_Temperature_Get, ADL_OVERDRIVE5_TEMPERATURE_GET, ADL, 0)
  40   HC_LOAD_FUNC(adl, ADL_Overdrive6_Temperature_Get, ADL_OVERDRIVE6_TEMPERATURE_GET, ADL, 0)
  41   HC_LOAD_FUNC(adl, ADL_Overdrive5_CurrentActivity_Get, ADL_OVERDRIVE5_CURRENTACTIVITY_GET, ADL, 0)
  42   HC_LOAD_FUNC(adl, ADL_Overdrive5_FanSpeedInfo_Get, ADL_OVERDRIVE5_FANSPEEDINFO_GET, ADL, 0)
  43   HC_LOAD_FUNC(adl, ADL_Overdrive5_FanSpeed_Get, ADL_OVERDRIVE5_FANSPEED_GET, ADL, 0)
  44   HC_LOAD_FUNC(adl, ADL_Overdrive6_FanSpeed_Get, ADL_OVERDRIVE6_FANSPEED_GET, ADL, 0)
  45   HC_LOAD_FUNC(adl, ADL_Overdrive5_FanSpeed_Set, ADL_OVERDRIVE5_FANSPEED_SET, ADL, 0)
  46   HC_LOAD_FUNC(adl, ADL_Overdrive6_FanSpeed_Set, ADL_OVERDRIVE6_FANSPEED_SET, ADL, 0)
  47   HC_LOAD_FUNC(adl, ADL_Overdrive5_FanSpeedToDefault_Set, ADL_OVERDRIVE5_FANSPEEDTODEFAULT_SET, ADL, 0)
  48   HC_LOAD_FUNC(adl, ADL_Overdrive5_ODParameters_Get, ADL_OVERDRIVE5_ODPARAMETERS_GET, ADL, 0)
  49   HC_LOAD_FUNC(adl, ADL_Overdrive5_ODPerformanceLevels_Get, ADL_OVERDRIVE5_ODPERFORMANCELEVELS_GET, ADL, 0)
  50   HC_LOAD_FUNC(adl, ADL_Overdrive5_ODPerformanceLevels_Set, ADL_OVERDRIVE5_ODPERFORMANCELEVELS_SET, ADL, 0)
  51   HC_LOAD_FUNC(adl, ADL_Overdrive6_PowerControlInfo_Get, ADL_OVERDRIVE6_POWERCONTROLINFO_GET, ADL, 0)
  52   HC_LOAD_FUNC(adl, ADL_Overdrive6_PowerControl_Get, ADL_OVERDRIVE6_POWERCONTROL_GET, ADL, 0)
  53   HC_LOAD_FUNC(adl, ADL_Overdrive6_PowerControl_Set, ADL_OVERDRIVE6_POWERCONTROL_SET, ADL, 0)
  54   HC_LOAD_FUNC(adl, ADL_Adapter_Active_Get, ADL_ADAPTER_ACTIVE_GET, ADL, 0)
  55   //HC_LOAD_FUNC(adl, ADL_DisplayEnable_Set, ADL_DISPLAYENABLE_SET, ADL, 0)
  56   HC_LOAD_FUNC(adl, ADL_Overdrive_Caps, ADL_OVERDRIVE_CAPS, ADL, 0)
  57   HC_LOAD_FUNC(adl, ADL_Overdrive6_PowerControl_Caps, ADL_OVERDRIVE6_POWERCONTROL_CAPS, ADL, 0)
  58   HC_LOAD_FUNC(adl, ADL_Overdrive6_Capabilities_Get, ADL_OVERDRIVE6_CAPABILITIES_GET, ADL, 0)
  59   HC_LOAD_FUNC(adl, ADL_Overdrive6_StateInfo_Get, ADL_OVERDRIVE6_STATEINFO_GET, ADL, 0)
  60   HC_LOAD_FUNC(adl, ADL_Overdrive6_CurrentStatus_Get, ADL_OVERDRIVE6_CURRENTSTATUS_GET, ADL, 0)
  61   HC_LOAD_FUNC(adl, ADL_Overdrive6_State_Set, ADL_OVERDRIVE6_STATE_SET, ADL, 0)
  62   HC_LOAD_FUNC(adl, ADL_Overdrive6_TargetTemperatureData_Get, ADL_OVERDRIVE6_TARGETTEMPERATUREDATA_GET, ADL, 0)
  63
  64   return 0;
  65 }
  66
  67 void adl_close (ADL_PTR *adl)
  68 {
  69   if (adl)
  70   {
  71     if (adl->lib)
  72       hc_dlclose (adl->lib);
  73
  74     myfree (adl);
  75   }
  76 }
  77
  78 int hc_ADL_Main_Control_Destroy (ADL_PTR *adl)
  79 {
  80   if (!adl) return (-1);
  81
  82   int ADL_rc = adl->ADL_Main_Control_Destroy ();
  83
  84   if (ADL_rc != ADL_OK)
  85   {
  86     log_info ("WARN: %s: %d\n", "ADL_Main_Control_Destroy()", ADL_rc);
  87   }
  88
  89   return (ADL_rc);
  90 }
  91
  92 int hc_ADL_Main_Control_Create (ADL_PTR *adl, ADL_MAIN_MALLOC_CALLBACK callback, int iEnumConnectedAdapters)
  93 {
  94   if (!adl) return (-1);
  95
  96   int ADL_rc = adl->ADL_Main_Control_Create (callback, iEnumConnectedAdapters);
  97
  98   if (ADL_rc != ADL_OK)
  99   {
 100     log_info ("WARN: %s: %d\n", "ADL_Main_Control_Create()", ADL_rc);
 101   }
 102
 103   return (ADL_rc);
 104 }
 105
 106 int hc_ADL_Adapter_NumberOfAdapters_Get (ADL_PTR *adl, int *lpNumAdapters)
 107 {
 108   if (!adl) return (-1);
 109
 110   int ADL_rc = adl->ADL_Adapter_NumberOfAdapters_Get (lpNumAdapters);
 111
 112   if (ADL_rc != ADL_OK)
 113   {
 114     log_info ("WARN: %s: %d\n", "ADL_Adapter_NumberOfAdapters_Get()", ADL_rc);
 115   }
 116
 117   return (ADL_rc);
 118 }
 119
 120 int hc_ADL_Adapter_AdapterInfo_Get (ADL_PTR *adl, LPAdapterInfo lpInfo, int iInputSize)
 121 {
 122   if (!adl) return (-1);
 123
 124   int ADL_rc = adl->ADL_Adapter_AdapterInfo_Get (lpInfo, iInputSize);
 125
 126   if (ADL_rc != ADL_OK)
 127   {
 128     log_info ("WARN: %s: %d\n", "ADL_Adapter_AdapterInfo_Get()", ADL_rc);
 129   }
 130
 131   return (ADL_rc);
 132 }
 133
 134 int hc_ADL_Display_DisplayInfo_Get (ADL_PTR *adl, int iAdapterIndex, int *iNumDisplays, ADLDisplayInfo **lppInfo, int iForceDetect)
 135 {
 136   if (!adl) return (-1);
 137
 138   int ADL_rc = adl->ADL_Display_DisplayInfo_Get (iAdapterIndex, iNumDisplays, lppInfo, iForceDetect);
 139
 140   if (ADL_rc != ADL_OK)
 141   {
 142     log_info ("WARN: %s: %d\n", "ADL_Display_DisplayInfo_Get()", ADL_rc);
 143   }
 144
 145   return (ADL_rc);
 146 }
 147
 148 int hc_ADL_Adapter_ID_Get (ADL_PTR *adl, int iAdapterIndex, int *lpAdapterID)
 149 {
 150   if (!adl) return (-1);
 151
 152   int ADL_rc = adl->ADL_Adapter_ID_Get (iAdapterIndex, lpAdapterID);
 153
 154   if (ADL_rc != ADL_OK)
 155   {
 156     log_info ("WARN: %s: %d\n", "ADL_Adapter_ID_Get()", ADL_rc);
 157   }
 158
 159   return ADL_rc;
 160 }
 161
 162 int hc_ADL_Adapter_VideoBiosInfo_Get (ADL_PTR *adl, int iAdapterIndex, ADLBiosInfo *lpBiosInfo)
 163 {
 164   if (!adl) return (-1);
 165
 166   int ADL_rc = adl->ADL_Adapter_VideoBiosInfo_Get (iAdapterIndex, lpBiosInfo);
 167
 168   if (ADL_rc != ADL_OK)
 169   {
 170     log_info ("WARN: %s: %d\n", "ADL_Adapter_VideoBiosInfo_Get()", ADL_rc);
 171   }
 172
 173   return ADL_rc;
 174 }
 175
 176 int hc_ADL_Overdrive_ThermalDevices_Enum (ADL_PTR *adl, int iAdapterIndex, int iThermalControllerIndex, ADLThermalControllerInfo *lpThermalControllerInfo)
 177 {
 178   if (!adl) return (-1);
 179
 180   int ADL_rc = adl->ADL_Overdrive5_ThermalDevices_Enum (iAdapterIndex, iThermalControllerIndex, lpThermalControllerInfo);
 181
 182   if (ADL_rc != ADL_OK)
 183   {
 184     log_info ("WARN: %s: %d\n", "ADL_Overdrive5_ThermalDevices_Enum()", ADL_rc);
 185   }
 186
 187   return (ADL_rc);
 188 }
 189
 190 int hc_ADL_Overdrive5_Temperature_Get (ADL_PTR *adl, int iAdapterIndex, int iThermalControllerIndex, ADLTemperature *lpTemperature)
 191 {
 192   if (!adl) return (-1);
 193
 194   int ADL_rc = adl->ADL_Overdrive5_Temperature_Get (iAdapterIndex, iThermalControllerIndex, lpTemperature);
 195
 196   if (ADL_rc != ADL_OK)
 197   {
 198     log_info ("WARN: %s: %d\n", "ADL_Overdrive5_Temperature_Get()", ADL_rc);
 199   }
 200
 201   return (ADL_rc);
 202 }
 203
 204 int hc_ADL_Overdrive6_Temperature_Get (ADL_PTR *adl, int iAdapterIndex, int *iTemperature)
 205 {
 206   if (!adl) return (-1);
 207
 208   int ADL_rc = adl->ADL_Overdrive6_Temperature_Get (iAdapterIndex, iTemperature);
 209
 210   if (ADL_rc != ADL_OK)
 211   {
 212     log_info ("WARN: %s: %d\n", "ADL_Overdrive6_Temperature_Get()", ADL_rc);
 213   }
 214
 215   return (ADL_rc);
 216 }
 217
 218 int hc_ADL_Overdrive_CurrentActivity_Get (ADL_PTR *adl, int iAdapterIndex, ADLPMActivity *lpActivity)
 219 {
 220   if (!adl) return (-1);
 221
 222   int ADL_rc = adl->ADL_Overdrive5_CurrentActivity_Get (iAdapterIndex, lpActivity);
 223
 224   if (ADL_rc != ADL_OK)
 225   {
 226     log_info ("WARN: %s: %d\n", "ADL_Overdrive5_CurrentActivity_Get()", ADL_rc);
 227   }
 228
 229   return (ADL_rc);
 230 }
 231
 232 int hc_ADL_Overdrive5_FanSpeedInfo_Get (ADL_PTR *adl, int iAdapterIndex, int iThermalControllerIndex, ADLFanSpeedInfo *lpFanSpeedInfo)
 233 {
 234   if (!adl) return (-1);
 235
 236   int ADL_rc = adl->ADL_Overdrive5_FanSpeedInfo_Get (iAdapterIndex, iThermalControllerIndex, lpFanSpeedInfo);
 237
 238   if (ADL_rc != ADL_OK)
 239   {
 240     log_info ("WARN: %s: %d\n", "ADL_Overdrive5_FanSpeedInfo_Get()", ADL_rc);
 241   }
 242
 243   return ADL_rc;
 244 }
 245
 246 int hc_ADL_Overdrive5_FanSpeed_Get (ADL_PTR *adl, int iAdapterIndex, int iThermalControllerIndex, ADLFanSpeedValue *lpFanSpeedValue)
 247 {
 248   if (!adl) return (-1);
 249
 250   int ADL_rc = adl->ADL_Overdrive5_FanSpeed_Get (iAdapterIndex, iThermalControllerIndex, lpFanSpeedValue);
 251
 252   if ((ADL_rc != ADL_OK) && (ADL_rc != ADL_ERR_NOT_SUPPORTED)) // exception allowed only here
 253   {
 254     log_info ("WARN: %s: %d\n", "ADL_Overdrive5_FanSpeed_Get()", ADL_rc);
 255   }
 256
 257   return (ADL_rc);
 258 }
 259
 260 int hc_ADL_Overdrive6_FanSpeed_Get (ADL_PTR *adl, int iAdapterIndex, ADLOD6FanSpeedInfo *lpFanSpeedInfo)
 261 {
 262   if (!adl) return (-1);
 263
 264   int ADL_rc = adl->ADL_Overdrive6_FanSpeed_Get (iAdapterIndex, lpFanSpeedInfo);
 265
 266   if ((ADL_rc != ADL_OK) && (ADL_rc != ADL_ERR_NOT_SUPPORTED)) // exception allowed only here
 267   {
 268     log_info ("WARN: %s: %d\n", "ADL_Overdrive6_FanSpeed_Get()", ADL_rc);
 269   }
 270
 271   return (ADL_rc);
 272 }
 273
 274 int hc_ADL_Overdrive5_FanSpeed_Set (ADL_PTR *adl, int iAdapterIndex, int iThermalControllerIndex, ADLFanSpeedValue *lpFanSpeedValue)
 275 {
 276   if (!adl) return (-1);
 277
 278   int ADL_rc = adl->ADL_Overdrive5_FanSpeed_Set (iAdapterIndex, iThermalControllerIndex, lpFanSpeedValue);
 279
 280   if ((ADL_rc != ADL_OK) && (ADL_rc != ADL_ERR_NOT_SUPPORTED)) // exception allowed only here
 281   {
 282     log_info ("WARN: %s: %d\n", "ADL_Overdrive5_FanSpeed_Set()", ADL_rc);
 283   }
 284
 285   return (ADL_rc);
 286 }
 287
 288 int hc_ADL_Overdrive6_FanSpeed_Set (ADL_PTR *adl, int iAdapterIndex, ADLOD6FanSpeedValue *lpFanSpeedValue)
 289 {
 290   if (!adl) return (-1);
 291
 292   int ADL_rc = adl->ADL_Overdrive6_FanSpeed_Set (iAdapterIndex, lpFanSpeedValue);
 293
 294   if ((ADL_rc != ADL_OK) && (ADL_rc != ADL_ERR_NOT_SUPPORTED)) // exception allowed only here
 295   {
 296     log_info ("WARN: %s: %d\n", "ADL_Overdrive6_FanSpeed_Set()", ADL_rc);
 297   }
 298
 299   return (ADL_rc);
 300 }
 301
 302 int hc_ADL_Overdrive5_FanSpeedToDefault_Set (ADL_PTR *adl, int iAdapterIndex, int iThermalControllerIndex)
 303 {
 304   if (!adl) return (-1);
 305
 306   int ADL_rc = adl->ADL_Overdrive5_FanSpeedToDefault_Set (iAdapterIndex, iThermalControllerIndex);
 307
 308   if ((ADL_rc != ADL_OK) && (ADL_rc != ADL_ERR_NOT_SUPPORTED)) // exception allowed only here
 309   {
 310     log_info ("WARN: %s: %d\n", "ADL_Overdrive5_FanSpeedToDefault_Set()", ADL_rc);
 311   }
 312
 313   return (ADL_rc);
 314 }
 315
 316 int hc_ADL_Overdrive_ODParameters_Get (ADL_PTR *adl, int iAdapterIndex, ADLODParameters *lpOdParameters)
 317 {
 318   if (!adl) return (-1);
 319
 320   int ADL_rc = adl->ADL_Overdrive5_ODParameters_Get (iAdapterIndex, lpOdParameters);
 321
 322   if (ADL_rc != ADL_OK)
 323   {
 324     log_info ("WARN: %s: %d\n", "ADL_Overdrive5_ODParameters_Get()", ADL_rc);
 325   }
 326
 327   return (ADL_rc);
 328 }
 329
 330 int hc_ADL_Overdrive_ODPerformanceLevels_Get (ADL_PTR *adl, int iAdapterIndex, int iDefault, ADLODPerformanceLevels *lpOdPerformanceLevels)
 331 {
 332   if (!adl) return (-1);
 333
 334   int ADL_rc = adl->ADL_Overdrive5_ODPerformanceLevels_Get (iAdapterIndex, iDefault, lpOdPerformanceLevels);
 335
 336   if (ADL_rc != ADL_OK)
 337   {
 338     log_info ("WARN: %s: %d\n", "ADL_Overdrive5_ODPerformanceLevels_Get()", ADL_rc);
 339   }
 340
 341   return (ADL_rc);
 342 }
 343
 344 int hc_ADL_Overdrive_ODPerformanceLevels_Set (ADL_PTR *adl, int iAdapterIndex, ADLODPerformanceLevels *lpOdPerformanceLevels)
 345 {
 346   if (!adl) return (-1);
 347
 348   int ADL_rc = adl->ADL_Overdrive5_ODPerformanceLevels_Set (iAdapterIndex, lpOdPerformanceLevels);
 349
 350   if (ADL_rc != ADL_OK)
 351   {
 352     log_info ("WARN: %s: %d\n", "ADL_Overdrive5_ODPerformanceLevels_Set()", ADL_rc);
 353   }
 354
 355   return (ADL_rc);
 356 }
 357
 358 int hc_ADL_Overdrive_PowerControlInfo_Get (ADL_PTR *adl, int iAdapterIndex, ADLOD6PowerControlInfo *powertune)
 359 {
 360   if (!adl) return (-1);
 361
 362   int ADL_rc = adl->ADL_Overdrive6_PowerControlInfo_Get (iAdapterIndex, powertune);
 363
 364   return (ADL_rc);
 365 }
 366
 367 int hc_ADL_Overdrive_PowerControl_Get (ADL_PTR *adl, int iAdapterIndex, int *iCurrentValue)
 368 {
 369   if (!adl) return (-1);
 370
 371   int default_value = 0;
 372
 373   int ADL_rc = adl->ADL_Overdrive6_PowerControl_Get (iAdapterIndex, iCurrentValue, &default_value);
 374
 375   return (ADL_rc);
 376 }
 377
 378 int hc_ADL_Overdrive_PowerControl_Set (ADL_PTR *adl, int iAdapterIndex, int level)
 379 {
 380   if (!adl) return (-1);
 381
 382   int ADL_rc = ADL_ERR;
 383
 384   ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
 385
 386   if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (adl, iAdapterIndex, &powertune)) != ADL_OK)
 387   {
 388     log_info ("WARN: %s\n", "ADL_Overdrive6_PowerControl_Get", ADL_rc);
 389   }
 390   else
 391   {
 392     int min  = powertune.iMinValue;
 393     int max  = powertune.iMaxValue;
 394     int step = powertune.iStepValue;
 395
 396     if (level < min || level > max)
 397     {
 398       log_info ("WARN: ADL PowerControl level invalid");
 399
 400       return ADL_ERR;
 401     }
 402     if (level % step != 0)
 403     {
 404       log_info ("WARN: ADL PowerControl step invalid");
 405
 406       return ADL_ERR;
 407     }
 408
 409     ADL_rc = adl->ADL_Overdrive6_PowerControl_Set (iAdapterIndex, level);
 410   }
 411
 412   return (ADL_rc);
 413 }
 414
 415 int hc_ADL_Adapter_Active_Get (ADL_PTR *adl, int iAdapterIndex, int *lpStatus)
 416 {
 417   if (!adl) return (-1);
 418
 419   int ADL_rc = adl->ADL_Adapter_Active_Get (iAdapterIndex, lpStatus);
 420
 421   if (ADL_rc != ADL_OK)
 422   {
 423     log_info ("WARN: %s: %d\n", "ADL_Adapter_Active_Get()", ADL_rc);
 424   }
 425
 426   return (ADL_rc);
 427 }
 428
 429 /*
 430 int hc_ADL_DisplayEnable_Set (ADL_PTR *adl, int iAdapterIndex, int *lpDisplayIndexList, int iDisplayListSize, int bPersistOnly)
 431 {
 432   if (!adl) return (-1);
 433
 434   int ADL_rc = adl->ADL_DisplayEnable_Set (iAdapterIndex, lpDisplayIndexList, iDisplayListSize, bPersistOnly);
 435
 436   if (ADL_rc != ADL_OK)
 437   {
 438     log_info ("WARN: %s: %d\n", "ADL_DisplayEnable_Set()", ADL_rc);
 439   }
 440
 441   return (ADL_rc);
 442 }
 443 */
 444
 445 int hc_ADL_Overdrive_Caps (ADL_PTR *adl, int iAdapterIndex, int *od_supported, int *od_enabled, int *od_version)
 446 {
 447   if (!adl) return (-1);
 448
 449   int ADL_rc = adl->ADL_Overdrive_Caps (iAdapterIndex, od_supported, od_enabled, od_version);
 450
 451   return (ADL_rc);
 452 }
 453
 454 int hc_ADL_Overdrive6_PowerControl_Caps (ADL_PTR *adl, int iAdapterIndex, int *lpSupported)
 455 {
 456   if (!adl) return (-1);
 457
 458   int ADL_rc = adl->ADL_Overdrive6_PowerControl_Caps (iAdapterIndex, lpSupported);
 459
 460   return (ADL_rc);
 461 }
 462
 463 int hc_ADL_Overdrive_Capabilities_Get (ADL_PTR *adl, int iAdapterIndex, ADLOD6Capabilities *caps)
 464 {
 465   if (!adl) return (-1);
 466
 467   int ADL_rc = adl->ADL_Overdrive6_Capabilities_Get (iAdapterIndex, caps);
 468
 469   return (ADL_rc);
 470 }
 471
 472 int hc_ADL_Overdrive_StateInfo_Get (ADL_PTR *adl, int iAdapterIndex, int type, ADLOD6MemClockState *state)
 473 {
 474   if (!adl) return (-1);
 475
 476   int ADL_rc = adl->ADL_Overdrive6_StateInfo_Get (iAdapterIndex, type, state);
 477
 478   if (ADL_rc == ADL_OK)
 479   {
 480     // check if clocks are okay with step sizes
 481     // if not run a little hack: adjust the clocks to nearest clock size (clock down just a little bit)
 482
 483     ADLOD6Capabilities caps;
 484
 485     if ((hc_ADL_Overdrive_Capabilities_Get (adl, iAdapterIndex, &caps)) != ADL_OK)
 486     {
 487       log_info ("ERROR: failed to get ADL device capabilities");
 488
 489       exit (1);
 490     }
 491
 492     if (state->state.aLevels[0].iEngineClock % caps.sEngineClockRange.iStep != 0)
 493     {
 494       log_info ("WARN: ADL engine step size invalid for performance level 1");
 495       state->state.aLevels[0].iEngineClock -= state->state.aLevels[0].iEngineClock % caps.sEngineClockRange.iStep;
 496     }
 497
 498     if (state->state.aLevels[1].iEngineClock % caps.sEngineClockRange.iStep != 0)
 499     {
 500       log_info ("WARN: ADL engine step size invalid for performance level 2");
 501       state->state.aLevels[1].iEngineClock -= state->state.aLevels[1].iEngineClock % caps.sEngineClockRange.iStep;
 502     }
 503
 504     if (state->state.aLevels[0].iMemoryClock % caps.sMemoryClockRange.iStep != 0)
 505     {
 506       log_info ("WARN: ADL memory step size invalid for performance level 1");
 507       state->state.aLevels[0].iMemoryClock -= state->state.aLevels[0].iMemoryClock % caps.sMemoryClockRange.iStep;
 508     }
 509
 510     if (state->state.aLevels[1].iMemoryClock % caps.sMemoryClockRange.iStep != 0)
 511     {
 512       log_info ("WARN: ADL memory step size invalid for performance level 2");
 513       state->state.aLevels[1].iMemoryClock -= state->state.aLevels[1].iMemoryClock % caps.sMemoryClockRange.iStep;
 514     }
 515   }
 516
 517   return (ADL_rc);
 518 }
 519
 520 int hc_ADL_Overdrive_CurrentStatus_Get (ADL_PTR *adl, int iAdapterIndex, ADLOD6CurrentStatus *status)
 521 {
 522   if (!adl) return (-1);
 523
 524   int ADL_rc = adl->ADL_Overdrive6_CurrentStatus_Get (iAdapterIndex, status);
 525
 526   return (ADL_rc);
 527 }
 528
 529 int hc_ADL_Overdrive_State_Set (ADL_PTR *adl, int iAdapterIndex, int type, ADLOD6StateInfo *state)
 530 {
 531   if (!adl) return (-1);
 532
 533   // sanity checks
 534
 535   ADLOD6Capabilities caps;
 536
 537   if ((hc_ADL_Overdrive_Capabilities_Get (adl, iAdapterIndex, &caps)) != ADL_OK)
 538   {
 539     log_info ("ERROR: failed to get ADL device capabilities");
 540
 541     exit (1);
 542   }
 543
 544   if (state->aLevels[0].iEngineClock < caps.sEngineClockRange.iMin || state->aLevels[1].iEngineClock > caps.sEngineClockRange.iMax)
 545   {
 546     log_info ("WARN: ADL engine clock outside valid range");
 547
 548     return ADL_ERR;
 549   }
 550
 551   if (state->aLevels[1].iEngineClock % caps.sEngineClockRange.iStep != 0)
 552   {
 553     log_info ("WARN: ADL engine step size invalid");
 554
 555     return ADL_ERR;
 556   }
 557
 558   if (state->aLevels[0].iMemoryClock < caps.sMemoryClockRange.iMin || state->aLevels[1].iMemoryClock > caps.sMemoryClockRange.iMax)
 559   {
 560     log_info ("WARN: ADL memory clock outside valid range");
 561
 562     return ADL_ERR;
 563   }
 564
 565   if (state->aLevels[1].iMemoryClock % caps.sMemoryClockRange.iStep != 0)
 566   {
 567     log_info ("WARN: ADL memory step size invalid");
 568
 569     return ADL_ERR;
 570   }
 571
 572   int ADL_rc = adl->ADL_Overdrive6_State_Set (iAdapterIndex, type, state);
 573
 574   return (ADL_rc);
 575 }
 576
 577 int hc_ADL_Overdrive6_TargetTemperatureData_Get (ADL_PTR *adl, int iAdapterIndex, int *cur_temp, int *default_temp)
 578 {
 579   if (!adl) return (-1);
 580
 581   int ADL_rc = adl->ADL_Overdrive6_TargetTemperatureData_Get (iAdapterIndex, cur_temp, default_temp);
 582
 583   return (ADL_rc);
 584 }