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/CorsairVengeanceController/CorsairVengeanceController.cpp
+62
View File
@@ -0,0 +1,62 @@
/*---------------------------------------------------------*\
| CorsairVengeanceController.cpp |
| |
| Driver for original single-zone Corsair Vengeance DDR4 |
| RGB RAM |
| |
| Adam Honse (CalcProgrammer1) 08 Mar 2019 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include "CorsairVengeanceController.h"
CorsairVengeanceController::CorsairVengeanceController(i2c_smbus_interface* bus, corsair_dev_id dev)
{
this->bus = bus;
this->dev = dev;
strcpy(device_name, "Corsair Vengeance RGB");
led_count = 1;
}
CorsairVengeanceController::~CorsairVengeanceController()
{
}
std::string CorsairVengeanceController::GetDeviceName()
{
return(device_name);
}
std::string CorsairVengeanceController::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);
}
unsigned int CorsairVengeanceController::GetLEDCount()
{
return(led_count);
}
void CorsairVengeanceController::SetLEDColor(unsigned char red, unsigned char green, unsigned char blue)
{
bus->i2c_smbus_write_byte_data(dev, CORSAIR_VENGEANCE_RGB_CMD_FADE_TIME, 0x00);
bus->i2c_smbus_write_byte_data(dev, CORSAIR_VENGEANCE_RGB_CMD_RED_VAL, red);
bus->i2c_smbus_write_byte_data(dev, CORSAIR_VENGEANCE_RGB_CMD_GREEN_VAL, green);
bus->i2c_smbus_write_byte_data(dev, CORSAIR_VENGEANCE_RGB_CMD_BLUE_VAL, blue);
bus->i2c_smbus_write_byte_data(dev, CORSAIR_VENGEANCE_RGB_CMD_MODE, CORSAIR_VENGEANCE_RGB_MODE_SINGLE);
}
void CorsairVengeanceController::SetMode(unsigned char /*mode*/)
{
bus->i2c_smbus_write_byte_data(dev, CORSAIR_VENGEANCE_RGB_CMD_MODE, CORSAIR_VENGEANCE_RGB_MODE_SINGLE);
}
Controllers/CorsairVengeanceController/CorsairVengeanceController.h
+57
View File
@@ -0,0 +1,57 @@
/*---------------------------------------------------------*\
| CorsairVengeanceController.h |
| |
| Driver for original single-zone Corsair Vengeance DDR4 |
| RGB RAM |
| |
| Adam Honse (CalcProgrammer1) 08 Mar 2019 |
| |
| 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 corsair_dev_id;
typedef unsigned char corsair_cmd;
enum
{
CORSAIR_VENGEANCE_RGB_CMD_FADE_TIME = 0xA4, /* Fade Time, 0 for Static */
CORSAIR_VENGEANCE_RGB_CMD_HOLD_TIME = 0xA5, /* Hold Time */
CORSAIR_VENGEANCE_RGB_CMD_MODE = 0xA6, /* Mode Control Value */
CORSAIR_VENGEANCE_RGB_CMD_RED_VAL = 0xB0, /* Red Color Value */
CORSAIR_VENGEANCE_RGB_CMD_GREEN_VAL = 0xB1, /* Green Color Value */
CORSAIR_VENGEANCE_RGB_CMD_BLUE_VAL = 0xB2, /* Blue Color Value */
};
enum
{
CORSAIR_VENGEANCE_RGB_MODE_SINGLE = 0x00, /* Single Color Effect Mode */
CORSAIR_VENGEANCE_RGB_MODE_FADE = 0x01, /* Fade Through Colors */
CORSAIR_VENGEANCE_RGB_MODE_PULSE = 0x02, /* Pulse Through Colors */
CORSAIR_NUMBER_MODES /* Number of Corsair modes */
};
class CorsairVengeanceController
{
public:
CorsairVengeanceController(i2c_smbus_interface* bus, corsair_dev_id dev);
~CorsairVengeanceController();
std::string GetDeviceName();
std::string GetDeviceLocation();
unsigned int GetLEDCount();
void SetMode(unsigned char mode);
void SetLEDColor(unsigned char red, unsigned char green, unsigned char blue);
private:
char device_name[32];
unsigned int led_count;
i2c_smbus_interface * bus;
corsair_dev_id dev;
};
Controllers/CorsairVengeanceController/CorsairVengeanceControllerDetect.cpp
+96
View File
@@ -0,0 +1,96 @@
/*---------------------------------------------------------*\
| CorsairVengeanceControllerDetect.cpp |
| |
| Detector for original single-zone Corsair Vengeance |
| DDR4 RGB RAM |
| |
| Adam Honse (CalcProgrammer1) 08 Mar 2019 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <vector>
#include "Detector.h"
#include "CorsairVengeanceController.h"
#include "RGBController_CorsairVengeance.h"
#include "i2c_smbus.h"
#include "pci_ids.h"
/******************************************************************************************\
* *
* TestForCorsairVengeanceController *
* *
* Tests the given address to see if a Corsair controller exists there. *
* *
\******************************************************************************************/
bool TestForCorsairVengeanceController(i2c_smbus_interface* bus, unsigned char address)
{
bool pass = false;
int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
if (res >= 0)
{
pass = true;
for (int i = 0xA0; i < 0xB0; i++)
{
res = bus->i2c_smbus_read_byte_data(address, i);
if (res != 0xBA)
{
pass = false;
}
}
}
return(pass);
} /* TestForCorsairVengeanceController() */
/******************************************************************************************\
* *
* DetectCorsairVengeanceControllers *
* *
* Detect Corsair controllers on the enumerated I2C busses. *
* *
* bus - pointer to i2c_smbus_interface where device is connected *
* slots - list of SPD entries with matching JEDEC ID *
* *
\******************************************************************************************/
void DetectCorsairVengeanceControllers(i2c_smbus_interface* bus, std::vector<SPDWrapper*> &slots, const std::string &/*name*/)
{
for(SPDWrapper *slot : slots)
{
/*-------------------------------------------------*\
| Test first address range 0x58-0x5F |
\*-------------------------------------------------*/
unsigned char address = slot->address() + 8;
if(TestForCorsairVengeanceController(bus, address))
{
CorsairVengeanceController* new_controller = new CorsairVengeanceController(bus, address);
RGBController_CorsairVengeance* new_rgbcontroller = new RGBController_CorsairVengeance(new_controller);
ResourceManager::get()->RegisterRGBController(new_rgbcontroller);
}
/*-------------------------------------------------*\
| Test second address range 0x18-0x1F |
\*-------------------------------------------------*/
address = slot->address() - 0x40 + 8;
if(TestForCorsairVengeanceController(bus, address))
{
CorsairVengeanceController* new_controller = new CorsairVengeanceController(bus, address);
RGBController_CorsairVengeance* new_rgbcontroller = new RGBController_CorsairVengeance(new_controller);
ResourceManager::get()->RegisterRGBController(new_rgbcontroller);
}
}
} /* DetectCorsairVengeanceControllers() */
REGISTER_I2C_DIMM_DETECTOR("Corsair Vengeance RGB DRAM", DetectCorsairVengeanceControllers, JEDEC_CORSAIR, SPD_DDR4_SDRAM);
Controllers/CorsairVengeanceController/RGBController_CorsairVengeance.cpp
+122
View File
@@ -0,0 +1,122 @@
/*---------------------------------------------------------*\
| RGBController_CorsairVengeance.cpp |
| |
| RGBController for original single-zone Corsair |
| Vengeance DDR4 RGB RAM |
| |
| Adam Honse (CalcProgrammer1) 16 Jun 2019 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_CorsairVengeance.h"
/**------------------------------------------------------------------*\
@name Corsair Vengeance
@category RAM
@type SMBus
@save :robot:
@direct :x:
@effects :white_check_mark:
@detectors DetectCorsairVengeanceControllers
@comment
\*-------------------------------------------------------------------*/
RGBController_CorsairVengeance::RGBController_CorsairVengeance(CorsairVengeanceController* controller_ptr)
{
controller = controller_ptr;
name = controller->GetDeviceName();
vendor = "Corsair";
type = DEVICE_TYPE_DRAM;
description = "Corsair Vengeance RGB Device";
location = controller->GetDeviceLocation();
mode Static;
Static.name = "Static";
Static.value = CORSAIR_VENGEANCE_RGB_MODE_SINGLE;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Static.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Static);
mode Fade;
Fade.name = "Fade";
Fade.value = CORSAIR_VENGEANCE_RGB_MODE_FADE;
Fade.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Fade.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Fade);
mode Pulse;
Pulse.name = "Pulse";
Pulse.value = CORSAIR_VENGEANCE_RGB_MODE_PULSE;
Pulse.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Pulse.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Pulse);
SetupZones();
}
RGBController_CorsairVengeance::~RGBController_CorsairVengeance()
{
delete controller;
}
void RGBController_CorsairVengeance::SetupZones()
{
/*---------------------------------------------------------*\
| Create a single zone |
\*---------------------------------------------------------*/
zone new_zone;
new_zone.name = "Corsair Zone";
new_zone.type = ZONE_TYPE_SINGLE;
new_zone.leds_min = controller->GetLEDCount();
new_zone.leds_max = controller->GetLEDCount();
new_zone.leds_count = controller->GetLEDCount();
new_zone.matrix_map = NULL;
zones.push_back(new_zone);
/*---------------------------------------------------------*\
| Set up LEDs |
\*---------------------------------------------------------*/
for(std::size_t led_idx = 0; led_idx < zones[0].leds_count; led_idx++)
{
led* new_led = new led();
new_led->name = "Corsair LED";
leds.push_back(*new_led);
}
SetupColors();
}
void RGBController_CorsairVengeance::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_CorsairVengeance::DeviceUpdateLEDs()
{
RGBColor color = colors[0];
unsigned char red = RGBGetRValue(color);
unsigned char grn = RGBGetGValue(color);
unsigned char blu = RGBGetBValue(color);
controller->SetLEDColor(red, grn, blu);
}
void RGBController_CorsairVengeance::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_CorsairVengeance::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_CorsairVengeance::DeviceUpdateMode()
{
controller->SetMode(modes[active_mode].value);
}
Controllers/CorsairVengeanceController/RGBController_CorsairVengeance.h
+36
View File
@@ -0,0 +1,36 @@
/*---------------------------------------------------------*\
| RGBController_CorsairVengeance.h |
| |
| RGBController for original single-zone Corsair |
| Vengeance DDR4 RGB RAM |
| |
| Adam Honse (CalcProgrammer1) 16 Jun 2019 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "CorsairVengeanceController.h"
class RGBController_CorsairVengeance : public RGBController
{
public:
RGBController_CorsairVengeance(CorsairVengeanceController* controller_ptr);
~RGBController_CorsairVengeance();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
CorsairVengeanceController* controller;
};