void NvAPI::Initialize() { NvAPI_Status r = NvAPI_Initialize(); if (r == NVAPI_OK) { } }
//----------------------------------------------------------------------------- D3D9StereoDriverBridge::D3D9StereoDriverBridge(StereoModeType stereoMode) { mPimpl = NULL; mIsNvapiInitialized = false; mStereoMode = stereoMode; if (SMT_FRAME_SEQUENTIAL != mStereoMode) return; // Both initialize and set driver mode need to be called to determine whether NVIDIA stereo is available NvAPI_Status nvStatus = NvAPI_Initialize(); if (NVAPI_OK == nvStatus) nvStatus = NvAPI_Stereo_SetDriverMode(NVAPI_STEREO_DRIVER_MODE_DIRECT); if (NVAPI_OK == nvStatus) { NvAPI_ShortString nvapiStatusMessage; NvAPI_GetErrorMessage(nvStatus, nvapiStatusMessage); mIsNvapiInitialized = true; mPimpl = new D3D9StereoDriverNVIDIA(); } else { // Assume the AMD implementation, since the device must be created before verifying AMD QBS mPimpl = new D3D9StereoDriverAMD(); } }
BEGIN_NAMESPACE_XEVOL3D xNvRenderer::xNvRenderer() { NvAPI_Status ret = NvAPI_Initialize(); if(NVAPI_OK != ret) { XEVOL_LOG(eXL_ERROR_NORMAL , L"Initialize NvApi Failed\n"); return ; } NvAPI_Status nvapiStatus; m_nvDisplayCount = 0; // Enumerate all display handles for(int i=0,nvapiStatus=NVAPI_OK; nvapiStatus == NVAPI_OK; i++) { nvapiStatus = NvAPI_EnumNvidiaDisplayHandle(i, &m_hDisplay[i]); if (nvapiStatus == NVAPI_OK) m_nvDisplayCount++; } for(int i=0; i< m_nvDisplayCount; i++) { NvAPI_GetDisplayDriverVersion(m_hDisplay[i] , &m_DrvVersion); } }
void EnumerateProfilesOnSystem() { NvAPI_Status status; status = NvAPI_Initialize(); if(status != NVAPI_OK) PrintError(status); NvDRSSessionHandle hSession = 0; status = NvAPI_DRS_CreateSession(&hSession); if(status != NVAPI_OK) PrintError(status); status = NvAPI_DRS_LoadSettings(hSession); if(status != NVAPI_OK) PrintError(status); NvDRSProfileHandle hProfile = 0; unsigned int index = 0; while((status = NvAPI_DRS_EnumProfiles(hSession, index, &hProfile)) == NVAPI_OK) { printf("Profile in position %d:\n", index); DisplayProfileContents(hSession, hProfile); index++; } if(status == NVAPI_END_ENUMERATION) { // this is expected at the end of the enumeration } else if(status != NVAPI_OK) PrintError(status); NvAPI_DRS_DestroySession(hSession); hSession = 0; }
PStateNV::PStateNV(void) { NvAPI_Status status = NvAPI_Initialize(); if(status != NVAPI_OK) throw "NVAPI cannot be initialized!"; NvAPI_EnumPhysicalGPUs(m_hPhysicalGPU, &m_gpuCount); m_DynamicPStateInfo.version = NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER; m_nNumPState = 0; GetPStateInfo(); }
void MemoryMonitor::Init() { NvAPI_Status Status = NvAPI_Initialize(); assert(Status == NVAPI_OK); NvPhysicalGpuHandle NvGpuHandles[NVAPI_MAX_PHYSICAL_GPUS] = { 0 }; NvU32 NvGpuCount = 0; Status = NvAPI_EnumPhysicalGPUs(NvGpuHandles, &NvGpuCount); assert(Status == NVAPI_OK); assert(NvGpuCount != 0); m_GpuHandle = NvGpuHandles[0]; }
////////////////////////////////////////////////////////// // // NvOptimusDetect // // Try detecting optimus via NvAPI // ////////////////////////////////////////////////////////// bool NvOptimusDetect( void ) { if( NvAPI_Initialize() != NVAPI_OK ) { return false; } // Get and log driver info NvAPI_ShortString szDesc = "-"; NvU32 uiDriverVersion = -1; NvAPI_ShortString szBuildBranchString = "-"; NvAPI_GetInterfaceVersionString( szDesc ); NvAPI_SYS_GetDriverAndBranchVersion( &uiDriverVersion, szBuildBranchString ); WriteDebugEventAndReport( 7460, SString( "NvAPI - InterfaceVersion:'%s' DriverVersion:%d.%d Branch:'%s'", szDesc, uiDriverVersion / 100, uiDriverVersion % 100, szBuildBranchString ) ); // Get all the Physical GPU Handles NvPhysicalGpuHandle nvGPUHandle[NVAPI_MAX_PHYSICAL_GPUS] = {0}; NvU32 uiGpuCount = 0; if( NvAPI_EnumPhysicalGPUs( nvGPUHandle, &uiGpuCount ) != NVAPI_OK ) { return false; } bool bFoundOptimus = false; for( NvU32 i = 0; i < uiGpuCount; i++ ) { NV_SYSTEM_TYPE SystemType = (NV_SYSTEM_TYPE)-1; // 1-Laptop 2-Desktop NV_GPU_TYPE GpuType = (NV_GPU_TYPE)-1; // 1-Integrated 2-Discrete NvAPI_ShortString szName = "-"; NvAPI_GPU_GetSystemType( nvGPUHandle[i], &SystemType ); NvAPI_GPU_GetGPUType( nvGPUHandle[i], &GpuType ); NvAPI_GPU_GetFullName( nvGPUHandle[i], szName ); SString strStatus( "NvAPI - GPU %d/%d - SystemType:%d GpuType:%d (%s)", i, uiGpuCount, SystemType, GpuType, szName ); if ( SystemType == NV_SYSTEM_TYPE_LAPTOP && GpuType == NV_SYSTEM_TYPE_DGPU ) { bFoundOptimus = true; strStatus += " FoundOptimus"; } WriteDebugEventAndReport( 7461, strStatus ); } return bFoundOptimus; }
CNvidia::CNvidia(void) { // NVAPI initialize NvAPI_Status nvResult = NVAPI_OK; nvResult = NvAPI_Initialize(); if (nvResult != NVAPI_OK) AfxMessageBox(_T("Error Initialize NVAPI.")); // Physical gpu enumeration nvResult = NvAPI_EnumPhysicalGPUs(&m_nvGPUHandle, &m_gpuCount); if (nvResult != NVAPI_OK) AfxMessageBox(_T("Error Get PhysicalGPU.")); // version m_settings.version = NV_GPU_THERMAL_SETTINGS_VER_1; m_clkFreqs.version = NV_GPU_CLOCK_FREQUENCIES_VER; m_clkFreqs.ClockType = NV_GPU_CLOCK_FREQUENCIES_CURRENT_FREQ; }
int _tmain(int argc, _TCHAR* argv[]) { NvAPI_Status ret = NVAPI_OK; ret = NvAPI_Initialize(); if(ret != NVAPI_OK) { printf("NvAPI_Initialize() failed = 0x%x", ret); return 1; // Initialization failed } ret = SetMode();//to get the current mode, set to single view and then apply clone mode if(ret != NVAPI_OK) { printf("Failed to Set Mode... return code = 0x%x", ret); return 1;//Failed to Set Mode } printf("\nDisplay Configuration Successful!\n"); printf("\nPress any key to exit..."); getchar(); return 0; }
//-------------------------------------------------------------------------------------- DepthTexture::DepthTexture(const LPDIRECT3D9 d3d) { D3DDISPLAYMODE currentDisplayMode; d3d->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, ¤tDisplayMode); // determine if RESZ is supported m_isRESZ = d3d->CheckDeviceFormat(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, currentDisplayMode.Format, D3DUSAGE_RENDERTARGET, D3DRTYPE_SURFACE, FOURCC_RESZ) == D3D_OK; SDLOG(-1, "[DepthTexture] RESZ: %s\n", m_isRESZ?"true":"false"); // determine if INTZ is supported m_isINTZ = d3d->CheckDeviceFormat(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, currentDisplayMode.Format, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, FOURCC_INTZ) == D3D_OK; SDLOG(-1, "[DepthTexture] INTZ: %s\n", m_isINTZ ? "true" : "false"); // determine if RAWZ is supported, used in GeForce 6-7 series. m_isRAWZ = d3d->CheckDeviceFormat(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, currentDisplayMode.Format, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, FOURCC_RAWZ) == D3D_OK; SDLOG(-1, "[DepthTexture] RAWZ: %s\n", m_isRAWZ ? "true" : "false"); // determine if RESZ or NVAPI supported m_isSupported = (NvAPI_Initialize() == NVAPI_OK || m_isRESZ) && (m_isRAWZ || m_isINTZ); }
//--------------------------------------------------------------------- D3D11StereoDriverBridge::D3D11StereoDriverBridge(StereoModeType stereoMode) { mPimpl = NULL; mIsNvapiInitialized = false; mStereoMode = stereoMode; if (SMT_FRAME_SEQUENTIAL != mStereoMode) return; NvAPI_Status nvStatus = NvAPI_Initialize(); if (NVAPI_OK == nvStatus) { NvAPI_ShortString nvapiStatusMessage; NvAPI_GetErrorMessage(nvStatus, nvapiStatusMessage); mIsNvapiInitialized = true; mPimpl = new D3D11StereoDriverNVIDIA(); } else { // Assume the AMD implementation, since the device must be created before verifying AMD QBS mPimpl = new D3D11StereoDriverAMD(); } }
int main() { if (NvAPI_Initialize() != NVAPI_OK) throw std::runtime_error("NVIDIA Api not initialized"); if (NvAPI_DRS_CreateSession(&_session) != NVAPI_OK) throw std::runtime_error("can't create session"); if (NvAPI_DRS_LoadSettings(_session) != NVAPI_OK) throw std::runtime_error("can't load system settings"); if (NvAPI_DRS_GetCurrentGlobalProfile(_session, &_profile) != NVAPI_OK) throw std::runtime_error("can't get current global profile"); NvPhysicalGpuHandle nvGPUHandle[NVAPI_MAX_PHYSICAL_GPUS]; NvAPI_Status status; NvU32 GpuCount; NvU32 DeviceId; NvU32 SubSystemId; NvU32 RevisionId; NvU32 ExtDeviceId; NvU32 BusId; NvU32 BiosRevision; NvU32 BiosRevisionOEM; NV_BOARD_INFO BoardInfo; BoardInfo.version = NV_BOARD_INFO_VER; NvU32 ConfiguredFeatureMask; NvU32 ConsistentFeatureMask; NvU32 CoreCount; NvAPI_EnumPhysicalGPUs(nvGPUHandle, &GpuCount); NvAPI_ShortString str; NvAPI_GPU_GetFullName(nvGPUHandle[0], str); NvAPI_GPU_GetPCIIdentifiers(nvGPUHandle[0], &DeviceId, &SubSystemId, &RevisionId, &ExtDeviceId); NvAPI_GPU_GetBusId(nvGPUHandle[0], &BusId); NvAPI_GPU_GetVbiosRevision(nvGPUHandle[0], &BiosRevision); NvAPI_GPU_GetVbiosOEMRevision(nvGPUHandle[0], &BiosRevisionOEM); NvAPI_GPU_GetVbiosVersionString(nvGPUHandle[0], str); status = NvAPI_GPU_GetBoardInfo(nvGPUHandle[0], &BoardInfo); status = NvAPI_GPU_WorkstationFeatureQuery(nvGPUHandle[0], &ConfiguredFeatureMask, &ConsistentFeatureMask); status = NvAPI_GPU_GetGpuCoreCount(nvGPUHandle[0], &CoreCount); NV_CHIPSET_INFO info; info.version = NV_CHIPSET_INFO_VER_4; status =NvAPI_SYS_GetChipSetInfo(&info); NvAPI_GetInterfaceVersionString(str); unsigned int test= (unsigned int) -0x68; unsigned int index = 0; while ((status = NvAPI_DRS_EnumProfiles(_session, index, &_profile)) == NVAPI_OK) { _profInfo.version = NVDRS_PROFILE_VER; if (NvAPI_DRS_GetProfileInfo(_session, _profile, &_profInfo) != NVAPI_OK) throw std::runtime_error("can't get current global profile info"); index++; } EnumerateProfilesOnSystem(); NvAPI_DRS_DestroySession(_session); return 0; }
int APIENTRY WINMAIN(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) { const S32 MAX_HEAPS = 255; DWORD heap_enable_lfh_error[MAX_HEAPS]; S32 num_heaps = 0; #if WINDOWS_CRT_MEM_CHECKS && !INCLUDE_VLD _CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF ); // dump memory leaks on exit #elif 1 // Experimental - enable the low fragmentation heap // This results in a 2-3x improvement in opening a new Inventory window (which uses a large numebr of allocations) // Note: This won't work when running from the debugger unless the _NO_DEBUG_HEAP environment variable is set to 1 _CrtSetDbgFlag(0); // default, just making explicit ULONG ulEnableLFH = 2; HANDLE* hHeaps = new HANDLE[MAX_HEAPS]; num_heaps = GetProcessHeaps(MAX_HEAPS, hHeaps); for(S32 i = 0; i < num_heaps; i++) { bool success = HeapSetInformation(hHeaps[i], HeapCompatibilityInformation, &ulEnableLFH, sizeof(ulEnableLFH)); if (success) heap_enable_lfh_error[i] = 0; else heap_enable_lfh_error[i] = GetLastError(); } #endif // *FIX: global gIconResource = MAKEINTRESOURCE(IDI_LL_ICON); LLAppViewerWin32* viewer_app_ptr = new LLAppViewerWin32(lpCmdLine); viewer_app_ptr->setErrorHandler(LLAppViewer::handleViewerCrash); // Set a debug info flag to indicate if multiple instances are running. bool found_other_instance = !create_app_mutex(); gDebugInfo["FoundOtherInstanceAtStartup"] = LLSD::Boolean(found_other_instance); bool ok = viewer_app_ptr->init(); if(!ok) { LL_WARNS() << "Application init failed." << LL_ENDL; return -1; } #ifdef USE_NVAPI NvAPI_Status status; // Initialize NVAPI status = NvAPI_Initialize(); NvDRSSessionHandle hSession = 0; if (status == NVAPI_OK) { // Create the session handle to access driver settings status = NvAPI_DRS_CreateSession(&hSession); if (status != NVAPI_OK) { nvapi_error(status); } else { //override driver setting as needed ll_nvapi_init(hSession); } } #endif // Have to wait until after logging is initialized to display LFH info if (num_heaps > 0) { LL_INFOS() << "Attempted to enable LFH for " << num_heaps << " heaps." << LL_ENDL; for(S32 i = 0; i < num_heaps; i++) { if (heap_enable_lfh_error[i]) { LL_INFOS() << " Failed to enable LFH for heap: " << i << " Error: " << heap_enable_lfh_error[i] << LL_ENDL; } } } // Run the application main loop if(!LLApp::isQuitting()) { viewer_app_ptr->mainLoop(); } if (!LLApp::isError()) { // // We don't want to do cleanup here if the error handler got called - // the assumption is that the error handler is responsible for doing // app cleanup if there was a problem. // #if WINDOWS_CRT_MEM_CHECKS LL_INFOS() << "CRT Checking memory:" << LL_ENDL; if (!_CrtCheckMemory()) { LL_WARNS() << "_CrtCheckMemory() failed at prior to cleanup!" << LL_ENDL; } else { LL_INFOS() << " No corruption detected." << LL_ENDL; } #endif gGLActive = TRUE; viewer_app_ptr->cleanup(); #if WINDOWS_CRT_MEM_CHECKS LL_INFOS() << "CRT Checking memory:" << LL_ENDL; if (!_CrtCheckMemory()) { LL_WARNS() << "_CrtCheckMemory() failed after cleanup!" << LL_ENDL; } else { LL_INFOS() << " No corruption detected." << LL_ENDL; } #endif } delete viewer_app_ptr; viewer_app_ptr = NULL; //start updater if(LLAppViewer::sUpdaterInfo) { _spawnl(_P_NOWAIT, LLAppViewer::sUpdaterInfo->mUpdateExePath.c_str(), LLAppViewer::sUpdaterInfo->mUpdateExePath.c_str(), LLAppViewer::sUpdaterInfo->mParams.str().c_str(), NULL); delete LLAppViewer::sUpdaterInfo ; LLAppViewer::sUpdaterInfo = NULL ; } #ifdef USE_NVAPI // (NVAPI) (6) We clean up. This is analogous to doing a free() if (hSession) { NvAPI_DRS_DestroySession(hSession); hSession = 0; } #endif return 0; }
BOOLEAN InitializeNvApi(VOID) { NvGpuPhysicalHandleList = PhCreateList(1); NvGpuDisplayHandleList = PhCreateList(1); #ifdef _M_IX86 if (!(NvApiLibrary = LoadLibrary(L"nvapi.dll"))) return FALSE; #else if (!(NvApiLibrary = LoadLibrary(L"nvapi64.dll"))) return FALSE; #endif if (!(NvAPI_QueryInterface = PhGetProcedureAddress(NvApiLibrary, "nvapi_QueryInterface", 0))) return FALSE; if (!(NvAPI_Initialize = NvAPI_QueryInterface(0x150E828UL))) return FALSE; if (!(NvAPI_Unload = NvAPI_QueryInterface(0xD22BDD7EUL))) return FALSE; if (!(NvAPI_GetErrorMessage = NvAPI_QueryInterface(0x6C2D048CUL))) return FALSE; if (!(NvAPI_EnumPhysicalGPUs = NvAPI_QueryInterface(0xE5AC921FUL))) return FALSE; if (!(NvAPI_EnumNvidiaDisplayHandle = NvAPI_QueryInterface(0x9ABDD40DUL))) return FALSE; // Information functions NvAPI_SYS_GetDriverAndBranchVersion = NvAPI_QueryInterface(0x2926AAADUL); NvAPI_GPU_GetFullName = NvAPI_QueryInterface(0xCEEE8E9FUL); // Query functions NvAPI_GPU_GetMemoryInfo = NvAPI_QueryInterface(0x774AA982UL); NvAPI_GPU_GetThermalSettings = NvAPI_QueryInterface(0xE3640A56UL); NvAPI_GPU_GetCoolerSettings = NvAPI_QueryInterface(0xDA141340UL); NvAPI_GPU_GetPerfDecreaseInfo = NvAPI_QueryInterface(0x7F7F4600UL); NvAPI_GPU_GetTachReading = NvAPI_QueryInterface(0x5F608315UL); NvAPI_GPU_GetAllClockFrequencies = NvAPI_QueryInterface(0xDCB616C3UL); // Undocumented Query functions NvAPI_GPU_GetUsages = NvAPI_QueryInterface(0x189A1FDFUL); NvAPI_GPU_GetAllClocks = NvAPI_QueryInterface(0x1BD69F49UL); NvAPI_GPU_GetVoltageDomainsStatus = NvAPI_QueryInterface(0xC16C7E2CUL); //NvAPI_GPU_GetPerfClocks = NvAPI_QueryInterface(0x1EA54A3B); //NvAPI_GPU_GetVoltages = NvAPI_QueryInterface(0x7D656244); //NvAPI_GPU_QueryActiveApps = NvAPI_QueryInterface(0x65B1C5F5); //NvAPI_GPU_GetShaderPipeCount = NvAPI_QueryInterface(0x63E2F56F); //NvAPI_GPU_GetShaderSubPipeCount = NvAPI_QueryInterface(0x0BE17923); NvAPI_GPU_GetRamBusWidth = NvAPI_QueryInterface(0x7975C581); // ADD ME NvAPI_GPU_GetRamBankCount = NvAPI_QueryInterface(0x17073A3CUL); NvAPI_GPU_GetRamType = NvAPI_QueryInterface(0x57F7CAACUL); NvAPI_GPU_GetRamMaker = NvAPI_QueryInterface(0x42AEA16AUL); NvAPI_GPU_GetFoundry = NvAPI_QueryInterface(0x5D857A00UL); //NvAPI_GetDisplayDriverMemoryInfo = NvAPI_QueryInterface(0x774AA982); //NvAPI_GetPhysicalGPUsFromDisplay = NvAPI_QueryInterface(0x34EF9506); NvAPI_GetDisplayDriverVersion = NvAPI_QueryInterface(0xF951A4D1UL); NvAPI_GetDisplayDriverRegistryPath = NvAPI_QueryInterface(0x0E24CEEEUL); //NvAPI_RestartDisplayDriver = NvAPI_QueryInterface(0xB4B26B65UL); //NvAPI_GPU_GetBoardInfo = NvAPI_QueryInterface(0x22D54523); //NvAPI_GPU_GetBusType = NvAPI_QueryInterface(0x1BB18724); //NvAPI_GPU_GetIRQ = NvAPI_QueryInterface(0xE4715417); NvAPI_GPU_GetVbiosVersionString = NvAPI_QueryInterface(0xA561FD7DUL); NvAPI_GPU_GetShortName = NvAPI_QueryInterface(0xD988F0F3UL); NvAPI_GPU_GetArchInfo = NvAPI_QueryInterface(0xD8265D24UL); NvAPI_GPU_GetPCIIdentifiers = NvAPI_QueryInterface(0x2DDFB66EUL); NvAPI_GPU_GetPartitionCount = NvAPI_QueryInterface(0x86F05D7AUL); NvAPI_GPU_GetGpuCoreCount = NvAPI_QueryInterface(0xC7026A87UL); NvAPI_GPU_GetPCIEInfo = NvAPI_QueryInterface(0xE3795199UL); NvAPI_GPU_GetFBWidthAndLocation = NvAPI_QueryInterface(0x11104158UL); NvAPI_GPU_ClientPowerTopologyGetStatus = NvAPI_QueryInterface(0x0EDCF624EUL); //typedef NvAPI_Status (WINAPIV *_NvAPI_GetDisplayDriverBuildTitle)(_In_ NvDisplayHandle hNvDisplay, NvAPI_ShortString pDriverBuildTitle); //typedef NvAPI_Status (WINAPIV *_NvAPI_GetDisplayDriverCompileType)(_In_ NvDisplayHandle hNvDisplay, NvU32* pDriverCompileType); //typedef NvAPI_Status (WINAPIV *_NvAPI_GetDisplayDriverSecurityLevel)(_In_ NvDisplayHandle hNvDisplay, NvU32* pDriverSecurityLevel); //typedef NvAPI_Status (WINAPIV *_NvAPI_GPU_GetVPECount)(_In_ NvPhysicalGpuHandle hPhysicalGPU, NvU32* pVPECount); //typedef NvAPI_Status (WINAPIV *_NvAPI_GPU_GetSerialNumber)(_In_ NvPhysicalGpuHandle hPhysicalGPU, NvU32* serialnumber); //typedef NvAPI_Status (WINAPIV *_NvAPI_GPU_GetExtendedMinorRevision)(_In_ NvPhysicalGpuHandle hPhysicalGPU, NvU32* revision); //typedef NvAPI_Status (WINAPIV *_NvAPI_GPU_GetTargetID)(_In_ NvPhysicalGpuHandle hPhysicalGPU, NvU32* target); //_NvAPI_GPU_GetExtendedMinorRevision NvAPI_GPU_GetExtendedMinorRevision; //_NvAPI_GPU_GetTargetID NvAPI_GPU_GetTargetID; //_NvAPI_GPU_GetSerialNumber NvAPI_GPU_GetSerialNumber; //_NvAPI_GPU_GetVPECount NvAPI_GPU_GetVPECount; //_NvAPI_GetDisplayDriverBuildTitle NvAPI_GetDisplayDriverBuildTitle; //_NvAPI_GetDisplayDriverCompileType NvAPI_GetDisplayDriverCompileType; //_NvAPI_GetDisplayDriverSecurityLevel NvAPI_GetDisplayDriverSecurityLevel; //NvAPI_GPU_GetExtendedMinorRevision = NvAPI_QueryInterface(0x025F17421); //NvAPI_GPU_GetTargetID = NvAPI_QueryInterface(0x35B5FD2F); //NvAPI_GPU_GetSerialNumber = NvAPI_QueryInterface(0x14B83A5F); //NvAPI_GPU_GetVPECount = NvAPI_QueryInterface(0xD8CBF37B); //NvAPI_GetDisplayDriverBuildTitle = NvAPI_QueryInterface(0x7562E947); //NvAPI_GetDisplayDriverCompileType = NvAPI_QueryInterface(0x988AEA78); //NvAPI_GetDisplayDriverSecurityLevel = NvAPI_QueryInterface(0x9D772BBA); if (NvAPI_Initialize() == NVAPI_OK) { NvGpuEnumPhysicalHandles(); NvGpuEnumDisplayHandles(); return TRUE; } return FALSE; }
VOID InitGfx(VOID) { HMODULE module; // Specify the nVidia Library to load. #ifdef _M_IX86 module = LoadLibrary(L"nvapi.dll"); #else module = LoadLibrary(L"nvapi64.dll"); #endif if (module == NULL) { // Specify the Ati Library to load. #ifdef _M_IX86 module = LoadLibrary(L"atiadlxy.dll"); #else module = LoadLibrary(L"atiadlxx.dll"); #endif if (module != NULL) { GraphicsType = AtiGraphics; } } else { GraphicsType = NvidiaGraphics; } switch (GraphicsType) { case NvidiaGraphics: { // Find our QueryInterface API NvAPI_QueryInterface = (P_NvAPI_QueryInterface)GetProcAddress(module, "nvapi_QueryInterface"); // Check if QueryInterface was found. if (NvAPI_QueryInterface != NULL) { // 50/50 these ID's and API defs are correct. // Library initialization functions NvAPI_Initialize = (P_NvAPI_Initialize)NvAPI_QueryInterface(0x150E828); NvAPI_Unload = (P_NvAPI_Unload)NvAPI_QueryInterface(0xD22BDD7E); // Error Functions NvAPI_GetErrorMessage = (P_NvAPI_GetErrorMessage)NvAPI_QueryInterface(0x6C2D048Cu); // Handle Functions NvAPI_EnumPhysicalGPUs = (P_NvAPI_EnumPhysicalGPUs)NvAPI_QueryInterface(0xE5AC921F); NvAPI_EnumNvidiaDisplayHandle = (P_NvAPI_EnumNvidiaDisplayHandle)NvAPI_QueryInterface(0x9ABDD40D); // Query Functions NvAPI_GetUsages = (P_NvAPI_GPU_GetUsages)NvAPI_QueryInterface(0x189A1FDF); NvAPI_GetMemoryInfo = (P_NvAPI_GetMemoryInfo)NvAPI_QueryInterface(0x774AA982); NvAPI_GetPhysicalGPUsFromDisplay = (P_NvAPI_GetPhysicalGPUsFromDisplay)NvAPI_QueryInterface(0x34EF9506); NvAPI_GetInterfaceVersionString = (P_NvAPI_GetInterfaceVersionString)NvAPI_QueryInterface(0x1053FA5); NvAPI_GetFullName = (P_NvAPI_GPU_GetFullName)NvAPI_QueryInterface(0xCEEE8E9F); NvAPI_GetAllClocks = (P_NvAPI_GPU_GetAllClocks)NvAPI_QueryInterface(0x1BD69F49); NvAPI_GetThermalSettings = (P_NvAPI_GPU_GetThermalSettings)NvAPI_QueryInterface(0xE3640A56); NvAPI_GetCoolerSettings = (P_NvAPI_GPU_GetCoolerSettings)NvAPI_QueryInterface(0xDA141340); NvAPI_GetDisplayDriverVersion = (P_NvAPI_GetDisplayDriverVersion)NvAPI_QueryInterface(0xF951A4D1); NvAPI_GetPerfDecreaseInfo = (P_NvAPI_GPU_GetPerfDecreaseInfo)NvAPI_QueryInterface(0x7F7F4600); { NvStatus status = NvAPI_Initialize(); if (NV_SUCCESS(status)) { physHandle = EnumNvidiaGpuHandles(); dispHandle = EnumNvidiaDisplayHandles(); } else { LogEvent(L"gfxinfo: (InitGfx) NvAPI_Initialize failed (%s)", status); } } } } break; case AtiGraphics: { //ADL_MAIN_CONTROL_DESTROY ADL_Main_Control_Destroy = NULL; //ADL_ADAPTER_NUMBEROFADAPTERS_GET ADL_Adapter_NumberOfAdapters_Get = NULL; //ADL_ADAPTER_ADAPTERINFO_GET ADL_Adapter_AdapterInfo_Get = NULL; //ADL_Main_Control_Create = (ADL_MAIN_CONTROL_CREATE)GetProcAddress(module, "ADL_Main_Control_Create"); //ADL_Main_Control_Destroy = (ADL_MAIN_CONTROL_DESTROY)GetProcAddress(module, "ADL_Main_Control_Destroy"); //ADL_Adapter_NumberOfAdapters_Get = (ADL_ADAPTER_NUMBEROFADAPTERS_GET)GetProcAddress(module, "ADL_Adapter_NumberOfAdapters_Get"); //ADL_Adapter_AdapterInfo_Get = (ADL_ADAPTER_ADAPTERINFO_GET)GetProcAddress(module, "ADL_Adapter_AdapterInfo_Get"); //ADL_Display_DisplayInfo_Get = (ADL_DISPLAY_DISPLAYINFO_GET)GetProcAddress(module, "ADL_Display_DisplayInfo_Get"); //ADL_Display_ColorCaps_Get = (ADL_DISPLAY_COLORCAPS_GET)GetProcAddress(module, "ADL_Display_ColorCaps_Get"); //ADL_Display_Color_Get = (ADL_DISPLAY_COLOR_GET)GetProcAddress(module, "ADL_Display_Color_Get"); //ADL_Display_Color_Set = (ADL_DISPLAY_COLOR_SET)GetProcAddress(module, "ADL_Display_Color_Set"); //Adl_GetCurrentActivity = (P_Adl_OVERDRIVE_CURRENTACTIVITY_Get)GetProcAddress(module, "ADL_Overdrive5_CurrentActivity_Get"); } break; default: { } break; } }
RF_Type::Bool NvidiaGPUService::IsAvailable() { NvAPI_Status ret = NVAPI_OK; ret = NvAPI_Initialize(); return ret == NVAPI_OK; }
VOID NvApiInitialize(VOID) { ULONG sampleCount; if (!PhGetIntegerSetting(SETTING_NAME_ENABLE_GPU)) return; sampleCount = PhGetIntegerSetting(L"SampleCount"); PhInitializeCircularBuffer_FLOAT(&GpuUtilizationHistory, sampleCount); PhInitializeCircularBuffer_ULONG(&GpuMemoryHistory, sampleCount); PhInitializeCircularBuffer_FLOAT(&GpuBoardHistory, sampleCount); PhInitializeCircularBuffer_FLOAT(&GpuBusHistory, sampleCount); NvGpuPhysicalHandleList = PhCreateList(1); NvGpuDisplayHandleList = PhCreateList(1); #ifdef _M_IX86 if (!(NvApiLibrary = LoadLibrary(L"nvapi.dll"))) return; #else if (!(NvApiLibrary = LoadLibrary(L"nvapi64.dll"))) return; #endif // Retrieve the NvAPI_QueryInterface function address if (!(NvAPI_QueryInterface = PhGetProcedureAddress(NvApiLibrary, "nvapi_QueryInterface", 0))) return; // Initialization functions if (!(NvAPI_Initialize = NvAPI_QueryInterface(0x150E828UL))) return; if (!(NvAPI_Unload = NvAPI_QueryInterface(0xD22BDD7EUL))) return; // Error functions NvAPI_GetErrorMessage = NvAPI_QueryInterface(0x6C2D048CUL); // Handle functions NvAPI_EnumPhysicalGPUs = NvAPI_QueryInterface(0xE5AC921FUL); NvAPI_EnumNvidiaDisplayHandle = NvAPI_QueryInterface(0x9ABDD40DUL); // Information functions NvAPI_SYS_GetDriverAndBranchVersion = NvAPI_QueryInterface(0x2926AAADUL); NvAPI_GPU_GetFullName = NvAPI_QueryInterface(0xCEEE8E9FUL); // Query functions NvAPI_GPU_GetMemoryInfo = NvAPI_QueryInterface(0x774AA982UL); NvAPI_GPU_GetThermalSettings = NvAPI_QueryInterface(0xE3640A56UL); NvAPI_GPU_GetCoolerSettings = NvAPI_QueryInterface(0xDA141340UL); NvAPI_GPU_GetPerfDecreaseInfo = NvAPI_QueryInterface(0x7F7F4600UL); NvAPI_GPU_GetTachReading = NvAPI_QueryInterface(0x5F608315UL); NvAPI_GPU_GetAllClockFrequencies = NvAPI_QueryInterface(0xDCB616C3UL); // Undocumented functions below NvAPI_GPU_GetUsages = NvAPI_QueryInterface(0x189A1FDFUL); NvAPI_GPU_GetAllClocks = NvAPI_QueryInterface(0x1BD69F49UL); NvAPI_GPU_GetVoltageDomainsStatus = NvAPI_QueryInterface(0xC16C7E2CUL); NvAPI_GPU_GetPerfClocks = NvAPI_QueryInterface(0x1EA54A3B); NvAPI_GPU_GetVoltages = NvAPI_QueryInterface(0x7D656244); NvAPI_GPU_QueryActiveApps = NvAPI_QueryInterface(0x65B1C5F5); NvAPI_GPU_GetShaderPipeCount = NvAPI_QueryInterface(0x63E2F56F); NvAPI_GPU_GetShaderSubPipeCount = NvAPI_QueryInterface(0x0BE17923); NvAPI_GPU_GetRamBusWidth = NvAPI_QueryInterface(0x7975C581); NvAPI_GPU_GetRamBankCount = NvAPI_QueryInterface(0x17073A3CUL); NvAPI_GPU_GetRamType = NvAPI_QueryInterface(0x57F7CAACUL); NvAPI_GPU_GetRamMaker = NvAPI_QueryInterface(0x42AEA16AUL); NvAPI_GPU_GetFoundry = NvAPI_QueryInterface(0x5D857A00UL); //NvAPI_GetDisplayDriverMemoryInfo = NvAPI_QueryInterface(0x774AA982); //NvAPI_GetPhysicalGPUsFromDisplay = NvAPI_QueryInterface(0x34EF9506); NvAPI_GetDisplayDriverVersion = NvAPI_QueryInterface(0xF951A4D1UL); NvAPI_GetDisplayDriverRegistryPath = NvAPI_QueryInterface(0x0E24CEEEUL); //NvAPI_RestartDisplayDriver = NvAPI_QueryInterface(0xB4B26B65UL); //NvAPI_GPU_GetBoardInfo = NvAPI_QueryInterface(0x22D54523); //NvAPI_GPU_GetBusType = NvAPI_QueryInterface(0x1BB18724); //NvAPI_GPU_GetIRQ = NvAPI_QueryInterface(0xE4715417); NvAPI_GPU_GetVbiosVersionString = NvAPI_QueryInterface(0xA561FD7DUL); NvAPI_GPU_GetShortName = NvAPI_QueryInterface(0xD988F0F3UL); NvAPI_GPU_GetArchInfo = NvAPI_QueryInterface(0xD8265D24UL); NvAPI_GPU_GetPCIIdentifiers = NvAPI_QueryInterface(0x2DDFB66EUL); NvAPI_GPU_GetPartitionCount = NvAPI_QueryInterface(0x86F05D7AUL); NvAPI_GPU_GetGpuCoreCount = NvAPI_QueryInterface(0xC7026A87UL); NvAPI_GPU_GetPCIEInfo = NvAPI_QueryInterface(0xE3795199UL); NvAPI_GPU_GetFBWidthAndLocation = NvAPI_QueryInterface(0x11104158UL); NvAPI_GPU_ClientPowerTopologyGetStatus = NvAPI_QueryInterface(0x0EDCF624EUL); NvAPI_GetDisplayDriverBuildTitle = NvAPI_QueryInterface(0x7562E947); NvAPI_GetDisplayDriverCompileType = NvAPI_QueryInterface(0x988AEA78); NvAPI_GetDisplayDriverSecurityLevel = NvAPI_QueryInterface(0x9D772BBA); NvAPI_GPU_GetVPECount = NvAPI_QueryInterface(0xD8CBF37B); NvAPI_GPU_GetTargetID = NvAPI_QueryInterface(0x35B5FD2F); //NvAPI_GPU_GetExtendedMinorRevision = NvAPI_QueryInterface(0x025F17421); //NvAPI_GPU_GetSerialNumber = NvAPI_QueryInterface(0x14B83A5F); if (NvAPI_Initialize() == NVAPI_OK) { NvGpuEnumPhysicalHandles(); NvGpuEnumDisplayHandles(); NvApiInitialized = TRUE; } }
HRESULT CGPUUsage::Init(CString DeviceName) { Clean(); { // ATI OverDrive ATIData.hAtiADL = LoadLibrary(L"atiadlxx.dll"); if (ATIData.hAtiADL == NULL) { ATIData.hAtiADL = LoadLibrary(L"atiadlxy.dll"); } if (ATIData.hAtiADL) { ADL_MAIN_CONTROL_CREATE ADL_Main_Control_Create; ADL_ADAPTER_NUMBEROFADAPTERS_GET ADL_Adapter_NumberOfAdapters_Get; ADL_ADAPTER_ADAPTERINFO_GET ADL_Adapter_AdapterInfo_Get; ADL_ADAPTER_ACTIVE_GET ADL_Adapter_Active_Get; ADL_OVERDRIVE_CAPS ADL_Overdrive_Caps; ADL_Main_Control_Create = (ADL_MAIN_CONTROL_CREATE)GetProcAddress(ATIData.hAtiADL,"ADL_Main_Control_Create"); ATIData.ADL_Main_Control_Destroy = (ADL_MAIN_CONTROL_DESTROY)GetProcAddress(ATIData.hAtiADL,"ADL_Main_Control_Destroy"); ADL_Adapter_NumberOfAdapters_Get = (ADL_ADAPTER_NUMBEROFADAPTERS_GET)GetProcAddress(ATIData.hAtiADL,"ADL_Adapter_NumberOfAdapters_Get"); ADL_Adapter_AdapterInfo_Get = (ADL_ADAPTER_ADAPTERINFO_GET)GetProcAddress(ATIData.hAtiADL,"ADL_Adapter_AdapterInfo_Get"); ADL_Adapter_Active_Get = (ADL_ADAPTER_ACTIVE_GET)GetProcAddress(ATIData.hAtiADL, "ADL_Adapter_Active_Get"); ADL_Overdrive_Caps = (ADL_OVERDRIVE_CAPS)GetProcAddress(ATIData.hAtiADL, "ADL_Overdrive_Caps"); if (NULL == ADL_Main_Control_Create || NULL == ATIData.ADL_Main_Control_Destroy || NULL == ADL_Adapter_NumberOfAdapters_Get || NULL == ADL_Adapter_AdapterInfo_Get || NULL == ADL_Adapter_Active_Get || NULL == ADL_Overdrive_Caps) { Clean(); } if (ATIData.hAtiADL) { int iNumberAdapters = 0; if (ADL_OK == ADL_Main_Control_Create(ADL_Main_Memory_Alloc, 1) && ADL_OK == ADL_Adapter_NumberOfAdapters_Get(&iNumberAdapters) && iNumberAdapters) { LPAdapterInfo lpAdapterInfo = DNew AdapterInfo[iNumberAdapters]; if (lpAdapterInfo) { memset(lpAdapterInfo, 0, sizeof(AdapterInfo) * iNumberAdapters); // Get the AdapterInfo structure for all adapters in the system ADL_Adapter_AdapterInfo_Get(lpAdapterInfo, sizeof(AdapterInfo) * iNumberAdapters); for (int i = 0; i < iNumberAdapters; i++ ) { int adapterActive = 0; AdapterInfo adapterInfo = lpAdapterInfo[i]; ADL_Adapter_Active_Get(adapterInfo.iAdapterIndex, &adapterActive); if (adapterActive && adapterInfo.iAdapterIndex >= 0 && adapterInfo.iVendorID == 1002) { if (DeviceName.GetLength() && DeviceName != CString(adapterInfo.strDisplayName)) { continue; } int iOverdriveSupported = 0; int iOverdriveEnabled = 0; if (ADL_OK != ADL_Overdrive_Caps(adapterInfo.iAdapterIndex, &iOverdriveSupported, &iOverdriveEnabled, &ATIData.iOverdriveVersion) || !iOverdriveSupported) { break; } if (ATIData.iOverdriveVersion == 5) { ADL_OVERDRIVE5_ODPARAMETERS_GET ADL_Overdrive5_ODParameters_Get; ADL_Overdrive5_ODParameters_Get = (ADL_OVERDRIVE5_ODPARAMETERS_GET)GetProcAddress(ATIData.hAtiADL, "ADL_Overdrive5_ODParameters_Get"); ATIData.ADL_Overdrive5_CurrentActivity_Get = (ADL_OVERDRIVE5_CURRENTACTIVITY_GET)GetProcAddress(ATIData.hAtiADL, "ADL_Overdrive5_CurrentActivity_Get"); if (NULL == ADL_Overdrive5_ODParameters_Get || NULL == ATIData.ADL_Overdrive5_CurrentActivity_Get) { break; } ADLODParameters overdriveParameters = {0}; overdriveParameters.iSize = sizeof (ADLODParameters); if (ADL_OK != ADL_Overdrive5_ODParameters_Get(adapterInfo.iAdapterIndex, &overdriveParameters) || !overdriveParameters.iActivityReportingSupported) { break; } ATIData.iAdapterId = adapterInfo.iAdapterIndex; } else if (ATIData.iOverdriveVersion == 6) { ADL_OVERDRIVE6_CAPABILITIES_GET ADL_Overdrive6_Capabilities_Get; ADL_Overdrive6_Capabilities_Get = (ADL_OVERDRIVE6_CAPABILITIES_GET)GetProcAddress(ATIData.hAtiADL, "ADL_Overdrive6_Capabilities_Get"); ATIData.ADL_Overdrive6_CurrentStatus_Get = (ADL_OVERDRIVE6_CURRENTSTATUS_GET)GetProcAddress(ATIData.hAtiADL, "ADL_Overdrive6_CurrentStatus_Get"); if (NULL == ADL_Overdrive6_Capabilities_Get || NULL == ATIData.ADL_Overdrive6_CurrentStatus_Get) { break; } ADLOD6Capabilities od6Capabilities = {0}; if (ADL_OK != ADL_Overdrive6_Capabilities_Get(adapterInfo.iAdapterIndex, &od6Capabilities) || (od6Capabilities.iCapabilities & ADL_OD6_CAPABILITY_GPU_ACTIVITY_MONITOR) != ADL_OD6_CAPABILITY_GPU_ACTIVITY_MONITOR) { break; } ATIData.iAdapterId = adapterInfo.iAdapterIndex; } break; } } delete [] lpAdapterInfo; } } } } if (ATIData.iAdapterId == -1 && ATIData.hAtiADL) { Clean(); } if (ATIData.iAdapterId >= 0 && ATIData.hAtiADL) { m_GPUType = ATI_GPU; } } if (m_GPUType == UNKNOWN_GPU) { // NVApi NVData.hNVApi = LoadLibrary(L"nvapi64.dll"); if (NVData.hNVApi == NULL) { NVData.hNVApi = LoadLibrary(L"nvapi.dll"); } if (NVData.hNVApi) { NvAPI_QueryInterface_t NvAPI_QueryInterface = (NvAPI_QueryInterface_t)GetProcAddress(NVData.hNVApi, "nvapi_QueryInterface"); NvAPI_Initialize_t NvAPI_Initialize = NULL; NvAPI_EnumPhysicalGPUs_t NvAPI_EnumPhysicalGPUs = NULL; if (NvAPI_QueryInterface) { NvAPI_Initialize = (NvAPI_Initialize_t)(NvAPI_QueryInterface)(0x0150E828); NvAPI_EnumPhysicalGPUs = (NvAPI_EnumPhysicalGPUs_t)(NvAPI_QueryInterface)(0xE5AC921F); NVData.NvAPI_GPU_GetUsages = (NvAPI_GPU_GetUsages_t)(NvAPI_QueryInterface)(0x189A1FDF); } if (NULL == NvAPI_QueryInterface || NULL == NvAPI_Initialize || NULL == NvAPI_EnumPhysicalGPUs || NULL == NVData.NvAPI_GPU_GetUsages) { Clean(); } if (NVData.hNVApi) { NvAPI_Initialize(); int gpuCount = 0; NvAPI_EnumPhysicalGPUs(NVData.gpuHandles, &gpuCount); if (!gpuCount) { Clean(); } } } if (NVData.hNVApi && NVData.NvAPI_GPU_GetUsages) { m_GPUType = NVIDIA_GPU; } } return m_GPUType == UNKNOWN_GPU ? E_FAIL : S_OK; }
bool StDXManager::getInfo(StDXInfo& theInfo, const bool theForced) { if(!theForced) { if(ST_DX_HAS_CACHED_INFO) { theInfo = ST_DX_CACHED_INFO; return true; } } const StStringUtfWide AQBS_TEST_CLASS = L"StTESTAqbsWin"; HINSTANCE anAppInst = GetModuleHandle(NULL); WNDCLASSW aWinClass; aWinClass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; aWinClass.lpfnWndProc = (WNDPROC )aDummyWinProc; aWinClass.cbClsExtra = 0; aWinClass.cbWndExtra = 0; aWinClass.hInstance = anAppInst; aWinClass.hIcon = LoadIcon(anAppInst, L"A"); aWinClass.hCursor = LoadCursor(NULL, IDC_ARROW); aWinClass.hbrBackground = NULL; aWinClass.lpszMenuName = NULL; aWinClass.lpszClassName = AQBS_TEST_CLASS.toCString(); // class name if(RegisterClassW(&aWinClass) == 0) { ST_DEBUG_LOG("Failed to RegisterClass '" + AQBS_TEST_CLASS.toUtf8() + "'"); return false; } HWND aWinHandle = CreateWindowExW(WS_EX_TOOLWINDOW | WS_EX_WINDOWEDGE | WS_EX_NOACTIVATE, AQBS_TEST_CLASS.toCString(), L"StTESTAqbs Window", WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN, 32, 32, 32, 32, NULL, NULL, anAppInst, NULL); if(aWinHandle == NULL) { ST_DEBUG_LOG("Failed to create 'StTESTAqbsWin' window (" + int(GetLastError()) + ")"); UnregisterClassW(AQBS_TEST_CLASS.toCString(), anAppInst); return false; } StHandle<StDXManager> aDXManager = new StDXManager(); // test AQBS support theInfo.hasAqbsSupport = aDXManager->checkAqbsSupport(aWinHandle); // enumerate available adapters if(aDXManager->myD3dLib != NULL) { const UINT aD3dAdaptersNb = aDXManager->getAdapterCount(); D3DADAPTER_IDENTIFIER9 anAdapterInfo; for(UINT anAdapterIter = 0; anAdapterIter < aD3dAdaptersNb; ++anAdapterIter) { aDXManager->getAdapterIdentifier(anAdapterIter, 0, &anAdapterInfo); if(anAdapterInfo.VendorId == ST_DX_VENDOR_AMD) { theInfo.hasAmdAdapter = true; } else if(anAdapterInfo.VendorId == ST_DX_VENDOR_NVIDIA) { theInfo.hasNvAdapter = true; } } } // release resources aDXManager.nullify(); DestroyWindow(aWinHandle); UnregisterClass(AQBS_TEST_CLASS.toCString(), anAppInst); // check NVIDIA Stereo enabled state if(NvAPI_Initialize() == NVAPI_OK) { NvU8 isStereoEnabled = FALSE; NvAPI_Stereo_IsEnabled(&isStereoEnabled); theInfo.hasNvStereoSupport = isStereoEnabled == TRUE; } //ST_DEBUG_LOG("DXInfo, AMD(" + int(theInfo.hasAmdAdapter) + "), AQBS(" + int(theInfo.hasAqbsSupport) // + "); NVIDIA(" + int(theInfo.hasNvAdapter) + "), NvStereo(" + int(theInfo.hasNvStereoSupport) + ")"); // cache the state to avoid unnecessary calls ST_DX_CACHED_INFO = theInfo; ST_DX_HAS_CACHED_INFO = true; return true; }