mirror of
https://github.com/CalcProgrammer1/OpenRGB.git
synced 2026-09-13 13:47:02 -04:00
642 lines
19 KiB
C++
642 lines
19 KiB
C++
/*---------------------------------------------------------*\
|
|
| ValveSteamMachineController_Windows.cpp |
|
|
| |
|
|
| Driver for Valve Steam Machine LEDs |
|
|
| |
|
|
| Adam Honse (calcprogrammer1@gmail.com) 28 Jul 2026 |
|
|
| |
|
|
| This file is part of the OpenRGB project |
|
|
| SPDX-License-Identifier: GPL-2.0-or-later |
|
|
\*---------------------------------------------------------*/
|
|
|
|
#include "LogManager.h"
|
|
#include "ValveSteamMachineController_Windows.h"
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Name for log entries |
|
|
\*---------------------------------------------------------*/
|
|
static const char* VALVESTEAMMACHINECONTROLLER = "ValveSteamMachineController";
|
|
|
|
static const std::vector<std::string> effects =
|
|
{
|
|
"patrol",
|
|
"breath",
|
|
"factory",
|
|
"normal",
|
|
"off",
|
|
"rainbow",
|
|
"demo",
|
|
"manual"
|
|
};
|
|
|
|
ValveSteamMachineController::ValveSteamMachineController(HANDLE dev_handle, std::string dev_name)
|
|
{
|
|
name = dev_name;
|
|
pawnio_handle = dev_handle;
|
|
|
|
/*-----------------------------------------------------*\
|
|
| Initialize driver |
|
|
\*-----------------------------------------------------*/
|
|
ULONG64 in[1];
|
|
ULONG64 out[1];
|
|
SIZE_T return_size;
|
|
HRESULT status;
|
|
|
|
status = pawnio_execute(pawnio_handle, "ioctl_init", in, 0, out, 0, &return_size);
|
|
|
|
if(status != S_OK)
|
|
{
|
|
LOG_ERROR("[%s] ioctl_init failed", VALVESTEAMMACHINECONTROLLER);
|
|
}
|
|
}
|
|
|
|
ValveSteamMachineController::~ValveSteamMachineController()
|
|
{
|
|
|
|
}
|
|
|
|
std::string ValveSteamMachineController::GetName()
|
|
{
|
|
return(name);
|
|
}
|
|
|
|
size_t ValveSteamMachineController::GetLEDCount()
|
|
{
|
|
return(17);
|
|
}
|
|
|
|
std::string ValveSteamMachineController::GetLocation()
|
|
{
|
|
return("PawnIO leds-valve");
|
|
}
|
|
|
|
std::vector<std::string> ValveSteamMachineController::GetAvailableEffects()
|
|
{
|
|
return(effects);
|
|
}
|
|
|
|
unsigned int ValveSteamMachineController::GetBrightness()
|
|
{
|
|
/*-----------------------------------------------------*\
|
|
| Get brightness |
|
|
\*-----------------------------------------------------*/
|
|
ULONG64 in[1];
|
|
ULONG64 out[1];
|
|
SIZE_T return_size;
|
|
HRESULT status;
|
|
|
|
status = pawnio_execute(pawnio_handle, "ioctl_get_brightness_scale", in, 0, out, 1, &return_size);
|
|
|
|
if(status != S_OK)
|
|
{
|
|
LOG_ERROR("[%s] ioctl_get_brightness_scale failed", VALVESTEAMMACHINECONTROLLER);
|
|
return(0);
|
|
}
|
|
|
|
if(out[0] <= 255)
|
|
{
|
|
return(out[0]);
|
|
}
|
|
else
|
|
{
|
|
LOG_ERROR("[%s] ioctl_get_brightness_scale delay out of range", VALVESTEAMMACHINECONTROLLER);
|
|
return(0);
|
|
}
|
|
}
|
|
|
|
unsigned int ValveSteamMachineController::GetDelay()
|
|
{
|
|
/*-----------------------------------------------------*\
|
|
| Get delay |
|
|
\*-----------------------------------------------------*/
|
|
ULONG64 in[1];
|
|
ULONG64 out[1];
|
|
SIZE_T return_size;
|
|
HRESULT status;
|
|
|
|
status = pawnio_execute(pawnio_handle, "ioctl_get_delay", in, 0, out, 1, &return_size);
|
|
|
|
if(status != S_OK)
|
|
{
|
|
LOG_ERROR("[%s] ioctl_get_delay failed", VALVESTEAMMACHINECONTROLLER);
|
|
return(0);
|
|
}
|
|
|
|
if(out[0] <= 20)
|
|
{
|
|
return(out[0]);
|
|
}
|
|
else
|
|
{
|
|
LOG_ERROR("[%s] ioctl_get_delay delay out of range", VALVESTEAMMACHINECONTROLLER);
|
|
return(0);
|
|
}
|
|
}
|
|
|
|
std::string ValveSteamMachineController::GetEffect()
|
|
{
|
|
/*-----------------------------------------------------*\
|
|
| Get effect |
|
|
\*-----------------------------------------------------*/
|
|
ULONG64 in[1];
|
|
ULONG64 out[1];
|
|
SIZE_T return_size;
|
|
HRESULT status;
|
|
|
|
status = pawnio_execute(pawnio_handle, "ioctl_get_effect", in, 0, out, 1, &return_size);
|
|
|
|
if(status != S_OK)
|
|
{
|
|
LOG_ERROR("[%s] ioctl_get_effect failed", VALVESTEAMMACHINECONTROLLER);
|
|
return("");
|
|
}
|
|
|
|
if(out[0] < effects.size())
|
|
{
|
|
return(effects[out[0]]);
|
|
}
|
|
else
|
|
{
|
|
LOG_ERROR("[%s] ioctl_get_effect effect out of range", VALVESTEAMMACHINECONTROLLER);
|
|
return("");
|
|
}
|
|
}
|
|
|
|
bool ValveSteamMachineController::GetEnabled()
|
|
{
|
|
/*-----------------------------------------------------*\
|
|
| Get enabled |
|
|
\*-----------------------------------------------------*/
|
|
ULONG64 in[1];
|
|
ULONG64 out[1];
|
|
SIZE_T return_size;
|
|
HRESULT status;
|
|
|
|
status = pawnio_execute(pawnio_handle, "ioctl_get_enabled", in, 0, out, 1, &return_size);
|
|
|
|
if(status != S_OK)
|
|
{
|
|
LOG_ERROR("[%s] ioctl_get_enabled failed", VALVESTEAMMACHINECONTROLLER);
|
|
return(false);
|
|
}
|
|
|
|
return((out[0] & 0xFF) != 0);
|
|
}
|
|
|
|
unsigned int ValveSteamMachineController::GetBreathOffset()
|
|
{
|
|
/*-----------------------------------------------------*\
|
|
| Get breath offset |
|
|
\*-----------------------------------------------------*/
|
|
ULONG64 in[1];
|
|
ULONG64 out[1];
|
|
SIZE_T return_size;
|
|
HRESULT status;
|
|
|
|
status = pawnio_execute(pawnio_handle, "ioctl_get_breath_offset", in, 0, out, 1, &return_size);
|
|
|
|
if(status != S_OK)
|
|
{
|
|
LOG_ERROR("[%s] ioctl_get_breath_offset failed", VALVESTEAMMACHINECONTROLLER);
|
|
return(0);
|
|
}
|
|
|
|
if(out[0] <= 255)
|
|
{
|
|
return(out[0]);
|
|
}
|
|
else
|
|
{
|
|
LOG_ERROR("[%s] ioctl_get_breath_offset out of range", VALVESTEAMMACHINECONTROLLER);
|
|
return(0);
|
|
}
|
|
}
|
|
|
|
unsigned int ValveSteamMachineController::GetBreathLevel()
|
|
{
|
|
/*-----------------------------------------------------*\
|
|
| Get breath level |
|
|
\*-----------------------------------------------------*/
|
|
ULONG64 in[1];
|
|
ULONG64 out[1];
|
|
SIZE_T return_size;
|
|
HRESULT status;
|
|
|
|
status = pawnio_execute(pawnio_handle, "ioctl_get_breath_level", in, 0, out, 1, &return_size);
|
|
|
|
if(status != S_OK)
|
|
{
|
|
LOG_ERROR("[%s] ioctl_get_breath_level failed", VALVESTEAMMACHINECONTROLLER);
|
|
return(0);
|
|
}
|
|
|
|
if(out[0] <= 255)
|
|
{
|
|
return(out[0]);
|
|
}
|
|
else
|
|
{
|
|
LOG_ERROR("[%s] ioctl_get_breath_level out of range", VALVESTEAMMACHINECONTROLLER);
|
|
return(0);
|
|
}
|
|
}
|
|
|
|
unsigned int ValveSteamMachineController::GetPatrolNum()
|
|
{
|
|
/*-----------------------------------------------------*\
|
|
| Get patrol num |
|
|
\*-----------------------------------------------------*/
|
|
ULONG64 in[1];
|
|
ULONG64 out[1];
|
|
SIZE_T return_size;
|
|
HRESULT status;
|
|
|
|
status = pawnio_execute(pawnio_handle, "ioctl_get_patrol_num", in, 0, out, 1, &return_size);
|
|
|
|
if(status != S_OK)
|
|
{
|
|
LOG_ERROR("[%s] ioctl_get_patrol_num failed", VALVESTEAMMACHINECONTROLLER);
|
|
return(0);
|
|
}
|
|
|
|
if(out[0] <= 255)
|
|
{
|
|
return(out[0]);
|
|
}
|
|
else
|
|
{
|
|
LOG_ERROR("[%s] ioctl_get_patrol_num out of range", VALVESTEAMMACHINECONTROLLER);
|
|
return(0);
|
|
}
|
|
}
|
|
|
|
unsigned int ValveSteamMachineController::GetColorShift()
|
|
{
|
|
/*-----------------------------------------------------*\
|
|
| Get color shift |
|
|
\*-----------------------------------------------------*/
|
|
ULONG64 in[1];
|
|
ULONG64 out[1];
|
|
SIZE_T return_size;
|
|
HRESULT status;
|
|
|
|
status = pawnio_execute(pawnio_handle, "ioctl_get_color_shift", in, 0, out, 1, &return_size);
|
|
|
|
if(status != S_OK)
|
|
{
|
|
LOG_ERROR("[%s] ioctl_get_color_shift failed", VALVESTEAMMACHINECONTROLLER);
|
|
return(0);
|
|
}
|
|
|
|
if(out[0] <= 255)
|
|
{
|
|
return(out[0]);
|
|
}
|
|
else
|
|
{
|
|
LOG_ERROR("[%s] ioctl_get_color_shift out of range", VALVESTEAMMACHINECONTROLLER);
|
|
return(0);
|
|
}
|
|
}
|
|
|
|
bool ValveSteamMachineController::GetPersistence()
|
|
{
|
|
/*-----------------------------------------------------*\
|
|
| Get persistence |
|
|
\*-----------------------------------------------------*/
|
|
ULONG64 in[1];
|
|
ULONG64 out[1];
|
|
SIZE_T return_size;
|
|
HRESULT status;
|
|
|
|
status = pawnio_execute(pawnio_handle, "ioctl_get_persistence", in, 0, out, 1, &return_size);
|
|
|
|
if(status != S_OK)
|
|
{
|
|
LOG_ERROR("[%s] ioctl_get_persistence failed", VALVESTEAMMACHINECONTROLLER);
|
|
return(false);
|
|
}
|
|
|
|
return((out[0] & 0xFF) != 0);
|
|
}
|
|
|
|
RGBColor ValveSteamMachineController::GetStartupColor()
|
|
{
|
|
/*-----------------------------------------------------*\
|
|
| Get startup color |
|
|
\*-----------------------------------------------------*/
|
|
ULONG64 in[1];
|
|
ULONG64 out[3];
|
|
SIZE_T return_size;
|
|
HRESULT status;
|
|
|
|
status = pawnio_execute(pawnio_handle, "ioctl_get_startup_color", in, 0, out, 3, &return_size);
|
|
|
|
if(status != S_OK)
|
|
{
|
|
LOG_ERROR("[%s] ioctl_get_startup_color failed", VALVESTEAMMACHINECONTROLLER);
|
|
return(0);
|
|
}
|
|
|
|
return(ToRGBColor(out[0], out[1], out[2]));
|
|
}
|
|
|
|
unsigned int ValveSteamMachineController::GetBrightnessStartup()
|
|
{
|
|
/*-----------------------------------------------------*\
|
|
| Get brightness startup |
|
|
\*-----------------------------------------------------*/
|
|
ULONG64 in[1];
|
|
ULONG64 out[1];
|
|
SIZE_T return_size;
|
|
HRESULT status;
|
|
|
|
status = pawnio_execute(pawnio_handle, "ioctl_get_brightness_startup", in, 0, out, 1, &return_size);
|
|
|
|
if(status != S_OK)
|
|
{
|
|
LOG_ERROR("[%s] ioctl_get_brightness_startup failed", VALVESTEAMMACHINECONTROLLER);
|
|
return(0);
|
|
}
|
|
|
|
if(out[0] <= 255)
|
|
{
|
|
return(out[0]);
|
|
}
|
|
else
|
|
{
|
|
LOG_ERROR("[%s] ioctl_get_brightness_startup out of range", VALVESTEAMMACHINECONTROLLER);
|
|
return(0);
|
|
}
|
|
}
|
|
|
|
void ValveSteamMachineController::SetLEDColor(unsigned int led_idx, RGBColor color)
|
|
{
|
|
if(led_idx >= GetLEDCount())
|
|
{
|
|
LOG_ERROR("[%s] ioctl_set_led_color led index out of range", VALVESTEAMMACHINECONTROLLER);
|
|
return;
|
|
}
|
|
|
|
/*-----------------------------------------------------*\
|
|
| Reverse order of LEDs |
|
|
\*-----------------------------------------------------*/
|
|
led_idx = (GetLEDCount() - 1) - led_idx;
|
|
|
|
/*-----------------------------------------------------*\
|
|
| Set LED color |
|
|
\*-----------------------------------------------------*/
|
|
ULONG64 in[4] = {led_idx, RGBGetRValue(color), RGBGetGValue(color), RGBGetBValue(color)};
|
|
ULONG64 out[1];
|
|
SIZE_T return_size;
|
|
HRESULT status;
|
|
|
|
status = pawnio_execute(pawnio_handle, "ioctl_set_led_color", in, 4, out, 0, &return_size);
|
|
|
|
if(status != S_OK)
|
|
{
|
|
LOG_ERROR("[%s] ioctl_set_led_color failed", VALVESTEAMMACHINECONTROLLER);
|
|
}
|
|
}
|
|
|
|
void ValveSteamMachineController::SetEffect(std::string effect)
|
|
{
|
|
/*-----------------------------------------------------*\
|
|
| Determine effect index |
|
|
\*-----------------------------------------------------*/
|
|
std::size_t effect_idx;
|
|
|
|
for(effect_idx = 0; effect_idx < effects.size(); effect_idx++)
|
|
{
|
|
if(effect == effects[effect_idx])
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(effect_idx >= effects.size())
|
|
{
|
|
LOG_ERROR("[%s] ioctl_set_effect effect out of range", VALVESTEAMMACHINECONTROLLER);
|
|
return;
|
|
}
|
|
|
|
/*-----------------------------------------------------*\
|
|
| Set effect |
|
|
\*-----------------------------------------------------*/
|
|
ULONG64 in[1] = {effect_idx};
|
|
ULONG64 out[1];
|
|
SIZE_T return_size;
|
|
HRESULT status;
|
|
|
|
status = pawnio_execute(pawnio_handle, "ioctl_set_effect", in, 1, out, 0, &return_size);
|
|
|
|
if(status != S_OK)
|
|
{
|
|
LOG_ERROR("[%s] ioctl_set_effect failed", VALVESTEAMMACHINECONTROLLER);
|
|
}
|
|
}
|
|
|
|
void ValveSteamMachineController::SetBrightness(unsigned int brightness)
|
|
{
|
|
if(brightness > 255)
|
|
{
|
|
LOG_ERROR("[%s] ioctl_set_brightness_scale brightness out of range", VALVESTEAMMACHINECONTROLLER);
|
|
return;
|
|
}
|
|
|
|
/*-----------------------------------------------------*\
|
|
| Set brightness |
|
|
\*-----------------------------------------------------*/
|
|
ULONG64 in[1] = {brightness};
|
|
ULONG64 out[1];
|
|
SIZE_T return_size;
|
|
HRESULT status;
|
|
|
|
status = pawnio_execute(pawnio_handle, "ioctl_set_brightness_scale", in, 1, out, 0, &return_size);
|
|
|
|
if(status != S_OK)
|
|
{
|
|
LOG_ERROR("[%s] ioctl_set_brightness_scale failed", VALVESTEAMMACHINECONTROLLER);
|
|
}
|
|
}
|
|
|
|
void ValveSteamMachineController::SetDelay(unsigned int delay)
|
|
{
|
|
if(delay > 20)
|
|
{
|
|
LOG_ERROR("[%s] ioctl_set_delay delay out of range", VALVESTEAMMACHINECONTROLLER);
|
|
return;
|
|
}
|
|
|
|
/*-----------------------------------------------------*\
|
|
| Set delay |
|
|
\*-----------------------------------------------------*/
|
|
ULONG64 in[1] = {delay};
|
|
ULONG64 out[1];
|
|
SIZE_T return_size;
|
|
HRESULT status;
|
|
|
|
status = pawnio_execute(pawnio_handle, "ioctl_set_delay", in, 1, out, 0, &return_size);
|
|
|
|
if(status != S_OK)
|
|
{
|
|
LOG_ERROR("[%s] ioctl_set_delay failed", VALVESTEAMMACHINECONTROLLER);
|
|
}
|
|
}
|
|
|
|
void ValveSteamMachineController::SetEnabled(bool enabled)
|
|
{
|
|
/*-----------------------------------------------------*\
|
|
| Set enabled |
|
|
\*-----------------------------------------------------*/
|
|
ULONG64 in[1] = {enabled ? 1 : 0};
|
|
ULONG64 out[1];
|
|
SIZE_T return_size;
|
|
HRESULT status;
|
|
|
|
status = pawnio_execute(pawnio_handle, "ioctl_set_enabled", in, 1, out, 0, &return_size);
|
|
|
|
if(status != S_OK)
|
|
{
|
|
LOG_ERROR("[%s] ioctl_set_enabled failed", VALVESTEAMMACHINECONTROLLER);
|
|
}
|
|
}
|
|
|
|
void ValveSteamMachineController::SetBreathOffset(unsigned int breath_offset)
|
|
{
|
|
if(breath_offset > 255)
|
|
{
|
|
LOG_ERROR("[%s] ioctl_set_breath_offset out of range", VALVESTEAMMACHINECONTROLLER);
|
|
return;
|
|
}
|
|
|
|
/*-----------------------------------------------------*\
|
|
| Set breath offset |
|
|
\*-----------------------------------------------------*/
|
|
ULONG64 in[1] = {breath_offset};
|
|
ULONG64 out[1];
|
|
SIZE_T return_size;
|
|
HRESULT status;
|
|
|
|
status = pawnio_execute(pawnio_handle, "ioctl_set_breath_offset", in, 1, out, 0, &return_size);
|
|
|
|
if(status != S_OK)
|
|
{
|
|
LOG_ERROR("[%s] ioctl_set_breath_offset failed", VALVESTEAMMACHINECONTROLLER);
|
|
}
|
|
}
|
|
|
|
void ValveSteamMachineController::SetBreathLevel(unsigned int breath_level)
|
|
{
|
|
if(breath_level > 255)
|
|
{
|
|
LOG_ERROR("[%s] ioctl_set_breath_level out of range", VALVESTEAMMACHINECONTROLLER);
|
|
return;
|
|
}
|
|
|
|
/*-----------------------------------------------------*\
|
|
| Set breath level |
|
|
\*-----------------------------------------------------*/
|
|
ULONG64 in[1] = {breath_level};
|
|
ULONG64 out[1];
|
|
SIZE_T return_size;
|
|
HRESULT status;
|
|
|
|
status = pawnio_execute(pawnio_handle, "ioctl_set_breath_level", in, 1, out, 0, &return_size);
|
|
|
|
if(status != S_OK)
|
|
{
|
|
LOG_ERROR("[%s] ioctl_set_breath_level failed", VALVESTEAMMACHINECONTROLLER);
|
|
}
|
|
}
|
|
|
|
void ValveSteamMachineController::SetPatrolNum(unsigned int patrol_num)
|
|
{
|
|
if(patrol_num > 255)
|
|
{
|
|
LOG_ERROR("[%s] ioctl_set_patrol_num out of range", VALVESTEAMMACHINECONTROLLER);
|
|
return;
|
|
}
|
|
|
|
/*-----------------------------------------------------*\
|
|
| Set patrol num |
|
|
\*-----------------------------------------------------*/
|
|
ULONG64 in[1] = {patrol_num};
|
|
ULONG64 out[1];
|
|
SIZE_T return_size;
|
|
HRESULT status;
|
|
|
|
status = pawnio_execute(pawnio_handle, "ioctl_set_patrol_num", in, 1, out, 0, &return_size);
|
|
|
|
if(status != S_OK)
|
|
{
|
|
LOG_ERROR("[%s] ioctl_set_patrol_num failed", VALVESTEAMMACHINECONTROLLER);
|
|
}
|
|
}
|
|
|
|
void ValveSteamMachineController::SetColorShift(unsigned int color_shift)
|
|
{
|
|
if(color_shift > 255)
|
|
{
|
|
LOG_ERROR("[%s] ioctl_set_color_shift out of range", VALVESTEAMMACHINECONTROLLER);
|
|
return;
|
|
}
|
|
|
|
/*-----------------------------------------------------*\
|
|
| Set color shift |
|
|
\*-----------------------------------------------------*/
|
|
ULONG64 in[1] = {color_shift};
|
|
ULONG64 out[1];
|
|
SIZE_T return_size;
|
|
HRESULT status;
|
|
|
|
status = pawnio_execute(pawnio_handle, "ioctl_set_color_shift", in, 1, out, 0, &return_size);
|
|
|
|
if(status != S_OK)
|
|
{
|
|
LOG_ERROR("[%s] ioctl_set_color_shift failed", VALVESTEAMMACHINECONTROLLER);
|
|
}
|
|
}
|
|
|
|
void ValveSteamMachineController::SetStartupColor(RGBColor color)
|
|
{
|
|
/*-----------------------------------------------------*\
|
|
| Set startup color |
|
|
\*-----------------------------------------------------*/
|
|
ULONG64 in[3] = {RGBGetRValue(color), RGBGetGValue(color), RGBGetBValue(color)};
|
|
ULONG64 out[1];
|
|
SIZE_T return_size;
|
|
HRESULT status;
|
|
|
|
status = pawnio_execute(pawnio_handle, "ioctl_set_startup_color", in, 3, out, 0, &return_size);
|
|
|
|
if(status != S_OK)
|
|
{
|
|
LOG_ERROR("[%s] ioctl_set_startup_color failed", VALVESTEAMMACHINECONTROLLER);
|
|
}
|
|
}
|
|
|
|
void ValveSteamMachineController::SetBrightnessStartup(unsigned int brightness_startup)
|
|
{
|
|
if(brightness_startup > 255)
|
|
{
|
|
LOG_ERROR("[%s] ioctl_set_brightness_startup out of range", VALVESTEAMMACHINECONTROLLER);
|
|
return;
|
|
}
|
|
|
|
/*-----------------------------------------------------*\
|
|
| Set brightness startup |
|
|
\*-----------------------------------------------------*/
|
|
ULONG64 in[1] = {brightness_startup};
|
|
ULONG64 out[1];
|
|
SIZE_T return_size;
|
|
HRESULT status;
|
|
|
|
status = pawnio_execute(pawnio_handle, "ioctl_set_brightness_startup", in, 1, out, 0, &return_size);
|
|
|
|
if(status != S_OK)
|
|
{
|
|
LOG_ERROR("[%s] ioctl_set_brightness_startup failed", VALVESTEAMMACHINECONTROLLER);
|
|
}
|
|
}
|