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/GigabyteSuperIORGBController/GigabyteSuperIORGBController.cpp
+142
View File
@@ -0,0 +1,142 @@
/*---------------------------------------------------------*\
| GigabyteSuperIORGBController.cpp |
| |
| Driver for Gigabyte Aorus Super IO motherboard |
| |
| Ryan Frankcombe (422gRdHuX5uk) 11 Sep 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "GigabyteSuperIORGBController.h"
#include "super_io.h"
GigabyteSuperIORGBController::GigabyteSuperIORGBController(int sioaddr, std::string dev_name)
{
gig_sioaddr = sioaddr;
name = dev_name;
}
GigabyteSuperIORGBController::~GigabyteSuperIORGBController()
{
}
std::string GigabyteSuperIORGBController::GetDeviceLocation()
{
char hex[12];
snprintf(hex, sizeof(hex), "0x%X", gig_sioaddr);
return("SIO: " + std::string(hex));
}
std::string GigabyteSuperIORGBController::GetDeviceName()
{
return(name);
}
void GigabyteSuperIORGBController::ChipEntry()
{
/*--------------------------------*\
| Chip Entry Command |
\*_-------------------------------*/
superio_enter(gig_sioaddr);
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_CHIPENTRY_REGISTER_1, GIGABYTE_SUPERIO_CHIPENTRY_VALUE_1);
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_CHIPENTRY_REGISTER_2, GIGABYTE_SUPERIO_CHIPENTRY_VALUE_2);
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_CHIPENTRY_REGISTER_2, GIGABYTE_SUPERIO_CHIPENTRY_VALUE_2);
/*--------------------------------*\
| Chip Select Command |
\*_-------------------------------*/
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_CHIPSELECT_REGISTER_1, GIGABYTE_SUPERIO_CHIPSELECT_VALUE_1);
}
void GigabyteSuperIORGBController::ChipExit()
{
/*-----------------------------------------------------------------------------------*\
| Chip Exit Command |
| Per https://pdf1.alldatasheetde.com/datasheet-pdf/download/1132513/ITE/IT8712F.html |
\*_----------------------------------------------------------------------------------*/
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_CHIPEXIT_REGISTER_1, GIGABYTE_SUPERIO_CHIPEXIT_VALUE_1);
}
void GigabyteSuperIORGBController::SetColor(unsigned int red, unsigned int green, unsigned int blue)
{
/*--------------------------------*\
| Chip Entry Command |
\*_-------------------------------*/
ChipEntry();
/*--------------------------------*\
| Set Colors |
\*_-------------------------------*/
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_RED_REGISTER_1, red);
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_GREEN_REGISTER_1, green);
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_BLUE_REGISTER_1, blue);
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_RED_REGISTER_2, red);
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_GREEN_REGISTER_2, green);
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_BLUE_REGISTER_2, blue);
/*--------------------------------*\
| Chip Exit Command |
\*_-------------------------------*/
ChipExit();
}
void GigabyteSuperIORGBController::SetMode(int new_mode)
{
if(new_mode>=GIGABYTE_MODE1_STATIC && new_mode<=GIGABYTE_MODE1_FLASHING)
{
ChipEntry();
}
/*-----------------------------------------------------*\
| Write the colors to the color sequence registers |
\*-----------------------------------------------------*/
switch (new_mode)
{
case GIGABYTE_MODE1_STATIC:
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_STATIC_REGISTER_1, GIGABYTE_SUPERIO_STATIC_VALUE_1);
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_STATIC_REGISTER_2, GIGABYTE_SUPERIO_STATIC_VALUE_2);
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_STATIC_REGISTER_3, GIGABYTE_SUPERIO_STATIC_VALUE_3);
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_STATIC_REGISTER_4, GIGABYTE_SUPERIO_STATIC_VALUE_4);
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_STATIC_REGISTER_5, GIGABYTE_SUPERIO_STATIC_VALUE_5);
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_STATIC_REGISTER_6, GIGABYTE_SUPERIO_STATIC_VALUE_6);
break;
case GIGABYTE_MODE1_RAINBOW:
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_RAINBOW_REGISTER_1, GIGABYTE_SUPERIO_RAINBOW_VALUE_1);
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_RAINBOW_REGISTER_2, GIGABYTE_SUPERIO_RAINBOW_VALUE_2);
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_RAINBOW_REGISTER_3, GIGABYTE_SUPERIO_RAINBOW_VALUE_3);
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_RAINBOW_REGISTER_4, GIGABYTE_SUPERIO_RAINBOW_VALUE_4);
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_RAINBOW_REGISTER_5, GIGABYTE_SUPERIO_RAINBOW_VALUE_5);
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_RAINBOW_REGISTER_6, GIGABYTE_SUPERIO_RAINBOW_VALUE_6);
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_RAINBOW_REGISTER_7, GIGABYTE_SUPERIO_RAINBOW_VALUE_7);
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_RAINBOW_REGISTER_8, GIGABYTE_SUPERIO_RAINBOW_VALUE_8);
break;
case GIGABYTE_MODE1_BREATHING:
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_BREATHING_REGISTER_1, GIGABYTE_SUPERIO_BREATHING_VALUE_1);
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_BREATHING_REGISTER_2, GIGABYTE_SUPERIO_BREATHING_VALUE_2);
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_BREATHING_REGISTER_3, GIGABYTE_SUPERIO_BREATHING_VALUE_3);
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_BREATHING_REGISTER_4, GIGABYTE_SUPERIO_BREATHING_VALUE_4);
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_BREATHING_REGISTER_5, GIGABYTE_SUPERIO_BREATHING_VALUE_5);
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_BREATHING_REGISTER_6, GIGABYTE_SUPERIO_BREATHING_VALUE_6);
break;
case GIGABYTE_MODE1_FLASHING:
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_FLASHING_REGISTER_1, GIGABYTE_SUPERIO_FLASHING_VALUE_1);
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_FLASHING_REGISTER_2, GIGABYTE_SUPERIO_FLASHING_VALUE_2);
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_FLASHING_REGISTER_3, GIGABYTE_SUPERIO_FLASHING_VALUE_3);
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_FLASHING_REGISTER_4, GIGABYTE_SUPERIO_FLASHING_VALUE_4);
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_FLASHING_REGISTER_5, GIGABYTE_SUPERIO_FLASHING_VALUE_5);
superio_outb(gig_sioaddr, GIGABYTE_SUPERIO_FLASHING_REGISTER_6, GIGABYTE_SUPERIO_FLASHING_VALUE_6);
break;
}
if(new_mode>=GIGABYTE_MODE1_STATIC && new_mode<=GIGABYTE_MODE1_FLASHING)
{
ChipExit();
}
}
Controllers/GigabyteSuperIORGBController/GigabyteSuperIORGBController.h
+150
View File
@@ -0,0 +1,150 @@
/*---------------------------------------------------------*\
| GigabyteSuperIORGBController.h |
| |
| Driver for Gigabyte Aorus Super IO motherboard |
| |
| Ryan Frankcombe (422gRdHuX5uk) 11 Sep 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <string>
enum
{
/*--------------------------------*\
| Chip Entry Registers and Values |
\*_-------------------------------*/
GIGABYTE_SUPERIO_CHIPENTRY_REGISTER_1 = 0x01,
GIGABYTE_SUPERIO_CHIPENTRY_REGISTER_2 = 0x55,
GIGABYTE_SUPERIO_CHIPENTRY_VALUE_1 = 0x00,
GIGABYTE_SUPERIO_CHIPENTRY_VALUE_2 = 0x00,
/*--------------------------------*\
| Chip Select Registers and Values |
\*_-------------------------------*/
GIGABYTE_SUPERIO_CHIPSELECT_REGISTER_1 = 0x07,
GIGABYTE_SUPERIO_CHIPSELECT_VALUE_1 = 0x00,
/*--------------------------------*\
| Chip Exit Registers and Values |
\*_-------------------------------*/
GIGABYTE_SUPERIO_CHIPEXIT_REGISTER_1 = 0x02,
GIGABYTE_SUPERIO_CHIPEXIT_VALUE_1 = 0x01,
};
enum
{
/*--------------------------------*\
| Chip Color Registers |
\*_-------------------------------*/
GIGABYTE_SUPERIO_RED_REGISTER_1 = 0xB3,
GIGABYTE_SUPERIO_RED_REGISTER_2 = 0xC3,
GIGABYTE_SUPERIO_GREEN_REGISTER_1 = 0xB4,
GIGABYTE_SUPERIO_GREEN_REGISTER_2 = 0xC4,
GIGABYTE_SUPERIO_BLUE_REGISTER_1 = 0xB5,
GIGABYTE_SUPERIO_BLUE_REGISTER_2 = 0xC5,
};
enum
{
/*--------------------------------*\
| Chip Modes |
\*_-------------------------------*/
GIGABYTE_MODE1_STATIC = 0x00, /* Mode 1 static effect */
GIGABYTE_MODE1_RAINBOW = 0x01, /* Mode 1 rainbow effect */
GIGABYTE_MODE1_BREATHING = 0x02, /* Mode 1 breathing effect */
GIGABYTE_MODE1_FLASHING = 0x03, /* Mode 1 flashing effect */
/*--------------------------------*\
| Chip Static Mode Registers |
\*_-------------------------------*/
GIGABYTE_SUPERIO_STATIC_REGISTER_1 = 0xB0,
GIGABYTE_SUPERIO_STATIC_REGISTER_2 = 0xB1,
GIGABYTE_SUPERIO_STATIC_REGISTER_3 = 0xB2,
GIGABYTE_SUPERIO_STATIC_REGISTER_4 = 0xC0,
GIGABYTE_SUPERIO_STATIC_REGISTER_5 = 0xC1,
GIGABYTE_SUPERIO_STATIC_REGISTER_6 = 0xC2,
GIGABYTE_SUPERIO_STATIC_VALUE_1 = 0x0F,
GIGABYTE_SUPERIO_STATIC_VALUE_2 = 0x00,
GIGABYTE_SUPERIO_STATIC_VALUE_3 = 0x20,
GIGABYTE_SUPERIO_STATIC_VALUE_4 = 0x0F,
GIGABYTE_SUPERIO_STATIC_VALUE_5 = 0x00,
GIGABYTE_SUPERIO_STATIC_VALUE_6 = 0x10,
/*--------------------------------*\
| Chip Rainbow Mode Registers |
\*_-------------------------------*/
GIGABYTE_SUPERIO_RAINBOW_REGISTER_1 = 0xB0,
GIGABYTE_SUPERIO_RAINBOW_REGISTER_2 = 0xB1,
GIGABYTE_SUPERIO_RAINBOW_REGISTER_3 = 0xB2,
GIGABYTE_SUPERIO_RAINBOW_REGISTER_4 = 0xB0,
GIGABYTE_SUPERIO_RAINBOW_REGISTER_5 = 0xC0,
GIGABYTE_SUPERIO_RAINBOW_REGISTER_6 = 0xC1,
GIGABYTE_SUPERIO_RAINBOW_REGISTER_7 = 0xC2,
GIGABYTE_SUPERIO_RAINBOW_REGISTER_8 = 0xC0,
GIGABYTE_SUPERIO_RAINBOW_VALUE_1 = 0x00,
GIGABYTE_SUPERIO_RAINBOW_VALUE_2 = 0x00,
GIGABYTE_SUPERIO_RAINBOW_VALUE_3 = 0xA0,
GIGABYTE_SUPERIO_RAINBOW_VALUE_4 = 0x7F,
GIGABYTE_SUPERIO_RAINBOW_VALUE_5 = 0x00,
GIGABYTE_SUPERIO_RAINBOW_VALUE_6 = 0x00,
GIGABYTE_SUPERIO_RAINBOW_VALUE_7 = 0x90,
GIGABYTE_SUPERIO_RAINBOW_VALUE_8 = 0x7F,
/*--------------------------------*\
| Chip Breathing Mode Registers |
\*_-------------------------------*/
GIGABYTE_SUPERIO_BREATHING_REGISTER_1 = 0xB0,
GIGABYTE_SUPERIO_BREATHING_REGISTER_2 = 0xB1,
GIGABYTE_SUPERIO_BREATHING_REGISTER_3 = 0xB2,
GIGABYTE_SUPERIO_BREATHING_REGISTER_4 = 0xC0,
GIGABYTE_SUPERIO_BREATHING_REGISTER_5 = 0xC1,
GIGABYTE_SUPERIO_BREATHING_REGISTER_6 = 0xC2,
GIGABYTE_SUPERIO_BREATHING_VALUE_1 = 0x8F,
GIGABYTE_SUPERIO_BREATHING_VALUE_2 = 0x00,
GIGABYTE_SUPERIO_BREATHING_VALUE_3 = 0x20,
GIGABYTE_SUPERIO_BREATHING_VALUE_4 = 0x8F,
GIGABYTE_SUPERIO_BREATHING_VALUE_5 = 0x00,
GIGABYTE_SUPERIO_BREATHING_VALUE_6 = 0x10,
/*--------------------------------*\
| Chip Flashing Mode Registers |
\*_-------------------------------*/
GIGABYTE_SUPERIO_FLASHING_REGISTER_1 = 0xB0,
GIGABYTE_SUPERIO_FLASHING_REGISTER_2 = 0xB1,
GIGABYTE_SUPERIO_FLASHING_REGISTER_3 = 0xB2,
GIGABYTE_SUPERIO_FLASHING_REGISTER_4 = 0xC0,
GIGABYTE_SUPERIO_FLASHING_REGISTER_5 = 0xC1,
GIGABYTE_SUPERIO_FLASHING_REGISTER_6 = 0xC2,
GIGABYTE_SUPERIO_FLASHING_VALUE_1 = 0x0F,
GIGABYTE_SUPERIO_FLASHING_VALUE_2 = 0x08,
GIGABYTE_SUPERIO_FLASHING_VALUE_3 = 0x20,
GIGABYTE_SUPERIO_FLASHING_VALUE_4 = 0x0F,
GIGABYTE_SUPERIO_FLASHING_VALUE_5 = 0x08,
GIGABYTE_SUPERIO_FLASHING_VALUE_6 = 0x10,
};
class GigabyteSuperIORGBController
{
public:
GigabyteSuperIORGBController(int sioaddr, std::string dev_name);
~GigabyteSuperIORGBController();
std::string GetDeviceLocation();
std::string GetDeviceName();
unsigned int GetMode();
void SetMode(int new_mode);
void SetColor(unsigned int red, unsigned int green, unsigned int blue);
void ChipEntry();
void ChipExit();
private:
int gig_sioaddr;
std::string name;
};
Controllers/GigabyteSuperIORGBController/GigabyteSuperIORGBControllerDetect.cpp
+70
View File
@@ -0,0 +1,70 @@
/*---------------------------------------------------------*\
| GigabyteSuperIORGBControllerDetect.cpp |
| |
| Detector for Gigabyte Aorus Super IO motherboard |
| |
| Ryan Frankcombe (422gRdHuX5uk) 11 Sep 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "Detector.h"
#include "GigabyteSuperIORGBController.h"
#include "RGBController_GigabyteSuperIORGB.h"
#include "super_io.h"
#include "dmiinfo.h"
#define NUM_COMPATIBLE_DEVICES (sizeof(compatible_devices) / sizeof(compatible_devices[0]))
typedef struct
{
const char* name;
} gig_device;
static gig_device compatible_devices[] =
{
{"X570 UD"}
};
void DetectGigabyteSuperIORGBControllers()
{
int sio_addrs[2] = {0x2E, 0x4E};
DMIInfo board;
std::string board_dmi = board.getMainboard();
std::string manufacturer = board.getManufacturer();
if(manufacturer != "Gigabyte Technology Co., Ltd.")
{
return;
}
for(int sioaddr_idx = 0; sioaddr_idx < 2; sioaddr_idx++)
{
int sioaddr = sio_addrs[sioaddr_idx];
superio_enter(sioaddr);
int val = (superio_inb(sioaddr, SIO_REG_DEVID) << 8) | superio_inb(sioaddr, SIO_REG_DEVID + 1);
switch(val & SIO_ID_MASK)
{
case SIO_ITE8688_ID:
for(unsigned int i = 0; i < NUM_COMPATIBLE_DEVICES; i++)
{
if(board_dmi.find(std::string(compatible_devices[i].name)) != std::string::npos)
{
GigabyteSuperIORGBController* controller = new GigabyteSuperIORGBController(sioaddr, "Gigabyte " + board_dmi);
RGBController_GigabyteSuperIORGB* rgb_controller = new RGBController_GigabyteSuperIORGB(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
break;
}
}
break;
}
}
} /* DetectGigabyteSuperIORGBControllers() */
REGISTER_DETECTOR("Gigabyte RGB", DetectGigabyteSuperIORGBControllers);
Controllers/GigabyteSuperIORGBController/RGBController_GigabyteSuperIORGB.cpp
+187
View File
@@ -0,0 +1,187 @@
/*---------------------------------------------------------*\
| RGBController_GigabyteSuperIORGB.cpp |
| |
| RGBController for Gigabyte Aorus Super IO motherboard |
| |
| Ryan Frankcombe (422gRdHuX5uk) 11 Sep 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_GigabyteSuperIORGB.h"
/**------------------------------------------------------------------*\
@name Gigabyte SuperIO RGB
@category Motherboard
@type SuperIO
@save :x:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectGigabyteSuperIORGBControllers
@comment
Testing was done on an ITE8688 Chipset, and adds the support for motherboards that can only be controlled with Gigabyte’s “Ambient Led” NOT EITHER RGB Fusion 1.0/2.0.
You should first check to confirm that you DO NOT HAVE EITHER A USB OR SMBUS controllable chipset, use the following powershell command to confirm if you have a USB device:
```powershell
gwmi Win32_USBControllerDevice |%{[wmi]($_.Dependent)} | Sort Manufacturer,Description,DeviceID | Ft -GroupBy Manufacturer Description,Service,DeviceID
```
If you see anything with a VID of 048D or 8297, DO NOT PROCEED, the software is likely supportable by OpenRGB's Fusion2 USB controller.
After that check output on the SMBus: Using the OpenRGB I2C Sniffer to confirm that no data is output on either bus while changing colors in “Ambient LED”, if either bus outputs data, DO NOT PROCEED, the software is likely supportable in Gigabyte RGB Fusion.
The following chipsets are likely supported:
| Chipset ID |
| :---: |
| ITE8620E |
| ITE8626 |
| ITE8686E |
| ITE8688 |
| ITE8689 |
| ITE8728F |
| ITE8790F |
| ITE8791E |
To confirm your chipset, you can open CPU-Z, the MCU chipset model is found under Mainboard like below:
To confirm that your RGB is compatible with this Controller in OpenRGB, you will need to add the motherboard DMI Model name, which is the output of the following powershell command:
```powershell
wmic baseboard get product
```
To the struct array that is found in GigabyteSuperIORGBControllerDetect.cpp, like below
```c++
gig_device compatible_devices[] =
{
{"X570 UD"},
{"EXAMPLEBASEBOARDPRODUCTNAME"}
};
```
If your chipset is also NOT an ITE8688, you will also need to add the chipset, to get this is a bit harder, for myself I added a breakpoint, on this line, in GigabyteSuperIORGBControllerDetect.cpp:
```c++
switch (val & SIO_ID_MASK)
```
For an ITE8688, the value was 0x8688 in Hexidecimal, it is likely the case with other models as well that the code matches the MCU model.
To add this chipset you will need to first add it to the SuperIO definitions file, which is named super_io.h like below
```c++
#define SIO_ITE8688_ID 0x8688 // Device ID for ITE8688 (8688)
#define SIO_NEWCHIPSETMODEL_ID 0xFOUNDHEXIDECIMALVALUE // Device ID for NEWCHIPSETMODEL (FOUNDHEXIDECIMALVALUE)
```
And lastly you will need to add the chip to the
GigabyteSuperIORGBControllerDetect.cpp like below:
```c++
switch (val & SIO_ID_MASK)
{
case SIO_ITE8688_ID:
case SIO_NEWCHIPSETMODEL_ID:
```
\*-------------------------------------------------------------------*/
RGBController_GigabyteSuperIORGB::RGBController_GigabyteSuperIORGB(GigabyteSuperIORGBController* controller_ptr)
{
controller = controller_ptr;
name = controller->GetDeviceName();
vendor = "Gigabyte";
type = DEVICE_TYPE_MOTHERBOARD;
description = "Gigabyte SuperIO RGB Device";
location = controller->GetDeviceLocation();
mode Direct;
Direct.name = "Direct";
Direct.value = 0;
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 = GIGABYTE_MODE1_STATIC;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Static.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Static);
mode Rainbow;
Rainbow.name = "Rainbow";
Rainbow.value = GIGABYTE_MODE1_RAINBOW;
Rainbow.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Rainbow.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Rainbow);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = GIGABYTE_MODE1_BREATHING;
Breathing.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Breathing.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Breathing);
mode Flashing;
Flashing.name = "Flashing";
Flashing.value = GIGABYTE_MODE1_FLASHING;
Flashing.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Flashing.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Flashing);
SetupZones();
}
RGBController_GigabyteSuperIORGB::~RGBController_GigabyteSuperIORGB()
{
delete controller;
}
void RGBController_GigabyteSuperIORGB::SetupZones()
{
zone gig_zone;
gig_zone.name = "Gigabyte Zone";
gig_zone.type = ZONE_TYPE_SINGLE;
gig_zone.leds_min = 1;
gig_zone.leds_max = 1;
gig_zone.leds_count = 1;
gig_zone.matrix_map = NULL;
zones.push_back(gig_zone);
led gig_led;
gig_led.name = "LED_C1";
leds.push_back(gig_led);
SetupColors();
}
void RGBController_GigabyteSuperIORGB::ResizeZone(int /*zone*/, int /*new_size*/)
{
}
void RGBController_GigabyteSuperIORGB::DeviceUpdateLEDs()
{
RGBColor color = colors[0];
unsigned char red = RGBGetRValue(color);
unsigned char grn = RGBGetGValue(color);
unsigned char blu = RGBGetBValue(color);
controller->SetColor(red, grn, blu);
}
void RGBController_GigabyteSuperIORGB::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_GigabyteSuperIORGB::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_GigabyteSuperIORGB::DeviceUpdateMode()
{
controller->SetMode(modes[active_mode].value);
}
Controllers/GigabyteSuperIORGBController/RGBController_GigabyteSuperIORGB.h
+34
View File
@@ -0,0 +1,34 @@
/*---------------------------------------------------------*\
| RGBController_GigabyteSuperIORGB.h |
| |
| RGBController for Gigabyte Aorus Super IO motherboard |
| |
| Ryan Frankcombe (422gRdHuX5uk) 11 Sep 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "GigabyteSuperIORGBController.h"
class RGBController_GigabyteSuperIORGB : public RGBController
{
public:
RGBController_GigabyteSuperIORGB(GigabyteSuperIORGBController* controller_ptr);
~RGBController_GigabyteSuperIORGB();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
GigabyteSuperIORGBController* controller;
};