Store name in EVGAAmpereGPUController to avoid setting it in detector

CalcProgrammer1 · CalcProgrammer1 · commit c94eed432de8 · 2025-08-07T11:53:26.000-05:00
diff --git a/Controllers/EVGAAmpereGPUController/EVGAAmpereGPUControllerDetect.cpp b/Controllers/EVGAAmpereGPUController/EVGAAmpereGPUControllerDetect.cpp
@@ -34,18 +34,17 @@ void DetectEVGAAmpereGPUControllers(i2c_smbus_interface* bus, uint8_t address, c
         EVGAGPUv3Controller*     controller;
         RGBController_EVGAGPUv3* rgb_controller;
 
-        controller = new EVGAGPUv3Controller(bus, address);
-        controller-> evgaGPUName = name.c_str(); // Pass name of the card into the controller for logging.
+        controller = new EVGAGPUv3Controller(bus, address, name);
 
         if(controller-> ReadFWVersion() != "")
         {
             rgb_controller = new RGBController_EVGAGPUv3(controller);
-            rgb_controller->name = name;
+
             ResourceManager::get()->RegisterRGBController(rgb_controller);
         }
         else
         {
-            LOG_INFO("[%s] Failed to get a valid FW version, does the i2c interface support `i2c_smbus_read_i2c_block_data`?", controller-> evgaGPUName);
+            LOG_INFO("[%s] Failed to get a valid FW version, does the i2c interface support `i2c_smbus_read_i2c_block_data`?", controller->GetDeviceName().c_str());
             delete controller;
         }
     }
diff --git a/Controllers/EVGAAmpereGPUController/EVGAGPUv3Controller.cpp b/Controllers/EVGAAmpereGPUController/EVGAGPUv3Controller.cpp
@@ -12,10 +12,11 @@
 #include "EVGAGPUv3Controller.h"
 #include "LogManager.h"
 
-EVGAGPUv3Controller::EVGAGPUv3Controller(i2c_smbus_interface* bus, evga_dev_id dev)
+EVGAGPUv3Controller::EVGAGPUv3Controller(i2c_smbus_interface* bus, evga_dev_id dev, std::string dev_name)
 {
-    this->bus = bus;
-    this->dev = dev;
+    this->bus   = bus;
+    this->dev   = dev;
+    this->name  = dev_name;
 }
 
 EVGAGPUv3Controller::~EVGAGPUv3Controller()
@@ -34,9 +35,14 @@ std::string EVGAGPUv3Controller::GetDeviceLocation()
     return("I2C: " + return_string);
 }
 
+std::string EVGAGPUv3Controller::GetDeviceName()
+{
+    return(name);
+}
+
 void EVGAGPUv3Controller::GetDeviceModes()
 {
-    LOG_DEBUG("[%s] Getting Zone and LED count from HW", evgaGPUName);
+    LOG_DEBUG("[%s] Getting Zone and LED count from HW", name.c_str());
     uint8_t data_pkt[I2C_SMBUS_BLOCK_MAX] = {};
 
     uint8_t result = bus->i2c_smbus_read_i2c_block_data(dev, EVGA_GPU_V3_REG_MODE, 10, data_pkt);
@@ -46,14 +52,14 @@ void EVGAGPUv3Controller::GetDeviceModes()
         {
             zone_modes[zone] = data_pkt[zone + 1];
             zone_led_count[zone] = data_pkt[zone + 5];
-            LOG_DEBUG("[%s] Zone %1d LED count: %02d, mode: %02d", evgaGPUName, zone + 1, zone_led_count[zone], zone_modes[zone]);
+            LOG_DEBUG("[%s] Zone %1d LED count: %02d, mode: %02d", name.c_str(), zone + 1, zone_led_count[zone], zone_modes[zone]);
         }
         zone_sync = data_pkt[9];
-        LOG_DEBUG("[%s] Zone Sync is %1d", evgaGPUName, zone_sync);
+        LOG_DEBUG("[%s] Zone Sync is %1d", name.c_str(), zone_sync);
     }
     else
     {
-            LOG_DEBUG("[%s] Invalid block read result: %02d", evgaGPUName, result);
+            LOG_DEBUG("[%s] Invalid block read result: %02d", name.c_str(), result);
             memset(zone_led_count, 0, sizeof(zone_led_count));
             memset(zone_modes, 0, sizeof(zone_modes));
     }
@@ -67,7 +73,7 @@ std::string EVGAGPUv3Controller::GetFWVersion()
 
 std::string EVGAGPUv3Controller::ReadFWVersion()
 {
-    LOG_TRACE("[%s] Getting FW from HW", evgaGPUName);
+    LOG_TRACE("[%s] Getting FW from HW", name.c_str());
     uint8_t         data_pkt[I2C_SMBUS_BLOCK_MAX] = {};
     std::string     return_string = "";
     char            version[10];
@@ -80,7 +86,7 @@ std::string EVGAGPUv3Controller::ReadFWVersion()
 
         snprintf(version, 10, "1.%02d.%02d", major, minor);
         return_string.append(version);
-        LOG_TRACE("[%s] Firmware %s", evgaGPUName, version);
+        LOG_TRACE("[%s] Firmware %s", name.c_str(), version);
         fwVersion = return_string;
         return(return_string);
     }
