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

SapphireGPUController: Implement Nitro Glow V3

Browse source 
Commit amended for code style and to squash commits by Adam Honse <calcprogrammer1@gmail.com>
This commit is contained in:
K900 2021-02-01 20:49:55 +03:00 • committed by Adam Honse
parent 50219f231a
commit f7756c003f
15 changed files with 573 additions and 162 deletions
Download patch file Download diff file Expand all files Collapse all files

30
Controllers/SapphireGPUController/RGBController_SapphireGPU.cpp → Controllers/SapphireGPUController/RGBController_SapphireNitroGlowV1.cpp
View file

@ -1,21 +1,21 @@
/*-----------------------------------------*\
| RGBController_RGBFusionGPU.cpp |
| RGBController_SapphireNitroGlowV1.cpp |
| |
| Generic RGB Interface for OpenRGB |
| Gigabyte RGB Fusion GPU Driver |
| Sapphire Nitro Glow V1 GPU Driver |
| |
| Adam Honse (CalcProgrammer1) 2/23/2020 |
| Adam Honse (CalcProgrammer1) 7/15/2020 |
\*-----------------------------------------*/
#include "RGBController_SapphireGPU.h"
#include "RGBController_SapphireNitroGlowV1.h"
RGBController_SapphireGPU::RGBController_SapphireGPU(SapphireGPUController* sapphire_ptr)
RGBController_SapphireNitroGlowV1::RGBController_SapphireNitroGlowV1(SapphireNitroGlowV1Controller* sapphire_ptr)
{
sapphire = sapphire_ptr;
name = "Sapphire GPU";
name = "Sapphire Nitro Glow V1 Device";
vendor = "Sapphire";
description = "Sapphire GPU";
description = "Sapphire Nitro Glow V1 Device";
location = sapphire->GetDeviceLocation();
type = DEVICE_TYPE_GPU;
@ -40,7 +40,7 @@ RGBController_SapphireGPU::RGBController_SapphireGPU(SapphireGPUController* sapp
active_mode = 0;
}
void RGBController_SapphireGPU::SetupZones()
void RGBController_SapphireNitroGlowV1::SetupZones()
{
/*---------------------------------------------------------*\
| This device only has one LED, so create a single zone and |
@ -67,14 +67,14 @@ void RGBController_SapphireGPU::SetupZones()
SetupColors();
}
void RGBController_SapphireGPU::ResizeZone(int /*zone*/, int /*new_size*/)
void RGBController_SapphireNitroGlowV1::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_SapphireGPU::DeviceUpdateLEDs()
void RGBController_SapphireNitroGlowV1::DeviceUpdateLEDs()
{
RGBColor color = colors[0];
unsigned char red = RGBGetRValue(color);
@ -84,22 +84,22 @@ void RGBController_SapphireGPU::DeviceUpdateLEDs()
sapphire->SetColor(red, grn, blu);
}
void RGBController_SapphireGPU::UpdateZoneLEDs(int /*zone*/)
void RGBController_SapphireNitroGlowV1::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_SapphireGPU::UpdateSingleLED(int /*led*/)
void RGBController_SapphireNitroGlowV1::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_SapphireGPU::SetCustomMode()
void RGBController_SapphireNitroGlowV1::SetCustomMode()
{
active_mode = 0;
}
void RGBController_SapphireGPU::DeviceUpdateMode()
void RGBController_SapphireNitroGlowV1::DeviceUpdateMode()
{
sapphire->SetMode((unsigned char)modes[(unsigned int)active_mode].value, (unsigned char)modes[(unsigned int)active_mode].speed);
}
}

14
Controllers/SapphireGPUController/RGBController_SapphireGPU.h → Controllers/SapphireGPUController/RGBController_SapphireNitroGlowV1.h
View file

@ -1,8 +1,8 @@
/*-----------------------------------------*\
| RGBController_SapphireGPU.h |
| RGBController_SapphireNitroGlowV1.h |
| |
| Generic RGB Interface for OpenRGB |
| Sapphire GPU RGB Driver |
| Sapphire Nitro Glow V1 GPU RGB Driver |
| |
| Adam Honse (CalcProgrammer1) 7/15/2020 |
\*-----------------------------------------*/
@ -10,12 +10,12 @@
#pragma once
#include "RGBController.h"
#include "SapphireGPUController.h"
#include "SapphireNitroGlowV1Controller.h"
class RGBController_SapphireGPU : public RGBController
class RGBController_SapphireNitroGlowV1 : public RGBController
{
public:
RGBController_SapphireGPU(SapphireGPUController* sapphire_ptr);
RGBController_SapphireNitroGlowV1(SapphireNitroGlowV1Controller* sapphire_ptr);
void SetupZones();
@ -29,5 +29,5 @@ public:
void DeviceUpdateMode();
private:
SapphireGPUController* sapphire;
};
SapphireNitroGlowV1Controller* sapphire;
};

