/*

 

  This Source Code Form is subject to the terms of the Mozilla Public

  License, v. 2.0. If a copy of the MPL was not distributed with this

  file, You can obtain one at http://mozilla.org/MPL/2.0/.

 

  Copyright (C) 2009-2012 Michael Möller <mmoeller@openhardwaremonitor.org>

	Copyright (C) 2011 Christian Valličres

 

*/



using System;

using System.Runtime.InteropServices;

using System.Text;



namespace OpenHardwareMonitor.Hardware.Nvidia {



  internal enum NvStatus {

    OK = 0,

    ERROR = -1,

    LIBRARY_NOT_FOUND = -2,

    NO_IMPLEMENTATION = -3,

    API_NOT_INTIALIZED = -4,

    INVALID_ARGUMENT = -5,

    NVIDIA_DEVICE_NOT_FOUND = -6,

    END_ENUMERATION = -7,

    INVALID_HANDLE = -8,

    INCOMPATIBLE_STRUCT_VERSION = -9,

    HANDLE_INVALIDATED = -10,

    OPENGL_CONTEXT_NOT_CURRENT = -11,

    NO_GL_EXPERT = -12,

    INSTRUMENTATION_DISABLED = -13,

    EXPECTED_LOGICAL_GPU_HANDLE = -100,

    EXPECTED_PHYSICAL_GPU_HANDLE = -101,

    EXPECTED_DISPLAY_HANDLE = -102,

    INVALID_COMBINATION = -103,

    NOT_SUPPORTED = -104,

    PORTID_NOT_FOUND = -105,

    EXPECTED_UNATTACHED_DISPLAY_HANDLE = -106,

    INVALID_PERF_LEVEL = -107,

    DEVICE_BUSY = -108,

    NV_PERSIST_FILE_NOT_FOUND = -109,

    PERSIST_DATA_NOT_FOUND = -110,

    EXPECTED_TV_DISPLAY = -111,

    EXPECTED_TV_DISPLAY_ON_DCONNECTOR = -112,

    NO_ACTIVE_SLI_TOPOLOGY = -113,

    SLI_RENDERING_MODE_NOTALLOWED = -114,

    EXPECTED_DIGITAL_FLAT_PANEL = -115,

    ARGUMENT_EXCEED_MAX_SIZE = -116,

    DEVICE_SWITCHING_NOT_ALLOWED = -117,

    TESTING_CLOCKS_NOT_SUPPORTED = -118,

    UNKNOWN_UNDERSCAN_CONFIG = -119,

    TIMEOUT_RECONFIGURING_GPU_TOPO = -120,

    DATA_NOT_FOUND = -121,

    EXPECTED_ANALOG_DISPLAY = -122,

    NO_VIDLINK = -123,

    REQUIRES_REBOOT = -124,

    INVALID_HYBRID_MODE = -125,

    MIXED_TARGET_TYPES = -126,

    SYSWOW64_NOT_SUPPORTED = -127,

    IMPLICIT_SET_GPU_TOPOLOGY_CHANGE_NOT_ALLOWED = -128,

    REQUEST_USER_TO_CLOSE_NON_MIGRATABLE_APPS = -129,

    OUT_OF_MEMORY = -130,

    WAS_STILL_DRAWING = -131,

    FILE_NOT_FOUND = -132,

    TOO_MANY_UNIQUE_STATE_OBJECTS = -133,

    INVALID_CALL = -134,

    D3D10_1_LIBRARY_NOT_FOUND = -135,

    FUNCTION_NOT_FOUND = -136

  }



  internal enum NvThermalController {

    NONE = 0,

    GPU_INTERNAL,

    ADM1032,

    MAX6649,

    MAX1617,

    LM99,

    LM89,

    LM64,

    ADT7473,

    SBMAX6649,

    VBIOSEVT,

    OS,

    UNKNOWN = -1,

  }



  internal enum NvThermalTarget {

    NONE = 0,

    GPU = 1,

    MEMORY = 2,

    POWER_SUPPLY = 4,

    BOARD = 8,

    ALL = 15,

    UNKNOWN = -1

  };



  [StructLayout(LayoutKind.Sequential, Pack = 8)]

  internal struct NvSensor {

    public NvThermalController Controller;

    public uint DefaultMinTemp;

    public uint DefaultMaxTemp;

    public uint CurrentTemp;

    public NvThermalTarget Target;

  }



  [StructLayout(LayoutKind.Sequential, Pack = 8)]

  internal struct NvGPUThermalSettings {

    public uint Version;

    public uint Count;