@@ -106,7 +112,7 @@ EVGAv3_config EVGAGPUv3Controller::GetZoneConfig(uint8_t zone, uint8_t mode)
     zone_config.numberOfColors  = 0;
     zone_config.speed           = EVGA_GPU_V3_SPEED_GENERIC_NORMAL;
 
-    LOG_DEBUG("[%s] Retriving Zone %1d config for mode %1d from HW", evgaGPUName, zone, mode);
+    LOG_DEBUG("[%s] Retriving Zone %1d config for mode %1d from HW", name.c_str(), zone, mode);
     uint8_t data_pkt[I2C_SMBUS_BLOCK_MAX] = {};
 
     switch (mode)
@@ -276,12 +282,12 @@ EVGAv3_config EVGAGPUv3Controller::GetZoneConfig(uint8_t zone, uint8_t mode)
 
     if(readFail == false)
     {
-        LOG_TRACE("[%s] Zone %1d Brightness: 0x%02X, Colors: %1d, Speed: 0x%04X, Direction %1d.", evgaGPUName, zone, zone_config.brightness, zone_config.numberOfColors, zone_config.speed, zone_config.direction);
+        LOG_TRACE("[%s] Zone %1d Brightness: 0x%02X, Colors: %1d, Speed: 0x%04X, Direction %1d.", name.c_str(), zone, zone_config.brightness, zone_config.numberOfColors, zone_config.speed, zone_config.direction);
         for(uint8_t color_index = 0; color_index < zone_config.numberOfColors; color_index++)
         {
-            LOG_TRACE("[%s] Color Index [%2d]: 0x%06X", evgaGPUName, color_index, zone_config.colors[color_index]);
+            LOG_TRACE("[%s] Color Index [%2d]: 0x%06X", name.c_str(), color_index, zone_config.colors[color_index]);
         }
-        LOG_DEBUG("[%s] Done loading Zone %1d configuration from HW", evgaGPUName, zone);
+        LOG_DEBUG("[%s] Done loading Zone %1d configuration from HW", name.c_str(), zone);
     }
     else
     {
@@ -291,7 +297,7 @@ EVGAv3_config EVGAGPUv3Controller::GetZoneConfig(uint8_t zone, uint8_t mode)
         {
             zone_config.colors[i] = 0;
         }
-        LOG_DEBUG("[%s] Failed while loading Zone %1d configuration from HW", evgaGPUName, zone);
+        LOG_DEBUG("[%s] Failed while loading Zone %1d configuration from HW", name.c_str(), zone);
     }
     return zone_config;
 }
@@ -302,13 +308,13 @@ void EVGAGPUv3Controller::initCard()
     // NvAPI_I2CWriteEx: Dev: 0x2D RegSize: 0x01 Reg: 0xB2 Size: 0x05 Data: 0x04 0xC6 0xEB 0xEA 0x15
     uint8_t data_pkt[5] = {0x04, 0xC6, 0xEB, 0xEA, 0x15};
     bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_ENABLE, sizeof(data_pkt), data_pkt);
-    LOG_TRACE("[%s] Sending SW int packet", evgaGPUName);
+    LOG_TRACE("[%s] Sending SW int packet", name.c_str());
     return;
 }
 
 void EVGAGPUv3Controller::SaveConfig()
 {
-    LOG_DEBUG("[%s] Sending save packet", evgaGPUName);
+    LOG_DEBUG("[%s] Sending save packet", name.c_str());
 
     //NvAPI_I2CWriteEx: Dev: 0x2D RegSize: 0x01 Reg: 0x90 Size: 0x05 Data: 0x04 0x9E 0xEB 0x00 0x90 //Sent on close of PX1
     uint8_t data_pkt[5] = {0x04, 0x9E, 0xEB, 0x00, 0x90};
@@ -328,7 +334,7 @@ void EVGAGPUv3Controller::ResizeARGB(uint8_t newSize)
         newSize = EVGAGPUV3_LEDS_MAX;
     }
 
-    LOG_DEBUG("[%s] Resizing ARGB header with %02d size", evgaGPUName, newSize);
+    LOG_DEBUG("[%s] Resizing ARGB header with %02d size", name.c_str(), newSize);
     uint8_t data_pkt[EVGAGPUV3_MODE_PACKET_SIZE] = { 0x09, EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT,
                                                            EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT, newSize, EVGAGPUV3_INIT};
 
@@ -361,7 +367,7 @@ void EVGAGPUv3Controller::SetAllModes(uint8_t zone_0_mode, uint8_t zone_1_mode,u
     mode_pkt[9] = sync;
 
     bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_MODE, EVGAGPUV3_MODE_PACKET_SIZE, mode_pkt);
-    //LOG_TRACE("[%s] Setting all zones to mode: %02d, %2d, %2d, %2d, zone sync %1d.", evgaGPUName, zone_0_mode, zone_1_mode, zone_2_mode, zone_3_mode, sync);
+    //LOG_TRACE("[%s] Setting all zones to mode: %02d, %2d, %2d, %2d, zone sync %1d.", name.c_str(), zone_0_mode, zone_1_mode, zone_2_mode, zone_3_mode, sync);
 }
 
 void EVGAGPUv3Controller::SetZoneMode(uint8_t zone, uint8_t mode)