140
Controllers/SapphireGPUController/RGBController_SapphireNitroGlowV3.cpp Normal file
View file

@ -0,0 +1,140 @@
/*-----------------------------------------*\
| RGBController_SapphireNitroGlowV3.cpp |
| |
| Generic RGB Interface for OpenRGB |
| Sapphire Nitro Glow V3 GPU Driver |
| |
| K900 2/3/2021 |
\*-----------------------------------------*/
#include "RGBController_SapphireNitroGlowV3.h"
RGBController_SapphireNitroGlowV3::RGBController_SapphireNitroGlowV3(SapphireNitroGlowV3Controller* sapphire_ptr)
{
sapphire = sapphire_ptr;
name = "Sapphire Nitro Glow V3 Device";
vendor = "Sapphire";
description = "Sapphire Nitro Glow V3 Device";
location = sapphire->GetDeviceLocation();
type = DEVICE_TYPE_GPU;
mode Static;
Static.name = "Static";
Static.value = SAPPHIRE_NITRO_GLOW_V3_MODE_CUSTOM;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Static.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Static);
mode Rainbow;
Rainbow.name = "Rainbow";
Rainbow.value = SAPPHIRE_NITRO_GLOW_V3_MODE_RAINBOW;
Rainbow.flags = MODE_FLAG_HAS_SPEED;
Rainbow.speed_min = 10;
Rainbow.speed_max = 250;
Rainbow.color_mode = MODE_COLORS_NONE;
modes.push_back(Rainbow);
mode Runway;
Runway.name = "Runway";
Runway.value = SAPPHIRE_NITRO_GLOW_V3_MODE_RUNWAY;
Runway.flags = MODE_FLAG_HAS_SPEED;
Runway.speed_min = 5;
Runway.speed_max = 50;
Runway.color_mode = MODE_COLORS_NONE;
modes.push_back(Runway);
mode ColorCycle;
ColorCycle.name = "Color Cycle";
ColorCycle.value = SAPPHIRE_NITRO_GLOW_V3_MODE_COLOR_CYCLE;
ColorCycle.flags = MODE_FLAG_HAS_SPEED;
ColorCycle.speed_min = 30;
ColorCycle.speed_max = 1;
ColorCycle.color_mode = MODE_COLORS_NONE;
modes.push_back(ColorCycle);
mode Serial;
Serial.name = "Serial";
Serial.value = SAPPHIRE_NITRO_GLOW_V3_MODE_SERIAL;
Serial.flags = MODE_FLAG_HAS_SPEED;
Serial.speed_min = 255;
Serial.speed_max = 5;
Serial.color_mode = MODE_COLORS_NONE;
modes.push_back(Serial);
mode ExternalControl;
ExternalControl.name = "External Control";
ExternalControl.value = SAPPHIRE_NITRO_GLOW_V3_MODE_EXTERNAL_CONTROL;
ExternalControl.flags = 0;
ExternalControl.color_mode = MODE_COLORS_NONE;
modes.push_back(ExternalControl);
SetupZones();
active_mode = 0;
}
void RGBController_SapphireNitroGlowV3::SetupZones()
{
/*---------------------------------------------------------*\
| This device only has one LED, so create a single zone and |
| LED for it |
\*---------------------------------------------------------*/
zone* new_zone = new zone();
led* new_led = new led();
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;
new_led->name = "GPU LED";
/*---------------------------------------------------------*\
| Push the zone and LED on to device vectors |
\*---------------------------------------------------------*/
leds.push_back(*new_led);
zones.push_back(*new_zone);
SetupColors();
}
void RGBController_SapphireNitroGlowV3::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_SapphireNitroGlowV3::DeviceUpdateLEDs()
{
RGBColor color = colors[0];
unsigned char red = RGBGetRValue(color);
unsigned char grn = RGBGetGValue(color);
unsigned char blu = RGBGetBValue(color);
sapphire->SetColor(red, grn, blu);
}
void RGBController_SapphireNitroGlowV3::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_SapphireNitroGlowV3::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_SapphireNitroGlowV3::SetCustomMode()
{
active_mode = 0;
}
void RGBController_SapphireNitroGlowV3::DeviceUpdateMode()
{
sapphire->SetMode((unsigned char)modes[(unsigned int)active_mode].value, (unsigned char)modes[(unsigned int)active_mode].speed);
}

33
Controllers/SapphireGPUController/RGBController_SapphireNitroGlowV3.h Normal file
View file

