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

Initial implementation of RGB Fusion 2 DRAM controller

Browse source
This commit is contained in:
Adam Honse 2020-06-07 15:49:28 -05:00
parent 919d89d52f
commit 5b8441c57d
7 changed files with 361 additions and 4 deletions
Download patch file Download diff file Expand all files Collapse all files

78
Controllers/RGBFusion2DRAMController/RGBFusion2DRAMController.cpp Normal file
View file

@ -0,0 +1,78 @@
/*-----------------------------------------*\
| RGBFusion2DRAMController.cpp |
| |
| Driver for Gigabyte Aorus RGB Fusion 2 |
| DRAM lighting controller |
| |
| Adam Honse (CalcProgrammer1) 6/7/2020 |
\*-----------------------------------------*/
#include "RGBFusion2DRAMController.h"
#include <cstring>
#include <stdio.h>
#include <stdlib.h>
RGBFusion2DRAMController::RGBFusion2DRAMController(i2c_smbus_interface* bus, rgb_fusion_dev_id dev)
{
/*-----------------------------------------------------*\
| Initialize pointers |
\*-----------------------------------------------------*/
this->bus = bus;
this->dev = dev;
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(led_data, 0, sizeof(led_data));
/*-----------------------------------------------------*\
| Initialize controller with 6 LEDs and mask 0x3B |
| This is hard coded for Aorus RGB RAM |
\*-----------------------------------------------------*/
led_data[RGB_FUSION_2_DRAM_LED_EN_MASK] = 0x3B;
led_count = 6;
/*-----------------------------------------------------*\
| Initialize brightness to 100% |
\*-----------------------------------------------------*/
led_data[RGB_FUSION_2_DRAM_IDX_BRIGHTNESS] = 0x64;
}
unsigned int RGBFusion2DRAMController::GetLEDCount()
{
return(led_count);
}
std::string RGBFusion2DRAMController::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 RGBFusion2DRAMController::Apply()
{
bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_2_DRAM_APPLY_ADDR, RGB_FUSION_2_DRAM_ACTION_APPLY);
}
void RGBFusion2DRAMController::SetLEDEffect
(
unsigned int led,
int mode,
unsigned int speed,
unsigned char red,
unsigned char green,
unsigned char blue
)
{
led_data[RGB_FUSION_2_DRAM_IDX_MODE] = mode;
led_data[RGB_FUSION_2_DRAM_IDX_RED] = red;
led_data[RGB_FUSION_2_DRAM_IDX_GREEN] = green;
led_data[RGB_FUSION_2_DRAM_IDX_BLUE] = blue;
bus->i2c_smbus_write_block_data(dev, RGB_FUSION_2_DRAM_LED_START_ADDR, 32, led_data);
}

72
Controllers/RGBFusion2DRAMController/RGBFusion2DRAMController.h Normal file
View file

