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/PNYLovelaceGPUController/PNYLovelaceGPUController.cpp
+79
View File
@@ -0,0 +1,79 @@
/*---------------------------------------------------------*\
| PNYLovelaceGPUController.cpp |
| |
| Driver for PNY Lovelace GPU |
| |
| yufan 01 Oct 2023 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "PNYLovelaceGPUController.h"
PNYLovelaceGPUController::PNYLovelaceGPUController(i2c_smbus_interface* bus, pny_dev_id dev, std::string dev_name)
{
this->bus = bus;
this->dev = dev;
this->name = dev_name;
}
PNYLovelaceGPUController::~PNYLovelaceGPUController()
{
}
std::string PNYLovelaceGPUController::GetDeviceLocation()
{
std::string return_string(bus->device_name);
char addr[5];
snprintf(addr, 5, "0x%02X", dev);
return_string.append(", address ");
return_string.append(addr);
return("I2C: " + return_string);
}
std::string PNYLovelaceGPUController::GetDeviceName()
{
return(name);
}
void PNYLovelaceGPUController::SetOff()
{
unsigned char data[7] = {};
bus->i2c_smbus_write_i2c_block_data(dev, PNY_GPU_REG_LIGHTING, sizeof(data), data);
}
void PNYLovelaceGPUController::SetDirect(unsigned char led, unsigned char red, unsigned char green, unsigned char blue)
{
unsigned char data[7] = {PNY_GPU_MODE_STATIC, 0xFF, led, 0x00, red, green, blue};
bus->i2c_smbus_write_i2c_block_data(dev, PNY_GPU_REG_LIGHTING, sizeof(data), data);
}
void PNYLovelaceGPUController::SetCycle(unsigned char speed, unsigned char brightness)
{
speed = 0xB2 - speed;
unsigned char data[7] = {PNY_GPU_MODE_CYCLE, brightness, speed, 0x00, 0xAA, 0x00, 0x00};
bus->i2c_smbus_write_i2c_block_data(dev, PNY_GPU_REG_LIGHTING, sizeof(data), data);
}
void PNYLovelaceGPUController::SetBreath(unsigned char speed, unsigned char red, unsigned char green, unsigned char blue)
{
speed = 0x19 - speed;
unsigned char data[7] = {PNY_GPU_MODE_BREATH, 0xFF, speed, 0x01, red, green, blue};
bus->i2c_smbus_write_i2c_block_data(dev, PNY_GPU_REG_LIGHTING, sizeof(data), data);
}
void PNYLovelaceGPUController::SetWave(unsigned char speed, unsigned char brightness)
{
speed = 0xBF - speed;
unsigned char data[7] = {PNY_GPU_MODE_WAVE, brightness, speed, 0x00, 0xAA, 0x00, 0x00};
bus->i2c_smbus_write_i2c_block_data(dev, PNY_GPU_REG_LIGHTING, sizeof(data), data);
}
void PNYLovelaceGPUController::SetFlash(unsigned char speed, unsigned char brightness, unsigned char red, unsigned char green, unsigned char blue)
{
speed = 0x4D - speed;
unsigned char data[7] = {PNY_GPU_MODE_FLASH, brightness, speed, 0x00, red, green, blue};
bus->i2c_smbus_write_i2c_block_data(dev, PNY_GPU_REG_LIGHTING, sizeof(data), data);
}
Controllers/PNYLovelaceGPUController/PNYLovelaceGPUController.h
+55
View File
@@ -0,0 +1,55 @@
/*---------------------------------------------------------*\
| PNYLovelaceGPUController.h |
| |
| Driver for PNY Lovelace GPU |
| |
| yufan 01 Oct 2023 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <string>
#include "i2c_smbus.h"
typedef unsigned char pny_dev_id;
enum
{
PNY_GPU_MODE_OFF = 0x00,
PNY_GPU_MODE_BREATH = 0x02,
PNY_GPU_MODE_CYCLE = 0x03,
PNY_GPU_MODE_WAVE = 0x04,
PNY_GPU_MODE_FLASH = 0x05,
PNY_GPU_MODE_STATIC = 0x06,
};
enum
{
PNY_GPU_REG_LIGHTING = 0x02,
};
class PNYLovelaceGPUController
{
public:
PNYLovelaceGPUController(i2c_smbus_interface* bus, pny_dev_id dev, std::string dev_name);
~PNYLovelaceGPUController();
std::string GetDeviceLocation();
std::string GetDeviceName();
void SetOff();
void SetBreath(unsigned char speed, unsigned char red, unsigned char green, unsigned char blue);
void SetCycle(unsigned char speed, unsigned char brightness);
void SetWave(unsigned char speed, unsigned char brightness);
void SetFlash(unsigned char speed, unsigned char brightness, unsigned char red, unsigned char green, unsigned char blue);
void SetDirect(unsigned char led, unsigned char red, unsigned char green, unsigned char blue);
private:
i2c_smbus_interface* bus;
pny_dev_id dev;
std::string name;
};
Controllers/PNYLovelaceGPUController/PNYLovelaceGPUControllerDetect.cpp
+51
View File
@@ -0,0 +1,51 @@
/*---------------------------------------------------------*\
| PNYLovelaceGPUControllerDetect.cpp |
| |
| Detector for PNY Lovelace GPU |
| |
| yufan 01 Oct 2023 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "Detector.h"
#include "PNYLovelaceGPUController.h"
#include "RGBController_PNYLovelaceGPU.h"
#include "i2c_smbus.h"
#include "pci_ids.h"
/*-----------------------------------------------------------------------------------------*\
| DetectPNYLovelaceGPUControllers |
| |
| Detect PNY 40xx GPU controllers on the enumerated I2C busses at address 0x60. |
| |
| bus - pointer to i2c_smbus_interface where PNY GPU device is connected |
| dev - I2C address of PNY GPU device |
\*-----------------------------------------------------------------------------------------*/
void DetectPNYLovelaceGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
{
if(bus->port_id != 1)
{
return;
}
PNYLovelaceGPUController* controller = new PNYLovelaceGPUController(bus, i2c_addr, name);
RGBController_PNYLovelaceGPU* rgb_controller = new RGBController_PNYLovelaceGPU(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
} /* DetectPNYLovelaceGPUControllers() */
REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 4070 Ti XLR8 VERTO Epic-X", DetectPNYLovelaceGPUControllers, NVIDIA_VEN, NVIDIA_RTX4070TI_DEV, PNY_SUB_VEN, PNY_RTX_4070TI_XLR8_VERTO_EPIC_X_SUB_DEV, 0x60);
REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 4070 Ti XLR8 VERTO REV1", DetectPNYLovelaceGPUControllers, NVIDIA_VEN, NVIDIA_RTX4070TI_DEV, PNY_SUB_VEN, PNY_RTX_4070TI_XLR8_VERTO_REV1_SUB_DEV, 0x60);
REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 4070 Ti XLR8 VERTO REV2", DetectPNYLovelaceGPUControllers, NVIDIA_VEN, NVIDIA_RTX4070TI_DEV, PNY_SUB_VEN, PNY_RTX_4070TI_XLR8_VERTO_REV2_SUB_DEV, 0x60);
REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 4070 Ti XLR8 VERTO OC", DetectPNYLovelaceGPUControllers, NVIDIA_VEN, NVIDIA_RTX4070TI_DEV, PNY_SUB_VEN, PNY_RTX_4070TI_XLR8_VERTO_OC_SUB_DEV, 0x60);
REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 4070 Ti Super XLR8 VERTO OC", DetectPNYLovelaceGPUControllers, NVIDIA_VEN, NVIDIA_RTX4070TIS_DEV, PNY_SUB_VEN, PNY_RTX_4070TIS_XLR8_VERTO_OC_SUB_DEV, 0x60);
REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 4080 XLR8 UPRISING", DetectPNYLovelaceGPUControllers, NVIDIA_VEN, NVIDIA_RTX4080_DEV, PNY_SUB_VEN, PNY_RTX_4080_XLR8_UPRISING_SUB_DEV, 0x60);
REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 4080 XLR8 VERTO", DetectPNYLovelaceGPUControllers, NVIDIA_VEN, NVIDIA_RTX4080_DEV, PNY_SUB_VEN, PNY_RTX_4080_XLR8_VERTO_SUB_DEV, 0x60);
REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 4080 SUPER XLR8 VERTO", DetectPNYLovelaceGPUControllers, NVIDIA_VEN, NVIDIA_RTX4080S_DEV, PNY_SUB_VEN, PNY_RTX_4080S_XLR8_VERTO_SUB_DEV, 0x60);
REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 4080 XLR8 Verto Epic-X", DetectPNYLovelaceGPUControllers, NVIDIA_VEN, NVIDIA_RTX4080_DEV, PNY_SUB_VEN, PNY_RTX_4080_XLR8_VERTO_EPIC_X_SUB_DEV, 0x60);
REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 4090 XLR8 VERTO", DetectPNYLovelaceGPUControllers, NVIDIA_VEN, NVIDIA_RTX4090_DEV, PNY_SUB_VEN, PNY_RTX_4090_XLR8_VERTO_SUB_DEV, 0x60);
REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 4090 XLR8 Verto Epic-X", DetectPNYLovelaceGPUControllers, NVIDIA_VEN, NVIDIA_RTX4090_DEV, PNY_SUB_VEN, PNY_RTX_4090_VERTO_EPIC_X_SUB_DEV, 0x60);
REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 4090 XLR8 Verto Epic-X OC", DetectPNYLovelaceGPUControllers, NVIDIA_VEN, NVIDIA_RTX4090_DEV, PNY_SUB_VEN, PNY_RTX_4090_VERTO_EPIC_X_OC_SUB_DEV, 0x60);
Controllers/PNYLovelaceGPUController/RGBController_PNYLovelaceGPU.cpp
+199
View File
@@ -0,0 +1,199 @@
/*---------------------------------------------------------*\
| RGBController_PNYLovelaceGPU.cpp |
| |
| RGBController for PNY Lovelace GPU |
| |
| yufan 01 Oct 2023 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_PNYLovelaceGPU.h"
/**------------------------------------------------------------------*\
@name PNY GPU 40xx
@category GPU
@type I2C
@save :x:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectPNYLovelaceGPUControllers
@comment
\*-------------------------------------------------------------------*/
RGBController_PNYLovelaceGPU::RGBController_PNYLovelaceGPU(PNYLovelaceGPUController* controller_ptr)
{
controller = controller_ptr;
name = controller->GetDeviceName();
vendor = "PNY";
description = "PNY RGB GPU Device";
location = controller->GetDeviceLocation();
type = DEVICE_TYPE_GPU;
mode Direct;
Direct.name = "Direct";
Direct.value = PNY_GPU_MODE_STATIC;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
mode Cycle;
Cycle.name = "Cycle";
Cycle.value = PNY_GPU_MODE_CYCLE;
Cycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
Cycle.speed = 0x89;
Cycle.speed_min = 0;
Cycle.speed_max = 0xB2;
Cycle.brightness = 0xFF;
Cycle.brightness_min = 0;
Cycle.brightness_max = 0xFF;
Cycle.color_mode = MODE_COLORS_NONE;
modes.push_back(Cycle);
mode Breath;
Breath.name = "Breath";
Breath.value = PNY_GPU_MODE_BREATH;
Breath.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Breath.speed = 0x09;
Breath.speed_min = 0;
Breath.speed_max = 0x19;
Breath.colors_min = 1;
Breath.colors_max = 1;
Breath.colors.resize(1);
Breath.color_mode = MODE_COLORS_MODE_SPECIFIC;
modes.push_back(Breath);
mode Wave;
Wave.name = "Wave";
Wave.value = PNY_GPU_MODE_WAVE;
Wave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
Wave.speed = 0x60;
Wave.speed_min = 0;
Wave.speed_max = 0xBF;
Wave.brightness = 0xFF;
Wave.brightness_min = 0;
Wave.brightness_max = 0xFF;
Wave.color_mode = MODE_COLORS_NONE;
modes.push_back(Wave);
mode Flash;
Flash.name = "Flash";
Flash.value = PNY_GPU_MODE_FLASH;
Flash.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Flash.speed = 0x27;
Flash.speed_min = 0;
Flash.speed_max = 0x4D;
Flash.brightness = 0xFF;
Flash.brightness_min = 0;
Flash.brightness_max = 0xFF;
Flash.colors_min = 1;
Flash.colors_max = 1;
Flash.colors.resize(1);
Flash.color_mode = MODE_COLORS_MODE_SPECIFIC;
modes.push_back(Flash);
mode Off;
Off.name = "Off";
Off.value = PNY_GPU_MODE_OFF;
Off.flags = 0;
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
SetupZones();
// Initialize active mode
active_mode = 0;
}
void RGBController_PNYLovelaceGPU::SetupZones()
{
/*---------------------------------------------------------*\
| This device only has 3 LED, so create a single zone. |
\*---------------------------------------------------------*/
zone* new_zone = new zone();
new_zone->name = "GPU Zone";
new_zone->type = ZONE_TYPE_SINGLE;
new_zone->leds_min = 3;
new_zone->leds_max = 3;
new_zone->leds_count = 3;
new_zone->matrix_map = NULL;
led* new_led = new led();
new_led->name = "Fan LED";
leds.push_back(*new_led);
new_led = new led();
new_led->name = "Right LED";
leds.push_back(*new_led);
new_led = new led();
new_led->name = "Left LED";
leds.push_back(*new_led);
zones.push_back(*new_zone);
SetupColors();
}
void RGBController_PNYLovelaceGPU::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_PNYLovelaceGPU::DeviceUpdateLEDs()
{
DeviceUpdateMode();
}
void RGBController_PNYLovelaceGPU::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateMode();
}
void RGBController_PNYLovelaceGPU::UpdateSingleLED(int /*led*/)
{
DeviceUpdateMode();
}
void RGBController_PNYLovelaceGPU::DeviceUpdateMode()
{
switch(modes[active_mode].value)
{
case PNY_GPU_MODE_OFF:
controller->SetOff();
break;
case PNY_GPU_MODE_STATIC:
for (int i = 0; i < 3; i++)
{
RGBColor color = GetLED(i);
controller->SetDirect(i, RGBGetRValue(color), RGBGetGValue(color), RGBGetBValue(color));
}
break;
case PNY_GPU_MODE_CYCLE:
controller->SetCycle(modes[active_mode].speed, modes[active_mode].brightness);
break;
case PNY_GPU_MODE_BREATH:
{
RGBColor color = modes[active_mode].colors[0];
controller->SetBreath(modes[active_mode].speed, RGBGetRValue(color), RGBGetGValue(color), RGBGetBValue(color));
break;
}
case PNY_GPU_MODE_WAVE:
controller->SetWave(modes[active_mode].speed, modes[active_mode].brightness);
break;
case PNY_GPU_MODE_FLASH:
{
RGBColor color = modes[active_mode].colors[0];
controller->SetFlash(modes[active_mode].speed, modes[active_mode].brightness,
RGBGetRValue(color), RGBGetGValue(color), RGBGetBValue(color));
break;
}
default:
break;
}
}
Controllers/PNYLovelaceGPUController/RGBController_PNYLovelaceGPU.h
+33
View File
@@ -0,0 +1,33 @@
/*---------------------------------------------------------*\
| RGBController_PNYLovelaceGPU.h |
| |
| RGBController for PNY Lovelace GPU |
| |
| yufan 01 Oct 2023 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "PNYLovelaceGPUController.h"
class RGBController_PNYLovelaceGPU : public RGBController
{
public:
RGBController_PNYLovelaceGPU(PNYLovelaceGPUController* controller_ptr);
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
PNYLovelaceGPUController* controller;
};