@ -0,0 +1,33 @@
/*-----------------------------------------*\
| RGBController_SapphireNitroGlowV3.h |
| |
| Generic RGB Interface for OpenRGB |
| Sapphire Nitro Glow V3 GPU RGB Driver |
| |
| K900 2/3/2021 |
\*-----------------------------------------*/
#pragma once
#include "RGBController.h"
#include "SapphireNitroGlowV3Controller.h"
class RGBController_SapphireNitroGlowV3 : public RGBController
{
public:
RGBController_SapphireNitroGlowV3(SapphireNitroGlowV3Controller* sapphire_ptr);
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void DeviceUpdateMode();
private:
SapphireNitroGlowV3Controller* sapphire;
};

58
Controllers/SapphireGPUController/SapphireGPUController.cpp
View file

@ -1,58 +0,0 @@
/*-----------------------------------------*\
| SapphireGPUController.cpp |
| |
| Driver for Sapphire Nitro Glow GPU RGB |
| lighting controller |
| |
| Adam Honse (CalcProgrammer1) 7/15/2020 |
\*-----------------------------------------*/
#include "SapphireGPUController.h"
SapphireGPUController::SapphireGPUController(i2c_smbus_interface* bus, sapphire_dev_id dev)
{
this->bus = bus;
this->dev = dev;
}
SapphireGPUController::~SapphireGPUController()
{
}
std::string SapphireGPUController::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);
}
unsigned char SapphireGPUController::GetRed()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_GPU_REG_RED));
}
unsigned char SapphireGPUController::GetGreen()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_GPU_REG_GREEN));
}
unsigned char SapphireGPUController::GetBlue()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_GPU_REG_BLUE));
}
void SapphireGPUController::SetColor(unsigned char red, unsigned char green, unsigned char blue)
{
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_GPU_REG_RED, red);
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_GPU_REG_GREEN, green);
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_GPU_REG_BLUE, blue);
}
void SapphireGPUController::SetMode(unsigned char mode, unsigned char /*speed*/)
{
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_GPU_REG_MODE, mode);
}

55
Controllers/SapphireGPUController/SapphireGPUController.h
View file

@ -1,55 +0,0 @@
/*-----------------------------------------*\
| SapphireGPUController.h |
| |
| Definitions and types for Sapphire Nitro |
| Glow GPU RGB lighting controller |
| |
| Adam Honse (CalcProgrammer1) 7/15/2020 |
\*-----------------------------------------*/
#include <string>
#include "i2c_smbus.h"
#pragma once
typedef unsigned char sapphire_dev_id;
enum
{
SAPPHIRE_GPU_REG_MODE = 0x00,
SAPPHIRE_GPU_REG_BRIGHTNESS = 0x01,
SAPPHIRE_GPU_REG_RED = 0x03,
SAPPHIRE_GPU_REG_GREEN = 0x04,
SAPPHIRE_GPU_REG_BLUE = 0x05,
};
enum
{
SAPPHIRE_GPU_MODE_SAPPHIRE_BLUE = 0x00,
SAPPHIRE_GPU_MODE_RAINBOW = 0x01,
SAPPHIRE_GPU_MODE_BOARD_TEMPERATURE = 0x02,
SAPPHIRE_GPU_MODE_FAN_SPEED = 0x03,
SAPPHIRE_GPU_MODE_CUSTOM = 0x04,
SAPPHIRE_GPU_MODE_OFF = 0x05,
};
class SapphireGPUController
{
public:
SapphireGPUController(i2c_smbus_interface* bus, sapphire_dev_id dev);
~SapphireGPUController();
std::string GetDeviceLocation();
unsigned char GetRed();
unsigned char GetGreen();
unsigned char GetBlue();
void SetColor(unsigned char red, unsigned char green, unsigned char blue);
void SetMode(unsigned char mode, unsigned char speed);
private:
i2c_smbus_interface* bus;
sapphire_dev_id dev;
};

82
Controllers/SapphireGPUController/SapphireGPUControllerDetect.cpp
View file