@ -0,0 +1,72 @@
/*-----------------------------------------*\
| RGBFusion2DRAMController.h |
| |
| Definitions and types for Gigabyte Aorus |
| RGB Fusion 2 DRAM lighting controller |
| |
| Adam Honse (CalcProgrammer1) 6/7/2020 |
\*-----------------------------------------*/
#include <string>
#include "i2c_smbus.h"
#pragma once
typedef unsigned char rgb_fusion_dev_id;
enum
{
RGB_FUSION_2_DRAM_LED_EN_MASK = 0x00, /* LED enable bitfield */
RGB_FUSION_2_DRAM_IDX_MODE = 0x09, /* Mode index */
RGB_FUSION_2_DRAM_IDX_BRIGHTNESS = 0x0A, /* Brightness index */
RGB_FUSION_2_DRAM_IDX_BLUE = 0x0C, /* Blue index */
RGB_FUSION_2_DRAM_IDX_GREEN = 0x0D, /* Green index */
RGB_FUSION_2_DRAM_IDX_RED = 0x0E, /* Red index */
// RGB_FUSION_2_DRAM_TIMER_1_LSB = 0x08, /* Timer 1 LSB. Valid timer values [0-65535] */
// RGB_FUSION_2_DRAM_TIMER_1_MSB = 0x09, /* Timer 1 MSB. Timer unis are milliseconds */
// RGB_FUSION_2_DRAM_TIMER_2_LSB = 0x0A, /* Timer 2 LSB */
// RGB_FUSION_2_DRAM_TIMER_2_MSB = 0x0B, /* Timer 2 MSB */
// RGB_FUSION_2_DRAM_TIMER_3_LSB = 0x0C, /* Timer 3 LSB */
// RGB_FUSION_2_DRAM_TIMER_3_MSB = 0x0D, /* Timer 3 MSB */
// RGB_FUSION_2_DRAM_IDX_OPT_1 = 0x0E, /* Option 1. Use case varies by mode */
// RGB_FUSION_2_DRAM_IDX_OPT_2 = 0x0F, /* Option 2. Use case varies by mode */
};
enum
{
RGB_FUSION_2_DRAM_LED_START_ADDR = 0x20,
RGB_FUSION_2_DRAM_APPLY_ADDR = 0x28,
};
enum
{
RGB_FUSION_2_DRAM_ACTION_APPLY = 0x0F,
};
class RGBFusion2DRAMController
{
public:
RGBFusion2DRAMController(i2c_smbus_interface* bus, rgb_fusion_dev_id dev);
~RGBFusion2DRAMController();
std::string GetDeviceLocation();
unsigned int GetLEDCount();
void Apply();
void SetLEDEffect
(
unsigned int led,
int mode,
unsigned int speed,
unsigned char red,
unsigned char green,
unsigned char blue
);
private:
unsigned int led_count;
i2c_smbus_interface* bus;
rgb_fusion_dev_id dev;
unsigned char led_data[32];
};

67
Controllers/RGBFusion2DRAMController/RGBFusion2DRAMControllerDetect.cpp Normal file
View file

@ -0,0 +1,67 @@
#include "RGBFusion2DRAMController.h"
#include "RGBController.h"
#include "RGBController_RGBFusion2DRAM.h"
#include "i2c_smbus.h"
#include <vector>
#include <stdio.h>
#include <stdlib.h>
#include <string>
/******************************************************************************************\
* *
* TestForRGBFusion2DRAMController *
* *
* Tests the given address to see if an RGB 2 Fusion DRAMcontroller exists there. *
* First does a quick write to test for a response *
* *
\******************************************************************************************/
bool TestForRGBFusion2DRAMController(i2c_smbus_interface* bus, unsigned char address)
{
bool pass = false;
int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
if (res >= 0)
{
pass = true;
// res = bus->i2c_smbus_read_byte_data(address, 0xF2);
// if (res != 0xC4)
// {
// pass = false;
// }
}
return(pass);
} /* TestForRGBFusion2DRAMController() */
/******************************************************************************************\
* *
* DetectRGBFusion2DRAMControllers *
* *
* Detect RGB Fusion 2 controllers on the enumerated I2C busses at address 0x67. *
* *
* bus - pointer to i2c_smbus_interface where RGB Fusion device is connected *
* dev - I2C address of RGB Fusion device *
* *
\******************************************************************************************/
void DetectRGBFusion2DRAMControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers)
{
RGBFusion2DRAMController* new_rgb_fusion;
RGBController_RGBFusion2DRAM* new_controller;
for (unsigned int bus = 0; bus < busses.size(); bus++)
{
// Check for RGB Fusion 2 DRAM controller at 0x67
if (TestForRGBFusion2DRAMController(busses[bus], 0x67))
{
new_rgb_fusion = new RGBFusion2DRAMController(busses[bus], 0x67);
new_controller = new RGBController_RGBFusion2DRAM(new_rgb_fusion);
rgb_controllers.push_back(new_controller);
}
}
} /* DetectRGBFusion2DRAMControllers() */

4
OpenRGB.cpp
View file