    [MarshalAs(UnmanagedType.ByValArray,

      SizeConst = NVAPI.MAX_THERMAL_SENSORS_PER_GPU)]

    public NvSensor[] Sensor;

  }



  [StructLayout(LayoutKind.Sequential)]

  internal struct NvDisplayHandle {

    private readonly IntPtr ptr;

  }



  [StructLayout(LayoutKind.Sequential)]

  internal struct NvPhysicalGpuHandle {

    private readonly IntPtr ptr;

  }



  [StructLayout(LayoutKind.Sequential, Pack = 8)]

  internal struct NvClocks {

    public uint Version;

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = NVAPI.MAX_CLOCKS_PER_GPU)]

    public uint[] Clock;

  }



  [StructLayout(LayoutKind.Sequential, Pack = 8)]

  internal struct NvPState {

    public bool Present;

    public int Percentage;

  }



  [StructLayout(LayoutKind.Sequential, Pack = 8)]

  internal struct NvPStates {

    public uint Version;

    public uint Flags;

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = NVAPI.MAX_PSTATES_PER_GPU)]

    public NvPState[] PStates;

  }



  [StructLayout(LayoutKind.Sequential, Pack = 8)]

  internal struct NvUsages {

    public uint Version;

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = NVAPI.MAX_USAGES_PER_GPU)]

    public uint[] Usage;

  }



  [StructLayout(LayoutKind.Sequential, Pack = 8)]

  internal struct NvCooler {

    public int Type;

    public int Controller;

    public int DefaultMin;

    public int DefaultMax;

    public int CurrentMin;

    public int CurrentMax;

    public int CurrentLevel;

    public int DefaultPolicy;

    public int CurrentPolicy;

    public int Target;

    public int ControlType;

    public int Active;

  }



  [StructLayout(LayoutKind.Sequential, Pack = 8)]

  internal struct NvGPUCoolerSettings {

    public uint Version;

    public uint Count;

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = NVAPI.MAX_COOLER_PER_GPU)]

    public NvCooler[] Cooler;

  }



  [StructLayout(LayoutKind.Sequential, Pack = 8)]

  internal struct NvLevel {

    public int Level;

    public int Policy;

  }



  [StructLayout(LayoutKind.Sequential, Pack = 8)]

  internal struct NvGPUCoolerLevels {

    public uint Version;

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = NVAPI.MAX_COOLER_PER_GPU)]

    public NvLevel[] Levels;

  }



  [StructLayout(LayoutKind.Sequential, Pack = 8)]

  internal struct NvMemoryInfo {

    public uint Version;

    [MarshalAs(UnmanagedType.ByValArray, SizeConst =

      NVAPI.MAX_MEMORY_VALUES_PER_GPU)]

    public uint[] Values;

  }



  [StructLayout(LayoutKind.Sequential, Pack = 8)]

  internal struct NvDisplayDriverVersion {

    public uint Version;

    public uint DriverVersion;

    public uint BldChangeListNum;

    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = NVAPI.SHORT_STRING_MAX)]

    public string BuildBranch;

    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = NVAPI.SHORT_STRING_MAX)]

    public string Adapter;

  }



  internal class NVAPI {



    public const int MAX_PHYSICAL_GPUS = 64;

    public const int SHORT_STRING_MAX = 64;



    public const int MAX_THERMAL_SENSORS_PER_GPU = 3;

    public const int MAX_CLOCKS_PER_GPU = 0x120;

    public const int MAX_PSTATES_PER_GPU = 8;

    public const int MAX_USAGES_PER_GPU = 33;

    public const int MAX_COOLER_PER_GPU = 20;

    public const int MAX_MEMORY_VALUES_PER_GPU = 5;



    public static readonly uint GPU_THERMAL_SETTINGS_VER = (uint)

      Marshal.SizeOf(typeof(NvGPUThermalSettings)) | 0x10000;

    public static readonly uint GPU_CLOCKS_VER = (uint)

      Marshal.SizeOf(typeof(NvClocks)) | 0x20000;

    public static readonly uint GPU_PSTATES_VER = (uint)

      Marshal.SizeOf(typeof(NvPStates)) | 0x10000;

    public static readonly uint GPU_USAGES_VER = (uint)

      Marshal.SizeOf(typeof(NvUsages)) | 0x10000;

    public static readonly uint GPU_COOLER_SETTINGS_VER = (uint)

      Marshal.SizeOf(typeof(NvGPUCoolerSettings)) | 0x20000;

    public static readonly uint GPU_MEMORY_INFO_VER = (uint)

      Marshal.SizeOf(typeof(NvMemoryInfo)) | 0x20000;

    public static readonly uint DISPLAY_DRIVER_VERSION_VER = (uint)

      Marshal.SizeOf(typeof(NvDisplayDriverVersion)) | 0x10000;

    public static readonly uint GPU_COOLER_LEVELS_VER = (uint)

      Marshal.SizeOf(typeof(NvGPUCoolerLevels)) | 0x10000;



    private delegate IntPtr nvapi_QueryInterfaceDelegate(uint id);

    private delegate NvStatus NvAPI_InitializeDelegate();

    private delegate NvStatus NvAPI_GPU_GetFullNameDelegate(

      NvPhysicalGpuHandle gpuHandle, StringBuilder name);



    public delegate NvStatus NvAPI_GPU_GetThermalSettingsDelegate(

      NvPhysicalGpuHandle gpuHandle, int sensorIndex,

      ref NvGPUThermalSettings nvGPUThermalSettings);

    public delegate NvStatus NvAPI_EnumNvidiaDisplayHandleDelegate(int thisEnum,

      ref NvDisplayHandle displayHandle);

    public delegate NvStatus NvAPI_GetPhysicalGPUsFromDisplayDelegate(

      NvDisplayHandle displayHandle, [Out] NvPhysicalGpuHandle[] gpuHandles,

      out uint gpuCount);

    public delegate NvStatus NvAPI_EnumPhysicalGPUsDelegate(

      [Out] NvPhysicalGpuHandle[] gpuHandles, out int gpuCount);

    public delegate NvStatus NvAPI_GPU_GetTachReadingDelegate(

      NvPhysicalGpuHandle gpuHandle, out int value);

    public delegate NvStatus NvAPI_GPU_GetAllClocksDelegate(

      NvPhysicalGpuHandle gpuHandle, ref NvClocks nvClocks);

    public delegate NvStatus NvAPI_GPU_GetPStatesDelegate(

      NvPhysicalGpuHandle gpuHandle, ref NvPStates nvPStates);

    public delegate NvStatus NvAPI_GPU_GetUsagesDelegate(

      NvPhysicalGpuHandle gpuHandle, ref NvUsages nvUsages);

    public delegate NvStatus NvAPI_GPU_GetCoolerSettingsDelegate(

      NvPhysicalGpuHandle gpuHandle, int coolerIndex,

      ref NvGPUCoolerSettings nvGPUCoolerSettings);

    public delegate NvStatus NvAPI_GPU_SetCoolerLevelsDelegate(

      NvPhysicalGpuHandle gpuHandle, int coolerIndex,

      ref NvGPUCoolerLevels NvGPUCoolerLevels);

    public delegate NvStatus NvAPI_GPU_GetMemoryInfoDelegate(

      NvDisplayHandle displayHandle, ref NvMemoryInfo nvMemoryInfo);

    public delegate NvStatus NvAPI_GetDisplayDriverVersionDelegate(

      NvDisplayHandle displayHandle, [In, Out] ref NvDisplayDriverVersion

      nvDisplayDriverVersion);

    public delegate NvStatus NvAPI_GetInterfaceVersionStringDelegate(

      StringBuilder version);

    public delegate NvStatus NvAPI_GPU_GetPCIIdentifiersDelegate(

      NvPhysicalGpuHandle gpuHandle, out uint deviceId, out uint subSystemId, 

      out uint revisionId, out uint extDeviceId);



    private static readonly bool available;

    private static readonly nvapi_QueryInterfaceDelegate nvapi_QueryInterface;

    private static readonly NvAPI_InitializeDelegate NvAPI_Initialize;

    private static readonly NvAPI_GPU_GetFullNameDelegate

      _NvAPI_GPU_GetFullName;

    private static readonly NvAPI_GetInterfaceVersionStringDelegate

      _NvAPI_GetInterfaceVersionString;



    public static readonly NvAPI_GPU_GetThermalSettingsDelegate

      NvAPI_GPU_GetThermalSettings;

    public static readonly NvAPI_EnumNvidiaDisplayHandleDelegate

      NvAPI_EnumNvidiaDisplayHandle;

    public static readonly NvAPI_GetPhysicalGPUsFromDisplayDelegate

      NvAPI_GetPhysicalGPUsFromDisplay;

    public static readonly NvAPI_EnumPhysicalGPUsDelegate

      NvAPI_EnumPhysicalGPUs;

    public static readonly NvAPI_GPU_GetTachReadingDelegate

      NvAPI_GPU_GetTachReading;

    public static readonly NvAPI_GPU_GetAllClocksDelegate

      NvAPI_GPU_GetAllClocks;

    public static readonly NvAPI_GPU_GetPStatesDelegate

      NvAPI_GPU_GetPStates;

    public static readonly NvAPI_GPU_GetUsagesDelegate

      NvAPI_GPU_GetUsages;

    public static readonly NvAPI_GPU_GetCoolerSettingsDelegate

      NvAPI_GPU_GetCoolerSettings;

    public static readonly NvAPI_GPU_SetCoolerLevelsDelegate

      NvAPI_GPU_SetCoolerLevels;

    public static readonly NvAPI_GPU_GetMemoryInfoDelegate

      NvAPI_GPU_GetMemoryInfo;

    public static readonly NvAPI_GetDisplayDriverVersionDelegate

      NvAPI_GetDisplayDriverVersion;

    public static readonly NvAPI_GPU_GetPCIIdentifiersDelegate

      NvAPI_GPU_GetPCIIdentifiers;



    private NVAPI() { }



    public static NvStatus NvAPI_GPU_GetFullName(NvPhysicalGpuHandle gpuHandle,

      out string name) {

      StringBuilder builder = new StringBuilder(SHORT_STRING_MAX);

      NvStatus status;

      if (_NvAPI_GPU_GetFullName != null)

        status = _NvAPI_GPU_GetFullName(gpuHandle, builder);

      else

        status = NvStatus.FUNCTION_NOT_FOUND;

      name = builder.ToString();

      return status;

    }



    public static NvStatus NvAPI_GetInterfaceVersionString(out string version) {

      StringBuilder builder = new StringBuilder(SHORT_STRING_MAX);

      NvStatus status;

      if (_NvAPI_GetInterfaceVersionString != null)

        status = _NvAPI_GetInterfaceVersionString(builder);

      else

        status = NvStatus.FUNCTION_NOT_FOUND;

      version = builder.ToString();

      return status;

    }



    private static string GetDllName() {

      if (IntPtr.Size == 4) {

        return "nvapi.dll";

      } else {

        return "nvapi64.dll";

      }

    }



    private static void GetDelegate<T>(uint id, out T newDelegate)

      where T : class {

      IntPtr ptr = nvapi_QueryInterface(id);

      if (ptr != IntPtr.Zero) {

        newDelegate =

          Marshal.GetDelegateForFunctionPointer(ptr, typeof(T)) as T;

      } else {

        newDelegate = null;

      }

    }



    static NVAPI() {

      DllImportAttribute attribute = new DllImportAttribute(GetDllName());

      attribute.CallingConvention = CallingConvention.Cdecl;

      attribute.PreserveSig = true;

      attribute.EntryPoint = "nvapi_QueryInterface";

      PInvokeDelegateFactory.CreateDelegate(attribute,

        out nvapi_QueryInterface);



      try {

        GetDelegate(0x0150E828, out NvAPI_Initialize);

      } catch (DllNotFoundException) { return; } 

        catch (EntryPointNotFoundException) { return; } 

        catch (ArgumentNullException) { return; }



      if (NvAPI_Initialize() == NvStatus.OK) {

        GetDelegate(0xE3640A56, out NvAPI_GPU_GetThermalSettings);

        GetDelegate(0xCEEE8E9F, out _NvAPI_GPU_GetFullName);

        GetDelegate(0x9ABDD40D, out NvAPI_EnumNvidiaDisplayHandle);

        GetDelegate(0x34EF9506, out NvAPI_GetPhysicalGPUsFromDisplay);

        GetDelegate(0xE5AC921F, out NvAPI_EnumPhysicalGPUs);

        GetDelegate(0x5F608315, out NvAPI_GPU_GetTachReading);

        GetDelegate(0x1BD69F49, out NvAPI_GPU_GetAllClocks);

        GetDelegate(0x60DED2ED, out NvAPI_GPU_GetPStates);

        GetDelegate(0x189A1FDF, out NvAPI_GPU_GetUsages);

        GetDelegate(0xDA141340, out NvAPI_GPU_GetCoolerSettings);

        GetDelegate(0x891FA0AE, out NvAPI_GPU_SetCoolerLevels);

        GetDelegate(0x774AA982, out NvAPI_GPU_GetMemoryInfo);

        GetDelegate(0xF951A4D1, out NvAPI_GetDisplayDriverVersion);

        GetDelegate(0x01053FA5, out _NvAPI_GetInterfaceVersionString);

        GetDelegate(0x2DDFB66E, out NvAPI_GPU_GetPCIIdentifiers);



        available = true;

      }

    }



    public static bool IsAvailable {

      get { return available; }

    }



  }

}