@ -1,12 +1,31 @@
#include "Detector.h"
#include "SapphireGPUController.h"
#include "RGBController.h"
#include "RGBController_SapphireGPU.h"
#include "SapphireNitroGlowV1Controller.h"
#include "SapphireNitroGlowV3Controller.h"
#include "RGBController_SapphireNitroGlowV1.h"
#include "RGBController_SapphireNitroGlowV3.h"
#include "i2c_smbus.h"
#include "pci_ids.h"
#include <vector>
#include <stdio.h>
#include <stdlib.h>
/*-----------------------------------------------------*\
| I2C Addresses for Sapphire Nitro Glow RGB |
\*-----------------------------------------------------*/
enum
{
SAPPHIRE_NITRO_GLOW_V1_ADDR = 0x55,
SAPPHIRE_NITRO_GLOW_V3_ADDR = 0x28,
};
/*-----------------------------------------------------*\
| Nitro Glow Versions |
\*-----------------------------------------------------*/
enum
{
SAPPHIRE_NITRO_GLOW_V1,
SAPPHIRE_NITRO_GLOW_V2,
SAPPHIRE_NITRO_GLOW_V3,
};
typedef struct
{
@ -14,6 +33,7 @@ typedef struct
int pci_device;
int pci_subsystem_vendor;
int pci_subsystem_device;
int version;
const char * name;
} gpu_pci_device;
@ -21,7 +41,18 @@ typedef struct
static const gpu_pci_device device_list[] =
{
{ AMD_GPU_VEN, AMD_RX580_DEV, SAPPHIRE_SUB_VEN, SAPPHIRE_RX580_NITRO_PLUS_SUB_DEV, "Sapphire RX580 Nitro+" },
{ AMD_GPU_VEN, AMD_POLARIS_DEV, SAPPHIRE_LEGACY_SUB_VEN, SAPPHIRE_LEGACY_POLARIS_NITRO_PLUS_SUB_DEV, SAPPHIRE_NITRO_GLOW_V1, "RX 470/480 Nitro+" },
{ AMD_GPU_VEN, AMD_POLARIS_DEV, SAPPHIRE_SUB_VEN, SAPPHIRE_POLARIS_NITRO_PLUS_SUB_DEV1, SAPPHIRE_NITRO_GLOW_V1, "RX 570/580/590 Nitro+" },
{ AMD_GPU_VEN, AMD_POLARIS_DEV, SAPPHIRE_SUB_VEN, SAPPHIRE_POLARIS_NITRO_PLUS_SUB_DEV2, SAPPHIRE_NITRO_GLOW_V1, "RX 570/580/590 Nitro+" },
{ AMD_GPU_VEN, AMD_POLARIS20XL_DEV, SAPPHIRE_SUB_VEN, SAPPHIRE_POLARIS_NITRO_PLUS_SUB_DEV1, SAPPHIRE_NITRO_GLOW_V1, "RX 580 Nitro+ (2048SP)" },
{ AMD_GPU_VEN, AMD_VEGA10_DEV, SAPPHIRE_SUB_VEN, SAPPHIRE_VEGA10_NITRO_PLUS_SUB_DEV, SAPPHIRE_NITRO_GLOW_V1, "RX Vega 56/64 Nitro+" },
{ AMD_GPU_VEN, AMD_NAVI10_DEV, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI10_NITRO_PLUS_SUB_DEV1, SAPPHIRE_NITRO_GLOW_V3, "RX 5700 (XT) Nitro+" },
{ AMD_GPU_VEN, AMD_NAVI10_DEV, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI10_NITRO_PLUS_SUB_DEV2, SAPPHIRE_NITRO_GLOW_V3, "RX 5700 XT Nitro+" },
{ AMD_GPU_VEN, AMD_NAVI10_DEV, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI10_NITRO_PLUS_SUB_DEV3, SAPPHIRE_NITRO_GLOW_V3, "RX 5700 XT Nitro+" },
{ AMD_GPU_VEN, AMD_NAVI14_DEV, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI14_NITRO_PLUS_SUB_DEV, SAPPHIRE_NITRO_GLOW_V3, "RX 5500 XT Nitro+" },
{ AMD_GPU_VEN, AMD_NAVI21_DEV, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI21_NITRO_PLUS_SUB_DEV1, SAPPHIRE_NITRO_GLOW_V3, "RX 6800 XT Nitro+ SE" },
{ AMD_GPU_VEN, AMD_NAVI21_DEV, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI21_NITRO_PLUS_SUB_DEV2, SAPPHIRE_NITRO_GLOW_V3, "RX 6800 XT/6900 XT Nitro+" },
{ AMD_GPU_VEN, AMD_NAVI21_DEV, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI21_NITRO_PLUS_SUB_DEV3, SAPPHIRE_NITRO_GLOW_V3, "RX 6800 Nitro+" },
};
/******************************************************************************************\
@ -29,7 +60,7 @@ static const gpu_pci_device device_list[] =
* TestForSapphireGPUController *
* *
* Tests the given address to see if an Sapphire controller exists there. First *
* does a quick write to test for a response *
* does a byte read to test for a response *
* *
\******************************************************************************************/
@ -54,19 +85,13 @@ bool TestForSapphireGPUController(i2c_smbus_interface* bus, unsigned char addres
* *
* DetectSapphireGPUControllers *
* *
* Detect Sapphire GPU controllers on the enumerated I2C busses at address 0x55. *
* *
* bus - pointer to i2c_smbus_interface where Sapphire GPU device is connected *
* dev - I2C address of Sapphire GPU device *
* Detect Sapphire GPU controllers on the enumerated I2C buses. *
* *
\******************************************************************************************/
void DetectSapphireGPUControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers)
void DetectSapphireGPUControllers(std::vector<i2c_smbus_interface *> &busses, std::vector<RGBController *> &rgb_controllers)
{
SapphireGPUController* new_sapphire_gpu;
RGBController_SapphireGPU* new_controller;
for (unsigned int bus = 0; bus < busses.size(); bus++)
for(unsigned int bus = 0; bus < busses.size(); bus++)
{
for(unsigned int dev_idx = 0; dev_idx < GPU_NUM_DEVICES; dev_idx++)
{
@ -75,12 +100,29 @@ void DetectSapphireGPUControllers(std::vector<i2c_smbus_interface*>& busses, std
busses[bus]->pci_subsystem_vendor == device_list[dev_idx].pci_subsystem_vendor &&
busses[bus]->pci_subsystem_device == device_list[dev_idx].pci_subsystem_device)
{
if(TestForSapphireGPUController(busses[bus], 0x55))
RGBController *controller;
switch(device_list[dev_idx].version)
{
new_sapphire_gpu = new SapphireGPUController(busses[bus], 0x55);
new_controller = new RGBController_SapphireGPU(new_sapphire_gpu);
new_controller->name = device_list[dev_idx].name;
rgb_controllers.push_back(new_controller);
case SAPPHIRE_NITRO_GLOW_V1:
if(TestForSapphireGPUController(busses[bus], SAPPHIRE_NITRO_GLOW_V1_ADDR))
{
SapphireNitroGlowV1Controller* new_sapphire_gpu = new SapphireNitroGlowV1Controller(busses[bus], SAPPHIRE_NITRO_GLOW_V1_ADDR);
RGBController_SapphireNitroGlowV1* new_controller = new RGBController_SapphireNitroGlowV1(new_sapphire_gpu);
new_controller->name = device_list[dev_idx].name;
rgb_controllers.push_back(new_controller);
}
break;
case SAPPHIRE_NITRO_GLOW_V3:
if(TestForSapphireGPUController(busses[bus], SAPPHIRE_NITRO_GLOW_V3_ADDR))
{
SapphireNitroGlowV3Controller* new_sapphire_gpu = new SapphireNitroGlowV3Controller(busses[bus], SAPPHIRE_NITRO_GLOW_V3_ADDR);
RGBController_SapphireNitroGlowV3* new_controller = new RGBController_SapphireNitroGlowV3(new_sapphire_gpu);
new_controller->name = device_list[dev_idx].name;
rgb_controllers.push_back(new_controller);
}
break;
}
}
}

58
Controllers/SapphireGPUController/SapphireNitroGlowV1Controller.cpp Normal file
View file

@ -0,0 +1,58 @@
/*-----------------------------------------*\
| SapphireNitroGlowV1Controller.cpp |
| |
| Driver for Sapphire Nitro Glow V1 GPU |
| RGB lighting controller |
| |
| Adam Honse (CalcProgrammer1) 7/15/2020 |
\*-----------------------------------------*/
#include "SapphireNitroGlowV1Controller.h"
SapphireNitroGlowV1Controller::SapphireNitroGlowV1Controller(i2c_smbus_interface* bus, sapphire_dev_id dev)
{
this->bus = bus;
this->dev = dev;
}
SapphireNitroGlowV1Controller::~SapphireNitroGlowV1Controller()
{
}
std::string SapphireNitroGlowV1Controller::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);
}
unsigned char SapphireNitroGlowV1Controller::GetRed()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V1_REG_RED));
}
unsigned char SapphireNitroGlowV1Controller::GetGreen()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V1_REG_GREEN));
}
unsigned char SapphireNitroGlowV1Controller::GetBlue()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V1_REG_BLUE));
}
void SapphireNitroGlowV1Controller::SetColor(unsigned char red, unsigned char green, unsigned char blue)
{
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V1_REG_RED, red);
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V1_REG_GREEN, green);
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V1_REG_BLUE, blue);
}
void SapphireNitroGlowV1Controller::SetMode(unsigned char mode, unsigned char /*speed*/)
{
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V1_REG_MODE, mode);
}