@ -326,6 +326,7 @@ void DetectPolychromeControllers(std::vector<i2c_smbus_interface*>& busses, std:
void DetectRGBFusionControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers);
void DetectRGBFusionGPUControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers);
void DetectRGBFusion2SMBusControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers);
void DetectRGBFusion2DRAMControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers);
void DetectMSIMysticLightControllers(std::vector<RGBController*> &rgb_controllers);
void DetectMSIRGBControllers(std::vector<RGBController*> &rgb_controllers);
void DetectAuraUSBControllers(std::vector<RGBController*> &rgb_controllers);
@ -373,8 +374,9 @@ void DetectRGBControllers(void)
DetectPolychromeControllers(busses, rgb_controllers);
DetectRGBFusionGPUControllers(busses, rgb_controllers);
//TODO: Implement better detection before enabling this controller
//TODO: Implement better detection before enabling these controllers
//DetectRGBFusion2SMBusControllers(busses, rgb_controllers);
//DetectRGBFusion2DRAMControllers(busses, rgb_controllers);
DetectRGBFusionControllers(busses, rgb_controllers);
DetectMSIMysticLightControllers(rgb_controllers);

12
OpenRGB.pro
View file

@ -74,6 +74,7 @@ INCLUDEPATH += \
Controllers/PoseidonZRGBController/ \
Controllers/RedragonController/ \
Controllers/RGBFusionController/ \
Controllers/RGBFusion2DRAMController/ \
Controllers/RGBFusion2SMBusController/ \
Controllers/RGBFusion2USBController/ \
Controllers/RGBFusionGPUController/ \
@ -131,8 +132,9 @@ HEADERS += \
Controllers/PolychromeController/PolychromeController.h \
Controllers/PoseidonZRGBController/PoseidonZRGBController.h \
Controllers/RGBFusionController/RGBFusionController.h \
Controllers/RGBFusion2USBController/RGBFusion2USBController.h \
Controllers/RGBFusion2DRAMController/RGBFusion2DRAMController.h \
Controllers/RGBFusion2SMBusController/RGBFusion2SMBusController.h \
Controllers/RGBFusion2USBController/RGBFusion2USBController.h \
Controllers/RGBFusionGPUController/RGBFusionGPUController.h \
Controllers/RedragonController/RedragonK556Controller.h \
Controllers/RedragonController/RedragonM711Controller.h \
@ -170,6 +172,7 @@ HEADERS += \
RGBController/RGBController_RedragonK556.h \
RGBController/RGBController_RedragonM711.h \
RGBController/RGBController_RGBFusion.h \
RGBController/RGBController_RGBFusion2DRAM.h \
RGBController/RGBController_RGBFusion2SMBus.h \
RGBController/RGBController_RGBFusion2USB.h \
RGBController/RGBController_RGBFusionGPU.h \
@ -255,10 +258,12 @@ SOURCES += \
Controllers/PoseidonZRGBController/PoseidonZRGBControllerDetect.cpp \
Controllers/RGBFusionController/RGBFusionController.cpp \
Controllers/RGBFusionController/RGBFusionControllerDetect.cpp \
Controllers/RGBFusion2USBController/RGBFusion2USBController.cpp \
Controllers/RGBFusion2USBController/RGBFusion2USBControllerDetect.cpp \
Controllers/RGBFusion2DRAMController/RGBFusion2DRAMController.cpp \
Controllers/RGBFusion2DRAMController/RGBFusion2DRAMControllerDetect.cpp \
Controllers/RGBFusion2SMBusController/RGBFusion2SMBusController.cpp \
Controllers/RGBFusion2SMBusController/RGBFusion2SMBusControllerDetect.cpp \
Controllers/RGBFusion2USBController/RGBFusion2USBController.cpp \
Controllers/RGBFusion2USBController/RGBFusion2USBControllerDetect.cpp \
Controllers/RGBFusionGPUController/RGBFusionGPUController.cpp \
Controllers/RGBFusionGPUController/RGBFusionGPUControllerDetect.cpp \
Controllers/RedragonController/RedragonK556Controller.cpp \
@ -302,6 +307,7 @@ SOURCES += \
RGBController/RGBController_RedragonK556.cpp \
RGBController/RGBController_RedragonM711.cpp \
RGBController/RGBController_RGBFusion.cpp \
RGBController/RGBController_RGBFusion2DRAM.cpp \
RGBController/RGBController_RGBFusion2SMBus.cpp \
RGBController/RGBController_RGBFusion2USB.cpp \
RGBController/RGBController_RGBFusionGPU.cpp \