@@ -381,7 +387,7 @@ void EVGAGPUv3Controller::SetZoneMode(uint8_t zone, uint8_t mode)
     mode_pkt[zone + 1] = mode;
 
     bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_MODE, EVGAGPUV3_MODE_PACKET_SIZE, mode_pkt);
-    //LOG_TRACE("[%s] Setting individual zone %1d to mode %02d", evgaGPUName, zone, mode);
+    //LOG_TRACE("[%s] Setting individual zone %1d to mode %02d", name.c_str(), zone, mode);
 }
 
 void EVGAGPUv3Controller::SetZone(uint8_t zone, uint8_t mode, EVGAv3_config zone_config)
@@ -510,7 +516,7 @@ void EVGAGPUv3Controller::SetZone(uint8_t zone, uint8_t mode, EVGAv3_config zone
         break;
     default:
         {
-            LOG_TRACE("[%s] Mode %02d not found", evgaGPUName, mode);
+            LOG_TRACE("[%s] Mode %02d not found", name->c_str(), mode);
         }
         break;
     }
diff --git a/Controllers/EVGAAmpereGPUController/EVGAGPUv3Controller.h b/Controllers/EVGAAmpereGPUController/EVGAGPUv3Controller.h
@@ -98,14 +98,14 @@ enum // Value limits for speeds
 class EVGAGPUv3Controller
 {
 public:
-    EVGAGPUv3Controller(i2c_smbus_interface* bus, evga_dev_id dev);
+    EVGAGPUv3Controller(i2c_smbus_interface* bus, evga_dev_id dev, std::string dev_name);
     ~EVGAGPUv3Controller();
 
     uint8_t         zone_led_count[4];
     uint8_t         zone_modes[4];
-    const char *    evgaGPUName;
 
     std::string     GetDeviceLocation();
+    std::string     GetDeviceName();
     std::string     GetFWVersion();
     std::string     ReadFWVersion();
 
@@ -123,6 +123,8 @@ class EVGAGPUv3Controller
     i2c_smbus_interface*    bus;
     evga_dev_id             dev;
     bool                    zone_sync;
-    void                    initCard();
     std::string             fwVersion;
+    std::string             name;
+
+    void                    initCard();
 };
diff --git a/Controllers/EVGAAmpereGPUController/RGBController_EVGAGPUv3.cpp b/Controllers/EVGAAmpereGPUController/RGBController_EVGAGPUv3.cpp
@@ -32,17 +32,16 @@ static const char* evga_v3_zone_names[] =
         is only able to set all LED's to a single color.
 \*-------------------------------------------------------------------*/
 