55
Controllers/SapphireGPUController/SapphireNitroGlowV1Controller.h Normal file
View file

@ -0,0 +1,55 @@
/*-----------------------------------------*\
| SapphireNitroGlowV1Controller.h |
| |
| Definitions and types for Sapphire Nitro |
| Glow V1 GPU RGB lighting controller |
| |
| Adam Honse (CalcProgrammer1) 7/15/2020 |
\*-----------------------------------------*/
#include <string>
#include "i2c_smbus.h"
#pragma once
typedef unsigned char sapphire_dev_id;
enum
{
SAPPHIRE_NITRO_GLOW_V1_REG_MODE = 0x00,
SAPPHIRE_NITRO_GLOW_V1_REG_BRIGHTNESS = 0x01,
SAPPHIRE_NITRO_GLOW_V1_REG_RED = 0x03,
SAPPHIRE_NITRO_GLOW_V1_REG_GREEN = 0x04,
SAPPHIRE_NITRO_GLOW_V1_REG_BLUE = 0x05,
};
enum
{
SAPPHIRE_NITRO_GLOW_V1_MODE_SAPPHIRE_BLUE = 0x00,
SAPPHIRE_NITRO_GLOW_V1_MODE_RAINBOW = 0x01,
SAPPHIRE_NITRO_GLOW_V1_MODE_BOARD_TEMPERATURE = 0x02,
SAPPHIRE_NITRO_GLOW_V1_MODE_FAN_SPEED = 0x03,
SAPPHIRE_NITRO_GLOW_V1_MODE_CUSTOM = 0x04,
SAPPHIRE_NITRO_GLOW_V1_MODE_OFF = 0x05,
};
class SapphireNitroGlowV1Controller
{
public:
SapphireNitroGlowV1Controller(i2c_smbus_interface* bus, sapphire_dev_id dev);
~SapphireNitroGlowV1Controller();
std::string GetDeviceLocation();
unsigned char GetRed();
unsigned char GetGreen();
unsigned char GetBlue();
void SetColor(unsigned char red, unsigned char green, unsigned char blue);
void SetMode(unsigned char mode, unsigned char speed);
private:
i2c_smbus_interface* bus;
sapphire_dev_id dev;
};

