Rooba
/
boinc
mirror of https://github.com/BOINC/boinc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
boinc/coprocs/NVIDIA/include/nvapi.h

1916 lines
94 KiB
C
Raw Blame History

/***************************************************************************\
|* *|
|* Copyright 2005-2008 NVIDIA Corporation. All rights reserved. *|
|* *|
|* NOTICE TO USER: *|
|* *|
|* This source code is subject to NVIDIA ownership rights under U.S. *|
|* and international Copyright laws. Users and possessors of this *|
|* source code are hereby granted a nonexclusive, royalty-free *|
|* license to use this code in individual and commercial software. *|
|* *|
|* NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS SOURCE *|
|* CODE FOR ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR *|
|* IMPLIED WARRANTY OF ANY KIND. NVIDIA DISCLAIMS ALL WARRANTIES WITH *|
|* REGARD TO THIS SOURCE CODE, INCLUDING ALL IMPLIED WARRANTIES OF *|
|* MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR *|
|* PURPOSE. IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, *|
|* INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES *|
|* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN *|
|* AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING *|
|* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOURCE *|
|* CODE. *|
|* *|
|* U.S. Government End Users. This source code is a "commercial item" *|
|* as that term is defined at 48 C.F.R. 2.101 (OCT 1995), consisting *|
|* of "commercial computer software" and "commercial computer software *|
|* documentation" as such terms are used in 48 C.F.R. 12.212 (SEPT 1995) *|
|* and is provided to the U.S. Government only as a commercial end item. *|
|* Consistent with 48 C.F.R.12.212 and 48 C.F.R. 227.7202-1 through *|
|* 227.7202-4 (JUNE 1995), all U.S. Government End Users acquire the *|
|* source code with only those rights set forth herein. *|
|* *|
|* Any use of this source code in individual and commercial software must *|
|* include, in the user documentation and internal comments to the code, *|
|* the above Disclaimer and U.S. Government End Users Notice. *|
|* *|
|* *|
\***************************************************************************/
///////////////////////////////////////////////////////////////////////////////
//
// Date: Aug 24, 2008
// File: nvapi.h
//
// NvAPI provides an interface to NVIDIA devices. This file contains the
// interface constants, structure definitions and function prototypes.
//
// Target Profile: developer
// Target OS-Arch: windows
//
///////////////////////////////////////////////////////////////////////////////
#ifndef _NVAPI_H
#define _NVAPI_H
#pragma pack(push,8) // Make sure we have consistent structure packings
#ifdef __cplusplus
extern "C" {
#endif
// ====================================================
// Universal NvAPI Definitions
// ====================================================
#ifndef _WIN32
#define __cdecl
#endif
#define NVAPI_INTERFACE extern NvAPI_Status __cdecl
/* 64-bit types for compilers that support them, plus some obsolete variants */
#if defined(__GNUC__) || defined(__arm) || defined(__IAR_SYSTEMS_ICC__) || defined(__ghs__) || defined(_WIN64)
typedef unsigned long long NvU64; /* 0 to 18446744073709551615 */
#else
typedef unsigned __int64 NvU64; /* 0 to 18446744073709551615 */
#endif
// mac os 32-bit still needs this
#if (defined(macintosh) || defined(__APPLE__)) && !defined(__LP64__)
typedef signed long NvS32; /* -2147483648 to 2147483647 */
#else
typedef signed int NvS32; /* -2147483648 to 2147483647 */
#endif
typedef unsigned long NvU32;
typedef unsigned short NvU16;
typedef unsigned char NvU8;
#define NV_DECLARE_HANDLE(name) struct name##__ { int unused; }; typedef struct name##__ *name
// NVAPI Handles - These handles are retrieved from various calls and passed in to others in NvAPI
// These are meant to be opaque types. Do not assume they correspond to indices, HDCs,
// display indexes or anything else.
//
// Most handles remain valid until a display re-configuration (display mode set) or GPU
// reconfiguration (going into or out of SLI modes) occurs. If NVAPI_HANDLE_INVALIDATED
// is received by an app, it should discard all handles, and re-enumerate them.
//
NV_DECLARE_HANDLE(NvDisplayHandle); // Display Device driven by NVIDIA GPU(s) (an attached display)
NV_DECLARE_HANDLE(NvUnAttachedDisplayHandle); // Unattached Display Device driven by NVIDIA GPU(s)
NV_DECLARE_HANDLE(NvLogicalGpuHandle); // One or more physical GPUs acting in concert (SLI)
NV_DECLARE_HANDLE(NvPhysicalGpuHandle); // A single physical GPU
NV_DECLARE_HANDLE(NvEventHandle); // A handle to an event registration instance
#define NVAPI_DEFAULT_HANDLE 0
#define NVAPI_GENERIC_STRING_MAX 4096
#define NVAPI_LONG_STRING_MAX 256
#define NVAPI_SHORT_STRING_MAX 64
typedef struct
{
NvS32 sX;
NvS32 sY;
NvS32 sWidth;
NvS32 sHeight;
} NvSBox;
#define NVAPI_MAX_PHYSICAL_GPUS 64
#define NVAPI_MAX_LOGICAL_GPUS 64
#define NVAPI_MAX_AVAILABLE_GPU_TOPOLOGIES 256
#define NVAPI_MAX_GPU_TOPOLOGIES NVAPI_MAX_PHYSICAL_GPUS
#define NVAPI_MAX_GPU_PER_TOPOLOGY 8
#define NVAPI_MAX_DISPLAY_HEADS 2
#define NVAPI_MAX_DISPLAYS NVAPI_MAX_PHYSICAL_GPUS * NVAPI_MAX_DISPLAY_HEADS
#define NV_MAX_HEADS 4 // Maximum heads, each with NVAPI_DESKTOP_RES resolution
#define NV_MAX_VID_STREAMS 4 // Maximum input video streams, each with a NVAPI_VIDEO_SRC_INFO
#define NV_MAX_VID_PROFILES 4 // Maximum output video profiles supported
typedef char NvAPI_String[NVAPI_GENERIC_STRING_MAX];
typedef char NvAPI_LongString[NVAPI_LONG_STRING_MAX];
typedef char NvAPI_ShortString[NVAPI_SHORT_STRING_MAX];
// =========================================================================================
// NvAPI Version Definition
// Maintain per structure specific version define using the MAKE_NVAPI_VERSION macro.
// Usage: #define NV_GENLOCK_STATUS_VER MAKE_NVAPI_VERSION(NV_GENLOCK_STATUS, 1)
// =========================================================================================
#define MAKE_NVAPI_VERSION(typeName,ver) (NvU32)(sizeof(typeName) | ((ver)<<16))
#define GET_NVAPI_VERSION(ver) (NvU32)((ver)>>16)
#define GET_NVAPI_SIZE(ver) (NvU32)((ver) & 0xffff)
// ====================================================
// NvAPI Status Values
// All NvAPI functions return one of these codes.
// ====================================================
typedef enum
{
NVAPI_OK = 0, // Success
NVAPI_ERROR = -1, // Generic error
NVAPI_LIBRARY_NOT_FOUND = -2, // nvapi.dll can not be loaded
NVAPI_NO_IMPLEMENTATION = -3, // not implemented in current driver installation
NVAPI_API_NOT_INTIALIZED = -4, // NvAPI_Initialize has not been called (successfully)
NVAPI_INVALID_ARGUMENT = -5, // invalid argument
NVAPI_NVIDIA_DEVICE_NOT_FOUND = -6, // no NVIDIA display driver was found
NVAPI_END_ENUMERATION = -7, // no more to enum
NVAPI_INVALID_HANDLE = -8, // invalid handle
NVAPI_INCOMPATIBLE_STRUCT_VERSION = -9, // an argument's structure version is not supported
NVAPI_HANDLE_INVALIDATED = -10, // handle is no longer valid (likely due to GPU or display re-configuration)
NVAPI_OPENGL_CONTEXT_NOT_CURRENT = -11, // no NVIDIA OpenGL context is current (but needs to be)
NVAPI_NO_GL_EXPERT = -12, // OpenGL Expert is not supported by the current drivers
NVAPI_INSTRUMENTATION_DISABLED = -13, // OpenGL Expert is supported, but driver instrumentation is currently disabled
NVAPI_EXPECTED_LOGICAL_GPU_HANDLE = -100, // expected a logical GPU handle for one or more parameters
NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE = -101, // expected a physical GPU handle for one or more parameters
NVAPI_EXPECTED_DISPLAY_HANDLE = -102, // expected an NV display handle for one or more parameters
NVAPI_INVALID_COMBINATION = -103, // used in some commands to indicate that the combination of parameters is not valid
NVAPI_NOT_SUPPORTED = -104, // Requested feature not supported in the selected GPU
NVAPI_PORTID_NOT_FOUND = -105, // NO port ID found for I2C transaction
NVAPI_EXPECTED_UNATTACHED_DISPLAY_HANDLE = -106, // expected an unattached display handle as one of the input param
NVAPI_INVALID_PERF_LEVEL = -107, // invalid perf level
NVAPI_DEVICE_BUSY = -108, // device is busy, request not fulfilled
NVAPI_NV_PERSIST_FILE_NOT_FOUND = -109, // NV persist file is not found
NVAPI_PERSIST_DATA_NOT_FOUND = -110, // NV persist data is not found
NVAPI_EXPECTED_TV_DISPLAY = -111, // expected TV output display
NVAPI_EXPECTED_TV_DISPLAY_ON_DCONNECTOR = -112, // expected TV output on D Connector - HDTV_EIAJ4120.
NVAPI_NO_ACTIVE_SLI_TOPOLOGY = -113, // SLI is not active on this device
NVAPI_SLI_RENDERING_MODE_NOTALLOWED = -114, // setup of SLI rendering mode is not possible right now
NVAPI_EXPECTED_DIGITAL_FLAT_PANEL = -115, // expected digital flat panel
NVAPI_ARGUMENT_EXCEED_MAX_SIZE = -116, // argument exceeds expected size
NVAPI_DEVICE_SWITCHING_NOT_ALLOWED = -117, // inhibit ON due to one of the flags in NV_GPU_DISPLAY_CHANGE_INHIBIT or SLI Active
NVAPI_TESTING_CLOCKS_NOT_SUPPORTED = -118, // testing clocks not supported
NVAPI_UNKNOWN_UNDERSCAN_CONFIG = -119, // the specified underscan config is from an unknown source (e.g. INF)
NVAPI_TIMEOUT_RECONFIGURING_GPU_TOPO = -120, // timeout while reconfiguring GPUs
NVAPI_DATA_NOT_FOUND = -121, // Requested data was not found
NVAPI_EXPECTED_ANALOG_DISPLAY = -122, // expected analog display
NVAPI_NO_VIDLINK = -123, // No SLI video bridge present
NVAPI_REQUIRES_REBOOT = -124, // NVAPI requires reboot for its settings to take effect
NVAPI_INVALID_HYBRID_MODE = -125, // the function is not supported with the current hybrid mode.
NVAPI_MIXED_TARGET_TYPES = -126, // The target types are not all the same
NVAPI_SYSWOW64_NOT_SUPPORTED = -127, // the function is not supported from 32-bit on a 64-bit system
NVAPI_IMPLICIT_SET_GPU_TOPOLOGY_CHANGE_NOT_ALLOWED = -128, //there is any implicit GPU topo active. Use NVAPI_SetHybridMode to change topology.
NVAPI_REQUEST_USER_TO_CLOSE_NON_MIGRATABLE_APPS = -129, //Prompt the user to close all non-migratable apps.
NVAPI_OUT_OF_MEMORY = -130, // Could not allocate sufficient memory to complete the call
NVAPI_WAS_STILL_DRAWING = -131, // The previous operation that is transferring information to or from this surface is incomplete
NVAPI_FILE_NOT_FOUND = -132, // The file was not found
NVAPI_TOO_MANY_UNIQUE_STATE_OBJECTS = -133, // There are too many unique instances of a particular type of state object
NVAPI_INVALID_CALL = -134, // The method call is invalid. For example, a method's parameter may not be a valid pointer
NVAPI_D3D10_1_LIBRARY_NOT_FOUND = -135, // d3d10_1.dll can not be loaded
NVAPI_FUNCTION_NOT_FOUND = -136, // Couldn't find the function in loaded dll library
} NvAPI_Status;
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_Initialize
//
// DESCRIPTION: Initializes NVAPI library. This must be called before any
// other NvAPI_ function.
//
// SUPPORTED OS: Mac OS X, Windows XP and higher
//
// RETURN STATUS: NVAPI_ERROR Something is wrong during the initialization process (generic error)
// NVAPI_LIBRARYNOTFOUND Can not load nvapi.dll
// NVAPI_OK Initialized
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_Initialize();
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GetErrorMessage
//
// DESCRIPTION: converts an NvAPI error code into a null terminated string
//
// SUPPORTED OS: Mac OS X, Windows XP and higher
//
// RETURN STATUS: null terminated string (always, never NULL)
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GetErrorMessage(NvAPI_Status nr,NvAPI_ShortString szDesc);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GetInterfaceVersionString
//
// DESCRIPTION: Returns a string describing the version of the NvAPI library.
// Contents of the string are human readable. Do not assume a fixed
// format.
//
// SUPPORTED OS: Mac OS X, Windows XP and higher
//
// RETURN STATUS: User readable string giving info on NvAPI's version
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GetInterfaceVersionString(NvAPI_ShortString szDesc);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GetDisplayDriverVersion
//
// DESCRIPTION: Returns a struct that describes aspects of the display driver
// build.
//
// SUPPORTED OS: Mac OS X, Windows XP and higher
//
// RETURN STATUS: NVAPI_ERROR or NVAPI_OK
//
///////////////////////////////////////////////////////////////////////////////
typedef struct
{
NvU32 version; // Structure version
NvU32 drvVersion;
NvU32 bldChangeListNum;
NvAPI_ShortString szBuildBranchString;
NvAPI_ShortString szAdapterString;
} NV_DISPLAY_DRIVER_VERSION;
#define NV_DISPLAY_DRIVER_VERSION_VER MAKE_NVAPI_VERSION(NV_DISPLAY_DRIVER_VERSION,1)
NVAPI_INTERFACE NvAPI_GetDisplayDriverVersion(NvDisplayHandle hNvDisplay, NV_DISPLAY_DRIVER_VERSION *pVersion);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_EnumNvidiaDisplayHandle
//
// DESCRIPTION: Returns the handle of the NVIDIA display specified by the enum
// index (thisEnum). The client should keep enumerating until it
// returns NVAPI_END_ENUMERATION.
//
// Note: Display handles can get invalidated on a modeset, so the calling applications need to
// renum the handles after every modeset.
//
// SUPPORTED OS: Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: either the handle pointer is NULL or enum index too big
// NVAPI_OK: return a valid NvDisplayHandle based on the enum index
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA device found in the system
// NVAPI_END_ENUMERATION: no more display device to enumerate.
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_EnumNvidiaDisplayHandle(NvU32 thisEnum, NvDisplayHandle *pNvDispHandle);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_EnumNvidiaUnAttachedDisplayHandle
//
// DESCRIPTION: Returns the handle of the NVIDIA UnAttached display specified by the enum
// index (thisEnum). The client should keep enumerating till it
// return error.
//
// Note: Display handles can get invalidated on a modeset, so the calling applications need to
// renum the handles after every modeset.
//
// SUPPORTED OS: Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: either the handle pointer is NULL or enum index too big
// NVAPI_OK: return a valid NvDisplayHandle based on the enum index
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA device found in the system
// NVAPI_END_ENUMERATION: no more display device to enumerate.
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_EnumNvidiaUnAttachedDisplayHandle(NvU32 thisEnum, NvUnAttachedDisplayHandle *pNvUnAttachedDispHandle);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_EnumPhysicalGPUs
//
// DESCRIPTION: Returns an array of physical GPU handles.
//
// Each handle represents a physical GPU present in the system.
// That GPU may be part of a SLI configuration, or not be visible to the OS directly.
//
// At least 1 GPU must be present in the system and running an NV display driver.
//
// The array nvGPUHandle will be filled with physical GPU handle values. The returned
// gpuCount determines how many entries in the array are valid.
//
// Note: In drivers older than 105.00, all physical GPU handles get invalidated on a modeset. So the calling applications
// need to renum the handles after every modeset.
// With drivers 105.00 and up all physical GPU handles are constant.
// Physical GPU handles are constant as long as the GPUs are not physically moved and the SBIOS VGA order is unchanged.
//
// SUPPORTED OS: Mac OS X, Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: nvGPUHandle or pGpuCount is NULL
// NVAPI_OK: one or more handles were returned
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_EnumPhysicalGPUs(NvPhysicalGpuHandle nvGPUHandle[NVAPI_MAX_PHYSICAL_GPUS], NvU32 *pGpuCount);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_EnumLogicalGPUs
//
// DESCRIPTION: Returns an array of logical GPU handles.
//
// Each handle represents one or more GPUs acting in concert as a single graphics device.
//
// At least 1 GPU must be present in the system and running an NV display driver.
//
// The array nvGPUHandle will be filled with logical GPU handle values. The returned
// gpuCount determines how many entries in the array are valid.
//
// Note: All logical GPUs handles get invalidated on a GPU topology change, so the calling application is required to
// renum the logical GPU handles to get latest physical handle mapping after every GPU topology change activated
// by a call to NvAPI_SetGpuTopologies.
//
// To detect if SLI rendering is enabled please use NvAPI_D3D_GetCurrentSLIState
//
// SUPPORTED OS: Mac OS X, Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: nvGPUHandle or pGpuCount is NULL
// NVAPI_OK: one or more handles were returned
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_EnumLogicalGPUs(NvLogicalGpuHandle nvGPUHandle[NVAPI_MAX_LOGICAL_GPUS], NvU32 *pGpuCount);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GetPhysicalGPUsFromDisplay
//
// DESCRIPTION: Returns an array of physical GPU handles associated with the specified display.
//
// At least 1 GPU must be present in the system and running an NV display driver.
//
// The array nvGPUHandle will be filled with physical GPU handle values. The returned
// gpuCount determines how many entries in the array are valid.
//
// If the display corresponds to more than one physical GPU, the first GPU returned
// is the one with the attached active output.
//
// SUPPORTED OS: Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: hNvDisp is not valid; nvGPUHandle or pGpuCount is NULL
// NVAPI_OK: one or more handles were returned
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GetPhysicalGPUsFromDisplay(NvDisplayHandle hNvDisp, NvPhysicalGpuHandle nvGPUHandle[NVAPI_MAX_PHYSICAL_GPUS], NvU32 *pGpuCount);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GetPhysicalGPUFromUnAttachedDisplay
//
// DESCRIPTION: Returns a physical GPU handle associated with the specified unattached display.
//
// At least 1 GPU must be present in the system and running an NV display driver.
//
// SUPPORTED OS: Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: hNvUnAttachedDisp is not valid or pPhysicalGpu is NULL.
// NVAPI_OK: one or more handles were returned
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GetPhysicalGPUFromUnAttachedDisplay(NvUnAttachedDisplayHandle hNvUnAttachedDisp, NvPhysicalGpuHandle *pPhysicalGpu);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_CreateDisplayFromUnAttachedDisplay
//
// DESCRIPTION: The unattached display handle is converted to a active attached display handle.
//
// At least 1 GPU must be present in the system and running an NV display driver.
//
// SUPPORTED OS: Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: hNvUnAttachedDisp is not valid or pNvDisplay is NULL.
// NVAPI_OK: one or more handles were returned
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_CreateDisplayFromUnAttachedDisplay(NvUnAttachedDisplayHandle hNvUnAttachedDisp, NvDisplayHandle *pNvDisplay);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GetLogicalGPUFromDisplay
//
// DESCRIPTION: Returns the logical GPU handle associated with the specified display.
//
// At least 1 GPU must be present in the system and running an NV display driver.
//
// SUPPORTED OS: Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: hNvDisp is not valid; pLogicalGPU is NULL
// NVAPI_OK: one or more handles were returned
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GetLogicalGPUFromDisplay(NvDisplayHandle hNvDisp, NvLogicalGpuHandle *pLogicalGPU);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GetLogicalGPUFromPhysicalGPU
//
// DESCRIPTION: Returns the logical GPU handle associated with specified physical GPU handle.
//
// At least 1 GPU must be present in the system and running an NV display driver.
//
// SUPPORTED OS: Mac OS X, Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: hPhysicalGPU is not valid; pLogicalGPU is NULL
// NVAPI_OK: one or more handles were returned
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GetLogicalGPUFromPhysicalGPU(NvPhysicalGpuHandle hPhysicalGPU, NvLogicalGpuHandle *pLogicalGPU);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GetPhysicalGPUsFromLogicalGPU
//
// DESCRIPTION: Returns the physical GPU handles associated with the specified logical GPU handle.
//
// At least 1 GPU must be present in the system and running an NV display driver.
//
// The array hPhysicalGPU will be filled with physical GPU handle values. The returned
// gpuCount determines how many entries in the array are valid.
//
// SUPPORTED OS: Mac OS X, Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: hLogicalGPU is not valid; hPhysicalGPU is NULL
// NVAPI_OK: one or more handles were returned
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found
// NVAPI_EXPECTED_LOGICAL_GPU_HANDLE: hLogicalGPU was not a logical GPU handle
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GetPhysicalGPUsFromLogicalGPU(NvLogicalGpuHandle hLogicalGPU,NvPhysicalGpuHandle hPhysicalGPU[NVAPI_MAX_PHYSICAL_GPUS], NvU32 *pGpuCount);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GetAssociatedNvidiaDisplayHandle
//
// DESCRIPTION: Returns the handle of the NVIDIA display that is associated
// with the display name given. Eg: "\\DISPLAY1"
//
// SUPPORTED OS: Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: either argument is NULL
// NVAPI_OK: *pNvDispHandle is now valid
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA device maps to that display name
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GetAssociatedNvidiaDisplayHandle(const char *szDisplayName, NvDisplayHandle *pNvDispHandle);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GetAssociatedNvidiaDisplayName
//
// DESCRIPTION: Returns the display name given. Eg: "\\DISPLAY1" using the NVIDIA display handle
//
// SUPPORTED OS: Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: either argument is NULL
// NVAPI_OK: *pNvDispHandle is now valid
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA device maps to that display name
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GetAssociatedNvidiaDisplayName(NvDisplayHandle NvDispHandle, NvAPI_ShortString szDisplayName);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GetUnAttachedAssociatedDisplayName
//
// DESCRIPTION: Returns the display name given. Eg: "\\DISPLAY1" using the NVIDIA unattached display handle
//
// SUPPORTED OS: Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: either argument is NULL
// NVAPI_OK: *pNvDispHandle is now valid
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA device maps to that display name
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GetUnAttachedAssociatedDisplayName(NvUnAttachedDisplayHandle hNvUnAttachedDisp, NvAPI_ShortString szDisplayName);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_EnableHWCursor
//
// DESCRIPTION: Enable hardware cursor support
//
// SUPPORTED OS: Windows XP
//
// RETURN STATUS: NVAPI_ERROR or NVAPI_OK
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_EnableHWCursor(NvDisplayHandle hNvDisplay);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_DisableHWCursor
//
// DESCRIPTION: Disable hardware cursor support
//
// SUPPORTED OS: Windows XP and higher
//
// RETURN STATUS: NVAPI_ERROR or NVAPI_OK
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_DisableHWCursor(NvDisplayHandle hNvDisplay);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GetVBlankCounter
//
// DESCRIPTION: get vblank counter
//
// SUPPORTED OS: Windows XP and higher
//
// RETURN STATUS: NVAPI_ERROR or NVAPI_OK
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GetVBlankCounter(NvDisplayHandle hNvDisplay, NvU32 *pCounter);
///////////////////////////////////////////////////////////////////////////////
// FUNCTION NAME: NvAPI_SetRefreshRateOverride
// DESCRIPTION: Override the refresh rate on the given display/outputsMask.
// The new refresh rate can be applied right away in this API call or deferred to happen with the
// next OS modeset. The override is only good for one modeset (doesn't matter it's deferred or immediate).
//
// SUPPORTED OS: Windows XP
//
//
// INPUT: hNvDisplay - the NVIDIA display handle. It can be NVAPI_DEFAULT_HANDLE or a handle
// enumerated from NvAPI_EnumNVidiaDisplayHandle().
//
// outputsMask - a set of bits that identify all target outputs which are associated with the NVIDIA
// display handle to apply the refresh rate override. Note when SLI is enabled, the
// outputsMask only applies to the GPU that is driving the display output.
//
// refreshRate - the override value. "0.0" means cancel the override.
//
//
// bSetDeferred - "0": apply the refresh rate override immediately in this API call.
// "1": apply refresh rate at the next OS modeset.
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: hNvDisplay or outputsMask is invalid
// NVAPI_OK: the refresh rate override is correct set
// NVAPI_ERROR: the operation failed
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_SetRefreshRateOverride(NvDisplayHandle hNvDisplay, NvU32 outputsMask, float refreshRate, NvU32 bSetDeferred);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GetAssociatedDisplayOutputId
//
// DESCRIPTION: Gets the active outputId associated with the display handle.
//
// SUPPORTED OS: Windows XP and higher
//
// PARAMETERS: hNvDisplay(IN) - NVIDIA Display selection. It can be NVAPI_DEFAULT_HANDLE or a handle enumerated from NvAPI_EnumNVidiaDisplayHandle().
// outputId(OUT) - The active display output id associated with the selected display handle hNvDisplay.
// The outputid will have only one bit set. In case of clone or span this will indicate the display
// outputId of the primary display that the GPU is driving.
// RETURN STATUS: NVAPI_OK: call successful.
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found.
// NVAPI_EXPECTED_DISPLAY_HANDLE: hNvDisplay is not a valid display handle.
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GetAssociatedDisplayOutputId(NvDisplayHandle hNvDisplay, NvU32 *pOutputId);
///////////////////////////////////////////////////////////////////////////////
// FUNCTION NAME: NvAPI_GetDisplayPortInfo
//
// DESCRIPTION: This API returns the current DP related into on the specified device(monitor)
//
// SUPPORTED OS: Windows XP and higher
//
// PARAMETERS: hNvDisplay(IN) - NVIDIA Display selection. It can be NVAPI_DEFAULT_HANDLE or a handle enumerated from NvAPI_EnumNVidiaDisplayHandle().
// outputId(IN) - The display output id. If it's "0" then the default outputId from NvAPI_GetAssociatedDisplayOutputId() will be used.
// pInfo(OUT) - The display port info
//
// RETURN STATUS:
// NVAPI_OK - completed request
// NVAPI_ERROR - miscellaneous error occurred
// NVAPI_INVALID_ARGUMENT: Invalid input parameter.
//
///////////////////////////////////////////////////////////////////////////////
typedef enum
{
NV_DP_1_62GBPS = 6,
NV_DP_2_70GBPS = 0xA,
} NV_DP_LINK_RATE;
typedef enum
{
NV_DP_1_LANE = 1,
NV_DP_2_LANE = 2,
NV_DP_4_LANE = 4,
} NV_DP_LANE_COUNT;
typedef enum
{
NV_DP_COLOR_FORMAT_RGB = 0,
NV_DP_COLOR_FORMAT_YCbCr422,
NV_DP_COLOR_FORMAT_YCbCr444,
} NV_DP_COLOR_FORMAT;
typedef enum
{
NV_DP_COLORIMETRY_RGB = 0,
NV_DP_COLORIMETRY_YCbCr_ITU601,
NV_DP_COLORIMETRY_YCbCr_ITU709,
} NV_DP_COLORIMETRY;
typedef enum
{
NV_DP_DYNAMIC_RANGE_VESA = 0,
NV_DP_DYNAMIC_RANGE_CEA,
} NV_DP_DYNAMIC_RANGE;
typedef enum
{
NV_DP_BPC_DEFAULT = 0,
NV_DP_BPC_6,
NV_DP_BPC_8,
NV_DP_BPC_10,
NV_DP_BPC_12,
NV_DP_BPC_16,
} NV_DP_BPC;
typedef struct
{
NvU32 version; // structure version
NvU32 dpcd_ver; // the DPCD version of the monitor
NV_DP_LINK_RATE maxLinkRate; // the max supported link rate
NV_DP_LANE_COUNT maxLaneCount; // the max supported lane count
NV_DP_LINK_RATE curLinkRate; // the current link rate
NV_DP_LANE_COUNT curLaneCount; // the current lane count
NV_DP_COLOR_FORMAT colorFormat; // the current color format
NV_DP_DYNAMIC_RANGE dynamicRange; // the dynamic range
NV_DP_COLORIMETRY colorimetry; // ignored in RGB space
NV_DP_BPC bpc; // the current bit-per-component;
NvU32 isDp : 1; // if the monitor is driven by display port
NvU32 isInternalDp : 1; // if the monitor is driven by NV Dp transmitter
NvU32 isColorCtrlSupported : 1; // if the color format change is supported
NvU32 is6BPCSupported : 1; // if 6 bpc is supported
NvU32 is8BPCSupported : 1; // if 8 bpc is supported
NvU32 is10BPCSupported : 1; // if 10 bpc is supported
NvU32 is12BPCSupported : 1; // if 12 bpc is supported
NvU32 is16BPCSupported : 1; // if 16 bpc is supported
} NV_DISPLAY_PORT_INFO;
#define NV_DISPLAY_PORT_INFO_VER MAKE_NVAPI_VERSION(NV_DISPLAY_PORT_INFO,1)
NVAPI_INTERFACE NvAPI_GetDisplayPortInfo(NvDisplayHandle hNvDisplay, NvU32 outputId, NV_DISPLAY_PORT_INFO *pInfo);
///////////////////////////////////////////////////////////////////////////////
// FUNCTION NAME: NvAPI_SetDisplayPort
//
// DESCRIPTION: This API is used to setup DP related configurations.
//
// SUPPORTED OS: Windows XP and higher
//
// PARAMETERS: hNvDisplay(IN) - NVIDIA display handle. It can be NVAPI_DEFAULT_HANDLE or a handle enumerated from NvAPI_EnumNVidiaDisplayHandle().
// outputId(IN) - This display output ID, when it's "0" it means the default outputId generated from the return of NvAPI_GetAssociatedDisplayOutputId().
// pCfg(IN) - The display port config structure. If pCfg is NULL, it means to use the driver's default value to setup.
//
// RETURN STATUS:
// NVAPI_OK - completed request
// NVAPI_ERROR - miscellaneous error occurred
// NVAPI_INVALID_ARGUMENT: Invalid input parameter.
///////////////////////////////////////////////////////////////////////////////
typedef struct
{
NvU32 version; // structure version - 2 is latest
NV_DP_LINK_RATE linkRate; // the link rate
NV_DP_LANE_COUNT laneCount; // the lane count
NV_DP_COLOR_FORMAT colorFormat; // the color format to set
NV_DP_DYNAMIC_RANGE dynamicRange; // the dynamic range
NV_DP_COLORIMETRY colorimetry; // ignored in RGB space
NV_DP_BPC bpc; // the current bit-per-component;
NvU32 isHPD : 1; // if CPL is making this call due to HPD
NvU32 isSetDeferred : 1; // requires an OS modeset to finalize the setup if set
NvU32 isChromaLpfOff : 1; // force the chroma low_pass_filter to be off
NvU32 isDitherOff : 1; // force to turn off dither
} NV_DISPLAY_PORT_CONFIG;
#define NV_DISPLAY_PORT_CONFIG_VER MAKE_NVAPI_VERSION(NV_DISPLAY_PORT_CONFIG,2)
#define NV_DISPLAY_PORT_CONFIG_VER_1 MAKE_NVAPI_VERSION(NV_DISPLAY_PORT_CONFIG,1)
#define NV_DISPLAY_PORT_CONFIG_VER_2 MAKE_NVAPI_VERSION(NV_DISPLAY_PORT_CONFIG,2)
NVAPI_INTERFACE NvAPI_SetDisplayPort(NvDisplayHandle hNvDisplay, NvU32 outputId, NV_DISPLAY_PORT_CONFIG *pCfg);
///////////////////////////////////////////////////////////////////////////////
// FUNCTION NAME: NvAPI_GetHDMISupportInfo
//
// DESCRIPTION: This API returns the current infoframe data on the specified device(monitor)
//
// SUPPORTED OS: Windows Vista and higher
//
// PARAMETERS: hNvDisplay(IN) - NVIDIA Display selection. It can be NVAPI_DEFAULT_HANDLE or a handle enumerated from NvAPI_EnumNVidiaDisplayHandle().
// outputId(IN) - The display output id. If it's "0" then the default outputId from NvAPI_GetAssociatedDisplayOutputId() will be used.
// pInfo(OUT) - The monitor and GPU's HDMI support info
//
// RETURN STATUS:
// NVAPI_OK - completed request
// NVAPI_ERROR - miscellaneous error occurred
// NVAPI_INVALID_ARGUMENT: Invalid input parameter.
//
///////////////////////////////////////////////////////////////////////////////
typedef struct
{
NvU32 version; // structure version
NvU32 isGpuHDMICapable : 1; // if the GPU can handle HDMI
NvU32 isMonUnderscanCapable : 1; // if the monitor supports underscan
NvU32 isMonBasicAudioCapable : 1; // if the monitor supports basic audio
NvU32 isMonYCbCr444Capable : 1; // if YCbCr 4:4:4 is supported
NvU32 isMonYCbCr422Capable : 1; // if YCbCr 4:2:2 is supported
NvU32 isMonxvYCC601Capable : 1; // if xvYCC 601 is supported
NvU32 isMonxvYCC709Capable : 1; // if xvYCC 709 is supported
NvU32 isMonHDMI : 1; // if the monitor is HDMI (with IEEE's HDMI registry ID)
NvU32 EDID861ExtRev; // the revision number of the EDID 861 extension
} NV_HDMI_SUPPORT_INFO;
#define NV_HDMI_SUPPORT_INFO_VER MAKE_NVAPI_VERSION(NV_HDMI_SUPPORT_INFO,1)
NVAPI_INTERFACE NvAPI_GetHDMISupportInfo(NvDisplayHandle hNvDisplay, NvU32 outputId, NV_HDMI_SUPPORT_INFO *pInfo);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GPU_GetAllOutputs
//
// DESCRIPTION: Returns set of all GPU-output identifiers as a bitmask.
//
// SUPPORTED OS: Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: hPhysicalGpu or pOutputsMask is NULL
// NVAPI_OK: *pOutputsMask contains a set of GPU-output identifiers
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found
// NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: hPhysicalGpu was not a physical GPU handle
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GPU_GetAllOutputs(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pOutputsMask);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GPU_GetConnectedOutputs
//
// DESCRIPTION: Same as NvAPI_GPU_GetAllOutputs but returns only the set of GPU-output
// identifiers that are connected to display devices.
//
// SUPPORTED OS: Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: hPhysicalGpu or pOutputsMask is NULL
// NVAPI_OK: *pOutputsMask contains a set of GPU-output identifiers
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found
// NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: hPhysicalGpu was not a physical GPU handle
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GPU_GetConnectedOutputs(NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pOutputsMask);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GPU_GetConnectedSLIOutputs
//
// DESCRIPTION: Same as NvAPI_GPU_GetConnectedOutputs but returns only the set of GPU-output
// identifiers that can be selected in an SLI configuration. With SLI disabled
// this function matches NvAPI_GPU_GetConnectedOutputs
//
// SUPPORTED OS: Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: hPhysicalGpu or pOutputsMask is NULL
// NVAPI_OK: *pOutputsMask contains a set of GPU-output identifiers
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found
// NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: hPhysicalGpu was not a physical GPU handle
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GPU_GetConnectedSLIOutputs(NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pOutputsMask);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GPU_GetConnectedOutputsWithLidState
//
// DESCRIPTION: Similar to NvAPI_GPU_GetConnectedOutputs this API returns the connected display identifiers that are connected
// as a output mask but unlike NvAPI_GPU_GetConnectedOutputs this API "always" reflects the Lid State in the output mask.
// Thus if you expect the LID close state to be available in the connection mask use this API.
// If LID is closed then this API will remove the LID panel from the connected display identifiers.
// If LID is open then this API will reflect the LID panel in the connected display identifiers.
// Note:This API should be used on laptop systems and on systems where LID state is required in the connection output mask.
// On desktop systems the returned identifiers will match NvAPI_GPU_GetConnectedOutputs.
//
// SUPPORTED OS: Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: hPhysicalGpu or pOutputsMask is NULL
// NVAPI_OK: *pOutputsMask contains a set of GPU-output identifiers
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found
// NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: hPhysicalGpu was not a physical GPU handle
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GPU_GetConnectedOutputsWithLidState(NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pOutputsMask);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GPU_GetConnectedSLIOutputsWithLidState
//
// DESCRIPTION: Same as NvAPI_GPU_GetConnectedOutputsWithLidState but returns only the set of GPU-output
// identifiers that can be selected in an SLI configuration. With SLI disabled
// this function matches NvAPI_GPU_GetConnectedOutputsWithLidState
//
// SUPPORTED OS: Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: hPhysicalGpu or pOutputsMask is NULL
// NVAPI_OK: *pOutputsMask contains a set of GPU-output identifiers
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found
// NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: hPhysicalGpu was not a physical GPU handle
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GPU_GetConnectedSLIOutputsWithLidState(NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pOutputsMask);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GPU_GetSystemType
//
// DESCRIPTION: Returns information to identify if the GPU type is for a laptop system or a desktop system.
//
// SUPPORTED OS: Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: hPhysicalGpu or pOutputsMask is NULL
// NVAPI_OK: *pSystemType contains the GPU system type
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found
// NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: hPhysicalGpu was not a physical GPU handle
//
///////////////////////////////////////////////////////////////////////////////
typedef enum
{
NV_SYSTEM_TYPE_UNKNOWN = 0,
NV_SYSTEM_TYPE_LAPTOP = 1,
NV_SYSTEM_TYPE_DESKTOP = 2,
} NV_SYSTEM_TYPE;
NVAPI_INTERFACE NvAPI_GPU_GetSystemType(NvPhysicalGpuHandle hPhysicalGpu, NV_SYSTEM_TYPE *pSystemType);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GPU_GetActiveOutputs
//
// DESCRIPTION: Same as NvAPI_GPU_GetAllOutputs but returns only the set of GPU-output
// identifiers that are actively driving display devices.
//
// SUPPORTED OS: Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: hPhysicalGpu or pOutputsMask is NULL
// NVAPI_OK: *pOutputsMask contains a set of GPU-output identifiers
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found
// NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: hPhysicalGpu was not a physical GPU handle
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GPU_GetActiveOutputs(NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pOutputsMask);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GPU_GetEDID
//
// DESCRIPTION: Returns the EDID data for the specified GPU handle and connection bit mask.
// displayOutputId should have exactly 1 bit set to indicate a single display.
//
// SUPPORTED OS: Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: pEDID is NULL; displayOutputId has 0 or > 1 bits set.
// NVAPI_OK: *pEDID contains valid data.
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found.
// NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: hPhysicalGpu was not a physical GPU handle.
// NVAPI_DATA_NOT_FOUND: requested display does not contain an EDID
//
///////////////////////////////////////////////////////////////////////////////
#define NV_EDID_V1_DATA_SIZE 256
#define NV_EDID_DATA_SIZE NV_EDID_V1_DATA_SIZE
typedef struct
{
NvU32 version; //structure version
NvU8 EDID_Data[NV_EDID_DATA_SIZE];
NvU32 sizeofEDID;
} NV_EDID;
#define NV_EDID_VER MAKE_NVAPI_VERSION(NV_EDID,2)
NVAPI_INTERFACE NvAPI_GPU_GetEDID(NvPhysicalGpuHandle hPhysicalGpu, NvU32 displayOutputId, NV_EDID *pEDID);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GPU_GetOutputType
//
// DESCRIPTION: Give a physical GPU handle and a single outputId (exactly 1 bit set), this API
// returns the output type.
//
// SUPPORTED OS: Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: hPhysicalGpu, outputId or pOutputsMask is NULL; or outputId has > 1 bit set
// NVAPI_OK: *pOutputType contains a NvGpuOutputType value
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found
// NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: hPhysicalGpu was not a physical GPU handle
//
///////////////////////////////////////////////////////////////////////////////
typedef enum _NV_GPU_OUTPUT_TYPE
{
NVAPI_GPU_OUTPUT_UNKNOWN = 0,
NVAPI_GPU_OUTPUT_CRT = 1, // CRT display device
NVAPI_GPU_OUTPUT_DFP = 2, // Digital Flat Panel display device
NVAPI_GPU_OUTPUT_TV = 3, // TV display device
} NV_GPU_OUTPUT_TYPE;
NVAPI_INTERFACE NvAPI_GPU_GetOutputType(NvPhysicalGpuHandle hPhysicalGpu, NvU32 outputId, NV_GPU_OUTPUT_TYPE *pOutputType);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GPU_ValidateOutputCombination
//
// DESCRIPTION: This call is used to determine if a set of GPU outputs can be active
// simultaneously. While a GPU may have <n> outputs, they can not typically
// all be active at the same time due to internal resource sharing.
//
// Given a physical GPU handle and a mask of candidate outputs, this call
// will return NVAPI_OK if all of the specified outputs can be driven
// simultaneously. It will return NVAPI_INVALID_COMBINATION if they cannot.
//
// Use NvAPI_GPU_GetAllOutputs() to determine which outputs are candidates.
//
// SUPPORTED OS: Windows XP and higher
//
// RETURN STATUS: NVAPI_OK: combination of outputs in outputsMask are valid (can be active simultaneously)
// NVAPI_INVALID_COMBINATION: combination of outputs in outputsMask are NOT valid
// NVAPI_INVALID_ARGUMENT: hPhysicalGpu or outputsMask does not have at least 2 bits set
// NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: hPhysicalGpu was not a physical GPU handle
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GPU_ValidateOutputCombination(NvPhysicalGpuHandle hPhysicalGpu, NvU32 outputsMask);
typedef enum _NV_GPU_CONNECTOR_TYPE
{
NVAPI_GPU_CONNECTOR_VGA_15_PIN = 0x00000000,
NVAPI_GPU_CONNECTOR_TV_COMPOSITE = 0x00000010,
NVAPI_GPU_CONNECTOR_TV_SVIDEO = 0x00000011,
NVAPI_GPU_CONNECTOR_TV_HDTV_COMPONENT = 0x00000013,
NVAPI_GPU_CONNECTOR_TV_SCART = 0x00000014,
NVAPI_GPU_CONNECTOR_TV_COMPOSITE_SCART_ON_EIAJ4120 = 0x00000016,
NVAPI_GPU_CONNECTOR_TV_HDTV_EIAJ4120 = 0x00000017,
NVAPI_GPU_CONNECTOR_PC_POD_HDTV_YPRPB = 0x00000018,
NVAPI_GPU_CONNECTOR_PC_POD_SVIDEO = 0x00000019,
NVAPI_GPU_CONNECTOR_PC_POD_COMPOSITE = 0x0000001A,
NVAPI_GPU_CONNECTOR_DVI_I_TV_SVIDEO = 0x00000020,
NVAPI_GPU_CONNECTOR_DVI_I_TV_COMPOSITE = 0x00000021,
NVAPI_GPU_CONNECTOR_DVI_I = 0x00000030,
NVAPI_GPU_CONNECTOR_DVI_D = 0x00000031,
NVAPI_GPU_CONNECTOR_ADC = 0x00000032,
NVAPI_GPU_CONNECTOR_LFH_DVI_I_1 = 0x00000038,
NVAPI_GPU_CONNECTOR_LFH_DVI_I_2 = 0x00000039,
NVAPI_GPU_CONNECTOR_SPWG = 0x00000040,
NVAPI_GPU_CONNECTOR_OEM = 0x00000041,
NVAPI_GPU_CONNECTOR_DISPLAYPORT_EXTERNAL = 0x00000046,
NVAPI_GPU_CONNECTOR_DISPLAYPORT_INTERNAL = 0x00000047,
NVAPI_GPU_CONNECTOR_HDMI_A = 0x00000061,
NVAPI_GPU_CONNECTOR_UNKNOWN = 0xFFFFFFFF,
} NV_GPU_CONNECTOR_TYPE;
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GPU_GetFullName
//
// DESCRIPTION: Retrieves the full GPU name as an ascii string. Eg: "Quadro FX 1400"
//
// SUPPORTED OS: Mac OS X, Windows XP and higher
//
// RETURN STATUS: NVAPI_ERROR or NVAPI_OK
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GPU_GetFullName(NvPhysicalGpuHandle hPhysicalGpu, NvAPI_ShortString szName);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GPU_GetPCIIdentifiers
//
// DESCRIPTION: Returns the PCI identifiers associated with this GPU.
// DeviceId - the internal PCI device identifier for the GPU.
// SubSystemId - the internal PCI subsystem identifier for the GPU.
// RevisionId - the internal PCI device-specific revision identifier for the GPU.
// ExtDeviceId - the external PCI device identifier for the GPU.
//
// SUPPORTED OS: Mac OS X, Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: hPhysicalGpu or an argument is NULL
// NVAPI_OK: arguments are populated with PCI identifiers
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found
// NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: hPhysicalGpu was not a physical GPU handle
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GPU_GetPCIIdentifiers(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pDeviceId,NvU32 *pSubSystemId,NvU32 *pRevisionId,NvU32 *pExtDeviceId);
typedef enum _NV_GPU_TYPE
{
NV_SYSTEM_TYPE_GPU_UNKNOWN = 0,
NV_SYSTEM_TYPE_IGPU = 1, //integrated
NV_SYSTEM_TYPE_DGPU = 2, //discrete
} NV_GPU_TYPE;
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GPU_GetGPUType
//
// DESCRIPTION: Returns information to identify the GPU type
//
// SUPPORTED OS: Mac OS X, Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: hPhysicalGpu
// NVAPI_OK: *pGpuType contains the GPU type
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found
// NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: hPhysicalGpu was not a physical GPU handle
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GPU_GetGPUType(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_TYPE *pGpuType);
typedef enum _NV_GPU_BUS_TYPE
{
NVAPI_GPU_BUS_TYPE_UNDEFINED = 0,
NVAPI_GPU_BUS_TYPE_PCI = 1,
NVAPI_GPU_BUS_TYPE_AGP = 2,
NVAPI_GPU_BUS_TYPE_PCI_EXPRESS = 3,
NVAPI_GPU_BUS_TYPE_FPCI = 4,
} NV_GPU_BUS_TYPE;
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GPU_GetBusType
//
// DESCRIPTION: Returns the type of bus associated with this GPU.
//
// SUPPORTED OS: Mac OS X, Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: hPhysicalGpu or pBusType is NULL
// NVAPI_OK: *pBusType contains bus identifier
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found
// NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: hPhysicalGpu was not a physical GPU handle
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GPU_GetBusType(NvPhysicalGpuHandle hPhysicalGpu,NV_GPU_BUS_TYPE *pBusType);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GPU_GetBusId
//
// DESCRIPTION: Returns the ID of bus associated with this GPU.
//
// SUPPORTED OS: Mac OS X, Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: hPhysicalGpu or pBusId is NULL
// NVAPI_OK: *pBusId contains bus id
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found
// NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: hPhysicalGpu was not a physical GPU handle
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GPU_GetBusId(NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pBusId);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GPU_GetBusSlotId
//
// DESCRIPTION: Returns the ID of bus-slot associated with this GPU.
//
// SUPPORTED OS: Mac OS X, Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: hPhysicalGpu or pBusSlotId is NULL
// NVAPI_OK: *pBusSlotId contains bus-slot id
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found
// NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: hPhysicalGpu was not a physical GPU handle
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GPU_GetBusSlotId(NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pBusSlotId);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GPU_GetIRQ
//
// DESCRIPTION: Returns the interrupt number associated with this GPU.
//
// SUPPORTED OS: Mac OS X, Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: hPhysicalGpu or pIRQ is NULL
// NVAPI_OK: *pIRQ contains interrupt number
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found
// NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: hPhysicalGpu was not a physical GPU handle
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GPU_GetIRQ(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pIRQ);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GPU_GetVbiosRevision
//
// DESCRIPTION: Returns the revision of the video bios associated with this GPU.
//
// SUPPORTED OS: Mac OS X, Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: hPhysicalGpu or pBiosRevision is NULL
// NVAPI_OK: *pBiosRevision contains revision number
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found
// NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: hPhysicalGpu was not a physical GPU handle
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GPU_GetVbiosRevision(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pBiosRevision);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GPU_GetVbiosOEMRevision
//
// DESCRIPTION: Returns the OEM revision of the video bios associated with this GPU.
//
// SUPPORTED OS: Mac OS X, Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: hPhysicalGpu or pBiosRevision is NULL
// NVAPI_OK: *pBiosRevision contains revision number
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found
// NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: hPhysicalGpu was not a physical GPU handle
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GPU_GetVbiosOEMRevision(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pBiosRevision);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GPU_GetVbiosVersionString
//
// DESCRIPTION: Returns the full bios version string in the form of xx.xx.xx.xx.yy where
// the xx numbers come from NvAPI_GPU_GetVbiosRevision and yy comes from
// NvAPI_GPU_GetVbiosOEMRevision.
//
// SUPPORTED OS: Mac OS X, Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: hPhysicalGpu is NULL
// NVAPI_OK: szBiosRevision contains version string
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found
// NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: hPhysicalGpu was not a physical GPU handle
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GPU_GetVbiosVersionString(NvPhysicalGpuHandle hPhysicalGpu,NvAPI_ShortString szBiosRevision);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GPU_GetAGPAperture
//
// DESCRIPTION: Returns AGP aperture in megabytes
//
// SUPPORTED OS: Mac OS X, Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: pSize is NULL
// NVAPI_OK: call successful
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found
// NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: hPhysicalGpu was not a physical GPU handle
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GPU_GetAGPAperture(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pSize);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GPU_GetCurrentAGPRate
//
// DESCRIPTION: Returns the current AGP Rate (1 = 1x, 2=2x etc, 0 = AGP not present)
//
// SUPPORTED OS: Mac OS X, Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: pRate is NULL
// NVAPI_OK: call successful
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found
// NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: hPhysicalGpu was not a physical GPU handle
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GPU_GetCurrentAGPRate(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pRate);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GPU_GetCurrentPCIEDownstreamWidth
//
// DESCRIPTION: Returns the number of PCIE lanes being used for the PCIE interface
// downstream from the GPU.
//
// On systems that do not support PCIE, the maxspeed for the root link
// will be zero.
//
// SUPPORTED OS: Mac OS X, Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: pWidth is NULL
// NVAPI_OK: call successful
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found
// NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: hPhysicalGpu was not a physical GPU handle
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GPU_GetCurrentPCIEDownstreamWidth(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pWidth);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GPU_GetPhysicalFrameBufferSize
//
// DESCRIPTION: Returns the physical size of framebuffer in Kb. This does NOT include any
// system RAM that may be dedicated for use by the GPU.
//
// SUPPORTED OS: Mac OS X, Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: pSize is NULL
// NVAPI_OK: call successful
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found
// NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: hPhysicalGpu was not a physical GPU handle
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GPU_GetPhysicalFrameBufferSize(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pSize);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GPU_GetVirtualFrameBufferSize
//
// DESCRIPTION: Returns the virtual size of framebuffer in Kb. This includes the physical RAM plus any
// system RAM that has been dedicated for use by the GPU.
//
// SUPPORTED OS: Mac OS X, Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: pSize is NULL
// NVAPI_OK: call successful
// NVAPI_NVIDIA_DEVICE_NOT_FOUND: no NVIDIA GPU driving a display was found
// NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: hPhysicalGpu was not a physical GPU handle
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GPU_GetVirtualFrameBufferSize(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pSize);
///////////////////////////////////////////////////////////////////////////////////
// Thermal API
// Provides ability to get temperature levels from the various thermal sensors associated with the GPU
#define NVAPI_MAX_THERMAL_SENSORS_PER_GPU 3
typedef enum
{
NVAPI_THERMAL_TARGET_NONE = 0,
NVAPI_THERMAL_TARGET_GPU = 1,
NVAPI_THERMAL_TARGET_MEMORY = 2,
NVAPI_THERMAL_TARGET_POWER_SUPPLY = 4,
NVAPI_THERMAL_TARGET_BOARD = 8,
NVAPI_THERMAL_TARGET_ALL = 15,
NVAPI_THERMAL_TARGET_UNKNOWN = -1,
} NV_THERMAL_TARGET;
typedef enum
{
NVAPI_THERMAL_CONTROLLER_NONE = 0,
NVAPI_THERMAL_CONTROLLER_GPU_INTERNAL,
NVAPI_THERMAL_CONTROLLER_ADM1032,
NVAPI_THERMAL_CONTROLLER_MAX6649,
NVAPI_THERMAL_CONTROLLER_MAX1617,
NVAPI_THERMAL_CONTROLLER_LM99,
NVAPI_THERMAL_CONTROLLER_LM89,
NVAPI_THERMAL_CONTROLLER_LM64,
NVAPI_THERMAL_CONTROLLER_ADT7473,
NVAPI_THERMAL_CONTROLLER_SBMAX6649,
NVAPI_THERMAL_CONTROLLER_VBIOSEVT,
NVAPI_THERMAL_CONTROLLER_OS,
NVAPI_THERMAL_CONTROLLER_UNKNOWN = -1,
} NV_THERMAL_CONTROLLER;
typedef struct
{
NvU32 version; //structure version
NvU32 count; //number of associated thermal sensors with the selected GPU
struct
{
NV_THERMAL_CONTROLLER controller; //internal, ADM1032, MAX6649...
NvU32 defaultMinTemp; //the min default temperature value of the thermal sensor in degrees centigrade
NvU32 defaultMaxTemp; //the max default temperature value of the thermal sensor in degrees centigrade
NvU32 currentTemp; //the current temperature value of the thermal sensor in degrees centigrade
NV_THERMAL_TARGET target; //thermal senor targeted @ GPU, memory, chipset, powersupply, canoas...
} sensor[NVAPI_MAX_THERMAL_SENSORS_PER_GPU];
} NV_GPU_THERMAL_SETTINGS;
#define NV_GPU_THERMAL_SETTINGS_VER MAKE_NVAPI_VERSION(NV_GPU_THERMAL_SETTINGS,1)
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GPU_GetThermalSettings
//
// DESCRIPTION: Retrieves the thermal information of all thermal sensors or specific thermal sensor associated with the selected GPU.
// Thermal sensors are indexed 0 to NVAPI_MAX_THERMAL_SENSORS_PER_GPU-1.
// To retrieve specific thermal sensor info set the sensorIndex to the required thermal sensor index.
// To retrieve info for all sensors set sensorIndex to NVAPI_THERMAL_TARGET_ALL.
//
// SUPPORTED OS: Mac OS X, Windows XP and higher
//
// PARAMETERS : hPhysicalGPU(IN) - GPU selection.
// sensorIndex(IN) - Explicit thermal sensor index selection.
// pThermalSettings(OUT) - Array of thermal settings.
//
// RETURN STATUS:
// NVAPI_OK - completed request
// NVAPI_ERROR - miscellaneous error occurred
// NVAPI_INVALID_ARGUMENT - pThermalInfo is NULL
// NVAPI_HANDLE_INVALIDATED - handle passed has been invalidated (see user guide)
// NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE - handle passed is not a physical GPU handle
// NVAPI_INCOMPATIBLE_STRUCT_VERSION - the version of the INFO struct is not supported
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GPU_GetThermalSettings(NvPhysicalGpuHandle hPhysicalGpu, NvU32 sensorIndex, NV_GPU_THERMAL_SETTINGS *pThermalSettings);
////////////////////////////////////////////////////////////////////////////////
//NvAPI_TVOutput Information
typedef enum _NV_DISPLAY_TV_FORMAT
{
NV_DISPLAY_TV_FORMAT_NONE = 0,
NV_DISPLAY_TV_FORMAT_SD_NTSCM = 0x00000001,
NV_DISPLAY_TV_FORMAT_SD_NTSCJ = 0x00000002,
NV_DISPLAY_TV_FORMAT_SD_PALM = 0x00000004,
NV_DISPLAY_TV_FORMAT_SD_PALBDGH = 0x00000008,
NV_DISPLAY_TV_FORMAT_SD_PALN = 0x00000010,
NV_DISPLAY_TV_FORMAT_SD_PALNC = 0x00000020,
NV_DISPLAY_TV_FORMAT_SD_576i = 0x00000100,
NV_DISPLAY_TV_FORMAT_SD_480i = 0x00000200,
NV_DISPLAY_TV_FORMAT_ED_480p = 0x00000400,
NV_DISPLAY_TV_FORMAT_ED_576p = 0x00000800,
NV_DISPLAY_TV_FORMAT_HD_720p = 0x00001000,
NV_DISPLAY_TV_FORMAT_HD_1080i = 0x00002000,
NV_DISPLAY_TV_FORMAT_HD_1080p = 0x00004000,
NV_DISPLAY_TV_FORMAT_HD_720p50 = 0x00008000,
NV_DISPLAY_TV_FORMAT_HD_1080p24 = 0x00010000,
NV_DISPLAY_TV_FORMAT_HD_1080i50 = 0x00020000,
NV_DISPLAY_TV_FORMAT_HD_1080p50 = 0x00040000,
} NV_DISPLAY_TV_FORMAT;
///////////////////////////////////////////////////////////////////////////////////
// I2C API
// Provides ability to read or write data using I2C protocol.
// These APIs allow I2C access only to DDC monitors
#define NVAPI_MAX_SIZEOF_I2C_DATA_BUFFER 256
#define NVAPI_NO_PORTID_FOUND 5
#define NVAPI_DISPLAY_DEVICE_MASK_MAX 24
typedef struct
{
NvU32 version; //structure version
NvU32 displayMask; //the Display Mask of the concerned display
NvU8 bIsDDCPort; //Flag indicating DDC port or a communication port
NvU8 i2cDevAddress; //the I2C target device address
NvU8* pbI2cRegAddress;//the I2C target register address
NvU32 regAddrSize; //the size in bytes of target register address
NvU8* pbData; //The buffer of data which is to be read/written
NvU32 cbSize; //The size of Data buffer to be read.
NvU32 i2cSpeed; //The speed at which the transaction is be made(between 28kbps to 40kbps)
} NV_I2C_INFO;
#define NV_I2C_INFO_VER MAKE_NVAPI_VERSION(NV_I2C_INFO,1)
/***********************************************************************************/
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_I2CRead
//
// DESCRIPTION: Read data buffer from I2C port
//
// SUPPORTED OS: Mac OS X, Windows XP and higher
//
// PARAMETERS: hPhysicalGPU(IN) - GPU selection.
// NV_I2C_INFO *pI2cInfo -The I2c data input structure
//
// RETURN STATUS:
// NVAPI_OK - completed request
// NVAPI_ERROR - miscellaneous error occurred
// NVAPI_HANDLE_INVALIDATED - handle passed has been invalidated (see user guide)
// NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE - handle passed is not a physical GPU handle
// NVAPI_INCOMPATIBLE_STRUCT_VERSION - structure version is not supported
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_I2CRead(NvPhysicalGpuHandle hPhysicalGpu, NV_I2C_INFO *pI2cInfo);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_I2CWrite
//
// DESCRIPTION: Writes data buffer to I2C port
//
// SUPPORTED OS: Mac OS X, Windows XP and higher
//
// PARAMETERS: hPhysicalGPU(IN) - GPU selection.
// NV_I2C_INFO *pI2cInfo -The I2c data input structure
//
// RETURN STATUS:
// NVAPI_OK - completed request
// NVAPI_ERROR - miscellaneous error occurred
// NVAPI_HANDLE_INVALIDATED - handle passed has been invalidated (see user guide)
// NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE - handle passed is not a physical GPU handle
// NVAPI_INCOMPATIBLE_STRUCT_VERSION - structure version is not supported
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_I2CWrite(NvPhysicalGpuHandle hPhysicalGpu, NV_I2C_INFO *pI2cInfo);
typedef struct
{
NvU32 version; //structure version
NvU32 vendorId; //vendorId
NvU32 deviceId; //deviceId
NvAPI_ShortString szVendorName; //vendor Name
NvAPI_ShortString szChipsetName; //device Name
NvU32 flags; //Chipset info flags - obsolete
NvU32 subSysVendorId; //subsystem vendorId
NvU32 subSysDeviceId; //subsystem deviceId
NvAPI_ShortString szSubSysVendorName; //subsystem vendor Name
} NV_CHIPSET_INFO;
#define NV_CHIPSET_INFO_VER MAKE_NVAPI_VERSION(NV_CHIPSET_INFO,3)
typedef enum
{
NV_CHIPSET_INFO_HYBRID = 0x00000001,
} NV_CHIPSET_INFO_FLAGS;
typedef struct
{
NvU32 version; //structure version
NvU32 vendorId; //vendorId
NvU32 deviceId; //deviceId
NvAPI_ShortString szVendorName; //vendor Name
NvAPI_ShortString szChipsetName; //device Name
NvU32 flags; //Chipset info flags
} NV_CHIPSET_INFO_v2;
#define NV_CHIPSET_INFO_VER_2 MAKE_NVAPI_VERSION(NV_CHIPSET_INFO_v2,2)
typedef struct
{
NvU32 version; //structure version
NvU32 vendorId; //vendorId
NvU32 deviceId; //deviceId
NvAPI_ShortString szVendorName; //vendor Name
NvAPI_ShortString szChipsetName; //device Name
} NV_CHIPSET_INFO_v1;
#define NV_CHIPSET_INFO_VER_1 MAKE_NVAPI_VERSION(NV_CHIPSET_INFO_v1,1)
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_SYS_GetChipSetInfo
//
// DESCRIPTION: Returns information about the System's ChipSet
//
// SUPPORTED OS: Mac OS X, Windows XP and higher
//
// RETURN STATUS: NVAPI_INVALID_ARGUMENT: pChipSetInfo is NULL
// NVAPI_OK: *pChipSetInfo is now set
// NVAPI_INCOMPATIBLE_STRUCT_VERSION - NV_CHIPSET_INFO version not compatible with driver
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_SYS_GetChipSetInfo(NV_CHIPSET_INFO *pChipSetInfo);
typedef struct
{
NvU32 version; // Structure version, constructed from macro below
NvU32 currentLidState;
NvU32 currentDockState;
NvU32 currentLidPolicy;
NvU32 currentDockPolicy;
NvU32 forcedLidMechanismPresent;
NvU32 forcedDockMechanismPresent;
}NV_LID_DOCK_PARAMS;
#define NV_LID_DOCK_PARAMS_VER MAKE_NVAPI_VERSION(NV_LID_DOCK_PARAMS,1)
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_GetLidDockInfo
//
// DESCRIPTION: Returns current lid and dock information.
//
// SUPPORTED OS: Mac OS X, Windows XP and higher
//
// RETURN STATUS: NVAPI_OK: now *pLidAndDock contains the returned lid and dock information.
// NVAPI_ERROR:If any way call is not success.
// NVAPI_NOT_SUPPORTED:If any way call is not success.
// NVAPI_HANDLE_INVALIDATED:If nvapi escape result handle is invalid.
// NVAPI_API_NOT_INTIALIZED:If NVAPI is not initialized.
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_SYS_GetLidAndDockInfo(NV_LID_DOCK_PARAMS *pLidAndDock);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_OGL_ExpertModeSet[Get]
//
// DESCRIPTION: Configure OpenGL Expert Mode, an API usage feedback and
// advice reporting mechanism. The effects of this call are
// applied only to the current context, and are reset to the
// defaults when the context is destroyed.
//
// Note: This feature is valid at runtime only when GLExpert
// functionality has been built into the OpenGL driver
// installed on the system. All Windows Vista OpenGL
// drivers provided by NVIDIA have this instrumentation
// included by default. Windows XP, however, requires a
// special display driver available with the NVIDIA
// PerfSDK found at developer.nvidia.com.
//
// Note: These functions are valid only for the current OpenGL
// context. Calling these functions prior to creating a
// context and calling MakeCurrent with it will result
// in errors and undefined behavior.
//
// PARAMETERS: expertDetailMask Mask made up of NVAPI_OGLEXPERT_DETAIL bits,
// this parameter specifies the detail level in
// the feedback stream.
//
// expertReportMask Mask made up of NVAPI_OGLEXPERT_REPORT bits,
// this parameter specifies the areas of
// functional interest.
//
// expertOutputMask Mask made up of NVAPI_OGLEXPERT_OUTPUT bits,
// this parameter specifies the feedback output
// location.
//
// expertCallback Used in conjunction with OUTPUT_TO_CALLBACK,
// this is a simple callback function the user
// may use to obtain the feedback stream. The
// function will be called once per fully
// qualified feedback stream entry.
//
// RETURN STATUS: NVAPI_API_NOT_INTIALIZED : NVAPI not initialized
// NVAPI_NVIDIA_DEVICE_NOT_FOUND : no NVIDIA GPU found
// NVAPI_OPENGL_CONTEXT_NOT_CURRENT : no NVIDIA OpenGL context
// which supports GLExpert
// has been made current
// NVAPI_ERROR : OpenGL driver failed to load properly
// NVAPI_OK : success
//
///////////////////////////////////////////////////////////////////////////////
#define NVAPI_OGLEXPERT_DETAIL_NONE 0x00000000
#define NVAPI_OGLEXPERT_DETAIL_ERROR 0x00000001
#define NVAPI_OGLEXPERT_DETAIL_SWFALLBACK 0x00000002
#define NVAPI_OGLEXPERT_DETAIL_BASIC_INFO 0x00000004
#define NVAPI_OGLEXPERT_DETAIL_DETAILED_INFO 0x00000008
#define NVAPI_OGLEXPERT_DETAIL_PERFORMANCE_WARNING 0x00000010
#define NVAPI_OGLEXPERT_DETAIL_QUALITY_WARNING 0x00000020
#define NVAPI_OGLEXPERT_DETAIL_USAGE_WARNING 0x00000040
#define NVAPI_OGLEXPERT_DETAIL_ALL 0xFFFFFFFF
#define NVAPI_OGLEXPERT_REPORT_NONE 0x00000000
#define NVAPI_OGLEXPERT_REPORT_ERROR 0x00000001
#define NVAPI_OGLEXPERT_REPORT_SWFALLBACK 0x00000002
#define NVAPI_OGLEXPERT_REPORT_PIPELINE_VERTEX 0x00000004
#define NVAPI_OGLEXPERT_REPORT_PIPELINE_GEOMETRY 0x00000008
#define NVAPI_OGLEXPERT_REPORT_PIPELINE_XFB 0x00000010
#define NVAPI_OGLEXPERT_REPORT_PIPELINE_RASTER 0x00000020
#define NVAPI_OGLEXPERT_REPORT_PIPELINE_FRAGMENT 0x00000040
#define NVAPI_OGLEXPERT_REPORT_PIPELINE_ROP 0x00000080
#define NVAPI_OGLEXPERT_REPORT_PIPELINE_FRAMEBUFFER 0x00000100
#define NVAPI_OGLEXPERT_REPORT_PIPELINE_PIXEL 0x00000200
#define NVAPI_OGLEXPERT_REPORT_PIPELINE_TEXTURE 0x00000400
#define NVAPI_OGLEXPERT_REPORT_OBJECT_BUFFEROBJECT 0x00000800
#define NVAPI_OGLEXPERT_REPORT_OBJECT_TEXTURE 0x00001000
#define NVAPI_OGLEXPERT_REPORT_OBJECT_PROGRAM 0x00002000
#define NVAPI_OGLEXPERT_REPORT_OBJECT_FBO 0x00004000
#define NVAPI_OGLEXPERT_REPORT_FEATURE_SLI 0x00008000
#define NVAPI_OGLEXPERT_REPORT_ALL 0xFFFFFFFF
#define NVAPI_OGLEXPERT_OUTPUT_TO_NONE 0x00000000
#define NVAPI_OGLEXPERT_OUTPUT_TO_CONSOLE 0x00000001
#define NVAPI_OGLEXPERT_OUTPUT_TO_DEBUGGER 0x00000004
#define NVAPI_OGLEXPERT_OUTPUT_TO_CALLBACK 0x00000008
#define NVAPI_OGLEXPERT_OUTPUT_TO_ALL 0xFFFFFFFF
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION TYPE: NVAPI_OGLEXPERT_CALLBACK
//
// DESCRIPTION: Used in conjunction with OUTPUT_TO_CALLBACK, this is a simple
// callback function the user may use to obtain the feedback
// stream. The function will be called once per fully qualified
// feedback stream entry.
//
// PARAMETERS: categoryId Contains the bit from the NVAPI_OGLEXPERT_REPORT
// mask that corresponds to the current message
// messageId Unique Id for the current message
// detailLevel Contains the bit from the NVAPI_OGLEXPERT_DETAIL
// mask that corresponds to the current message
// objectId Unique Id of the object that corresponds to the
// current message
// messageStr Text string from the current message
//
///////////////////////////////////////////////////////////////////////////////
typedef void (* NVAPI_OGLEXPERT_CALLBACK) (unsigned int categoryId, unsigned int messageId, unsigned int detailLevel, int objectId, const char *messageStr);
// SUPPORTED OS: Windows XP and higher
NVAPI_INTERFACE NvAPI_OGL_ExpertModeSet(NvU32 expertDetailLevel,
NvU32 expertReportMask,
NvU32 expertOutputMask,
NVAPI_OGLEXPERT_CALLBACK expertCallback);
// SUPPORTED OS: Windows XP and higher
NVAPI_INTERFACE NvAPI_OGL_ExpertModeGet(NvU32 *pExpertDetailLevel,
NvU32 *pExpertReportMask,
NvU32 *pExpertOutputMask,
NVAPI_OGLEXPERT_CALLBACK *pExpertCallback);
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION NAME: NvAPI_OGL_ExpertModeDefaultsSet[Get]
//
// DESCRIPTION: Configure OpenGL Expert Mode global defaults. These settings
// apply to any OpenGL application which starts up after these
// values are applied (i.e. these settings *do not* apply to
// currently running applications).
//
// PARAMETERS: expertDetailLevel Value which specifies the detail level in
// the feedback stream. This is a mask made up
// of NVAPI_OGLEXPERT_LEVEL bits.
//
// expertReportMask Mask made up of NVAPI_OGLEXPERT_REPORT bits,
// this parameter specifies the areas of
// functional interest.
//
// expertOutputMask Mask made up of NVAPI_OGLEXPERT_OUTPUT bits,
// this parameter specifies the feedback output
// location. Note that using OUTPUT_TO_CALLBACK
// here is meaningless and has no effect, but
// using it will not cause an error.
//
// RETURN STATUS: NVAPI_ERROR or NVAPI_OK
//
///////////////////////////////////////////////////////////////////////////////
// SUPPORTED OS: Windows XP and higher
NVAPI_INTERFACE NvAPI_OGL_ExpertModeDefaultsSet(NvU32 expertDetailLevel,
NvU32 expertReportMask,
NvU32 expertOutputMask);
// SUPPORTED OS: Windows XP and higher
NVAPI_INTERFACE NvAPI_OGL_ExpertModeDefaultsGet(NvU32 *pExpertDetailLevel,
NvU32 *pExpertReportMask,
NvU32 *pExpertOutputMask);
#define NVAPI_MAX_VIEW_TARGET 2
typedef enum _NV_TARGET_VIEW_MODE
{
NV_VIEW_MODE_STANDARD = 0,
NV_VIEW_MODE_CLONE = 1,
NV_VIEW_MODE_HSPAN = 2,
NV_VIEW_MODE_VSPAN = 3,
NV_VIEW_MODE_DUALVIEW = 4,
NV_VIEW_MODE_MULTIVIEW = 5,
} NV_TARGET_VIEW_MODE;
// Following definitions are used in NvAPI_SetViewEx.
// Scaling modes
typedef enum _NV_SCALING
{
NV_SCALING_DEFAULT = 0, // No change
NV_SCALING_MONITOR_SCALING = 1,
NV_SCALING_ADAPTER_SCALING = 2,
NV_SCALING_CENTERED = 3,
NV_SCALING_ASPECT_SCALING = 5,
NV_SCALING_CUSTOMIZED = 255 // For future use
} NV_SCALING;
// Rotate modes
typedef enum _NV_ROTATE
{
NV_ROTATE_0 = 0,
NV_ROTATE_90 = 1,
NV_ROTATE_180 = 2,
NV_ROTATE_270 = 3
} NV_ROTATE;
// Color formats
typedef enum _NV_FORMAT
{
NV_FORMAT_UNKNOWN = 0, // unknown. Driver will choose one as following value.
NV_FORMAT_P8 = 41, // for 8bpp mode
NV_FORMAT_R5G6B5 = 23, // for 16bpp mode
NV_FORMAT_A8R8G8B8 = 21, // for 32bpp mode
NV_FORMAT_A16B16G16R16F = 113 // for 64bpp(floating point) mode.
} NV_FORMAT;
// TV standard
///////////////////////////////////////////////////////////////////////////////
// FUNCTION NAME: NvAPI_SetView
//
// DESCRIPTION: This API lets caller to modify target display arrangement for selected source display handle in any of the nview modes.
// It also allows to modify or extend the source display in dualview mode.
//
// SUPPORTED OS: Windows Vista and higher
//
// PARAMETERS: hNvDisplay(IN) - NVIDIA Display selection. NVAPI_DEFAULT_HANDLE not allowed, it has to be a handle enumerated with NvAPI_EnumNVidiaDisplayHandle().
// pTargetInfo(IN) - Pointer to array of NV_VIEW_TARGET_INFO, specifying device properties in this view.
// The first device entry in the array is the physical primary.
// The device entry with the lowest source id is the desktop primary.
// targetCount(IN) - Count of target devices specified in pTargetInfo.
// targetView(IN) - Target view selected from NV_TARGET_VIEW_MODE.
//
// RETURN STATUS:
// NVAPI_OK - completed request
// NVAPI_ERROR - miscellaneous error occurred
// NVAPI_INVALID_ARGUMENT: Invalid input parameter.
//
///////////////////////////////////////////////////////////////////////////////
typedef struct
{
NvU32 version; // (IN) structure version
NvU32 count; // (IN) target count
struct
{
NvU32 deviceMask; // (IN/OUT) device mask
NvU32 sourceId; // (IN/OUT) source id
NvU32 bPrimary:1; // (OUT) Indicates if this is the GPU's primary view target. This is not the desktop GDI primary.
// NvAPI_SetView automatically selects the first target in NV_VIEW_TARGET_INFO index 0 as the GPU's primary view.
NvU32 bInterlaced:1;// (IN/OUT) Indicates if the timing being used on this monitor is interlaced
NvU32 bGDIPrimary:1;// (IN/OUT) Indicates if this is the desktop GDI primary.
} target[NVAPI_MAX_VIEW_TARGET];
} NV_VIEW_TARGET_INFO;
#define NV_VIEW_TARGET_INFO_VER MAKE_NVAPI_VERSION(NV_VIEW_TARGET_INFO,2)
NVAPI_INTERFACE NvAPI_SetView(NvDisplayHandle hNvDisplay, NV_VIEW_TARGET_INFO *pTargetInfo, NV_TARGET_VIEW_MODE targetView);
///////////////////////////////////////////////////////////////////////////////
// FUNCTION NAME: NvAPI_GetView
//
// DESCRIPTION: This API lets caller retrieve the target display arrangement for selected source display handle.
//
// SUPPORTED OS: Windows Vista and higher
//
// PARAMETERS: hNvDisplay(IN) - NVIDIA Display selection. NVAPI_DEFAULT_HANDLE not allowed, it has to be a handle enumerated with NvAPI_EnumNVidiaDisplayHandle().
// pTargetInfo(OUT) - User allocated storage to retrieve an array of NV_VIEW_TARGET_INFO. Can be NULL to retrieve the targetCount.
// targetMaskCount(IN/OUT) - Count of target device mask specified in pTargetMask.
// targetView(OUT) - Target view selected from NV_TARGET_VIEW_MODE.
//
// RETURN STATUS:
// NVAPI_OK - completed request
// NVAPI_ERROR - miscellaneous error occurred
// NVAPI_INVALID_ARGUMENT: Invalid input parameter.
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GetView(NvDisplayHandle hNvDisplay, NV_VIEW_TARGET_INFO *pTargets, NvU32 *pTargetMaskCount, NV_TARGET_VIEW_MODE *pTargetView);
///////////////////////////////////////////////////////////////////////////////
// FUNCTION NAME: NvAPI_SetViewEx
//
// DESCRIPTION: This API lets caller to modify the display arrangement for selected source display handle in any of the nview modes.
// It also allows to modify or extend the source display in dualview mode.
//
// SUPPORTED OS: Windows Vista and higher
//
// PARAMETERS: hNvDisplay(IN) - NVIDIA Display selection. NVAPI_DEFAULT_HANDLE not allowed, it has to be a handle enumerated with NvAPI_EnumNVidiaDisplayHandle().
// pPathInfo(IN) - Pointer to array of NV_VIEW_PATH_INFO, specifying device properties in this view.
// The first device entry in the array is the physical primary.
// The device entry with the lowest source id is the desktop primary.
// pathCount(IN) - Count of paths specified in pPathInfo.
// displayView(IN)- Display view selected from NV_TARGET_VIEW_MODE.
//
// RETURN STATUS:
// NVAPI_OK - completed request
// NVAPI_ERROR - miscellaneous error occurred
// NVAPI_INVALID_ARGUMENT: Invalid input parameter.
//
///////////////////////////////////////////////////////////////////////////////
#define NVAPI_MAX_DISPLAY_PATH NVAPI_MAX_VIEW_TARGET
typedef struct
{
NvU32 version; // (IN) structure version
NvU32 count; // (IN) path count
struct
{
NvU32 deviceMask; // (IN) device mask
NvU32 sourceId; // (IN) source id
NvU32 bPrimary:1; // (IN/OUT) Indicates if this is the GPU's primary view target. This is not the desktop GDI primary.
// NvAPI_SetViewEx automatically selects the first target in NV_DISPLAY_PATH_INFO index 0 as the GPU's primary view.
NV_GPU_CONNECTOR_TYPE connector; // (IN) Specify connector type. For TV only.
// source mode information
NvU32 width; // (IN) width of the mode
NvU32 height; // (IN) height of the mode
NvU32 depth; // (IN) depth of the mode
NV_FORMAT colorFormat; // color format if needs to specify. Not used now.
//rotation setting of the mode
NV_ROTATE rotation; // (IN) rotation setting.
// the scaling mode
NV_SCALING scaling; // (IN) scaling setting
// Timing info
NvU32 refreshRate; // (IN) refresh rate of the mode
NvU32 interlaced:1; // (IN) interlaced mode flag
NV_DISPLAY_TV_FORMAT tvFormat; // (IN) to choose the last TV format set this value to NV_DISPLAY_TV_FORMAT_NONE
// Windows desktop position
NvU32 posx; // (IN/OUT) x offset of this display on the Windows desktop
NvU32 posy; // (IN/OUT) y offset of this display on the Windows desktop
NvU32 bGDIPrimary:1; // (IN/OUT) Indicates if this is the desktop GDI primary.
} path[NVAPI_MAX_DISPLAY_PATH];
} NV_DISPLAY_PATH_INFO;
#define NV_DISPLAY_PATH_INFO_VER MAKE_NVAPI_VERSION(NV_DISPLAY_PATH_INFO,2)
NVAPI_INTERFACE NvAPI_SetViewEx(NvDisplayHandle hNvDisplay, NV_DISPLAY_PATH_INFO *pPathInfo, NV_TARGET_VIEW_MODE displayView);
///////////////////////////////////////////////////////////////////////////////
// FUNCTION NAME: NvAPI_GetViewEx
//
// DESCRIPTION: This API lets caller retrieve the target display arrangement for selected source display handle.
//
// SUPPORTED OS: Windows Vista and higher
//
// PARAMETERS: hNvDisplay(IN) - NVIDIA Display selection. NVAPI_DEFAULT_HANDLE not allowed, it has to be a handle enumerated with NvAPI_EnumNVidiaDisplayHandle().
// pPathInfo(IN/OUT) - count field should be set to NVAPI_MAX_DISPLAY_PATH. Can be NULL to retrieve just the pathCount.
// pPathCount(IN/OUT) - Number of elements in array pPathInfo->path.
// pTargetViewMode(OUT)- Display view selected from NV_TARGET_VIEW_MODE.
//
// RETURN STATUS:
// NVAPI_OK - completed request
// NVAPI_API_NOT_INTIALIZED - NVAPI not initialized
// NVAPI_ERROR - miscellaneous error occurred
// NVAPI_INVALID_ARGUMENT - Invalid input parameter.
// NVAPI_EXPECTED_DISPLAY_HANDLE - hNvDisplay is not a valid display handle.
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GetViewEx(NvDisplayHandle hNvDisplay, NV_DISPLAY_PATH_INFO *pPathInfo, NvU32 *pPathCount, NV_TARGET_VIEW_MODE *pTargetViewMode);
///////////////////////////////////////////////////////////////////////////////
// FUNCTION NAME: NvAPI_GetSupportedViews
//
// DESCRIPTION: This API lets caller enumerate all the supported NVIDIA display views - nview and dualview modes.
//
// SUPPORTED OS: Windows XP and higher
//
// PARAMETERS: hNvDisplay(IN) - NVIDIA Display selection. It can be NVAPI_DEFAULT_HANDLE or a handle enumerated from NvAPI_EnumNVidiaDisplayHandle().
// pTargetViews(OUT) - Array of supported views. Can be NULL to retrieve the pViewCount first.
// pViewCount(IN/OUT) - Count of supported views.
//
// RETURN STATUS:
// NVAPI_OK - completed request
// NVAPI_ERROR - miscellaneous error occurred
// NVAPI_INVALID_ARGUMENT: Invalid input parameter.
//
///////////////////////////////////////////////////////////////////////////////
NVAPI_INTERFACE NvAPI_GetSupportedViews(NvDisplayHandle hNvDisplay, NV_TARGET_VIEW_MODE *pTargetViews, NvU32 *pViewCount);
#ifdef __cplusplus
}; //extern "C" {
#endif
#pragma pack(pop)
#endif // _NVAPI_H
Reference in New Issue View Git Blame Copy Permalink