-RGBController_EVGAGPUv3::RGBController_EVGAGPUv3(EVGAGPUv3Controller* evga_ptr)
+RGBController_EVGAGPUv3::RGBController_EVGAGPUv3(EVGAGPUv3Controller* controller_ptr)
 {
-    evga = evga_ptr;
+    controller                  = controller_ptr;
 
-    name                        = "EVGA GPU";
+    name                        = controller->GetDeviceName();
     vendor                      = "EVGA";
     description                 = "EVGA Ampere RGB GPU Device";
-    location                    = evga->GetDeviceLocation();
-    version                     = evga->GetFWVersion();
-
-    type = DEVICE_TYPE_GPU;
+    location                    = controller->GetDeviceLocation();
+    version                     = controller->GetFWVersion();
+    type                        = DEVICE_TYPE_GPU;
 
     mode Off;
     Off.name                    = "Off";
@@ -169,11 +168,11 @@ RGBController_EVGAGPUv3::RGBController_EVGAGPUv3(EVGAGPUv3Controller* evga_ptr)
     // Initialize active mode
     for( uint8_t zone_idx = 0; zone_idx < zoneIndexMap.size(); zone_idx++)
     {
-        active_mode = evga->GetZoneMode(0); // Hard coding zone 0 until per zone modes are available.
+        active_mode = controller->GetZoneMode(0); // Hard coding zone 0 until per zone modes are available.
 
         if(active_mode != EVGA_GPU_V3_MODE_OFF)
         {
-            EVGAv3_config hw_config = evga->GetZoneConfig(zoneIndexMap[zone_idx], active_mode);
+            EVGAv3_config hw_config = controller->GetZoneConfig(zoneIndexMap[zone_idx], active_mode);
 
             /*---------------------------------------------------------*\
             | The LED color (color[0]) will always be set. Mode colors  |
@@ -206,7 +205,7 @@ RGBController_EVGAGPUv3::RGBController_EVGAGPUv3(EVGAGPUv3Controller* evga_ptr)
 
 RGBController_EVGAGPUv3::~RGBController_EVGAGPUv3()
 {
-    delete evga;
+    delete controller;
 }
 
 uint8_t RGBController_EVGAGPUv3::getModeIndex(uint8_t mode_value)
@@ -229,11 +228,11 @@ void RGBController_EVGAGPUv3::SetupZones()
     | Resizing is only possible on zone 4, addressable header   |
     \*---------------------------------------------------------*/
 
-    evga->GetDeviceModes();
+    controller->GetDeviceModes();
 
     for(uint8_t zone_idx = 0; zone_idx < 4; zone_idx++)
     {
-        if(evga->zone_led_count[zone_idx] > 0)
+        if(controller->zone_led_count[zone_idx] > 0)
         {
             zone* new_zone = new zone();
             led*  new_led  = new led();
@@ -259,7 +258,7 @@ void RGBController_EVGAGPUv3::SetupZones()
 
 void RGBController_EVGAGPUv3::ResizeZone(int /*zone*/, int newSize)
 {
-    evga->ResizeARGB(newSize);
+    controller->ResizeARGB(newSize);
 }
 
 void RGBController_EVGAGPUv3::DeviceUpdateLEDs()
@@ -286,20 +285,20 @@ void RGBController_EVGAGPUv3::DeviceUpdateLEDs()
                 zone_config.colors[i] = modes[active_mode].colors[i];
             }
         }
-        //LOG_TRACE("[%s] Updating LED %1d", evga->evgaGPUName, zone_idx);
-        evga->SetZone(zoneIndexMap[zone_idx], modes[active_mode].value, zone_config);
+        //LOG_TRACE("[%s] Updating LED %1d", controller->evgaGPUName, zone_idx);
+        controller->SetZone(zoneIndexMap[zone_idx], modes[active_mode].value, zone_config);
     }
 }
 
 void RGBController_EVGAGPUv3::UpdateZoneLEDs(int /*zone*/)
 {
-    //LOG_TRACE("[%s] Updating zone %1d", evga->evgaGPUName, zone);
+    //LOG_TRACE("[%s] Updating zone %1d", controller->evgaGPUName, zone);
     DeviceUpdateLEDs();
 }
 
 void RGBController_EVGAGPUv3::UpdateSingleLED(int /*led*/)
 {
-    //LOG_TRACE("[%s] Updating single LED %1d", evga->evgaGPUName, led);
+    //LOG_TRACE("[%s] Updating single LED %1d", controller->evgaGPUName, led);
     DeviceUpdateLEDs();
 }
 
@@ -308,15 +307,15 @@ void RGBController_EVGAGPUv3::DeviceUpdateMode()
     /* Update all zone modes in a loop, each one with a packet to be use with per zone control
     for(uint8_t zone = 0; zone < 4; zone++)
     {
-        evga->SetZoneMode(zone, modes[active_mode].value);
+        controller->SetZoneMode(zone, modes[active_mode].value);
     }
     */
-    //LOG_TRACE("[%s] Updating to mode %1d", evga->evgaGPUName, modes[active_mode].value);
+    //LOG_TRACE("[%s] Updating to mode %1d", controller->evgaGPUName, modes[active_mode].value);
     DeviceUpdateLEDs();
-    evga->SetAllModes(modes[active_mode].value, modes[active_mode].value, modes[active_mode].value,modes[active_mode].value, true); //Set all zones to the same mode
+    controller->SetAllModes(modes[active_mode].value, modes[active_mode].value, modes[active_mode].value,modes[active_mode].value, true); //Set all zones to the same mode
 }
 
 void RGBController_EVGAGPUv3::DeviceSaveMode()
 {
-    evga->SaveConfig();
+    controller->SaveConfig();
 }
diff --git a/Controllers/EVGAAmpereGPUController/RGBController_EVGAGPUv3.h b/Controllers/EVGAAmpereGPUController/RGBController_EVGAGPUv3.h
@@ -17,7 +17,7 @@
 class RGBController_EVGAGPUv3 : public RGBController
 {
 public:
-    RGBController_EVGAGPUv3(EVGAGPUv3Controller* evga_ptr);
+    RGBController_EVGAGPUv3(EVGAGPUv3Controller* controller_ptr);
     ~RGBController_EVGAGPUv3();
 
     void        SetupZones();
@@ -32,7 +32,8 @@ class RGBController_EVGAGPUv3 : public RGBController
     void        DeviceSaveMode();
 
 private:
-    uint8_t     getModeIndex(uint8_t mode_value);
-    EVGAGPUv3Controller* evga;
+    EVGAGPUv3Controller* controller;
     std::vector<uint8_t> zoneIndexMap;
+
+    uint8_t     getModeIndex(uint8_t mode_value);
 };

Original file line number	Diff line number	Diff line change
`@@ -34,18 +34,17 @@ void DetectEVGAAmpereGPUControllers(i2c_smbus_interface* bus, uint8_t address, c`
`34`	`34`	`EVGAGPUv3Controller* controller;`
`35`	`35`	`RGBController_EVGAGPUv3* rgb_controller;`
`36`	`36`
`37`		`- controller = new EVGAGPUv3Controller(bus, address);`
`38`		`- controller-> evgaGPUName = name.c_str(); // Pass name of the card into the controller for logging.`
	`37`	`+ controller = new EVGAGPUv3Controller(bus, address, name);`
`39`	`38`
`40`	`39`	`if(controller-> ReadFWVersion() != "")`
`41`	`40`	`{`
`42`	`41`	`rgb_controller = new RGBController_EVGAGPUv3(controller);`
`43`		`- rgb_controller->name = name;`
	`42`	`+`
