jalr/OpenRGB
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Initial commit for Gigabyte Super-IO motherboard controller (X570-UD)

Browse source
This commit is contained in:
Ryan Frankcombe 2022-09-15 22:40:13 +00:00 • committed by Adam Honse
parent e855e19a09
commit 777d292c7c
7 changed files with 493 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

120
Controllers/GigabyteSuperIORGBController/GigabyteSuperIORGBController.cpp Normal file
View file

@ -0,0 +1,120 @@
/*------------------------------------------*\
| GigabyteSuperIORGBController.cpp |
| |
| Ryan Frankcombe (422gRdHuX5uk) 2/11/2020 |
\*------------------------------------------*/
#include "GigabyteSuperIORGBController.h"
#include "super_io.h"
GigabyteSuperIORGBController::GigabyteSuperIORGBController(int sioaddr)
{
gig_sioaddr = sioaddr;
}
GigabyteSuperIORGBController::~GigabyteSuperIORGBController()
{
}
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();
}
}

146
Controllers/GigabyteSuperIORGBController/GigabyteSuperIORGBController.h Normal file
View file

@ -0,0 +1,146 @@
/*-----------------------------------------------*\
| GigabyteSuperIORGBController.h |
| |
| Definitions and types for Gigabyte SuperIO RGB |
| lighting controller |
| |
| Ryan Frankcombe (422gRdHuX5uk) 9/11/2022 |
\*-----------------------------------------------*/
#include <string>
#pragma once
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);
~GigabyteSuperIORGBController();
std::string GetDeviceName();
std::string GetDeviceLocation();
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;
};

71
Controllers/GigabyteSuperIORGBController/GigabyteSuperIORGBControllerDetect.cpp Normal file
View file

@ -0,0 +1,71 @@
/*-----------------------------------------------*\
| RGBController_GigabyteSuperIORGB.cpp |
| |
| Detect Gigabyte RGB compatible Super-IO chips |
| |
| Ryan Frankcombe (422gRdHuX5uk ) 9/11/2022 |
\*-----------------------------------------------*/
#include "Detector.h"
#include "GigabyteSuperIORGBController.h"
#include "RGBController.h"
#include "RGBController_GigabyteSuperIORGB.h"
#include "super_io.h"
#include "dependencies/dmiinfo.h"
#include <iostream>
#include <vector>
#include <stdio.h>
#include <stdlib.h>
#define NUM_COMPATIBLE_DEVICES (sizeof(compatible_devices) / sizeof(compatible_devices[0]))
typedef struct
{
const char* name;
} gig_device;
gig_device compatible_devices[] =
{
{"X570 UD"}
};
void DetectGigabyteSuperIORGBControllers(std::vector<RGBController*> &rgb_controllers)
{
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_ITE688_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);
RGBController_GigabyteSuperIORGB* rgb_controller = new RGBController_GigabyteSuperIORGB(controller);
rgb_controller->name = "Gigabyte " + board_dmi;
rgb_controllers.push_back(rgb_controller);
break;
}
}
break;
}
}
} /* DetectGigabyteSuperIORGBControllers() */
REGISTER_DETECTOR("Gigabyte RGB", DetectGigabyteSuperIORGBControllers);

120
Controllers/GigabyteSuperIORGBController/RGBController_GigabyteSuperIORGB.cpp Normal file
View file

@ -0,0 +1,120 @@
/*-------------------------------------------*\
| RGBController_GigabyteSuperIORGB.cpp |
| |
| Generic RGB Interface for Gigabyte RGB |
| |
| Ryan Frankcombe (422gRdHuX5uk ) 9/11/2022 |
\*-------------------------------------------*/
#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
\*-------------------------------------------------------------------*/
RGBController_GigabyteSuperIORGB::RGBController_GigabyteSuperIORGB(GigabyteSuperIORGBController* controller_ptr)
{
controller = controller_ptr;
name = "Gigabyte SuperIO Compatible Motherboard";
vendor = "Gigabyte";
type = DEVICE_TYPE_MOTHERBOARD;
description = "Gigabyte SuperIO RGB Device";
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;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Static);
mode Rainbow;
Rainbow.name = "Rainbow";
Rainbow.value = GIGABYTE_MODE1_RAINBOW;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Rainbow);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = GIGABYTE_MODE1_BREATHING;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Breathing);
mode Flashing;
Flashing.name = "Flashing";
Flashing.value = GIGABYTE_MODE1_FLASHING;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.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);
}

30
Controllers/GigabyteSuperIORGBController/RGBController_GigabyteSuperIORGB.h Normal file
View file

@ -0,0 +1,30 @@
/*------------------------------------------*\
| RGBController_GigabyteSuperIORGB.h |
| |
| Generic RGB Interface for Gigabyte RGB |
| |
| Ryan Frankcombe (422gRdHuX5uk) 9/11/2022 |
\*------------------------------------------*/
#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;
};

5
OpenRGB.pro
View file

@ -121,6 +121,7 @@ INCLUDEPATH +=
Controllers/GigabyteRGBFusionController/ \
Controllers/GigabyteRGBFusionGPUController/ \
Controllers/GigabyteRGBFusion2GPUController/ \
Controllers/GigabyteSuperIORGBController/ \
Controllers/HoltekController/ \
Controllers/HPOmen30LController/ \
Controllers/HyperXDRAMController/ \
@ -402,6 +403,7 @@ HEADERS +=
Controllers/GigabyteRGBFusionGPUController/RGBController_GigabyteRGBFusionGPU.h \
Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUController.h \
Controllers/GigabyteRGBFusion2GPUController/RGBController_GigabyteRGBFusion2GPU.h \
Controllers/GigabyteSuperIORGBController/GigabyteSuperIORGBController.h \
Controllers/HoltekController/HoltekA070Controller.h \
Controllers/HoltekController/HoltekA1FAController.h \
Controllers/HoltekController/RGBController_HoltekA070.h \
@ -928,6 +930,9 @@ SOURCES +=
Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUController.cpp \
Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUControllerDetect.cpp \
Controllers/GigabyteRGBFusion2GPUController/RGBController_GigabyteRGBFusion2GPU.cpp \
Controllers/GigabyteSuperIORGBController/GigabyteSuperIORGBController.cpp \
Controllers/GigabyteSuperIORGBController/GigabyteSuperIORGBControllerDetect.cpp \
Controllers/GigabyteSuperIORGBController/RGBController_GigabyteSuperIORGB.cpp \
Controllers/HoltekController/HoltekA070Controller.cpp \
Controllers/HoltekController/HoltekA1FAController.cpp \
Controllers/HoltekController/HoltekControllerDetect.cpp \

1
super_io/super_io.h
View file

@ -19,6 +19,7 @@
#define SIO_NCT6796_ID 0xd420 /* Device ID for NCT6796D (D421) */
#define SIO_NCT6797_ID 0xd450 /* Device ID for NCT6797D (D450) */
#define SIO_NCT6798_ID 0xd428 /* Device ID for NCT6798D (D428) */
#define SIO_ITE688_ID 0x8688 /* Device ID for ITE8688 (8688) */
#define SIO_REG_LOGDEV 0x07 /* Logical Device Register */
#define SIO_REG_DEVID 0x20 /* Device ID Register */
#define SIO_REG_SMBA 0x62 /* SMBus Base Address Register */