Publish LumaOps source

2026-09-03 01:18:36 +02:00
commit 7f1c0e5f71
2363 changed files with 501543 additions and 0 deletions
@@ -0,0 +1,119 @@
+/*---------------------------------------------------------*\
+| GalaxGPUv2Controller.cpp                                  |
+|                                                           |
+|   RGBController for Galax GPUs (Xtreme Tuner)             |
+|                                                           |
+|   Daniel Stuart  (daniel.stuart14)            26 may 2025 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include <cstring>
+#include "GalaxGPUv2Controller.h"
+
+GalaxGPUv2Controller::GalaxGPUv2Controller(i2c_smbus_interface* bus, galax_gpu_dev_id dev, std::string dev_name)
+{
+    this->bus   = bus;
+    this->dev   = dev;
+    this->name  = dev_name;
+}
+
+GalaxGPUv2Controller::~GalaxGPUv2Controller()
+{
+
+}
+
+std::string GalaxGPUv2Controller::GetDeviceLocation()
+{
+    std::string return_string(bus->device_name);
+    char addr[5];
+    snprintf(addr, 5, "0x%02X", dev);
+    return_string.append(", address ");
+    return_string.append(addr);
+    return("I2C: " + return_string);
+}
+
+std::string GalaxGPUv2Controller::GetDeviceName()
+{
+    return(name);
+}
+
+unsigned char GalaxGPUv2Controller::GetLEDRed()
+{
+    return(GalaxGPURegisterRead(GALAX_V2_RED_REGISTER));
+}
+
+unsigned char GalaxGPUv2Controller::GetLEDGreen()
+{
+    return(GalaxGPURegisterRead(GALAX_V2_GREEN_REGISTER));
+}
+
+unsigned char GalaxGPUv2Controller::GetLEDBlue()
+{
+    return(GalaxGPURegisterRead(GALAX_V2_BLUE_REGISTER));
+}
+
+unsigned char GalaxGPUv2Controller::GetMode()
+{
+    return GalaxGPURegisterRead(GALAX_V2_MODE_REGISTER);
+}
+
+unsigned char GalaxGPUv2Controller::GetSync()
+{
+    return GalaxGPURegisterRead(GALAX_V2_SYNC_REGISTER);
+}
+
+unsigned char GalaxGPUv2Controller::GetSpeed()
+{
+    return GalaxGPURegisterRead(GALAX_V2_SPEED_REGISTER_A);
+}
+
+unsigned char GalaxGPUv2Controller::GetBrightness()
+{
+    return GalaxGPURegisterRead(GALAX_V2_BRIGHTNESS_REGISTER);
+}
+
+void GalaxGPUv2Controller::SetLEDColors(unsigned char red, unsigned char green, unsigned char blue)
+{
+    GalaxGPURegisterWrite(GALAX_V2_RED_REGISTER, red);
+    GalaxGPURegisterWrite(GALAX_V2_GREEN_REGISTER, green);
+    GalaxGPURegisterWrite(GALAX_V2_BLUE_REGISTER, blue);
+}
+
+void GalaxGPUv2Controller::SetMode(unsigned char value)
+{
+    GalaxGPURegisterWrite(GALAX_V2_MODE_REGISTER, value);
+}
+
+void GalaxGPUv2Controller::SetSync(unsigned char value)
+{
+    GalaxGPURegisterWrite(GALAX_V2_SYNC_REGISTER, value);
+}
+
+void GalaxGPUv2Controller::SetSpeed(unsigned char value)
+{
+    // We just duplicate the value to both speed registers
+    GalaxGPURegisterWrite(GALAX_V2_SPEED_REGISTER_A, value);
+    GalaxGPURegisterWrite(GALAX_V2_SPEED_REGISTER_B, value);
+}
+
+void GalaxGPUv2Controller::SetBrightness(unsigned char value)
+{
+    GalaxGPURegisterWrite(GALAX_V2_BRIGHTNESS_REGISTER, value);
+}
+
+void GalaxGPUv2Controller::SaveMode()
+{
+    GalaxGPURegisterWrite(GALAX_V2_SAVE_REGISTER, GALAX_V2_SAVE_VALUE);
+}
+
+unsigned char GalaxGPUv2Controller::GalaxGPURegisterRead(unsigned char reg)
+{
+    return(bus->i2c_smbus_read_byte_data(dev, reg));
+}
+
+void GalaxGPUv2Controller::GalaxGPURegisterWrite(unsigned char reg, unsigned char val)
+{
+    bus->i2c_smbus_write_byte_data(dev, reg, val);
+}
@@ -0,0 +1,82 @@
+/*---------------------------------------------------------*\
+| GalaxGPUv2Controller.h                                    |
+|                                                           |
+|   RGBController for Galax GPUs (Xtreme Tuner)             |
+|                                                           |
+|   Daniel Stuart  (daniel.stuart14)            26 may 2025 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include <string>
+#include "i2c_smbus.h"
+
+typedef unsigned char galax_gpu_dev_id;
+
+enum
+{
+    GALAX_V2_RED_REGISTER                      = 0x02, /* Red Register */
+    GALAX_V2_GREEN_REGISTER                    = 0x03, /* Green Register */
+    GALAX_V2_BLUE_REGISTER                     = 0x04, /* Blue Register */
+    GALAX_V2_SPEED_REGISTER_A                  = 0x21, /* Speed Register A */
+    GALAX_V2_SPEED_REGISTER_B                  = 0x22, /* Speed Register B */
+    GALAX_V2_SYNC_REGISTER                     = 0x27, /* Sync Register */
+    GALAX_V2_BRIGHTNESS_REGISTER               = 0x2D, /* Brightness Register */
+    GALAX_V2_MODE_REGISTER                     = 0x30, /* Mode Register */
+    GALAX_V2_SAVE_REGISTER                     = 0x40, /* Save Register */
+};
+
+enum
+{
+    GALAX_V2_MODE_STATIC_VALUE                 = 0x01, /* Static Mode */
+    GALAX_V2_MODE_BREATHING_VALUE              = 0x02, /* Breathing Mode */
+    GALAX_V2_MODE_RAINBOW_VALUE                = 0x16, /* Rainbow Mode */
+    GALAX_V2_MODE_OFF_VALUE                    = 0x19, /* Off Mode */
+};
+
+enum
+{
+    GALAX_V2_SYNC_OFF                          = 0x00, /* Sync Off */
+    GALAX_V2_SYNC_ON                           = 0x01, /* Sync On */
+};
+
+enum
+{
+    GALAX_V2_SAVE_VALUE                        = 0x5A, /* Save Value */
+};
+
+class GalaxGPUv2Controller
+{
+public:
+    GalaxGPUv2Controller(i2c_smbus_interface* bus, galax_gpu_dev_id, std::string dev_name);
+    ~GalaxGPUv2Controller();
+
+    std::string   GetDeviceLocation();
+    std::string   GetDeviceName();
+    unsigned char GetLEDRed();
+    unsigned char GetLEDGreen();
+    unsigned char GetLEDBlue();
+    unsigned char GetMode();
+    unsigned char GetSync();
+    unsigned char GetSpeed();
+    unsigned char GetBrightness();
+    void          SetLEDColors(unsigned char red, unsigned char green, unsigned char blue);
+    void          SetMode(unsigned char value);
+    void          SetSync(unsigned char value);
+    void          SetSpeed(unsigned char value);
+    void          SetBrightness(unsigned char value);
+    void          SaveMode();
+
+    unsigned char GalaxGPURegisterRead(unsigned char reg);
+    void          GalaxGPURegisterWrite(unsigned char reg, unsigned char val);
+
+    bool          direct = false;                                                // Temporary solution to check if we are in "Direct" mode
+
+private:
+    i2c_smbus_interface *   bus;
+    galax_gpu_dev_id        dev;
+    std::string             name;
+};
@@ -0,0 +1,221 @@
+/*---------------------------------------------------------*\
+| RGBController_GalaxGPUv2.cpp                              |
+|                                                           |
+|   RGBController for Galax GPUs (Xtreme Tuner)             |
+|                                                           |
+|   Daniel Stuart  (daniel.stuart14)            26 may 2025 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "RGBController_GalaxGPUv2.h"
+
+int RGBController_GalaxGPUv2::GetDeviceMode()
+{
+    int modereg = controller->GetMode();
+    int syncreg = controller->GetSync();
+
+    int cur_mode = 0; // Static mode by default
+
+    if (syncreg == GALAX_V2_SYNC_ON)
+    {
+        cur_mode = 3; // External Sync mode
+    }
+    else
+    {
+        switch (modereg)
+        {
+            case GALAX_V2_MODE_BREATHING_VALUE:
+                cur_mode = 1;
+                break;
+
+            case GALAX_V2_MODE_RAINBOW_VALUE:
+                cur_mode = 2;
+                break;
+
+            case GALAX_V2_MODE_OFF_VALUE:
+                cur_mode = 4; // Off mode
+                break;
+        }
+    }
+
+    return(cur_mode);
+}
+
+/**------------------------------------------------------------------*\
+    @name Galax GPU v2
+    @category GPU
+    @type I2C
+    @save :x:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectGalaxGPUv2Controllers
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_GalaxGPUv2::RGBController_GalaxGPUv2(GalaxGPUv2Controller* controller_ptr)
+{
+    controller                      = controller_ptr;
+
+    name                            = controller->GetDeviceName();
+    vendor                          = "GALAX";
+    type                            = DEVICE_TYPE_GPU;
+    description                     = "GALAX RTX 40+ GPU";
+    location                        = controller->GetDeviceLocation();
+
+    mode Direct;
+    Direct.name                     = "Direct";
+    Direct.value                    = 0;
+    Direct.brightness_min           = 0x01;
+    Direct.brightness_max           = 0x03;
+    Direct.flags                    = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
+    Direct.color_mode               = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    mode Breathing;
+    Breathing.name                  = "Breathing";
+    Breathing.value                 = 1;
+    Breathing.brightness_min        = 0x01;
+    Breathing.brightness_max        = 0x03;
+    Breathing.speed_min             = 0x00;
+    Breathing.speed_max             = 0x09;
+    Breathing.flags                 = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
+    Breathing.color_mode            = MODE_COLORS_PER_LED;
+    modes.push_back(Breathing);
+
+    mode Rainbow;
+    Rainbow.name                    = "Rainbow";
+    Rainbow.value                   = 2;
+    Rainbow.flags                   = 0;
+    Rainbow.brightness_min          = 0x01;
+    Rainbow.brightness_max          = 0x03;
+    Rainbow.speed_min               = 0x00;
+    Rainbow.speed_max               = 0x09;
+    Rainbow.flags                   = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
+    Rainbow.color_mode              = MODE_COLORS_NONE;
+    modes.push_back(Rainbow);
+
+    mode Sync;
+    Sync.name                       = "External Sync";
+    Sync.value                      = 3;
+    Sync.flags                      = MODE_FLAG_MANUAL_SAVE;
+    Sync.color_mode                 = MODE_COLORS_NONE;
+    modes.push_back(Sync);
+
+    mode Off;
+    Off.name                        = "Off";
+    Off.value                       = 4;
+    Off.flags                       = MODE_FLAG_MANUAL_SAVE;
+    Off.color_mode                  = MODE_COLORS_NONE;
+    modes.push_back(Off);
+
+    SetupZones();
+
+    active_mode                     = GetDeviceMode();
+    modes[active_mode].brightness   = controller->GetBrightness();
+    modes[active_mode].speed        = controller->GetSpeed();
+}
+
+RGBController_GalaxGPUv2::~RGBController_GalaxGPUv2()
+{
+    delete controller;
+}
+
+void RGBController_GalaxGPUv2::SetupZones()
+{
+    /*---------------------------------------------------------*\
+    | Set up zone                                               |
+    \*---------------------------------------------------------*/
+    zone galax_gpu_zone;
+    galax_gpu_zone.name         = "GPU";
+    galax_gpu_zone.type         = ZONE_TYPE_SINGLE;
+    galax_gpu_zone.leds_min     = 1;
+    galax_gpu_zone.leds_max     = 1;
+    galax_gpu_zone.leds_count   = 1;
+    galax_gpu_zone.matrix_map   = NULL;
+    zones.push_back(galax_gpu_zone);
+
+    /*---------------------------------------------------------*\
+    | Set up LED                                                |
+    \*---------------------------------------------------------*/
+    led galax_gpu_led;
+    galax_gpu_led.name          = "GPU";
+    leds.push_back(galax_gpu_led);
+
+    SetupColors();
+
+    /*---------------------------------------------------------*\
+    | Initialize color                                          |
+    \*---------------------------------------------------------*/
+    unsigned char red = controller->GetLEDRed();
+    unsigned char grn = controller->GetLEDGreen();
+    unsigned char blu = controller->GetLEDBlue();
+
+    colors[0] = ToRGBColor(red, grn, blu);
+}
+
+void RGBController_GalaxGPUv2::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_GalaxGPUv2::DeviceUpdateLEDs()
+{
+    for(std::size_t led = 0; led < colors.size(); led++)
+    {
+        unsigned char red = RGBGetRValue(colors[led]);
+        unsigned char grn = RGBGetGValue(colors[led]);
+        unsigned char blu = RGBGetBValue(colors[led]);
+
+        controller->SetLEDColors(red, grn, blu);
+    }
+}
+
+void RGBController_GalaxGPUv2::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_GalaxGPUv2::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_GalaxGPUv2::DeviceUpdateMode()
+{
+    unsigned char mode_value = GALAX_V2_MODE_STATIC_VALUE; // Default to static mode
+    unsigned char sync_value = GALAX_V2_SYNC_OFF; // Default to sync off
+
+    switch(modes[active_mode].value)
+    {
+        case 1:
+            mode_value = GALAX_V2_MODE_BREATHING_VALUE;
+            break;
+
+        case 2:
+            mode_value = GALAX_V2_MODE_RAINBOW_VALUE;
+            break;
+
+        case 3:
+            sync_value = GALAX_V2_SYNC_ON; // Enable sync
+            break;
+
+        case 4:
+            mode_value = GALAX_V2_MODE_OFF_VALUE; // Off mode
+            break;
+    }
+
+    controller->SetSync(sync_value);
+    controller->SetMode(mode_value);
+    controller->SetSpeed(modes[active_mode].speed);
+    controller->SetBrightness(modes[active_mode].brightness);
+}
+
+void RGBController_GalaxGPUv2::DeviceSaveMode()
+{
+    DeviceUpdateMode();
+    controller->SaveMode();
+}
@@ -0,0 +1,38 @@
+/*---------------------------------------------------------*\
+| RGBController_GalaxGPUv2.h                                |
+|                                                           |
+|   RGBController for Galax GPUs (Xtreme Tuner)             |
+|                                                           |
+|   Daniel Stuart  (daniel.stuart14)            26 may 2025 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "GalaxGPUv2Controller.h"
+
+class RGBController_GalaxGPUv2 : public RGBController
+{
+public:
+    RGBController_GalaxGPUv2(GalaxGPUv2Controller* controller_ptr);
+    ~RGBController_GalaxGPUv2();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+    void        DeviceSaveMode();
+
+private:
+    GalaxGPUv2Controller* controller;
+
+    int        GetDeviceMode();
+};