Jens/LumaOps-Public
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Publish LumaOps source

Browse Source
This commit is contained in:
LumaOps release export
2026-09-03 01:18:36 +02:00
commit 7f1c0e5f71
2363 changed files with 501543 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Controllers/HPOmenLaptopController/HPOmenLaptopController_Windows.cpp
+340
View File
@@ -0,0 +1,340 @@
/*---------------------------------------------------------*\
| HPOmenLaptopController_Windows.cpp |
| |
| Driver for HP Omen laptop |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "HPOmenLaptopController_Windows.h"
#include <Wbemidl.h>
#include <comdef.h>
#define RESULT_STEP 5
#define PARAM_STEP 4
#define OBJ_STEP 3
#define SERVICE_STEP 2
#define LOCATE_STEP 1
#define INIT_STEP 0
HPOmenLaptopController_Windows::HPOmenLaptopController_Windows()
{
}
HPOmenLaptopController_Windows::~HPOmenLaptopController_Windows()
{
}
void HPOmenLaptopController_Windows::cleanup(int fail_level)
{
/*-----------------------------------------------------*\
| Cleanup for the execute method |
\*-----------------------------------------------------*/
switch(fail_level)
{
case RESULT_STEP:
if (callResult)
{
callResult->Release();
}
case PARAM_STEP:
methodParameters->Release();
case OBJ_STEP:
classObject->Release();
case SERVICE_STEP:
pSvc->Release();
case LOCATE_STEP:
pLoc->Release();
case INIT_STEP:
CoUninitialize();
}
}
int HPOmenLaptopController_Windows::execute(int command, int commandType, int inputDataSize, BYTE* inputData, int* returnDataSize, BYTE** returnData)
{
/*-----------------------------------------------------*\
| Talk to WMI |
\*-----------------------------------------------------*/
// magic constant
static const BYTE Sign[4] = { 83, 69, 67, 85 };
// will hold the return codes from all the calls to WMI
HRESULT hres;
// initialize COM interface
hres = CoInitializeEx(0, COINIT_APARTMENTTHREADED);
if(FAILED(hres))
{
return 1;
}
// obtain the initial locator to the Windows Management Instrumentation
pLoc = nullptr;
hres = CoCreateInstance(CLSID_WbemLocator, 0, CLSCTX_INPROC_SERVER, IID_IWbemLocator, (LPVOID*) &pLoc );
if(FAILED(hres))
{
cleanup(INIT_STEP);
return 1;
}
pSvc = nullptr;
hres = pLoc->ConnectServer(_bstr_t(L"ROOT\\WMI"), NULL, NULL, 0, NULL, 0, 0, &pSvc);
if(FAILED(hres))
{
cleanup(LOCATE_STEP);
return 1;
}
hres = CoSetProxyBlanket(
pSvc, // Indicates the proxy to set
RPC_C_AUTHN_WINNT, // RPC_C_AUTHN_xxx
RPC_C_AUTHZ_NONE, // RPC_C_AUTHZ_xxx
NULL, // Server principal name
RPC_C_AUTHN_LEVEL_CALL, // RPC_C_AUTHN_LEVEL_xxx
RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
NULL, // client identity
EOAC_NONE // proxy capabilities
);
if(FAILED(hres))
{
cleanup(SERVICE_STEP);
return 1;
}
/*-----------------------------------------------------*\
| Get all the required custom hp wmi obejcts |
\*-----------------------------------------------------*/
classObject = nullptr;
hres = pSvc->GetObject(_bstr_t(L"hpqBIntM"), 0, NULL, &classObject, NULL);
if(FAILED(hres))
{
cleanup(SERVICE_STEP);
return 1;
}
methodParameters = nullptr;
hres = classObject->GetMethod(L"hpqBIOSInt128", 0, &methodParameters, NULL);
if(FAILED(hres))
{
cleanup(OBJ_STEP);
return 1;
}
dataInClass = nullptr;
hres = pSvc->GetObject(_bstr_t(L"hpqBDataIn"), 0, NULL, &dataInClass, NULL);
if(FAILED(hres))
{
cleanup(PARAM_STEP);
return 1;
}
callResult = nullptr;
hres = pSvc->GetObject(_bstr_t(L"hpqBDataOut128"), 0, NULL, NULL, &callResult);
if(FAILED(hres))
{
dataInClass->Release();
cleanup(PARAM_STEP);
return 1;
}
/*-----------------------------------------------------*\
| Populate the input parameters |
\*-----------------------------------------------------*/
// Sign
VARIANT signVar;
VariantInit(&signVar);
signVar.vt = VT_UI1 | VT_ARRAY;
SAFEARRAYBOUND safeArrayBound = { 4, 0 };
signVar.parray = SafeArrayCreate(VT_UI1, 1, &safeArrayBound);
SafeArrayLock(signVar.parray);
memcpy(signVar.parray->pvData, Sign, sizeof(Sign));
SafeArrayUnlock(signVar.parray);
dataInClass->Put(L"Sign", 0, &signVar, 0);
VariantClear(&signVar);
// Command
VARIANT commandVar;
VariantInit(&commandVar);
commandVar.vt = VT_I4;
commandVar.lVal = command;
dataInClass->Put(L"Command", 0, &commandVar, 0);
VariantClear(&commandVar);
// CommandType
VARIANT commandTypeVar;
VariantInit(&commandTypeVar);
commandTypeVar.vt = VT_I4;
commandTypeVar.lVal = commandType;
dataInClass->Put(L"CommandType", 0, &commandTypeVar, 0);
VariantClear(&commandTypeVar);
// Size
VARIANT sizeVar;
VariantInit(&sizeVar);
sizeVar.vt = VT_I4;
sizeVar.lVal = inputDataSize;
dataInClass->Put(L"Size", 0, &sizeVar, 0);
// hpqBData
VARIANT hpqBDataVar;
VariantInit(&hpqBDataVar);
hpqBDataVar.vt = VT_UI1 | VT_ARRAY;
SAFEARRAYBOUND safeArrayBoundData = { static_cast<ULONG>(inputDataSize), 0 };
hpqBDataVar.parray = SafeArrayCreate(VT_UI1, 1, &safeArrayBoundData);
SafeArrayLock(hpqBDataVar.parray);
memcpy(hpqBDataVar.parray->pvData, inputData, inputDataSize);
SafeArrayUnlock(hpqBDataVar.parray);
dataInClass->Put(L"hpqBData", 0, &hpqBDataVar, 0);
VariantClear(&hpqBDataVar);
/*-----------------------------------------------------------*\
| Fill the 'InData' parameter from the 'hpqBIOSInt128' method |
\*-----------------------------------------------------------*/
// InData
VARIANT inDataVar;
VariantInit(&inDataVar);
inDataVar.vt = VT_UNKNOWN;
inDataVar.punkVal = dataInClass;
methodParameters->Put(L"InData", 0, &inDataVar, 0);
VariantClear(&inDataVar);
/*-----------------------------------------------------------*\
| Call the 'hpqBIOSInt128' method from the 'hpqBIntM' class |
\*-----------------------------------------------------------*/
hres = pSvc->ExecMethod(_bstr_t(L"hpqBIntM.InstanceName='ACPI\\PNP0C14\\0_0'"), _bstr_t(L"hpqBIOSInt128"), 0, NULL, methodParameters, NULL, &callResult);
if(FAILED(hres))
{
cleanup(RESULT_STEP);
return 1;
}
/*-------------------------------------------------------*\
| Get the returned data |
\*-------------------------------------------------------*/
if(returnDataSize != NULL && returnData != NULL)
{
IWbemClassObject* ppResultObject = nullptr;
callResult->GetResultObject(WBEM_INFINITE, &ppResultObject);
// get OutData from object returned (is an object of type hpqBDataOut128)
VARIANT outDataVar;
VariantInit(&outDataVar);
ppResultObject->Get(L"OutData", 0, &outDataVar, NULL, NULL);
// get 'Data' property from the object returned
IWbemClassObject* retData = (IWbemClassObject*)outDataVar.punkVal;
retData->Get(L"Data", 0, &outDataVar, NULL, NULL);
// extract the byte array from the result VARIANT
long lower, upper;
SAFEARRAY* safeArray = outDataVar.parray;
SafeArrayGetLBound(safeArray, 1, &lower);
SafeArrayGetUBound(safeArray, 1, &upper);
long length = upper - lower + 1;
*returnData = new BYTE[length];
*returnDataSize = length;
SafeArrayLock(safeArray);
memcpy(*returnData, safeArray->pvData, length);
SafeArrayUnlock(safeArray);
// cleanup
retData->Release();
VariantClear(&outDataVar);
ppResultObject->Release();
}
// cleanup
cleanup(RESULT_STEP);
return 0;
}
void HPOmenLaptopController_Windows::setColors(std::vector<RGBColor>& colors)
{
/*-----------------------------------------------------*\
| Set the new colors |
\*-----------------------------------------------------*/
int returnDataSize = 0;
BYTE* returnData = nullptr;
int num = execute(131081, 2, 0, nullptr, &returnDataSize, &returnData);
if(num == 0 && returnData != nullptr)
{
// prepare the data byte array to be sent to WMI
for (int i = 0; i < 4; i++)
{
returnData[25 + i * 3] = RGBGetRValue(colors[3 - i]);
returnData[25 + i * 3 + 1] = RGBGetGValue(colors[3 - i]);
returnData[25 + i * 3 + 2] = RGBGetBValue(colors[3 - i]);
}
// make the WMI call to set the colors
execute(131081, 3, returnDataSize, returnData, NULL, NULL);
delete[] returnData;
}
}
bool HPOmenLaptopController_Windows::isLightingSupported()
{
/*-----------------------------------------------------*\
| Check if the laptop supports rgb lighting |
\*-----------------------------------------------------*/
BYTE b = 0;
int returnDataSize = 0;
BYTE* returnData = nullptr;
if(execute(131081, 1, 0, nullptr, &returnDataSize, &returnData) == 0)
{
b = (BYTE)(returnData[0] & 1u);
}
delete[] returnData;
return b == 1;
}
KeyboardType HPOmenLaptopController_Windows::getKeyboardType()
{
/*-----------------------------------------------------*\
| Get keyboard type |
\*-----------------------------------------------------*/
int returnDataSize = 0;
BYTE* returnData = nullptr;
if(execute(131080, 43, 0, nullptr, &returnDataSize, &returnData) == 0)
{
int result = returnData[0];
delete[] returnData;
return (KeyboardType)(result + 1);
}
return KeyboardType::INVALID;
}
void HPOmenLaptopController_Windows::changeMode(KeyboardMode mode)
{
/*-----------------------------------------------------*\
| Change keyboard rgb mode |
\*-----------------------------------------------------*/
switch(mode)
{
case KeyboardMode::OFF:
{
BYTE array[4] = { 100, 0, 0, 0 };
execute(131081, 5, sizeof(array), array, NULL, NULL);
break;
}
case KeyboardMode::DIRECT:
{
BYTE array[4] = { 228, 0, 0, 0 };
execute(131081, 5, sizeof(array), array, NULL, NULL);
break;
}
default:
break;
}
}