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/GigabyteRGBFusionController/GigabyteRGBFusionController.cpp
+196
View File
@@ -0,0 +1,196 @@
/*---------------------------------------------------------*\
| GigabyteRGBFusionController.cpp |
| |
| Driver for Gigabyte Aorus RGB Fusion SMBus motherboard |
| |
| Adam Honse (CalcProgrammer1) 10 Dec 2019 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include <stdio.h>
#include <stdlib.h>
#include "GigabyteRGBFusionController.h"
RGBFusionController::RGBFusionController(i2c_smbus_interface* bus, rgb_fusion_dev_id dev)
{
this->bus = bus;
this->dev = dev;
// Set Device name
strcpy(device_name, "Gigabyte Motherboard");
// Set LED count
led_count = 2;
// Enable control
switch_bank(0);
bus->i2c_smbus_write_byte_data(dev, 0x02, 0x09);
}
RGBFusionController::~RGBFusionController()
{
}
std::string RGBFusionController::GetDeviceName()
{
return(device_name);
}
std::string RGBFusionController::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 RGBFusionController::GetLEDCount()
{
return(led_count);
}
unsigned char RGBFusionController::GetMode()
{
switch_bank(0);
return(get_mode_ch_0());
}
void RGBFusionController::SetAllColors(unsigned char red, unsigned char green, unsigned char blue)
{
unsigned char mode_ch_0;
unsigned char mode_ch_1;
switch_bank(1);
set_color_ch_0(red, green, blue);
set_color_ch_1(red, green, blue);
switch_bank(0);
mode_ch_0 = get_mode_ch_0();
mode_ch_1 = get_mode_ch_1();
set_mode_ch_0(mode_ch_0);
set_mode_ch_1(mode_ch_1);
}
void RGBFusionController::SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
{
unsigned char mode;
switch (led)
{
case 0:
switch_bank(1);
set_color_ch_0(red, green, blue);
switch_bank(0);
mode = get_mode_ch_0();
set_mode_ch_0(mode);
break;
case 1:
switch_bank(1);
set_color_ch_1(red, green, blue);
switch_bank(0);
mode = get_mode_ch_1();
set_mode_ch_1(mode);
break;
}
}
void RGBFusionController::SetMode(unsigned char mode, unsigned char speed)
{
switch_bank(0);
set_mode_ch_0(mode);
set_timers_ch_0(speed_table[0][speed], speed_table[1][speed]);
set_mode_ch_1(mode);
set_timers_ch_1(speed_table[0][speed], speed_table[1][speed]);
}
void RGBFusionController::dump()
{
int i, j;
int start = 0x00;
FILE* file = freopen("rgb_fusion_dump.txt", "a", stdout);
printf(" 0 1 2 3 4 5 6 7 8 9 a b c d e f\r\n");
for (i = 0; i < 0xFF; i += 16)
{
printf("%04x: ", i + start);
for (j = 0; j < 16; j++)
{
printf("%02x ", bus->i2c_smbus_read_byte_data(dev, (start + i + j)));
}
printf("\r\n");
}
fclose(file);
}
unsigned char RGBFusionController::get_mode_ch_0()
{
return(bus->i2c_smbus_read_byte_data(dev, RGB_FUSION_BANK_0_REG_CH_0_MODE));
}
unsigned char RGBFusionController::get_mode_ch_1()
{
return(bus->i2c_smbus_read_byte_data(dev, RGB_FUSION_BANK_0_REG_CH_1_MODE));
}
void RGBFusionController::set_color_ch_0(unsigned char red, unsigned char green, unsigned char blue)
{
bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_1_REG_CH_0_R, red);
bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_1_REG_CH_0_G, green);
bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_1_REG_CH_0_B, blue);
bus->i2c_smbus_write_byte_data(dev, 0x03, 0x01);
}
void RGBFusionController::set_color_ch_1(unsigned char red, unsigned char green, unsigned char blue)
{
bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_1_REG_CH_1_R, red);
bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_1_REG_CH_1_G, green);
bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_1_REG_CH_1_B, blue);
bus->i2c_smbus_write_byte_data(dev, 0x0B, 0x01);
}
void RGBFusionController::set_mode_ch_0(unsigned char mode)
{
bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_0_REG_CH_0_MODE, mode + RGB_FUSION_WRITE_MODE_OFST);
}
void RGBFusionController::set_mode_ch_1(unsigned char mode)
{
bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_0_REG_CH_1_MODE, mode + RGB_FUSION_WRITE_MODE_OFST);
}
void RGBFusionController::set_timers_ch_0(unsigned short timer0, unsigned short timer1)
{
bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_0_REG_CH_0_TIMER_0_MSB, timer0 >> 8);
bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_0_REG_CH_0_TIMER_0_LSB, timer0 & 0xFF);
bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_0_REG_CH_0_TIMER_1_MSB, timer1 >> 8);
bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_0_REG_CH_0_TIMER_1_LSB, timer1 & 0xFF);
}
void RGBFusionController::set_timers_ch_1(unsigned short timer0, unsigned short timer1)
{
bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_0_REG_CH_1_TIMER_0_MSB, timer0 >> 8);
bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_0_REG_CH_1_TIMER_0_LSB, timer0 & 0xFF);
bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_0_REG_CH_1_TIMER_1_MSB, timer1 >> 8);
bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_0_REG_CH_1_TIMER_1_LSB, timer1 & 0xFF);
}
void RGBFusionController::switch_bank(unsigned char bank)
{
bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_SWITCH_REG, bank);
}
Controllers/GigabyteRGBFusionController/GigabyteRGBFusionController.h
+104
View File
@@ -0,0 +1,104 @@
/*---------------------------------------------------------*\
| GigabyteRGBFusionController.h |
| |
| Driver for Gigabyte Aorus RGB Fusion SMBus motherboard |
| |
| Adam Honse (CalcProgrammer1) 10 Dec 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 rgb_fusion_dev_id;
enum
{
RGB_FUSION_BANK_0_REG_CH_0_MODE = 0x03, /* Channel 0 Mode Selection */
RGB_FUSION_BANK_0_REG_CH_0_TIMER_0_MSB
= 0x06, /* Channel 0 Timer 0 MSB */
RGB_FUSION_BANK_0_REG_CH_0_TIMER_0_LSB
= 0x07, /* Channel 0 Timer 0 LSB */
RGB_FUSION_BANK_0_REG_CH_0_TIMER_1_MSB
= 0x08, /* Channel 0 Timer 1 MSB */
RGB_FUSION_BANK_0_REG_CH_0_TIMER_1_LSB
= 0x09, /* Channel 0 Timer 1 LSB */
RGB_FUSION_BANK_0_REG_CH_1_MODE = 0x13, /* Channel 1 Mode Selection */
RGB_FUSION_BANK_0_REG_CH_1_TIMER_0_MSB
= 0x16, /* Channel 1 Timer 0 MSB */
RGB_FUSION_BANK_0_REG_CH_1_TIMER_0_LSB
= 0x17, /* Channel 1 Timer 0 LSB */
RGB_FUSION_BANK_0_REG_CH_1_TIMER_1_MSB
= 0x18, /* Channel 1 Timer 1 MSB */
RGB_FUSION_BANK_0_REG_CH_1_TIMER_1_LSB
= 0x19, /* Channel 1 Timer 1 LSB */
RGB_FUSION_BANK_1_REG_CH_0_R = 0x00, /* Channel 0 Red Value */
RGB_FUSION_BANK_1_REG_CH_0_G = 0x01, /* Channel 0 Green Value */
RGB_FUSION_BANK_1_REG_CH_0_B = 0x02, /* Channel 0 Blue Value */
RGB_FUSION_BANK_1_REG_CH_1_R = 0x08, /* Channel 1 Red Value */
RGB_FUSION_BANK_1_REG_CH_1_G = 0x09, /* Channel 1 Green Value */
RGB_FUSION_BANK_1_REG_CH_1_B = 0x0A, /* Channel 1 Blue Value */
RGB_FUSION_BANK_SWITCH_REG = 0xF0, /* Bank Switch Register */
};
enum
{
RGB_FUSION_SPEED_SLOW = 0x00, /* Slowest speed */
RGB_FUSION_SPEED_NORMAL = 0x01, /* Normal speed */
RGB_FUSION_SPEED_FAST = 0x02, /* Fastest speed */
};
static const short speed_table[2][3] =
{
{ 0x01E0, 0x00F0, 0x0078 },
{ 0x4000, 0x2000, 0x1000 }
};
#define RGB_FUSION_NUMBER_MODES 3 /* Number of RGB Fusion modes */
#define RGB_FUSION_WRITE_MODE_OFST 0x10 /* offset to add when writing mode */
enum
{
RGB_FUSION_MODE_STATIC = 0x00, /* Static color mode */
RGB_FUSION_MODE_BREATHING = 0x01, /* Breathing effect mode */
RGB_FUSION_MODE_FLASHING = 0x02, /* Flashing effect mode */
};
class RGBFusionController
{
public:
RGBFusionController(i2c_smbus_interface* bus, rgb_fusion_dev_id dev);
~RGBFusionController();
std::string GetDeviceName();
std::string GetDeviceLocation();
unsigned int GetLEDCount();
unsigned char GetMode();
void SetAllColors(unsigned char red, unsigned char green, unsigned char blue);
void SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
void SetMode(unsigned char mode, unsigned char speed);
private:
void dump();
unsigned char get_mode_ch_0();
unsigned char get_mode_ch_1();
void set_color_ch_0(unsigned char red, unsigned char green, unsigned char blue);
void set_color_ch_1(unsigned char red, unsigned char green, unsigned char blue);
void set_mode_ch_0(unsigned char mode);
void set_mode_ch_1(unsigned char mode);
void set_timers_ch_0(unsigned short timer0, unsigned short timer1);
void set_timers_ch_1(unsigned short timer0, unsigned short timer1);
void switch_bank(unsigned char bank);
char device_name[32];
unsigned int led_count;
i2c_smbus_interface* bus;
rgb_fusion_dev_id dev;
};
Controllers/GigabyteRGBFusionController/GigabyteRGBFusionControllerDetect.cpp
+94
View File
@@ -0,0 +1,94 @@
/*---------------------------------------------------------*\
| GigabyteRGBFusionControllerDetect.cpp |
| |
| Detector for Gigabyte Aorus RGB Fusion SMBus |
| motherboard |
| |
| Adam Honse (CalcProgrammer1) 10 Dec 2019 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <vector>
#include "Detector.h"
#include "GigabyteRGBFusionController.h"
#include "LogManager.h"
#include "RGBController_GigabyteRGBFusion.h"
#include "i2c_smbus.h"
#include "pci_ids.h"
#define DETECTOR_NAME "Gigabyte RGB Fusion SMBus"
#define VENDOR_NAME "Gigabyte Technology Co., Ltd."
#define SMBUS_ADDRESS 0x28
/******************************************************************************************\
* *
* TestForGigabyteRGBFusionController *
* *
* Tests the given address to see if an RGB Fusion controller exists there. First *
* does a quick write to test for a response *
* *
\******************************************************************************************/
bool TestForGigabyteRGBFusionController(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;
res = bus->i2c_smbus_read_byte_data(address, 0xF2);
if (res != 0xC4)
{
pass = false;
}
}
return(pass);
} /* TestForGigabyteRGBFusionController() */
/******************************************************************************************\
* *
* DetectGigabyteRGBFusionControllers *
* *
* Detect RGB Fusion controllers on the enumerated I2C busses at address 0x28. *
* *
* bus - pointer to i2c_smbus_interface where RGB Fusion device is connected *
* dev - I2C address of RGB Fusion device *
* *
\******************************************************************************************/
void DetectGigabyteRGBFusionControllers(std::vector<i2c_smbus_interface*>& busses)
{
for(unsigned int bus = 0; bus < busses.size(); bus++)
{
IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
{
if(busses[bus]->pci_subsystem_vendor == GIGABYTE_SUB_VEN)
{
LOG_DEBUG(SMBUS_CHECK_DEVICE_MESSAGE_EN, DETECTOR_NAME, bus, VENDOR_NAME, SMBUS_ADDRESS);
// Check for RGB Fusion controller at 0x28
if(TestForGigabyteRGBFusionController(busses[bus], SMBUS_ADDRESS))
{
RGBFusionController* controller = new RGBFusionController(busses[bus], SMBUS_ADDRESS);
RGBController_RGBFusion* rgb_controller = new RGBController_RGBFusion(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
else
{
LOG_DEBUG(SMBUS_CHECK_DEVICE_FAILURE_EN, DETECTOR_NAME, bus, VENDOR_NAME);
}
}
}
} /* DetectGigabyteRGBFusionControllers() */
REGISTER_I2C_DETECTOR("Gigabyte RGB Fusion", DetectGigabyteRGBFusionControllers);
Controllers/GigabyteRGBFusionController/RGBController_GigabyteRGBFusion.cpp
+176
View File
@@ -0,0 +1,176 @@
/*---------------------------------------------------------*\
| RGBController_GigabyteRGBFusion.cpp |
| |
| RGBController for Gigabyte Aorus RGB Fusion SMBus |
| motherboard |
| |
| Adam Honse (CalcProgrammer1) 11 Dec 2019 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_GigabyteRGBFusion.h"
static const char* rgb_fusion_zone_names[] =
{
"Motherboard",
"RGB Header"
};
/**------------------------------------------------------------------*\
@name Gigabyte Fusion SMBus
@category Motherboard
@type I2C
@save :x:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectGigabyteRGBFusionControllers
@comment
\*-------------------------------------------------------------------*/
RGBController_RGBFusion::RGBController_RGBFusion(RGBFusionController* controller_ptr)
{
controller = controller_ptr;
name = controller->GetDeviceName();
vendor = "Gigabyte";
description = "RGB Fusion 1.0";
location = controller->GetDeviceLocation();
type = DEVICE_TYPE_MOTHERBOARD;
mode Direct;
Direct.name = "Direct";
Direct.value = RGB_FUSION_MODE_STATIC;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = RGB_FUSION_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
Breathing.speed_min = RGB_FUSION_SPEED_SLOW;
Breathing.speed_max = RGB_FUSION_SPEED_FAST;
Breathing.speed = RGB_FUSION_SPEED_NORMAL;
Breathing.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Breathing);
mode Flashing;
Flashing.name = "Flashing";
Flashing.value = RGB_FUSION_MODE_FLASHING;
Flashing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
Flashing.speed_min = RGB_FUSION_SPEED_SLOW;
Flashing.speed_max = RGB_FUSION_SPEED_FAST;
Flashing.speed = RGB_FUSION_SPEED_NORMAL;
Flashing.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Flashing);
SetupZones();
// Initialize active mode
active_mode = GetDeviceMode();
}
RGBController_RGBFusion::~RGBController_RGBFusion()
{
delete controller;
}
void RGBController_RGBFusion::SetupZones()
{
/*---------------------------------------------------------*\
| Search through all LEDs and create zones for each channel |
| type |
\*---------------------------------------------------------*/
for(unsigned int zone_idx = 0; zone_idx < controller->GetLEDCount(); zone_idx++)
{
zone* new_zone = new zone();
/*---------------------------------------------------------*\
| Set zone name to channel name |
\*---------------------------------------------------------*/
new_zone->name = rgb_fusion_zone_names[zone_idx];
new_zone->leds_min = 1;
new_zone->leds_max = 1;
new_zone->leds_count = 1;
new_zone->matrix_map = NULL;
/*---------------------------------------------------------*\
| Push new zone to zones vector |
\*---------------------------------------------------------*/
zones.push_back(*new_zone);
}
for(unsigned int led_idx = 0; led_idx < zones.size(); led_idx++)
{
led* new_led = new led();
/*---------------------------------------------------------*\
| Set LED name to channel name |
\*---------------------------------------------------------*/
new_led->name = rgb_fusion_zone_names[led_idx];
/*---------------------------------------------------------*\
| Push new LED to LEDs vector |
\*---------------------------------------------------------*/
leds.push_back(*new_led);
}
SetupColors();
}
void RGBController_RGBFusion::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_RGBFusion::DeviceUpdateLEDs()
{
for(unsigned int led = 0; led < (unsigned int)colors.size(); led++)
{
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);
}
}
void RGBController_RGBFusion::UpdateZoneLEDs(int zone)
{
RGBColor color = colors[zone];
unsigned char red = RGBGetRValue(color);
unsigned char grn = RGBGetGValue(color);
unsigned char blu = RGBGetBValue(color);
controller->SetLEDColor(zone, red, grn, blu);
}
void RGBController_RGBFusion::UpdateSingleLED(int led)
{
UpdateZoneLEDs(led);
}
int RGBController_RGBFusion::GetDeviceMode()
{
int dev_mode = controller->GetMode();
for(int mode = 0; mode < (int)modes.size(); mode++)
{
if(modes[mode].value == dev_mode)
{
return(mode);
}
}
return(0);
}
void RGBController_RGBFusion::DeviceUpdateMode()
{
controller->SetMode(modes[active_mode].value, modes[active_mode].speed);
}
Controllers/GigabyteRGBFusionController/RGBController_GigabyteRGBFusion.h
+38
View File
@@ -0,0 +1,38 @@
/*---------------------------------------------------------*\
| RGBController_GigabyteRGBFusion.h |
| |
| RGBController for Gigabyte Aorus RGB Fusion SMBus |
| motherboard |
| |
| Adam Honse (CalcProgrammer1) 11 Dec 2019 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "GigabyteRGBFusionController.h"
class RGBController_RGBFusion : public RGBController
{
public:
RGBController_RGBFusion(RGBFusionController* controller_ptr);
~RGBController_RGBFusion();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
RGBFusionController* controller;
int GetDeviceMode();
};