From 224f59450e3fde4f5b0a72f682874987074a34df Mon Sep 17 00:00:00 2001 From: xyz Date: Tue, 2 Jun 2020 17:00:27 +0200 Subject: [PATCH] Add support for MSI RTX 2080S Gaming X Trio --- .../MSIGPUController/MSIGPUController.cpp | 74 +++++ .../MSIGPUController/MSIGPUController.h | 79 +++++ .../MSIGPUControllerDetect.cpp | 73 +++++ OpenRGB.cpp | 82 +++++ OpenRGB.pro | 8 +- RGBController/RGBController_MSIGPU.cpp | 309 ++++++++++++++++++ RGBController/RGBController_MSIGPU.h | 33 ++ i2c_smbus/i2c_smbus.cpp | 11 +- i2c_smbus/i2c_smbus.h | 6 + 9 files changed, 671 insertions(+), 4 deletions(-) create mode 100644 Controllers/MSIGPUController/MSIGPUController.cpp create mode 100644 Controllers/MSIGPUController/MSIGPUController.h create mode 100644 Controllers/MSIGPUController/MSIGPUControllerDetect.cpp create mode 100644 RGBController/RGBController_MSIGPU.cpp create mode 100644 RGBController/RGBController_MSIGPU.h diff --git a/Controllers/MSIGPUController/MSIGPUController.cpp b/Controllers/MSIGPUController/MSIGPUController.cpp new file mode 100644 index 00000000..e24153ad --- /dev/null +++ b/Controllers/MSIGPUController/MSIGPUController.cpp @@ -0,0 +1,74 @@ +/*-----------------------------------------*\ +| MSIGPUController.cpp | +| | +| Driver for MSI GPUs | +| | +\*-----------------------------------------*/ + +#include "MSIGPUController.h" +#include + +MSIGPUController::MSIGPUController(i2c_smbus_interface* bus) +{ + this->bus = bus; + this->dev = 0x68; + + strcpy(device_name, "MSI RTX GPU"); +} + +MSIGPUController::~MSIGPUController() +{ + +} + +std::string MSIGPUController::GetDeviceName() +{ + return(device_name); +} + +std::string MSIGPUController::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(return_string); +} + +void MSIGPUController::SetRGB1(unsigned char red, unsigned char green, unsigned char blue) +{ + MSIGPURegisterWrite(MSI_GPU_REG_R1, red); + MSIGPURegisterWrite(MSI_GPU_REG_G1, green); + MSIGPURegisterWrite(MSI_GPU_REG_B1, blue); +} + +void MSIGPUController::SetRGB2(unsigned char red, unsigned char green, unsigned char blue) +{ + MSIGPURegisterWrite(MSI_GPU_REG_R2, red); + MSIGPURegisterWrite(MSI_GPU_REG_G2, green); + MSIGPURegisterWrite(MSI_GPU_REG_B2, blue); +} + +void MSIGPUController::SetRGB3(unsigned char red, unsigned char green, unsigned char blue) +{ + MSIGPURegisterWrite(MSI_GPU_REG_R3, red); + MSIGPURegisterWrite(MSI_GPU_REG_G3, green); + MSIGPURegisterWrite(MSI_GPU_REG_B3, blue); +} + +void MSIGPUController::SetMode(unsigned char mode) +{ + MSIGPURegisterWrite(MSI_GPU_REG_MODE, mode); + MSIGPURegisterWrite(MSI_GPU_REG_APPLY, 0x01); +} + +unsigned char MSIGPUController::MSIGPURegisterRead(unsigned char reg) +{ + return(bus->i2c_smbus_read_byte_data(dev, reg)); +} + +void MSIGPUController::MSIGPURegisterWrite(unsigned char reg, unsigned char val) +{ + bus->i2c_smbus_write_byte_data(dev, reg, val); +} diff --git a/Controllers/MSIGPUController/MSIGPUController.h b/Controllers/MSIGPUController/MSIGPUController.h new file mode 100644 index 00000000..e4f4cd7a --- /dev/null +++ b/Controllers/MSIGPUController/MSIGPUController.h @@ -0,0 +1,79 @@ +/*-----------------------------------------*\ +| MSIGPUController.h | +| | +| Definitions for MSI GPUs | +| | +\*-----------------------------------------*/ + +#include +#include "i2c_smbus.h" + +#pragma once + +typedef unsigned char msi_gpu_dev_id; + +enum +{ + MSI_GPU_REG_BRIGHTNESS = 0x36, /* MSI GPU Brightness Register */ + MSI_GPU_REG_SPEED = 0x38, /* MSI GPU Speed Register */ + MSI_GPU_REG_UNKNOWN = 0x26, /* MSI GPU Unknown Register */ + MSI_GPU_REG_R1 = 0x30, /* MSI GPU R1 Register */ + MSI_GPU_REG_G1 = 0x31, /* MSI GPU G1 Register */ + MSI_GPU_REG_B1 = 0x32, /* MSI GPU B1 Register */ + MSI_GPU_REG_R2 = 0x27, /* MSI GPU R2 Register */ + MSI_GPU_REG_G2 = 0x28, /* MSI GPU G2 Register */ + MSI_GPU_REG_B2 = 0x29, /* MSI GPU B2 Register */ + MSI_GPU_REG_R3 = 0x2a, /* MSI GPU R3 Register */ + MSI_GPU_REG_G3 = 0x2b, /* MSI GPU G3 Register */ + MSI_GPU_REG_B3 = 0x2c, /* MSI GPU B3 Register */ + MSI_GPU_REG_MODE = 0x22, /* MSI GPU Mode Selection Register */ + MSI_GPU_REG_APPLY = 0x3f, /* MSI GPU Apply Changes Register */ +}; + +enum +{ + MSI_GPU_MODE_OFF = 0x01, /* OFF mode */ + MSI_GPU_MODE_RAINBOW = 0x08, /* Rainbow effect mode */ + MSI_GPU_MODE_STATIC = 0x13, /* Static color mode */ + MSI_GPU_MODE_RAINDROP = 0x1a, /* Raindrop effect mode */ + MSI_GPU_MODE_MAGIC = 0x07, /* Magic effect mode */ + MSI_GPU_MODE_PATROLLING = 0x05, /* Patrolling effect mode */ + MSI_GPU_MODE_STREAMING = 0x06, /* Streaming effect mode */ + MSI_GPU_MODE_LIGHTNING = 0x15, /* Lightning effect mode */ + MSI_GPU_MODE_WAVE = 0x1f, /* Wave effect mode */ + MSI_GPU_MODE_METEOR = 0x16, /* Meteor effect mode */ + MSI_GPU_MODE_STACK = 0x0d, /* Stack effect mode */ + MSI_GPU_MODE_RHYTHM = 0x0b, /* Rhythm effect mode */ + MSI_GPU_MODE_FLOWING = 0x09, /* Flowing effect mode */ + MSI_GPU_MODE_WHIRLING = 0x0f, /* Whirling effect mode */ + MSI_GPU_MODE_TWISTING = 0x11, /* Twisting effect mode */ + MSI_GPU_MODE_LAMINATING = 0x1d, /* Laminating effect mode */ + MSI_GPU_MODE_FADEIN = 0x14, /* Fadein effect mode */ + MSI_GPU_MODE_BREATHING = 0x04, /* Breathing effect mode */ + MSI_GPU_MODE_FLASHING = 0x02, /* Flashing effect mode */ + MSI_GPU_MODE_DOUBLEFLASHING = 0x03, /* Doubleflashing effect mode */ +}; + +class MSIGPUController +{ +public: + MSIGPUController(i2c_smbus_interface* bus); + ~MSIGPUController(); + + std::string GetDeviceName(); + std::string GetDeviceLocation(); + + void SetRGB1(unsigned char red, unsigned char green, unsigned char blue); + void SetRGB2(unsigned char red, unsigned char green, unsigned char blue); + void SetRGB3(unsigned char red, unsigned char green, unsigned char blue); + + void SetMode(unsigned char mode); + + unsigned char MSIGPURegisterRead(unsigned char reg); + void MSIGPURegisterWrite(unsigned char reg, unsigned char val); + +private: + char device_name[16]; + i2c_smbus_interface * bus; + msi_gpu_dev_id dev; +}; diff --git a/Controllers/MSIGPUController/MSIGPUControllerDetect.cpp b/Controllers/MSIGPUController/MSIGPUControllerDetect.cpp new file mode 100644 index 00000000..3b9d13dd --- /dev/null +++ b/Controllers/MSIGPUController/MSIGPUControllerDetect.cpp @@ -0,0 +1,73 @@ +/*-----------------------------------------*\ +| MSIGPUControllerDetect.cpp | +| | +| Driver for MSI GPUs | +| | +\*-----------------------------------------*/ + +#include "MSIGPUController.h" +#include "RGBController.h" +#include "RGBController_MSIGPU.h" +#include "i2c_smbus.h" +#include +#include +#include + +/******************************************************************************************\ +* * +* IsMSIGPUController * +* * +* Compare PCI IDs * +* * +\******************************************************************************************/ + +bool IsMSIGPUController(i2c_smbus_interface* bus) +{ + bool pass = false; + + if (bus->port_id != 1) + return(pass); + + // MSI RTX 2080S Gaming X Trio + if (bus->pci_device == 0x1e81 && + bus->pci_vendor == 0x10de && + bus->pci_subsystem_device == 0xc724 && + bus->pci_subsystem_vendor == 0x1462) { + pass = true; + } + + // MSI RTX 2070S Gaming X Trio + if (bus->pci_device == 0x1e84 && + bus->pci_vendor == 0x10de && + bus->pci_subsystem_device == 0xc726 && + bus->pci_subsystem_vendor == 0x1462) { + pass = true; + } + + return(pass); +} /* IsMSIGPUController() */ + + +/******************************************************************************************\ +* * +* DetectMSIGPUControllers * +* * +* Detect MSI GPU controllers on the enumerated I2C busses. * +* * +\******************************************************************************************/ + +void DetectMSIGPUControllers(std::vector &busses, std::vector &rgb_controllers) +{ + MSIGPUController* new_msi_gpu; + RGBController_MSIGPU* new_controller; + + for (unsigned int bus = 0; bus < busses.size(); bus++) + { + if (IsMSIGPUController(busses[bus])) + { + new_msi_gpu = new MSIGPUController(busses[bus]); + new_controller = new RGBController_MSIGPU(new_msi_gpu); + rgb_controllers.push_back(new_controller); + } + } +} /* DetectMSIGPUControllers() */ diff --git a/OpenRGB.cpp b/OpenRGB.cpp index 3e5a7544..d0c82975 100644 --- a/OpenRGB.cpp +++ b/OpenRGB.cpp @@ -260,6 +260,11 @@ void DetectI2CBusses() char driver_path[512]; struct dirent * ent; int test_fd; + char path[1024]; + char buff[100]; + unsigned short pci_device, pci_vendor, pci_subsystem_device, pci_subsystem_vendor; + unsigned short port_id; + bool info; // Start looking for I2C adapters in /sys/bus/i2c/devices/ strcpy(driver_path, "/sys/bus/i2c/devices/"); @@ -291,6 +296,74 @@ void DetectI2CBusses() close(test_fd); + // For now, only get PCI information from nVidia GPUs + // PCI IDs are not currently obtained from the Nouveau driver + // and GPUs using PCI IDs for detection will not work with it. + if (sscanf(device_string, "NVIDIA i2c adapter %hu at", &port_id) == 1) + { + info = true; + + // Get PCI Device + snprintf(path, sizeof(path), "%s%s%s", driver_path, ent->d_name, "/device/device"); + test_fd = open(path, O_RDONLY); + if (test_fd < 0) + { + ent = readdir(dir); + continue; + } + memset(buff, 0x00, sizeof(buff)); + read(test_fd, buff, sizeof(buff)); + buff[strlen(buff) - 1] = 0x00; + pci_device = strtoul(buff, NULL, 16); + close(test_fd); + + // Get PCI Vendor + snprintf(path, sizeof(path), "%s%s%s", driver_path, ent->d_name, "/device/vendor"); + test_fd = open(path, O_RDONLY); + if (test_fd < 0) + { + ent = readdir(dir); + continue; + } + memset(buff, 0x00, sizeof(buff)); + read(test_fd, buff, sizeof(buff)); + buff[strlen(buff) - 1] = 0x00; + pci_vendor = strtoul(buff, NULL, 16); + close(test_fd); + + // Get PCI Subsystem Device + snprintf(path, sizeof(path), "%s%s%s", driver_path, ent->d_name, "/device/subsystem_device"); + test_fd = open(path, O_RDONLY); + if (test_fd < 0) + { + ent = readdir(dir); + continue; + } + memset(buff, 0x00, sizeof(buff)); + read(test_fd, buff, sizeof(buff)); + buff[strlen(buff) - 1] = 0x00; + pci_subsystem_device = strtoul(buff, NULL, 16); + close(test_fd); + + // Get PCI Subsystem Vendor + snprintf(path, sizeof(path), "%s%s%s", driver_path, ent->d_name, "/device/subsystem_vendor"); + test_fd = open(path, O_RDONLY); + if (test_fd < 0) + { + ent = readdir(dir); + continue; + } + memset(buff, 0x00, sizeof(buff)); + read(test_fd, buff, sizeof(buff)); + buff[strlen(buff) - 1] = 0x00; + pci_subsystem_vendor = strtoul(buff, NULL, 16); + close(test_fd); + } + else + { + info = false; + } + strcpy(device_string, "/dev/"); strcat(device_string, ent->d_name); test_fd = open(device_string, O_RDWR); @@ -304,6 +377,13 @@ void DetectI2CBusses() bus = new i2c_smbus_linux(); strcpy(bus->device_name, device_string); bus->handle = test_fd; + if (info) { + bus->pci_device = pci_device; + bus->pci_vendor = pci_vendor; + bus->pci_subsystem_device = pci_subsystem_device; + bus->pci_subsystem_vendor = pci_subsystem_vendor; + bus->port_id = port_id; + } busses.push_back(bus); } } @@ -327,6 +407,7 @@ void DetectRGBFusionControllers(std::vector& busses, std:: void DetectRGBFusionGPUControllers(std::vector& busses, std::vector& rgb_controllers); void DetectRGBFusion2SMBusControllers(std::vector& busses, std::vector& rgb_controllers); void DetectRGBFusion2DRAMControllers(std::vector& busses, std::vector& rgb_controllers); +void DetectMSIGPUControllers(std::vector& busses, std::vector& rgb_controllers); void DetectMSIMysticLightControllers(std::vector &rgb_controllers); void DetectMSIRGBControllers(std::vector &rgb_controllers); void DetectAuraUSBControllers(std::vector &rgb_controllers); @@ -374,6 +455,7 @@ void DetectRGBControllers(void) DetectPatriotViperControllers(busses, rgb_controllers); DetectPolychromeControllers(busses, rgb_controllers); DetectRGBFusionGPUControllers(busses, rgb_controllers); + DetectMSIGPUControllers(busses, rgb_controllers); //TODO: Implement better detection before enabling these controllers //DetectRGBFusion2SMBusControllers(busses, rgb_controllers); diff --git a/OpenRGB.pro b/OpenRGB.pro index 843ea5bc..76a90aba 100644 --- a/OpenRGB.pro +++ b/OpenRGB.pro @@ -66,6 +66,7 @@ INCLUDEPATH += \ Controllers/LEDStripController/ \ Controllers/LogitechController/ \ Controllers/MSI3ZoneController/ \ + Controllers/MSIGPUController/ \ Controllers/MSIMysticLightController/ \ Controllers/MSIRGBController/ \ Controllers/NZXTHue2Controller/ \ @@ -85,7 +86,6 @@ INCLUDEPATH += \ qt/ HEADERS += \ - dependencies/dmiinfo.h \ dependencies/ColorWheel/ColorWheel.h \ NetworkClient.h \ NetworkProtocol.h \ @@ -131,6 +131,7 @@ HEADERS += \ Controllers/LogitechController/LogitechG403Controller.h \ Controllers/LogitechController/LogitechG810Controller.h \ Controllers/MSI3ZoneController/MSI3ZoneController.h \ + Controllers/MSIGPUController/MSIGPUController.h \ Controllers/MSIMysticLightController/MSIMysticLightController.h \ Controllers/MSIRGBController/MSIRGBController.h \ Controllers/NZXTHue2Controller/NZXTHue2Controller.h \ @@ -174,6 +175,8 @@ HEADERS += \ RGBController/RGBController_LogitechG403.h \ RGBController/RGBController_LogitechG810.h \ RGBController/RGBController_MSI3Zone.h \ + RGBController/RGBController_MSIGPU.h \ + RGBController/RGBController_MSIGPU.h \ RGBController/RGBController_MSIMysticLight.h \ RGBController/RGBController_MSIRGB.h \ RGBController/RGBController_Network.h \ @@ -263,6 +266,8 @@ SOURCES += \ Controllers/LogitechController/LogitechG810Controller.cpp \ Controllers/MSI3ZoneController/MSI3ZoneController.cpp \ Controllers/MSI3ZoneController/MSI3ZoneControllerDetect.cpp \ + Controllers/MSIGPUController/MSIGPUController.cpp \ + Controllers/MSIGPUController/MSIGPUControllerDetect.cpp \ Controllers/MSIMysticLightController/MSIMysticLightController.cpp \ Controllers/MSIMysticLightController/MSIMysticLightControllerDetect.cpp \ Controllers/MSIRGBController/MSIRGBController.cpp \ @@ -322,6 +327,7 @@ SOURCES += \ RGBController/RGBController_LogitechG403.cpp \ RGBController/RGBController_LogitechG810.cpp \ RGBController/RGBController_MSI3Zone.cpp \ + RGBController/RGBController_MSIGPU.cpp \ RGBController/RGBController_MSIMysticLight.cpp \ RGBController/RGBController_MSIRGB.cpp \ RGBController/RGBController_Network.cpp \ diff --git a/RGBController/RGBController_MSIGPU.cpp b/RGBController/RGBController_MSIGPU.cpp new file mode 100644 index 00000000..dadd472e --- /dev/null +++ b/RGBController/RGBController_MSIGPU.cpp @@ -0,0 +1,309 @@ +/*-----------------------------------------*\ +| RGBController_MSIGPU.h | +| | +| Generic RGB Interface for MSI GPU | +| | +\*-----------------------------------------*/ + +#include "RGBController_MSIGPU.h" + +static unsigned char brightness_values[] = { 0x14, 0x28, 0x3c, 0x50, 0x64 }; +static unsigned char speed_values[] = { 0x04, 0x02, 0x01 }; + +int RGBController_MSIGPU::GetDeviceMode() +{ + int dev_mode = msi_gpu->MSIGPURegisterRead(MSI_GPU_REG_MODE); + + for(std::size_t mode = 0; mode < modes.size(); mode++) + { + if (modes[mode].value == dev_mode) + { + active_mode = mode; + break; + } + } + + return(active_mode); +} + +RGBController_MSIGPU::RGBController_MSIGPU(MSIGPUController * msi_gpu_ptr) +{ + msi_gpu = msi_gpu_ptr; + + name = msi_gpu->GetDeviceName(); + type = DEVICE_TYPE_GPU; + description = "MSI RTX Gaming X Trio GPU Device"; + version = "0.00.1"; + location = msi_gpu->GetDeviceLocation(); + + mode Off; + Off.name = "Off"; + Off.value = MSI_GPU_MODE_OFF; + Off.flags = 0; + Off.color_mode = MODE_COLORS_NONE; + modes.push_back(Off); + + mode Rainbow; + Rainbow.name = "Rainbow"; + Rainbow.value = MSI_GPU_MODE_RAINBOW; + Rainbow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS; + Rainbow.speed_min = 0; + Rainbow.speed_max = 2; + Rainbow.color_mode = MODE_COLORS_NONE; + modes.push_back(Rainbow); + + mode Static; + Static.name = "Static"; + Static.value = MSI_GPU_MODE_STATIC; + Static.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS; + Static.color_mode = MODE_COLORS_PER_LED; + modes.push_back(Static); + + mode Raindrop; + Raindrop.name = "Raindrop"; + Raindrop.value = MSI_GPU_MODE_RAINDROP; + Raindrop.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR; + Raindrop.speed_min = 0; + Raindrop.speed_max = 2; + Raindrop.color_mode = MODE_COLORS_PER_LED; + modes.push_back(Raindrop); + + mode Magic; + Magic.name = "Magic"; + Magic.value = MSI_GPU_MODE_MAGIC; + Magic.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS; + Magic.speed_min = 0; + Magic.speed_max = 2; + Magic.color_mode = MODE_COLORS_NONE; + modes.push_back(Magic); + + mode Patrolling; + Patrolling.name = "Patrolling"; + Patrolling.value = MSI_GPU_MODE_PATROLLING; + Patrolling.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR; + Patrolling.speed_min = 0; + Patrolling.speed_max = 2; + Patrolling.color_mode = MODE_COLORS_PER_LED; + modes.push_back(Patrolling); + + mode Streaming; + Streaming.name = "Streaming"; + Streaming.value = MSI_GPU_MODE_STREAMING; + Streaming.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS; + Streaming.speed_min = 0; + Streaming.speed_max = 2; + Streaming.color_mode = MODE_COLORS_NONE; + modes.push_back(Streaming); + + mode Lightning; + Lightning.name = "Lightning"; + Lightning.value = MSI_GPU_MODE_LIGHTNING; + Lightning.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS; + Lightning.speed_min = 0; + Lightning.speed_max = 2; + Lightning.color_mode = MODE_COLORS_NONE; + modes.push_back(Lightning); + + mode Wave; + Wave.name = "Wave"; + Wave.value = MSI_GPU_MODE_WAVE; + Wave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR; + Wave.speed_min = 0; + Wave.speed_max = 2; + Wave.color_mode = MODE_COLORS_PER_LED; + modes.push_back(Wave); + + mode Meteor; + Meteor.name = "Meteor"; + Meteor.value = MSI_GPU_MODE_METEOR; + Meteor.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR; + Meteor.speed_min = 0; + Meteor.speed_max = 2; + Meteor.color_mode = MODE_COLORS_PER_LED; + modes.push_back(Meteor); + + mode Stack; + Stack.name = "Stack"; + Stack.value = MSI_GPU_MODE_STACK; + Stack.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR; + Stack.speed_min = 0; + Stack.speed_max = 2; + Stack.color_mode = MODE_COLORS_PER_LED; + modes.push_back(Stack); + + mode Rhythm; + Rhythm.name = "Rhythm"; + Rhythm.value = MSI_GPU_MODE_RHYTHM; + Rhythm.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR; + Rhythm.speed_min = 0; + Rhythm.speed_max = 2; + Rhythm.color_mode = MODE_COLORS_PER_LED; + modes.push_back(Rhythm); + + mode Flowing; + Flowing.name = "Flowing"; + Flowing.value = MSI_GPU_MODE_FLOWING; + Flowing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR; + Flowing.speed_min = 0; + Flowing.speed_max = 2; + Flowing.color_mode = MODE_COLORS_PER_LED; + modes.push_back(Flowing); + + mode Whirling; + Whirling.name = "Whirling"; + Whirling.value = MSI_GPU_MODE_WHIRLING; + Whirling.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR; + Whirling.speed_min = 0; + Whirling.speed_max = 2; + Whirling.color_mode = MODE_COLORS_PER_LED; + modes.push_back(Whirling); + + mode Twisting; + Twisting.name = "Twisting"; + Twisting.value = MSI_GPU_MODE_TWISTING; + Twisting.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR; + Twisting.speed_min = 0; + Twisting.speed_max = 2; + Twisting.color_mode = MODE_COLORS_PER_LED; + modes.push_back(Twisting); + + mode Laminating; + Laminating.name = "Laminating"; + Laminating.value = MSI_GPU_MODE_LAMINATING; + Laminating.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR; + Laminating.speed_min = 0; + Laminating.speed_max = 2; + Laminating.color_mode = MODE_COLORS_PER_LED; + modes.push_back(Laminating); + + mode Fadein; + Fadein.name = "Fadein"; + Fadein.value = MSI_GPU_MODE_FADEIN; + Fadein.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR; + Fadein.speed_min = 0; + Fadein.speed_max = 2; + Fadein.color_mode = MODE_COLORS_PER_LED; + modes.push_back(Fadein); + + mode Breathing; + Breathing.name = "Breathing"; + Breathing.value = MSI_GPU_MODE_BREATHING; + Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR; + Breathing.speed_min = 0; + Breathing.speed_max = 2; + Breathing.color_mode = MODE_COLORS_PER_LED; + modes.push_back(Breathing); + + mode flashing; + flashing.name = "Flashing"; + flashing.value = MSI_GPU_MODE_FLASHING; + flashing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR; + flashing.speed_min = 0; + flashing.speed_max = 2; + flashing.color_mode = MODE_COLORS_PER_LED; + modes.push_back(flashing); + + mode doubleflashing; + doubleflashing.name = "Doubleflashing"; + doubleflashing.value = MSI_GPU_MODE_DOUBLEFLASHING; + doubleflashing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR; + doubleflashing.speed_min = 0; + doubleflashing.speed_max = 2; + doubleflashing.color_mode = MODE_COLORS_PER_LED; + modes.push_back(doubleflashing); + + SetupZones(); + + active_mode = GetDeviceMode(); +} + +void RGBController_MSIGPU::SetupZones() +{ + /*---------------------------------------------------------*\ + | Set up zone | + \*---------------------------------------------------------*/ + zone msi_gpu_zone; + msi_gpu_zone.name = "GPU"; + msi_gpu_zone.type = ZONE_TYPE_SINGLE; + msi_gpu_zone.leds_min = 1; + msi_gpu_zone.leds_max = 1; + msi_gpu_zone.leds_count = 3; + msi_gpu_zone.matrix_map = NULL; + zones.push_back(msi_gpu_zone); + + /*---------------------------------------------------------*\ + | Set up LED | + \*---------------------------------------------------------*/ + led led1; + led1.name = "Color 1"; + leds.push_back(led1); + led led2; + led2.name = "Color 2"; + leds.push_back(led2); + led led3; + led3.name = "Color 3"; + leds.push_back(led3); + + SetupColors(); + + /*---------------------------------------------------------*\ + | Initialize color | + \*---------------------------------------------------------*/ + unsigned char r1 = msi_gpu->MSIGPURegisterRead(MSI_GPU_REG_R1); + unsigned char g1 = msi_gpu->MSIGPURegisterRead(MSI_GPU_REG_G1); + unsigned char b1 = msi_gpu->MSIGPURegisterRead(MSI_GPU_REG_B1); + unsigned char r2 = msi_gpu->MSIGPURegisterRead(MSI_GPU_REG_R2); + unsigned char g2 = msi_gpu->MSIGPURegisterRead(MSI_GPU_REG_G2); + unsigned char b2 = msi_gpu->MSIGPURegisterRead(MSI_GPU_REG_B2); + unsigned char r3 = msi_gpu->MSIGPURegisterRead(MSI_GPU_REG_R3); + unsigned char g3 = msi_gpu->MSIGPURegisterRead(MSI_GPU_REG_G3); + unsigned char b3 = msi_gpu->MSIGPURegisterRead(MSI_GPU_REG_B3); + + colors[0] = ToRGBColor(r1, g1, b1); + colors[1] = ToRGBColor(r2, g2, b2); + colors[2] = ToRGBColor(r3, g3, b3); +} + +void RGBController_MSIGPU::ResizeZone(int /*zone*/, int /*new_size*/) +{ + /*---------------------------------------------------------*\ + | This device does not support resizing zones | + \*---------------------------------------------------------*/ +} + +void RGBController_MSIGPU::DeviceUpdateLEDs() +{ + if (modes[active_mode].flags & MODE_FLAG_HAS_BRIGHTNESS) + msi_gpu->MSIGPURegisterWrite(MSI_GPU_REG_BRIGHTNESS, brightness_values[4]); // how to access brightness value? + if (modes[active_mode].flags & MODE_FLAG_HAS_SPEED) + msi_gpu->MSIGPURegisterWrite(MSI_GPU_REG_SPEED, speed_values[modes[active_mode].speed]); + msi_gpu->MSIGPURegisterWrite(MSI_GPU_REG_UNKNOWN, 0x00); + if (modes[active_mode].flags & MODE_FLAG_HAS_PER_LED_COLOR) { + if (modes[active_mode].value == MSI_GPU_MODE_FADEIN) { + msi_gpu->SetRGB2(RGBGetRValue(colors[1]), RGBGetGValue(colors[1]), RGBGetBValue(colors[1])); + msi_gpu->SetRGB3(RGBGetRValue(colors[2]), RGBGetGValue(colors[2]), RGBGetBValue(colors[2])); + } else + msi_gpu->SetRGB1(RGBGetRValue(colors[0]), RGBGetGValue(colors[0]), RGBGetBValue(colors[0])); + } + msi_gpu->SetMode(modes[active_mode].value); +} + +void RGBController_MSIGPU::UpdateZoneLEDs(int /*zone*/) +{ + DeviceUpdateLEDs(); +} + +void RGBController_MSIGPU::UpdateSingleLED(int /*led*/) +{ + DeviceUpdateLEDs(); +} + +void RGBController_MSIGPU::SetCustomMode() +{ + active_mode = 0; +} + +void RGBController_MSIGPU::UpdateMode() +{ + DeviceUpdateLEDs(); +} diff --git a/RGBController/RGBController_MSIGPU.h b/RGBController/RGBController_MSIGPU.h new file mode 100644 index 00000000..4559ea62 --- /dev/null +++ b/RGBController/RGBController_MSIGPU.h @@ -0,0 +1,33 @@ +/*-----------------------------------------*\ +| RGBController_MSIGPU.h | +| | +| Generic RGB Interface for MSI GPU | +| | +\*-----------------------------------------*/ + +#pragma once + +#include "RGBController.h" +#include "MSIGPUController.h" + +class RGBController_MSIGPU : public RGBController +{ +public: + RGBController_MSIGPU(MSIGPUController* msi_gpu_ptr); + + void SetupZones(); + + void ResizeZone(int zone, int new_size); + + void DeviceUpdateLEDs(); + void UpdateZoneLEDs(int zone); + void UpdateSingleLED(int led); + + void SetCustomMode(); + void UpdateMode(); + +private: + MSIGPUController* msi_gpu; + + int GetDeviceMode(); +}; diff --git a/i2c_smbus/i2c_smbus.cpp b/i2c_smbus/i2c_smbus.cpp index 4e603f60..5499638e 100644 --- a/i2c_smbus/i2c_smbus.cpp +++ b/i2c_smbus/i2c_smbus.cpp @@ -17,9 +17,14 @@ i2c_smbus_interface::i2c_smbus_interface() { - i2c_smbus_start = false; - i2c_smbus_done = false; - i2c_smbus_thread = new std::thread(&i2c_smbus_interface::i2c_smbus_thread_function, this); + i2c_smbus_start = false; + i2c_smbus_done = false; + this->port_id = -1; + this->pci_device = -1; + this->pci_vendor = -1; + this->pci_subsystem_device = -1; + this->pci_subsystem_vendor = -1; + i2c_smbus_thread = new std::thread(&i2c_smbus_interface::i2c_smbus_thread_function, this); } s32 i2c_smbus_interface::i2c_smbus_write_quick(u8 addr, u8 value) diff --git a/i2c_smbus/i2c_smbus.h b/i2c_smbus/i2c_smbus.h index 77708460..c55bd82a 100644 --- a/i2c_smbus/i2c_smbus.h +++ b/i2c_smbus/i2c_smbus.h @@ -59,6 +59,12 @@ class i2c_smbus_interface public: char device_name[512]; + int port_id; + int pci_device; + int pci_vendor; + int pci_subsystem_device; + int pci_subsystem_vendor; + i2c_smbus_interface(); virtual ~i2c_smbus_interface() = default;