`44`	`43`	`ResourceManager::get()->RegisterRGBController(rgb_controller);`
`45`	`44`	`}`
`46`	`45`	`else`
`47`	`46`	`{`
`48`		- LOG_INFO("[%s] Failed to get a valid FW version, does the i2c interface support `i2c_smbus_read_i2c_block_data`?", controller-> evgaGPUName);
	`47`	+ LOG_INFO("[%s] Failed to get a valid FW version, does the i2c interface support `i2c_smbus_read_i2c_block_data`?", controller->GetDeviceName().c_str());
`49`	`48`	`delete controller;`
`50`	`49`	`}`
`51`	`50`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,10 +12,11 @@`
`12`	`12`	`#include "EVGAGPUv3Controller.h"`
`13`	`13`	`#include "LogManager.h"`
`14`	`14`
`15`		`-EVGAGPUv3Controller::EVGAGPUv3Controller(i2c_smbus_interface* bus, evga_dev_id dev)`
	`15`	`+EVGAGPUv3Controller::EVGAGPUv3Controller(i2c_smbus_interface* bus, evga_dev_id dev, std::string dev_name)`
`16`	`16`	`{`
`17`		`- this->bus = bus;`
`18`		`- this->dev = dev;`
	`17`	`+ this->bus = bus;`
	`18`	`+ this->dev = dev;`
	`19`	`+ this->name = dev_name;`
`19`	`20`	`}`
`20`	`21`
`21`	`22`	`EVGAGPUv3Controller::~EVGAGPUv3Controller()`
`@@ -34,9 +35,14 @@ std::string EVGAGPUv3Controller::GetDeviceLocation()`
`34`	`35`	`return("I2C: " + return_string);`
`35`	`36`	`}`
`36`	`37`
	`38`	`+std::string EVGAGPUv3Controller::GetDeviceName()`
	`39`	`+{`
	`40`	`+ return(name);`
	`41`	`+}`
	`42`	`+`
`37`	`43`	`void EVGAGPUv3Controller::GetDeviceModes()`
`38`	`44`	`{`
`39`		`- LOG_DEBUG("[%s] Getting Zone and LED count from HW", evgaGPUName);`
	`45`	`+ LOG_DEBUG("[%s] Getting Zone and LED count from HW", name.c_str());`
`40`	`46`	`uint8_t data_pkt[I2C_SMBUS_BLOCK_MAX] = {};`
`41`	`47`
`42`	`48`	`uint8_t result = bus->i2c_smbus_read_i2c_block_data(dev, EVGA_GPU_V3_REG_MODE, 10, data_pkt);`
`@@ -46,14 +52,14 @@ void EVGAGPUv3Controller::GetDeviceModes()`
`46`	`52`	`{`
`47`	`53`	`zone_modes[zone] = data_pkt[zone + 1];`
`48`	`54`	`zone_led_count[zone] = data_pkt[zone + 5];`
`49`		`- LOG_DEBUG("[%s] Zone %1d LED count: %02d, mode: %02d", evgaGPUName, zone + 1, zone_led_count[zone], zone_modes[zone]);`
	`55`	`+ LOG_DEBUG("[%s] Zone %1d LED count: %02d, mode: %02d", name.c_str(), zone + 1, zone_led_count[zone], zone_modes[zone]);`
`50`	`56`	`}`
`51`	`57`	`zone_sync = data_pkt[9];`
`52`		`- LOG_DEBUG("[%s] Zone Sync is %1d", evgaGPUName, zone_sync);`
	`58`	`+ LOG_DEBUG("[%s] Zone Sync is %1d", name.c_str(), zone_sync);`
`53`	`59`	`}`
`54`	`60`	`else`
`55`	`61`	`{`
`56`		`- LOG_DEBUG("[%s] Invalid block read result: %02d", evgaGPUName, result);`
	`62`	`+ LOG_DEBUG("[%s] Invalid block read result: %02d", name.c_str(), result);`
`57`	`63`	`memset(zone_led_count, 0, sizeof(zone_led_count));`
`58`	`64`	`memset(zone_modes, 0, sizeof(zone_modes));`
`59`	`65`	`}`
`@@ -67,7 +73,7 @@ std::string EVGAGPUv3Controller::GetFWVersion()`
`67`	`73`
`68`	`74`	`std::string EVGAGPUv3Controller::ReadFWVersion()`
`69`	`75`	`{`
`70`		`- LOG_TRACE("[%s] Getting FW from HW", evgaGPUName);`
	`76`	`+ LOG_TRACE("[%s] Getting FW from HW", name.c_str());`
`71`	`77`	`uint8_t data_pkt[I2C_SMBUS_BLOCK_MAX] = {};`
`72`	`78`	`std::string return_string = "";`
`73`	`79`	`char version[10];`
`@@ -80,7 +86,7 @@ std::string EVGAGPUv3Controller::ReadFWVersion()`
`80`	`86`
`81`	`87`	`snprintf(version, 10, "1.%02d.%02d", major, minor);`
`82`	`88`	`return_string.append(version);`
`83`		`- LOG_TRACE("[%s] Firmware %s", evgaGPUName, version);`
	`89`	`+ LOG_TRACE("[%s] Firmware %s", name.c_str(), version);`
