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

Store name in ENESMBusController to avoid setting it in detector

Browse source
This commit is contained in:
Adam Honse 2025-08-15 22:49:21 -05:00
parent 5190274004
commit bf24ab3d53
7 changed files with 160 additions and 96 deletions
Download patch file Download diff file Expand all files Collapse all files

195
Controllers/ENESMBusController/ENESMBusController.cpp
View file

@ -29,26 +29,30 @@ static const char* ene_channels[] = /* ENE channel strings
"Unknown", "Unknown",
}; };
ENESMBusController::ENESMBusController(ENESMBusInterface* interface, ene_dev_id dev) ENESMBusController::ENESMBusController(ENESMBusInterface* interface, ene_dev_id dev, std::string dev_name, device_type dev_type)
{ {
this->interface = interface; this->interface = interface;
this->dev = dev; this->dev = dev;
this->name = dev_name;
this->type = dev_type;
supports_mode_14 = false; supports_mode_14 = false;
if(interface->GetInterfaceType() != ENE_INTERFACE_TYPE_ROG_ARION) if(interface->GetInterfaceType() != ENE_INTERFACE_TYPE_ROG_ARION)
{ {
UpdateDeviceName(); UpdateDeviceName();
// Read the device configuration table /*-------------------------------------------------*\
for (int i = 0; i < 64; i++) | Read the device configuration table |
\*-------------------------------------------------*/
for(int i = 0; i < 64; i++)
{ {
config_table[i] = ENERegisterRead(ENE_REG_CONFIG_TABLE + i); config_table[i] = ENERegisterRead(ENE_REG_CONFIG_TABLE + i);
} }
/*-----------------------------------------------------------------*\ /*-------------------------------------------------*\
| If this is running with TRACE or higher loglevel then | | If this is running with TRACE or higher loglevel |
| dump the entire Feature list to log | | then dump the entire Feature list to log |
\*-----------------------------------------------------------------*/ \*-------------------------------------------------*/
if(LogManager::get()->getLoglevel() >= LL_TRACE) if(LogManager::get()->getLoglevel() >= LL_TRACE)
{ {
LOG_TRACE("[ENE SMBus] ENE config table for 0x%02X:", dev); LOG_TRACE("[ENE SMBus] ENE config table for 0x%02X:", dev);
@ -79,35 +83,47 @@ ENESMBusController::ENESMBusController(ENESMBusInterface* interface, ene_dev_id
memset(config_table, 0, sizeof(config_table)); memset(config_table, 0, sizeof(config_table));
config_table[ENE_CONFIG_LED_COUNT] = 4; config_table[ENE_CONFIG_LED_COUNT] = 4;
config_table[0x03] = 4; config_table[0x03] = 4;
strcpy(device_name, "ROG STRIX ARION"); strcpy(device_version, "ROG STRIX ARION");
} }
// Read LED count from configuration table /*-----------------------------------------------------*\
| Read LED count from configuration table |
\*-----------------------------------------------------*/
led_count = config_table[ENE_CONFIG_LED_COUNT]; led_count = config_table[ENE_CONFIG_LED_COUNT];
// LED-0116 - First generation motherboard controller /*-----------------------------------------------------*\
if (strcmp(device_name, "LED-0116") == 0) | LED-0116 - First generation motherboard controller |
\*-----------------------------------------------------*/
if(strcmp(device_version, "LED-0116") == 0)
{ {
direct_reg = ENE_REG_COLORS_DIRECT; direct_reg = ENE_REG_COLORS_DIRECT;
effect_reg = ENE_REG_COLORS_EFFECT; effect_reg = ENE_REG_COLORS_EFFECT;
channel_cfg = ENE_CONFIG_CHANNEL_V1; channel_cfg = ENE_CONFIG_CHANNEL_V1;
} }
// DIMM_LED-0102 - First generation DRAM controller (Trident Z RGB) /*-----------------------------------------------------*\
else if (strcmp(device_name, "DIMM_LED-0102") == 0) | DIMM_LED-0102 - First generation DRAM controller |
| (Trident Z RGB) |
\*-----------------------------------------------------*/
else if(strcmp(device_version, "DIMM_LED-0102") == 0)
{ {
direct_reg = ENE_REG_COLORS_DIRECT; direct_reg = ENE_REG_COLORS_DIRECT;
effect_reg = ENE_REG_COLORS_EFFECT; effect_reg = ENE_REG_COLORS_EFFECT;
channel_cfg = ENE_CONFIG_CHANNEL_V1; channel_cfg = ENE_CONFIG_CHANNEL_V1;
} }
// AUDA0-E6K5-0101 - Second generation DRAM controller (Geil Super Luce) /*-----------------------------------------------------*\
else if (strcmp(device_name, "AUDA0-E6K5-0101") == 0) | AUDA0-E6K5-0101 - Second generation DRAM controller |
| (Geil Super Luce) |
\*-----------------------------------------------------*/
else if(strcmp(device_version, "AUDA0-E6K5-0101") == 0)
{ {
direct_reg = ENE_REG_COLORS_DIRECT_V2; direct_reg = ENE_REG_COLORS_DIRECT_V2;
effect_reg = ENE_REG_COLORS_EFFECT_V2; effect_reg = ENE_REG_COLORS_EFFECT_V2;
channel_cfg = ENE_CONFIG_CHANNEL_V1; channel_cfg = ENE_CONFIG_CHANNEL_V1;
// Check for Mode 14 support, only known to exist on modules where the /*-------------------------------------------------*\
// DRAM 3 zone ID exists | Check for Mode 14 support, only known to exist on |
| modules where the DRAM 3 zone ID exists |
\*-------------------------------------------------*/
for(std::size_t cfg_zone_idx = 0; cfg_zone_idx < ENE_NUM_ZONES; cfg_zone_idx++) for(std::size_t cfg_zone_idx = 0; cfg_zone_idx < ENE_NUM_ZONES; cfg_zone_idx++)
{ {
if(config_table[channel_cfg + cfg_zone_idx] == (unsigned char)ENE_LED_CHANNEL_DRAM_3) if(config_table[channel_cfg + cfg_zone_idx] == (unsigned char)ENE_LED_CHANNEL_DRAM_3)
@ -117,109 +133,154 @@ ENESMBusController::ENESMBusController(ENESMBusInterface* interface, ene_dev_id
} }
} }
} }
// AUMA0-E6K5-0106 - Second generation motherboard controller /*-----------------------------------------------------*\
else if (strcmp(device_name, "AUMA0-E6K5-0106") == 0) | AUMA0-E6K5-0106 - Second generation motherboard |
| controller |
\*-----------------------------------------------------*/
else if(strcmp(device_version, "AUMA0-E6K5-0106") == 0)
{ {
direct_reg = ENE_REG_COLORS_DIRECT_V2; direct_reg = ENE_REG_COLORS_DIRECT_V2;
effect_reg = ENE_REG_COLORS_EFFECT_V2; effect_reg = ENE_REG_COLORS_EFFECT_V2;
channel_cfg = ENE_CONFIG_CHANNEL_V2; channel_cfg = ENE_CONFIG_CHANNEL_V2;
} }
// AUMA0-E6K5-0105 - Second generation motherboard controller /*-----------------------------------------------------*\
else if (strcmp(device_name, "AUMA0-E6K5-0105") == 0) | AUMA0-E6K5-0105 - Second generation motherboard |
| controller |
\*-----------------------------------------------------*/
else if(strcmp(device_version, "AUMA0-E6K5-0105") == 0)
{ {
direct_reg = ENE_REG_COLORS_DIRECT_V2; direct_reg = ENE_REG_COLORS_DIRECT_V2;
effect_reg = ENE_REG_COLORS_EFFECT_V2; effect_reg = ENE_REG_COLORS_EFFECT_V2;
channel_cfg = ENE_CONFIG_CHANNEL_V2; channel_cfg = ENE_CONFIG_CHANNEL_V2;
} }
// AUMA0-E6K5-0104 - Second generation motherboard controller /*-----------------------------------------------------*\
else if (strcmp(device_name, "AUMA0-E6K5-0104") == 0) | AUMA0-E6K5-0104 - Second generation motherboard |
| controller |
\*-----------------------------------------------------*/
else if(strcmp(device_version, "AUMA0-E6K5-0104") == 0)
{ {
direct_reg = ENE_REG_COLORS_DIRECT_V2; direct_reg = ENE_REG_COLORS_DIRECT_V2;
effect_reg = ENE_REG_COLORS_EFFECT_V2; effect_reg = ENE_REG_COLORS_EFFECT_V2;
channel_cfg = ENE_CONFIG_CHANNEL_V2; channel_cfg = ENE_CONFIG_CHANNEL_V2;
} }
// AUMA0-E8K4-0101 - First generation motherboard controller /*-----------------------------------------------------*\
else if (strcmp(device_name, "AUMA0-E8K4-0101") == 0) | AUMA0-E8K4-0101 - First generation motherboard |
| controller |
\*-----------------------------------------------------*/
else if(strcmp(device_version, "AUMA0-E8K4-0101") == 0)
{ {
direct_reg = ENE_REG_COLORS_DIRECT; direct_reg = ENE_REG_COLORS_DIRECT;
effect_reg = ENE_REG_COLORS_EFFECT; effect_reg = ENE_REG_COLORS_EFFECT;
channel_cfg = ENE_CONFIG_CHANNEL_V1; channel_cfg = ENE_CONFIG_CHANNEL_V1;
} }
// AUMA0-E6K5-0107 - Second generation GPU controller /*-----------------------------------------------------*\
else if (strcmp(device_name, "AUMA0-E6K5-0107") == 0) | AUMA0-E6K5-0107 - Second generation GPU controller |
\*-----------------------------------------------------*/
else if(strcmp(device_version, "AUMA0-E6K5-0107") == 0)
{ {
direct_reg = ENE_REG_COLORS_DIRECT_V2; direct_reg = ENE_REG_COLORS_DIRECT_V2;
effect_reg = ENE_REG_COLORS_EFFECT_V2; effect_reg = ENE_REG_COLORS_EFFECT_V2;
channel_cfg = ENE_CONFIG_CHANNEL_V2; channel_cfg = ENE_CONFIG_CHANNEL_V2;
// Read LED count from configuration table /*-------------------------------------------------*\
| Read LED count from configuration table |
\*-------------------------------------------------*/
led_count = config_table[ENE_CONFIG_LED_COUNT_0107]; led_count = config_table[ENE_CONFIG_LED_COUNT_0107];
} }
// AUMA0-E6K5-1110 - Third generation GPU controller? /*-----------------------------------------------------*\
// found an ASUS ROG Strix 4080 OC, seems to be equal to AUMA0-E6K5-0107 | AUMA0-E6K5-1110 - Third generation GPU controller? |
else if (strcmp(device_name, "AUMA0-E6K5-1110") == 0) | found an ASUS ROG Strix 4080 OC, seems to be equal to |
| AUMA0-E6K5-0107 |
\*-----------------------------------------------------*/
else if(strcmp(device_version, "AUMA0-E6K5-1110") == 0)
{ {
direct_reg = ENE_REG_COLORS_DIRECT_V2; direct_reg = ENE_REG_COLORS_DIRECT_V2;
effect_reg = ENE_REG_COLORS_EFFECT_V2; effect_reg = ENE_REG_COLORS_EFFECT_V2;
channel_cfg = ENE_CONFIG_CHANNEL_V2; channel_cfg = ENE_CONFIG_CHANNEL_V2;
// Read LED count from configuration table /*-------------------------------------------------*\
| Read LED count from configuration table |
\*-------------------------------------------------*/
led_count = config_table[ENE_CONFIG_LED_COUNT_1110]; led_count = config_table[ENE_CONFIG_LED_COUNT_1110];
} }
// AUMA0-E6K5-1111 - Fourth generation GPU controller? /*-----------------------------------------------------*\
// found on ASUS ROG Strix 4090 OC EVA-02 Edition, seems to be equal to AUMA0-E6K5-0107 | AUMA0-E6K5-1111 - Fourth generation GPU controller? |
else if (strcmp(device_name, "AUMA0-E6K5-1111") == 0) | found on ASUS ROG Strix 4090 OC EVA-02 Edition, seems |
| to be equal to AUMA0-E6K5-0107 |
\*-----------------------------------------------------*/
else if(strcmp(device_version, "AUMA0-E6K5-1111") == 0)
{ {
direct_reg = ENE_REG_COLORS_DIRECT_V2; direct_reg = ENE_REG_COLORS_DIRECT_V2;
effect_reg = ENE_REG_COLORS_EFFECT_V2; effect_reg = ENE_REG_COLORS_EFFECT_V2;
channel_cfg = ENE_CONFIG_CHANNEL_V2; channel_cfg = ENE_CONFIG_CHANNEL_V2;
// Read LED count from configuration table /*-------------------------------------------------*\
| Read LED count from configuration table |
\*-------------------------------------------------*/
led_count = config_table[ENE_CONFIG_LED_COUNT_0107]; led_count = config_table[ENE_CONFIG_LED_COUNT_0107];
} }
// AUMA0-E6K5-1107 - Second generation GPU controller /*-----------------------------------------------------*\
// Found on ASUS TUF 4070 TI OC, seems to be equal to AUMA0-E6K5-0107 | AUMA0-E6K5-1107 - Second generation GPU controller |
else if (strcmp(device_name, "AUMA0-E6K5-1107") == 0) | Found on ASUS TUF 4070 TI OC, seems to be equal to |
| AUMA0-E6K5-0107 |
\*-----------------------------------------------------*/
else if(strcmp(device_version, "AUMA0-E6K5-1107") == 0)
{ {
direct_reg = ENE_REG_COLORS_DIRECT_V2; direct_reg = ENE_REG_COLORS_DIRECT_V2;
effect_reg = ENE_REG_COLORS_EFFECT_V2; effect_reg = ENE_REG_COLORS_EFFECT_V2;
channel_cfg = ENE_CONFIG_CHANNEL_V2; channel_cfg = ENE_CONFIG_CHANNEL_V2;
// Read LED count from configuration table /*-------------------------------------------------*\
| Read LED count from configuration table |
\*-------------------------------------------------*/
led_count = config_table[ENE_CONFIG_LED_COUNT_0107]; led_count = config_table[ENE_CONFIG_LED_COUNT_0107];
} }
// AUMA0-E6K5-0008 /*-----------------------------------------------------*\
// Found on ASUS STRIX 4070 Super OC | AUMA0-E6K5-0008 |
else if (strcmp(device_name, "AUMA0-E6K5-0008") == 0) | Found on ASUS STRIX 4070 Super OC |
\*-----------------------------------------------------*/
else if(strcmp(device_version, "AUMA0-E6K5-0008") == 0)
{ {
direct_reg = ENE_REG_COLORS_DIRECT_V2; direct_reg = ENE_REG_COLORS_DIRECT_V2;
effect_reg = ENE_REG_COLORS_EFFECT_V2; effect_reg = ENE_REG_COLORS_EFFECT_V2;
channel_cfg = ENE_CONFIG_CHANNEL_V1; channel_cfg = ENE_CONFIG_CHANNEL_V1;
// Read LED count from configuration table /*-------------------------------------------------*\
| Read LED count from configuration table |
\*-------------------------------------------------*/
led_count = config_table[ENE_CONFIG_LED_COUNT_0107]; led_count = config_table[ENE_CONFIG_LED_COUNT_0107];
} }
// AUMA0-E6K5-1113 /*-----------------------------------------------------*\
// Found on ASUS ASTRAL 5080 OC | AUMA0-E6K5-1113 |
else if (strcmp(device_name, "AUMA0-E6K5-1113") == 0) | Found on ASUS ASTRAL 5080 OC |
\*-----------------------------------------------------*/
else if(strcmp(device_version, "AUMA0-E6K5-1113") == 0)
{ {
direct_reg = ENE_REG_COLORS_DIRECT_V2; direct_reg = ENE_REG_COLORS_DIRECT_V2;
effect_reg = ENE_REG_COLORS_EFFECT_V2; effect_reg = ENE_REG_COLORS_EFFECT_V2;
channel_cfg = ENE_CONFIG_CHANNEL_V2; channel_cfg = ENE_CONFIG_CHANNEL_V2;
// Read LED count from configuration table /*-------------------------------------------------*\
| Read LED count from configuration table |
\*-------------------------------------------------*/
led_count = config_table[ENE_CONFIG_LED_COUNT_0107]; led_count = config_table[ENE_CONFIG_LED_COUNT_0107];
} }
// ROG ARION - ASUS ROG Arion external SSD enclosure /*-----------------------------------------------------*\
// This device does not support ENE read, so we fake the device name string | ROG ARION - ASUS ROG Arion external SSD enclosure |
// if the interface is ROG Arion type. It uses second generation registers. | This device does not support ENE read, so we fake the |
else if(strcmp(device_name, "ROG STRIX ARION") == 0) | device name string if the interface is ROG Arion type.|
| It uses second generation registers. |
\*-----------------------------------------------------*/
else if(strcmp(device_version, "ROG STRIX ARION") == 0)
{ {
direct_reg = ENE_REG_COLORS_DIRECT_V2; direct_reg = ENE_REG_COLORS_DIRECT_V2;
effect_reg = ENE_REG_COLORS_EFFECT_V2; effect_reg = ENE_REG_COLORS_EFFECT_V2;
channel_cfg = ENE_CONFIG_CHANNEL_V2; channel_cfg = ENE_CONFIG_CHANNEL_V2;
} }
// Assume first generation controller if string does not match /*-----------------------------------------------------*\
| Assume first generation controller if string does not |
| match |
\*-----------------------------------------------------*/
else else
{ {
direct_reg = ENE_REG_COLORS_DIRECT; direct_reg = ENE_REG_COLORS_DIRECT;
@ -233,12 +294,7 @@ ENESMBusController::~ENESMBusController()
delete interface; delete interface;
} }
std::string ENESMBusController::GetDeviceName() std::string ENESMBusController::GetLocation()
{
return(device_name);
}
std::string ENESMBusController::GetDeviceLocation()
{ {
std::string return_string = interface->GetLocation(); std::string return_string = interface->GetLocation();
@ -250,9 +306,24 @@ std::string ENESMBusController::GetDeviceLocation()
return(return_string); return(return_string);
} }
std::string ENESMBusController::GetName()
{
return(name);
}
std::string ENESMBusController::GetVersion()
{
return(device_version);
}
device_type ENESMBusController::GetType()
{
return(type);
}
const char * ENESMBusController::GetChannelName(unsigned int cfg_zone) const char * ENESMBusController::GetChannelName(unsigned int cfg_zone)
{ {
LOG_TRACE("[%s] Config table for zone %02d: %02d", device_name, cfg_zone, config_table[channel_cfg + cfg_zone]); LOG_TRACE("[%s] Config table for zone %02d: %02d", device_version, cfg_zone, config_table[channel_cfg + cfg_zone]);
if(interface->GetInterfaceType() == ENE_INTERFACE_TYPE_ROG_ARION) if(interface->GetInterfaceType() == ENE_INTERFACE_TYPE_ROG_ARION)
{ {
@ -313,7 +384,7 @@ const char * ENESMBusController::GetChannelName(unsigned int cfg_zone)
unsigned int ENESMBusController::GetLEDCount(unsigned int cfg_zone) unsigned int ENESMBusController::GetLEDCount(unsigned int cfg_zone)
{ {
LOG_TRACE("[%s] LED Count for zone %02d: %02d", device_name, cfg_zone, config_table[0x03 + cfg_zone]); LOG_TRACE("[%s] LED Count for zone %02d: %02d", device_version, cfg_zone, config_table[0x03 + cfg_zone]);
return(config_table[0x03 + cfg_zone]); return(config_table[0x03 + cfg_zone]);
} }
@ -452,7 +523,7 @@ void ENESMBusController::UpdateDeviceName()
{ {
for (int i = 0; i < 16; i++) for (int i = 0; i < 16; i++)
{ {
device_name[i] = ENERegisterRead(ENE_REG_DEVICE_NAME + i); device_version[i] = ENERegisterRead(ENE_REG_DEVICE_NAME + i);
} }
} }

13
Controllers/ENESMBusController/ENESMBusController.h
View file

@ -100,11 +100,14 @@ enum
class ENESMBusController class ENESMBusController
{ {
public: public:
ENESMBusController(ENESMBusInterface* interface, ene_dev_id dev); ENESMBusController(ENESMBusInterface* interface, ene_dev_id dev, std::string dev_name, device_type dev_type);
~ENESMBusController(); ~ENESMBusController();
std::string GetDeviceName(); std::string GetLocation();
std::string GetDeviceLocation(); std::string GetName();
std::string GetVersion();
device_type GetType();
const char* GetChannelName(unsigned int cfg_zone); const char* GetChannelName(unsigned int cfg_zone);
unsigned int GetLEDCount(unsigned int cfg_zone); unsigned int GetLEDCount(unsigned int cfg_zone);
unsigned char GetLEDRed(unsigned int led); unsigned char GetLEDRed(unsigned int led);
@ -129,7 +132,7 @@ public:
void ENERegisterWriteBlock(ene_register reg, unsigned char * data, unsigned char sz); void ENERegisterWriteBlock(ene_register reg, unsigned char * data, unsigned char sz);
private: private:
char device_name[16]; char device_version[16];
unsigned char config_table[64]; unsigned char config_table[64];
unsigned int led_count; unsigned int led_count;
ene_register direct_reg; ene_register direct_reg;
@ -138,4 +141,6 @@ private:
ENESMBusInterface* interface; ENESMBusInterface* interface;
ene_dev_id dev; ene_dev_id dev;
bool supports_mode_14; bool supports_mode_14;
std::string name;
device_type type;
}; };

11
Controllers/ENESMBusController/ENESMBusControllerDetect.cpp
View file

@ -247,7 +247,7 @@ void DetectENESMBusDRAMControllers(std::vector<i2c_smbus_interface*> &busses)
if (TestForENESMBusController(busses[bus], ene_ram_addresses[address_list_idx])) if (TestForENESMBusController(busses[bus], ene_ram_addresses[address_list_idx]))
{ {
ENESMBusInterface_i2c_smbus* interface = new ENESMBusInterface_i2c_smbus(busses[bus]); ENESMBusInterface_i2c_smbus* interface = new ENESMBusInterface_i2c_smbus(busses[bus]);
ENESMBusController* controller = new ENESMBusController(interface, ene_ram_addresses[address_list_idx]); ENESMBusController* controller = new ENESMBusController(interface, ene_ram_addresses[address_list_idx], "ENE DRAM", DEVICE_TYPE_DRAM);
RGBController_ENESMBus* rgb_controller = new RGBController_ENESMBus(controller); RGBController_ENESMBus* rgb_controller = new RGBController_ENESMBus(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller); ResourceManager::get()->RegisterRGBController(rgb_controller);
@ -288,11 +288,9 @@ void DetectENESMBusMotherboardControllers(std::vector<i2c_smbus_interface*> &bus
DMIInfo dmi; DMIInfo dmi;
ENESMBusInterface_i2c_smbus* interface = new ENESMBusInterface_i2c_smbus(busses[bus]); ENESMBusInterface_i2c_smbus* interface = new ENESMBusInterface_i2c_smbus(busses[bus]);
ENESMBusController* controller = new ENESMBusController(interface, aura_mobo_addresses[address_list_idx]); ENESMBusController* controller = new ENESMBusController(interface, aura_mobo_addresses[address_list_idx], "ASUS " + dmi.getMainboard(), DEVICE_TYPE_MOTHERBOARD);
RGBController_ENESMBus* rgb_controller = new RGBController_ENESMBus(controller); RGBController_ENESMBus* rgb_controller = new RGBController_ENESMBus(controller);
rgb_controller->name = "ASUS " + dmi.getMainboard();
ResourceManager::get()->RegisterRGBController(rgb_controller); ResourceManager::get()->RegisterRGBController(rgb_controller);
} }
@ -322,12 +320,9 @@ void DetectENESMBusGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, co
if(TestForENESMBusController(bus, i2c_addr)) if(TestForENESMBusController(bus, i2c_addr))
{ {
ENESMBusInterface_i2c_smbus* interface = new ENESMBusInterface_i2c_smbus(bus); ENESMBusInterface_i2c_smbus* interface = new ENESMBusInterface_i2c_smbus(bus);
ENESMBusController* controller = new ENESMBusController(interface, i2c_addr); ENESMBusController* controller = new ENESMBusController(interface, i2c_addr, name, DEVICE_TYPE_GPU);
RGBController_ENESMBus* rgb_controller = new RGBController_ENESMBus(controller); RGBController_ENESMBus* rgb_controller = new RGBController_ENESMBus(controller);
rgb_controller->name = name;
rgb_controller->type = DEVICE_TYPE_GPU;
ResourceManager::get()->RegisterRGBController(rgb_controller); ResourceManager::get()->RegisterRGBController(rgb_controller);
} }
else else

31
Controllers/ENESMBusController/RGBController_ENESMBus.cpp
View file

@ -27,17 +27,17 @@
RGBController_ENESMBus::RGBController_ENESMBus(ENESMBusController * controller_ptr) RGBController_ENESMBus::RGBController_ENESMBus(ENESMBusController * controller_ptr)
{ {
controller = controller_ptr; controller = controller_ptr;
/*---------------------------------------------------------*\ /*---------------------------------------------------------*\
| Get ENEController settings | | Get ENEController settings |
\*---------------------------------------------------------*/ \*---------------------------------------------------------*/
json ene_settings = ResourceManager::get()->GetSettingsManager()->GetSettings("ENESMBusSettings"); json ene_settings = ResourceManager::get()->GetSettingsManager()->GetSettings("ENESMBusSettings");
/*---------------------------------------------------------*\ /*---------------------------------------------------------*\
| Check if save to device is enabled | | Check if save to device is enabled |
\*---------------------------------------------------------*/ \*---------------------------------------------------------*/
unsigned int save_flag = 0; unsigned int save_flag = 0;
if(ene_settings.contains("enable_save")) if(ene_settings.contains("enable_save"))
{ {
@ -51,36 +51,29 @@ RGBController_ENESMBus::RGBController_ENESMBus(ENESMBusController * controller_p
| Determine name and type (DRAM or Motherboard) by checking | | Determine name and type (DRAM or Motherboard) by checking |
| the ENE controller's version string | | the ENE controller's version string |
\*---------------------------------------------------------*/ \*---------------------------------------------------------*/
version = controller->GetDeviceName(); name = controller->GetName();
location = controller->GetDeviceLocation(); description = "ENE SMBus Device";
version = controller->GetVersion();
location = controller->GetLocation();
type = controller->GetType();
if((version.find("DIMM_LED") != std::string::npos) || (version.find("AUDA") != std::string::npos) ) if((version.find("DIMM_LED") != std::string::npos) || (version.find("AUDA") != std::string::npos) )
{ {
type = DEVICE_TYPE_DRAM; vendor = "ENE";
name = "ENE DRAM";
vendor = "ENE";
} }
else if(version.find("ROG STRIX ARION") != std::string::npos) else if(version.find("ROG STRIX ARION") != std::string::npos)
{ {
type = DEVICE_TYPE_STORAGE; vendor = "ASUS";
name = "ASUS ROG Strix Arion";
vendor = "ASUS";
} }
else if(location.find("NVMe:") != std::string::npos) else if(location.find("NVMe:") != std::string::npos)
{ {
type = DEVICE_TYPE_STORAGE; vendor = "XPG";
name = "XPG Spectrix S40G";
vendor = "XPG";
} }
else else
{ {
type = DEVICE_TYPE_MOTHERBOARD; vendor = "ASUS";
name = "ASUS Aura Motherboard";
vendor = "ASUS";
} }
description = "ENE SMBus Device";
mode Direct; mode Direct;
Direct.name = "Direct"; Direct.name = "Direct";
Direct.value = 0xFFFF; Direct.value = 0xFFFF;

2
Controllers/ENESMBusController/ROGArionDetect.cpp
View file

@ -34,7 +34,7 @@ void DetectROGArionControllers()
if(dev) if(dev)
{ {
ENESMBusInterface_ROGArion* interface = new ENESMBusInterface_ROGArion(dev, info->path); ENESMBusInterface_ROGArion* interface = new ENESMBusInterface_ROGArion(dev, info->path);
ENESMBusController* controller = new ENESMBusController(interface, 0x67); ENESMBusController* controller = new ENESMBusController(interface, 0x67, "Asus ROG Strix Arion", DEVICE_TYPE_STORAGE);
RGBController_ENESMBus* rgb_controller = new RGBController_ENESMBus(controller); RGBController_ENESMBus* rgb_controller = new RGBController_ENESMBus(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller); ResourceManager::get()->RegisterRGBController(rgb_controller);

2
Controllers/ENESMBusController/XPGSpectrixS40GDetect_Linux.cpp
View file

@ -79,7 +79,7 @@ void DetectSpectrixS40GControllers()
if(nvme_fd > 0) if(nvme_fd > 0)
{ {
ENESMBusInterface_SpectrixS40G* interface = new ENESMBusInterface_SpectrixS40G(nvme_fd, nvme_dev_buf); ENESMBusInterface_SpectrixS40G* interface = new ENESMBusInterface_SpectrixS40G(nvme_fd, nvme_dev_buf);
ENESMBusController* controller = new ENESMBusController(interface, 0x67); ENESMBusController* controller = new ENESMBusController(interface, 0x67, "XPG Spectrix S40G", DEVICE_TYPE_STORAGE);
RGBController_ENESMBus* rgb_controller = new RGBController_ENESMBus(controller); RGBController_ENESMBus* rgb_controller = new RGBController_ENESMBus(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller); ResourceManager::get()->RegisterRGBController(rgb_controller);

2
Controllers/ENESMBusController/XPGSpectrixS40GDetect_Windows.cpp
View file

@ -113,7 +113,7 @@ void DetectSpectrixS40GControllers()
if(nvme_fd != INVALID_HANDLE_VALUE) if(nvme_fd != INVALID_HANDLE_VALUE)
{ {
ENESMBusInterface_SpectrixS40G* interface = new ENESMBusInterface_SpectrixS40G(nvme_fd, dev_name); ENESMBusInterface_SpectrixS40G* interface = new ENESMBusInterface_SpectrixS40G(nvme_fd, dev_name);
ENESMBusController* controller = new ENESMBusController(interface, 0x67); ENESMBusController* controller = new ENESMBusController(interface, 0x67, "XPG Spectrix S40G", DEVICE_TYPE_STORAGE);
RGBController_ENESMBus* rgb_controller = new RGBController_ENESMBus(controller); RGBController_ENESMBus* rgb_controller = new RGBController_ENESMBus(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller); ResourceManager::get()->RegisterRGBController(rgb_controller);