102
Controllers/SapphireGPUController/SapphireNitroGlowV3Controller.cpp Normal file
View file

@ -0,0 +1,102 @@
/*-----------------------------------------*\
| SapphireNitroGlowV3Controller.cpp |
| |
| Driver for Sapphire Nitro Glow V3 GPU |
| RGB lighting controller |
| |
| K900 2/3/2021 |
\*-----------------------------------------*/
#include "SapphireNitroGlowV3Controller.h"
SapphireNitroGlowV3Controller::SapphireNitroGlowV3Controller(i2c_smbus_interface* bus, sapphire_dev_id dev)
{
this->bus = bus;
this->dev = dev;
}
SapphireNitroGlowV3Controller::~SapphireNitroGlowV3Controller()
{
}
std::string SapphireNitroGlowV3Controller::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);
}
unsigned char SapphireNitroGlowV3Controller::GetRed()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_RED));
}
unsigned char SapphireNitroGlowV3Controller::GetGreen()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_GREEN));
}
unsigned char SapphireNitroGlowV3Controller::GetBlue()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_BLUE));
}
void SapphireNitroGlowV3Controller::SetColor(unsigned char red, unsigned char green, unsigned char blue)
{
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_RED, red);
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_GREEN, green);
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_BLUE, blue);
}
void SapphireNitroGlowV3Controller::SetMode(unsigned char mode, unsigned char speed)
{
switch(mode)
{
case SAPPHIRE_NITRO_GLOW_V3_MODE_RAINBOW:
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_EXTERNAL_CONTROL, 0);
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_RAINBOW_ANIMATION_SPEED, speed);
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_MODE, mode);
break;
case SAPPHIRE_NITRO_GLOW_V3_MODE_RUNWAY:
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_EXTERNAL_CONTROL, 0);
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_RUNWAY_ANIMATION_SPEED, speed);
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_RUNWAY_ANIMATION_REPEAT_COUNT, 5);
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_MODE, mode);
break;
case SAPPHIRE_NITRO_GLOW_V3_MODE_COLOR_CYCLE:
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_EXTERNAL_CONTROL, 0);
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_COLOR_CYCLE_ANIMATION_SPEED, speed);
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_MODE, mode);
break;
case SAPPHIRE_NITRO_GLOW_V3_MODE_SERIAL:
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_EXTERNAL_CONTROL, 0);
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_SERIAL_ANIMATION_SPEED, speed);
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_MODE, mode);
break;
case SAPPHIRE_NITRO_GLOW_V3_MODE_SAPPHIRE_BLUE:
break;
case SAPPHIRE_NITRO_GLOW_V3_MODE_AUDIO_VISUALIZATION:
break;
case SAPPHIRE_NITRO_GLOW_V3_MODE_CUSTOM:
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_EXTERNAL_CONTROL, 0);
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_MODE, mode);
break;
case SAPPHIRE_NITRO_GLOW_V3_MODE_OFF:
break;
case SAPPHIRE_NITRO_GLOW_V3_MODE_EXTERNAL_CONTROL:
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_EXTERNAL_CONTROL, 1);
break;
}
}