`84`	`90`	`fwVersion = return_string;`
`85`	`91`	`return(return_string);`
`86`	`92`	`}`
`@@ -106,7 +112,7 @@ EVGAv3_config EVGAGPUv3Controller::GetZoneConfig(uint8_t zone, uint8_t mode)`
`106`	`112`	`zone_config.numberOfColors = 0;`
`107`	`113`	`zone_config.speed = EVGA_GPU_V3_SPEED_GENERIC_NORMAL;`
`108`	`114`
`109`		`- LOG_DEBUG("[%s] Retriving Zone %1d config for mode %1d from HW", evgaGPUName, zone, mode);`
	`115`	`+ LOG_DEBUG("[%s] Retriving Zone %1d config for mode %1d from HW", name.c_str(), zone, mode);`
`110`	`116`	`uint8_t data_pkt[I2C_SMBUS_BLOCK_MAX] = {};`
`111`	`117`
`112`	`118`	`switch (mode)`
`@@ -276,12 +282,12 @@ EVGAv3_config EVGAGPUv3Controller::GetZoneConfig(uint8_t zone, uint8_t mode)`
`276`	`282`
`277`	`283`	`if(readFail == false)`
`278`	`284`	`{`
`279`		`- LOG_TRACE("[%s] Zone %1d Brightness: 0x%02X, Colors: %1d, Speed: 0x%04X, Direction %1d.", evgaGPUName, zone, zone_config.brightness, zone_config.numberOfColors, zone_config.speed, zone_config.direction);`
	`285`	`+ LOG_TRACE("[%s] Zone %1d Brightness: 0x%02X, Colors: %1d, Speed: 0x%04X, Direction %1d.", name.c_str(), zone, zone_config.brightness, zone_config.numberOfColors, zone_config.speed, zone_config.direction);`
`280`	`286`	`for(uint8_t color_index = 0; color_index < zone_config.numberOfColors; color_index++)`
`281`	`287`	`{`
`282`		`- LOG_TRACE("[%s] Color Index [%2d]: 0x%06X", evgaGPUName, color_index, zone_config.colors[color_index]);`
	`288`	`+ LOG_TRACE("[%s] Color Index [%2d]: 0x%06X", name.c_str(), color_index, zone_config.colors[color_index]);`
`283`	`289`	`}`
`284`		`- LOG_DEBUG("[%s] Done loading Zone %1d configuration from HW", evgaGPUName, zone);`
	`290`	`+ LOG_DEBUG("[%s] Done loading Zone %1d configuration from HW", name.c_str(), zone);`
`285`	`291`	`}`
`286`	`292`	`else`
`287`	`293`	`{`
`@@ -291,7 +297,7 @@ EVGAv3_config EVGAGPUv3Controller::GetZoneConfig(uint8_t zone, uint8_t mode)`
`291`	`297`	`{`
`292`	`298`	`zone_config.colors[i] = 0;`
`293`	`299`	`}`
`294`		`- LOG_DEBUG("[%s] Failed while loading Zone %1d configuration from HW", evgaGPUName, zone);`
	`300`	`+ LOG_DEBUG("[%s] Failed while loading Zone %1d configuration from HW", name.c_str(), zone);`
`295`	`301`	`}`
`296`	`302`	`return zone_config;`
`297`	`303`	`}`
`@@ -302,13 +308,13 @@ void EVGAGPUv3Controller::initCard()`
`302`	`308`	`// NvAPI_I2CWriteEx: Dev: 0x2D RegSize: 0x01 Reg: 0xB2 Size: 0x05 Data: 0x04 0xC6 0xEB 0xEA 0x15`
`303`	`309`	`uint8_t data_pkt[5] = {0x04, 0xC6, 0xEB, 0xEA, 0x15};`
`304`	`310`	`bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_ENABLE, sizeof(data_pkt), data_pkt);`
`305`		`- LOG_TRACE("[%s] Sending SW int packet", evgaGPUName);`
	`311`	`+ LOG_TRACE("[%s] Sending SW int packet", name.c_str());`
`306`	`312`	`return;`
`307`	`313`	`}`
`308`	`314`
`309`	`315`	`void EVGAGPUv3Controller::SaveConfig()`
`310`	`316`	`{`
`311`		`- LOG_DEBUG("[%s] Sending save packet", evgaGPUName);`
	`317`	`+ LOG_DEBUG("[%s] Sending save packet", name.c_str());`
`312`	`318`
`313`	`319`	`//NvAPI_I2CWriteEx: Dev: 0x2D RegSize: 0x01 Reg: 0x90 Size: 0x05 Data: 0x04 0x9E 0xEB 0x00 0x90 //Sent on close of PX1`
`314`	`320`	`uint8_t data_pkt[5] = {0x04, 0x9E, 0xEB, 0x00, 0x90};`
`@@ -328,7 +334,7 @@ void EVGAGPUv3Controller::ResizeARGB(uint8_t newSize)`
`328`	`334`	`newSize = EVGAGPUV3_LEDS_MAX;`
`329`	`335`	`}`
`330`	`336`
`331`		`- LOG_DEBUG("[%s] Resizing ARGB header with %02d size", evgaGPUName, newSize);`
	`337`	`+ LOG_DEBUG("[%s] Resizing ARGB header with %02d size", name.c_str(), newSize);`
