diff --git a/Controllers/ManliGPUController/ManliGPUController.cpp b/Controllers/ManliGPUController/ManliGPUController.cpp new file mode 100644 index 000000000..8f04aeb43 --- /dev/null +++ b/Controllers/ManliGPUController/ManliGPUController.cpp @@ -0,0 +1,125 @@ +/*---------------------------------------------------------*\ +| ManliGPUController.cpp | +| | +| Driver for Manli GPU RGB controllers | +| | +| Based on ZotacV2GPUController | +| Adapted for Manli RTX 4090 Gallardo | +| | +| This file is part of the OpenRGB project | +| SPDX-License-Identifier: GPL-2.0-or-later | +\*---------------------------------------------------------*/ + +#include "ManliGPUController.h" + +ManliGPUController::ManliGPUController(i2c_smbus_interface* bus, u8 dev, std::string dev_name) +{ + this->bus = bus; + this->dev = dev; + this->name = dev_name; + + if(dev) + { + ReadVersion(); + } +} + +ManliGPUController::~ManliGPUController() +{ +} + +std::string ManliGPUController::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 ManliGPUController::GetName() +{ + return(name); +} + +std::string ManliGPUController::GetVersion() +{ + return(version); +} + +bool ManliGPUController::ReadVersion() +{ + u8 data_pkt[] = { MANLI_GPU_REG_RGB, 0xF1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; + if(bus->i2c_write_block(dev, sizeof(data_pkt), data_pkt) < 0) + { + return false; + } + + u8 rdata_pkt[I2C_SMBUS_BLOCK_MAX] = { 0x00 }; + int rdata_len = sizeof(rdata_pkt); + if(bus->i2c_read_block(dev, &rdata_len, rdata_pkt) < 0) + { + return false; + } + + version = std::string((char*)rdata_pkt); + return true; +} + +bool ManliGPUController::TurnOnOff(bool on) +{ + ManliGPUZone zoneConfig; + return SendCommand(on, zoneConfig); +} + +bool ManliGPUController::SetMode(ManliGPUZone zoneConfig) +{ + return SendCommand(true, zoneConfig); +} + +bool ManliGPUController::SendCommand(bool on, ManliGPUZone zoneConfig) +{ + /*---------------------------------------------------------*\ + | Color Cycle: Uses breathing mode (0x01) with flag 0x07 | + | This cycles through colors with brightness and speed | + \*---------------------------------------------------------*/ + if(zoneConfig.mode == MANLI_GPU_MODE_COLOR_CYCLE) + { + u8 data_pkt[30] = { 0x00 }; + data_pkt[0] = on ? (u8)0x01 : (u8)0x00; + data_pkt[6] = 0x01; // mode = breathing + data_pkt[7] = 0x00; // R + data_pkt[8] = 0x00; // G + data_pkt[9] = 0x00; // B + data_pkt[10] = (u8)zoneConfig.speed; + data_pkt[11] = (u8)zoneConfig.brightness; + data_pkt[13] = 0x07; // color cycle flag + + if(bus->i2c_smbus_write_i2c_block_data(dev, MANLI_GPU_REG_RGB, sizeof(data_pkt), data_pkt) < 0) + { + return false; + } + return true; + } + /*---------------------------------------------------------*\ + | Standard modes (Static, Breathing, Wave, Strobing, Rainbow)| + \*---------------------------------------------------------*/ + else + { + u8 data_pkt[30] = { 0x00 }; + data_pkt[0] = on ? (u8)0x01 : (u8)0x00; + data_pkt[6] = (u8)zoneConfig.mode; + data_pkt[7] = (u8)RGBGetRValue(zoneConfig.color1); + data_pkt[8] = (u8)RGBGetGValue(zoneConfig.color1); + data_pkt[9] = (u8)RGBGetBValue(zoneConfig.color1); + data_pkt[10] = (u8)zoneConfig.speed; + data_pkt[11] = (u8)zoneConfig.brightness; + + if(bus->i2c_smbus_write_i2c_block_data(dev, MANLI_GPU_REG_RGB, sizeof(data_pkt), data_pkt) < 0) + { + return false; + } + return true; + } +} diff --git a/Controllers/ManliGPUController/ManliGPUController.h b/Controllers/ManliGPUController/ManliGPUController.h new file mode 100644 index 000000000..276082b85 --- /dev/null +++ b/Controllers/ManliGPUController/ManliGPUController.h @@ -0,0 +1,70 @@ +/*---------------------------------------------------------*\ +| ManliGPUController.h | +| | +| Driver for Manli GPU RGB controllers | +| | +| Based on ZotacV2GPUController | +| Adapted for Manli RTX 4090 Gallardo | +| | +| This file is part of the OpenRGB project | +| SPDX-License-Identifier: GPL-2.0-or-later | +\*---------------------------------------------------------*/ + +#pragma once + +#include +#include "i2c_smbus.h" +#include "RGBController.h" + +enum +{ + MANLI_GPU_REG_RGB = 0xA0, +}; + +enum +{ + MANLI_GPU_MODE_STATIC = 0x00, // Static color + MANLI_GPU_MODE_BREATHING = 0x01, // Breathing effect + MANLI_GPU_MODE_WAVE = 0x02, // Wave effect (no brightness - HW limitation) + MANLI_GPU_MODE_STROBING = 0x03, // Strobing effect + MANLI_GPU_MODE_RAINBOW = 0x08, // Rainbow effect (no brightness - HW limitation) + MANLI_GPU_MODE_COLOR_CYCLE = 0x10, // Color Cycle (breathing + flag 0x07) +}; + +struct ManliGPUConfig +{ + int numberOfZones = 0; + bool supportsExternalLEDStrip = false; +}; + +struct ManliGPUZone +{ + int mode = 0; + RGBColor color1 = ToRGBColor(0, 0, 0); + unsigned int speed = 0; + unsigned int brightness = 0; +}; + +class ManliGPUController +{ +public: + ManliGPUController(i2c_smbus_interface* bus, u8 dev, std::string dev_name); + ~ManliGPUController(); + + std::string GetDeviceLocation(); + std::string GetName(); + std::string GetVersion(); + + bool TurnOnOff(bool on); + bool SetMode(ManliGPUZone zoneConfig); + +private: + i2c_smbus_interface* bus; + u8 dev; + std::string name; + std::string version; + + bool ReadVersion(); + bool SendCommand(bool on, ManliGPUZone zoneConfig); +}; + diff --git a/Controllers/ManliGPUController/ManliGPUControllerDetect.cpp b/Controllers/ManliGPUController/ManliGPUControllerDetect.cpp new file mode 100644 index 000000000..413a5935d --- /dev/null +++ b/Controllers/ManliGPUController/ManliGPUControllerDetect.cpp @@ -0,0 +1,61 @@ +/*---------------------------------------------------------*\ +| ManliGPUControllerDetect.cpp | +| | +| Detector for Manli GPU | +| | +| Based on ZotacV2GPUControllerDetect | +| Adapted for Manli RTX 4090 Gallardo | +| | +| This file is part of the OpenRGB project | +| SPDX-License-Identifier: GPL-2.0-or-later | +\*---------------------------------------------------------*/ + +#include "Detector.h" +#include "ManliGPUController.h" +#include "RGBController_ManliGPU.h" +#include "i2c_smbus.h" +#include "pci_ids.h" +#include "LogManager.h" + +/******************************************************************************************\ +* * +* DetectManliGPUControllers * +* * +* Detect Manli GPU RGB controllers on the enumerated I2C busses * +* at address 0x49. * +* * +* bus - pointer to i2c_smbus_interface where RGB device is connected * +* dev - I2C address of RGB device * +* * +\******************************************************************************************/ + +void DetectManliGPUControllers(i2c_smbus_interface* bus, u8 i2c_addr, const std::string& name) +{ + u8 data_pkt[] = { MANLI_GPU_REG_RGB, 0xF1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; + if(bus->i2c_write_block(i2c_addr, sizeof(data_pkt), data_pkt) < 0) + { + return; + } + + u8 rdata_pkt[I2C_SMBUS_BLOCK_MAX] = { 0x00 }; + int rdata_len = sizeof(rdata_pkt); + + if(bus->i2c_read_block(i2c_addr, &rdata_len, rdata_pkt) >= 0) + { + ManliGPUController* controller = new ManliGPUController(bus, i2c_addr, name); + RGBController_ManliGPU* rgb_controller = new RGBController_ManliGPU(controller); + + if(rgb_controller->config.numberOfZones > 0) + { + ResourceManager::get()->RegisterRGBController(rgb_controller); + } + else + { + LOG_ERROR("[%s] RGB controller not registered - invalid zone count: %d", name.c_str(), rgb_controller->config.numberOfZones); + delete rgb_controller; + } + } +} + +REGISTER_I2C_PCI_DETECTOR("MANLI GeForce RTX 4090 Gallardo", DetectManliGPUControllers, NVIDIA_VEN, NVIDIA_RTX4090_DEV, NVIDIA_SUB_VEN, MANLI_RTX4090_GALLARDO_SUB_DEV, 0x49); + diff --git a/Controllers/ManliGPUController/RGBController_ManliGPU.cpp b/Controllers/ManliGPUController/RGBController_ManliGPU.cpp new file mode 100644 index 000000000..84f5b7066 --- /dev/null +++ b/Controllers/ManliGPUController/RGBController_ManliGPU.cpp @@ -0,0 +1,201 @@ +/*---------------------------------------------------------*\ +| RGBController_ManliGPU.cpp | +| | +| RGBController for Manli GPU | +| | +| Based on RGBController_ZotacV2GPU | +| Adapted for Manli RTX 4090 Gallardo | +| | +| This file is part of the OpenRGB project | +| SPDX-License-Identifier: GPL-2.0-or-later | +\*---------------------------------------------------------*/ + +#include +#include "RGBController_ManliGPU.h" + +std::map MANLI_GPU_CONFIG = +{ + { "N675M-1018", { 1, false } }, // MANLI GeForce RTX 4090 Gallardo +}; + +/**------------------------------------------------------------------*\ + @name Manli GPU + @category GPU + @type I2C + @save :robot: + @direct :x: + @effects :white_check_mark: + @detectors DetectManliGPUControllers + @comment + Manli GPU RGB controllers use I2C communication at address 0x49. + Supported modes: Static, Breathing, Wave, Strobing, Rainbow, Color Cycle. +\*-------------------------------------------------------------------*/ + +RGBController_ManliGPU::RGBController_ManliGPU(ManliGPUController* controller_ptr) +{ + controller = controller_ptr; + + name = controller->GetName(); + vendor = "MANLI"; + description = "MANLI RGB GPU Device (" + controller->GetVersion() + ")"; + location = controller->GetDeviceLocation(); + type = DEVICE_TYPE_GPU; + + if(MANLI_GPU_CONFIG.count(controller->GetVersion()) > 0) + { + config = MANLI_GPU_CONFIG.at(controller->GetVersion()); + } + else + { + config = { 0, false }; + } + + version += std::to_string(config.numberOfZones) + " zones"; + + mode STATIC; + STATIC.name = "Static"; + STATIC.value = MANLI_GPU_MODE_STATIC; + STATIC.flags = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; + STATIC.brightness_min = 0; + STATIC.brightness_max = 100; + STATIC.brightness = 100; + STATIC.color_mode = MODE_COLORS_MODE_SPECIFIC; + STATIC.colors_min = 1; + STATIC.colors_max = 1; + STATIC.colors.resize(1); + STATIC.colors[0] = ToRGBColor(0, 0, 255); + modes.push_back(STATIC); + + mode BREATHING; + BREATHING.name = "Breathing"; + BREATHING.value = MANLI_GPU_MODE_BREATHING; + BREATHING.flags = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; + BREATHING.brightness_min = 0; + BREATHING.brightness_max = 100; + BREATHING.brightness = 100; + BREATHING.speed_min = 0; + BREATHING.speed_max = 100; + BREATHING.speed = 50; + BREATHING.color_mode = MODE_COLORS_MODE_SPECIFIC; + BREATHING.colors_min = 1; + BREATHING.colors_max = 1; + BREATHING.colors.resize(1); + BREATHING.colors[0] = ToRGBColor(0, 0, 255); + modes.push_back(BREATHING); + + mode WAVE; + WAVE.name = "Wave"; + WAVE.value = MANLI_GPU_MODE_WAVE; + WAVE.flags = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_SPEED; // No brightness - HW limitation + WAVE.speed_min = 0; + WAVE.speed_max = 100; + WAVE.speed = 50; + WAVE.color_mode = MODE_COLORS_NONE; + modes.push_back(WAVE); + + mode STROBING; + STROBING.name = "Strobing"; + STROBING.value = MANLI_GPU_MODE_STROBING; + STROBING.flags = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; + STROBING.brightness_min = 0; + STROBING.brightness_max = 100; + STROBING.brightness = 100; + STROBING.speed_min = 0; + STROBING.speed_max = 100; + STROBING.speed = 50; + STROBING.color_mode = MODE_COLORS_MODE_SPECIFIC; + STROBING.colors_min = 1; + STROBING.colors_max = 1; + STROBING.colors.resize(1); + STROBING.colors[0] = ToRGBColor(0, 0, 255); + modes.push_back(STROBING); + + mode RAINBOW; + RAINBOW.name = "Rainbow"; + RAINBOW.value = MANLI_GPU_MODE_RAINBOW; + RAINBOW.flags = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_SPEED; + RAINBOW.speed_min = 0; + RAINBOW.speed_max = 100; + RAINBOW.speed = 50; + RAINBOW.color_mode = MODE_COLORS_NONE; + modes.push_back(RAINBOW); + + mode COLOR_CYCLE; + COLOR_CYCLE.name = "Color Cycle"; + COLOR_CYCLE.value = MANLI_GPU_MODE_COLOR_CYCLE; + COLOR_CYCLE.flags = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED; + COLOR_CYCLE.brightness_min = 0; + COLOR_CYCLE.brightness_max = 100; + COLOR_CYCLE.brightness = 100; + COLOR_CYCLE.speed_min = 0; + COLOR_CYCLE.speed_max = 100; + COLOR_CYCLE.speed = 50; + COLOR_CYCLE.color_mode = MODE_COLORS_NONE; + modes.push_back(COLOR_CYCLE); + + SetupZones(); +} + +RGBController_ManliGPU::~RGBController_ManliGPU() +{ + delete controller; +} + +void RGBController_ManliGPU::SetupZones() +{ + led new_led; + new_led.name = "GPU LED"; + leds.push_back(new_led); + + zone new_zone; + new_zone.name = "GPU Zone"; + new_zone.type = ZONE_TYPE_SINGLE; + new_zone.leds_min = 1; + new_zone.leds_max = 1; + new_zone.leds_count = 1; + new_zone.matrix_map = NULL; + zones.push_back(new_zone); + + SetupColors(); +} + +void RGBController_ManliGPU::ResizeZone(int /*zone*/, int /*new_size*/) +{ + /*---------------------------------------------------------*\ + | This device does not support resizing zones | + \*---------------------------------------------------------*/ +} + +void RGBController_ManliGPU::DeviceUpdateLEDs() +{ + DeviceUpdateMode(); +} + +void RGBController_ManliGPU::UpdateZoneLEDs(int /*zone*/) +{ + DeviceUpdateMode(); +} + +void RGBController_ManliGPU::UpdateSingleLED(int /*led*/) +{ + DeviceUpdateMode(); +} + +void RGBController_ManliGPU::DeviceUpdateMode() +{ + ManliGPUZone zoneConfig; + zoneConfig.mode = modes[active_mode].value; + zoneConfig.speed = modes[active_mode].speed; + zoneConfig.brightness = modes[active_mode].brightness; + + if(modes[active_mode].colors.size() >= 1) + { + zoneConfig.color1 = modes[active_mode].colors[0]; + } + else + { + zoneConfig.color1 = ToRGBColor(0, 0, 0); + } + + controller->SetMode(zoneConfig); +} diff --git a/Controllers/ManliGPUController/RGBController_ManliGPU.h b/Controllers/ManliGPUController/RGBController_ManliGPU.h new file mode 100644 index 000000000..61435f5b1 --- /dev/null +++ b/Controllers/ManliGPUController/RGBController_ManliGPU.h @@ -0,0 +1,39 @@ +/*---------------------------------------------------------*\ +| RGBController_ManliGPU.h | +| | +| RGBController for Manli GPU | +| | +| Based on RGBController_ZotacV2GPU | +| Adapted for Manli RTX 4090 Gallardo | +| | +| This file is part of the OpenRGB project | +| SPDX-License-Identifier: GPL-2.0-or-later | +\*---------------------------------------------------------*/ + +#pragma once + +#include "RGBController.h" +#include "ManliGPUController.h" + +class RGBController_ManliGPU : public RGBController +{ +public: + RGBController_ManliGPU(ManliGPUController* controller_ptr); + ~RGBController_ManliGPU(); + + void SetupZones(); + + void ResizeZone(int zone, int new_size); + + void DeviceUpdateLEDs(); + void UpdateZoneLEDs(int zone); + void UpdateSingleLED(int led); + + void DeviceUpdateMode(); + + ManliGPUConfig config; + +private: + ManliGPUController* controller; +}; + diff --git a/pci_ids/pci_ids.h b/pci_ids/pci_ids.h index 978c35095..9f0cb1517 100644 --- a/pci_ids/pci_ids.h +++ b/pci_ids/pci_ids.h @@ -970,6 +970,7 @@ | Manli Sub-Device IDs | \*-----------------------------------------------------*/ #define MANLI_RTX3080TI_GALLARDO_SUB_DEV 0x2612 +#define MANLI_RTX4090_GALLARDO_SUB_DEV 0x167C /*---------------------------------------------------------*\ | PCI ID Macros |