65
Controllers/SapphireGPUController/SapphireNitroGlowV3Controller.h Normal file
View file

@ -0,0 +1,65 @@
/*-----------------------------------------*\
| SapphireNitroGlowV3Controller.h |
| |
| Definitions and types for Sapphire Nitro |
| Glow V3 GPU RGB lighting controller |
| |
| K900 2/3/2021 |
\*-----------------------------------------*/
#include <string>
#include "i2c_smbus.h"
#pragma once
typedef unsigned char sapphire_dev_id;
enum
{
SAPPHIRE_NITRO_GLOW_V3_REG_MODE = 0x10,
SAPPHIRE_NITRO_GLOW_V3_REG_EXTERNAL_CONTROL = 0x0F,
SAPPHIRE_NITRO_GLOW_V3_REG_BRIGHTNESS = 0x3E,
SAPPHIRE_NITRO_GLOW_V3_REG_RUNWAY_ANIMATION_SPEED = 0x11,
SAPPHIRE_NITRO_GLOW_V3_REG_RUNWAY_ANIMATION_REPEAT_COUNT = 0x12,
SAPPHIRE_NITRO_GLOW_V3_REG_COLOR_CYCLE_ANIMATION_SPEED = 0x13,
SAPPHIRE_NITRO_GLOW_V3_REG_RAINBOW_ANIMATION_SPEED = 0x15,
SAPPHIRE_NITRO_GLOW_V3_REG_SERIAL_ANIMATION_SPEED = 0x16,
SAPPHIRE_NITRO_GLOW_V3_REG_MUSIC_VOLUME = 0x29,
SAPPHIRE_NITRO_GLOW_V3_REG_RED = 0x1A,
SAPPHIRE_NITRO_GLOW_V3_REG_GREEN = 0x1B,
SAPPHIRE_NITRO_GLOW_V3_REG_BLUE = 0x1C,
};
enum
{
SAPPHIRE_NITRO_GLOW_V3_MODE_RAINBOW = 0x00,
SAPPHIRE_NITRO_GLOW_V3_MODE_RUNWAY = 0x01,
SAPPHIRE_NITRO_GLOW_V3_MODE_COLOR_CYCLE = 0x02,
SAPPHIRE_NITRO_GLOW_V3_MODE_SERIAL = 0x03,
SAPPHIRE_NITRO_GLOW_V3_MODE_SAPPHIRE_BLUE = 0x04,
SAPPHIRE_NITRO_GLOW_V3_MODE_AUDIO_VISUALIZATION = 0x05,
SAPPHIRE_NITRO_GLOW_V3_MODE_CUSTOM = 0x06,
SAPPHIRE_NITRO_GLOW_V3_MODE_OFF = 0x07,
SAPPHIRE_NITRO_GLOW_V3_MODE_EXTERNAL_CONTROL = 0xFF,
};
class SapphireNitroGlowV3Controller
{
public:
SapphireNitroGlowV3Controller(i2c_smbus_interface* bus, sapphire_dev_id dev);
~SapphireNitroGlowV3Controller();
std::string GetDeviceLocation();
unsigned char GetRed();
unsigned char GetGreen();
unsigned char GetBlue();
void SetColor(unsigned char red, unsigned char green, unsigned char blue);
void SetMode(unsigned char mode, unsigned char speed);
private:
i2c_smbus_interface* bus;
sapphire_dev_id dev;
};

12
OpenRGB.pro
View file

@ -271,8 +271,10 @@ HEADERS +=
Controllers/RedragonController/RGBController_RedragonM711.h \
Controllers/RoccatController/RGBController_RoccatKoneAimo.h \
Controllers/RoccatController/RoccatKoneAimoController.h \
Controllers/SapphireGPUController/SapphireGPUController.h \
Controllers/SapphireGPUController/RGBController_SapphireGPU.h \
Controllers/SapphireGPUController/SapphireNitroGlowV1Controller.h \
Controllers/SapphireGPUController/SapphireNitroGlowV3Controller.h \
Controllers/SapphireGPUController/RGBController_SapphireNitroGlowV1.h \
Controllers/SapphireGPUController/RGBController_SapphireNitroGlowV3.h \
Controllers/SinowealthController/SinowealthController.h \
Controllers/SinowealthController/RGBController_Sinowealth.h \
Controllers/SonyDS4Controller/SonyDS4Controller.h \
@ -507,9 +509,11 @@ SOURCES +=
Controllers/RoccatController/RGBController_RoccatKoneAimo.cpp \
Controllers/RoccatController/RoccatKoneAimoController.cpp \
Controllers/RoccatController/RoccatControllerDetect.cpp \
Controllers/SapphireGPUController/SapphireGPUController.cpp \
Controllers/SapphireGPUController/SapphireNitroGlowV1Controller.cpp \
Controllers/SapphireGPUController/SapphireNitroGlowV3Controller.cpp \
Controllers/SapphireGPUController/SapphireGPUControllerDetect.cpp \
Controllers/SapphireGPUController/RGBController_SapphireGPU.cpp \
Controllers/SapphireGPUController/RGBController_SapphireNitroGlowV1.cpp \
Controllers/SapphireGPUController/RGBController_SapphireNitroGlowV3.cpp \
Controllers/SinowealthController/SinowealthController.cpp \
Controllers/SinowealthController/SinowealthControllerDetect.cpp \
Controllers/SinowealthController/RGBController_Sinowealth.cpp \