99
RGBController/RGBController_RGBFusion2DRAM.cpp Normal file
View file

@ -0,0 +1,99 @@
/*-----------------------------------------*\
| RGBController_RGBFusion2DRAM.cpp |
| |
| Generic RGB Interface for OpenRGB |
| Gigabyte RGB Fusion 2 DRAM Driver |
| |
| Adam Honse (CalcProgrammer1) 6/7/2020 |
\*-----------------------------------------*/
#include "RGBController_RGBFusion2DRAM.h"
RGBController_RGBFusion2DRAM::RGBController_RGBFusion2DRAM(RGBFusion2DRAMController* rgb_fusion_ptr)
{
rgb_fusion = rgb_fusion_ptr;
name = "RGB Fusion 2 DRAM";
description = "RGB Fusion 2 DRAM Device";
location = rgb_fusion->GetDeviceLocation();
type = DEVICE_TYPE_DRAM;
mode Static;
Static.name = "Static";
Static.value = 1;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Static.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Static);
SetupZones();
}
void RGBController_RGBFusion2DRAM::SetupZones()
{
/*---------------------------------------------------------*\
| Search through all LEDs and create zones for each channel |
| type |
\*---------------------------------------------------------*/
zone* new_zone = new zone();
// Set zone name to channel name
new_zone->name = "DRAM Zone";
new_zone->leds_min = 1;
new_zone->leds_max = 1;
new_zone->leds_count = 1;
// Push new zone to zones vector
zones.push_back(*new_zone);
led* new_led = new led();
new_led->name = "DRAM LED";
// Push new LED to LEDs vector
leds.push_back(*new_led);
SetupColors();
}
void RGBController_RGBFusion2DRAM::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_RGBFusion2DRAM::DeviceUpdateLEDs()
{
RGBColor color = colors[0];
unsigned char red = RGBGetRValue(color);
unsigned char grn = RGBGetGValue(color);
unsigned char blu = RGBGetBValue(color);
int mode = modes[active_mode].value;
unsigned int speed = modes[active_mode].speed;
rgb_fusion->SetLEDEffect(0, mode, speed, red, grn, blu);
rgb_fusion->Apply();
}
void RGBController_RGBFusion2DRAM::UpdateZoneLEDs(int /*zone*/)
{
UpdateLEDs();
}
void RGBController_RGBFusion2DRAM::UpdateSingleLED(int /*led*/)
{
UpdateLEDs();
}
void RGBController_RGBFusion2DRAM::SetCustomMode()
{
}
void RGBController_RGBFusion2DRAM::UpdateMode()
{
}

33
RGBController/RGBController_RGBFusion2DRAM.h Normal file
View file

@ -0,0 +1,33 @@
/*-----------------------------------------*\
| RGBController_RGBFusion2DRAM.h |
| |
| Generic RGB Interface for OpenRGB |
| Gigabyte RGB Fusion 2 DRAM Driver |
| |
| Adam Honse (CalcProgrammer1) 6/7/2020 |
\*-----------------------------------------*/
#pragma once
#include "RGBController.h"
#include "RGBFusion2DRAMController.h"
class RGBController_RGBFusion2DRAM : public RGBController
{
public:
RGBController_RGBFusion2DRAM(RGBFusion2DRAMController* rgb_fusion_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:
RGBFusion2DRAMController* rgb_fusion;
};