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

Publish curated LumaOps source from c85ee9ef8f1454f5c305398902afbb9e6738de40
Managed validation / full (push) Failing after 8s

Browse Source
This commit is contained in:
Public Source Publisher committed 2026-09-30 00:26:45 +00:00
1 parent 91f8b3e3c1
commit def7920856
2271 files changed
+501225 -501178
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

Controllers/TForceXtreemController/RGBController_TForceXtreem.cpp
+502 -502
View File
File diff suppressed because it is too large. Load diff
Controllers/TForceXtreemController/RGBController_TForceXtreem.h
+37 -37
View File
@@ -1,37 +1,37 @@
/*---------------------------------------------------------*\
| RGBController_TForceXtreem.h |
| |
| RGBController for TeamGroup T-Force Xtreem RAM |
| |
| Milan Cermak (krysmanta) 28 Dec 2024 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "TForceXtreemController.h"
class RGBController_TForceXtreem : public RGBController
{
public:
RGBController_TForceXtreem(TForceXtreemController* controller_ptr);
~RGBController_TForceXtreem();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
TForceXtreemController* controller;
int GetDeviceMode();
};
/*---------------------------------------------------------*\
| RGBController_TForceXtreem.h |
| |
| RGBController for TeamGroup T-Force Xtreem RAM |
| |
| Milan Cermak (krysmanta) 28 Dec 2024 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "TForceXtreemController.h"
class RGBController_TForceXtreem : public RGBController
{
public:
RGBController_TForceXtreem(TForceXtreemController* controller_ptr);
~RGBController_TForceXtreem();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
TForceXtreemController* controller;
int GetDeviceMode();
};
Controllers/TForceXtreemController/TForceXtreemController.cpp
+183 -183
View File
@@ -1,183 +1,183 @@
/*---------------------------------------------------------*\
| TForceXtreemController.cpp |
| |
| Driver for T-Force XTreem DRAM |
| |
| Milan Cermak (krysmanta) 28 Dec 2024 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include "TForceXtreemController.h"
#include "LogManager.h"
TForceXtreemController::TForceXtreemController(i2c_smbus_interface *bus, ene_dev_id dev)
{
this->bus = bus;
this->dev = dev;
}
TForceXtreemController::~TForceXtreemController()
{
}
std::string TForceXtreemController::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(return_string);
}
unsigned int TForceXtreemController::GetLEDCount()
{
return(XTREEM_LED_COUNT);
}
/*---------------------------------------------------*\
| LEDs are in a single strip that is folded in half. |
| That makes the LED order: 0-14-1-13-2-...-7-9-8 |
\*---------------------------------------------------*/
#define XTREEM_LED_OFFSET(x) ((((x) & 0x01) > 0) ? XTREEM_LED_COUNT - 1 - ((x) >> 1) : ((x) >> 1))
unsigned char TForceXtreemController::GetLEDRed(unsigned int led)
{
return(ENERegisterRead(XTREEM_REG_COLORS_DIRECT + ( 3 * XTREEM_LED_OFFSET(led) )));
}
unsigned char TForceXtreemController::GetLEDGreen(unsigned int led)
{
return(ENERegisterRead(XTREEM_REG_COLORS_DIRECT + ( 3 * XTREEM_LED_OFFSET(led) ) + 2));
}
unsigned char TForceXtreemController::GetLEDBlue(unsigned int led)
{
return(ENERegisterRead(XTREEM_REG_COLORS_DIRECT + ( 3 * XTREEM_LED_OFFSET(led) ) + 1));
}
unsigned char TForceXtreemController::GetLEDRedEffect(unsigned int led)
{
return(ENERegisterRead(XTREEM_REG_COLORS_EFFECT + ( 3 * XTREEM_LED_OFFSET(led) )));
}
unsigned char TForceXtreemController::GetLEDGreenEffect(unsigned int led)
{
return(ENERegisterRead(XTREEM_REG_COLORS_EFFECT + ( 3 * XTREEM_LED_OFFSET(led) ) + 2));
}
unsigned char TForceXtreemController::GetLEDBlueEffect(unsigned int led)
{
return(ENERegisterRead(XTREEM_REG_COLORS_EFFECT + ( 3 * XTREEM_LED_OFFSET(led) ) + 1));
}
void TForceXtreemController::SetAllColorsDirect(RGBColor* colors)
{
unsigned char* color_buf = new unsigned char[XTREEM_LED_COUNT * 3];
unsigned int bytes_sent = 0;
for(unsigned int i = 0; i < XTREEM_LED_COUNT; i++)
{
unsigned int offset = 3 * XTREEM_LED_OFFSET(i);
color_buf[offset + 0] = RGBGetRValue(colors[i]);
color_buf[offset + 1] = RGBGetBValue(colors[i]);
color_buf[offset + 2] = RGBGetGValue(colors[i]);
}
while(bytes_sent < (XTREEM_LED_COUNT * 3))
{
ENERegisterWriteBlock(XTREEM_REG_COLORS_DIRECT + bytes_sent, &color_buf[bytes_sent], 3);
bytes_sent += 3;
}
delete[] color_buf;
}
void TForceXtreemController::SetAllColorsEffect(RGBColor* colors)
{
unsigned char* color_buf = new unsigned char[XTREEM_LED_COUNT * 3];
unsigned int bytes_sent = 0;
for(unsigned int i = 0; i < XTREEM_LED_COUNT; i++)
{
unsigned int offset = 3 * XTREEM_LED_OFFSET(i);
color_buf[offset + 0] = RGBGetRValue(colors[i]);
color_buf[offset + 1] = RGBGetBValue(colors[i]);
color_buf[offset + 2] = RGBGetGValue(colors[i]);
}
while(bytes_sent < (XTREEM_LED_COUNT * 3))
{
ENERegisterWriteBlock(XTREEM_REG_COLORS_EFFECT + bytes_sent, &color_buf[bytes_sent], 3);
bytes_sent += 3;
}
ENERegisterWrite(XTREEM_REG_APPLY, XTREEM_APPLY_VAL);
delete[] color_buf;
}
void TForceXtreemController::SetDirect(unsigned char direct)
{
ENERegisterWrite(XTREEM_REG_DIRECT, direct);
ENERegisterWrite(XTREEM_REG_APPLY, XTREEM_APPLY_VAL);
}
void TForceXtreemController::SetLEDColorDirect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
{
unsigned char colors[3] = { red, blue, green };
ENERegisterWriteBlock(XTREEM_REG_COLORS_DIRECT + ( 3 * XTREEM_LED_OFFSET(led) ), colors, 3);
}
void TForceXtreemController::SetLEDColorEffect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
{
unsigned char colors[3] = { red, blue, green };
ENERegisterWriteBlock(XTREEM_REG_COLORS_EFFECT + (3 * XTREEM_LED_OFFSET(led)), colors, 3);
ENERegisterWrite(XTREEM_REG_APPLY, XTREEM_APPLY_VAL);
}
void TForceXtreemController::SetMode(unsigned char mode, unsigned char speed, unsigned char direction)
{
ENERegisterWrite(XTREEM_REG_MODE, mode);
ENERegisterWrite(XTREEM_REG_SPEED, speed);
ENERegisterWrite(XTREEM_REG_DIRECTION, direction);
ENERegisterWrite(XTREEM_REG_APPLY, XTREEM_APPLY_VAL);
}
unsigned char TForceXtreemController::ENERegisterRead(ene_register reg)
{
//Write ENE register
bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
//Read ENE value
return(bus->i2c_smbus_read_byte_data(dev, 0x81));
}
void TForceXtreemController::ENERegisterWrite(ene_register reg, unsigned char val)
{
//Write ENE register
bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
//Write ENE value
bus->i2c_smbus_write_byte_data(dev, 0x01, val);
}
void TForceXtreemController::ENERegisterWriteBlock(ene_register reg, unsigned char * data, unsigned char sz)
{
//Write ENE register
bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
//Write ENE block data
bus->i2c_smbus_write_block_data(dev, 0x03, sz, data);
}
/*---------------------------------------------------------*\
| TForceXtreemController.cpp |
| |
| Driver for T-Force XTreem DRAM |
| |
| Milan Cermak (krysmanta) 28 Dec 2024 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include "TForceXtreemController.h"
#include "LogManager.h"
TForceXtreemController::TForceXtreemController(i2c_smbus_interface *bus, ene_dev_id dev)
{
this->bus = bus;
this->dev = dev;
}
TForceXtreemController::~TForceXtreemController()
{
}
std::string TForceXtreemController::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(return_string);
}
unsigned int TForceXtreemController::GetLEDCount()
{
return(XTREEM_LED_COUNT);
}
/*---------------------------------------------------*\
| LEDs are in a single strip that is folded in half. |
| That makes the LED order: 0-14-1-13-2-...-7-9-8 |
\*---------------------------------------------------*/
#define XTREEM_LED_OFFSET(x) ((((x) & 0x01) > 0) ? XTREEM_LED_COUNT - 1 - ((x) >> 1) : ((x) >> 1))
unsigned char TForceXtreemController::GetLEDRed(unsigned int led)
{
return(ENERegisterRead(XTREEM_REG_COLORS_DIRECT + ( 3 * XTREEM_LED_OFFSET(led) )));
}
unsigned char TForceXtreemController::GetLEDGreen(unsigned int led)
{
return(ENERegisterRead(XTREEM_REG_COLORS_DIRECT + ( 3 * XTREEM_LED_OFFSET(led) ) + 2));
}
unsigned char TForceXtreemController::GetLEDBlue(unsigned int led)
{
return(ENERegisterRead(XTREEM_REG_COLORS_DIRECT + ( 3 * XTREEM_LED_OFFSET(led) ) + 1));
}
unsigned char TForceXtreemController::GetLEDRedEffect(unsigned int led)
{
return(ENERegisterRead(XTREEM_REG_COLORS_EFFECT + ( 3 * XTREEM_LED_OFFSET(led) )));
}
unsigned char TForceXtreemController::GetLEDGreenEffect(unsigned int led)
{
return(ENERegisterRead(XTREEM_REG_COLORS_EFFECT + ( 3 * XTREEM_LED_OFFSET(led) ) + 2));
}
unsigned char TForceXtreemController::GetLEDBlueEffect(unsigned int led)
{
return(ENERegisterRead(XTREEM_REG_COLORS_EFFECT + ( 3 * XTREEM_LED_OFFSET(led) ) + 1));
}
void TForceXtreemController::SetAllColorsDirect(RGBColor* colors)
{
unsigned char* color_buf = new unsigned char[XTREEM_LED_COUNT * 3];
unsigned int bytes_sent = 0;
for(unsigned int i = 0; i < XTREEM_LED_COUNT; i++)
{
unsigned int offset = 3 * XTREEM_LED_OFFSET(i);
color_buf[offset + 0] = RGBGetRValue(colors[i]);
color_buf[offset + 1] = RGBGetBValue(colors[i]);
color_buf[offset + 2] = RGBGetGValue(colors[i]);
}
while(bytes_sent < (XTREEM_LED_COUNT * 3))
{
ENERegisterWriteBlock(XTREEM_REG_COLORS_DIRECT + bytes_sent, &color_buf[bytes_sent], 3);
bytes_sent += 3;
}
delete[] color_buf;
}
void TForceXtreemController::SetAllColorsEffect(RGBColor* colors)
{
unsigned char* color_buf = new unsigned char[XTREEM_LED_COUNT * 3];
unsigned int bytes_sent = 0;
for(unsigned int i = 0; i < XTREEM_LED_COUNT; i++)
{
unsigned int offset = 3 * XTREEM_LED_OFFSET(i);
color_buf[offset + 0] = RGBGetRValue(colors[i]);
color_buf[offset + 1] = RGBGetBValue(colors[i]);
color_buf[offset + 2] = RGBGetGValue(colors[i]);
}
while(bytes_sent < (XTREEM_LED_COUNT * 3))
{
ENERegisterWriteBlock(XTREEM_REG_COLORS_EFFECT + bytes_sent, &color_buf[bytes_sent], 3);
bytes_sent += 3;
}
ENERegisterWrite(XTREEM_REG_APPLY, XTREEM_APPLY_VAL);
delete[] color_buf;
}
void TForceXtreemController::SetDirect(unsigned char direct)
{
ENERegisterWrite(XTREEM_REG_DIRECT, direct);
ENERegisterWrite(XTREEM_REG_APPLY, XTREEM_APPLY_VAL);
}
void TForceXtreemController::SetLEDColorDirect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
{
unsigned char colors[3] = { red, blue, green };
ENERegisterWriteBlock(XTREEM_REG_COLORS_DIRECT + ( 3 * XTREEM_LED_OFFSET(led) ), colors, 3);
}
void TForceXtreemController::SetLEDColorEffect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
{
unsigned char colors[3] = { red, blue, green };
ENERegisterWriteBlock(XTREEM_REG_COLORS_EFFECT + (3 * XTREEM_LED_OFFSET(led)), colors, 3);
ENERegisterWrite(XTREEM_REG_APPLY, XTREEM_APPLY_VAL);
}
void TForceXtreemController::SetMode(unsigned char mode, unsigned char speed, unsigned char direction)
{
ENERegisterWrite(XTREEM_REG_MODE, mode);
ENERegisterWrite(XTREEM_REG_SPEED, speed);
ENERegisterWrite(XTREEM_REG_DIRECTION, direction);
ENERegisterWrite(XTREEM_REG_APPLY, XTREEM_APPLY_VAL);
}
unsigned char TForceXtreemController::ENERegisterRead(ene_register reg)
{
//Write ENE register
bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
//Read ENE value
return(bus->i2c_smbus_read_byte_data(dev, 0x81));
}
void TForceXtreemController::ENERegisterWrite(ene_register reg, unsigned char val)
{
//Write ENE register
bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
//Write ENE value
bus->i2c_smbus_write_byte_data(dev, 0x01, val);
}
void TForceXtreemController::ENERegisterWriteBlock(ene_register reg, unsigned char * data, unsigned char sz)
{
//Write ENE register
bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
//Write ENE block data
bus->i2c_smbus_write_block_data(dev, 0x03, sz, data);
}
Controllers/TForceXtreemController/TForceXtreemController.h
+111 -111
View File
@@ -1,111 +1,111 @@
/*---------------------------------------------------------*\
| TForceXtreemController.h |
| |
| Driver for T-Force Xtreem DRAM |
| |
| Milan Cermak (krysmanta) 28 Dec 2024 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <string>
#include "RGBController.h"
#include "i2c_smbus.h"
#define XTREEM_APPLY_VAL 0x01 /* Value for Apply Changes Register */
#define XTREEM_LED_COUNT 15
typedef unsigned short ene_register;
typedef unsigned char ene_dev_id;
enum
{
XTREEM_REG_DIRECT = 0xE020, /* "Direct Access" Selection Register */
XTREEM_REG_MODE = 0xE021, /* Mode Selection Register */
XTREEM_REG_SPEED = 0xE022, /* Speed Control Register */
XTREEM_REG_DIRECTION = 0xE023, /* Direction Control Register */
XTREEM_REG_APPLY = 0xE02F, /* Apply Changes Register */
XTREEM_REG_SLOT_INDEX = 0xE0F8, /* Slot Index Register (RAM only) */
XTREEM_REG_I2C_ADDRESS = 0xE0F9, /* I2C Address Register (RAM only) */
XTREEM_REG_COLORS_DIRECT = 0xE100, /* Colors for Direct Mode 45 bytes */
XTREEM_REG_COLORS_EFFECT = 0xE300, /* Colors for Internal Effects 45 bytes */
};
enum
{
XTREEM_MODE_OFF = 0, /* OFF mode */
XTREEM_MODE_STATIC = 1, /* Static color mode */
XTREEM_MODE_BREATHING = 2, /* Breathing effect mode */
XTREEM_MODE_FLASHING = 3, /* Flashing effect mode */
XTREEM_MODE_SPECTRUM_CYCLE = 4, /* Spectrum Cycle mode */
XTREEM_MODE_RAINBOW = 5, /* Rainbow effect mode */
XTREEM_MODE_SPECTRUM_CYCLE_BREATHING = 6, /* Rainbow Breathing effect mode */
XTREEM_MODE_CHASE_FADE = 7, /* Chase with Fade effect mode */
XTREEM_MODE_SPECTRUM_CYCLE_CHASE_FADE = 8, /* Chase with Fade, Rainbow effect mode */
XTREEM_MODE_CHASE = 9, /* Chase effect mode */
XTREEM_MODE_SPECTRUM_CYCLE_CHASE = 10, /* Chase with Rainbow effect mode */
XTREEM_MODE_SPECTRUM_CYCLE_WAVE = 11, /* Wave effect mode */
XTREEM_MODE_CHASE_RAINBOW_PULSE = 12, /* Chase with Rainbow Pulse effect mode*/
XTREEM_MODE_RANDOM_FLICKER = 13, /* Random flicker effect mode */
XTREEM_MODE_STACK = 14, /* Stacking effect mode */
XTREEM_MODE_PONG = 15, /* Pong effect mode */
XTREEM_MODE_FILLUP = 16, /* Fill up effect mode */
XTREEM_MODE_NEON = 17, /* Neon effect mode */
XTREEM_MODE_COLOR_WAVE = 18, /* Color Wave effect mode */
XTREEM_MODE_COLOR_DOUBLE_WAVE = 19, /* Color double wave effect mode */
XTREEM_MODE_MIXER = 20, /* Mixer effect mode */
XTREEM_MODE_SPECTRUM_CYCLE_2 = 21, /* Spectrum cycle 2 effect mode */
XTREEM_MODE_FIRE_BREATHING = 22, /* Color shift breathing effect mode */
XTREEM_MODE_SPECTRUM_CYCLE_3 = 23, /* Spectrum cycle 3 effect mode */
XTREEM_MODE_SLITHER = 24, /* Slither effect mode */
XTREEM_MODE_TFORCE_XTREEM = 25, /* Default T-Force Xtreem mode */
XTREEM_NUMBER_MODES /* Number of Aura modes */
};
enum
{
XTREEM_SPEED_SLOWEST = 0x04, /* Slowest effect speed */
XTREEM_SPEED_SLOW = 0x03, /* Slow effect speed */
XTREEM_SPEED_NORMAL = 0x02, /* Normal effect speed */
XTREEM_SPEED_FAST = 0x01, /* Fast effect speed */
XTREEM_SPEED_FASTEST = 0x00, /* Fastest effect speed */
};
enum
{
XTREEM_DIRECTION_FORWARD = 0x0, /* Forward effect direction */
XTREEM_DIRECTION_REVERSE = 0x1, /* Reverse effect direction */
};
class TForceXtreemController
{
public:
TForceXtreemController(i2c_smbus_interface *bus, ene_dev_id dev);
~TForceXtreemController();
std::string GetDeviceLocation();
unsigned int GetLEDCount();
unsigned char GetLEDRed(unsigned int led);
unsigned char GetLEDGreen(unsigned int led);
unsigned char GetLEDBlue(unsigned int led);
unsigned char GetLEDRedEffect(unsigned int led);
unsigned char GetLEDGreenEffect(unsigned int led);
unsigned char GetLEDBlueEffect(unsigned int led);
void SetAllColorsDirect(RGBColor* colors);
void SetAllColorsEffect(RGBColor* colors);
void SetDirect(unsigned char direct);
void SetLEDColorDirect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
void SetLEDColorEffect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
void SetMode(unsigned char mode, unsigned char speed, unsigned char direction);
unsigned char ENERegisterRead(ene_register reg);
void ENERegisterWrite(ene_register reg, unsigned char val);
void ENERegisterWriteBlock(ene_register reg, unsigned char * data, unsigned char sz);
private:
i2c_smbus_interface * bus;
ene_dev_id dev;
};
/*---------------------------------------------------------*\
| TForceXtreemController.h |
| |
| Driver for T-Force Xtreem DRAM |
| |
| Milan Cermak (krysmanta) 28 Dec 2024 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <string>
#include "RGBController.h"
#include "i2c_smbus.h"
#define XTREEM_APPLY_VAL 0x01 /* Value for Apply Changes Register */
#define XTREEM_LED_COUNT 15
typedef unsigned short ene_register;
typedef unsigned char ene_dev_id;
enum
{
XTREEM_REG_DIRECT = 0xE020, /* "Direct Access" Selection Register */
XTREEM_REG_MODE = 0xE021, /* Mode Selection Register */
XTREEM_REG_SPEED = 0xE022, /* Speed Control Register */
XTREEM_REG_DIRECTION = 0xE023, /* Direction Control Register */
XTREEM_REG_APPLY = 0xE02F, /* Apply Changes Register */
XTREEM_REG_SLOT_INDEX = 0xE0F8, /* Slot Index Register (RAM only) */
XTREEM_REG_I2C_ADDRESS = 0xE0F9, /* I2C Address Register (RAM only) */
XTREEM_REG_COLORS_DIRECT = 0xE100, /* Colors for Direct Mode 45 bytes */
XTREEM_REG_COLORS_EFFECT = 0xE300, /* Colors for Internal Effects 45 bytes */
};
enum
{
XTREEM_MODE_OFF = 0, /* OFF mode */
XTREEM_MODE_STATIC = 1, /* Static color mode */
XTREEM_MODE_BREATHING = 2, /* Breathing effect mode */
XTREEM_MODE_FLASHING = 3, /* Flashing effect mode */
XTREEM_MODE_SPECTRUM_CYCLE = 4, /* Spectrum Cycle mode */
XTREEM_MODE_RAINBOW = 5, /* Rainbow effect mode */
XTREEM_MODE_SPECTRUM_CYCLE_BREATHING = 6, /* Rainbow Breathing effect mode */
XTREEM_MODE_CHASE_FADE = 7, /* Chase with Fade effect mode */
XTREEM_MODE_SPECTRUM_CYCLE_CHASE_FADE = 8, /* Chase with Fade, Rainbow effect mode */
XTREEM_MODE_CHASE = 9, /* Chase effect mode */
XTREEM_MODE_SPECTRUM_CYCLE_CHASE = 10, /* Chase with Rainbow effect mode */
XTREEM_MODE_SPECTRUM_CYCLE_WAVE = 11, /* Wave effect mode */
XTREEM_MODE_CHASE_RAINBOW_PULSE = 12, /* Chase with Rainbow Pulse effect mode*/
XTREEM_MODE_RANDOM_FLICKER = 13, /* Random flicker effect mode */
XTREEM_MODE_STACK = 14, /* Stacking effect mode */
XTREEM_MODE_PONG = 15, /* Pong effect mode */
XTREEM_MODE_FILLUP = 16, /* Fill up effect mode */
XTREEM_MODE_NEON = 17, /* Neon effect mode */
XTREEM_MODE_COLOR_WAVE = 18, /* Color Wave effect mode */
XTREEM_MODE_COLOR_DOUBLE_WAVE = 19, /* Color double wave effect mode */
XTREEM_MODE_MIXER = 20, /* Mixer effect mode */
XTREEM_MODE_SPECTRUM_CYCLE_2 = 21, /* Spectrum cycle 2 effect mode */
XTREEM_MODE_FIRE_BREATHING = 22, /* Color shift breathing effect mode */
XTREEM_MODE_SPECTRUM_CYCLE_3 = 23, /* Spectrum cycle 3 effect mode */
XTREEM_MODE_SLITHER = 24, /* Slither effect mode */
XTREEM_MODE_TFORCE_XTREEM = 25, /* Default T-Force Xtreem mode */
XTREEM_NUMBER_MODES /* Number of Aura modes */
};
enum
{
XTREEM_SPEED_SLOWEST = 0x04, /* Slowest effect speed */
XTREEM_SPEED_SLOW = 0x03, /* Slow effect speed */
XTREEM_SPEED_NORMAL = 0x02, /* Normal effect speed */
XTREEM_SPEED_FAST = 0x01, /* Fast effect speed */
XTREEM_SPEED_FASTEST = 0x00, /* Fastest effect speed */
};
enum
{
XTREEM_DIRECTION_FORWARD = 0x0, /* Forward effect direction */
XTREEM_DIRECTION_REVERSE = 0x1, /* Reverse effect direction */
};
class TForceXtreemController
{
public:
TForceXtreemController(i2c_smbus_interface *bus, ene_dev_id dev);
~TForceXtreemController();
std::string GetDeviceLocation();
unsigned int GetLEDCount();
unsigned char GetLEDRed(unsigned int led);
unsigned char GetLEDGreen(unsigned int led);
unsigned char GetLEDBlue(unsigned int led);
unsigned char GetLEDRedEffect(unsigned int led);
unsigned char GetLEDGreenEffect(unsigned int led);
unsigned char GetLEDBlueEffect(unsigned int led);
void SetAllColorsDirect(RGBColor* colors);
void SetAllColorsEffect(RGBColor* colors);
void SetDirect(unsigned char direct);
void SetLEDColorDirect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
void SetLEDColorEffect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
void SetMode(unsigned char mode, unsigned char speed, unsigned char direction);
unsigned char ENERegisterRead(ene_register reg);
void ENERegisterWrite(ene_register reg, unsigned char val);
void ENERegisterWriteBlock(ene_register reg, unsigned char * data, unsigned char sz);
private:
i2c_smbus_interface * bus;
ene_dev_id dev;
};
Controllers/TForceXtreemController/TForceXtreemControllerDetect.cpp
+184 -184
View File
@@ -1,184 +1,184 @@
/*---------------------------------------------------------*\
| TForceXtreemControllerDetect.cpp |
| |
| Detector for T-Force Xtreem RAM |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <vector>
#include "Detector.h"
#include "TForceXtreemController.h"
#include "LogManager.h"
#include "RGBController_TForceXtreem.h"
#include "i2c_smbus.h"
#define DETECTOR_NAME "TForce Xtreem Controller"
using namespace std::chrono_literals;
/*----------------------------------------------------------------------*\
| Windows defines "interface" for some reason. Work around this |
\*----------------------------------------------------------------------*/
#ifdef interface
#undef interface
#endif
/*----------------------------------------------------------------------*\
| This list contains the available SMBus addresses for mapping ENE RAM |
\*----------------------------------------------------------------------*/
#define XTREEM_RAM_ADDRESS_COUNT 13
static const unsigned char xtreem_ram_addresses[] =
{
0x70,
0x71,
0x72,
0x73,
0x74,
0x75,
0x76,
0x78,
0x39,
0x3A,
0x3B,
0x3C,
0x3D
};
/******************************************************************************************\
* *
* XtreemRegisterWrite *
* *
* A standalone version of the TForceXtreemController::ENERegisterWrite function for *
* access to ENE devices without instancing the TForceXtreemController class. *
* *
\******************************************************************************************/
static void XtreemRegisterWrite(i2c_smbus_interface* bus, ene_dev_id dev, ene_register reg, unsigned char val)
{
//Write ENE register
bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
//Write ENE value
bus->i2c_smbus_write_byte_data(dev, 0x01, val);
}
/******************************************************************************************\
* *
* TestForENESMBusController *
* *
* Tests the given address to see if an ENE controller exists there. First does a *
* quick write to test for a response, and if so does a simple read at 0x90 to test *
* for incrementing values 10...1F which was observed at this location *
* *
\******************************************************************************************/
bool TestForTForceXtreemController(i2c_smbus_interface* bus, unsigned char address)
{
bool pass = false;
LOG_DEBUG("[%s] looking for devices at 0x%02X...", DETECTOR_NAME, address);
int res = bus->i2c_smbus_read_byte(address);
if(res < 0)
{
res = bus->i2c_smbus_read_byte_data(address, 0x00);
}
if(res >= 0)
{
pass = true;
LOG_DEBUG("[%s] Detected an I2C device at address %02X, testing register range", DETECTOR_NAME, address);
for(int i = 0x90; i < 0xA1; i++)
{
res = bus->i2c_smbus_read_byte_data(address, i);
if(res != (i - 0x80))
{
LOG_VERBOSE("[%s] Detection failed testing register %02X. Expected %02X, got %02X.", DETECTOR_NAME, i, (i - 0x80), res);
pass = false;
break;
}
}
}
return(pass);
} /* TestForTForceXtreemController() */
/******************************************************************************************\
* *
* DetectTForceXtreemDRAMControllers *
* *
* Detects T-Force Xtreem controllers on DRAM devices *
* *
* bus - pointer to i2c_smbus_interface where device is connected *
* slots - SPD accessors to occupied slots *
* *
\******************************************************************************************/
void DetectTForceXtreemControllers(i2c_smbus_interface* bus, std::vector<SPDWrapper*> &slots, const std::string &/*name*/)
{
LOG_DEBUG("[%s] Remapping ENE SMBus RAM modules on 0x77", DETECTOR_NAME);
for(SPDWrapper *slot : slots)
{
int address_list_idx = slot->index() - 1;
int res;
/*-------------------------------------------------*\
| Full test to avoid conflicts with other ENE DRAMs |
\*-------------------------------------------------*/
if(!TestForTForceXtreemController(bus, 0x77))
{
LOG_DEBUG("[%s] No device detected at 0x77, aborting remap", DETECTOR_NAME);
break;
}
do
{
address_list_idx++;
if(address_list_idx < XTREEM_RAM_ADDRESS_COUNT)
{
LOG_DEBUG("[%s] Testing address %02X to see if there is a device there", DETECTOR_NAME, xtreem_ram_addresses[address_list_idx]);
res = bus->i2c_smbus_write_quick(xtreem_ram_addresses[address_list_idx], I2C_SMBUS_WRITE);
}
else
{
break;
}
} while(res >= 0);
if(address_list_idx < XTREEM_RAM_ADDRESS_COUNT)
{
LOG_DEBUG("[%s] Remapping slot %d to address %02X", DETECTOR_NAME, slot, xtreem_ram_addresses[address_list_idx]);
XtreemRegisterWrite(bus, 0x77, XTREEM_REG_SLOT_INDEX, slot->index());
XtreemRegisterWrite(bus, 0x77, XTREEM_REG_I2C_ADDRESS, (xtreem_ram_addresses[address_list_idx] << 1));
}
}
// Add ENE controllers at their remapped addresses
for(unsigned int address_list_idx = 0; address_list_idx < XTREEM_RAM_ADDRESS_COUNT; address_list_idx++)
{
if(TestForTForceXtreemController(bus, xtreem_ram_addresses[address_list_idx]))
{
TForceXtreemController* controller = new TForceXtreemController(bus, xtreem_ram_addresses[address_list_idx]);
RGBController_TForceXtreem* rgb_controller = new RGBController_TForceXtreem(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
} /* DetectTForceXtreemControllers() */
REGISTER_I2C_DIMM_DETECTOR("T-Force Xtreem DDR4 DRAM", DetectTForceXtreemControllers, JEDEC_TEAMGROUP, SPD_DDR4_SDRAM);
/*---------------------------------------------------------*\
| TForceXtreemControllerDetect.cpp |
| |
| Detector for T-Force Xtreem RAM |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <vector>
#include "Detector.h"
#include "TForceXtreemController.h"
#include "LogManager.h"
#include "RGBController_TForceXtreem.h"
#include "i2c_smbus.h"
#define DETECTOR_NAME "TForce Xtreem Controller"
using namespace std::chrono_literals;
/*----------------------------------------------------------------------*\
| Windows defines "interface" for some reason. Work around this |
\*----------------------------------------------------------------------*/
#ifdef interface
#undef interface
#endif
/*----------------------------------------------------------------------*\
| This list contains the available SMBus addresses for mapping ENE RAM |
\*----------------------------------------------------------------------*/
#define XTREEM_RAM_ADDRESS_COUNT 13
static const unsigned char xtreem_ram_addresses[] =
{
0x70,
0x71,
0x72,
0x73,
0x74,
0x75,
0x76,
0x78,
0x39,
0x3A,
0x3B,
0x3C,
0x3D
};
/******************************************************************************************\
* *
* XtreemRegisterWrite *
* *
* A standalone version of the TForceXtreemController::ENERegisterWrite function for *
* access to ENE devices without instancing the TForceXtreemController class. *
* *
\******************************************************************************************/
static void XtreemRegisterWrite(i2c_smbus_interface* bus, ene_dev_id dev, ene_register reg, unsigned char val)
{
//Write ENE register
bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
//Write ENE value
bus->i2c_smbus_write_byte_data(dev, 0x01, val);
}
/******************************************************************************************\
* *
* TestForENESMBusController *
* *
* Tests the given address to see if an ENE controller exists there. First does a *
* quick write to test for a response, and if so does a simple read at 0x90 to test *
* for incrementing values 10...1F which was observed at this location *
* *
\******************************************************************************************/
bool TestForTForceXtreemController(i2c_smbus_interface* bus, unsigned char address)
{
bool pass = false;
LOG_DEBUG("[%s] looking for devices at 0x%02X...", DETECTOR_NAME, address);
int res = bus->i2c_smbus_read_byte(address);
if(res < 0)
{
res = bus->i2c_smbus_read_byte_data(address, 0x00);
}
if(res >= 0)
{
pass = true;
LOG_DEBUG("[%s] Detected an I2C device at address %02X, testing register range", DETECTOR_NAME, address);
for(int i = 0x90; i < 0xA1; i++)
{
res = bus->i2c_smbus_read_byte_data(address, i);
if(res != (i - 0x80))
{
LOG_VERBOSE("[%s] Detection failed testing register %02X. Expected %02X, got %02X.", DETECTOR_NAME, i, (i - 0x80), res);
pass = false;
break;
}
}
}
return(pass);
} /* TestForTForceXtreemController() */
/******************************************************************************************\
* *
* DetectTForceXtreemDRAMControllers *
* *
* Detects T-Force Xtreem controllers on DRAM devices *
* *
* bus - pointer to i2c_smbus_interface where device is connected *
* slots - SPD accessors to occupied slots *
* *
\******************************************************************************************/
void DetectTForceXtreemControllers(i2c_smbus_interface* bus, std::vector<SPDWrapper*> &slots, const std::string &/*name*/)
{
LOG_DEBUG("[%s] Remapping ENE SMBus RAM modules on 0x77", DETECTOR_NAME);
for(SPDWrapper *slot : slots)
{
int address_list_idx = slot->index() - 1;
int res;
/*-------------------------------------------------*\
| Full test to avoid conflicts with other ENE DRAMs |
\*-------------------------------------------------*/
if(!TestForTForceXtreemController(bus, 0x77))
{
LOG_DEBUG("[%s] No device detected at 0x77, aborting remap", DETECTOR_NAME);
break;
}
do
{
address_list_idx++;
if(address_list_idx < XTREEM_RAM_ADDRESS_COUNT)
{
LOG_DEBUG("[%s] Testing address %02X to see if there is a device there", DETECTOR_NAME, xtreem_ram_addresses[address_list_idx]);
res = bus->i2c_smbus_write_quick(xtreem_ram_addresses[address_list_idx], I2C_SMBUS_WRITE);
}
else
{
break;
}
} while(res >= 0);
if(address_list_idx < XTREEM_RAM_ADDRESS_COUNT)
{
LOG_DEBUG("[%s] Remapping slot %d to address %02X", DETECTOR_NAME, slot, xtreem_ram_addresses[address_list_idx]);
XtreemRegisterWrite(bus, 0x77, XTREEM_REG_SLOT_INDEX, slot->index());
XtreemRegisterWrite(bus, 0x77, XTREEM_REG_I2C_ADDRESS, (xtreem_ram_addresses[address_list_idx] << 1));
}
}
// Add ENE controllers at their remapped addresses
for(unsigned int address_list_idx = 0; address_list_idx < XTREEM_RAM_ADDRESS_COUNT; address_list_idx++)
{
if(TestForTForceXtreemController(bus, xtreem_ram_addresses[address_list_idx]))
{
TForceXtreemController* controller = new TForceXtreemController(bus, xtreem_ram_addresses[address_list_idx]);
RGBController_TForceXtreem* rgb_controller = new RGBController_TForceXtreem(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
} /* DetectTForceXtreemControllers() */
REGISTER_I2C_DIMM_DETECTOR("T-Force Xtreem DDR4 DRAM", DetectTForceXtreemControllers, JEDEC_TEAMGROUP, SPD_DDR4_SDRAM);