2
i2c_smbus/i2c_smbus_amdadl.cpp
View file

@ -167,7 +167,7 @@ s32 i2c_smbus_amdadl::i2c_smbus_xfer(u8 addr, char read_write, u8 command, int s
pI2C->iAction = ADL_DL_I2C_ACTIONREAD;
ret = ADL2_Display_WriteAndReadI2C(context, PrimaryDisplay, pI2C);
}
else if (read_write == I2C_SMBUS_WRITE)
else
{
pI2C->iAction = ADL_DL_I2C_ACTIONWRITE;
ret = ADL2_Display_WriteAndReadI2C(context, PrimaryDisplay, pI2C);

24
pci_ids/pci_ids.h
View file

@ -13,8 +13,17 @@
/*-----------------------------------------------------*\
| AMD GPU Device IDs |
|
| Note: AMD uses the same PCI IDs for different SKUs |
| based on the same silicon, so we use internal code |
| names here instead of referring to specific products. |
\*-----------------------------------------------------*/
#define AMD_RX580_DEV 0x67DF
#define AMD_POLARIS_DEV 0x67DF
#define AMD_POLARIS20XL_DEV 0x6FDF
#define AMD_VEGA10_DEV 0x687F
#define AMD_NAVI10_DEV 0x731F
#define AMD_NAVI14_DEV 0x7340
#define AMD_NAVI21_DEV 0x73BF
/*-----------------------------------------------------*\
| Intel Device IDs |
@ -60,6 +69,7 @@
#define NVIDIA_SUB_VEN 0x10DE
#define PNY_SUB_VEN 0x196E
#define SAPPHIRE_SUB_VEN 0x1DA2
#define SAPPHIRE_LEGACY_SUB_VEN 0x174B
#define ZOTAC_SUB_VEN 0x19DA
/*-----------------------------------------------------*\
@ -133,7 +143,17 @@
/*-----------------------------------------------------*\
| Sapphire Sub-Device IDs |
\*-----------------------------------------------------*/
#define SAPPHIRE_RX580_NITRO_PLUS_SUB_DEV 0xE366
#define SAPPHIRE_POLARIS_NITRO_PLUS_SUB_DEV1 0xE366
#define SAPPHIRE_POLARIS_NITRO_PLUS_SUB_DEV2 0xE399
#define SAPPHIRE_LEGACY_POLARIS_NITRO_PLUS_SUB_DEV 0xE347
#define SAPPHIRE_VEGA10_NITRO_PLUS_SUB_DEV 0xE37F
#define SAPPHIRE_NAVI10_NITRO_PLUS_SUB_DEV1 0xE409
#define SAPPHIRE_NAVI10_NITRO_PLUS_SUB_DEV2 0xE410
#define SAPPHIRE_NAVI10_NITRO_PLUS_SUB_DEV3 0x426E
#define SAPPHIRE_NAVI14_NITRO_PLUS_SUB_DEV 0xE423
#define SAPPHIRE_NAVI21_NITRO_PLUS_SUB_DEV1 0x438E
#define SAPPHIRE_NAVI21_NITRO_PLUS_SUB_DEV2 0xE438
#define SAPPHIRE_NAVI21_NITRO_PLUS_SUB_DEV3 0xE439
/*---------------------------------------------------------*\
| PCI ID Macros |

5
wmi/wmi.cpp
View file

@ -138,6 +138,11 @@ HRESULT Wmi::init()
HRESULT Wmi::query(std::string queryStr, std::vector<QueryObj>& queryVectorOut, const AdditionalFilters* filters)
{
if (pSvc == nullptr)
{
return E_FAIL;
}
HRESULT hres;
int nIdx = 0;
IEnumWbemClassObject* pEnumerator = nullptr;