`332`	`338`	`uint8_t data_pkt[EVGAGPUV3_MODE_PACKET_SIZE] = { 0x09, EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT,`
`333`	`339`	`EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT, newSize, EVGAGPUV3_INIT};`
`334`	`340`
`@@ -361,7 +367,7 @@ void EVGAGPUv3Controller::SetAllModes(uint8_t zone_0_mode, uint8_t zone_1_mode,u`
`361`	`367`	`mode_pkt[9] = sync;`
`362`	`368`
`363`	`369`	`bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_MODE, EVGAGPUV3_MODE_PACKET_SIZE, mode_pkt);`
`364`		`- //LOG_TRACE("[%s] Setting all zones to mode: %02d, %2d, %2d, %2d, zone sync %1d.", evgaGPUName, zone_0_mode, zone_1_mode, zone_2_mode, zone_3_mode, sync);`
	`370`	`+ //LOG_TRACE("[%s] Setting all zones to mode: %02d, %2d, %2d, %2d, zone sync %1d.", name.c_str(), zone_0_mode, zone_1_mode, zone_2_mode, zone_3_mode, sync);`
`365`	`371`	`}`
`366`	`372`
`367`	`373`	`void EVGAGPUv3Controller::SetZoneMode(uint8_t zone, uint8_t mode)`
`@@ -381,7 +387,7 @@ void EVGAGPUv3Controller::SetZoneMode(uint8_t zone, uint8_t mode)`
`381`	`387`	`mode_pkt[zone + 1] = mode;`
`382`	`388`
`383`	`389`	`bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_MODE, EVGAGPUV3_MODE_PACKET_SIZE, mode_pkt);`
`384`		`- //LOG_TRACE("[%s] Setting individual zone %1d to mode %02d", evgaGPUName, zone, mode);`
	`390`	`+ //LOG_TRACE("[%s] Setting individual zone %1d to mode %02d", name.c_str(), zone, mode);`
`385`	`391`	`}`
`386`	`392`
`387`	`393`	`void EVGAGPUv3Controller::SetZone(uint8_t zone, uint8_t mode, EVGAv3_config zone_config)`
`@@ -510,7 +516,7 @@ void EVGAGPUv3Controller::SetZone(uint8_t zone, uint8_t mode, EVGAv3_config zone`
`510`	`516`	`break;`
`511`	`517`	`default:`
`512`	`518`	`{`
`513`		`- LOG_TRACE("[%s] Mode %02d not found", evgaGPUName, mode);`
	`519`	`+ LOG_TRACE("[%s] Mode %02d not found", name->c_str(), mode);`
`514`	`520`	`}`
`515`	`521`	`break;`
`516`	`522`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,17 +32,16 @@ static const char* evga_v3_zone_names[] =`
`32`	`32`	`is only able to set all LED's to a single color.`
`33`	`33`	`\-------------------------------------------------------------------/`
`34`	`34`
`35`		`-RGBController_EVGAGPUv3::RGBController_EVGAGPUv3(EVGAGPUv3Controller* evga_ptr)`
	`35`	`+RGBController_EVGAGPUv3::RGBController_EVGAGPUv3(EVGAGPUv3Controller* controller_ptr)`
`36`	`36`	`{`
`37`		`- evga = evga_ptr;`
	`37`	`+ controller = controller_ptr;`
`38`	`38`
`39`		`- name = "EVGA GPU";`
	`39`	`+ name = controller->GetDeviceName();`
`40`	`40`	`vendor = "EVGA";`
`41`	`41`	`description = "EVGA Ampere RGB GPU Device";`
`42`		`- location = evga->GetDeviceLocation();`
`43`		`- version = evga->GetFWVersion();`
`44`		`-`
`45`		`- type = DEVICE_TYPE_GPU;`
	`42`	`+ location = controller->GetDeviceLocation();`
	`43`	`+ version = controller->GetFWVersion();`
	`44`	`+ type = DEVICE_TYPE_GPU;`
`46`	`45`
`47`	`46`	`mode Off;`
`48`	`47`	`Off.name = "Off";`
`@@ -169,11 +168,11 @@ RGBController_EVGAGPUv3::RGBController_EVGAGPUv3(EVGAGPUv3Controller* evga_ptr)`
`169`	`168`	`// Initialize active mode`
`170`	`169`	`for( uint8_t zone_idx = 0; zone_idx < zoneIndexMap.size(); zone_idx++)`
`171`	`170`	`{`
`172`		`- active_mode = evga->GetZoneMode(0); // Hard coding zone 0 until per zone modes are available.`
	`171`	`+ active_mode = controller->GetZoneMode(0); // Hard coding zone 0 until per zone modes are available.`
`173`	`172`
`174`	`173`	`if(active_mode != EVGA_GPU_V3_MODE_OFF)`
`175`	`174`	`{`
`176`		`- EVGAv3_config hw_config = evga->GetZoneConfig(zoneIndexMap[zone_idx], active_mode);`
	`175`	`+ EVGAv3_config hw_config = controller->GetZoneConfig(zoneIndexMap[zone_idx], active_mode);`
