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/HyperXDRAMController/HyperXDRAMController.cpp
+285
View File
@@ -0,0 +1,285 @@
/*---------------------------------------------------------*\
| HyperXDRAMController.cpp |
| |
| Driver for HyperX/Kingston Fury RAM |
| |
| Adam Honse (CalcProgrammer1) 19 Jun 2019 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include "HyperXDRAMController.h"
HyperXDRAMController::HyperXDRAMController(i2c_smbus_interface* bus, hyperx_dev_id dev, unsigned char slots, std::string dev_name)
{
this->bus = bus;
this->dev = dev;
this->name = dev_name;
slots_valid = slots;
led_count = 0;
for(unsigned int slot = 0; slot < 4; slot++)
{
if(((slots_valid & ( 0x01 << slot)) != 0)
||((slots_valid & ( 0x10 << slot)) != 0))
{
led_count += 5;
}
}
mode = HYPERX_MODE_DIRECT;
}
HyperXDRAMController::~HyperXDRAMController()
{
}
std::string HyperXDRAMController::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 HyperXDRAMController::GetDeviceName()
{
return(name);
}
unsigned int HyperXDRAMController::GetLEDCount()
{
return(led_count);
}
unsigned int HyperXDRAMController::GetSlotCount()
{
unsigned int slot_count = 0;
for(int slot = 0; slot < 4; slot++)
{
if(((slots_valid & ( 0x01 << slot)) != 0)
||((slots_valid & ( 0x10 << slot)) != 0))
{
slot_count++;
}
}
return(slot_count);
}
unsigned int HyperXDRAMController::GetMode()
{
return(mode);
}
void HyperXDRAMController::SendApply()
{
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x02);
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x03);
}
void HyperXDRAMController::SetEffectColor(unsigned char red, unsigned char green, unsigned char blue)
{
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x01);
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_EFFECT_RED, red );
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_EFFECT_GREEN, green);
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_EFFECT_BLUE, blue );
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_EFFECT_BRIGHTNESS, 0x64 );
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x02);
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x03);
}
void HyperXDRAMController::SetAllColors(unsigned char red, unsigned char green, unsigned char blue)
{
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x01);
/*-----------------------------------------------------*\
| Loop through all slots and only set those which are |
| active. |
\*-----------------------------------------------------*/
for(unsigned int slot_idx = 0; slot_idx < 4; slot_idx++)
{
unsigned char slot = slot_map[slot_idx];
if(((slots_valid & ( 0x01 << slot)) != 0)
||((slots_valid & ( 0x10 << slot)) != 0))
{
unsigned char base = slot_base[slot];
unsigned char red_base = base + 0x00;
unsigned char green_base = base + 0x01;
unsigned char blue_base = base + 0x02;
unsigned char bright_base = base + 0x10;
if(mode == HYPERX_MODE_DIRECT)
{
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_MODE_INDEPENDENT, HYPERX_MODE3_DIRECT);
}
for(int led = 0; led < 5; led++)
{
bus->i2c_smbus_write_byte_data(dev, red_base + (3 * led), red );
bus->i2c_smbus_write_byte_data(dev, green_base + (3 * led), green);
bus->i2c_smbus_write_byte_data(dev, blue_base + (3 * led), blue );
bus->i2c_smbus_write_byte_data(dev, bright_base + (3 * led), 0x64 );
}
}
}
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x02);
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x03);
}
void HyperXDRAMController::SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
{
/*-----------------------------------------------------*\
| led_slot - the unmapped slot ID for the given LED |
| led - the LED ID within that slot |
| slot_id - counts enabled slots |
| slot - the mapped slot ID for the given LED |
\*-----------------------------------------------------*/
int led_slot = led / 5;
int slot_id = -1;
unsigned char slot;
led -= (led_slot * 5);
/*-----------------------------------------------------*\
| Loop through all possible slots and only count those |
| which are active. |
\*-----------------------------------------------------*/
for(unsigned int slot_idx = 0; slot_idx < 4; slot_idx++)
{
slot = slot_map[slot_idx];
if(((slots_valid & ( 0x01 << slot)) != 0)
||((slots_valid & ( 0x10 << slot)) != 0))
{
slot_id++;
}
if(slot_id == led_slot)
{
break;
}
}
SetLEDColor(slot, led, red, green, blue);
}
void HyperXDRAMController::SetLEDColor(unsigned int slot, unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
{
unsigned char base = slot_base[slot];
unsigned char red_base = base + 0x00;
unsigned char green_base = base + 0x01;
unsigned char blue_base = base + 0x02;
unsigned char bright_base = base + 0x10;
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x01);
bus->i2c_smbus_write_byte_data(dev, red_base + (3 * led), red );
bus->i2c_smbus_write_byte_data(dev, green_base + (3 * led), green);
bus->i2c_smbus_write_byte_data(dev, blue_base + (3 * led), blue );
bus->i2c_smbus_write_byte_data(dev, bright_base + (3 * led), 0x64 );
}
void HyperXDRAMController::SetMode(unsigned char new_mode, bool random, unsigned short new_speed)
{
mode = new_mode;
speed = new_speed;
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x01);
/*-----------------------------------------------------*\
| Determine which mode register to use. |
| If set to random color mode, use Mode1. |
| If set to fixed color mode, use Mode2. |
\*-----------------------------------------------------*/
unsigned char mode_reg;
if(random)
{
mode_reg = HYPERX_REG_MODE_RANDOM;
}
else
{
mode_reg = HYPERX_REG_MODE_CUSTOM;
}
switch (mode)
{
case HYPERX_MODE_DIRECT:
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_MODE_INDEPENDENT, HYPERX_MODE3_DIRECT);
break;
case HYPERX_MODE_STATIC:
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_MODE_CUSTOM, HYPERX_MODE2_STATIC);
break;
case HYPERX_MODE_RAINBOW:
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_MODE_RANDOM, HYPERX_MODE1_RAINBOW);
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_TIMER_MSB, speed >> 8);
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_TIMER_LSB, speed & 0xFF);
break;
case HYPERX_MODE_COMET:
bus->i2c_smbus_write_byte_data(dev, mode_reg, HYPERX_MODE2_COMET);
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_TIMER_MSB, speed >> 8);
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_TIMER_LSB, speed & 0xFF);
break;
case HYPERX_MODE_HEARTBEAT:
bus->i2c_smbus_write_byte_data(dev, mode_reg, HYPERX_MODE2_HEARTBEAT);
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_OFF_TIME_MSB, speed >> 8);
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_OFF_TIME_LSB, speed & 0xFF);
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_ON_TIME_MSB, speed >> 8);
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_ON_TIME_LSB, speed & 0xFF);
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_DELAY_TIME_MSB, 0x03);
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_DELAY_TIME_LSB, 0xE8);
break;
case HYPERX_MODE_CYCLE:
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_MODE_RANDOM, HYPERX_MODE1_CYCLE);
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_ON_TIME_MSB, speed >> 8);
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_ON_TIME_LSB, speed & 0xFF);
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_CHANGE_TIME_MSB, speed >> 8);
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_CHANGE_TIME_LSB, speed & 0xFF);
break;
case HYPERX_MODE_BREATHING:
bus->i2c_smbus_write_byte_data(dev, mode_reg, HYPERX_MODE2_BREATHING);
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_FADE_IN_TIME_MSB, speed >> 8);
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_FADE_IN_TIME_LSB, speed & 0xFF);
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_FADE_OUT_TIME_MSB, speed >> 8);
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_FADE_OUT_TIME_LSB, speed & 0xFF);
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_OFF_TIME_MSB, 0x00);
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_OFF_TIME_LSB, 0x00);
break;
case HYPERX_MODE_BOUNCE:
bus->i2c_smbus_write_byte_data(dev, mode_reg, HYPERX_MODE2_BOUNCE);
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_TIMER_MSB, speed >> 8);
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_TIMER_LSB, speed & 0xFF);
break;
case HYPERX_MODE_BLINK:
bus->i2c_smbus_write_byte_data(dev, mode_reg, HYPERX_MODE2_BLINK);
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_OFF_TIME_MSB, speed >> 8);
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_OFF_TIME_LSB, speed & 0xFF);
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_ON_TIME_MSB, 0x07);
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_ON_TIME_LSB, 0xD4);
break;
}
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x02);
bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x03);
}
Controllers/HyperXDRAMController/HyperXDRAMController.h
+236
View File
@@ -0,0 +1,236 @@
/*---------------------------------------------------------*\
| HyperXDRAMController.h |
| |
| Driver for HyperX/Kingston Fury RAM |
| |
| Adam Honse (CalcProgrammer1) 19 Jun 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 hyperx_dev_id;
typedef unsigned short hyperx_register;
enum
{
HYPERX_REG_SLOT0_LED0_RED = 0x11, /* R color register for LED 0, Slot 0 */
HYPERX_REG_SLOT0_LED0_GREEN = 0x12, /* G color register for LED 0, Slot 0 */
HYPERX_REG_SLOT0_LED0_BLUE = 0x13, /* B color register for LED 0, Slot 0 */
HYPERX_REG_SLOT0_LED1_RED = 0x14, /* R color register for LED 1, Slot 0 */
HYPERX_REG_SLOT0_LED1_GREEN = 0x15, /* G color register for LED 1, Slot 0 */
HYPERX_REG_SLOT0_LED1_BLUE = 0x16, /* B color register for LED 1, Slot 0 */
HYPERX_REG_SLOT0_LED2_RED = 0x17, /* R color register for LED 2, Slot 0 */
HYPERX_REG_SLOT0_LED2_GREEN = 0x18, /* G color register for LED 2, Slot 0 */
HYPERX_REG_SLOT0_LED2_BLUE = 0x19, /* B color register for LED 2, Slot 0 */
HYPERX_REG_SLOT0_LED3_RED = 0x1A, /* R color register for LED 3, Slot 0 */
HYPERX_REG_SLOT0_LED3_GREEN = 0x1B, /* G color register for LED 3, Slot 0 */
HYPERX_REG_SLOT0_LED3_BLUE = 0x1C, /* B color register for LED 3, Slot 0 */
HYPERX_REG_SLOT0_LED4_RED = 0x1D, /* R color register for LED 4, Slot 0 */
HYPERX_REG_SLOT0_LED4_GREEN = 0x1E, /* G color register for LED 4, Slot 0 */
HYPERX_REG_SLOT0_LED4_BLUE = 0x1F, /* B color register for LED 4, Slot 0 */
HYPERX_REG_SLOT0_LED0_BRIGHTNESS = 0x21, /* Brightness for LED 0, Slot 0 (0-100) */
HYPERX_REG_SLOT0_LED1_BRIGHTNESS = 0x24, /* Brightness for LED 1, Slot 0 (0-100) */
HYPERX_REG_SLOT0_LED2_BRIGHTNESS = 0x27, /* Brightness for LED 2, Slot 0 (0-100) */
HYPERX_REG_SLOT0_LED3_BRIGHTNESS = 0x2A, /* Brightness for LED 3, Slot 0 (0-100) */
HYPERX_REG_SLOT0_LED4_BRIGHTNESS = 0x2D, /* Brightness for LED 4, Slot 0 (0-100) */
HYPERX_REG_SLOT1_LED0_RED = 0x41, /* R color register for LED 0, Slot 1 */
HYPERX_REG_SLOT1_LED0_GREEN = 0x42, /* G color register for LED 0, Slot 1 */
HYPERX_REG_SLOT1_LED0_BLUE = 0x43, /* B color register for LED 0, Slot 1 */
HYPERX_REG_SLOT1_LED1_RED = 0x44, /* R color register for LED 1, Slot 1 */
HYPERX_REG_SLOT1_LED1_GREEN = 0x45, /* G color register for LED 1, Slot 1 */
HYPERX_REG_SLOT1_LED1_BLUE = 0x46, /* B color register for LED 1, Slot 1 */
HYPERX_REG_SLOT1_LED2_RED = 0x47, /* R color register for LED 2, Slot 1 */
HYPERX_REG_SLOT1_LED2_GREEN = 0x48, /* G color register for LED 2, Slot 1 */
HYPERX_REG_SLOT1_LED2_BLUE = 0x49, /* B color register for LED 2, Slot 1 */
HYPERX_REG_SLOT1_LED3_RED = 0x4A, /* R color register for LED 3, Slot 1 */
HYPERX_REG_SLOT1_LED3_GREEN = 0x4B, /* G color register for LED 3, Slot 1 */
HYPERX_REG_SLOT1_LED3_BLUE = 0x4C, /* B color register for LED 3, Slot 1 */
HYPERX_REG_SLOT1_LED4_RED = 0x4D, /* R color register for LED 4, Slot 1 */
HYPERX_REG_SLOT1_LED4_GREEN = 0x4E, /* G color register for LED 4, Slot 1 */
HYPERX_REG_SLOT1_LED4_BLUE = 0x4F, /* B color register for LED 4, Slot 1 */
HYPERX_REG_SLOT1_LED0_BRIGHTNESS = 0x51, /* Brightness for LED 0, Slot 1 (0-100) */
HYPERX_REG_SLOT1_LED1_BRIGHTNESS = 0x54, /* Brightness for LED 1, Slot 1 (0-100) */
HYPERX_REG_SLOT1_LED2_BRIGHTNESS = 0x57, /* Brightness for LED 2, Slot 1 (0-100) */
HYPERX_REG_SLOT1_LED3_BRIGHTNESS = 0x5A, /* Brightness for LED 3, Slot 1 (0-100) */
HYPERX_REG_SLOT1_LED4_BRIGHTNESS = 0x5D, /* Brightness for LED 4, Slot 1 (0-100) */
HYPERX_REG_SLOT2_LED0_RED = 0x71, /* R color register for LED 0, Slot 2 */
HYPERX_REG_SLOT2_LED0_GREEN = 0x72, /* G color register for LED 0, Slot 2 */
HYPERX_REG_SLOT2_LED0_BLUE = 0x73, /* B color register for LED 0, Slot 2 */
HYPERX_REG_SLOT2_LED1_RED = 0x74, /* R color register for LED 1, Slot 2 */
HYPERX_REG_SLOT2_LED1_GREEN = 0x75, /* G color register for LED 1, Slot 2 */
HYPERX_REG_SLOT2_LED1_BLUE = 0x76, /* B color register for LED 1, Slot 2 */
HYPERX_REG_SLOT2_LED2_RED = 0x77, /* R color register for LED 2, Slot 2 */
HYPERX_REG_SLOT2_LED2_GREEN = 0x78, /* G color register for LED 2, Slot 2 */
HYPERX_REG_SLOT2_LED2_BLUE = 0x79, /* B color register for LED 2, Slot 2 */
HYPERX_REG_SLOT2_LED3_RED = 0x7A, /* R color register for LED 3, Slot 2 */
HYPERX_REG_SLOT2_LED3_GREEN = 0x7B, /* G color register for LED 3, Slot 2 */
HYPERX_REG_SLOT2_LED3_BLUE = 0x7C, /* B color register for LED 3, Slot 2 */
HYPERX_REG_SLOT2_LED4_RED = 0x7D, /* R color register for LED 4, Slot 2 */
HYPERX_REG_SLOT2_LED4_GREEN = 0x7E, /* G color register for LED 4, Slot 2 */
HYPERX_REG_SLOT2_LED4_BLUE = 0x7F, /* B color register for LED 4, Slot 2 */
HYPERX_REG_SLOT2_LED0_BRIGHTNESS = 0x81, /* Brightness for LED 0, Slot 2 (0-100) */
HYPERX_REG_SLOT2_LED1_BRIGHTNESS = 0x84, /* Brightness for LED 1, Slot 2 (0-100) */
HYPERX_REG_SLOT2_LED2_BRIGHTNESS = 0x87, /* Brightness for LED 2, Slot 2 (0-100) */
HYPERX_REG_SLOT2_LED3_BRIGHTNESS = 0x8A, /* Brightness for LED 3, Slot 2 (0-100) */
HYPERX_REG_SLOT2_LED4_BRIGHTNESS = 0x8D, /* Brightness for LED 4, Slot 2 (0-100) */
HYPERX_REG_SLOT3_LED0_RED = 0xA1, /* R color register for LED 0, Slot 3 */
HYPERX_REG_SLOT3_LED0_GREEN = 0xA2, /* G color register for LED 0, Slot 3 */
HYPERX_REG_SLOT3_LED0_BLUE = 0xA3, /* B color register for LED 0, Slot 3 */
HYPERX_REG_SLOT3_LED1_RED = 0xA4, /* R color register for LED 1, Slot 3 */
HYPERX_REG_SLOT3_LED1_GREEN = 0xA5, /* G color register for LED 1, Slot 3 */
HYPERX_REG_SLOT3_LED1_BLUE = 0xA6, /* B color register for LED 1, Slot 3 */
HYPERX_REG_SLOT3_LED2_RED = 0xA7, /* R color register for LED 2, Slot 3 */
HYPERX_REG_SLOT3_LED2_GREEN = 0xA8, /* G color register for LED 2, Slot 3 */
HYPERX_REG_SLOT3_LED2_BLUE = 0xA9, /* B color register for LED 2, Slot 3 */
HYPERX_REG_SLOT3_LED3_RED = 0xAA, /* R color register for LED 3, Slot 3 */
HYPERX_REG_SLOT3_LED3_GREEN = 0xAB, /* G color register for LED 3, Slot 3 */
HYPERX_REG_SLOT3_LED3_BLUE = 0xAC, /* B color register for LED 3, Slot 3 */
HYPERX_REG_SLOT3_LED4_RED = 0xAD, /* R color register for LED 4, Slot 3 */
HYPERX_REG_SLOT3_LED4_GREEN = 0xAE, /* G color register for LED 4, Slot 3 */
HYPERX_REG_SLOT3_LED4_BLUE = 0xAF, /* B color register for LED 4, Slot 3 */
HYPERX_REG_SLOT3_LED0_BRIGHTNESS = 0xB1, /* Brightness for LED 0, Slot 3 (0-100) */
HYPERX_REG_SLOT3_LED1_BRIGHTNESS = 0xB4, /* Brightness for LED 1, Slot 3 (0-100) */
HYPERX_REG_SLOT3_LED2_BRIGHTNESS = 0xB7, /* Brightness for LED 2, Slot 3 (0-100) */
HYPERX_REG_SLOT3_LED3_BRIGHTNESS = 0xBA, /* Brightness for LED 3, Slot 3 (0-100) */
HYPERX_REG_SLOT3_LED4_BRIGHTNESS = 0xBD, /* Brightness for LED 4, Slot 3 (0-100) */
HYPERX_REG_TIMER_MSB = 0xD1, /* Timer MSB */
HYPERX_REG_TIMER_LSB = 0xD2, /* Timer LSB */
HYPERX_REG_ON_TIME_MSB = 0xD3, /* Effect on time MSB */
HYPERX_REG_ON_TIME_LSB = 0xD4, /* Effect on time LSB */
HYPERX_REG_CHANGE_TIME_MSB = 0xD5, /* Change time MSB */
HYPERX_REG_CHANGE_TIME_LSB = 0xD6, /* Change time LSB */
HYPERX_REG_FADE_IN_TIME_MSB = 0xD7, /* Fade in time MSB */
HYPERX_REG_FADE_IN_TIME_LSB = 0xD8, /* Fade in time LSB */
HYPERX_REG_FADE_OUT_TIME_MSB = 0xD9, /* Fade out time MSB */
HYPERX_REG_FADE_OUT_TIME_LSB = 0xDA, /* Fade out time LSB */
HYPERX_REG_OFF_TIME_MSB = 0xDB, /* Effect off time MSB */
HYPERX_REG_OFF_TIME_LSB = 0xDC, /* Effect off time LSB */
HYPERX_REG_EFFECT_BRIGHTNESS = 0xDD, /* Brightness for effects (0-100) */
HYPERX_REG_APPLY = 0xE1, /* Apply changes register */
HYPERX_REG_MODE_RANDOM = 0xE3, /* Mode control register, random colors */
HYPERX_REG_MODE_CUSTOM = 0xE4, /* Mode control register, custom colors */
HYPERX_REG_MODE_INDEPENDENT = 0xE5, /* Mode control register, independent */
HYPERX_REG_DELAY_TIME_MSB = 0xEA, /* Delay time MSB */
HYPERX_REG_DELAY_TIME_LSB = 0xEB, /* Delay time LSB */
HYPERX_REG_EFFECT_RED = 0xEC, /* Red color register for effects */
HYPERX_REG_EFFECT_GREEN = 0xED, /* Green color register for effects */
HYPERX_REG_EFFECT_BLUE = 0xEE, /* Blue color register for effects */
};
enum
{
HYPERX_MODE1_RAINBOW = 0x05, /* Mode 1 rainbow effect */
HYPERX_MODE1_CYCLE = 0x04, /* Mode 1 cycle effect */
};
enum
{
HYPERX_MODE2_BOUNCE = 0x02, /* Mode 2 bounce effect */
HYPERX_MODE2_BREATHING = 0x03, /* Mode 2 breathing effect */
HYPERX_MODE2_BLINK = 0x06, /* Mode 2 blink effect */
HYPERX_MODE2_HEARTBEAT = 0x07, /* Mode 2 heartbeat effect */
HYPERX_MODE2_COMET = 0x08, /* Mode 2 comet effect */
HYPERX_MODE2_STATIC = 0x09, /* Mode 2 static effect */
};
enum
{
HYPERX_MODE3_DIRECT = 0x21, /* Mode 3 direct control */
};
enum
{
HYPERX_MODE_DIRECT = 0, /* Direct control mode */
HYPERX_MODE_STATIC = 1, /* Static color mode */
HYPERX_MODE_RAINBOW = 2, /* Rainbow wave mode */
HYPERX_MODE_COMET = 3, /* Comet (chase) mode */
HYPERX_MODE_HEARTBEAT = 4, /* Heartbeat (pulsing) mode */
HYPERX_MODE_CYCLE = 5, /* Spectrum cycle mode */
HYPERX_MODE_BREATHING = 6, /* Breathing mode */
HYPERX_MODE_BOUNCE = 7, /* Bounce mode */
HYPERX_MODE_BLINK = 8, /* Blinking mode */
HYPERX_NUMBER_MODES /* Number of HyperX modes */
};
enum
{
HYPERX_SPEED_BOUNCE_SLOW = 0x07D0, /* Slowest speed for bounce mode */
HYPERX_SPEED_BOUNCE_NORMAL = 0x07D0, /* Normal speed for bounce mode */
HYPERX_SPEED_BOUNCE_FAST = 0x0064, /* Fastest speed for bounce mode */
HYPERX_SPEED_BREATHING_SLOW = 0x07D0, /* Slowest speed for breathing mode */
HYPERX_SPEED_BREATHING_NORMAL = 0x07D0, /* Normal speed for breathing mode */
HYPERX_SPEED_BREATHING_FAST = 0x0064, /* Fastest speed for breathing mode */
HYPERX_SPEED_CYCLE_SLOW = 0x05DC, /* Slowest speed for cycle mode */
HYPERX_SPEED_CYCLE_NORMAL = 0x05DC, /* Normal speed for cycle mode */
HYPERX_SPEED_CYCLE_FAST = 0x00FA, /* Fastest speed for cycle mode */
HYPERX_SPEED_RAINBOW_SLOW = 0x07D0, /* Slowest speed for rainbow mode */
HYPERX_SPEED_RAINBOW_NORMAL = 0x07D0, /* Normal speed for rainbow mode */
HYPERX_SPEED_RAINBOW_FAST = 0x0064, /* Fastest speed for rainbow mode */
HYPERX_SPEED_BLINK_SLOW = 0x07D0, /* Slowest speed for blink mode */
HYPERX_SPEED_BLINK_NORMAL = 0x07D0, /* Normal speed for blink mode */
HYPERX_SPEED_BLINK_FAST = 0x01F4, /* Fastest speed for blink mode */
HYPERX_SPEED_HEARTBEAT_SLOW = 0x07D0, /* Slowest speed for heartbeat mode */
HYPERX_SPEED_HEARTBEAT_NORMAL = 0x07D0, /* Normal speed for heartbeat mode */
HYPERX_SPEED_HEARTBEAT_FAST = 0x01F4, /* Fastest speed for heartbeat mode */
HYPERX_SPEED_COMET_SLOW = 0x07D0, /* Slowest speed for comet mode */
HYPERX_SPEED_COMET_NORMAL = 0x07D0, /* Normal speed for comet mode */
HYPERX_SPEED_COMET_FAST = 0x0064, /* Fastest speed for comet mode */
};
static const unsigned char slot_base[4] =
{
HYPERX_REG_SLOT0_LED0_RED, /* SPD 0x50 maps to slot 0 */
HYPERX_REG_SLOT1_LED0_RED, /* SPD 0x52 maps to slot 1 */
HYPERX_REG_SLOT2_LED0_RED, /* SPD 0x51 maps to slot 2 */
HYPERX_REG_SLOT3_LED0_RED /* SPD 0x53 maps to slot 3 */
};
static const unsigned char slot_map[4] =
{
0,
2,
1,
3
};
class HyperXDRAMController
{
public:
HyperXDRAMController(i2c_smbus_interface* bus, hyperx_dev_id dev, unsigned char slots, std::string dev_name);
~HyperXDRAMController();
std::string GetDeviceLocation();
std::string GetDeviceName();
unsigned int GetLEDCount();
unsigned int GetSlotCount();
unsigned int GetMode();
void SendApply();
void SetMode(unsigned char new_mode, bool random, unsigned short new_speed);
void SetAllColors(unsigned char red, unsigned char green, unsigned char blue);
void SetEffectColor(unsigned char red, unsigned char green, unsigned char blue);
void SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
void SetLEDColor(unsigned int slot, unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
private:
unsigned int led_count;
unsigned char slots_valid;
i2c_smbus_interface* bus;
hyperx_dev_id dev;
unsigned int mode;
unsigned short speed;
std::string name;
};
Controllers/HyperXDRAMController/HyperXDRAMControllerDetect.cpp
+104
View File
@@ -0,0 +1,104 @@
/*---------------------------------------------------------*\
| HyperXDRAMControllerDetect.cpp |
| |
| Driver for HyperX/Kingston Fury RAM |
| |
| Adam Honse (CalcProgrammer1) 19 Jun 2019 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <vector>
#include "Detector.h"
#include "HyperXDRAMController.h"
#include "LogManager.h"
#include "RGBController_HyperXDRAM.h"
#include "i2c_smbus.h"
#include "pci_ids.h"
using namespace std::chrono_literals;
/******************************************************************************************\
* *
* TestForHyperXDRAMController *
* *
* Tests the given address to see if a HyperX controller exists there. *
* *
\******************************************************************************************/
#define HYPERX_CONTROLLER_NAME "HyperX DRAM"
bool TestForHyperXDRAMController(i2c_smbus_interface* bus, unsigned char address)
{
int res = bus->i2c_smbus_read_byte(address);
return(res >= 0);
} /* TestForHyperXDRAMController() */
/******************************************************************************************\
* *
* DetectHyperXDRAMControllers *
* *
* Detect HyperX DRAM controllers on the enumerated I2C busses. *
* *
* bus - pointer to i2c_smbus_interface where Aura device is connected *
* slots - accessors to SPD information of the occupied slots *
* *
\******************************************************************************************/
void DetectHyperXDRAMControllers(i2c_smbus_interface* bus, std::vector<SPDWrapper*> &slots, const std::string &/*name*/)
{
unsigned char slots_valid = 0x00;
bool fury_detected = false;
bool pred_detected = false;
// Check for HyperX controller at 0x27
LOG_DEBUG("[%s] Testing bus %d at address 0x27", HYPERX_CONTROLLER_NAME, bus->port_id);
if(TestForHyperXDRAMController(bus, 0x27))
{
for(SPDWrapper *slot : slots)
{
LOG_DEBUG("[%s] SPD check success", HYPERX_CONTROLLER_NAME);
slots_valid |= (1 << (slot->index()));
if(slot->manufacturer_data(0x06) == 0x01)
{
fury_detected = true;
}
else
{
pred_detected = true;
}
std::this_thread::sleep_for(1ms);
}
LOG_DEBUG("[%s] slots_valid=%d fury_detected=%d pred_detected=%d",
HYPERX_CONTROLLER_NAME, slots_valid, fury_detected, pred_detected);
if(slots_valid != 0)
{
std::string name = "HyperX DRAM";
if(fury_detected && !pred_detected)
{
name = "HyperX Fury RGB";
}
else if(!fury_detected && pred_detected)
{
name = "HyperX Predator RGB";
}
HyperXDRAMController* controller = new HyperXDRAMController(bus, 0x27, slots_valid, name);
RGBController_HyperXDRAM* rgb_controller = new RGBController_HyperXDRAM(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
} /* DetectHyperXDRAMControllers() */
REGISTER_I2C_DIMM_DETECTOR("HyperX DRAM", DetectHyperXDRAMControllers, JEDEC_KINGSTON, SPD_DDR4_SDRAM);
Controllers/HyperXDRAMController/RGBController_HyperXDRAM.cpp
+273
View File
@@ -0,0 +1,273 @@
/*---------------------------------------------------------*\
| RGBController_HyperXDRAM.cpp |
| |
| RGBController for HyperX/Kingston Fury RAM |
| |
| Adam Honse (CalcProgrammer1) 29 Jun 2019 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_HyperXDRAM.h"
/**------------------------------------------------------------------*\
@name HyperX DRAM
@category RAM
@type I2C
@save :x:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectHyperXDRAMControllers
@comment
\*-------------------------------------------------------------------*/
RGBController_HyperXDRAM::RGBController_HyperXDRAM(HyperXDRAMController* controller_ptr)
{
controller = controller_ptr;
name = controller->GetDeviceName();
vendor = "HyperX";
type = DEVICE_TYPE_DRAM;
description = "HyperX DRAM Device";
location = controller->GetDeviceLocation();
mode Direct;
Direct.name = "Direct";
Direct.value = HYPERX_MODE_DIRECT;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
mode Static;
Static.name = "Static";
Static.value = HYPERX_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Static.colors_min = 1;
Static.colors_max = 1;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.colors.resize(1);
modes.push_back(Static);
mode Rainbow;
Rainbow.name = "Rainbow";
Rainbow.value = HYPERX_MODE_RAINBOW;
Rainbow.flags = MODE_FLAG_HAS_SPEED;
Rainbow.speed_min = HYPERX_SPEED_RAINBOW_SLOW;
Rainbow.speed_max = HYPERX_SPEED_RAINBOW_FAST;
Rainbow.speed = HYPERX_SPEED_RAINBOW_NORMAL;
Rainbow.color_mode = MODE_COLORS_NONE;
modes.push_back(Rainbow);
mode Comet;
Comet.name = "Comet";
Comet.value = HYPERX_MODE_COMET;
Comet.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
Comet.speed_min = HYPERX_SPEED_COMET_SLOW;
Comet.speed_max = HYPERX_SPEED_COMET_FAST;
Comet.colors_min = 1;
Comet.colors_max = 1;
Comet.speed = HYPERX_SPEED_COMET_NORMAL;
Comet.color_mode = MODE_COLORS_MODE_SPECIFIC;
Comet.colors.resize(1);
modes.push_back(Comet);
mode Heartbeat;
Heartbeat.name = "Heartbeat";
Heartbeat.value = HYPERX_MODE_HEARTBEAT;
Heartbeat.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
Heartbeat.speed_min = HYPERX_SPEED_COMET_SLOW;
Heartbeat.speed_max = HYPERX_SPEED_COMET_FAST;
Heartbeat.colors_min = 1;
Heartbeat.colors_max = 1;
Heartbeat.speed = HYPERX_SPEED_COMET_NORMAL;
Heartbeat.color_mode = MODE_COLORS_MODE_SPECIFIC;
Heartbeat.colors.resize(1);
modes.push_back(Heartbeat);
mode SpectrumCycle;
SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = HYPERX_MODE_CYCLE;
SpectrumCycle.flags = MODE_FLAG_HAS_SPEED;
SpectrumCycle.speed_min = HYPERX_SPEED_CYCLE_SLOW;
SpectrumCycle.speed_max = HYPERX_SPEED_CYCLE_FAST;
SpectrumCycle.speed = HYPERX_SPEED_CYCLE_NORMAL;
SpectrumCycle.color_mode = MODE_COLORS_NONE;
modes.push_back(SpectrumCycle);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = HYPERX_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
Breathing.speed_min = HYPERX_SPEED_BREATHING_SLOW;
Breathing.speed_max = HYPERX_SPEED_BREATHING_FAST;
Breathing.colors_min = 1;
Breathing.colors_max = 1;
Breathing.speed = HYPERX_SPEED_BREATHING_NORMAL;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.colors.resize(1);
modes.push_back(Breathing);
mode Bounce;
Bounce.name = "Bounce";
Bounce.value = HYPERX_MODE_BOUNCE;
Bounce.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
Bounce.speed_min = HYPERX_SPEED_BOUNCE_SLOW;
Bounce.speed_max = HYPERX_SPEED_BOUNCE_FAST;
Bounce.colors_min = 1;
Bounce.colors_max = 1;
Bounce.speed = HYPERX_SPEED_BOUNCE_NORMAL;
Bounce.color_mode = MODE_COLORS_MODE_SPECIFIC;
Bounce.colors.resize(1);
modes.push_back(Bounce);
mode Blink;
Blink.name = "Blink";
Blink.value = HYPERX_MODE_BLINK;
Blink.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
Blink.speed_min = HYPERX_SPEED_BLINK_SLOW;
Blink.speed_max = HYPERX_SPEED_BLINK_FAST;
Blink.colors_min = 1;
Blink.colors_max = 1;
Blink.speed = HYPERX_SPEED_BLINK_NORMAL;
Blink.color_mode = MODE_COLORS_MODE_SPECIFIC;
Blink.colors.resize(1);
modes.push_back(Blink);
SetupZones();
}
RGBController_HyperXDRAM::~RGBController_HyperXDRAM()
{
delete controller;
}
void RGBController_HyperXDRAM::SetupZones()
{
for(unsigned int slot = 0; slot < controller->GetSlotCount(); slot++)
{
zone* new_zone = new zone;
new_zone->name = "HyperX Slot ";
new_zone->name.append(std::to_string(slot + 1));
new_zone->type = ZONE_TYPE_LINEAR;
new_zone->leds_min = 5;
new_zone->leds_max = 5;
new_zone->leds_count = 5;
new_zone->matrix_map = NULL;
zones.push_back(*new_zone);
}
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
for(std::size_t led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
{
led* new_led = new led();
new_led->name = "HyperX Slot ";
new_led->name.append(std::to_string(zone_idx + 1));
new_led->name.append(", LED ");
new_led->name.append(std::to_string(led_idx + 1));
new_led->value = (unsigned int)leds.size();
leds.push_back(*new_led);
}
}
SetupColors();
}
void RGBController_HyperXDRAM::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_HyperXDRAM::DeviceUpdateLEDs()
{
if(controller->GetMode() == HYPERX_MODE_DIRECT)
{
for(unsigned int led_idx = 0; led_idx < (unsigned int)colors.size(); led_idx++ )
{
RGBColor color = colors[led_idx];
unsigned char red = RGBGetRValue(color);
unsigned char grn = RGBGetGValue(color);
unsigned char blu = RGBGetBValue(color);
controller->SetLEDColor(led_idx, red, grn, blu);
}
controller->SendApply();
}
else
{
unsigned char red = RGBGetRValue(colors[0]);
unsigned char grn = RGBGetGValue(colors[0]);
unsigned char blu = RGBGetBValue(colors[0]);
controller->SetEffectColor(red, grn, blu);
}
}
void RGBController_HyperXDRAM::UpdateZoneLEDs(int zone)
{
if(controller->GetMode() == HYPERX_MODE_DIRECT)
{
for(std::size_t led_idx = 0; led_idx < zones[zone].leds_count; led_idx++ )
{
unsigned int led = zones[zone].leds[led_idx].value;
RGBColor color = colors[led];
unsigned char red = RGBGetRValue(color);
unsigned char grn = RGBGetGValue(color);
unsigned char blu = RGBGetBValue(color);
controller->SetLEDColor(led, red, grn, blu);
}
controller->SendApply();
}
else
{
unsigned char red = RGBGetRValue(colors[0]);
unsigned char grn = RGBGetGValue(colors[0]);
unsigned char blu = RGBGetBValue(colors[0]);
controller->SetEffectColor(red, grn, blu);
}
}
void RGBController_HyperXDRAM::UpdateSingleLED(int led)
{
RGBColor color = colors[led];
unsigned char red = RGBGetRValue(color);
unsigned char grn = RGBGetGValue(color);
unsigned char blu = RGBGetBValue(color);
if(controller->GetMode() == HYPERX_MODE_DIRECT)
{
controller->SetLEDColor(led, red, grn, blu);
}
else
{
controller->SetEffectColor(red, grn, blu);
}
controller->SendApply();
}
void RGBController_HyperXDRAM::DeviceUpdateMode()
{
bool random = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
controller->SetMode(modes[active_mode].value, random, modes[active_mode].speed);
if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
{
unsigned char red = RGBGetRValue(modes[active_mode].colors[0]);
unsigned char grn = RGBGetGValue(modes[active_mode].colors[0]);
unsigned char blu = RGBGetBValue(modes[active_mode].colors[0]);
controller->SetEffectColor(red, grn, blu);
}
}
Controllers/HyperXDRAMController/RGBController_HyperXDRAM.h
+35
View File
@@ -0,0 +1,35 @@
/*---------------------------------------------------------*\
| RGBController_HyperXDRAM.h |
| |
| RGBController for HyperX/Kingston Fury RAM |
| |
| Adam Honse (CalcProgrammer1) 29 Jun 2019 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "HyperXDRAMController.h"
class RGBController_HyperXDRAM : public RGBController
{
public:
RGBController_HyperXDRAM(HyperXDRAMController* controller_ptr);
~RGBController_HyperXDRAM();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
HyperXDRAMController* controller;
};