Jens/LumaOps-Public
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Publish LumaOps source

Browse Source
This commit is contained in:
LumaOps release export
2026-09-03 01:18:36 +02:00
commit 7f1c0e5f71
2363 changed files with 501543 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Controllers/MSIMysticLightController/MSIMysticLight112Controller/MSIMysticLight112Controller.cpp
+436
View File
@@ -0,0 +1,436 @@
/*---------------------------------------------------------*\
| MSIMysticLight112Controller.cpp |
| |
| Driver for MSI Mystic Light 112-byte motherboard |
| |
| thombo 17 Dec 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <algorithm>
#include <array>
#include <bitset>
#include "MSIMysticLight112Controller.h"
#include "StringUtils.h"
#define BITSET(val, bit, pos) ((unsigned char)std::bitset<8>(val).set((pos), (bit)).to_ulong())
struct Config
{
unsigned short pid; // PID of the board
size_t numof_onboard_leds; // number of onboard leds
const std::vector<MSI_ZONE>* supported_zones; // pointer to vector of supported zones
};
const std::vector<MSI_ZONE> zones_set =
{
MSI_ZONE_J_RGB_1,
MSI_ZONE_J_RAINBOW_1,
MSI_ZONE_J_CORSAIR,
MSI_ZONE_ON_BOARD_LED_0
};
MSIMysticLight112Controller::MSIMysticLight112Controller
(
hid_device* handle,
const char* path,
std::string dev_name
)
{
dev = handle;
location = path;
name = dev_name;
if(dev)
{
ReadFwVersion();
ReadSettings();
}
/*-----------------------------------------*\
| Initialize save flag |
\*-----------------------------------------*/
data.save_data = 0;
data.on_board_led.colorFlags = 0x81; // force MS bit of color flags to 1 to have expected zone control
/*-----------------------------------------*\
| Initialize zone based per LED data |
\*-----------------------------------------*/
numof_onboard_leds = 7;
supported_zones = &zones_set;
zone_based_per_led_data.j_rgb_1.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2;
zone_based_per_led_data.j_rgb_1.colorFlags = BITSET(zone_based_per_led_data.j_rgb_1.colorFlags, true, 7u);
zone_based_per_led_data.j_rainbow_1.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2;
zone_based_per_led_data.j_rainbow_1.colorFlags = BITSET(zone_based_per_led_data.j_rainbow_1.colorFlags, true, 7u);
zone_based_per_led_data.on_board_led.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2;
zone_based_per_led_data.on_board_led.colorFlags = BITSET(zone_based_per_led_data.on_board_led.colorFlags, true, 7u);
zone_based_per_led_data.on_board_led_1.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2;
zone_based_per_led_data.on_board_led_1.colorFlags = BITSET(zone_based_per_led_data.on_board_led_1.colorFlags, true, 7u);
zone_based_per_led_data.on_board_led_2.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2;
zone_based_per_led_data.on_board_led_2.colorFlags = BITSET(zone_based_per_led_data.on_board_led_2.colorFlags, true, 7u);
zone_based_per_led_data.on_board_led_3.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2;
zone_based_per_led_data.on_board_led_3.colorFlags = BITSET(zone_based_per_led_data.on_board_led_3.colorFlags, true, 7u);
zone_based_per_led_data.on_board_led_4.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2;
zone_based_per_led_data.on_board_led_4.colorFlags = BITSET(zone_based_per_led_data.on_board_led_4.colorFlags, true, 7u);
zone_based_per_led_data.on_board_led_5.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2;
zone_based_per_led_data.on_board_led_5.colorFlags = BITSET(zone_based_per_led_data.on_board_led_5.colorFlags, true, 7u);
zone_based_per_led_data.on_board_led_6.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2 << 2;
zone_based_per_led_data.on_board_led_6.colorFlags = BITSET(zone_based_per_led_data.on_board_led_6.colorFlags, true, 7u);
zone_based_per_led_data.save_data = 0;
direct_mode = false;
}
MSIMysticLight112Controller::~MSIMysticLight112Controller()
{
hid_close(dev);
}
void MSIMysticLight112Controller::SetMode
(
MSI_ZONE zone,
MSI_MODE mode,
MSI_SPEED speed,
MSI_BRIGHTNESS brightness,
bool rainbow_color
)
{
ZoneData* zone_data = GetZoneData(data, zone);
if(zone_data == nullptr)
{
return;
}
if (zone <= MSI_ZONE_ON_BOARD_LED_0)
{
zone_data->effect = mode;
zone_data->speedAndBrightnessFlags = (brightness << 2) | (speed & 0x03);
zone_data->colorFlags = BITSET(zone_data->colorFlags, !rainbow_color, 7u);
zone_data->padding = 0x00;
if(mode > MSI_MODE_DOUBLE_FLASHING)
{
zone_data->speedAndBrightnessFlags |= SYNC_SETTING_JRGB;
zone_data->colorFlags |= SYNC_SETTING_ONBOARD;
}
else
{
zone_data->speedAndBrightnessFlags &= ~SYNC_SETTING_JRGB;
zone_data->colorFlags &= ~SYNC_SETTING_ONBOARD;
}
}
if((zone >= MSI_ZONE_ON_BOARD_LED_0) && (mode <= MSI_MODE_DOUBLE_FLASHING))
{
zone_data = GetZoneData(data, (MSI_ZONE)((int)zone + 1));
if(zone_data != nullptr)
{
zone_data->effect = mode;
zone_data->speedAndBrightnessFlags = (brightness << 2) | (speed & 0x03);
zone_data->colorFlags = BITSET(zone_data->colorFlags, !rainbow_color, 7u);
zone_data->padding = 0x00;
}
}
}
std::string MSIMysticLight112Controller::GetDeviceName()
{
return name;
}
std::string MSIMysticLight112Controller::GetFWVersion()
{
std::string firmware_version;
firmware_version = "APROM: " + version_APROM + ", LDROM: " + version_LDROM;
return firmware_version;
}
std::string MSIMysticLight112Controller::GetDeviceLocation()
{
return("HID: " + location);
}
std::string MSIMysticLight112Controller::GetSerial()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
if(ret != 0)
{
return("");
}
return(StringUtils::wstring_to_string(serial_string));
}
bool MSIMysticLight112Controller::ReadSettings()
{
/*-----------------------------------------------------*\
| Read packet from hardware, return true if successful |
\*-----------------------------------------------------*/
return(hid_get_feature_report(dev, (unsigned char*)&data, sizeof(data)) == sizeof data);
}
bool MSIMysticLight112Controller::Update
(
bool save
)
{
/*-----------------------------------------------------*\
| Send packet to hardware, return true if successful |
\*-----------------------------------------------------*/
if(direct_mode)
{
return (hid_send_feature_report(dev, (unsigned char*)&zone_based_per_led_data, sizeof(zone_based_per_led_data)) == sizeof(zone_based_per_led_data));
}
else
{
data.save_data = save;
return (hid_send_feature_report(dev, (unsigned char*)&data, sizeof(data)) == sizeof(data));
}
}
void MSIMysticLight112Controller::SetZoneColor
(
MSI_ZONE zone,
unsigned char red1,
unsigned char grn1,
unsigned char blu1,
unsigned char red2,
unsigned char grn2,
unsigned char blu2
)
{
ZoneData* zone_data = GetZoneData(data, zone);
if(zone_data == nullptr)
{
return;
}
if (zone <= MSI_ZONE_ON_BOARD_LED_0)
{
zone_data->color.R = red1;
zone_data->color.G = grn1;
zone_data->color.B = blu1;
zone_data->color2.R = red2;
zone_data->color2.G = grn2;
zone_data->color2.B = blu2;
}
if(zone >= MSI_ZONE_ON_BOARD_LED_0)
{
zone_data = GetZoneData(data, (MSI_ZONE)((int)zone + 1));
if(zone_data != nullptr)
{
zone_data->color.R = red1;
zone_data->color.G = grn1;
zone_data->color.B = blu1;
zone_data->color2.R = red2;
zone_data->color2.G = grn2;
zone_data->color2.B = blu2;
}
}
}
void MSIMysticLight112Controller::SetLedColor
(
MSI_ZONE zone,
unsigned char red,
unsigned char grn,
unsigned char blu
)
{
if(zone >= MSI_ZONE_ON_BOARD_LED_0)
{
zone = (MSI_ZONE)((int)zone + 1);
}
ZoneData *zone_data = GetZoneData(zone_based_per_led_data, zone);
if(zone_data == nullptr)
{
return;
}
zone_data->color.R = red;
zone_data->color.G = grn;
zone_data->color.B = blu;
zone_data->color2.R = red;
zone_data->color2.G = grn;
zone_data->color2.B = blu;
}
ZoneData *MSIMysticLight112Controller::GetZoneData
(
FeaturePacket_112& data_packet,
MSI_ZONE zone
)
{
switch(zone)
{
case MSI_ZONE_J_RGB_1:
return &data_packet.j_rgb_1;
case MSI_ZONE_J_RAINBOW_1:
return &data_packet.j_rainbow_1;
case MSI_ZONE_ON_BOARD_LED_0:
return &data_packet.on_board_led;
case MSI_ZONE_ON_BOARD_LED_1:
return &data_packet.on_board_led_1;
case MSI_ZONE_ON_BOARD_LED_2:
return &data_packet.on_board_led_2;
case MSI_ZONE_ON_BOARD_LED_3:
return &data_packet.on_board_led_3;
case MSI_ZONE_ON_BOARD_LED_4:
return &data_packet.on_board_led_4;
case MSI_ZONE_ON_BOARD_LED_5:
return &data_packet.on_board_led_5;
case MSI_ZONE_ON_BOARD_LED_6:
return &data_packet.on_board_led_6;
case MSI_ZONE_J_CORSAIR:
return &data_packet.j_corsair_1;
default:
break;
}
return nullptr;
}
bool MSIMysticLight112Controller::ReadFwVersion()
{
unsigned char request[64];
unsigned char response[64];
int ret_val = 64;
/*-----------------------------------------------------*\
| First read the APROM |
| Checksum also available at report ID 180, with MSB |
| stored at index 0x08 and LSB at 0x09 |
\*-----------------------------------------------------*/
/*-----------------------------------------------------*\
| Zero out buffers |
\*-----------------------------------------------------*/
memset(request, 0x00, sizeof(request));
memset(response, 0x00, sizeof(response));
/*-----------------------------------------------------*\
| Set up APROM Firmware Version Request packet |
\*-----------------------------------------------------*/
request[0x00] = 0x01;
request[0x01] = 0xB0;
/*-----------------------------------------------------*\
| Fill request from 0x02 to 0x61 with 0xCC |
\*-----------------------------------------------------*/
memset(&request[0x02], 0xCC, sizeof(request) - 2);
/*-----------------------------------------------------*\
| Send request and receive response packets |
\*-----------------------------------------------------*/
ret_val &= hid_write(dev, request, 64);
ret_val &= hid_read(dev, response, 64);
/*-----------------------------------------------------*\
| Extract high and low values from response |
\*-----------------------------------------------------*/
unsigned char highValue = response[2] >> 4;
unsigned char lowValue = response[2] & 0x0F;
/*-----------------------------------------------------*\
| Build firmware string <high>.<low> |
\*-----------------------------------------------------*/
version_APROM = std::to_string((int)highValue).append(".").append(std::to_string((int)lowValue));
/*-----------------------------------------------------*\
| First read the LDROM |
| Checksum also available at report ID 184, with MSB |
| stored at index 0x08 and LSB at 0x09 |
\*-----------------------------------------------------*/
/*-----------------------------------------------------*\
| Set up LDROM Firmware Version Request packet |
\*-----------------------------------------------------*/
request[0x00] = 0x01;
request[0x01] = 0xB6;
/*-----------------------------------------------------*\
| Send request and receive response packets |
\*-----------------------------------------------------*/
ret_val &= hid_write(dev, request, 64);
ret_val &= hid_read(dev, response, 64);
/*-----------------------------------------------------*\
| Extract high and low values from response |
\*-----------------------------------------------------*/
highValue = response[2] >> 4;
lowValue = response[2] & 0x0F;
/*-----------------------------------------------------*\
| Build firmware string <high>.<low> |
\*-----------------------------------------------------*/
version_LDROM = std::to_string((int)highValue).append(".").append(std::to_string((int)lowValue));
/*-----------------------------------------------------*\
| If return value is zero it means an HID transfer |
| failed |
\*-----------------------------------------------------*/
return(ret_val > 0);
}
MSI_MODE MSIMysticLight112Controller::GetMode()
{
return (MSI_MODE)data.on_board_led.effect;
}
void MSIMysticLight112Controller::GetMode
(
MSI_ZONE zone,
MSI_MODE &mode,
MSI_SPEED &speed,
MSI_BRIGHTNESS &brightness,
bool &rainbow_color,
unsigned int &color
)
{
/*-----------------------------------------------------*\
| Get data for given zone |
\*-----------------------------------------------------*/
ZoneData *zone_data = GetZoneData(data, zone);
/*-----------------------------------------------------*\
| Return if zone is invalid |
\*-----------------------------------------------------*/
if(zone_data == nullptr)
{
return;
}
/*-----------------------------------------------------*\
| Update pointers with data |
\*-----------------------------------------------------*/
mode = (MSI_MODE)zone_data->effect;
speed = (MSI_SPEED)(zone_data->speedAndBrightnessFlags & 0x03);
brightness = (MSI_BRIGHTNESS)((zone_data->speedAndBrightnessFlags >> 2) & 0x1F);
rainbow_color = (zone_data->colorFlags & 0x80) == 0 ? true : false;
color = ToRGBColor(zone_data->color.R, zone_data->color.G, zone_data->color.B);
}
void MSIMysticLight112Controller::SetDirectMode
(
bool mode
)
{
direct_mode = mode;
}
size_t MSIMysticLight112Controller::GetMaxOnboardLeds()
{
return numof_onboard_leds;
}
Controllers/MSIMysticLightController/MSIMysticLight112Controller/MSIMysticLight112Controller.h
+112
View File
@@ -0,0 +1,112 @@
/*---------------------------------------------------------*\
| MSIMysticLight112Controller.h |
| |
| Driver for MSI Mystic Light 112-byte motherboard |
| |
| thombo 17 Dec 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <cstring>
#include <limits>
#include <hidapi.h>
#include "MSIMysticLightCommon.h"
#include "RGBController.h"
class MSIMysticLight112Controller
{
public:
MSIMysticLight112Controller
(
hid_device* handle,
const char* path,
std::string dev_name
);
~MSIMysticLight112Controller();
void SetMode
(
MSI_ZONE zone,
MSI_MODE mode,
MSI_SPEED speed,
MSI_BRIGHTNESS brightness,
bool rainbow_color
);
MSI_MODE GetMode();
void GetMode
(
MSI_ZONE zone,
MSI_MODE &mode,
MSI_SPEED &speed,
MSI_BRIGHTNESS &brightness,
bool &rainbow_color,
unsigned int &color
);
void SetZoneColor
(
MSI_ZONE zone,
unsigned char red1,
unsigned char grn1,
unsigned char blu1,
unsigned char red2,
unsigned char grn2,
unsigned char blu2
);
void SetLedColor
(
MSI_ZONE zone,
unsigned char red,
unsigned char grn,
unsigned char blu
);
bool Update
(
bool save
);
std::string GetDeviceName();
std::string GetDeviceLocation();
std::string GetFWVersion();
std::string GetSerial();
void SetDirectMode
(
bool mode
);
bool IsDirectModeActive() { return direct_mode; }
size_t GetMaxOnboardLeds();
const std::vector<MSI_ZONE>*
GetSupportedZones() { return supported_zones; }
private:
hid_device* dev;
std::string name;
std::string location;
std::string version_APROM;
std::string version_LDROM;
FeaturePacket_112 data;
FeaturePacket_112 zone_based_per_led_data;
bool direct_mode;
size_t numof_onboard_leds;
const std::vector<MSI_ZONE>* supported_zones;
bool ReadSettings();
bool ReadFwVersion();
ZoneData* GetZoneData
(
FeaturePacket_112& dataPacket,
MSI_ZONE zone
);
};
Controllers/MSIMysticLightController/MSIMysticLight112Controller/RGBController_MSIMysticLight112.cpp
+386
View File
@@ -0,0 +1,386 @@
/*---------------------------------------------------------*\
| RGBController_MSIMysticLight112.cpp |
| |
| RGBController for MSI Mystic Light 112-byte motherboard |
| |
| thombo 17 Dec 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_MSIMysticLight112.h"
struct ZoneDescription
{
std::string name;
MSI_ZONE zone_type;
};
#define NUMOF_ZONES (sizeof(led_zones) / sizeof(ZoneDescription))
const ZoneDescription led_zones[] =
{
ZoneDescription{ "JRGB1", MSI_ZONE_J_RGB_1 },
ZoneDescription{ "JRAINBOW1", MSI_ZONE_J_RAINBOW_1 },
ZoneDescription{ "JCORSAIR", MSI_ZONE_J_CORSAIR },
ZoneDescription{ "Onboard LEDs", MSI_ZONE_ON_BOARD_LED_0 }
};
static std::vector<const ZoneDescription*> zone_description;
/**------------------------------------------------------------------*\
@name MSI Mystic Light (112 Byte)
@category Motherboard
@type USB
@save :robot:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectMSIMysticLightControllers
@comment
\*-------------------------------------------------------------------*/
RGBController_MSIMysticLight112::RGBController_MSIMysticLight112
(
MSIMysticLight112Controller* controller_ptr
)
{
controller = controller_ptr;
name = controller->GetDeviceName();
vendor = "MSI";
type = DEVICE_TYPE_MOTHERBOARD;
description = "MSI Mystic Light Device (112-byte)";
version = controller->GetFWVersion();
location = controller->GetDeviceLocation();
serial = controller->GetSerial();
const std::vector<MSI_ZONE>* supported_zones = controller->GetSupportedZones();
for(std::size_t i = 0; i < supported_zones->size(); ++i)
{
for(std::size_t j = 0; j < NUMOF_ZONES; ++j)
{
if(led_zones[j].zone_type == (*supported_zones)[i])
{
zone_description.push_back(&led_zones[j]);
break;
}
}
}
SetupModes();
SetupZones();
SetupColors();
active_mode = GetDeviceMode();
GetDeviceConfig();
}
RGBController_MSIMysticLight112::~RGBController_MSIMysticLight112()
{
zone_description.clear();
delete controller;
}
int RGBController_MSIMysticLight112::GetDeviceMode()
{
MSI_MODE mode = controller->GetMode();
for(unsigned int i = 0; i < modes.size(); ++i)
{
if(mode == modes[i].value)
{
return i;
}
}
return 0;
}
void RGBController_MSIMysticLight112::SetupZones()
{
/*---------------------------------------------------------*\
| Set up zones |
\*---------------------------------------------------------*/
for(std::size_t zone_idx = 0; zone_idx < zone_description.size(); ++zone_idx)
{
const ZoneDescription* zd = zone_description[zone_idx];
zone new_zone;
new_zone.name = zd->name;
/*--------------------------------------------------\
| 112-byte MSI does not have resizable zones, but |
| onboard LED zones have multiple LEDs |
\*-------------------------------------------------*/
if(zd->zone_type == MSI_ZONE_ON_BOARD_LED_0)
{
new_zone.leds_max = (int)controller->GetMaxOnboardLeds();
}
else
{
new_zone.leds_max = 1;
}
new_zone.leds_min = new_zone.leds_max;
new_zone.leds_count = new_zone.leds_max;
/*-------------------------------------------------*\
| Determine zone type based on max number of LEDs |
\*-------------------------------------------------*/
if(new_zone.leds_max == 1)
{
new_zone.type = ZONE_TYPE_SINGLE;
}
else
{
new_zone.type = ZONE_TYPE_LINEAR;
}
new_zone.matrix_map = NULL;
zones.push_back(new_zone);
}
/*---------------------------------------------------------*\
| Set up LEDs |
\*---------------------------------------------------------*/
for(std::size_t zone_idx = 0; zone_idx < zone_description.size(); ++zone_idx)
{
for(std::size_t led_idx = 0; led_idx < zones[zone_idx].leds_count; ++led_idx)
{
led new_led;
new_led.name = zones[zone_idx].name + " LED ";
if(zones[zone_idx].leds_count > 1)
{
new_led.name.append(std::to_string(led_idx + 1));
}
new_led.value = (unsigned int)(zone_description[zone_idx]->zone_type + led_idx);
leds.push_back(new_led);
}
}
}
void RGBController_MSIMysticLight112::ResizeZone
(
int /*zone*/,
int /*new_size*/
)
{
}
void RGBController_MSIMysticLight112::DeviceUpdateLEDs()
{
for(std::size_t zone_idx = 0; zone_idx < zones.size(); ++zone_idx)
{
for(int led_idx = zones[zone_idx].leds_count - 1; led_idx >= 0; led_idx--)
{
UpdateLed((int)zone_idx, led_idx);
}
}
controller->Update((modes[active_mode].flags & MODE_FLAG_AUTOMATIC_SAVE) != 0);
}
void RGBController_MSIMysticLight112::UpdateZoneLEDs
(
int zone
)
{
for(int led_idx = zones[zone].leds_count - 1; led_idx >= 0; led_idx--)
{
UpdateLed(zone, led_idx);
}
controller->Update((modes[active_mode].flags & MODE_FLAG_AUTOMATIC_SAVE) != 0);
}
void RGBController_MSIMysticLight112::UpdateSingleLED
(
int led
)
{
UpdateLed(leds[led].value, led);
controller->Update((modes[active_mode].flags & MODE_FLAG_AUTOMATIC_SAVE) != 0);
}
void RGBController_MSIMysticLight112::DeviceUpdateMode()
{
if(modes[active_mode].value == MSI_MODE_DIRECT_DUMMY)
{
controller->SetDirectMode(true);
}
else
{
controller->SetDirectMode(false);
DeviceUpdateLEDs();
}
}
void RGBController_MSIMysticLight112::DeviceSaveMode()
{
controller->Update(true);
}
void RGBController_MSIMysticLight112::SetupModes()
{
constexpr unsigned int PER_LED_ONLY = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE;
constexpr unsigned int RANDOM_ONLY = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_MANUAL_SAVE;
constexpr unsigned int COMMON = RANDOM_ONLY | MODE_FLAG_HAS_PER_LED_COLOR;
SetupMode("Direct", MSI_MODE_DIRECT_DUMMY, MODE_FLAG_HAS_PER_LED_COLOR);
SetupMode("Static", MSI_MODE_STATIC, MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE);
SetupMode("Breathing", MSI_MODE_BREATHING, PER_LED_ONLY);
SetupMode("Flashing", MSI_MODE_FLASHING, COMMON);
SetupMode("Double flashing", MSI_MODE_DOUBLE_FLASHING, COMMON);
SetupMode("Lightning", MSI_MODE_LIGHTNING, PER_LED_ONLY);
SetupMode("Meteor", MSI_MODE_METEOR, COMMON);
SetupMode("Stack", MSI_MODE_WATER_DROP, COMMON);
SetupMode("Rainbow", MSI_MODE_COLOR_RING, COMMON);
SetupMode("Planetary", MSI_MODE_PLANETARY, RANDOM_ONLY);
SetupMode("Double meteor", MSI_MODE_DOUBLE_METEOR, RANDOM_ONLY);
SetupMode("Energy", MSI_MODE_ENERGY, RANDOM_ONLY);
SetupMode("Blink", MSI_MODE_BLINK, COMMON);
SetupMode("Clock", MSI_MODE_CLOCK, RANDOM_ONLY);
SetupMode("Color pulse", MSI_MODE_COLOR_PULSE, COMMON);
SetupMode("Color shift", MSI_MODE_COLOR_SHIFT, RANDOM_ONLY);
SetupMode("Color wave", MSI_MODE_COLOR_WAVE, COMMON);
SetupMode("Marquee", MSI_MODE_MARQUEE, PER_LED_ONLY);
SetupMode("Rainbow wave", MSI_MODE_RAINBOW_WAVE, RANDOM_ONLY);
SetupMode("Visor", MSI_MODE_VISOR, COMMON);
SetupMode("Rainbow flashing", MSI_MODE_RAINBOW_FLASHING, RANDOM_ONLY);
SetupMode("Rainbow double flashing", MSI_MODE_RAINBOW_DOUBLE_FLASHING, RANDOM_ONLY);
}
void RGBController_MSIMysticLight112::UpdateLed
(
int zone,
int led
)
{
unsigned char red = RGBGetRValue(zones[zone].colors[led]);
unsigned char grn = RGBGetGValue(zones[zone].colors[led]);
unsigned char blu = RGBGetBValue(zones[zone].colors[led]);
if(controller->IsDirectModeActive())
{
controller->SetLedColor((MSI_ZONE)zones[zone].leds[led].value, red, grn, blu);
}
else
{
bool random = modes[active_mode].color_mode == MODE_COLORS_RANDOM;
MSI_MODE mode = (MSI_MODE)modes[active_mode].value;
MSI_SPEED speed = (MSI_SPEED)modes[active_mode].speed;
MSI_BRIGHTNESS brightness = (MSI_BRIGHTNESS)modes[active_mode].brightness;
controller->SetMode((MSI_ZONE)zones[zone].leds[led].value, mode, speed, brightness, random);
controller->SetZoneColor((MSI_ZONE)zones[zone].leds[led].value, red, grn, blu, red, grn, blu);
}
}
void RGBController_MSIMysticLight112::SetupMode
(
const char *name,
MSI_MODE mod,
unsigned int flags
)
{
mode Mode;
Mode.name = name;
Mode.value = mod;
Mode.flags = flags;
if(flags & MODE_FLAG_HAS_PER_LED_COLOR)
{
Mode.color_mode = MODE_COLORS_PER_LED;
}
else
{
Mode.color_mode = MODE_COLORS_RANDOM;
}
if(flags & MODE_FLAG_HAS_SPEED)
{
Mode.speed = MSI_SPEED_MEDIUM;
Mode.speed_max = MSI_SPEED_HIGH;
Mode.speed_min = MSI_SPEED_LOW;
}
else
{
/*---------------------------------------------------------*\
| For modes without speed this needs to be set to avoid |
| bad values in the saved profile which in turn corrupts |
| the brightness calculation when loading the profile |
\*---------------------------------------------------------*/
Mode.speed = 0;
Mode.speed_max = 0;
Mode.speed_min = 0;
}
if(flags & MODE_FLAG_HAS_BRIGHTNESS)
{
Mode.brightness = MSI_BRIGHTNESS_LEVEL_100;
Mode.brightness_max = MSI_BRIGHTNESS_LEVEL_100;
Mode.brightness_min = MSI_BRIGHTNESS_OFF;
}
else
{
Mode.brightness = MSI_BRIGHTNESS_LEVEL_100;
Mode.brightness_max = MSI_BRIGHTNESS_LEVEL_100;
Mode.brightness_min = MSI_BRIGHTNESS_LEVEL_100;
}
modes.push_back(Mode);
}
void RGBController_MSIMysticLight112::GetDeviceConfig()
{
MSI_MODE mode;
MSI_SPEED speed;
MSI_BRIGHTNESS brightness;
bool rainbow;
unsigned int color;
for(size_t i = 0; i < zone_description.size(); ++i)
{
controller->GetMode(zone_description[i]->zone_type, mode, speed, brightness, rainbow, color);
for(size_t j = 0; j < zones[i].leds_count; ++j)
{
zones[i].colors[j] = color;
}
}
controller->GetMode(zone_description[0]->zone_type, mode, speed, brightness, rainbow, color);
for(size_t i = 0; i < modes.size(); ++i)
{
if(mode == modes[i].value)
{
if(modes[i].flags & MODE_FLAG_HAS_SPEED)
{
modes[i].speed = speed;
}
if(modes[i].flags & MODE_FLAG_HAS_BRIGHTNESS)
{
modes[i].brightness = brightness;
}
if(rainbow)
{
if(modes[i].flags & (MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR))
{
if(rainbow)
{
modes[i].color_mode = MODE_COLORS_RANDOM;
}
else
{
modes[i].color_mode = MODE_COLORS_PER_LED;
}
}
}
break;
}
}
}
Controllers/MSIMysticLightController/MSIMysticLight112Controller/RGBController_MSIMysticLight112.h
+50
View File
@@ -0,0 +1,50 @@
/*---------------------------------------------------------*\
| RGBController_MSIMysticLight112.h |
| |
| RGBController for MSI Mystic Light 112-byte motherboard |
| |
| thombo 17 Dec 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "MSIMysticLight112Controller.h"
class RGBController_MSIMysticLight112: public RGBController
{
public:
RGBController_MSIMysticLight112(MSIMysticLight112Controller* controller_ptr);
~RGBController_MSIMysticLight112();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
void DeviceSaveMode();
private:
MSIMysticLight112Controller* controller;
void SetupModes();
void UpdateLed
(
int zone,
int led
);
void SetupMode
(
const char *name,
MSI_MODE mode,
unsigned int flags
);
int GetDeviceMode();
void GetDeviceConfig();
};
Controllers/MSIMysticLightController/MSIMysticLight162Controller/MSIMysticLight162Controller.cpp
+452
View File
@@ -0,0 +1,452 @@
/*---------------------------------------------------------*\
| MSIMysticLight162Controller.cpp |
| |
| Driver for MSI Mystic Light 162-byte motherboard |
| |
| T-bond 03 Apr 2020 |
| Adam Honse 06 Mar 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <algorithm>
#include <array>
#include <bitset>
#include "MSIMysticLight162Controller.h"
#include "StringUtils.h"
#define BITSET(val, bit, pos) ((unsigned char)std::bitset<8>(val).set((pos), (bit)).to_ulong())
struct mystic_light_162_config
{
unsigned short pid; // PID of the board
size_t numof_onboard_leds; // number of onboard leds
const std::vector<MSI_ZONE>* supported_zones; // pointer to vector of supported zones
};
const std::vector<MSI_ZONE> zones_set0 =
{
MSI_ZONE_J_RGB_1,
MSI_ZONE_J_RGB_2,
MSI_ZONE_J_RAINBOW_1,
MSI_ZONE_J_CORSAIR,
MSI_ZONE_ON_BOARD_LED_0
};
const std::vector<MSI_ZONE> zones_set1 =
{
MSI_ZONE_J_RGB_1,
MSI_ZONE_J_RGB_2,
MSI_ZONE_J_RAINBOW_1,
MSI_ZONE_ON_BOARD_LED_0
};
const std::vector<MSI_ZONE> zones_set2 =
{
MSI_ZONE_J_RGB_1,
MSI_ZONE_J_RGB_2,
MSI_ZONE_J_RAINBOW_1,
MSI_ZONE_J_RAINBOW_2,
MSI_ZONE_ON_BOARD_LED_0
};
const std::vector<MSI_ZONE> zones_set3 =
{
MSI_ZONE_J_RAINBOW_1,
MSI_ZONE_ON_BOARD_LED_0
};
/*-----------------------------------------------------------------------------------------------------------------------------*\
| Definition of the board sepcific configurations (number of onboard LEDs and supported zones). |
| |
| Only tested boards are listed here (refer to MSIMysticLightControllerDetect.cpp). If more boards |
| are tested the list must be extended here. Otherwise the default settings will be used (7 onboard LEDs, all zones supported). |
| Boards with yet unknown supported zones are configured to support all zones. |
\*-----------------------------------------------------------------------------------------------------------------------------*/
#define NUMOF_CONFIGS (sizeof(board_configs) / sizeof(mystic_light_162_config))
static const mystic_light_162_config board_configs[] =
{
{ 0x1720, 10, &zones_set0 }, // MPG Z390 GAMING EDGE AC
{ 0x7B12, 10, &zones_set0 }, // MEG Z390 ACE
{ 0x7B17, 10, &zones_set0 }, // MPG Z390 GAMING PRO CARBON
{ 0x7B18, 6, &zones_set1 }, // MAG Z390 TOMAHAWK
{ 0x7B50, 6, &zones_set2 }, // MPG Z390M GAMING EDGE AC
{ 0x7B85, 7, &zones_set0 }, // B450 GAMING PRO CARBON
{ 0x7B92, 10, &zones_set0 }, // MEG X399 CREATION
{ 0xB926, 3, &zones_set3 }, // MPG B460 TRIDENT AS
};
MSIMysticLight162Controller::MSIMysticLight162Controller
(
hid_device* handle,
const char* path,
unsigned short pid,
std::string dev_name
)
{
dev = handle;
location = path;
name = dev_name;
if(dev)
{
ReadFwVersion();
ReadSettings();
}
/*-----------------------------------------*\
| Initialize save flag |
\*-----------------------------------------*/
data.save_data = 0;
data.on_board_led.colorFlags = 0x81; // force MS bit of color flags to 1 to have expectd zone control
/*-----------------------------------------*\
| Initialize zone based per LED data |
\*-----------------------------------------*/
const mystic_light_162_config* board_config = nullptr;
for(std::size_t i = 0; i < NUMOF_CONFIGS; ++i)
{
if (board_configs[i].pid == pid)
{
board_config = &board_configs[i];
break;
}
}
if(board_config != nullptr)
{
numof_onboard_leds = board_config->numof_onboard_leds;
supported_zones = board_config->supported_zones;
}
else
{
numof_onboard_leds = 10;
supported_zones = &zones_set0;
}
}
MSIMysticLight162Controller::~MSIMysticLight162Controller()
{
hid_close(dev);
}
void MSIMysticLight162Controller::SetMode
(
MSI_ZONE zone,
MSI_MODE mode,
MSI_SPEED speed,
MSI_BRIGHTNESS brightness,
bool rainbow_color
)
{
ZoneData* zone_data = GetZoneData(data, zone);
if(zone_data == nullptr)
{
return;
}
if (zone <= MSI_ZONE_ON_BOARD_LED_0)
{
zone_data->effect = mode;
zone_data->speedAndBrightnessFlags = (brightness << 2) | (speed & 0x03);
zone_data->colorFlags = BITSET(zone_data->colorFlags, !rainbow_color, 7u);
zone_data->padding = 0x00;
if(mode > MSI_MODE_DOUBLE_FLASHING)
{
zone_data->speedAndBrightnessFlags |= SYNC_SETTING_JRGB;
zone_data->colorFlags |= SYNC_SETTING_ONBOARD;
}
else
{
zone_data->speedAndBrightnessFlags &= ~SYNC_SETTING_JRGB;
zone_data->colorFlags &= ~SYNC_SETTING_ONBOARD;
}
}
if((zone >= MSI_ZONE_ON_BOARD_LED_0) && (mode <= MSI_MODE_DOUBLE_FLASHING))
{
zone_data = GetZoneData(data, (MSI_ZONE)((int)zone + 1));
if(zone_data != nullptr)
{
zone_data->effect = mode;
zone_data->speedAndBrightnessFlags = (brightness << 2) | (speed & 0x03);
zone_data->colorFlags = BITSET(zone_data->colorFlags, !rainbow_color, 7u);
zone_data->padding = 0x00;
}
}
}
std::string MSIMysticLight162Controller::GetDeviceName()
{
return name;
}
std::string MSIMysticLight162Controller::GetFWVersion()
{
std::string firmware_version;
firmware_version = "APROM: " + version_APROM + ", LDROM: " + version_LDROM;
return firmware_version;
}
std::string MSIMysticLight162Controller::GetDeviceLocation()
{
return("HID: " + location);
}
std::string MSIMysticLight162Controller::GetSerial()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
if(ret != 0)
{
return("");
}
return(StringUtils::wstring_to_string(serial_string));
}
bool MSIMysticLight162Controller::ReadSettings()
{
/*-----------------------------------------------------*\
| Read packet from hardware, return true if successful |
\*-----------------------------------------------------*/
return(hid_get_feature_report(dev, (unsigned char*)&data, sizeof(data)) == sizeof data);
}
bool MSIMysticLight162Controller::Update
(
bool save
)
{
/*-----------------------------------------------------*\
| Send packet to hardware, return true if successful |
\*-----------------------------------------------------*/
data.save_data = save;
return (hid_send_feature_report(dev, (unsigned char*)&data, sizeof(data)) == sizeof(data));
}
void MSIMysticLight162Controller::SetZoneColor
(
MSI_ZONE zone,
unsigned char red1,
unsigned char grn1,
unsigned char blu1,
unsigned char red2,
unsigned char grn2,
unsigned char blu2
)
{
ZoneData* zone_data = GetZoneData(data, zone);
if(zone_data == nullptr)
{
return;
}
if (zone <= MSI_ZONE_ON_BOARD_LED_0)
{
zone_data->color.R = red1;
zone_data->color.G = grn1;
zone_data->color.B = blu1;
zone_data->color2.R = red2;
zone_data->color2.G = grn2;
zone_data->color2.B = blu2;
}
if(zone >= MSI_ZONE_ON_BOARD_LED_0)
{
zone_data = GetZoneData(data, (MSI_ZONE)((int)zone + 1));
if(zone_data != nullptr)
{
zone_data->color.R = red1;
zone_data->color.G = grn1;
zone_data->color.B = blu1;
zone_data->color2.R = red2;
zone_data->color2.G = grn2;
zone_data->color2.B = blu2;
}
}
}
ZoneData *MSIMysticLight162Controller::GetZoneData
(
FeaturePacket_162& data_packet,
MSI_ZONE zone
)
{
switch(zone)
{
case MSI_ZONE_J_RGB_1:
return &data_packet.j_rgb_1;
case MSI_ZONE_J_RGB_2:
return &data_packet.j_rgb_2;
case MSI_ZONE_J_RAINBOW_1:
return &data_packet.j_rainbow_1;
case MSI_ZONE_J_RAINBOW_2:
return &data_packet.on_board_led_10;
case MSI_ZONE_ON_BOARD_LED_0:
return &data_packet.on_board_led;
case MSI_ZONE_ON_BOARD_LED_1:
return &data_packet.on_board_led_1;
case MSI_ZONE_ON_BOARD_LED_2:
return &data_packet.on_board_led_2;
case MSI_ZONE_ON_BOARD_LED_3:
return &data_packet.on_board_led_3;
case MSI_ZONE_ON_BOARD_LED_4:
return &data_packet.on_board_led_4;
case MSI_ZONE_ON_BOARD_LED_5:
return &data_packet.on_board_led_5;
case MSI_ZONE_ON_BOARD_LED_6:
return &data_packet.on_board_led_6;
case MSI_ZONE_ON_BOARD_LED_7:
return &data_packet.on_board_led_7;
case MSI_ZONE_ON_BOARD_LED_8:
return &data_packet.on_board_led_8;
case MSI_ZONE_ON_BOARD_LED_9:
return &data_packet.on_board_led_9;
case MSI_ZONE_ON_BOARD_LED_10:
return &data_packet.on_board_led_10;
case MSI_ZONE_J_CORSAIR:
return &data_packet.j_corsair_1;
default:
break;
}
return nullptr;
}
bool MSIMysticLight162Controller::ReadFwVersion()
{
unsigned char request[64];
unsigned char response[64];
int ret_val = 64;
/*-----------------------------------------------------*\
| First read the APROM |
| Checksum also available at report ID 180, with MSB |
| stored at index 0x08 and LSB at 0x09 |
\*-----------------------------------------------------*/
/*-----------------------------------------------------*\
| Zero out buffers |
\*-----------------------------------------------------*/
memset(request, 0x00, sizeof(request));
memset(response, 0x00, sizeof(response));
/*-----------------------------------------------------*\
| Set up APROM Firmware Version Request packet |
\*-----------------------------------------------------*/
request[0x00] = 0x01;
request[0x01] = 0xB0;
/*-----------------------------------------------------*\
| Fill request from 0x02 to 0x61 with 0xCC |
\*-----------------------------------------------------*/
memset(&request[0x02], 0xCC, sizeof(request) - 2);
/*-----------------------------------------------------*\
| Send request and receive response packets |
\*-----------------------------------------------------*/
ret_val &= hid_write(dev, request, 64);
ret_val &= hid_read(dev, response, 64);
/*-----------------------------------------------------*\
| Extract high and low values from response |
\*-----------------------------------------------------*/
unsigned char highValue = response[2] >> 4;
unsigned char lowValue = response[2] & 0x0F;
/*-----------------------------------------------------*\
| Build firmware string <high>.<low> |
\*-----------------------------------------------------*/
version_APROM = std::to_string((int)highValue).append(".").append(std::to_string((int)lowValue));
/*-----------------------------------------------------*\
| First read the LDROM |
| Checksum also available at report ID 184, with MSB |
| stored at index 0x08 and LSB at 0x09 |
\*-----------------------------------------------------*/
/*-----------------------------------------------------*\
| Set up LDROM Firmware Version Request packet |
\*-----------------------------------------------------*/
request[0x00] = 0x01;
request[0x01] = 0xB6;
/*-----------------------------------------------------*\
| Send request and receive response packets |
\*-----------------------------------------------------*/
ret_val &= hid_write(dev, request, 64);
ret_val &= hid_read(dev, response, 64);
/*-----------------------------------------------------*\
| Extract high and low values from response |
\*-----------------------------------------------------*/
highValue = response[2] >> 4;
lowValue = response[2] & 0x0F;
/*-----------------------------------------------------*\
| Build firmware string <high>.<low> |
\*-----------------------------------------------------*/
version_LDROM = std::to_string((int)highValue).append(".").append(std::to_string((int)lowValue));
/*-----------------------------------------------------*\
| If return value is zero it means an HID transfer |
| failed |
\*-----------------------------------------------------*/
return(ret_val > 0);
}
MSI_MODE MSIMysticLight162Controller::GetMode()
{
return (MSI_MODE)data.on_board_led.effect;
}
void MSIMysticLight162Controller::GetMode
(
MSI_ZONE zone,
MSI_MODE &mode,
MSI_SPEED &speed,
MSI_BRIGHTNESS &brightness,
bool &rainbow_color,
unsigned int &color
)
{
/*-----------------------------------------------------*\
| Get data for given zone |
\*-----------------------------------------------------*/
ZoneData *zone_data = GetZoneData(data, zone);
/*-----------------------------------------------------*\
| Return if zone is invalid |
\*-----------------------------------------------------*/
if(zone_data == nullptr)
{
return;
}
/*-----------------------------------------------------*\
| Update pointers with data |
\*-----------------------------------------------------*/
mode = (MSI_MODE)zone_data->effect;
speed = (MSI_SPEED)(zone_data->speedAndBrightnessFlags & 0x03);
brightness = (MSI_BRIGHTNESS)((zone_data->speedAndBrightnessFlags >> 2) & 0x1F);
rainbow_color = (zone_data->colorFlags & 0x80) == 0 ? true : false;
color = ToRGBColor(zone_data->color.R, zone_data->color.G, zone_data->color.B);
}
size_t MSIMysticLight162Controller::GetMaxOnboardLeds()
{
return numof_onboard_leds;
}
Controllers/MSIMysticLightController/MSIMysticLight162Controller/MSIMysticLight162Controller.h
+98
View File
@@ -0,0 +1,98 @@
/*---------------------------------------------------------*\
| MSIMysticLight162Controller.h |
| |
| Driver for MSI Mystic Light 162-byte motherboard |
| |
| T-bond 03 Apr 2020 |
| Adam Honse 06 Mar 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <cstring>
#include <limits>
#include <hidapi.h>
#include "MSIMysticLightCommon.h"
#include "RGBController.h"
class MSIMysticLight162Controller
{
public:
MSIMysticLight162Controller
(
hid_device* handle,
const char* path,
unsigned short pid,
std::string dev_name
);
~MSIMysticLight162Controller();
void SetMode
(
MSI_ZONE zone,
MSI_MODE mode,
MSI_SPEED speed,
MSI_BRIGHTNESS brightness,
bool rainbow_color
);
MSI_MODE GetMode();
void GetMode
(
MSI_ZONE zone,
MSI_MODE &mode,
MSI_SPEED &speed,
MSI_BRIGHTNESS &brightness,
bool &rainbow_color,
unsigned int &color
);
void SetZoneColor
(
MSI_ZONE zone,
unsigned char red1,
unsigned char grn1,
unsigned char blu1,
unsigned char red2,
unsigned char grn2,
unsigned char blu2
);
bool Update
(
bool save
);
std::string GetDeviceName();
std::string GetDeviceLocation();
std::string GetFWVersion();
std::string GetSerial();
size_t GetMaxOnboardLeds();
const std::vector<MSI_ZONE>*
GetSupportedZones() { return supported_zones; }
private:
hid_device* dev;
std::string name;
std::string location;
std::string version_APROM;
std::string version_LDROM;
FeaturePacket_162 data;
size_t numof_onboard_leds;
const std::vector<MSI_ZONE>* supported_zones;
bool ReadSettings();
bool ReadFwVersion();
ZoneData* GetZoneData
(
FeaturePacket_162& dataPacket,
MSI_ZONE zone
);
};
Controllers/MSIMysticLightController/MSIMysticLight162Controller/RGBController_MSIMysticLight162.cpp
+392
View File
@@ -0,0 +1,392 @@
/*---------------------------------------------------------*\
| RGBController_MSIMysticLight162.cpp |
| |
| RGBController for MSI Mystic Light 162-byte motherboard |
| |
| T-bond 03 Apr 2020 |
| Adam Honse 06 Mar 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_MSIMysticLight162.h"
struct ZoneDescription
{
std::string name;
MSI_ZONE zone_type;
};
#define NUMOF_ZONES (sizeof(led_zones) / sizeof(ZoneDescription))
const ZoneDescription led_zones[] =
{
ZoneDescription{ "JRGB1", MSI_ZONE_J_RGB_1 },
ZoneDescription{ "JRGB2", MSI_ZONE_J_RGB_2 },
ZoneDescription{ "JRAINBOW1", MSI_ZONE_J_RAINBOW_1 },
ZoneDescription{ "JRAINBOW2", MSI_ZONE_J_RAINBOW_2 },
ZoneDescription{ "JCORSAIR", MSI_ZONE_J_CORSAIR },
ZoneDescription{ "Onboard LEDs", MSI_ZONE_ON_BOARD_LED_0 }
};
static std::vector<const ZoneDescription*> zone_description;
/**------------------------------------------------------------------*\
@name MSI Mystic Light (162 Byte)
@category Motherboard
@type USB
@save :robot:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectMSIMysticLightControllers
@comment
\*-------------------------------------------------------------------*/
RGBController_MSIMysticLight162::RGBController_MSIMysticLight162
(
MSIMysticLight162Controller* controller_ptr
)
{
controller = controller_ptr;
name = controller->GetDeviceName();
vendor = "MSI";
type = DEVICE_TYPE_MOTHERBOARD;
description = "MSI Mystic Light Device (162-byte)";
version = controller->GetFWVersion();
location = controller->GetDeviceLocation();
serial = controller->GetSerial();
const std::vector<MSI_ZONE>* supported_zones = controller->GetSupportedZones();
for(std::size_t i = 0; i < supported_zones->size(); ++i)
{
for(std::size_t j = 0; j < NUMOF_ZONES; ++j)
{
if(led_zones[j].zone_type == (*supported_zones)[i])
{
zone_description.push_back(&led_zones[j]);
break;
}
}
}
SetupModes();
SetupZones();
SetupColors();
active_mode = GetDeviceMode();
GetDeviceConfig();
}
RGBController_MSIMysticLight162::~RGBController_MSIMysticLight162()
{
zone_description.clear();
delete controller;
}
int RGBController_MSIMysticLight162::GetDeviceMode()
{
MSI_MODE mode = controller->GetMode();
for(unsigned int i = 0; i < modes.size(); ++i)
{
if(mode == modes[i].value)
{
return i;
}
}
return 0;
}
void RGBController_MSIMysticLight162::SetupZones()
{
/*---------------------------------------------------------*\
| Set up zones |
\*---------------------------------------------------------*/
for(std::size_t zone_idx = 0; zone_idx < zone_description.size(); ++zone_idx)
{
const ZoneDescription* zd = zone_description[zone_idx];
zone new_zone;
new_zone.name = zd->name;
/*--------------------------------------------------\
| 162-byte MSI does not have resizable zones, but |
| onboard LED zones have multiple LEDs |
\*-------------------------------------------------*/
if(zd->zone_type == MSI_ZONE_ON_BOARD_LED_0)
{
new_zone.leds_max = (int)controller->GetMaxOnboardLeds();
}
else
{
new_zone.leds_max = 1;
}
new_zone.leds_min = new_zone.leds_max;
new_zone.leds_count = new_zone.leds_max;
/*-------------------------------------------------*\
| Determine zone type based on max number of LEDs |
\*-------------------------------------------------*/
if(new_zone.leds_max == 1)
{
new_zone.type = ZONE_TYPE_SINGLE;
}
else
{
new_zone.type = ZONE_TYPE_LINEAR;
}
new_zone.matrix_map = NULL;
zones.push_back(new_zone);
}
/*---------------------------------------------------------*\
| Set up LEDs |
\*---------------------------------------------------------*/
for(std::size_t zone_idx = 0; zone_idx < zone_description.size(); ++zone_idx)
{
for(std::size_t led_idx = 0; led_idx < zones[zone_idx].leds_count; ++led_idx)
{
led new_led;
new_led.name = zones[zone_idx].name + " LED ";
if(zones[zone_idx].leds_count > 1)
{
new_led.name.append(std::to_string(led_idx + 1));
}
new_led.value = (unsigned int)(zone_description[zone_idx]->zone_type + led_idx);
leds.push_back(new_led);
}
}
}
void RGBController_MSIMysticLight162::ResizeZone
(
int /*zone*/,
int /*new_size*/
)
{
}
void RGBController_MSIMysticLight162::DeviceUpdateLEDs()
{
for(std::size_t zone_idx = 0; zone_idx < zones.size(); ++zone_idx)
{
for(int led_idx = zones[zone_idx].leds_count - 1; led_idx >= 0; led_idx--)
{
UpdateLed((int)zone_idx, led_idx);
}
}
controller->Update((modes[active_mode].flags & MODE_FLAG_AUTOMATIC_SAVE) != 0);
}
void RGBController_MSIMysticLight162::UpdateZoneLEDs
(
int zone
)
{
for(int led_idx = zones[zone].leds_count - 1; led_idx >= 0; led_idx--)
{
UpdateLed(zone, led_idx);
}
controller->Update((modes[active_mode].flags & MODE_FLAG_AUTOMATIC_SAVE) != 0);
}
void RGBController_MSIMysticLight162::UpdateSingleLED
(
int led
)
{
UpdateLed(leds[led].value, led);
controller->Update((modes[active_mode].flags & MODE_FLAG_AUTOMATIC_SAVE) != 0);
}
void RGBController_MSIMysticLight162::DeviceUpdateMode()
{
DeviceUpdateLEDs();
}
void RGBController_MSIMysticLight162::DeviceSaveMode()
{
controller->Update(true);
}
void RGBController_MSIMysticLight162::SetupModes()
{
constexpr unsigned int PER_LED_ONLY = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE;
constexpr unsigned int RANDOM_ONLY = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_MANUAL_SAVE;
constexpr unsigned int COMMON = RANDOM_ONLY | MODE_FLAG_HAS_PER_LED_COLOR;
SetupMode("Direct", MSI_MODE_STATIC, MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE);
// SetupMode("Off", MSI_MODE_DISABLE, 0);
SetupMode("Breathing", MSI_MODE_BREATHING, PER_LED_ONLY);
SetupMode("Flashing", MSI_MODE_FLASHING, COMMON);
SetupMode("Double flashing", MSI_MODE_DOUBLE_FLASHING, COMMON);
SetupMode("Lightning", MSI_MODE_LIGHTNING, PER_LED_ONLY);
// SetupMode("MSI Marquee", MSI_MODE_MSI_MARQUEE, COMMON);
SetupMode("Meteor", MSI_MODE_METEOR, COMMON);
SetupMode("Stack", MSI_MODE_WATER_DROP, COMMON);
// SetupMode("MSI Rainbow", MSI_MODE_MSI_RAINBOW, RANDOM_ONLY);
// SetupMode("Pop", MSI_MODE_POP, COMMON);
// SetupMode("Rap", MSI_MODE_RAP, COMMON);
// SetupMode("Jazz", MSI_MODE_JAZZ, COMMON);
// SetupMode("Play", MSI_MODE_PLAY, COMMON);
// SetupMode("Movie", MSI_MODE_MOVIE, COMMON);
SetupMode("Rainbow", MSI_MODE_COLOR_RING, COMMON);
SetupMode("Planetary", MSI_MODE_PLANETARY, RANDOM_ONLY);
SetupMode("Double meteor", MSI_MODE_DOUBLE_METEOR, RANDOM_ONLY);
SetupMode("Energy", MSI_MODE_ENERGY, RANDOM_ONLY);
SetupMode("Blink", MSI_MODE_BLINK, COMMON);
SetupMode("Clock", MSI_MODE_CLOCK, RANDOM_ONLY);
SetupMode("Color pulse", MSI_MODE_COLOR_PULSE, COMMON);
SetupMode("Color shift", MSI_MODE_COLOR_SHIFT, RANDOM_ONLY);
SetupMode("Color wave", MSI_MODE_COLOR_WAVE, COMMON);
SetupMode("Marquee", MSI_MODE_MARQUEE, PER_LED_ONLY);
// SetupMode("Rainbow", MSI_MODE_RAINBOW, COMMON);
SetupMode("Rainbow wave", MSI_MODE_RAINBOW_WAVE, RANDOM_ONLY);
SetupMode("Visor", MSI_MODE_VISOR, COMMON);
// SetupMode("JRainbow", MSI_MODE_JRAINBOW, COMMON);
SetupMode("Rainbow flashing", MSI_MODE_RAINBOW_FLASHING, RANDOM_ONLY);
SetupMode("Rainbow double flashing", MSI_MODE_RAINBOW_DOUBLE_FLASHING, RANDOM_ONLY);
// SetupMode("Random", MSI_MODE_RANDOM, COMMON);
// SetupMode("Fan control", MSI_MODE_FAN_CONTROL, COMMON);
// SetupMode("Off 2", MSI_MODE_DISABLE_2, COMMON);
// SetupMode("Color ring flashing", MSI_MODE_COLOR_RING_FLASHING, COMMON);
// SetupMode("Color ring double flashing", MSI_MODE_COLOR_RING_DOUBLE_FLASHING, COMMON);
// SetupMode("Stack", MSI_MODE_STACK, COMMON);
// SetupMode("Corsair Que", MSI_MODE_CORSAIR_QUE, COMMON);
// SetupMode("Fire", MSI_MODE_FIRE, COMMON);
// SetupMode("Lava", MSI_MODE_LAVA, COMMON);
}
void RGBController_MSIMysticLight162::UpdateLed
(
int zone,
int led
)
{
unsigned char red = RGBGetRValue(zones[zone].colors[led]);
unsigned char grn = RGBGetGValue(zones[zone].colors[led]);
unsigned char blu = RGBGetBValue(zones[zone].colors[led]);
bool random = modes[active_mode].color_mode == MODE_COLORS_RANDOM;
MSI_MODE mode = (MSI_MODE)modes[active_mode].value;
MSI_SPEED speed = (MSI_SPEED)modes[active_mode].speed;
MSI_BRIGHTNESS brightness = (MSI_BRIGHTNESS)modes[active_mode].brightness;
controller->SetMode((MSI_ZONE)zones[zone].leds[led].value, mode, speed, brightness, random);
controller->SetZoneColor((MSI_ZONE)zones[zone].leds[led].value, red, grn, blu, red, grn, blu);
}
void RGBController_MSIMysticLight162::SetupMode
(
const char *name,
MSI_MODE mod,
unsigned int flags
)
{
mode Mode;
Mode.name = name;
Mode.value = mod;
Mode.flags = flags;
if(flags & MODE_FLAG_HAS_PER_LED_COLOR)
{
Mode.color_mode = MODE_COLORS_PER_LED;
}
else
{
Mode.color_mode = MODE_COLORS_RANDOM;
}
if(flags & MODE_FLAG_HAS_SPEED)
{
Mode.speed = MSI_SPEED_MEDIUM;
Mode.speed_max = MSI_SPEED_HIGH;
Mode.speed_min = MSI_SPEED_LOW;
}
else
{
/*---------------------------------------------------------*\
| For modes without speed this needs to be set to avoid |
| bad values in the saved profile which in turn corrupts |
| the brightness calculation when loading the profile |
\*---------------------------------------------------------*/
Mode.speed = 0;
Mode.speed_max = 0;
Mode.speed_min = 0;
}
if(flags & MODE_FLAG_HAS_BRIGHTNESS)
{
Mode.brightness = MSI_BRIGHTNESS_LEVEL_100;
Mode.brightness_max = MSI_BRIGHTNESS_LEVEL_100;
Mode.brightness_min = MSI_BRIGHTNESS_OFF;
}
else
{
Mode.brightness = MSI_BRIGHTNESS_LEVEL_100;
Mode.brightness_max = MSI_BRIGHTNESS_LEVEL_100;
Mode.brightness_min = MSI_BRIGHTNESS_LEVEL_100;
}
modes.push_back(Mode);
}
void RGBController_MSIMysticLight162::GetDeviceConfig()
{
MSI_MODE mode;
MSI_SPEED speed;
MSI_BRIGHTNESS brightness;
bool rainbow;
unsigned int color;
for(size_t i = 0; i < zone_description.size(); ++i)
{
controller->GetMode(zone_description[i]->zone_type, mode, speed, brightness, rainbow, color);
for(size_t j = 0; j < zones[i].leds_count; ++j)
{
zones[i].colors[j] = color;
}
}
controller->GetMode(zone_description[0]->zone_type, mode, speed, brightness, rainbow, color);
for(size_t i = 0; i < modes.size(); ++i)
{
if(mode == modes[i].value)
{
if(modes[i].flags & MODE_FLAG_HAS_SPEED)
{
modes[i].speed = speed;
}
if(modes[i].flags & MODE_FLAG_HAS_BRIGHTNESS)
{
modes[i].brightness = brightness;
}
if(rainbow)
{
if(modes[i].flags & (MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR))
{
if(rainbow)
{
modes[i].color_mode = MODE_COLORS_RANDOM;
}
else
{
modes[i].color_mode = MODE_COLORS_PER_LED;
}
}
}
break;
}
}
}
Controllers/MSIMysticLightController/MSIMysticLight162Controller/RGBController_MSIMysticLight162.h
+52
View File
@@ -0,0 +1,52 @@
/*---------------------------------------------------------*\
| RGBController_MSIMysticLight162.h |
| |
| RGBController for MSI Mystic Light 162-byte motherboard |
| |
| T-bond 03 Apr 2020 |
| Adam Honse 06 Mar 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <vector>
#include "RGBController.h"
#include "MSIMysticLight162Controller.h"
class RGBController_MSIMysticLight162: public RGBController
{
public:
RGBController_MSIMysticLight162(MSIMysticLight162Controller* controller_ptr);
~RGBController_MSIMysticLight162();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
void DeviceSaveMode();
private:
void SetupModes();
void UpdateLed
(
int zone,
int led
);
void SetupMode
(
const char *name,
MSI_MODE mode,
unsigned int flags
);
int GetDeviceMode();
void GetDeviceConfig();
MSIMysticLight162Controller* controller;
};
Controllers/MSIMysticLightController/MSIMysticLight185Controller/MSIMysticLight185Controller.cpp
+1294
View File
File diff suppressed because it is too large Load Diff
Controllers/MSIMysticLightController/MSIMysticLight185Controller/MSIMysticLight185Controller.h
+157
View File
@@ -0,0 +1,157 @@
/*---------------------------------------------------------*\
| MSIMysticLight185Controller.h |
| |
| Driver for MSI Mystic Light 185-byte motherboard |
| |
| Direct mode functionality has been implemented based on |
| the mystic-why project provided by Aleksandr |
| Garashchenko |
| (https://github.com/garashchenko/mystic-why) |
| |
| T-bond 03 Apr 2020 |
| Adam Honse 06 Mar 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <cstring>
#include <limits>
#include <hidapi.h>
#include "MSIMysticLightCommon.h"
#include "RGBController.h"
class MSIMysticLight185Controller
{
public:
MSIMysticLight185Controller
(
hid_device* handle,
const char* path,
unsigned short pid,
std::string dev_name
);
~MSIMysticLight185Controller();
void SetMode
(
MSI_ZONE zone,
MSI_MODE mode,
MSI_SPEED speed,
MSI_BRIGHTNESS brightness,
bool rainbow_color
);
MSI_MODE GetMode();
void GetMode
(
MSI_ZONE zone,
MSI_MODE &mode,
MSI_SPEED &speed,
MSI_BRIGHTNESS &brightness,
bool &rainbow_color,
unsigned int &color
);
void SetZoneColor
(
MSI_ZONE zone,
unsigned char red1,
unsigned char grn1,
unsigned char blu1,
unsigned char red2,
unsigned char grn2,
unsigned char blu2
);
void SetLedColor
(
MSI_ZONE zone,
int index,
unsigned char red,
unsigned char grn,
unsigned char blu
);
void SetCycleCount
(
MSI_ZONE zone,
unsigned char cycle_num
);
bool Update
(
bool save
);
std::string GetDeviceName();
std::string GetDeviceLocation();
std::string GetFWVersion();
std::string GetSerial();
void SetDirectMode
(
bool mode
);
bool IsDirectModeActive() { return direct_mode; }
size_t GetMaxDirectLeds
(
MSI_ZONE zone
);
const std::vector<MSI_ZONE>*
GetSupportedZones() { return supported_zones; }
enum DIRECT_MODE
{
DIRECT_MODE_DISABLED,
DIRECT_MODE_PER_LED,
DIRECT_MODE_ZONE_BASED
};
DIRECT_MODE GetSupportedDirectMode() { return per_led_mode; }
private:
hid_device* dev;
std::string name;
std::string location;
std::string version_APROM;
std::string version_LDROM;
FeaturePacket_185 data;
FeaturePacket_PerLED_185 per_led_data_onboard_and_sync;
FeaturePacket_PerLED_185 per_led_data_jrainbow1;
FeaturePacket_PerLED_185 per_led_data_jrainbow2;
FeaturePacket_PerLED_185 per_led_data_jcorsair;
FeaturePacket_185 zone_based_per_led_data;
bool direct_mode;
bool sync_direct_mode;
bool no_onboards;
bool no_jrainbow1;
bool no_jrainbow2;
bool no_jcorsair;
bool mixed_mode_support;
int numof_onboard_leds;
int numof_pipe1_leds;
int numof_pipe2_leds;
int numof_JRGBs;
const std::vector<MSI_ZONE>* supported_zones;
DIRECT_MODE per_led_mode;
bool ReadSettings();
bool ReadFwVersion();
ZoneData* GetZoneData
(
FeaturePacket_185& data_packet,
MSI_ZONE zone
);
RainbowZoneData* GetRainbowZoneData(MSI_ZONE zone);
Color* GetPerLedZoneData
(
MSI_ZONE zone
);
void SelectPerLedProtocol();
};
Controllers/MSIMysticLightController/MSIMysticLight185Controller/RGBController_MSIMysticLight185.cpp
+520
View File
@@ -0,0 +1,520 @@
/*---------------------------------------------------------*\
| RGBController_MSIMysticLight185.cpp |
| |
| RGBController for MSI Mystic Light 185-byte motherboard |
| |
| T-bond 03 Apr 2020 |
| Adam Honse 06 Mar 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_MSIMysticLight185.h"
#include "LogManager.h"
struct ZoneDescription
{
std::string name;
MSI_ZONE zone_type;
};
#define NUMOF_ZONES (sizeof(led_zones) / sizeof(ZoneDescription))
const ZoneDescription led_zones[] =
{
ZoneDescription{ "JRGB1", MSI_ZONE_J_RGB_1 },
ZoneDescription{ "JRGB2", MSI_ZONE_J_RGB_2 },
ZoneDescription{ "JRAINBOW1", MSI_ZONE_J_RAINBOW_1 },
ZoneDescription{ "JRAINBOW2", MSI_ZONE_J_RAINBOW_2 },
ZoneDescription{ "JRAINBOW3", MSI_ZONE_J_RAINBOW_3 },
ZoneDescription{ "JCORSAIR", MSI_ZONE_J_CORSAIR },
ZoneDescription{ "PIPE1", MSI_ZONE_J_PIPE_1 },
ZoneDescription{ "PIPE2", MSI_ZONE_J_PIPE_2 },
ZoneDescription{ "ONBOARD", MSI_ZONE_ON_BOARD_LED_0 }
};
static std::vector<const ZoneDescription*> zone_description;
/*---------------------------------------------------------------------------------------------------------*\
| Returns the index of the zone_description in led_zones which has zone_type equal to the given zone_type. |
| Returns -1 if no such zone_description exists. |
\*---------------------------------------------------------------------------------------------------------*/
static int IndexOfZoneForType(MSI_ZONE zone_type)
{
for(size_t i = 0; i < zone_description.size(); ++i)
{
if(zone_description[i]->zone_type == zone_type)
{
return (int)i;
}
}
return -1;
}
/**------------------------------------------------------------------*\
@name MSI Mystic Light (185 Byte)
@category Motherboard
@type USB
@save :robot:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectMSIMysticLightControllers
@comment
\*-------------------------------------------------------------------*/
RGBController_MSIMysticLight185::RGBController_MSIMysticLight185
(
MSIMysticLight185Controller* controller_ptr
)
{
controller = controller_ptr;
name = controller->GetDeviceName();
vendor = "MSI";
type = DEVICE_TYPE_MOTHERBOARD;
description = "MSI Mystic Light Device (185-byte)";
version = controller->GetFWVersion();
location = controller->GetDeviceLocation();
serial = controller->GetSerial();
const std::vector<MSI_ZONE>* supported_zones = controller->GetSupportedZones();
for(std::size_t i = 0; i < supported_zones->size(); ++i)
{
for(std::size_t j = 0; j < NUMOF_ZONES; ++j)
{
if(led_zones[j].zone_type == (*supported_zones)[i])
{
zone_description.push_back(&led_zones[j]);
break;
}
}
}
last_resizable_zone = MSI_ZONE_NONE;
SetupModes();
SetupZones();
active_mode = GetDeviceMode();
}
RGBController_MSIMysticLight185::~RGBController_MSIMysticLight185()
{
zone_description.clear();
delete controller;
}
int RGBController_MSIMysticLight185::GetDeviceMode()
{
MSI_MODE mode = controller->GetMode();
for(unsigned int i = 0; i < modes.size(); ++i)
{
if(mode == modes[i].value)
{
return i;
}
}
return 0;
}
void RGBController_MSIMysticLight185::SetupZones()
{
/*-------------------------------------------------*\
| Clear any existing color/LED configuration |
\*-------------------------------------------------*/
leds.clear();
colors.clear();
bool first_run = false;
if(zones.size() == 0)
{
first_run = true;
}
if(first_run)
{
/*---------------------------------------------------------*\
| Set up zones |
\*---------------------------------------------------------*/
for(std::size_t zone_idx = 0; zone_idx < zone_description.size(); ++zone_idx)
{
const ZoneDescription* zd = zone_description[zone_idx];
zone new_zone;
new_zone.name = zd->name;
new_zone.flags = 0;
int maxLeds = (int)controller->GetMaxDirectLeds(zd->zone_type);
/*-------------------------------------------------*\
| This is a fixed size zone |
\*-------------------------------------------------*/
if(((zd->zone_type != MSI_ZONE_J_RAINBOW_1)
&& (zd->zone_type != MSI_ZONE_J_RAINBOW_2)
&& (zd->zone_type != MSI_ZONE_J_RAINBOW_3)
&& (zd->zone_type != MSI_ZONE_J_CORSAIR)))
{
new_zone.leds_min = maxLeds;
new_zone.leds_max = maxLeds;
new_zone.leds_count = maxLeds;
}
/*--------------------------------------------------\
| This is a resizable zone on a board that does not |
| support per-LED direct mode |
\*-------------------------------------------------*/
else if(controller->GetSupportedDirectMode() == MSIMysticLight185Controller::DIRECT_MODE_ZONE_BASED)
{
new_zone.leds_min = 0;
new_zone.leds_max = 30;//maxLeds;
new_zone.leds_count = 0;
last_resizable_zone = zd->zone_type;
new_zone.flags |= ZONE_FLAG_RESIZE_EFFECTS_ONLY;
}
/*--------------------------------------------------\
| This is a resizable zone on a board that does |
| support per-LED direct mode |
\*-------------------------------------------------*/
else
{
new_zone.leds_min = 0;
new_zone.leds_max = maxLeds;
new_zone.leds_count = 0;
last_resizable_zone = zd->zone_type;
}
/*-------------------------------------------------*\
| Determine zone type based on max number of LEDs |
\*-------------------------------------------------*/
if((new_zone.leds_max == 1) || (new_zone.flags & ZONE_FLAG_RESIZE_EFFECTS_ONLY))
{
new_zone.type = ZONE_TYPE_SINGLE;
}
else
{
new_zone.type = ZONE_TYPE_LINEAR;
}
new_zone.matrix_map = NULL;
zones.push_back(new_zone);
}
}
/*---------------------------------------------------------*\
| Set up LEDs |
\*---------------------------------------------------------*/
for(std::size_t zone_idx = 0; zone_idx < zone_description.size(); ++zone_idx)
{
controller->SetCycleCount(zone_description[zone_idx]->zone_type, zones[zone_idx].leds_count);
if((zones[zone_idx].flags & ZONE_FLAG_RESIZE_EFFECTS_ONLY) == 0)
{
for(std::size_t led_idx = 0; led_idx < zones[zone_idx].leds_count; ++led_idx)
{
led new_led;
new_led.name = zones[zone_idx].name;
if(zones[zone_idx].leds_count > 1)
{
new_led.name.append(" LED " + std::to_string(led_idx + 1));
}
new_led.value = zone_description[zone_idx]->zone_type;
leds.push_back(new_led);
}
}
else if(zones[zone_idx].leds_count > 0)
{
led new_led;
new_led.name = zones[zone_idx].name;
new_led.value = zone_description[zone_idx]->zone_type;
leds.push_back(new_led);
}
}
SetupColors();
}
void RGBController_MSIMysticLight185::ResizeZone
(
int zone,
int new_size
)
{
if((size_t)zone >= zones.size())
{
return;
}
if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
{
zones[zone].leds_count = new_size;
SetupZones();
if(zone_description[zone]->zone_type == last_resizable_zone)
{
GetDeviceConfig();
last_resizable_zone = MSI_ZONE_NONE;
}
}
}
void RGBController_MSIMysticLight185::DeviceUpdateLEDs()
{
for(std::size_t zone_idx = 0; zone_idx < zones.size(); ++zone_idx)
{
for(int led_idx = zones[zone_idx].leds_count - 1; led_idx >= 0; led_idx--)
{
UpdateLed((int)zone_idx, led_idx);
}
}
controller->Update((modes[active_mode].flags & MODE_FLAG_AUTOMATIC_SAVE) != 0);
}
void RGBController_MSIMysticLight185::UpdateZoneLEDs(int zone)
{
for(int led_idx = zones[zone].leds_count - 1; led_idx >= 0; led_idx--)
{
UpdateLed(zone, led_idx);
}
controller->Update((modes[active_mode].flags & MODE_FLAG_AUTOMATIC_SAVE) != 0);
}
void RGBController_MSIMysticLight185::UpdateSingleLED
(
int led
)
{
int zone_index = IndexOfZoneForType((MSI_ZONE)leds[led].value);
if(zone_index == -1)
{
LOG_DEBUG("[%s]: could not find zone for type %d", controller->GetDeviceName().c_str(), leds[led].value);
return;
}
int led_index = led - zones[zone_index].start_idx;
UpdateLed(zone_index, led_index);
controller->Update((modes[active_mode].flags & MODE_FLAG_AUTOMATIC_SAVE) != 0);
}
void RGBController_MSIMysticLight185::DeviceUpdateMode()
{
if(modes[active_mode].value == MSI_MODE_DIRECT_DUMMY)
{
controller->SetDirectMode(true);
}
else
{
controller->SetDirectMode(false);
DeviceUpdateLEDs();
}
}
void RGBController_MSIMysticLight185::DeviceSaveMode()
{
controller->Update(true);
}
void RGBController_MSIMysticLight185::SetupModes()
{
constexpr unsigned int PER_LED_ONLY = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE;
constexpr unsigned int RANDOM_ONLY = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_MANUAL_SAVE;
constexpr unsigned int COMMON = RANDOM_ONLY | MODE_FLAG_HAS_PER_LED_COLOR;
if(controller->GetSupportedDirectMode() != MSIMysticLight185Controller::DIRECT_MODE_DISABLED)
{
SetupMode("Direct", MSI_MODE_DIRECT_DUMMY, MODE_FLAG_HAS_PER_LED_COLOR);
}
SetupMode("Static", MSI_MODE_STATIC, MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE);
// SetupMode("Off", MSI_MODE_DISABLE, 0);
SetupMode("Breathing", MSI_MODE_BREATHING, PER_LED_ONLY);
SetupMode("Flashing", MSI_MODE_FLASHING, COMMON);
SetupMode("Double flashing", MSI_MODE_DOUBLE_FLASHING, COMMON);
SetupMode("Lightning", MSI_MODE_LIGHTNING, PER_LED_ONLY);
// SetupMode("MSI Marquee", MSI_MODE_MSI_MARQUEE, COMMON);
SetupMode("Meteor", MSI_MODE_METEOR, COMMON);
// SetupMode("Water drop", MSI_MODE_WATER_DROP, COMMON);
// SetupMode("MSI Rainbow", MSI_MODE_MSI_RAINBOW, RANDOM_ONLY);
// SetupMode("Pop", MSI_MODE_POP, COMMON);
// SetupMode("Rap", MSI_MODE_RAP, COMMON);
// SetupMode("Jazz", MSI_MODE_JAZZ, COMMON);
// SetupMode("Play", MSI_MODE_PLAY, COMMON);
// SetupMode("Movie", MSI_MODE_MOVIE, COMMON);
SetupMode("Color ring", MSI_MODE_COLOR_RING, RANDOM_ONLY);
SetupMode("Planetary", MSI_MODE_PLANETARY, RANDOM_ONLY);
SetupMode("Double meteor", MSI_MODE_DOUBLE_METEOR, RANDOM_ONLY);
SetupMode("Energy", MSI_MODE_ENERGY, RANDOM_ONLY);
SetupMode("Blink", MSI_MODE_BLINK, COMMON);
SetupMode("Clock", MSI_MODE_CLOCK, RANDOM_ONLY);
SetupMode("Color pulse", MSI_MODE_COLOR_PULSE, COMMON);
SetupMode("Color shift", MSI_MODE_COLOR_SHIFT, RANDOM_ONLY);
SetupMode("Color wave", MSI_MODE_COLOR_WAVE, COMMON);
SetupMode("Marquee", MSI_MODE_MARQUEE, PER_LED_ONLY);
// SetupMode("Rainbow", MSI_MODE_RAINBOW, COMMON);
SetupMode("Rainbow wave", MSI_MODE_RAINBOW_WAVE, RANDOM_ONLY);
SetupMode("Visor", MSI_MODE_VISOR, COMMON);
// SetupMode("JRainbow", MSI_MODE_JRAINBOW, COMMON);
SetupMode("Rainbow flashing", MSI_MODE_RAINBOW_FLASHING, RANDOM_ONLY);
// SetupMode("Rainbow double flashing", MSI_MODE_RAINBOW_DOUBLE_FLASHING, COMMON);
// SetupMode("Random", MSI_MODE_RANDOM, COMMON);
// SetupMode("Fan control", MSI_MODE_FAN_CONTROL, COMMON);
// SetupMode("Off 2", MSI_MODE_DISABLE_2, COMMON);
// SetupMode("Color ring flashing", MSI_MODE_COLOR_RING_FLASHING, COMMON);
SetupMode("Color ring double flashing", MSI_MODE_COLOR_RING_DOUBLE_FLASHING, RANDOM_ONLY);
SetupMode("Stack", MSI_MODE_STACK, COMMON);
// SetupMode("Corsair Que", MSI_MODE_CORSAIR_QUE, COMMON);
SetupMode("Fire", MSI_MODE_FIRE, RANDOM_ONLY);
// SetupMode("Lava", MSI_MODE_LAVA, COMMON);
}
void RGBController_MSIMysticLight185::UpdateLed
(
int zone,
int led
)
{
unsigned char red = RGBGetRValue(zones[zone].colors[led]);
unsigned char grn = RGBGetGValue(zones[zone].colors[led]);
unsigned char blu = RGBGetBValue(zones[zone].colors[led]);
if(controller->IsDirectModeActive())
{
controller->SetLedColor((MSI_ZONE)(zones[zone].leds[led].value), led, red, grn, blu);
}
else
{
if(led == 0)
{
bool random = modes[active_mode].color_mode == MODE_COLORS_RANDOM;
MSI_MODE mode = (MSI_MODE)modes[active_mode].value;
MSI_SPEED speed = (MSI_SPEED)modes[active_mode].speed;
MSI_BRIGHTNESS brightness = (MSI_BRIGHTNESS)modes[active_mode].brightness;
controller->SetMode((MSI_ZONE)zones[zone].leds[led].value, mode, speed, brightness, random);
controller->SetZoneColor((MSI_ZONE)zones[zone].leds[led].value, red, grn, blu, red, grn, blu);
}
}
}
void RGBController_MSIMysticLight185::SetupMode
(
const char *name,
MSI_MODE mod,
unsigned int flags
)
{
mode Mode;
Mode.name = name;
Mode.value = mod;
Mode.flags = flags;
if(flags & MODE_FLAG_HAS_PER_LED_COLOR)
{
Mode.color_mode = MODE_COLORS_PER_LED;
}
else
{
Mode.color_mode = MODE_COLORS_RANDOM;
}
if(flags & MODE_FLAG_HAS_SPEED)
{
Mode.speed = MSI_SPEED_MEDIUM;
Mode.speed_max = MSI_SPEED_HIGH;
Mode.speed_min = MSI_SPEED_LOW;
}
else
{
/*---------------------------------------------------------*\
| For modes without speed this needs to be set to avoid |
| bad values in the saved profile which in turn corrupts |
| the brightness calculation when loading the profile |
\*---------------------------------------------------------*/
Mode.speed = 0;
Mode.speed_max = 0;
Mode.speed_min = 0;
}
if(flags & MODE_FLAG_HAS_BRIGHTNESS)
{
Mode.brightness = MSI_BRIGHTNESS_LEVEL_100;
Mode.brightness_max = MSI_BRIGHTNESS_LEVEL_100;
Mode.brightness_min = MSI_BRIGHTNESS_OFF;
}
else
{
Mode.brightness = MSI_BRIGHTNESS_LEVEL_100;
Mode.brightness_max = MSI_BRIGHTNESS_LEVEL_100;
Mode.brightness_min = MSI_BRIGHTNESS_LEVEL_100;
}
modes.push_back(Mode);
}
void RGBController_MSIMysticLight185::GetDeviceConfig()
{
if(controller->GetMode() != MSI_MODE_DIRECT_DUMMY)
{
MSI_MODE mode;
MSI_SPEED speed;
MSI_BRIGHTNESS brightness;
bool rainbow;
unsigned int color;
for(size_t i = 0; i < zone_description.size(); ++i)
{
controller->GetMode(zone_description[i]->zone_type, mode, speed, brightness, rainbow, color);
if(zones[i].colors != nullptr)
{
for(size_t j = 0; j < GetLEDsInZone((unsigned int)i); ++j)
{
zones[i].colors[j] = color;
}
}
}
controller->GetMode(zone_description[0]->zone_type, mode, speed, brightness, rainbow, color);
for(size_t i = 0; i < modes.size(); ++i)
{
if(mode == modes[i].value)
{
if(modes[i].flags & MODE_FLAG_HAS_SPEED)
{
modes[i].speed = speed;
}
if(modes[i].flags & MODE_FLAG_HAS_BRIGHTNESS)
{
modes[i].brightness = brightness;
}
if(rainbow)
{
if(modes[i].flags & (MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR))
{
if(rainbow)
{
modes[i].color_mode = MODE_COLORS_RANDOM;
}
else
{
modes[i].color_mode = MODE_COLORS_PER_LED;
}
}
}
break;
}
}
}
}
Controllers/MSIMysticLightController/MSIMysticLight185Controller/RGBController_MSIMysticLight185.h
+53
View File
@@ -0,0 +1,53 @@
/*---------------------------------------------------------*\
| RGBController_MSIMysticLight185.h |
| |
| RGBController for MSI Mystic Light 185-byte motherboard |
| |
| T-bond 03 Apr 2020 |
| Adam Honse 06 Mar 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <vector>
#include "RGBController.h"
#include "MSIMysticLight185Controller.h"
class RGBController_MSIMysticLight185: public RGBController
{
public:
RGBController_MSIMysticLight185(MSIMysticLight185Controller* controller_ptr);
~RGBController_MSIMysticLight185();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
void DeviceSaveMode();
private:
void SetupModes();
void UpdateLed
(
int zone,
int led
);
void SetupMode
(
const char *name,
MSI_MODE mode,
unsigned int flags
);
int GetDeviceMode();
void GetDeviceConfig();
MSIMysticLight185Controller* controller;
MSI_ZONE last_resizable_zone;
};
Controllers/MSIMysticLightController/MSIMysticLight64Controller/MSIMysticLight64Controller.cpp
+115
View File
@@ -0,0 +1,115 @@
/*---------------------------------------------------------*\
| MSIMysticLight64Controller.cpp |
| |
| Driver for MSI Mystic Light 64-byte motherboard |
| |
| T-bond 03 Apr 2020 |
| Adam Honse 06 Mar 2021 |
| Elchanan Haas 23 Aug 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <algorithm>
#include <array>
#include <bitset>
#include "MSIMysticLight64Controller.h"
#include "StringUtils.h"
MSIMysticLight64Controller::MSIMysticLight64Controller
(
hid_device *handle,
const char *path
)
{
dev = handle;
if(dev)
{
location = path;
}
}
MSIMysticLight64Controller::~MSIMysticLight64Controller()
{
hid_close(dev);
}
void MSIMysticLight64Controller::SetMode
(
MSI_64_MODE mode,
MSI_SPEED speed,
MSI_BRIGHTNESS brightness,
unsigned int num_colors,
Color colors[]
)
{
FeaturePacket_64 data;
for(int i = 0; i < MSI_64_MAX_COLORS; i++)
{
data.colors[i] = colors[i];
}
data.speed = speed;
data.brightness = brightness;
data.num_colors = num_colors;
data.mode = mode;
/*-----------------------------------------------------*\
| Send packet to hardware, return true if successful |
\*-----------------------------------------------------*/
hid_send_feature_report(dev, (unsigned char *)&data, sizeof(data));
return;
}
std::string MSIMysticLight64Controller::GetDeviceName()
{
wchar_t tname[256];
/*-----------------------------------------------------*\
| Get the manufacturer string from HID |
\*-----------------------------------------------------*/
hid_get_manufacturer_string(dev, tname, 256);
/*-----------------------------------------------------*\
| Convert to std::string |
\*-----------------------------------------------------*/
std::string name = StringUtils::wstring_to_string(tname);
/*-----------------------------------------------------*\
| Get the product string from HID |
\*-----------------------------------------------------*/
hid_get_product_string(dev, tname, 256);
/*-----------------------------------------------------*\
| Append the product string to the manufacturer string |
\*-----------------------------------------------------*/
name.append(" ").append(StringUtils::wstring_to_string(tname));
return(name);
}
std::string MSIMysticLight64Controller::GetFWVersion()
{
/*-----------------------------------------------------*\
| This device doesn't support firmware version |
\*-----------------------------------------------------*/
std::string firmware_version = "";
return firmware_version;
}
std::string MSIMysticLight64Controller::GetDeviceLocation()
{
return ("HID: " + location);
}
std::string MSIMysticLight64Controller::GetSerial()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
if(ret != 0)
{
return("");
}
return(StringUtils::wstring_to_string(serial_string));
}
Controllers/MSIMysticLightController/MSIMysticLight64Controller/MSIMysticLight64Controller.h
+62
View File
@@ -0,0 +1,62 @@
/*---------------------------------------------------------*\
| MSIMysticLight64Controller.h |
| |
| Driver for MSI Mystic Light 64-byte motherboard |
| |
| T-bond 03 Apr 2020 |
| Adam Honse 06 Mar 2021 |
| Elchanan Haas 23 Aug 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <cstring>
#include <limits>
#include <hidapi.h>
#include "MSIMysticLightCommon.h"
#include "RGBController.h"
enum MSI_64_MODE
{
MSI_64_OFF = 0,
MSI_64_STEADY = 1,
MSI_64_BREATHING = 2,
MSI_64_PULSE = 3,
MSI_64_DOUBLE_PULSE = 4,
MSI_64_CYCLE = 5,
MSI_64_SMOOTH_CYCLE = 6,
};
class MSIMysticLight64Controller
{
public:
MSIMysticLight64Controller
(
hid_device* handle,
const char *path
);
~MSIMysticLight64Controller();
void SetMode
(
MSI_64_MODE mode,
MSI_SPEED speed,
MSI_BRIGHTNESS brightness,
unsigned int num_colors,
Color colors[]
);
std::string GetDeviceName();
std::string GetDeviceLocation();
std::string GetFWVersion();
std::string GetSerial();
private:
hid_device* dev;
std::string location;
};
Controllers/MSIMysticLightController/MSIMysticLight64Controller/RGBController_MSIMysticLight64.cpp
+164
View File
@@ -0,0 +1,164 @@
/*---------------------------------------------------------*\
| RGBController_MSIMysticLight64.cpp |
| |
| RGBController for MSI Mystic Light 64-byte motherboard |
| |
| T-bond 03 Apr 2020 |
| Adam Honse 06 Mar 2021 |
| Elchanan Haas 23 Aug 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_MSIMysticLight64.h"
/**------------------------------------------------------------------*\
@name MSI GL66 Mystic Light Keyboard (64 Byte)
@category Keyboard
@type USB
@save :robot:
@effects :white_check_mark:
@detectors DetectMSIMysticLight64Controllers
@comment
\*-------------------------------------------------------------------*/
RGBController_MSIMysticLight64::RGBController_MSIMysticLight64
(
MSIMysticLight64Controller *controller_ptr
)
{
controller = controller_ptr;
name = controller->GetDeviceName();
vendor = "MSI";
type = DEVICE_TYPE_KEYBOARD;
description = "MSI Mystic Light Device (64-byte)";
version = controller->GetFWVersion();
location = controller->GetDeviceLocation();
serial = controller->GetSerial();
SetupZones();
}
RGBController_MSIMysticLight64::~RGBController_MSIMysticLight64()
{
delete controller;
}
void RGBController_MSIMysticLight64::ResizeZone
(
int /*zone*/,
int /*new_size*/
)
{
}
void RGBController_MSIMysticLight64::SetupZones()
{
zone msi_zone;
msi_zone.name = "MSI Zone";
msi_zone.type = ZONE_TYPE_SINGLE;
msi_zone.leds_min = 1;
msi_zone.leds_max = 1;
msi_zone.leds_count = 1;
msi_zone.matrix_map = NULL;
zones.push_back(msi_zone);
led msi_led;
msi_led.name = "MSI LED";
leds.push_back(msi_led);
SetupModes();
SetupColors();
}
void RGBController_MSIMysticLight64::DeviceUpdateMode()
{
DeviceUpdateLEDs();
}
void RGBController_MSIMysticLight64::DeviceUpdateLEDs()
{
mode &Mode = modes[active_mode];
MSI_64_MODE msi_mode = (MSI_64_MODE)Mode.value;
MSI_SPEED speed = (MSI_SPEED)Mode.speed;
MSI_BRIGHTNESS brightness = (MSI_BRIGHTNESS)(Mode.brightness);
Color led_colors[MSI_64_MAX_COLORS] = {};
unsigned int num_colors = 0;
if(Mode.flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR)
{
num_colors = (unsigned int)Mode.colors.size();
for(unsigned int i = 0; i < num_colors; i++)
{
led_colors[i].R = RGBGetRValue(Mode.colors[i]);
led_colors[i].G = RGBGetGValue(Mode.colors[i]);
led_colors[i].B = RGBGetBValue(Mode.colors[i]);
}
}
controller->SetMode(msi_mode, speed, brightness, num_colors, led_colors);
}
void RGBController_MSIMysticLight64::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_MSIMysticLight64::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_MSIMysticLight64::SetupModes()
{
unsigned int TRANSITION=MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
SetupMode("Off", MSI_64_MODE::MSI_64_OFF, 0);
SetupMode("Static", MSI_64_MODE::MSI_64_STEADY, MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR);
SetupMode("Breathing", MSI_64_MODE::MSI_64_BREATHING, TRANSITION);
SetupMode("Flashing", MSI_64_MODE::MSI_64_PULSE, TRANSITION);
SetupMode("Double Flashing", MSI_64_MODE::MSI_64_DOUBLE_PULSE, TRANSITION);
SetupMode("Spectrum Cycle", MSI_64_MODE::MSI_64_CYCLE, TRANSITION);
SetupMode("Smooth Spectrum Cycle", MSI_64_MODE::MSI_64_SMOOTH_CYCLE, TRANSITION);
}
void RGBController_MSIMysticLight64::SetupMode
(
const char *name,
MSI_64_MODE mod,
unsigned int flags
)
{
mode Mode;
Mode.name = name;
Mode.value = mod;
Mode.flags = flags;
if(flags & MODE_FLAG_HAS_BRIGHTNESS)
{
Mode.brightness_min = MSI_BRIGHTNESS_LEVEL_10;
Mode.brightness_max = MSI_BRIGHTNESS_LEVEL_100;
Mode.brightness = MSI_BRIGHTNESS_LEVEL_100;
}
if(flags & MODE_FLAG_HAS_SPEED)
{
Mode.speed_min = MSI_SPEED_LOW;
Mode.speed_max = MSI_SPEED_HIGH;
Mode.speed = MSI_SPEED_LOW;
}
if(flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR)
{
Mode.color_mode= MODE_COLORS_MODE_SPECIFIC;
Mode.colors_min = 1;
Mode.colors_max = 1;
if (flags & MODE_FLAG_HAS_SPEED)
{
Mode.colors_max = MSI_64_MAX_COLORS;
}
/*-------------------------------------------------*\
| Set up colors for rainbow cycle |
\*-------------------------------------------------*/
Mode.colors.push_back(0x000000FF);
Mode.colors.push_back(0x000050FF);
Mode.colors.push_back(0x0000FFFF);
Mode.colors.push_back(0x0000FF00);
Mode.colors.push_back(0x00FF0000);
Mode.colors.push_back(0x00FF0096);
Mode.colors.push_back(0x00FF00FF);
}
modes.push_back(Mode);
}
Controllers/MSIMysticLightController/MSIMysticLight64Controller/RGBController_MSIMysticLight64.h
+43
View File
@@ -0,0 +1,43 @@
/*---------------------------------------------------------*\
| RGBController_MSIMysticLight64.h |
| |
| RGBController for MSI Mystic Light 64-byte motherboard |
| |
| T-bond 03 Apr 2020 |
| Adam Honse 06 Mar 2021 |
| Elchanan Haas 23 Aug 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "MSIMysticLight64Controller.h"
class RGBController_MSIMysticLight64 : public RGBController
{
public:
RGBController_MSIMysticLight64(MSIMysticLight64Controller* controller_ptr);
~RGBController_MSIMysticLight64();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
MSIMysticLight64Controller* controller;
void SetupModes();
void SetupMode
(
const char *name,
MSI_64_MODE mode,
unsigned int flags
);
};
Controllers/MSIMysticLightController/MSIMysticLight761Controller/MSIMysticLight761Controller.cpp
+633
View File
@@ -0,0 +1,633 @@
/*---------------------------------------------------------*\
| MSIMysticLight761Controller.cpp |
| |
| Driver for MSI Mystic Light 761-byte motherboard |
| |
| Direct mode functionality has been implemented based on |
| the SignalRGB project |
| (https://signalrgb.com/) |
| |
| rom4ster 11 Jun 2025 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <vector>
#include "LogManager.h"
#include "MSIMysticLight761Controller.h"
#include "StringUtils.h"
#define NUM_CONFS sizeof(board_configs) / sizeof(mystic_light_761_config)
#define COLOR_BLACK {0, 0, 0}
#define IS_JARGB(X) (X == MSI_ZONE_JARGB_1 || X == MSI_ZONE_JARGB_2 || X == MSI_ZONE_JARGB_3)
#define GET_CHAR_PTR_REF(X) (unsigned char *) &(X)
#define ARRAY_ROW(X, Y) get_zone_setup_index(X)*16 + Y
#define ARRAY_ROW_RAW(X, Y) X*16 + Y
#define SETUP_ARRAY_SIZE 290
struct mystic_light_761_config
{
const std::string * name; // Name of the board
int numof_onboard_leds; // number of onboard leds
int numof_pipe1_leds; // number of pipe 1 leds (used in per LED mode only)
int numof_pipe2_leds; // number of pipe 2 leds (used in per LED mode only)
int numof_JRGBs; // number of supported JRGB headers (used in per LED mode only)
const std::vector<MSI_ZONE>* supported_zones; // pointer to vector of supported zones
MSIMysticLight761Controller::DIRECT_MODE per_led_mode; // type of direct mode support
};
static const std::vector<MSI_ZONE> zone_set1 =
{
MSI_ZONE_JAF,
MSI_ZONE_JARGB_1,
MSI_ZONE_JARGB_2,
MSI_ZONE_JARGB_3,
};
static const std::string board_names[] =
{
"MSI MAG X870 TOMAHAWK WIFI (MS-7E51)",
"MSI MAG B850M MORTAR WIFI (MS-7E61)",
"MSI MPG B850I EDGE TI WIFI (MS-7E79)",
"MSI X870 GAMING PLUS WIFI (MS-7E47)",
"MSI B850 GAMING PLUS WIFI6E (MS-7E80)",
"MSI B850M GAMING PLUS WIFI6E (MS-7E81)",
"MSI MPG X870E CARBON WIFI (MS-7E49)",
"MSI Z890 GAMING PLUS WIFI (MS-7E34)",
"MSI X870E GAMING PLUS WIFI (MS-7E70)",
"MSI MAG X870E TOMAHAWK WIFI (MS-7E59)",
"MSI PRO B850-P WIFI (MS-7E56)",
"MSI B850M GAMING PLUS WIFI (MS-7E66)",
"MSI PRO X870E-P WIFI (MS-7E70)",
"MSI MPG X870I EDGE TI EVO WIFI (MS-7E50)",
"MSI B850 GAMING PLUS WIFI (MS-7E56)",
"MSI PRO X870-P WIFI (MS-7E47)",
"MSI MPG X870E EDGE TI WIFI (MS-7E59)",
"MSI MAG B850 TOMAHAWK MAX WIFI (MS-7E62)",
"MSI PRO B850M-P WIFI (MS-7E71)",
"MSI MAG Z890 TOMAHAWK WIFI (MS-7E32)",
"MSI MPG B850 EDGE TI WIFI (MS-7E62)",
"MSI PRO B850M-VC WIFI6E (MS-7E71)",
"MSI MAG B850 TOMAHAWK WIFI (MS-7E53)",
"MSI MEG Z890 UNIFY-X (MS-7E20)",
"MSI PRO X870E-S EVO WIFI (MS-7E86)",
"MSI PRO Z890-P WIFI (MS-7E34)",
};
static const mystic_light_761_config board_configs[] =
{
{ &(board_names[0]), 0, 0, 0, 1, &zone_set1, MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED }, // MSI X870 TOMAHAWK WIFI
{ &(board_names[1]), 0, 0, 0, 1, &zone_set1, MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED }, // MSI MAG B850M MORTAR WIFI
{ &(board_names[2]), 0, 0, 0, 1, &zone_set1, MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED }, // MSI MPG B850I EDGE TI WIFI
{ &(board_names[3]), 0, 0, 0, 1, &zone_set1, MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED }, // MSI X870 GAMING PLUS WIFI
{ &(board_names[4]), 0, 0, 0, 1, &zone_set1, MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED }, // MSI B850 GAMING PLUS WIFI6E
{ &(board_names[5]), 0, 0, 0, 1, &zone_set1, MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED }, // MSI B850M GAMING PLUS WIFI6E
{ &(board_names[6]), 0, 0, 0, 1, &zone_set1, MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED }, // MSI MPG X870E CARBON WIFI
{ &(board_names[7]), 0, 0, 0, 1, &zone_set1, MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED }, // MSI Z890 GAMING PLUS WIFI
{ &(board_names[8]), 0, 0, 0, 1, &zone_set1, MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED }, // MSI X870E GAMING PLUS WIFI
{ &(board_names[9]), 0, 0, 0, 1, &zone_set1, MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED }, // MSI MAG X870E TOMAHAWK WIFI
{ &(board_names[10]), 0, 0, 0, 1, &zone_set1, MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED }, // MSI PRO B850-P WIFI (MS-7E56)
{ &(board_names[11]), 0, 0, 0, 1, &zone_set1, MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED }, // MSI B850M GAMING PLUS WIFI
{ &(board_names[12]), 0, 0, 0, 1, &zone_set1, MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED }, // MSI PRO X870E-P WIFI
{ &(board_names[13]), 0, 0, 0, 1, &zone_set1, MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED }, // MSI MPG X870I EDGE TI EVO WIFI (MS-7E50)
{ &(board_names[14]), 0, 0, 0, 1, &zone_set1, MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED }, // MSI B850 GAMING PLUS WIFI (MS-7E56)
{ &(board_names[15]), 0, 0, 0, 1, &zone_set1, MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED }, // MSI PRO X870-P WIFI
{ &(board_names[16]), 0, 0, 0, 1, &zone_set1, MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED }, // MSI MPG X870E EDGE TI WIFI
{ &(board_names[17]), 0, 0, 0, 1, &zone_set1, MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED }, // MSI MAG B850 TOMAHAWK MAX WIFI
{ &(board_names[18]), 0, 0, 0, 1, &zone_set1, MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED }, // MSI PRO B850M-P WIFI (MS-7E71)
{ &(board_names[19]), 0, 0, 0, 1, &zone_set1, MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED }, // MSI MAG Z890 TOMAHAWK WIFI (MS-7E32)
{ &(board_names[20]), 0, 0, 0, 1, &zone_set1, MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED }, // MSI MPG B850 EDGE TI WIFI (MS-7E62)
{ &(board_names[21]), 0, 0, 0, 1, &zone_set1, MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED }, // MSI PRO B850M-VC WIFI6E (MS-7E71)
{ &(board_names[22]), 0, 0, 0, 1, &zone_set1, MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED }, // MSI MAG B850 TOMAHAWK WIFI (MS-7E53)
{ &(board_names[23]), 0, 0, 0, 1, &zone_set1, MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED }, // MSI MEG Z890 UNIFY-X (MS-7E20)
{ &(board_names[24]), 0, 0, 0, 1, &zone_set1, MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED }, // MSI PRO X870E-S EVO WIFI (MS-7E86)
{ &(board_names[25]), 0, 0, 0, 1, &zone_set1, MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED }, // MSI PRO Z890-P WIFI (MS-7E34)
};
enum MSI_ZONE setup_map [] =
{
MSI_ZONE_JARGB_1,
MSI_ZONE_JARGB_2,
MSI_ZONE_JARGB_3,
MSI_ZONE_JAF,
MSI_ZONE_J_PIPE_1,
MSI_ZONE_J_PIPE_2,
MSI_ZONE_J_PIPE_3,
MSI_ZONE_J_PIPE_4,
MSI_ZONE_J_PIPE_5,
MSI_ZONE_J_RGB_1,
MSI_ZONE_J_RGB_2,
MSI_ZONE_ON_BOARD_LED_0,
MSI_ZONE_ON_BOARD_LED_1,
MSI_ZONE_ON_BOARD_LED_2,
MSI_ZONE_ON_BOARD_LED_3,
MSI_ZONE_ON_BOARD_LED_4,
MSI_ZONE_ON_BOARD_LED_5,
};
int get_zone_setup_index(MSI_ZONE index)
{
int size = sizeof(setup_map) / sizeof(setup_map[0]);
for(int i = 0; i < size; i++)
{
if(setup_map[i] == index)
{
return i;
}
}
return -1;
}
// Copying from signal plugin
// DO NOT MODIFY THIS ARRAY DIRECTLY, MAKE COPY
unsigned char initial_setup_array[] =
{
0x50,
0x09, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0x15, 0x78, //JARGB 1
0x09, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0x15, 0x78, //JARGB 2
0x09, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0x15, 0x78, //JARGB 3
0x09, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0x15, 0x78, //JAF //Fans go here with the weird connector
0x09, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0x95, 0x1E, //JPIPE1
0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x94, 0x1E, //JPIPE2 //95 for active zones 94 for inactive
0x09, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0x95, 0x1E, //JPIPE3
0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x94, 0x1E, //JPIPE4
0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x94, 0x1E, //JPIPE5
0x09, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0x95, 0x1E, //JRGB1
0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x94, 0x1E, //JRGB2
0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x94, 0x1E, //Onboard1
0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x94, 0x1E, //Onboard2
0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x94, 0x1E, //Onboard3
0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x94, 0x1E, //Onboard4
0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x94, 0x1E, //Onboard5
0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x94, 0x1E, //Onboard6
0x09, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0x95, 0x1E, //Select all?
0x00
};
unsigned char * initializer_array()
{
unsigned char * arr = (unsigned char *) malloc(SETUP_ARRAY_SIZE);
for(int i = 0; i < SETUP_ARRAY_SIZE; i++)
{
arr[i] = initial_setup_array[i];
}
return arr;
}
void init_packet(FeaturePacket_Zone_761 * packet)
{
packet->packet.fixed1 = 0x09;
packet->packet.fixed2 = 0x00;
packet->packet.fixed3 = 0x00;
packet->packet.hdr2 = 240;
for(int i = 0; i < NUM_LEDS_761; i++)
{
packet->packet.colors[i] = 0x0;
}
}
MSIMysticLight761Controller::MSIMysticLight761Controller
(
hid_device* handle,
const char* path,
std::string dev_name
)
{
dev = handle;
location = path;
name = dev_name;
const mystic_light_761_config * board_config = nullptr;
for(std::size_t i = 0; i < NUM_CONFS; i++)
{
if(*(board_configs[i].name) == name)
{
board_config = &board_configs[i];
break;
}
}
if(board_config != nullptr)
{
supported_zones = (std::vector<MSI_ZONE>*) board_config->supported_zones;
unsigned int max = 0;
for(std::size_t i = 0; i < board_config->supported_zones[0].size(); i++)
{
unsigned int curr_val = (unsigned int) (board_config->supported_zones[0][i]);
if(curr_val > max)
{
max = curr_val;
}
}
// Need to send configuration to board
unsigned char * conf_arr = initializer_array();
// First set everything off
for(int i = 4; i < 17; i++)
{
conf_arr[ARRAY_ROW_RAW(i, 1)] = 0x00;
conf_arr[ARRAY_ROW_RAW(i, 2)] = 0x00;
conf_arr[ARRAY_ROW_RAW(i, 6)] = 0x00;
conf_arr[ARRAY_ROW_RAW(i, 10)] = 0x00;
conf_arr[ARRAY_ROW_RAW(i, 11)] = 0x00;
conf_arr[ARRAY_ROW_RAW(i, 12)] = 0x00;
conf_arr[ARRAY_ROW_RAW(i, 13)] = 0x00;
conf_arr[ARRAY_ROW_RAW(i, 14)] = 0x00;
conf_arr[ARRAY_ROW_RAW(i, 15)] = 0x00;
}
for(std::size_t i = 0; i < supported_zones->size(); i++)
{
MSI_ZONE supp_zone = (*supported_zones)[i];
ZoneConfig conf;
conf.msi_zone = supp_zone;
// Turn on relevant zones (0-3 are always active)
if(get_zone_setup_index(supp_zone) > 3)
{
conf_arr[ARRAY_ROW(supp_zone,1 )] = 0x09;
conf_arr[ARRAY_ROW(supp_zone,2 )] = 0xFF;
conf_arr[ARRAY_ROW(supp_zone,6 )] = 0xFF;
conf_arr[ARRAY_ROW(supp_zone,10)] = 0xFF;
conf_arr[ARRAY_ROW(supp_zone,11)] = 0xFF;
conf_arr[ARRAY_ROW(supp_zone,12)] = 0xFF;
conf_arr[ARRAY_ROW(supp_zone,13)] = 0xFF;
conf_arr[ARRAY_ROW(supp_zone,14)] = 0x03;
conf_arr[ARRAY_ROW(supp_zone,15)] = 0x95;
}
ZoneData * dat = new ZoneData;
conf.zone_data = dat;
zone_configs.push_back(conf);
}
if(dev)
{
location = path;
ReadName();
ReadFwVersion();
ReadSettings();
// Push config so setting colors works
int res = hid_send_feature_report(dev, conf_arr, SETUP_ARRAY_SIZE);
LOG_INFO("Sending configuration resulted in %i\n", res);
data = new FeaturePacket_761;
data->jaf.zone = MSI_ZONE_JAF;
data->jargb1.zone = MSI_ZONE_JARGB_1;
data->jargb2.zone = MSI_ZONE_JARGB_2;
data->jargb3.zone = MSI_ZONE_JARGB_3;
data->jaf.packet.hdr0 = 0x08;
data->jargb1.packet.hdr0 = 0x04;
data->jargb2.packet.hdr0 = 0x04;
data->jargb3.packet.hdr0 = 0x04;
data->jaf.packet.hdr1 = 0x00;
data->jargb1.packet.hdr1 = 0x00;
data->jargb2.packet.hdr1 = 0x01;
data->jargb3.packet.hdr1 = 0x02;
init_packet(&data->jaf);
init_packet(&data->jargb1);
init_packet(&data->jargb2);
init_packet(&data->jargb3);
}
free(conf_arr);
}
else
{
throw std::runtime_error(BOARD_UNSUPPORTED_ERROR);
}
}
MSIMysticLight761Controller::~MSIMysticLight761Controller()
{
hid_close(dev);
if(data)
{
delete data;
data = nullptr;
}
for(ZoneConfig& zone : zone_configs)
{
if(zone.zone_data)
{
delete zone.zone_data;
zone.zone_data = nullptr;
}
}
zone_configs.clear();
}
void MSIMysticLight761Controller::SetMode
(
MSI_ZONE /*zone*/,
MSI_MODE /*mode*/,
MSI_SPEED /*speed*/,
MSI_BRIGHTNESS /*brightness*/,
bool /*rainbow_color*/
)
{
return; // Only supporting direct for now
}
std::string MSIMysticLight761Controller::GetDeviceName()
{
return name;
}
std::string MSIMysticLight761Controller::GetFWVersion()
{
return std::string("AP/LD ").append(version_aprom).append(" / ").append(version_ldrom);
}
std::string MSIMysticLight761Controller::GetDeviceLocation()
{
return("HID: " + location);
}
std::string MSIMysticLight761Controller::GetSerial()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
if(ret != 0)
{
return("");
}
return(StringUtils::wstring_to_string(serial_string));
}
bool MSIMysticLight761Controller::ReadSettings()
{
/*-----------------------------------------------------*\
| Read packet from hardware, return true if successful |
\*-----------------------------------------------------*/
unsigned char buffer [500];
buffer[0] = 0x51;
return (hid_get_feature_report(dev, buffer, 500)) > 0 ;
}
bool MSIMysticLight761Controller::Update
(
bool /*save*/
)
{
int ret = 0;
bool flag = true;
ret = hid_send_feature_report(dev, GET_CHAR_PTR_REF(data->jaf.packet) , sizeof(FeaturePacket_PerLED_761));
if(ret < 0)
{
flag = false;
}
ret = hid_send_feature_report(dev, GET_CHAR_PTR_REF(data->jargb1.packet) , sizeof(FeaturePacket_PerLED_761));
if(ret < 0)
{
flag = false;
}
ret = hid_send_feature_report(dev, GET_CHAR_PTR_REF(data->jargb2.packet) , sizeof(FeaturePacket_PerLED_761));
if(ret < 0)
{
flag = false;
}
ret = hid_send_feature_report(dev, GET_CHAR_PTR_REF(data->jargb3.packet) , sizeof(FeaturePacket_PerLED_761));
if(ret < 0)
{
flag = false;
}
return flag;
}
void MSIMysticLight761Controller::SetZoneColor
(
MSI_ZONE zone,
unsigned char red1,
unsigned char grn1,
unsigned char blu1,
unsigned char red2,
unsigned char grn2,
unsigned char blu2
)
{
for(std::size_t i = 0; i < zone_configs.size(); i++)
{
if(zone_configs[i].msi_zone == zone)
{
zone_configs[i].zone_data->color.R = red1;
zone_configs[i].zone_data->color.G = grn1;
zone_configs[i].zone_data->color.B = blu1;
zone_configs[i].zone_data->color2.R = red2;
zone_configs[i].zone_data->color2.G = grn2;
zone_configs[i].zone_data->color2.B = blu2;
}
}
}
void set_data_color(FeaturePacket_Zone_761 * packet, std::size_t index, unsigned char color_val )
{
if(packet == nullptr)
{
return;
}
packet->packet.colors[index] = color_val;
}
void MSIMysticLight761Controller::SetLedColor
(
MSI_ZONE zone,
std::size_t index,
unsigned char red,
unsigned char grn,
unsigned char blu
)
{
FeaturePacket_Zone_761 * ptr = nullptr;
switch(zone)
{
case MSI_ZONE_JAF:
ptr = &data->jaf;
break;
case MSI_ZONE_JARGB_1:
ptr = &data->jargb1;
break;
case MSI_ZONE_JARGB_2:
ptr = &data->jargb2;
break;
case MSI_ZONE_JARGB_3:
ptr = &data->jargb3;
break;
default:
break;
}
std::size_t candidate_index = (index * 3);
if((candidate_index + 2) <= GetMaxDirectLeds(zone))
{
set_data_color(ptr, candidate_index, red);
set_data_color(ptr, candidate_index + 1, grn);
set_data_color(ptr, candidate_index + 2, blu);
}
}
ZoneData *MSIMysticLight761Controller::GetZoneData
(
FeaturePacket_761& /*data_packet*/,
MSI_ZONE zone
)
{
for(std::size_t i = 0; i < zone_configs.size(); i++)
{
if(zone_configs[i].msi_zone == zone)
{
return zone_configs[i].zone_data;
}
}
return nullptr;
}
Color *MSIMysticLight761Controller::GetPerLedZoneData
(
MSI_ZONE zone
)
{
return &(GetZoneData(*data, zone)->color);
}
RainbowZoneData *MSIMysticLight761Controller::GetRainbowZoneData
(
MSI_ZONE /*zone*/
)
{
return nullptr;
}
bool MSIMysticLight761Controller::ReadFwVersion()
{
return true;
}
void MSIMysticLight761Controller::ReadName()
{
wchar_t tname[256];
/*-----------------------------------------------------*\
| Get the manufacturer string from HID |
\*-----------------------------------------------------*/
hid_get_manufacturer_string(dev, tname, 256);
/*-----------------------------------------------------*\
| Convert to std::string |
\*-----------------------------------------------------*/
name = StringUtils::wstring_to_string(tname);
/*-----------------------------------------------------*\
| Get the product string from HID |
\*-----------------------------------------------------*/
hid_get_product_string(dev, tname, 256);
/*-----------------------------------------------------*\
| Append the product string to the manufacturer string |
\*-----------------------------------------------------*/
name.append(" ").append(StringUtils::wstring_to_string(tname));
}
MSI_MODE MSIMysticLight761Controller::GetMode()
{
return MSI_MODE_DIRECT_DUMMY;
}
void MSIMysticLight761Controller::GetMode
(
MSI_ZONE zone,
MSI_MODE & mode,
MSI_SPEED & speed,
MSI_BRIGHTNESS & brightness,
bool & rainbow_color,
unsigned int & color
)
{
/*-----------------------------------------------------*\
| Get data for given zone |
\*-----------------------------------------------------*/
ZoneData *zone_data = GetZoneData(*data, zone);
/*-----------------------------------------------------*\
| Return if zone is invalid |
\*-----------------------------------------------------*/
if(!zone_data)
{
return;
}
/*-----------------------------------------------------*\
| Update pointers with data |
\*-----------------------------------------------------*/
// Actual support of non direct modes needs to be further investigated
mode = (MSI_MODE)zone_data->effect;
speed = (MSI_SPEED)(zone_data->speedAndBrightnessFlags & 0x03);
brightness = (MSI_BRIGHTNESS)((zone_data->speedAndBrightnessFlags >> 2) & 0x1F);
rainbow_color = (zone_data->colorFlags & 0x80) == 0 ? true : false;
color = ToRGBColor(zone_data->color.R, zone_data->color.G, zone_data->color.B);
}
void MSIMysticLight761Controller::SetCycleCount
(
MSI_ZONE /*zone*/,
unsigned char /*cycle_num*/
)
{
return;
}
void MSIMysticLight761Controller::SetDirectMode
(
bool /*mode*/
)
{
SelectPerLedProtocol();
}
bool MSIMysticLight761Controller::IsDirectModeActive()
{
return true;
}
size_t MSIMysticLight761Controller::GetMaxDirectLeds
(
MSI_ZONE zone
)
{
switch(zone)
{
case MSI_ZONE_JAF:
case MSI_ZONE_JARGB_1:
case MSI_ZONE_JARGB_2:
case MSI_ZONE_JARGB_3:
return 240;
break;
default:
return 1;
}
}
void MSIMysticLight761Controller::SelectPerLedProtocol()
{
return;
}
Controllers/MSIMysticLightController/MSIMysticLight761Controller/MSIMysticLight761Controller.h
+155
View File
@@ -0,0 +1,155 @@
/*---------------------------------------------------------*\
| MSIMysticLight761Controller.h |
| |
| Driver for MSI Mystic Light 761-byte motherboard |
| |
| Direct mode functionality has been implemented based on |
| the SignalRGB project |
| (https://signalrgb.com/) |
| |
| rom4ster 11 Jun 2025 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <cstring>
#include <hidapi.h>
#include "MSIMysticLightCommon.h"
#include "RGBController.h"
inline constexpr const char * BOARD_UNSUPPORTED_ERROR = "No Config Found For Board";
class MSIMysticLight761Controller
{
public:
MSIMysticLight761Controller
(
hid_device* handle,
const char* path,
std::string dev_name
);
~MSIMysticLight761Controller();
void SetMode
(
MSI_ZONE zone,
MSI_MODE mode,
MSI_SPEED speed,
MSI_BRIGHTNESS brightness,
bool rainbow_color
);
MSI_MODE GetMode();
void GetMode
(
MSI_ZONE zone,
MSI_MODE &mode,
MSI_SPEED &speed,
MSI_BRIGHTNESS &brightness,
bool &rainbow_color,
unsigned int &color
);
void SetZoneColor
(
MSI_ZONE zone,
unsigned char red1,
unsigned char grn1,
unsigned char blu1,
unsigned char red2,
unsigned char grn2,
unsigned char blu2
);
void SetLedColor
(
MSI_ZONE zone,
std::size_t index,
unsigned char red,
unsigned char grn,
unsigned char blu
);
void SetCycleCount
(
MSI_ZONE zone,
unsigned char cycle_num
);
bool Update
(
bool save
);
std::string GetDeviceName();
std::string GetDeviceLocation();
std::string GetFWVersion();
std::string GetSerial();
void SetDirectMode
(
bool mode
);
bool IsDirectModeActive();
size_t GetMaxDirectLeds
(
MSI_ZONE zone
);
const std::vector<MSI_ZONE>*
GetSupportedZones()
{
return supported_zones;
}
enum DIRECT_MODE
{
DIRECT_MODE_DISABLED,
DIRECT_MODE_PER_LED,
DIRECT_MODE_ZONE_BASED
};
DIRECT_MODE GetSupportedDirectMode()
{
return DIRECT_MODE_PER_LED;
}
struct ZoneConfig
{
MSI_ZONE msi_zone;
ZoneData * zone_data;
};
private:
std::string name;
std::vector<MSIMysticLight761Controller::ZoneConfig> zone_configs;
const std::vector<MSI_ZONE>* supported_zones;
hid_device* dev;
std::string location;
std::string version_aprom;
std::string version_ldrom;
FeaturePacket_761* data;
bool ReadSettings();
bool ReadFwVersion();
void ReadName();
ZoneData* GetZoneData
(
FeaturePacket_761& data_packet,
MSI_ZONE zone
);
RainbowZoneData* GetRainbowZoneData(MSI_ZONE zone);
Color* GetPerLedZoneData
(
MSI_ZONE zone
);
void SelectPerLedProtocol();
};
Controllers/MSIMysticLightController/MSIMysticLight761Controller/RGBController_MSIMysticLight761.cpp
+459
View File
@@ -0,0 +1,459 @@
/*---------------------------------------------------------*\
| RGBController_MSIMysticLight761.cpp |
| |
| RGBController for MSI Mystic Light 761-byte motherboard |
| |
| |
| rom4ster 11 Jun 2025 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_MSIMysticLight761.h"
#include "LogManager.h"
struct ZoneDescription
{
std::string name;
MSI_ZONE zone_type;
};
#define NUMOF_ZONES (sizeof(led_zones) / sizeof(ZoneDescription))
const ZoneDescription led_zones[] =
{
ZoneDescription{ "JAF", MSI_ZONE_JAF },
ZoneDescription{ "JARGB 1", MSI_ZONE_JARGB_1 },
ZoneDescription{ "JARGB 2", MSI_ZONE_JARGB_2 },
ZoneDescription{ "JARGB 3", MSI_ZONE_JARGB_3 },
};
static std::vector<const ZoneDescription*> zone_description;
static int IndexOfZoneForType(MSI_ZONE zone_type)
{
for(std::size_t i = 0; i < zone_description.size(); ++i)
{
if(zone_description[i]->zone_type == zone_type)
{
return (int) i;
}
}
return -1;
}
RGBController_MSIMysticLight761::RGBController_MSIMysticLight761
(
MSIMysticLight761Controller* controller_ptr
)
{
controller = controller_ptr;
name = controller->GetDeviceName();
vendor = "MSI";
type = DEVICE_TYPE_MOTHERBOARD;
description = "MSI Mystic Light Device (761-byte)";
version = controller->GetFWVersion();
location = controller->GetDeviceLocation();
serial = controller->GetSerial();
const std::vector<MSI_ZONE>* supported_zones = controller->GetSupportedZones();
for(std::size_t i = 0; i < supported_zones->size(); ++i)
{
for(std::size_t j = 0; j < NUMOF_ZONES; ++j)
{
if(led_zones[j].zone_type == (*supported_zones)[i])
{
zone_description.push_back(&led_zones[j]);
break;
}
}
}
last_resizable_zone = MSI_ZONE_NONE;
SetupModes();
SetupZones();
active_mode = GetDeviceMode();
}
RGBController_MSIMysticLight761::~RGBController_MSIMysticLight761()
{
zone_description.clear();
delete controller;
}
int RGBController_MSIMysticLight761::GetDeviceMode()
{
MSI_MODE mode = controller->GetMode();
for(std::size_t i = 0; i < modes.size(); ++i)
{
if(mode == modes[i].value)
{
return (int)i;
}
}
return 0;
}
void RGBController_MSIMysticLight761::SetupZones()
{
/*-------------------------------------------------*\
| Clear any existing color/LED configuration |
\*-------------------------------------------------*/
leds.clear();
colors.clear();
bool first_run = false;
if(zones.size() == 0)
{
first_run = true;
}
if(first_run)
{
/*---------------------------------------------------------*\
| Set up zones |
\*---------------------------------------------------------*/
for(std::size_t zone_idx = 0; zone_idx < zone_description.size(); ++zone_idx)
{
const ZoneDescription* zd = zone_description[zone_idx];
zone new_zone;
new_zone.name = zd->name;
new_zone.flags = 0;
int maxLeds = (int)controller->GetMaxDirectLeds(zd->zone_type);
/*-------------------------------------------------*\
| This is a fixed size zone |
\*-------------------------------------------------*/
if(((zd->zone_type != MSI_ZONE_J_RAINBOW_1)
&& (zd->zone_type != MSI_ZONE_J_RAINBOW_2)
&& (zd->zone_type != MSI_ZONE_J_RAINBOW_3)
&& (zd->zone_type != MSI_ZONE_JAF)
&& (zd->zone_type != MSI_ZONE_JARGB_1)
&& (zd->zone_type != MSI_ZONE_JARGB_2)
&& (zd->zone_type != MSI_ZONE_JARGB_3)
&& (zd->zone_type != MSI_ZONE_J_CORSAIR)))
{
new_zone.leds_min = maxLeds;
new_zone.leds_max = maxLeds;
new_zone.leds_count = maxLeds;
}
/*--------------------------------------------------*\
| This is a resizable zone on a board that does not |
| support per-LED direct mode |
\*--------------------------------------------------*/
else if(controller->GetSupportedDirectMode() == MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED)
{
new_zone.leds_min = 0;
new_zone.leds_max = 30;//maxLeds;
new_zone.leds_count = 0;
last_resizable_zone = zd->zone_type;
new_zone.flags |= ZONE_FLAG_RESIZE_EFFECTS_ONLY;
}
/*--------------------------------------------------*\
| This is a resizable zone on a board that does |
| support per-LED direct mode |
\*--------------------------------------------------*/
else
{
new_zone.leds_min = 0;
new_zone.leds_max = maxLeds;
new_zone.leds_count = 0;
last_resizable_zone = zd->zone_type;
}
/*-------------------------------------------------*\
| Determine zone type based on max number of LEDs |
\*-------------------------------------------------*/
if((new_zone.leds_max == 1) || (new_zone.flags & ZONE_FLAG_RESIZE_EFFECTS_ONLY))
{
new_zone.type = ZONE_TYPE_SINGLE;
}
else
{
new_zone.type = ZONE_TYPE_LINEAR;
}
new_zone.matrix_map = NULL;
zones.push_back(new_zone);
}
}
/*---------------------------------------------------------*\
| Set up LEDs |
\*---------------------------------------------------------*/
for(std::size_t zone_idx = 0; zone_idx < zone_description.size(); ++zone_idx)
{
controller->SetCycleCount(zone_description[zone_idx]->zone_type, zones[zone_idx].leds_count);
if((zones[zone_idx].flags & ZONE_FLAG_RESIZE_EFFECTS_ONLY) == 0)
{
for(unsigned int led_idx = 0; led_idx < zones[zone_idx].leds_count; ++led_idx)
{
led new_led;
new_led.name = zones[zone_idx].name;
if(zones[zone_idx].leds_count > 1)
{
new_led.name.append(" LED " + std::to_string(led_idx + 1));
}
new_led.value = zone_description[zone_idx]->zone_type;
leds.push_back(new_led);
}
}
else if(zones[zone_idx].leds_count > 0)
{
led new_led;
new_led.name = zones[zone_idx].name;
new_led.value = zone_description[zone_idx]->zone_type;
leds.push_back(new_led);
}
}
SetupColors();
}
void RGBController_MSIMysticLight761::ResizeZone
(
int zone,
int new_size
)
{
if((std::size_t)zone >= zones.size())
{
return;
}
if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
{
zones[zone].leds_count = new_size;
SetupZones();
if(zone_description[zone]->zone_type == last_resizable_zone)
{
GetDeviceConfig();
last_resizable_zone = MSI_ZONE_NONE;
}
}
}
void RGBController_MSIMysticLight761::DeviceUpdateLEDs()
{
for(std::size_t zone_idx = 0; zone_idx < zones.size(); ++zone_idx)
{
for(int led_idx = zones[zone_idx].leds_count - 1; led_idx >= 0; led_idx--)
{
UpdateLed((int)zone_idx, led_idx);
}
}
controller->Update((modes[active_mode].flags & MODE_FLAG_AUTOMATIC_SAVE) != 0);
}
void RGBController_MSIMysticLight761::UpdateZoneLEDs(int zone)
{
for(int led_idx = zones[zone].leds_count - 1; led_idx >= 0; led_idx--)
{
UpdateLed(zone, led_idx);
}
controller->Update((modes[active_mode].flags & MODE_FLAG_AUTOMATIC_SAVE) != 0);
}
void RGBController_MSIMysticLight761::UpdateSingleLED
(
int led
)
{
int zone_index = IndexOfZoneForType((MSI_ZONE)leds[led].value);
if(zone_index == -1)
{
LOG_DEBUG("[%s]: could not find zone for type %d", controller->GetDeviceName().c_str(), leds[led].value);
return;
}
int led_index = led - zones[zone_index].start_idx;
UpdateLed(zone_index, led_index);
controller->Update((modes[active_mode].flags & MODE_FLAG_AUTOMATIC_SAVE) != 0);
}
void RGBController_MSIMysticLight761::DeviceUpdateMode()
{
if(modes[active_mode].value == MSI_MODE_DIRECT_DUMMY)
{
controller->SetDirectMode(true);
}
else
{
controller->SetDirectMode(false);
DeviceUpdateLEDs();
}
}
void RGBController_MSIMysticLight761::DeviceSaveMode()
{
controller->Update(true);
}
void RGBController_MSIMysticLight761::SetupModes()
{
if(controller->GetSupportedDirectMode() != MSIMysticLight761Controller::DIRECT_MODE_DISABLED)
{
SetupMode("Direct", MSI_MODE_DIRECT_DUMMY, MODE_FLAG_HAS_PER_LED_COLOR);
}
}
void RGBController_MSIMysticLight761::UpdateLed
(
int zone,
int led
)
{
unsigned char red = RGBGetRValue(zones[zone].colors[led]);
unsigned char grn = RGBGetGValue(zones[zone].colors[led]);
unsigned char blu = RGBGetBValue(zones[zone].colors[led]);
if(controller->IsDirectModeActive())
{
controller->SetLedColor((MSI_ZONE)(zones[zone].leds[led].value), led, red, grn, blu);
}
else
{
if(led == 0)
{
bool random = modes[active_mode].color_mode == MODE_COLORS_RANDOM;
MSI_MODE mode = (MSI_MODE)modes[active_mode].value;
MSI_SPEED speed = (MSI_SPEED)modes[active_mode].speed;
MSI_BRIGHTNESS brightness = (MSI_BRIGHTNESS)modes[active_mode].brightness;
controller->SetMode((MSI_ZONE)zones[zone].leds[led].value, mode, speed, brightness, random);
controller->SetZoneColor((MSI_ZONE)zones[zone].leds[led].value, red, grn, blu, red, grn, blu);
}
}
}
void RGBController_MSIMysticLight761::SetupMode
(
const char *name,
MSI_MODE mod,
unsigned int flags
)
{
mode Mode;
Mode.name = name;
Mode.value = mod;
Mode.flags = flags;
if(flags & MODE_FLAG_HAS_PER_LED_COLOR)
{
Mode.color_mode = MODE_COLORS_PER_LED;
}
else
{
Mode.color_mode = MODE_COLORS_RANDOM;
}
if(flags & MODE_FLAG_HAS_SPEED)
{
Mode.speed = MSI_SPEED_MEDIUM;
Mode.speed_max = MSI_SPEED_HIGH;
Mode.speed_min = MSI_SPEED_LOW;
}
else
{
/*---------------------------------------------------------*\
| For modes without speed this needs to be set to avoid |
| bad values in the saved profile which in turn corrupts |
| the brightness calculation when loading the profile |
\*---------------------------------------------------------*/
Mode.speed = 0;
Mode.speed_max = 0;
Mode.speed_min = 0;
}
if(flags & MODE_FLAG_HAS_BRIGHTNESS)
{
Mode.brightness = MSI_BRIGHTNESS_LEVEL_100;
Mode.brightness_max = MSI_BRIGHTNESS_LEVEL_100;
Mode.brightness_min = MSI_BRIGHTNESS_OFF;
}
else
{
Mode.brightness = MSI_BRIGHTNESS_LEVEL_100;
Mode.brightness_max = MSI_BRIGHTNESS_LEVEL_100;
Mode.brightness_min = MSI_BRIGHTNESS_LEVEL_100;
}
modes.push_back(Mode);
}
void RGBController_MSIMysticLight761::GetDeviceConfig()
{
if(controller->GetMode() != MSI_MODE_DIRECT_DUMMY)
{
MSI_MODE mode;
MSI_SPEED speed;
MSI_BRIGHTNESS brightness;
bool rainbow;
unsigned int color;
for(std::size_t i = 0; i < zone_description.size(); ++i)
{
controller->GetMode(zone_description[i]->zone_type, mode, speed, brightness, rainbow, color);
if(zones[i].colors != nullptr)
{
for(size_t j = 0; j < GetLEDsInZone((unsigned int)i); ++j)
{
zones[i].colors[j] = color;
}
}
}
controller->GetMode(zone_description[0]->zone_type, mode, speed, brightness, rainbow, color);
for(std::size_t i = 0; i < modes.size(); ++i)
{
if(mode == modes[i].value)
{
if(modes[i].flags & MODE_FLAG_HAS_SPEED)
{
modes[i].speed = speed;
}
if(modes[i].flags & MODE_FLAG_HAS_BRIGHTNESS)
{
modes[i].brightness = brightness;
}
if(rainbow)
{
if(modes[i].flags & (MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR))
{
if(rainbow)
{
modes[i].color_mode = MODE_COLORS_RANDOM;
}
else
{
modes[i].color_mode = MODE_COLORS_PER_LED;
}
}
}
break;
}
}
}
}
Controllers/MSIMysticLightController/MSIMysticLight761Controller/RGBController_MSIMysticLight761.h
+52
View File
@@ -0,0 +1,52 @@
/*---------------------------------------------------------*\
| RGBController_MSIMysticLight761.h |
| |
| RGBController for MSI Mystic Light 761-byte motherboard |
| |
| |
| rom4ster 11 Jun 2025 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "MSIMysticLight761Controller.h"
class RGBController_MSIMysticLight761: public RGBController
{
public:
RGBController_MSIMysticLight761(MSIMysticLight761Controller* controller_ptr);
~RGBController_MSIMysticLight761();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
void DeviceSaveMode();
private:
void SetupModes();
void UpdateLed
(
int zone,
int led
);
void SetupMode
(
const char *name,
MSI_MODE mode,
unsigned int flags
);
int GetDeviceMode();
void GetDeviceConfig();
MSIMysticLight761Controller* controller;
MSI_ZONE last_resizable_zone;
};
Controllers/MSIMysticLightController/MSIMysticLightCommon.h
+278
View File
@@ -0,0 +1,278 @@
/*---------------------------------------------------------*\
| MSIMysticLightCommon.h |
| |
| Common definitions for MSI Mystic Light motherboards |
| |
| Adam Honse 06 Mar 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <string>
enum MSI_ZONE
{
MSI_ZONE_NONE = 0,
MSI_ZONE_J_RGB_1 = 1,
MSI_ZONE_J_RGB_2 = 2,
MSI_ZONE_J_PIPE_1 = 3,
MSI_ZONE_J_PIPE_2 = 4,
MSI_ZONE_J_PIPE_3 = 5,
MSI_ZONE_J_PIPE_4 = 6,
MSI_ZONE_J_PIPE_5 = 7,
MSI_ZONE_J_RAINBOW_1 = 8,
MSI_ZONE_J_RAINBOW_2 = 9,
MSI_ZONE_J_RAINBOW_3 = 10,
MSI_ZONE_J_CORSAIR = 11,
MSI_ZONE_J_CORSAIR_OUTERLL120 = 12,
MSI_ZONE_ON_BOARD_LED_0 = 13,
MSI_ZONE_ON_BOARD_LED_1 = 14,
MSI_ZONE_ON_BOARD_LED_2 = 15,
MSI_ZONE_ON_BOARD_LED_3 = 16,
MSI_ZONE_ON_BOARD_LED_4 = 17,
MSI_ZONE_ON_BOARD_LED_5 = 18,
MSI_ZONE_ON_BOARD_LED_6 = 19,
MSI_ZONE_ON_BOARD_LED_7 = 20,
MSI_ZONE_ON_BOARD_LED_8 = 21,
MSI_ZONE_ON_BOARD_LED_9 = 22,
MSI_ZONE_ON_BOARD_LED_10 = 23,
MSI_ZONE_JAF = 24,
MSI_ZONE_JARGB_1 = 25,
MSI_ZONE_JARGB_2 = 26,
MSI_ZONE_JARGB_3 = 27,
};
enum MSI_MODE
{
MSI_MODE_DISABLE = 0,
MSI_MODE_STATIC = 1,
MSI_MODE_BREATHING = 2,
MSI_MODE_FLASHING = 3,
MSI_MODE_DOUBLE_FLASHING = 4,
MSI_MODE_LIGHTNING = 5,
MSI_MODE_MSI_MARQUEE = 6,
MSI_MODE_METEOR = 7,
MSI_MODE_WATER_DROP = 8,
MSI_MODE_MSI_RAINBOW = 9,
MSI_MODE_POP = 10,
MSI_MODE_RAP = 11,
MSI_MODE_JAZZ = 12,
MSI_MODE_PLAY = 13,
MSI_MODE_MOVIE = 14,
MSI_MODE_COLOR_RING = 15,
MSI_MODE_PLANETARY = 16,
MSI_MODE_DOUBLE_METEOR = 17,
MSI_MODE_ENERGY = 18,
MSI_MODE_BLINK = 19,
MSI_MODE_CLOCK = 20,
MSI_MODE_COLOR_PULSE = 21,
MSI_MODE_COLOR_SHIFT = 22,
MSI_MODE_COLOR_WAVE = 23,
MSI_MODE_MARQUEE = 24,
MSI_MODE_RAINBOW = 25,
MSI_MODE_RAINBOW_WAVE = 26,
MSI_MODE_VISOR = 27,
MSI_MODE_JRAINBOW = 28,
MSI_MODE_RAINBOW_FLASHING = 29,
MSI_MODE_RAINBOW_DOUBLE_FLASHING = 30,
MSI_MODE_RANDOM = 31,
MSI_MODE_FAN_CONTROL = 32,
MSI_MODE_DISABLE_2 = 33,
MSI_MODE_COLOR_RING_FLASHING = 34,
MSI_MODE_COLOR_RING_DOUBLE_FLASHING = 35,
MSI_MODE_STACK = 36,
MSI_MODE_CORSAIR_QUE = 37,
MSI_MODE_FIRE = 38,
MSI_MODE_LAVA = 39,
MSI_MODE_DIRECT_DUMMY = 100
};
enum MSI_SPEED
{
MSI_SPEED_LOW = 0,
MSI_SPEED_MEDIUM = 1,
MSI_SPEED_HIGH = 2,
};
enum MSI_FAN_TYPE
{
MSI_FAN_TYPE_SP = 0,
MSI_FAN_TYPE_HD = 1,
MSI_FAN_TYPE_LL = 2,
};
enum MSI_BRIGHTNESS
{
MSI_BRIGHTNESS_OFF = 0,
MSI_BRIGHTNESS_LEVEL_10 = 1,
MSI_BRIGHTNESS_LEVEL_20 = 2,
MSI_BRIGHTNESS_LEVEL_30 = 3,
MSI_BRIGHTNESS_LEVEL_40 = 4,
MSI_BRIGHTNESS_LEVEL_50 = 5,
MSI_BRIGHTNESS_LEVEL_60 = 6,
MSI_BRIGHTNESS_LEVEL_70 = 7,
MSI_BRIGHTNESS_LEVEL_80 = 8,
MSI_BRIGHTNESS_LEVEL_90 = 9,
MSI_BRIGHTNESS_LEVEL_100 = 10,
};
#define NUMOF_PER_LED_MODE_LEDS 240
#define NUM_LEDS_761 720
#define SYNC_SETTING_ONBOARD 0x01
#define SYNC_SETTING_JRAINBOW1 0x02
#define SYNC_SETTING_JRAINBOW2 0x04
#define SYNC_SETTING_JCORSAIR 0x08
#define SYNC_SETTING_JPIPE1 0x10
#define SYNC_SETTING_JPIPE2 0x20
#define SYNC_SETTING_JRGB 0x80
#define MSI_64_MAX_COLORS 7
struct Color
{
unsigned char R;
unsigned char G;
unsigned char B;
};
struct CorsairZoneData
{
unsigned char effect = MSI_MODE_STATIC;
Color color { 0, 0, 0 };
unsigned char fan_flags = 40;
unsigned char corsair_quantity = 0;
unsigned char padding[4] = { 0, 0, 0, 0 };
unsigned char is_individual = 0;
};
struct ZoneData
{
unsigned char effect = MSI_MODE_STATIC;
Color color { 0, 0, 0 };
unsigned char speedAndBrightnessFlags = 0;
Color color2 { 0, 0, 0 };
unsigned char colorFlags = 0;
unsigned char padding = 0;
};
struct RainbowZoneData : ZoneData
{
unsigned char cycle_or_led_num = 100;
};
struct FeaturePacket_64
{
const unsigned char report_id = 0x02; // Report ID
const unsigned char second_byte = 0x00;
unsigned char mode = 0x00;
unsigned char speed = 0x00;
unsigned char brightness = 0x00;
unsigned char num_colors = 0x00;
Color colors[MSI_64_MAX_COLORS] = {};
const unsigned char padding[37] = {}; //pad to make the packet size 64 bytes
};
struct FeaturePacket_112
{
const unsigned char report_id = 0x52; // Report ID
ZoneData j_rgb_1; // 1
ZoneData j_rainbow_1; // 11
ZoneData j_corsair_1; // 21
ZoneData j_corsair_outerll120; // 31
ZoneData on_board_led; // 41
ZoneData on_board_led_1; // 51
ZoneData on_board_led_2; // 61
ZoneData on_board_led_3; // 71
ZoneData on_board_led_4; // 81
ZoneData on_board_led_5; // 91
ZoneData on_board_led_6; // 101
unsigned char save_data = 0; // 111
};
struct FeaturePacket_162
{
const unsigned char report_id = 0x52; // Report ID
ZoneData j_rgb_1; // 1
ZoneData j_rainbow_1; // 11
ZoneData j_corsair_1; // 21
ZoneData j_corsair_outerll120; // 31
ZoneData on_board_led; // 41
ZoneData on_board_led_1; // 51
ZoneData on_board_led_2; // 61
ZoneData on_board_led_3; // 71
ZoneData on_board_led_4; // 81
ZoneData on_board_led_5; // 91
ZoneData on_board_led_6; // 101
ZoneData on_board_led_7; // 111
ZoneData on_board_led_8; // 121
ZoneData on_board_led_9; // 131
ZoneData on_board_led_10; // 141
ZoneData j_rgb_2; // 151
unsigned char save_data = 0; // 161
};
struct FeaturePacket_185
{
const unsigned char report_id = 0x52; // Report ID
ZoneData j_rgb_1; // 1
ZoneData j_pipe_1; // 11
ZoneData j_pipe_2; // 21
RainbowZoneData j_rainbow_1; // 31
RainbowZoneData j_rainbow_2; // 42
CorsairZoneData j_corsair; // 53
ZoneData j_corsair_outerll120; // 64
ZoneData on_board_led; // 74
ZoneData on_board_led_1; // 84
ZoneData on_board_led_2; // 94
ZoneData on_board_led_3; // 104
ZoneData on_board_led_4; // 114
ZoneData on_board_led_5; // 124
ZoneData on_board_led_6; // 134
ZoneData on_board_led_7; // 144
ZoneData on_board_led_8; // 154
ZoneData on_board_led_9; // 164
ZoneData j_rgb_2; // 174
unsigned char save_data = 0; // 184
};
struct FeaturePacket_PerLED_185
{
unsigned char report_id = 0x53; // Report ID
unsigned char hdr0 = 0x25; // header byte 0
unsigned char hdr1 = 0x06; // header byte 1
unsigned char hdr2 = 0x00; // header byte 2
unsigned char hdr3 = 0x00; // header byte 3
Color leds[NUMOF_PER_LED_MODE_LEDS];
};
struct FeaturePacket_PerLED_761
{
unsigned char report_id = 0x51; // Report ID
unsigned char fixed1 = 0x09; // Always 9?
unsigned char hdr0; // 0x08 for ez 0x04 for ARGB 0x06 for LED
unsigned char hdr1; // 0 for LED/EZ and argb num for ARGB?
unsigned char fixed2 = 0x00; // IDK what this is
unsigned char fixed3 = 0x00; // IDK what this is
unsigned char hdr2; // Led Count
unsigned char colors [NUM_LEDS_761];
};
struct FeaturePacket_Zone_761
{
MSI_ZONE zone;
FeaturePacket_PerLED_761 packet;
};
struct FeaturePacket_761
{
FeaturePacket_Zone_761 jargb1;
FeaturePacket_Zone_761 jargb2;
FeaturePacket_Zone_761 jargb3;
FeaturePacket_Zone_761 jaf;
};
#define MSI_USB_PID_COMMON 0x0076 // Common PID for a certain set of 185-byte boards
Controllers/MSIMysticLightController/MSIMysticLightControllerDetect.cpp
+287
View File
@@ -0,0 +1,287 @@
/*---------------------------------------------------------*\
| MSIMysticLightControllerDetect.cpp |
| |
| Detector for MSI Mystic Light motherboards |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "Detector.h"
#include "MSIMysticLight64Controller.h"
#include "MSIMysticLight112Controller.h"
#include "MSIMysticLight162Controller.h"
#include "MSIMysticLight185Controller.h"
#include "MSIMysticLight761Controller.h"
#include "RGBController_MSIMysticLight64.h"
#include "RGBController_MSIMysticLight112.h"
#include "RGBController_MSIMysticLight162.h"
#include "RGBController_MSIMysticLight185.h"
#include "RGBController_MSIMysticLight761.h"
#include "dmiinfo.h"
#include "LogManager.h"
#define MSI_USB_VID 0x1462
#define MSI_USB_VID_COMMON 0x0DB0
/*---------------------------------------------------------------------------------*\
| WARNING! |
| |
| The MSI Mystic Light controller had a bricking risk in the past. |
| The code has been tested on a few boards and the bricking issue has been fixed. |
| Uncomment this line to enable for untested boards. Do so at your own risk. |
\*---------------------------------------------------------------------------------*/
//#define ENABLE_UNTESTED_MYSTIC_LIGHT
/*----------------------------------------------------------------------------------------*\
| |
| DetectMSIMysticLightControllers |
| |
| Detect MSI Mystic Light devices |
| |
\*----------------------------------------------------------------------------------------*/
void DetectMSIMysticLightControllers
(
hid_device_info* info,
const std::string& /*name*/
)
{
hid_device* dev = hid_open_path(info->path);
if(dev != nullptr)
{
unsigned char temp_buffer[200];
temp_buffer[0] = 0x52;
size_t packet_length = hid_get_feature_report(dev, temp_buffer, 200);
DMIInfo dmi;
std::string dmi_name = "MSI " + dmi.getMainboard();
if((packet_length >= sizeof(FeaturePacket_185)) && (packet_length <= (sizeof(FeaturePacket_185) + 1))) //WHY r we doing this ? why not ==
{
MSIMysticLight185Controller* controller = new MSIMysticLight185Controller(dev, info->path, info->product_id, dmi_name);
RGBController_MSIMysticLight185* rgb_controller = new RGBController_MSIMysticLight185(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
else if((packet_length >= sizeof(FeaturePacket_162)) && (packet_length <= (sizeof(FeaturePacket_162) + 1)))
{
MSIMysticLight162Controller* controller = new MSIMysticLight162Controller(dev, info->path, info->product_id, dmi_name);
RGBController_MSIMysticLight162* rgb_controller = new RGBController_MSIMysticLight162(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
else if((packet_length >= sizeof(FeaturePacket_112)) && (packet_length <= (sizeof(FeaturePacket_112) + 1)))
{
MSIMysticLight112Controller* controller = new MSIMysticLight112Controller(dev, info->path, dmi_name);
RGBController_MSIMysticLight112* rgb_controller = new RGBController_MSIMysticLight112(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
else // no supported length returned
{
unsigned char second_buffer [761];
second_buffer[0] = 0x50;
memset(second_buffer + sizeof(unsigned char), 0x0, sizeof(second_buffer) - sizeof(unsigned char));
//Using this enables subsequent reads to work for some reason
size_t enable_reading_packet = hid_get_feature_report(dev, second_buffer, 290);
LOG_INFO("Read %i bytes from read enable packet, subsequent get reports should work", enable_reading_packet);
memset(second_buffer + sizeof(unsigned char), 0x0, sizeof(second_buffer) - sizeof(unsigned char));
second_buffer[0] = 0x51;
size_t packet_length_new_attempt = hid_send_feature_report(dev, second_buffer, 761);
if(packet_length_new_attempt > 0)
{
try
{
MSIMysticLight761Controller* controller = new MSIMysticLight761Controller(dev, (const char *) info->path, dmi_name);
RGBController_MSIMysticLight761* rgb_controller = new RGBController_MSIMysticLight761(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
catch(const std::runtime_error& e)
{
if (strcmp(e.what(), BOARD_UNSUPPORTED_ERROR) != 0)
{
throw e;
}
else
{
LOG_INFO("Found Board %s but does not have valid config", dmi_name.c_str());
}
}
}
else
{
LOG_INFO("No matching driver found for %s, packet length = %d", dmi_name.c_str(), packet_length);
return;
}
}
}
}
void DetectMSIMysticLight64Controllers
(
hid_device_info* info,
const std::string& /*name*/
)
{
hid_device* dev = hid_open_path(info->path);
if(dev != nullptr)
{
MSIMysticLight64Controller* controller = new MSIMysticLight64Controller(dev, info->path);
RGBController_MSIMysticLight64* rgb_controller = new RGBController_MSIMysticLight64(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_1562", DetectMSIMysticLight64Controllers, MSI_USB_VID, 0x1562, 0x00FF, 0x01);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_1563", DetectMSIMysticLight64Controllers, MSI_USB_VID, 0x1563, 0x00FF, 0x01);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_1564", DetectMSIMysticLight64Controllers, MSI_USB_VID, 0x1564, 0x00FF, 0x01);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_1720", DetectMSIMysticLightControllers, MSI_USB_VID, 0x1720, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7B12", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7B12, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7B16", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7B16, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7B17", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7B17, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7B18", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7B18, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7B50", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7B50, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7B85", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7B85, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7B92", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7B92, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7B93", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7B93, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C02", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C02, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C34", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C34, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C35", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C35, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C36", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C36, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C37", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C37, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C56", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C56, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C59", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C59, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C60", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C60, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C67", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C67, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C71", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C71, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C73", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C73, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C75", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C75, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C76", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C76, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C77", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C77, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C79", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C79, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C80", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C80, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C81", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C81, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C82", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C82, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C83", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C83, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C84", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C84, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C86", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C86, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C87", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C87, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C90", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C90, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C91", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C91, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C92", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C92, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C94", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C94, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C95", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C95, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C98", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C98, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D03", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D03, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D04", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D04, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D06", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D06, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D07", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D07, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D08", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D08, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D09", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D09, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D13", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D13, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D14", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D14, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D15", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D15, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D17", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D17, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D18", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D18, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D19", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D19, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D20", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D20, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D25", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D25, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D27", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D27, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D28", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D28, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D29", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D29, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D30", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D30, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D31", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D31, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D32", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D32, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D33", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D33, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D36", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D36, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D37", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D37, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D38", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D38, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D40", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D40, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D41", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D41, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D42", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D42, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D43", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D43, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D46", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D46, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D50", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D50, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D51", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D51, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D52", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D52, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D53", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D53, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D54", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D54, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D59", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D59, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D67", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D67, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D69", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D69, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D70", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D70, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D73", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D73, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D74", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D74, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D75", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D75, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D76", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D76, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D77", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D77, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D78", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D78, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D86", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D86, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D88", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D88, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D89", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D89, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D90", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D90, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D91", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D91, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D93", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D93, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D96", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D96, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D97", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D97, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D98", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D98, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D99", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7D99, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E01", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7E01, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E03", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7E03, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E06", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7E06, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E07", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7E07, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E09", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7E09, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E10", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7E10, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_B926", DetectMSIMysticLightControllers, MSI_USB_VID, 0xB926, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E70", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7E70, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E59", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7E59, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E80", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7E80, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E81", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7E81, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E34", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7E34, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E32", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7E32, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E20", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7E20, 0x0001, 0x00);
// Detector for the set of common boards
REGISTER_HID_DETECTOR_PU("MSI Mystic Light Common", DetectMSIMysticLightControllers, MSI_USB_VID_COMMON, MSI_USB_PID_COMMON, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light X870", DetectMSIMysticLightControllers, MSI_USB_VID_COMMON, MSI_USB_PID_COMMON, 0xFF00, 0x01);
/*---------------------------------------------------------------------------------------------------------*\
| Dummy entries for boards using common VID and PID |
| |
| DUMMY_DEVICE_DETECTOR("MSI Mystic Light MS_7E12", DetectMSIMysticLightControllers, 0x1462, 0x7E12 ) |
| DUMMY_DEVICE_DETECTOR("MSI Mystic Light MS_7E16", DetectMSIMysticLightControllers, 0x1462, 0x7E16 ) |
| DUMMY_DEVICE_DETECTOR("MSI Mystic Light MS_7E24", DetectMSIMysticLightControllers, 0x1462, 0x7E24 ) |
| DUMMY_DEVICE_DETECTOR("MSI Mystic Light MS_7E26", DetectMSIMysticLightControllers, 0x1462, 0x7E26 ) |
| DUMMY_DEVICE_DETECTOR("MSI Mystic Light MS_7E27", DetectMSIMysticLightControllers, 0x1462, 0x7E27 ) |
| DUMMY_DEVICE_DETECTOR("MSI Mystic Light MS_7E49", DetectMSIMysticLightControllers, 0x1462, 0x7E49 ) |
\*---------------------------------------------------------------------------------------------------------*/
#ifdef ENABLE_UNTESTED_MYSTIC_LIGHT
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_3EA4", DetectMSIMysticLightControllers, MSI_USB_VID, 0x3EA4, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_4459", DetectMSIMysticLightControllers, MSI_USB_VID, 0x4459, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7B10", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7B10, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7B94", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7B94, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7B96", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7B96, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C42", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C42, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C70", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C70, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C85", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C85, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C88", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C88, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C89", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C89, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C96", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C96, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C99", DetectMSIMysticLightControllers, MSI_USB_VID, 0x7C99, 0x0001, 0x00);
REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_905D", DetectMSIMysticLightControllers, MSI_USB_VID, 0x905D, 0x0001, 0x00);
#endif