`177`	`176`
`178`	`177`	`/---------------------------------------------------------\`
`179`	`178`	`\| The LED color (color[0]) will always be set. Mode colors \|`
`@@ -206,7 +205,7 @@ RGBController_EVGAGPUv3::RGBController_EVGAGPUv3(EVGAGPUv3Controller* evga_ptr)`
`206`	`205`
`207`	`206`	`RGBController_EVGAGPUv3::~RGBController_EVGAGPUv3()`
`208`	`207`	`{`
`209`		`- delete evga;`
	`208`	`+ delete controller;`
`210`	`209`	`}`
`211`	`210`
`212`	`211`	`uint8_t RGBController_EVGAGPUv3::getModeIndex(uint8_t mode_value)`
`@@ -229,11 +228,11 @@ void RGBController_EVGAGPUv3::SetupZones()`
`229`	`228`	`\| Resizing is only possible on zone 4, addressable header \|`
`230`	`229`	`\---------------------------------------------------------/`
`231`	`230`
`232`		`- evga->GetDeviceModes();`
	`231`	`+ controller->GetDeviceModes();`
`233`	`232`
`234`	`233`	`for(uint8_t zone_idx = 0; zone_idx < 4; zone_idx++)`
`235`	`234`	`{`
`236`		`- if(evga->zone_led_count[zone_idx] > 0)`
	`235`	`+ if(controller->zone_led_count[zone_idx] > 0)`
`237`	`236`	`{`
`238`	`237`	`zone* new_zone = new zone();`
`239`	`238`	`led* new_led = new led();`
`@@ -259,7 +258,7 @@ void RGBController_EVGAGPUv3::SetupZones()`
`259`	`258`
`260`	`259`	`void RGBController_EVGAGPUv3::ResizeZone(int /zone/, int newSize)`
`261`	`260`	`{`
`262`		`- evga->ResizeARGB(newSize);`
	`261`	`+ controller->ResizeARGB(newSize);`
`263`	`262`	`}`
`264`	`263`
`265`	`264`	`void RGBController_EVGAGPUv3::DeviceUpdateLEDs()`
`@@ -286,20 +285,20 @@ void RGBController_EVGAGPUv3::DeviceUpdateLEDs()`
`286`	`285`	`zone_config.colors[i] = modes[active_mode].colors[i];`
`287`	`286`	`}`
`288`	`287`	`}`
`289`		`- //LOG_TRACE("[%s] Updating LED %1d", evga->evgaGPUName, zone_idx);`
`290`		`- evga->SetZone(zoneIndexMap[zone_idx], modes[active_mode].value, zone_config);`
	`288`	`+ //LOG_TRACE("[%s] Updating LED %1d", controller->evgaGPUName, zone_idx);`
	`289`	`+ controller->SetZone(zoneIndexMap[zone_idx], modes[active_mode].value, zone_config);`
`291`	`290`	`}`
`292`	`291`	`}`
`293`	`292`
`294`	`293`	`void RGBController_EVGAGPUv3::UpdateZoneLEDs(int /zone/)`
`295`	`294`	`{`
`296`		`- //LOG_TRACE("[%s] Updating zone %1d", evga->evgaGPUName, zone);`
	`295`	`+ //LOG_TRACE("[%s] Updating zone %1d", controller->evgaGPUName, zone);`
`297`	`296`	`DeviceUpdateLEDs();`
`298`	`297`	`}`
`299`	`298`
`300`	`299`	`void RGBController_EVGAGPUv3::UpdateSingleLED(int /led/)`
`301`	`300`	`{`
`302`		`- //LOG_TRACE("[%s] Updating single LED %1d", evga->evgaGPUName, led);`
	`301`	`+ //LOG_TRACE("[%s] Updating single LED %1d", controller->evgaGPUName, led);`
`303`	`302`	`DeviceUpdateLEDs();`
`304`	`303`	`}`
`305`	`304`
`@@ -308,15 +307,15 @@ void RGBController_EVGAGPUv3::DeviceUpdateMode()`
`308`	`307`	`/* Update all zone modes in a loop, each one with a packet to be use with per zone control`
`309`	`308`	`for(uint8_t zone = 0; zone < 4; zone++)`
`310`	`309`	`{`
`311`		`- evga->SetZoneMode(zone, modes[active_mode].value);`
	`310`	`+ controller->SetZoneMode(zone, modes[active_mode].value);`
`312`	`311`	`}`
`313`	`312`	`*/`
`314`		`- //LOG_TRACE("[%s] Updating to mode %1d", evga->evgaGPUName, modes[active_mode].value);`
	`313`	`+ //LOG_TRACE("[%s] Updating to mode %1d", controller->evgaGPUName, modes[active_mode].value);`
`315`	`314`	`DeviceUpdateLEDs();`
`316`		`- evga->SetAllModes(modes[active_mode].value, modes[active_mode].value, modes[active_mode].value,modes[active_mode].value, true); //Set all zones to the same mode`
	`315`	`+ controller->SetAllModes(modes[active_mode].value, modes[active_mode].value, modes[active_mode].value,modes[active_mode].value, true); //Set all zones to the same mode`
`317`	`316`	`}`
`318`	`317`
`319`	`318`	`void RGBController_EVGAGPUv3::DeviceSaveMode()`
`320`	`319`	`{`
`321`		`- evga->SaveConfig();`
	`320`	`+ controller->SaveConfig();`
`322`	`321`	`}`