TEST: increment above latest firmware to verify it works

Ensure macOS SMBus detectors initialize the macUSPCIO connection before attempting detection instead of relying on the cached connection status.

InitMacUSPCIODriver() is idempotent, so this preserves the normal startup path while allowing the detectors to establish the required connection when needed.

Also update the failure messages to report initialization failure rather than incorrectly assuming macUSPCIO is not loaded.

Controllers/ASRockSMBusController/ASRockGPUSMBusController/ASRockGPUSMBusControllerDetect.cpp

@@ -41,5 +41,6 @@ DetectedControllers DetectASRockGPUSMBusControllers(i2c_smbus_interface* bus, ui
     return(detected_controllers);
 }
 
-REGISTER_I2C_PCI_DETECTOR("ASRock Radeon RX 9070 XT Steel Legend", DetectASRockGPUSMBusControllers, AMD_GPU_VEN, AMD_NAVI48_DEV, ASROCK_SUB_VEN, 0x5403, ASROCK_GPU_SMBUS_ADDRESS);
-REGISTER_I2C_PCI_DETECTOR("ASRock Radeon RX 9060 XT Steel Legend", DetectASRockGPUSMBusControllers, AMD_GPU_VEN, AMD_NAVI44_DEV, ASROCK_SUB_VEN, 0x5407, ASROCK_GPU_SMBUS_ADDRESS);
+REGISTER_I2C_PCI_DETECTOR("ASRock Radeon RX 9070 XT Steel Legend",   DetectASRockGPUSMBusControllers, AMD_GPU_VEN, AMD_NAVI48_DEV, ASROCK_SUB_VEN, 0x5403, ASROCK_GPU_SMBUS_ADDRESS);
+REGISTER_I2C_PCI_DETECTOR("ASRock Radeon RX 9070 XT Taichi 16GB OC", DetectASRockGPUSMBusControllers, AMD_GPU_VEN, AMD_NAVI48_DEV, ASROCK_SUB_VEN, 0x5401, ASROCK_GPU_SMBUS_ADDRESS);
+REGISTER_I2C_PCI_DETECTOR("ASRock Radeon RX 9060 XT Steel Legend",   DetectASRockGPUSMBusControllers, AMD_GPU_VEN, AMD_NAVI44_DEV, ASROCK_SUB_VEN, 0x5407, ASROCK_GPU_SMBUS_ADDRESS);

Controllers/AlienwareController/AlienwareController.cpp

@@ -32,6 +32,7 @@ static const std::map<alienware_platform_id, uint8_t> zone_quirks_table =
     { 0x0C01,   4 },    // Dell G5 SE 5505
     { 0x0A01,  16 },    // Dell G7 15 7500
     { 0x0E03,   4 },    // Dell G15   5511
+    { 0x0E07,   4 },    // Dell G15   5520
     { 0x0E0A,   4 }     // Dell G15   5530
 
 };
@@ -49,9 +50,21 @@ static const std::map<alienware_platform_id, std::vector<const char*>> zone_name
                   "Light Bar 7",    "Light Bar 8",  "Light Bar 9",
                   "Light Bar 10",   "Light Bar 11", "Light Bar 12"              } },
     { 0x0E03,   { "Left",           "Middle",       "Right",        "Numpad"    } },
+    { 0x0E07,   { "Left",           "Middle",       "Right",        "Numpad"    } },
     { 0x0E0A,   { "Left",           "Middle",       "Right",        "Numpad"    } }
 };
 
+/*---------------------------------------------------------*\
+| Mapping the platform ID to the actual hardware zone IDs   |
+\*---------------------------------------------------------*/
+static const std::map<alienware_platform_id, std::vector<uint8_t>> zone_ids_table =
+{
+    { 0x0C01,   { 0x00, 0x01, 0x02, 0x03 } }, // Dell G5 SE 5505
+    { 0x0E03,   { 0x00, 0x01, 0x02, 0x03 } }, // Dell G15   5511
+    { 0x0E07,   { 0x10, 0x11, 0x12, 0x13 } }, // Dell G15   5520
+    { 0x0E0A,   { 0x10, 0x11, 0x12, 0x13 } }  // Dell G15   5530
+};
+
 static void SendHIDReport(hid_device *dev, const unsigned char* usb_buf, size_t usb_buf_size)
 {
     using namespace std::chrono_literals;
@@ -138,6 +151,21 @@ AlienwareController::AlienwareController(hid_device* dev_handle, const hid_devic
         }
     }
 
+    /*-----------------------------------------------------*\
+    | Initialize hardware zone IDs                          |
+    \*-----------------------------------------------------*/
+    if(zone_ids_table.count(platform_id))
+    {
+        zone_ids = zone_ids_table.at(platform_id);
+    }
+    else
+    {
+        for(size_t i = 0; i < number_of_zones; i++)
+        {
+            zone_ids.push_back(static_cast<uint8_t>(i));
+        }
+    }
+
     /*-----------------------------------------------------*\
     | Set defaults for all zones                            |
     | It doesn't seem possible to read the controller's     |
@@ -155,6 +183,7 @@ AlienwareController::AlienwareController(hid_device* dev_handle, const hid_devic
         zones[zone_idx].period      = 2000;
         zones[zone_idx].tempo       = ALIENWARE_TEMPO_MAX;
         zones[zone_idx].dim         = 0;
+        zones[zone_idx].direction   = 0;
     }
 
     /*-----------------------------------------------------*\
@@ -673,6 +702,15 @@ void AlienwareController::SetDim(uint8_t zone, uint8_t dim)
     }
 }
 
+void AlienwareController::SetDirection(uint8_t zone, uint8_t direction)
+{
+    if(zone < zones.size())
+    {
+        zones[zone].direction   = direction;
+        dirty                   = true;
+    }
+}
+
 void AlienwareController::UpdateDim()
 {
     if(!dirty_dim)
@@ -688,7 +726,8 @@ void AlienwareController::UpdateDim()
 
     for(size_t i = 0; i < zones.size(); i++)
     {
-        dim_zone_map[zones[i].dim].emplace_back((uint8_t)i);
+        uint8_t hw_zone = (i < zone_ids.size()) ? zone_ids[i] : static_cast<uint8_t>(i);
+        dim_zone_map[zones[i].dim].emplace_back(hw_zone);
     }
 
     for(std::pair<const uint8_t, std::vector<uint8_t>> &pair : dim_zone_map)
@@ -715,7 +754,8 @@ bool AlienwareController::UpdateDirect()
 
     for(size_t i = 0; i < zones.size(); i++)
     {
-        color_zone_map[zones[i].color[0]].emplace_back((uint8_t)i);
+        uint8_t hw_zone = (i < zone_ids.size()) ? zone_ids[i] : static_cast<uint8_t>(i);
+        color_zone_map[zones[i].color[0]].emplace_back(hw_zone);
     }
 
     for(std::pair<const RGBColor, std::vector<uint8_t>> &pair : color_zone_map)
@@ -759,8 +799,9 @@ void AlienwareController::UpdateMode()
     for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
     {
         alienware_zone zone = zones[zone_idx];
+        uint8_t hw_zone = (zone_idx < zone_ids.size()) ? zone_ids[zone_idx] : static_cast<uint8_t>(zone_idx);
 
-        result = SelectZones({static_cast<uint8_t>(zone_idx)});
+        result = SelectZones({hw_zone});
 
         if(!result)
         {
@@ -783,18 +824,18 @@ void AlienwareController::UpdateMode()
 
             case ALIENWARE_MODE_MORPH:
                 {
-                    uint8_t  zones[2]   = { zone.mode,              zone.mode     };
+                    uint8_t  modes[2]   = { zone.mode,              zone.mode     };
                     uint16_t periods[2] = { zone.period,            zone.period   };
                     uint16_t tempos[2]  = { zone.tempo,             zone.tempo    };
                     RGBColor colors[2]  = { zone.color[0],          zone.color[1] };
 
-                    result = MultiModeAction(zones, periods, tempos, colors, 2);
+                    result = MultiModeAction(modes, periods, tempos, colors, 2);
                 }
                 break;
 
             case ALIENWARE_MODE_SPECTRUM:
                 {
-                    uint8_t  zones[7]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                    uint8_t  modes[7]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
                                             ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
                                             ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
                                             ALIENWARE_MODE_MORPH };
@@ -807,13 +848,13 @@ void AlienwareController::UpdateMode()
                                             zone.tempo,             zone.tempo,
                                             zone.tempo };
 
-                    result = MultiModeAction(zones, periods, tempos, rainbow_colors[0], 7);
+                    result = MultiModeAction(modes, periods, tempos, rainbow_colors[0], 7);
                 }
                 break;
 
             case ALIENWARE_MODE_RAINBOW:
                 {
-                    uint8_t  zones[7]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                    uint8_t  modes[7]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
                                             ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
                                             ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
                                             ALIENWARE_MODE_MORPH };
@@ -826,18 +867,19 @@ void AlienwareController::UpdateMode()
                                             zone.tempo,             zone.tempo,
                                             zone.tempo };
 
-                    result = MultiModeAction(zones, periods, tempos, rainbow_colors[zone_idx], 7);
+                    unsigned int color_idx = (zone.direction == MODE_DIRECTION_LEFT) ? (4 - 1 - (zone_idx % 4)) : (zone_idx % 4);
+                    result = MultiModeAction(modes, periods, tempos, rainbow_colors[color_idx], 7);
                 }
                 break;
 
             case ALIENWARE_MODE_BREATHING:
                 {
-                    uint8_t  zones[2]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH };
+                    uint8_t  modes[2]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH };
                     uint16_t periods[2] = { zone.period,            zone.period          };
                     uint16_t tempos[2]  = { zone.tempo,             zone.tempo           };
                     RGBColor colors[2]  = { zone.color[0],          0x0                  };
 
-                    result = MultiModeAction(zones, periods, tempos, colors, 2);
+                    result = MultiModeAction(modes, periods, tempos, colors, 2);
                 }
                 break;
 
@@ -864,6 +906,117 @@ void AlienwareController::UpdateMode()
     dirty = false;
 }
 
+void AlienwareController::SaveController()
+{
+    /*-----------------------------------------------------*\
+    | Save current mode configuration to EEPROM slot 0x0061 |
+    \*-----------------------------------------------------*/
+    UserAnimation(ALIENWARE_COMMAND_USER_ANIM_REMOVE, ALIENWARE_ANIM_DEFAULT, 0);
+    bool result = UserAnimation(ALIENWARE_COMMAND_USER_ANIM_NEW, ALIENWARE_ANIM_DEFAULT, 0);
+
+    if(!result)
+    {
+        return;
+    }
+
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        alienware_zone zone = zones[zone_idx];
+        uint8_t hw_zone = (zone_idx < zone_ids.size()) ? zone_ids[zone_idx] : static_cast<uint8_t>(zone_idx);
+
+        result = SelectZones({hw_zone});
+
+        if(!result)
+        {
+            return;
+        }
+
+        switch (zone.mode)
+        {
+            case ALIENWARE_MODE_COLOR:
+                result = ModeAction(zone.mode, 2000, ALIENWARE_TEMPO_MAX, zone.color[0]);
+                break;
+
+            case ALIENWARE_MODE_PULSE:
+                result = ModeAction(zone.mode, zone.period, zone.tempo, zone.color[0]);
+                break;
+
+            case ALIENWARE_MODE_MORPH:
+                {
+                    uint8_t  modes[2]   = { zone.mode,              zone.mode     };
+                    uint16_t periods[2] = { zone.period,            zone.period   };
+                    uint16_t tempos[2]  = { zone.tempo,             zone.tempo    };
+                    RGBColor colors[2]  = { zone.color[0],          zone.color[1] };
+
+                    result = MultiModeAction(modes, periods, tempos, colors, 2);
+                }
+                break;
+
+            case ALIENWARE_MODE_SPECTRUM:
+                {
+                    uint8_t  modes[7]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                                            ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                                            ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                                            ALIENWARE_MODE_MORPH };
+                    uint16_t periods[7] = { zone.period,            zone.period,
+                                            zone.period,            zone.period,
+                                            zone.period,            zone.period,
+                                            zone.period };
+                    uint16_t tempos[7] = {  zone.tempo,             zone.tempo,
+                                            zone.tempo,             zone.tempo,
+                                            zone.tempo,             zone.tempo,
+                                            zone.tempo };
+
+                    result = MultiModeAction(modes, periods, tempos, rainbow_colors[0], 7);
+                }
+                break;
+
+            case ALIENWARE_MODE_RAINBOW:
+                {
+                    uint8_t  modes[7]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                                            ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                                            ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                                            ALIENWARE_MODE_MORPH };
+                    uint16_t periods[7] = { zone.period,            zone.period,
+                                            zone.period,            zone.period,
+                                            zone.period,            zone.period,
+                                            zone.period };
+                    uint16_t tempos[7]  = { zone.tempo,             zone.tempo,
+                                            zone.tempo,             zone.tempo,
+                                            zone.tempo,             zone.tempo,
+                                            zone.tempo };
+
+                    unsigned int color_idx = (zone.direction == MODE_DIRECTION_LEFT) ? (4 - 1 - (zone_idx % 4)) : (zone_idx % 4);
+                    result = MultiModeAction(modes, periods, tempos, rainbow_colors[color_idx], 7);
+                }
+                break;
+
+            case ALIENWARE_MODE_BREATHING:
+                {
+                    uint8_t  modes[2]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH };
+                    uint16_t periods[2] = { zone.period,            zone.period          };
+                    uint16_t tempos[2]  = { zone.tempo,             zone.tempo           };
+                    RGBColor colors[2]  = { zone.color[0],          0x0                  };
+
+                    result = MultiModeAction(modes, periods, tempos, colors, 2);
+                }
+                break;
+
+            default:
+                result = false;
+        }
+
+        if(!result)
+        {
+            return;
+        }
+    }
+
+    UserAnimation(ALIENWARE_COMMAND_USER_ANIM_FINISH_SAVE, ALIENWARE_ANIM_DEFAULT, 0);
+    UserAnimation(ALIENWARE_COMMAND_USER_ANIM_DEFAULT, ALIENWARE_ANIM_DEFAULT, 0);
+    UserAnimation(ALIENWARE_COMMAND_USER_ANIM_STARTUP, ALIENWARE_ANIM_DEFAULT, 0);
+}
+
 void AlienwareController::UpdateController()
 {
     UpdateMode();

Controllers/AlienwareController/AlienwareController.h

@@ -123,11 +123,13 @@ public:
     void                        SetPeriod(uint8_t zone, uint16_t period);
     void                        SetTempo(uint8_t zone, uint16_t tempo);
     void                        SetDim(uint8_t zone, uint8_t dim);
+    void                        SetDirection(uint8_t zone, uint8_t direction);
     AlienwareReport             GetStatus(uint8_t subcommand);
 
     void                        UpdateDim();
     void                        UpdateMode();
     void                        UpdateController();
+    void                        SaveController();
 
 protected:
     hid_device* dev;
@@ -140,6 +142,7 @@ private:
         uint16_t                period;
         uint16_t                tempo;
         uint8_t                 dim;
+        uint8_t                 direction;
     } alienware_zone;
 
     typedef struct
@@ -153,6 +156,7 @@ private:
     std::string                 serial_number;
     std::string                 version;
     std::vector<const char*>    zone_names;
+    std::vector<uint8_t>        zone_ids;
     bool                        dirty;
     bool                        dirty_dim;
 

Controllers/AlienwareController/RGBController_Alienware.cpp

@@ -39,7 +39,7 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* controller
     mode Color;
     Color.name                 = "Static";
     Color.value                = ALIENWARE_MODE_COLOR;
-    Color.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Color.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
     Color.color_mode           = MODE_COLORS_PER_LED;
     Color.colors_min           = 1;
     Color.colors_max           = 1;
@@ -51,13 +51,13 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* controller
     mode Pulse;
     Pulse.name                 = "Flashing";
     Pulse.value                = ALIENWARE_MODE_PULSE;
-    Pulse.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Pulse.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
     Pulse.color_mode           = MODE_COLORS_PER_LED;
     Pulse.colors_min           = 1;
     Pulse.colors_max           = 1;
-    Pulse.speed_min            = ALIENWARE_TEMPO_MIN;
-    Pulse.speed_max            = ALIENWARE_TEMPO_MAX;
-    Pulse.speed                = ALIENWARE_TEMPO_MIN;
+    Pulse.speed_min            = ALIENWARE_TEMPO_MAX;
+    Pulse.speed_max            = 50;
+    Pulse.speed                = 150;
     Pulse.brightness_min       = 100;
     Pulse.brightness_max       = 0;
     Pulse.brightness           = 0;
@@ -66,14 +66,16 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* controller
     mode Morph;
     Morph.name                 = "Morph";
     Morph.value                = ALIENWARE_MODE_MORPH;
-    Morph.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Morph.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
     Morph.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-    Morph.colors_min           = 2 * controller->GetZoneCount();
-    Morph.colors_max           = Morph.colors_min;
-    Morph.colors.resize(Morph.colors_max);
-    Morph.speed_min            = ALIENWARE_TEMPO_MIN;
-    Morph.speed_max            = ALIENWARE_TEMPO_MAX;
-    Morph.speed                = ALIENWARE_TEMPO_MIN;
+    Morph.colors_min           = 2;
+    Morph.colors_max           = 2 * controller->GetZoneCount();
+    Morph.colors.resize(2);
+    Morph.colors[0]            = 0x0000FF;
+    Morph.colors[1]            = 0xFF0000;
+    Morph.speed_min            = ALIENWARE_TEMPO_MAX;
+    Morph.speed_max            = 20;
+    Morph.speed                = 100;
     Morph.brightness_min       = 100;
     Morph.brightness_max       = 0;
     Morph.brightness           = 0;
@@ -82,11 +84,11 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* controller
     mode Spectrum;
     Spectrum.name              = "Spectrum Cycle";
     Spectrum.value             = ALIENWARE_MODE_SPECTRUM;
-    Spectrum.flags             = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Spectrum.flags             = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
     Spectrum.color_mode        = MODE_COLORS_NONE;
-    Spectrum.speed_min         = ALIENWARE_TEMPO_SPECTRUM;
-    Spectrum.speed_max         = ALIENWARE_TEMPO_MAX;
-    Spectrum.speed             = ALIENWARE_TEMPO_SPECTRUM;
+    Spectrum.speed_min         = ALIENWARE_TEMPO_MAX;
+    Spectrum.speed_max         = ALIENWARE_TEMPO_SPECTRUM;
+    Spectrum.speed             = 40;
     Spectrum.brightness_min    = 100;
     Spectrum.brightness_max    = 0;
     Spectrum.brightness        = 0;
@@ -95,11 +97,12 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* controller
     mode Rainbow;
     Rainbow.name               = "Rainbow Wave";
     Rainbow.value              = ALIENWARE_MODE_RAINBOW;
-    Rainbow.flags              = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Rainbow.flags              = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_MANUAL_SAVE;
     Rainbow.color_mode         = MODE_COLORS_NONE;
-    Rainbow.speed_min          = ALIENWARE_TEMPO_SPECTRUM;
-    Rainbow.speed_max          = ALIENWARE_TEMPO_MAX;
-    Rainbow.speed              = ALIENWARE_TEMPO_SPECTRUM;
+    Rainbow.speed_min          = ALIENWARE_TEMPO_MAX;
+    Rainbow.speed_max          = ALIENWARE_TEMPO_SPECTRUM;
+    Rainbow.speed              = 40;
+    Rainbow.direction          = MODE_DIRECTION_RIGHT;
     Rainbow.brightness_min     = 100;
     Rainbow.brightness_max     = 0;
     Rainbow.brightness         = 0;
@@ -108,13 +111,13 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* controller
     mode Breathing;
     Breathing.name             = "Breathing";
     Breathing.value            = ALIENWARE_MODE_BREATHING;
-    Breathing.flags            = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Breathing.flags            = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
     Breathing.color_mode       = MODE_COLORS_PER_LED;
     Breathing.colors_min       = 1;
     Breathing.colors_max       = 1;
-    Breathing.speed_min        = ALIENWARE_TEMPO_MIN;
-    Breathing.speed_max        = ALIENWARE_TEMPO_MAX;
-    Breathing.speed            = ALIENWARE_TEMPO_MIN;
+    Breathing.speed_min        = ALIENWARE_TEMPO_MAX;
+    Breathing.speed_max        = 50;
+    Breathing.speed            = 150;
     Breathing.brightness_min   = 100;
     Breathing.brightness_max   = 0;
     Breathing.brightness       = 0;
@@ -224,6 +227,7 @@ void RGBController_Alienware::DeviceUpdateMode()
             uint16_t period = 0x07d0;
 
             controller->SetMode(zone_idx, current_mode.value);
+            controller->SetDirection(zone_idx, current_mode.direction);
 
             switch(current_mode_idx)
             {
@@ -235,6 +239,7 @@ void RGBController_Alienware::DeviceUpdateMode()
                     break;
 
                 case ALIENWARE_MODE_PULSE:
+                    period = std::max<uint16_t>(500, (uint16_t)(current_mode.speed * 10));
                     controller->SetPeriod(zone_idx, period);
                     controller->SetColor( zone_idx, colors[current_zone.start_idx]);
                     controller->SetTempo( zone_idx, current_mode.speed);
@@ -242,10 +247,22 @@ void RGBController_Alienware::DeviceUpdateMode()
                     break;
 
                 case ALIENWARE_MODE_MORPH:
-                    controller->SetPeriod(zone_idx, period);
-                    controller->SetColor( zone_idx, current_mode.colors[zone_idx * 2], current_mode.colors[(zone_idx * 2) + 1]);
-                    controller->SetTempo( zone_idx, current_mode.speed);
-                    controller->SetDim(   zone_idx, modes[current_mode_idx].brightness);
+                    {
+                        RGBColor c1 = (current_mode.colors.size() >= 1) ? current_mode.colors[0] : 0x0000FF;
+                        RGBColor c2 = (current_mode.colors.size() >= 2) ? current_mode.colors[1] : 0xFF0000;
+
+                        if(current_mode.colors.size() >= (zone_idx + 1) * 2)
+                        {
+                            c1 = current_mode.colors[zone_idx * 2];
+                            c2 = current_mode.colors[(zone_idx * 2) + 1];
+                        }
+
+                        period = std::max<uint16_t>(400, (uint16_t)(current_mode.speed * 10));
+                        controller->SetPeriod(zone_idx, period);
+                        controller->SetColor( zone_idx, c1, c2);
+                        controller->SetTempo( zone_idx, current_mode.speed);
+                        controller->SetDim(   zone_idx, modes[current_mode_idx].brightness);
+                    }
                     break;
 
                 case ALIENWARE_MODE_SPECTRUM:
@@ -256,6 +273,7 @@ void RGBController_Alienware::DeviceUpdateMode()
                     break;
 
                 case ALIENWARE_MODE_BREATHING:
+                    period = std::max<uint16_t>(500, (uint16_t)(current_mode.speed * 10));
                     controller->SetPeriod(zone_idx, period);
                     controller->SetColor( zone_idx, colors[current_zone.start_idx], 0x0);
                     controller->SetTempo( zone_idx, current_mode.speed);
@@ -282,3 +300,9 @@ void RGBController_Alienware::DeviceUpdateMode()
         current_mode              = new_current_mode;
     }
 }
+
+void RGBController_Alienware::DeviceSaveMode()
+{
+    controller->SaveController();
+}
+

Controllers/AlienwareController/RGBController_Alienware.h

@@ -28,6 +28,7 @@ public:
     void        DeviceUpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
+    void        DeviceSaveMode();
 
 private:
     AlienwareController*                    controller;

Controllers/ClevoKeyboardController/ClevoKeyboardDevices.cpp

@@ -18,71 +18,79 @@
 |                                                           |
 | Based on KEYBOARD_SIZE_TKL with numpad added and          |
 | navigation cluster adjusted to match Clevo's layout.      |
-|                                                           |
-| Hardware LED indices (value field):                       |
-| - Row 5 (F-keys):     105-124                             |
-| - Row 4 (numbers):    84-102                              |
-| - Row 3 (QWERTY):     63-81                               |
-| - Row 2 (home):       42-59                               |
-| - Row 1 (Z row):      22-39                               |
-| - Row 0 (modifiers):  0-18                                |
 \*---------------------------------------------------------*/
 
 /*---------------------------------------------------------*\
-| LED values in TKL order (fn_row + main + extras)          |
+| LED values, in physical (row, then column) order.         |
+|                                                           |
+| This must match the order KeyboardLayoutManager assigns   |
+| default_values against: the structural keymap sorted by   |
+| (row, col) across main+fn_row+extras combined, NOT the    |
+| fn_row-then-main-then-extras order the zone tables below  |
+| are declared in. Getting this wrong silently misassigns   |
+| almost every key from Print Screen onward, not just a few.|
 |                                                           |
-| Values follow the key order in KeyboardLayoutManager.cpp. |
 | For ANSI-only keys (not present on this ISO keyboard),    |
 | use 0 as a placeholder - they won't be displayed.         |
 | Numpad values are added via edit_keys.                    |
 \*---------------------------------------------------------*/
 static const std::vector<unsigned int> clevo_tkl_values =
 {
-    /*---------------------------------------------------------*\
-    | Function row (keyboard_zone_fn_row)                       |
-    \*---------------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Row 0: fn_row + Print Screen/Scroll Lock/Pause        |
+    \*-----------------------------------------------------*/
     105,                                                        // Escape
     106, 107, 108, 109,                                         // F1-F4
     110, 111, 112, 113,                                         // F5-F8
     114, 115, 116, 117,                                         // F9-F12
+    118,                                                        // Print Screen
+    0,                                                          // Scroll Lock (removed via edit_keys)
+    0,                                                          // Pause (removed via edit_keys)
 
-    /*---------------------------------------------------------*\
-    | Main block - Row 1 (keyboard_zone_main)                   |
-    \*---------------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Row 1: numbers row + Insert/Home/Page Up              |
+    \*-----------------------------------------------------*/
     84,                                                         // Back tick
     85, 86, 87, 88, 89, 90, 91, 92, 93, 94,                     // 1-0
     95, 96,                                                     // Minus, Equals
     98,                                                         // Backspace
+    119,                                                        // Insert
+    121,                                                        // Home
+    122,                                                        // Page Up
 
-    /*---------------------------------------------------------*\
-    | Main block - Row 2                                        |
-    \*---------------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Row 2: Tab/QWERTY row + Delete/End/PageDown           |
+    \*-----------------------------------------------------*/
     63,                                                         // Tab
     65, 66, 67, 68, 69, 70, 71, 72, 73, 74,                     // Q-P
     75, 76,                                                     // [ ]
     0,                                                          // ANSI backslash (not on ISO)
+    120,                                                        // Delete
+    124,                                                        // End
+    123,                                                        // Page Down
 
-    /*---------------------------------------------------------*\
-    | Main block - Row 3                                        |
-    \*---------------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Row 3: Caps Lock/home row/Enter                       |
+    \*-----------------------------------------------------*/
     42,                                                         // Caps Lock
     44, 45, 46, 47, 48, 49, 50, 51, 52,                         // A-L
     53, 54,                                                     // ; '
     55,                                                         // ISO # (POUND)
-    77,                                                         // Enter (ANSI/ISO share same LED)
+    56,                                                         // Enter
 
-    /*---------------------------------------------------------*\
-    | Main block - Row 4                                        |
-    \*---------------------------------------------------------*/
-    22,                                                         // Left Shift
-    23,                                                         // ISO backslash
+    /*-----------------------------------------------------*\
+    | Row 4: Left Shift/ISO backslash/Z row + Up            |
+    \*-----------------------------------------------------*/
+    21,                                                         // Left Shift
+    77,                                                         // ISO backslash
     24, 25, 26, 27, 28, 29, 30, 31, 32,                         // Z-. (9 keys)
     33,                                                         // /
     35,                                                         // Right Shift
+    14,                                                         // Up
 
-    /*---------------------------------------------------------*\
-    | Main block - Row 5                                        |
-    \*---------------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Row 5: bottom modifier row + Left/Down/Right          |
+    \*-----------------------------------------------------*/
     0,                                                          // Left Ctrl
     3,                                                          // Left Win
     4,                                                          // Left Alt
@@ -91,24 +99,6 @@ static const std::vector<unsigned int> clevo_tkl_values =
     0,                                                          // Right Fn (removed via edit_keys)
     0,                                                          // Menu (removed via edit_keys)
     12,                                                         // Right Ctrl
-
-    /*---------------------------------------------------------*\
-    | Extras - Navigation cluster (keyboard_zone_extras)        |
-    \*---------------------------------------------------------*/
-    118,                                                        // Print Screen
-    0,                                                          // Scroll Lock (removed via edit_keys)
-    0,                                                          // Pause (removed via edit_keys)
-    119,                                                        // Insert
-    121,                                                        // Home
-    123,                                                        // Page Up
-    120,                                                        // Delete
-    122,                                                        // End
-    124,                                                        // Page Down
-
-    /*---------------------------------------------------------*\
-    | Extras - Arrow keys                                       |
-    \*---------------------------------------------------------*/
-    14,                                                         // Up
     13,                                                         // Left
     18,                                                         // Down
     15,                                                         // Right

Controllers/HIDLampArrayController/RGBController_HIDLampArray.cpp

@@ -196,7 +196,7 @@ static const char *HIDUsageIDsToKeyNames[HID_KEYBOARD_USAGE_IDS_COUNT] =
     KEY_EN_NUMPAD_0,            // Keypad 0 and Insert
     KEY_EN_NUMPAD_PERIOD,       // Keypad . and Delete
     KEY_EN_BACK_SLASH,          // Keyboard Non-US \ and |
-    KEY_EN_UNUSED,              // Keyboard Application
+    KEY_EN_MENU,                // Keyboard Application
     KEY_EN_POWER,               // Keyboard Power
     KEY_EN_NUMPAD_EQUAL,        // Keypad =
     KEY_EN_F13,                 // Keyboard F13
@@ -260,6 +260,16 @@ static const char *HIDUsageIDsToKeyNames[HID_KEYBOARD_USAGE_IDS_COUNT] =
     KEY_EN_UNUSED,              // Keyboard Clear/Again
     KEY_EN_UNUSED,              // Keyboard CrSel/Props
     KEY_EN_UNUSED,              // Keyboard ExSel
+    KEY_EN_UNUSED,              // A5 Reserved
+    KEY_EN_UNUSED,              // A6 Reserved
+    KEY_EN_UNUSED,              // A7 Reserved
+    KEY_EN_UNUSED,              // A8 Reserved
+    KEY_EN_UNUSED,              // A9 Reserved
+    KEY_EN_UNUSED,              // AA Reserved
+    KEY_EN_UNUSED,              // AB Reserved
+    KEY_EN_UNUSED,              // AC Reserved
+    KEY_EN_UNUSED,              // AD Reserved
+    KEY_EN_UNUSED,              // AE Reserved
     KEY_EN_UNUSED,              // AF Reserved
     KEY_EN_UNUSED,              // Keypad 00
     KEY_EN_UNUSED,              // Keypad 000
@@ -307,6 +317,7 @@ static const char *HIDUsageIDsToKeyNames[HID_KEYBOARD_USAGE_IDS_COUNT] =
     KEY_EN_UNUSED,              // Keypad Octal
     KEY_EN_UNUSED,              // Keypad Decimal
     KEY_EN_UNUSED,              // Keypad Hexadecimal
+    KEY_EN_UNUSED,              // DE Reserved
     KEY_EN_UNUSED,              // DF Reserved
     KEY_EN_LEFT_CONTROL,        // Keyboard LeftControl
     KEY_EN_LEFT_SHIFT,          // Keyboard LeftShift
@@ -357,9 +368,11 @@ void RGBController_HIDLampArray::SetupZones()
     {
         led new_led;
 
-        if(controller->GetLamps()[lamp_idx].LampKey < HID_KEYBOARD_USAGE_IDS_COUNT)
+        unsigned char lamp_key = controller->GetLamps()[lamp_idx].LampKey;
+
+        if(lamp_key < HID_KEYBOARD_USAGE_IDS_COUNT && HIDUsageIDsToKeyNames[lamp_key] != nullptr)
         {
-            new_led.name = HIDUsageIDsToKeyNames[controller->GetLamps()[lamp_idx].LampKey];
+            new_led.name = HIDUsageIDsToKeyNames[lamp_key];
         }
         else
         {

Controllers/MSIMotherboardController/MSIMotherboard112Controller/MSIMotherboard112Controller.cpp

@@ -38,17 +38,24 @@ MSIMotherboard112Controller::MSIMotherboard112Controller(hid_device* handle, con
     location    = path;
     name        = dev_name;
 
-    if(dev)
-    {
-        ReadFwVersion();
-        ReadSettings();
-    }
+    /*-----------------------------------------------------*\
+    | Perform initial reads - get the controller's firmware |
+    | version and then read the controller's active         |
+    | configuration data                                    |
+    \*-----------------------------------------------------*/
+    ReadFwVersion();
+    ReadSettings();
 
     /*-----------------------------------------------------*\
-    | Initialize save flag                                  |
+    | The last byte of the packet is the save flag.  This   |
+    | byte is stored as a zero in the data flash, but is    |
+    | set to 1 at the protocol level to tell the firmware   |
+    | to save the active configuration to flash.            |
+    | Also set onboard zone to act as sync master for all   |
+    | of the onboard LEDs.                                  |
     \*-----------------------------------------------------*/
-    data.save_data = 0;
-    data.on_board_led.colorFlags = 0x81;    // force MS bit of color flags to 1 to have expected zone control
+    data.save_data                  = 0;
+    data.on_board_led.colorFlags    = MSI_COLOR_FLAG_USE_CUSTOM_COLOR | MSI_COLOR_FLAG_SYNC_SETTING_ONBOARD;
 
     /*-----------------------------------------------------*\
     | Initialize zone based per LED data                    |
@@ -56,25 +63,25 @@ MSIMotherboard112Controller::MSIMotherboard112Controller(hid_device* handle, con
     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;
+    zone_based_per_led_data.j_rgb_1.speedAndBrightnessFlags         = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+    zone_based_per_led_data.j_rgb_1.colorFlags                     |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+    zone_based_per_led_data.j_rainbow_1.speedAndBrightnessFlags     = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+    zone_based_per_led_data.j_rainbow_1.colorFlags                 |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+    zone_based_per_led_data.on_board_led.speedAndBrightnessFlags    = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+    zone_based_per_led_data.on_board_led.colorFlags                |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+    zone_based_per_led_data.on_board_led_1.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+    zone_based_per_led_data.on_board_led_1.colorFlags              |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+    zone_based_per_led_data.on_board_led_2.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+    zone_based_per_led_data.on_board_led_2.colorFlags              |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+    zone_based_per_led_data.on_board_led_3.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+    zone_based_per_led_data.on_board_led_3.colorFlags              |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+    zone_based_per_led_data.on_board_led_4.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+    zone_based_per_led_data.on_board_led_4.colorFlags              |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+    zone_based_per_led_data.on_board_led_5.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+    zone_based_per_led_data.on_board_led_5.colorFlags              |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+    zone_based_per_led_data.on_board_led_6.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+    zone_based_per_led_data.on_board_led_6.colorFlags              |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+    zone_based_per_led_data.save_data                               = 0;
 
     direct_mode = false;
 }
@@ -93,29 +100,38 @@ void MSIMotherboard112Controller::SetMode
     bool            rainbow_color
     )
 {
+    /*-----------------------------------------------------*\
+    | Get the zone data pointer within the configuration    |
+    | data buffer                                           |
+    \*-----------------------------------------------------*/
     ZoneData* zone_data = GetZoneData(data, zone);
 
+    /*-----------------------------------------------------*\
+    | Return if zone is invalid                             |
+    \*-----------------------------------------------------*/
     if(zone_data == nullptr)
     {
         return;
     }
 
-    if (zone <= MSI_ZONE_ON_BOARD_LED_0)
+    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->speedAndBrightnessFlags   = ((brightness << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT) & MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_MASK)
+                                             | ((speed << MSI_SPEED_BRIGHTNESS_FLAG_SPEED_SHIFT)           & MSI_SPEED_BRIGHTNESS_FLAG_SPEED_MASK);
+        zone_data->colorFlags                = (rainbow_color ? (zone_data->colorFlags & ~MSI_COLOR_FLAG_USE_CUSTOM_COLOR)
+                                                              : (zone_data->colorFlags | MSI_COLOR_FLAG_USE_CUSTOM_COLOR));
         zone_data->padding                   = 0x00;
 
         if(mode > MSI_MODE_DOUBLE_FLASHING)
         {
-            zone_data->speedAndBrightnessFlags |= SYNC_SETTING_JRGB;
-            zone_data->colorFlags              |= SYNC_SETTING_ONBOARD;
+            zone_data->speedAndBrightnessFlags |= MSI_SPEED_BRIGHTNESS_FLAG_SYNC_SETTING_JRGB;
+            zone_data->colorFlags              |= MSI_COLOR_FLAG_SYNC_SETTING_ONBOARD;
         }
         else
         {
-            zone_data->speedAndBrightnessFlags &= ~SYNC_SETTING_JRGB;
-            zone_data->colorFlags              &= ~SYNC_SETTING_ONBOARD;
+            zone_data->speedAndBrightnessFlags &= ~MSI_SPEED_BRIGHTNESS_FLAG_SYNC_SETTING_JRGB;
+            zone_data->colorFlags              &= ~MSI_COLOR_FLAG_SYNC_SETTING_ONBOARD;
         }
     }
 
@@ -126,8 +142,10 @@ void MSIMotherboard112Controller::SetMode
         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->speedAndBrightnessFlags   = ((brightness << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT) & MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_MASK)
+                                                 | ((speed << MSI_SPEED_BRIGHTNESS_FLAG_SPEED_SHIFT)           & MSI_SPEED_BRIGHTNESS_FLAG_SPEED_MASK);
+            zone_data->colorFlags                = (rainbow_color ? (zone_data->colorFlags & ~MSI_COLOR_FLAG_USE_CUSTOM_COLOR)
+                                                                  : (zone_data->colorFlags | MSI_COLOR_FLAG_USE_CUSTOM_COLOR));
             zone_data->padding                   = 0x00;
         }
     }
@@ -201,14 +219,21 @@ void MSIMotherboard112Controller::SetZoneColor
     unsigned char   blu2
     )
 {
+    /*-----------------------------------------------------*\
+    | Get the zone data pointer within the configuration    |
+    | data buffer                                           |
+    \*-----------------------------------------------------*/
     ZoneData* zone_data = GetZoneData(data, zone);
 
+    /*-----------------------------------------------------*\
+    | Return if zone is invalid                             |
+    \*-----------------------------------------------------*/
     if(zone_data == nullptr)
     {
         return;
     }
 
-    if (zone <= MSI_ZONE_ON_BOARD_LED_0)
+    if(zone <= MSI_ZONE_ON_BOARD_LED_0)
     {
         zone_data->color.R  = red1;
         zone_data->color.G  = grn1;
@@ -410,10 +435,10 @@ void MSIMotherboard112Controller::GetMode
     /*-----------------------------------------------------*\
     | 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;
+    mode            = (MSI_MODE)        zone_data->effect;
+    speed           = (MSI_SPEED)     ((zone_data->speedAndBrightnessFlags >> MSI_SPEED_BRIGHTNESS_FLAG_SPEED_SHIFT)      & MSI_SPEED_BRIGHTNESS_FLAG_SPEED_MASK);
+    brightness      = (MSI_BRIGHTNESS)((zone_data->speedAndBrightnessFlags >> MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT) & MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_MASK);
+    rainbow_color   = ((zone_data->colorFlags & MSI_COLOR_FLAG_USE_CUSTOM_COLOR) == 0 ? false : true);
     color           = ToRGBColor(zone_data->color.R, zone_data->color.G, zone_data->color.B);
 }
 

Controllers/MSIMotherboardController/MSIMotherboard162Controller/MSIMotherboard162Controller.cpp

@@ -85,24 +85,32 @@ MSIMotherboard162Controller::MSIMotherboard162Controller(hid_device* handle, con
     location    = path;
     name        = dev_name;
 
-    if(dev)
-    {
-        ReadFwVersion();
-        ReadSettings();
-    }
-
     /*-----------------------------------------------------*\
-    | Initialize save flag                                  |
+    | Perform initial reads - get the controller's firmware |
+    | version and then read the controller's active         |
+    | configuration data                                    |
     \*-----------------------------------------------------*/
-    data.save_data = 0;
-    data.on_board_led.colorFlags = 0x81;    // force MS bit of color flags to 1 to have expectd zone control
+    ReadFwVersion();
+    ReadSettings();
 
     /*-----------------------------------------------------*\
-    | Initialize zone based per LED data                    |
+    | The last byte of the packet is the save flag.  This   |
+    | byte is stored as a zero in the data flash, but is    |
+    | set to 1 at the protocol level to tell the firmware   |
+    | to save the active configuration to flash.            |
+    | Also set onboard zone to act as sync master for all   |
+    | of the onboard LEDs.                                  |
+    \*-----------------------------------------------------*/
+    data.save_data                  = 0;
+    data.on_board_led.colorFlags    = MSI_COLOR_FLAG_USE_CUSTOM_COLOR | MSI_COLOR_FLAG_SYNC_SETTING_ONBOARD;
+
+    /*-----------------------------------------------------*\
+    | Search for the board configuration matching this      |
+    | board.                                                |
     \*-----------------------------------------------------*/
     const mystic_light_162_config* board_config = nullptr;
 
-    for(std::size_t i = 0; i < NUMOF_CONFIGS; ++i)
+    for(std::size_t i = 0; i < NUMOF_CONFIGS; i++)
     {
         if (board_configs[i].pid == pid)
         {
@@ -111,6 +119,10 @@ MSIMotherboard162Controller::MSIMotherboard162Controller(hid_device* handle, con
         }
     }
 
+    /*-----------------------------------------------------*\
+    | Fill in the number of each zone type based on the     |
+    | board configuration                                   |
+    \*-----------------------------------------------------*/
     if(board_config != nullptr)
     {
         numof_onboard_leds = board_config->numof_onboard_leds;
@@ -137,29 +149,38 @@ void MSIMotherboard162Controller::SetMode
     bool            rainbow_color
     )
 {
+    /*-----------------------------------------------------*\
+    | Get the zone data pointer within the configuration    |
+    | data buffer                                           |
+    \*-----------------------------------------------------*/
     ZoneData* zone_data = GetZoneData(data, zone);
 
+    /*-----------------------------------------------------*\
+    | Return if zone is invalid                             |
+    \*-----------------------------------------------------*/
     if(zone_data == nullptr)
     {
         return;
     }
 
-    if (zone <= MSI_ZONE_ON_BOARD_LED_0)
+    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->speedAndBrightnessFlags   = ((brightness << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT) & MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_MASK)
+                                             | ((speed << MSI_SPEED_BRIGHTNESS_FLAG_SPEED_SHIFT)           & MSI_SPEED_BRIGHTNESS_FLAG_SPEED_MASK);
+        zone_data->colorFlags                = (rainbow_color ? (zone_data->colorFlags & ~MSI_COLOR_FLAG_USE_CUSTOM_COLOR)
+                                                              : (zone_data->colorFlags | MSI_COLOR_FLAG_USE_CUSTOM_COLOR));
         zone_data->padding                   = 0x00;
 
         if(mode > MSI_MODE_DOUBLE_FLASHING)
         {
-            zone_data->speedAndBrightnessFlags |= SYNC_SETTING_JRGB;
-            zone_data->colorFlags              |= SYNC_SETTING_ONBOARD;
+            zone_data->speedAndBrightnessFlags |= MSI_SPEED_BRIGHTNESS_FLAG_SYNC_SETTING_JRGB;
+            zone_data->colorFlags              |= MSI_COLOR_FLAG_SYNC_SETTING_ONBOARD;
         }
         else
         {
-            zone_data->speedAndBrightnessFlags &= ~SYNC_SETTING_JRGB;
-            zone_data->colorFlags              &= ~SYNC_SETTING_ONBOARD;
+            zone_data->speedAndBrightnessFlags &= ~MSI_SPEED_BRIGHTNESS_FLAG_SYNC_SETTING_JRGB;
+            zone_data->colorFlags              &= ~MSI_COLOR_FLAG_SYNC_SETTING_ONBOARD;
         }
     }
 
@@ -170,8 +191,10 @@ void MSIMotherboard162Controller::SetMode
         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->speedAndBrightnessFlags   = ((brightness << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT) & MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_MASK)
+                                                 | ((speed << MSI_SPEED_BRIGHTNESS_FLAG_SPEED_SHIFT)           & MSI_SPEED_BRIGHTNESS_FLAG_SPEED_MASK);
+            zone_data->colorFlags                = (rainbow_color ? (zone_data->colorFlags & ~MSI_COLOR_FLAG_USE_CUSTOM_COLOR)
+                                                                  : (zone_data->colorFlags | MSI_COLOR_FLAG_USE_CUSTOM_COLOR));
             zone_data->padding                   = 0x00;
         }
     }
@@ -238,14 +261,21 @@ void MSIMotherboard162Controller::SetZoneColor
     unsigned char   blu2
     )
 {
+    /*-----------------------------------------------------*\
+    | Get the zone data pointer within the configuration    |
+    | data buffer                                           |
+    \*-----------------------------------------------------*/
     ZoneData* zone_data = GetZoneData(data, zone);
 
+    /*-----------------------------------------------------*\
+    | Return if zone is invalid                             |
+    \*-----------------------------------------------------*/
     if(zone_data == nullptr)
     {
         return;
     }
 
-    if (zone <= MSI_ZONE_ON_BOARD_LED_0)
+    if(zone <= MSI_ZONE_ON_BOARD_LED_0)
     {
         zone_data->color.R  = red1;
         zone_data->color.G  = grn1;
@@ -431,10 +461,10 @@ void MSIMotherboard162Controller::GetMode
     /*-----------------------------------------------------*\
     | 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;
+    mode            = (MSI_MODE)        zone_data->effect;
+    speed           = (MSI_SPEED)     ((zone_data->speedAndBrightnessFlags >> MSI_SPEED_BRIGHTNESS_FLAG_SPEED_SHIFT)      & MSI_SPEED_BRIGHTNESS_FLAG_SPEED_MASK);
+    brightness      = (MSI_BRIGHTNESS)((zone_data->speedAndBrightnessFlags >> MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT) & MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_MASK);
+    rainbow_color   = ((zone_data->colorFlags & MSI_COLOR_FLAG_USE_CUSTOM_COLOR) == 0 ? false : true);
     color           = ToRGBColor(zone_data->color.R, zone_data->color.G, zone_data->color.B);
 }
 

Controllers/MSIMotherboardController/MSIMotherboard185Controller/MSIMotherboard185Controller.cpp

@@ -33,18 +33,19 @@ using namespace std::chrono_literals;
 #define JCORSAIR_MAX_LED_COUNT                  240
 
 #define MSI_DIRECT_MODE                         0x25
-#define PER_LED_BASIC_SYNC_MODE                 (0x80 | SYNC_SETTING_ONBOARD | SYNC_SETTING_JPIPE1 | SYNC_SETTING_JPIPE2)
-#define PER_LED_FULL_SYNC_MODE                  (PER_LED_BASIC_SYNC_MODE | SYNC_SETTING_JRAINBOW1 | SYNC_SETTING_JRAINBOW2 | SYNC_SETTING_JCORSAIR)
+#define PER_LED_BASIC_SYNC_MODE                 (MSI_COLOR_FLAG_USE_CUSTOM_COLOR | MSI_COLOR_FLAG_SYNC_SETTING_ONBOARD | MSI_COLOR_FLAG_SYNC_SETTING_JPIPE1 | MSI_COLOR_FLAG_SYNC_SETTING_JPIPE2)
+#define PER_LED_FULL_SYNC_MODE                  (PER_LED_BASIC_SYNC_MODE | MSI_COLOR_FLAG_SYNC_SETTING_JRAINBOW1 | MSI_COLOR_FLAG_SYNC_SETTING_JRAINBOW2 | MSI_COLOR_FLAG_SYNC_SETTING_JCORSAIR)
 
 struct mystic_light_185_config
 {
-    unsigned short                           pid;                   // PID 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
-    MSIMotherboard185Controller::DIRECT_MODE per_led_mode;          // type of direct mode support
+    unsigned short                           pid;                       // PID 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
+    MSIMotherboard185Controller::DIRECT_MODE per_led_mode;              // type of direct mode support
+    unsigned char                            minimum_firmware_version;  // minimum required firmware version for this config (0 = all versions acceptable)
 };
 
 const std::vector<MSI_ZONE> all_zones =
@@ -257,104 +258,103 @@ const std::vector<MSI_ZONE> zones_set21 =
 
 static const mystic_light_185_config board_configs[] =
 {
-    { 0x7B93, 6,  1,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED },    // MPG X570 GAMING PRO CARBON WIFI
-    { 0x7C34, 0,  1,  1, 1, &zones_set8,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED },    // MEG X570 GODLIKE
-    { 0x7C35, 0,  1,  0, 1, &zones_set9,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED },    // MEG X570 ACE
-    { 0x7C36, 6,  1,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED },    // PRESTIGE X570 CREATION
-    { 0x7C37, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED },    // MPG X570 GAMING PLUS
-    { 0x7C56, 6,  0,  0, 1, &zones_set2,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG B550 GAMING PLUS
-    { 0x7C59, 0,  8,  0, 1, &zones_set9,  MSIMotherboard185Controller::DIRECT_MODE_DISABLED },      // CREATOR TRX40
-    { 0x7C60, 6,  0,  0, 1, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // TRX40-A PRO
-    { 0x7C67, 6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B365M MORTAR
-    { 0x7C71, 6,  6,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG Z490 ACE
-    { 0x7C73, 6,  4,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG Z490 GAMING CARBON WIFI
-    { 0x7C75, 6,  0,  0, 1, &zones_set2,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG Z490 GAMING PLUS
-    { 0x7C76, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_DISABLED },      // MPG Z490M GAMING EDGE
-    { 0x7C77, 0,  0,  0, 0, &zones_set14, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG Z490I UNIFY
-    { 0x7C79, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG Z490 GAMING EDGE WIFI
-    { 0x7C80, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG Z490 TOMAHAWK
-    { 0x7C02, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B450 TOMAHAWK MAX
-    { 0x7C81, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B460 TOMAHAWK
-    { 0x7C82, 6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B460M MORTAR WIFI
-    { 0x7C83, 6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_DISABLED },      // B460M PRO-VDH WIFI
-    { 0x7C84, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED },    // MAG X570 TOMAHAWK WIFI
-    { 0x7C86, 6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_DISABLED },      // MPG B460I GAMING EDGE
-    { 0x7C87, 6,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // B450M BAZOOKA MAX WIFI
-    { 0x7C90, 6,  4,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG B550 GAMING CARBON WIFI
-    { 0x7C91, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B550 TOMAHAWK
-    { 0x7C92, 6,  0,  0, 0, &zones_set6,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG B550I GAMING EDGE WIFI
-    { 0x7C94, 6,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B550M MORTAR
-    { 0x7C95, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // B550M PRO-VDH WIFI
-    { 0x7C98, 6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // Z490 PLUS
-    { 0x7D03, 0, 15, 18, 1, &zones_set8,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG Z590 GODLIKE
-    { 0x7D06, 4,  4,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG Z590 GAMING FORCE
-    { 0x7D07, 4,  5,  0, 2, &zones_set7,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG Z590 GAMING EDGE WIFI
-    { 0x7D08, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG Z590 TOMAHAWK
-    { 0x7D09, 6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // Z590-A PRO WIFI
-    { 0x7D13, 6,  0,  0, 1, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG B550 UNIFY
-    { 0x7D14, 6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // A520M PRO
-    { 0x7D15, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B560 TOMAHAWK WIFI
-    { 0x7D17, 6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B560M MORTAR
-    { 0x7D18, 6,  0,  0, 2, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B560M PRO-VDH
-    { 0x7D19, 6,  0,  0, 2, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG B560I GAMIING EDGE WIFI
-    { 0x7D20, 6,  0,  0, 2, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B560M PRO
-    { 0x7D25, 6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO Z690-A WIFI DDR4
-    { 0x7D27, 6,  0,  0, 2, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG Z690 ACE
-    { 0x7D28, 6,  0,  0, 1, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG Z690 UNIFY-X
-    { 0x7D29, 6,  0,  0, 0, &zones_set6,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG Z690I UNIFY
-    { 0x7D30, 6,  6,  0, 2, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG Z690 CARBON WIFI
-    { 0x7D31, 4,  8,  0, 2, &zones_set12, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG EDGE WIFI DDR4
-    { 0x7D32, 1,  0,  0, 1, &zones_set10, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG Z690 TOMAHAWK WIFI DDR4
-    { 0x7D33, 6,  0,  0, 2, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO Z790-VC WIFI
-    { 0x7D36, 6,  0,  0, 2, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO Z690-P DDR4
-    { 0x7D37, 6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO B760M-VC WIFI (MS-7D37) - fans on JRAINBOW2
-    { 0x7D38, 0,  0,  0, 1, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG Z590 UNIFY-X
-    { 0x7D40, 0,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG B760i EDGE WIFI DDR4
-    { 0x7D41, 6,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B660M TOMAHAWK WIFI DDR4
-    { 0x7D42, 6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B660 MORTAR WIFI DDR4
-    { 0x7D43, 0,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO B660M-A WIFI DDR4
-    { 0x7D46, 0,  1,  1, 0, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO H610M-G DDR4
-    { 0x7D50, 6, 12,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG X570S ACE MAX
-    { 0x7D51, 6,  0,  0, 2, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG X570S UNIFY-X MAX
-    { 0x7D52, 6, 14,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG X570S CARBON EK X
-    { 0x7D53, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG X570S EDGE MAX WIFI
-    { 0x7D54, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG X570S TOMAHAWK MAX WIFI
-    { 0x7D59, 0,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO B660-A DDR4
-    { 0x7D67, 0,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO X670-P WIFI
-    { 0x7D69, 9,  2,  4, 1, &zones_set15, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG X670E ACE
-    { 0x7D70, 0,  6,  0, 1, &zones_set9,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG X670E Carbon WIFI
-    { 0x7D73, 1,  0,  0, 0, &zones_set6,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG B650I EDGE WIFI
-    { 0x7D74, 0,  6,  0, 1, &zones_set18, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG B650 CARBON WIFI
-    { 0x7D75, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B650 TOMAHAWK WIFI
-    { 0x7D76, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B650M MORTAR WIFI
-    { 0x7D77, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO B650M-A WIFI
-    { 0x7D78, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO B650-P WIFI
-    { 0x7D86, 0, 18,  4, 1, &zones_set16, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG Z790 ACE
-    { 0x7D88, 0,  0,  0, 1, &zones_set20, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG Z790-S WIFI
-    { 0x7D89, 0,  6,  0, 1, &zones_set18, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG Z790 CARBON WIFI
-    { 0x7D90, 0,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // B760M BOMBER DDR4
-    { 0x7D91, 1,  0,  0, 1, &zones_set10, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG Z790 TOMAHAWK WIFI
-    { 0x7D93, 6,  0,  0, 1, &zones_set2,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // Z790 GAMING PRO WIFI
-    { 0x7D96, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B760 TOMAHAWK WIFI DDR5
-    { 0x7D97, 6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B660 MORTAR MAX WIFI DDR4
-    { 0x7D98, 0,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO B760-P WIFI DDR4
-    { 0x7D99, 6,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO B760M-A WIFI DDR4
-    { 0x7E01, 0,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B760M MORTAR MAX
-    { 0x7E03, 6,  0,  0, 0, &zones_set6,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG Z790I EDGE WIFI
-    { 0x7E06, 0,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO Z790-P WIFI DDR4
-    { 0x7E07, 0,  0,  0, 2, &zones_set10, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO Z790-A WIFI DDR4
-    { 0x7E09, 0,  0,  0, 0, &zones_set19, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // B650M PROJECT ZERO
-    { 0x7E10, 0,  6,  0, 2, &zones_set17, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG B650 EDGE WIFI
-    { 0x7E12, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG X670E TOMAHAWK WIFI
-    { 0x0076, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG X670E TOMAHAWK WIFI (Common PID)
-    { 0x7E16, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // X670E GAMING PLUS WIFI
-    { 0x7E24, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // B650M GAMING PLUS WIFI
-    { 0x7E26, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // B650 GAMING PLUS WIFI
-    { 0x7E27, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO B650M-P
-    { 0x7E28, 6,  0,  0, 2, &zones_set21, MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED },    // MSI PRO A620M-B (MS-7E28)
+    { 0x7B93, 6,  1,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED,  0 },    // MPG X570 GAMING PRO CARBON WIFI
+    { 0x7C34, 0,  1,  1, 1, &zones_set8,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED,  0 },    // MEG X570 GODLIKE
+    { 0x7C35, 0,  1,  0, 1, &zones_set9,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED,  0 },    // MEG X570 ACE
+    { 0x7C36, 6,  1,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED,  0 },    // PRESTIGE X570 CREATION
+    { 0x7C37, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED,  0 },    // MPG X570 GAMING PLUS
+    { 0x7C56, 6,  0,  0, 1, &zones_set2,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     7 },    // MPG B550 GAMING PLUS
+    { 0x7C59, 0,  8,  0, 1, &zones_set9,  MSIMotherboard185Controller::DIRECT_MODE_DISABLED,    0 },    // CREATOR TRX40
+    { 0x7C60, 6,  0,  0, 1, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // TRX40-A PRO
+    { 0x7C67, 6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B365M MORTAR
+    { 0x7C71, 6,  6,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG Z490 ACE
+    { 0x7C73, 6,  4,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG Z490 GAMING CARBON WIFI
+    { 0x7C75, 6,  0,  0, 1, &zones_set2,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG Z490 GAMING PLUS
+    { 0x7C76, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_DISABLED,    0 },    // MPG Z490M GAMING EDGE
+    { 0x7C77, 0,  0,  0, 0, &zones_set14, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG Z490I UNIFY
+    { 0x7C79, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG Z490 GAMING EDGE WIFI
+    { 0x7C80, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG Z490 TOMAHAWK
+    { 0x7C02, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B450 TOMAHAWK MAX
+    { 0x7C81, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B460 TOMAHAWK
+    { 0x7C82, 6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B460M MORTAR WIFI
+    { 0x7C83, 6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_DISABLED,    0 },    // B460M PRO-VDH WIFI
+    { 0x7C84, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED,  0 },    // MAG X570 TOMAHAWK WIFI
+    { 0x7C86, 6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_DISABLED,    0 },    // MPG B460I GAMING EDGE
+    { 0x7C87, 6,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // B450M BAZOOKA MAX WIFI
+    { 0x7C90, 6,  4,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG B550 GAMING CARBON WIFI
+    { 0x7C91, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B550 TOMAHAWK
+    { 0x7C92, 6,  0,  0, 0, &zones_set6,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG B550I GAMING EDGE WIFI
+    { 0x7C94, 6,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B550M MORTAR
+    { 0x7C95, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // B550M PRO-VDH WIFI
+    { 0x7C98, 6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // Z490 PLUS
+    { 0x7D03, 0, 15, 18, 1, &zones_set8,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG Z590 GODLIKE
+    { 0x7D06, 4,  4,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG Z590 GAMING FORCE
+    { 0x7D07, 4,  5,  0, 2, &zones_set7,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG Z590 GAMING EDGE WIFI
+    { 0x7D08, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG Z590 TOMAHAWK
+    { 0x7D09, 6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // Z590-A PRO WIFI
+    { 0x7D13, 6,  0,  0, 1, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG B550 UNIFY
+    { 0x7D14, 6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // A520M PRO
+    { 0x7D15, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B560 TOMAHAWK WIFI
+    { 0x7D17, 6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B560M MORTAR
+    { 0x7D18, 6,  0,  0, 2, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B560M PRO-VDH
+    { 0x7D19, 6,  0,  0, 2, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG B560I GAMIING EDGE WIFI
+    { 0x7D20, 6,  0,  0, 2, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B560M PRO
+    { 0x7D25, 6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO Z690-A WIFI DDR4
+    { 0x7D27, 6,  0,  0, 2, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG Z690 ACE
+    { 0x7D28, 6,  0,  0, 1, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG Z690 UNIFY-X
+    { 0x7D29, 6,  0,  0, 0, &zones_set6,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG Z690I UNIFY
+    { 0x7D30, 6,  6,  0, 2, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG Z690 CARBON WIFI
+    { 0x7D31, 4,  8,  0, 2, &zones_set12, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG EDGE WIFI DDR4
+    { 0x7D32, 1,  0,  0, 1, &zones_set10, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG Z690 TOMAHAWK WIFI DDR4
+    { 0x7D33, 6,  0,  0, 2, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO Z790-VC WIFI
+    { 0x7D36, 6,  0,  0, 2, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO Z690-P DDR4
+    { 0x7D37, 6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO B760M-VC WIFI (MS-7D37) - fans on JRAINBOW2
+    { 0x7D38, 0,  0,  0, 1, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG Z590 UNIFY-X
+    { 0x7D40, 0,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG B760i EDGE WIFI DDR4
+    { 0x7D41, 6,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B660M TOMAHAWK WIFI DDR4
+    { 0x7D42, 6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B660 MORTAR WIFI DDR4
+    { 0x7D43, 0,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO B660M-A WIFI DDR4
+    { 0x7D46, 0,  1,  1, 0, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO H610M-G DDR4
+    { 0x7D50, 6, 12,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG X570S ACE MAX
+    { 0x7D51, 6,  0,  0, 2, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG X570S UNIFY-X MAX
+    { 0x7D52, 6, 14,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG X570S CARBON EK X
+    { 0x7D53, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG X570S EDGE MAX WIFI
+    { 0x7D54, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG X570S TOMAHAWK MAX WIFI
+    { 0x7D59, 0,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO B660-A DDR4
+    { 0x7D67, 0,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO X670-P WIFI
+    { 0x7D69, 9,  2,  4, 1, &zones_set15, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG X670E ACE
+    { 0x7D70, 0,  6,  0, 1, &zones_set9,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG X670E Carbon WIFI
+    { 0x7D73, 1,  0,  0, 0, &zones_set6,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG B650I EDGE WIFI
+    { 0x7D74, 0,  6,  0, 1, &zones_set18, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG B650 CARBON WIFI
+    { 0x7D75, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B650 TOMAHAWK WIFI
+    { 0x7D76, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B650M MORTAR WIFI
+    { 0x7D77, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO B650M-A WIFI
+    { 0x7D78, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO B650-P WIFI
+    { 0x7D86, 0, 18,  4, 1, &zones_set16, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG Z790 ACE
+    { 0x7D88, 0,  0,  0, 1, &zones_set20, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG Z790-S WIFI
+    { 0x7D89, 0,  6,  0, 1, &zones_set18, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG Z790 CARBON WIFI
+    { 0x7D90, 0,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // B760M BOMBER DDR4
+    { 0x7D91, 1,  0,  0, 1, &zones_set10, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG Z790 TOMAHAWK WIFI
+    { 0x7D93, 6,  0,  0, 1, &zones_set2,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // Z790 GAMING PRO WIFI
+    { 0x7D96, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B760 TOMAHAWK WIFI DDR5
+    { 0x7D97, 6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B660 MORTAR MAX WIFI DDR4
+    { 0x7D98, 0,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO B760-P WIFI DDR4
+    { 0x7D99, 6,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO B760M-A WIFI DDR4
+    { 0x7E01, 0,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B760M MORTAR MAX
+    { 0x7E03, 6,  0,  0, 0, &zones_set6,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG Z790I EDGE WIFI
+    { 0x7E06, 0,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO Z790-P WIFI DDR4
+    { 0x7E07, 0,  0,  0, 2, &zones_set10, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO Z790-A WIFI DDR4
+    { 0x7E09, 0,  0,  0, 0, &zones_set19, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // B650M PROJECT ZERO
+    { 0x7E10, 0,  6,  0, 2, &zones_set17, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG B650 EDGE WIFI
+    { 0x7E12, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG X670E TOMAHAWK WIFI
+    { 0x0076, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG X670E TOMAHAWK WIFI (Common PID)
+    { 0x7E16, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // X670E GAMING PLUS WIFI
+    { 0x7E24, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // B650M GAMING PLUS WIFI
+    { 0x7E26, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // B650 GAMING PLUS WIFI
+    { 0x7E27, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO B650M-P
+    { 0x7E28, 6,  0,  0, 2, &zones_set21, MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED,  0 },    // MSI PRO A620M-B (MS-7E28)
 };
 
-
 FeaturePacket_185 enable_per_led_msg;
 
 Color* per_led_onboard_leds;
@@ -367,22 +367,29 @@ Color* per_led_jcorsair_sync;
 
 MSIMotherboard185Controller::MSIMotherboard185Controller(hid_device* handle, const char* path, unsigned short pid, std::string dev_name)
 {
-    dev         = handle;
-    location    = path;
-    name        = dev_name;
+    dev             = handle;
+    location        = path;
+    name            = dev_name;
+    version_invalid = false;
 
-    if(dev)
-    {
-        ReadFwVersion();
-        ReadSettings();
-    }
+    /*-----------------------------------------------------*\
+    | Read the controller's firmware version                |
+    \*-----------------------------------------------------*/
+    ReadFwVersion();
 
+    /*-----------------------------------------------------*\
+    | Common PID boards embed their virtual PID in the      |
+    | serial number, extract it                             |
+    \*-----------------------------------------------------*/
     if(pid == MSI_USB_PID_COMMON)
     {
         std::string pidStr(GetSerial().substr(0, 4));
         pid = std::stoi(pidStr, nullptr, 16);
     }
 
+    /*-----------------------------------------------------*\
+    | Determine if this board has mixed-mode support        |
+    \*-----------------------------------------------------*/
     mixed_mode_support = false;
 
     if(pid >= 0x7D03)
@@ -391,14 +398,23 @@ MSIMotherboard185Controller::MSIMotherboard185Controller(hid_device* handle, con
     }
 
     /*-----------------------------------------------------*\
-    | Initialize save flag and some static settings         |
+    | The last byte of the packet is the save flag.  This   |
+    | byte is stored as a zero in the data flash, but is    |
+    | set to 1 at the protocol level to tell the firmware   |
+    | to save the active configuration to flash.            |
+    | Also set onboard zone to act as sync master for all   |
+    | of the onboard LEDs.                                  |
     \*-----------------------------------------------------*/
-    data.save_data = 0;
-    data.on_board_led.colorFlags = 0x80 | SYNC_SETTING_ONBOARD; // always enable onboard sync flag to have expected zone control
+    data.save_data                  = 0;
+    data.on_board_led.colorFlags    = MSI_COLOR_FLAG_USE_CUSTOM_COLOR | MSI_COLOR_FLAG_SYNC_SETTING_ONBOARD;
 
+    /*-----------------------------------------------------*\
+    | Search for the board configuration matching this      |
+    | board.                                                |
+    \*-----------------------------------------------------*/
     const mystic_light_185_config* board_config = nullptr;
 
-    for(std::size_t i = 0; i < NUMOF_CONFIGS; ++i)
+    for(std::size_t i = 0; i < NUMOF_CONFIGS; i++)
     {
         if(board_configs[i].pid == pid)
         {
@@ -407,6 +423,20 @@ MSIMotherboard185Controller::MSIMotherboard185Controller(hid_device* handle, con
         }
     }
 
+    /*-----------------------------------------------------*\
+    | If the firmware version is below the minimum, set     |
+    | invalid version flag and return                       |
+    \*-----------------------------------------------------*/
+    if(version_APROM_val < board_config->minimum_firmware_version)
+    {
+        version_invalid = true;
+        return;
+    }
+
+    /*-----------------------------------------------------*\
+    | Fill in the number of each zone type based on the     |
+    | board configuration                                   |
+    \*-----------------------------------------------------*/
     if(board_config != nullptr)
     {
         numof_onboard_leds = board_config->numof_onboard_leds;
@@ -426,6 +456,11 @@ MSIMotherboard185Controller::MSIMotherboard185Controller(hid_device* handle, con
         per_led_mode       = DIRECT_MODE_DISABLED;
     }
 
+    /*-----------------------------------------------------*\
+    | Read the controller's active configuration data       |
+    \*-----------------------------------------------------*/
+    ReadSettings();
+
     /*-----------------------------------------------------*\
     | Initialize per-LED data                               |
     \*-----------------------------------------------------*/
@@ -500,7 +535,7 @@ MSIMotherboard185Controller::MSIMotherboard185Controller(hid_device* handle, con
     enable_per_led_msg.j_corsair_outerll120.speedAndBrightnessFlags = 0x28;
     enable_per_led_msg.j_corsair_outerll120.colorFlags              = 0x80;
     enable_per_led_msg.on_board_led.effect                          = MSI_DIRECT_MODE;
-    enable_per_led_msg.on_board_led.speedAndBrightnessFlags         = 0x29 | SYNC_SETTING_JRGB;
+    enable_per_led_msg.on_board_led.speedAndBrightnessFlags         = 0x29 | MSI_SPEED_BRIGHTNESS_FLAG_SYNC_SETTING_JRGB;
     enable_per_led_msg.on_board_led.colorFlags                      = PER_LED_FULL_SYNC_MODE;
     enable_per_led_msg.on_board_led_1.speedAndBrightnessFlags       = 0x28;
     enable_per_led_msg.on_board_led_1.colorFlags                    = 0x80;
@@ -526,38 +561,38 @@ MSIMotherboard185Controller::MSIMotherboard185Controller(hid_device* handle, con
     /*-----------------------------------------------------*\
     | Initialize zone based per LED data                    |
     \*-----------------------------------------------------*/
-    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_pipe_1.speedAndBrightnessFlags        = MSI_BRIGHTNESS_LEVEL_100 << 2;
-    zone_based_per_led_data.j_pipe_1.colorFlags                     = BITSET(zone_based_per_led_data.j_pipe_1.colorFlags, true, 7u);
-    zone_based_per_led_data.j_pipe_2.speedAndBrightnessFlags        = MSI_BRIGHTNESS_LEVEL_100 << 2;
-    zone_based_per_led_data.j_pipe_2.colorFlags                     = BITSET(zone_based_per_led_data.j_pipe_2.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.j_rainbow_2.speedAndBrightnessFlags     = MSI_BRIGHTNESS_LEVEL_100 << 2;
-    zone_based_per_led_data.j_rainbow_2.colorFlags                  = BITSET(zone_based_per_led_data.j_rainbow_2.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.on_board_led_7.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100;
-    zone_based_per_led_data.on_board_led_7.colorFlags               = BITSET(zone_based_per_led_data.on_board_led_7.colorFlags, true, 7u);
-    zone_based_per_led_data.on_board_led_8.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << 2;
-    zone_based_per_led_data.on_board_led_8.colorFlags               = BITSET(zone_based_per_led_data.on_board_led_8.colorFlags, true, 7u);
-    zone_based_per_led_data.on_board_led_9.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << 2;
-    zone_based_per_led_data.on_board_led_9.colorFlags               = BITSET(zone_based_per_led_data.on_board_led_9.colorFlags, true, 7u);
-    zone_based_per_led_data.j_rgb_2.speedAndBrightnessFlags         = MSI_BRIGHTNESS_LEVEL_100 << 2;
-    zone_based_per_led_data.j_rgb_2.colorFlags                      = BITSET(zone_based_per_led_data.j_rgb_2.colorFlags, true, 7u);
+    zone_based_per_led_data.j_rgb_1.speedAndBrightnessFlags         = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+    zone_based_per_led_data.j_rgb_1.colorFlags                     |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+    zone_based_per_led_data.j_pipe_1.speedAndBrightnessFlags        = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+    zone_based_per_led_data.j_pipe_1.colorFlags                    |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+    zone_based_per_led_data.j_pipe_2.speedAndBrightnessFlags        = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+    zone_based_per_led_data.j_pipe_2.colorFlags                    |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+    zone_based_per_led_data.j_rainbow_1.speedAndBrightnessFlags     = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+    zone_based_per_led_data.j_rainbow_1.colorFlags                 |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+    zone_based_per_led_data.j_rainbow_2.speedAndBrightnessFlags     = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+    zone_based_per_led_data.j_rainbow_2.colorFlags                 |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+    zone_based_per_led_data.on_board_led.speedAndBrightnessFlags    = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+    zone_based_per_led_data.on_board_led.colorFlags                |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+    zone_based_per_led_data.on_board_led_1.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+    zone_based_per_led_data.on_board_led_1.colorFlags              |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+    zone_based_per_led_data.on_board_led_2.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+    zone_based_per_led_data.on_board_led_2.colorFlags              |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+    zone_based_per_led_data.on_board_led_3.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+    zone_based_per_led_data.on_board_led_3.colorFlags              |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+    zone_based_per_led_data.on_board_led_4.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+    zone_based_per_led_data.on_board_led_4.colorFlags              |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+    zone_based_per_led_data.on_board_led_5.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+    zone_based_per_led_data.on_board_led_5.colorFlags              |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+    zone_based_per_led_data.on_board_led_6.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+    zone_based_per_led_data.on_board_led_6.colorFlags              |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+    zone_based_per_led_data.on_board_led_7.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+    zone_based_per_led_data.on_board_led_7.colorFlags              |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+    zone_based_per_led_data.on_board_led_8.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+    zone_based_per_led_data.on_board_led_8.colorFlags              |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+    zone_based_per_led_data.on_board_led_9.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+    zone_based_per_led_data.on_board_led_9.colorFlags              |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+    zone_based_per_led_data.j_rgb_2.speedAndBrightnessFlags         = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+    zone_based_per_led_data.j_rgb_2.colorFlags                     |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
     zone_based_per_led_data.save_data                               = 0;
 
     direct_mode             = false;
@@ -570,6 +605,11 @@ MSIMotherboard185Controller::~MSIMotherboard185Controller()
     hid_close(dev);
 }
 
+bool MSIMotherboard185Controller::GetFirmwareVersionInvalid()
+{
+    return(version_invalid);
+}
+
 void MSIMotherboard185Controller::SetMode
     (
     MSI_ZONE        zone,
@@ -584,40 +624,74 @@ void MSIMotherboard185Controller::SetMode
         return;
     }
 
+    /*-----------------------------------------------------*\
+    | Get the zone data pointer within the configuration    |
+    | data buffer                                           |
+    \*-----------------------------------------------------*/
     ZoneData* zone_data = GetZoneData(data, zone);
 
+    /*-----------------------------------------------------*\
+    | Return if zone is invalid                             |
+    \*-----------------------------------------------------*/
     if(zone_data == nullptr)
     {
         return;
     }
 
+    /*-----------------------------------------------------*\
+    | Update the zone's mode and mode parameters            |
+    \*-----------------------------------------------------*/
     zone_data->effect                    = mode;
-    zone_data->speedAndBrightnessFlags   = (brightness << 2) | (speed & 0x03);
-    zone_data->colorFlags                = BITSET(zone_data->colorFlags, !rainbow_color, 7u);
+    zone_data->speedAndBrightnessFlags   = ((brightness << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT) & MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_MASK)
+                                         | ((speed << MSI_SPEED_BRIGHTNESS_FLAG_SPEED_SHIFT)           & MSI_SPEED_BRIGHTNESS_FLAG_SPEED_MASK);
+    zone_data->colorFlags                = (rainbow_color ? (zone_data->colorFlags & ~MSI_COLOR_FLAG_USE_CUSTOM_COLOR)
+                                                          : (zone_data->colorFlags | MSI_COLOR_FLAG_USE_CUSTOM_COLOR));
+
+    /*-----------------------------------------------------*\
+    | J_RAINBOW_3 zone needs padding of 4                   |
+    \*-----------------------------------------------------*/
     zone == MSI_ZONE_J_RAINBOW_3 ? zone_data->padding = 4 : zone_data->padding = 0;
 
+    /*-----------------------------------------------------*\
+    | Get the zone data pointer to the on-board LED 0 zone  |
+    \*-----------------------------------------------------*/
     ZoneData* on_board_zone = GetZoneData(data, MSI_ZONE_ON_BOARD_LED_0);
 
+    /*-----------------------------------------------------*\
+    | If the zone is JRGB or JPIPE and the board has no     |
+    | onboard LEDs, set the onboard zone to this zone's     |
+    | settings                                              |
+    \*-----------------------------------------------------*/
     if(no_onboards && ((zone == MSI_ZONE_J_RGB_1) || (zone == MSI_ZONE_J_RGB_2) || (zone == MSI_ZONE_J_PIPE_1) || (zone == MSI_ZONE_J_PIPE_2)))
     {
-        on_board_zone->effect                  =  zone_data->effect;
-        on_board_zone->speedAndBrightnessFlags =  zone_data->speedAndBrightnessFlags;
-        on_board_zone->colorFlags              =  zone_data->colorFlags;
-        on_board_zone->colorFlags              |= SYNC_SETTING_ONBOARD;
-        on_board_zone->padding                 =  0x00;
+        on_board_zone->effect                   =  zone_data->effect;
+        zone_data->speedAndBrightnessFlags      = ((brightness << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT) & MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_MASK)
+                                                | ((speed << MSI_SPEED_BRIGHTNESS_FLAG_SPEED_SHIFT)           & MSI_SPEED_BRIGHTNESS_FLAG_SPEED_MASK);
+        zone_data->colorFlags                   = (rainbow_color ? (zone_data->colorFlags & ~MSI_COLOR_FLAG_USE_CUSTOM_COLOR)
+                                                                 : (zone_data->colorFlags | MSI_COLOR_FLAG_USE_CUSTOM_COLOR));
+        on_board_zone->colorFlags              |= MSI_COLOR_FLAG_SYNC_SETTING_ONBOARD;
+        on_board_zone->padding                  = 0x00;
     }
 
+    /*-----------------------------------------------------*\
+    | For modes above MSI_MODE_LIGHTNING, set the onboard   |
+    | zone to sync with JRGB, JPIPE1, and JPIPE2            |
+    \*-----------------------------------------------------*/
     if(mode > MSI_MODE_LIGHTNING)
     {
-        on_board_zone->speedAndBrightnessFlags |= SYNC_SETTING_JRGB;
-        on_board_zone->colorFlags              |= (SYNC_SETTING_JPIPE1 | SYNC_SETTING_JPIPE2);
+        on_board_zone->speedAndBrightnessFlags |= MSI_SPEED_BRIGHTNESS_FLAG_SYNC_SETTING_JRGB;
+        on_board_zone->colorFlags              |= (MSI_COLOR_FLAG_SYNC_SETTING_JPIPE1 | MSI_COLOR_FLAG_SYNC_SETTING_JPIPE2);
     }
     else
     {
-        on_board_zone->speedAndBrightnessFlags &= ~SYNC_SETTING_JRGB;
-        on_board_zone->colorFlags              &= ~(SYNC_SETTING_JPIPE1 | SYNC_SETTING_JPIPE2);
+        on_board_zone->speedAndBrightnessFlags &= ~MSI_SPEED_BRIGHTNESS_FLAG_SYNC_SETTING_JRGB;
+        on_board_zone->colorFlags              &= ~(MSI_COLOR_FLAG_SYNC_SETTING_JPIPE1 | MSI_COLOR_FLAG_SYNC_SETTING_JPIPE2);
     }
 
+    /*-----------------------------------------------------*\
+    | For modes at or below MSI_MODE_LIGHTNING, set all     |
+    | onboard LED zones to match onboard LED zone 0         |
+    \*-----------------------------------------------------*/
     if((zone == MSI_ZONE_ON_BOARD_LED_0) && (mode <= MSI_MODE_LIGHTNING))
     {
         for(int i = 0; i < numof_onboard_leds; ++i)
@@ -627,8 +701,10 @@ void MSIMotherboard185Controller::SetMode
             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->speedAndBrightnessFlags   = ((brightness << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT) & MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_MASK)
+                                                     | ((speed << MSI_SPEED_BRIGHTNESS_FLAG_SPEED_SHIFT)           & MSI_SPEED_BRIGHTNESS_FLAG_SPEED_MASK);
+                zone_data->colorFlags                = (rainbow_color ? (zone_data->colorFlags & ~MSI_COLOR_FLAG_USE_CUSTOM_COLOR)
+                                                                      : (zone_data->colorFlags | MSI_COLOR_FLAG_USE_CUSTOM_COLOR));
                 zone_data->padding                   = 0x00;
             }
         }
@@ -789,13 +865,23 @@ void MSIMotherboard185Controller::SetZoneColor
         return;
     }
 
+    /*-----------------------------------------------------*\
+    | Get the zone data pointer within the configuration    |
+    | data buffer                                           |
+    \*-----------------------------------------------------*/
     ZoneData* zone_data = GetZoneData(data, zone);
 
+    /*-----------------------------------------------------*\
+    | Return if zone is invalid                             |
+    \*-----------------------------------------------------*/
     if(zone_data == nullptr)
     {
         return;
     }
 
+    /*-----------------------------------------------------*\
+    | Set the colors in the zone data                       |
+    \*-----------------------------------------------------*/
     zone_data->color.R  = red1;
     zone_data->color.G  = grn1;
     zone_data->color.B  = blu1;
@@ -803,6 +889,11 @@ void MSIMotherboard185Controller::SetZoneColor
     zone_data->color2.G = grn2;
     zone_data->color2.B = blu2;
 
+    /*-----------------------------------------------------*\
+    | If the zone is JRGB or JPIPE and the board has no     |
+    | onboard LEDs, set the onboard zone's colors to this   |
+    | zone's colors                                         |
+    \*-----------------------------------------------------*/
     if(no_onboards && ((zone == MSI_ZONE_J_RGB_1) || (zone == MSI_ZONE_J_RGB_2) || (zone == MSI_ZONE_J_PIPE_1) || (zone == MSI_ZONE_J_PIPE_2)))
     {
         ZoneData* on_board_zone = GetZoneData(data, MSI_ZONE_ON_BOARD_LED_0);
@@ -815,6 +906,10 @@ void MSIMotherboard185Controller::SetZoneColor
         on_board_zone->color2.B = blu2;
     }
 
+    /*-----------------------------------------------------*\
+    | Set all onboard LED zones' colors to match onboard    |
+    | LED 0                                                 |
+    \*-----------------------------------------------------*/
     if(zone == MSI_ZONE_ON_BOARD_LED_0)
     {
         for(int i = 0; i < numof_onboard_leds; ++i)
@@ -843,6 +938,10 @@ void MSIMotherboard185Controller::SetLedColor
     unsigned char   blu
     )
 {
+    /*-----------------------------------------------------*\
+    | If this board supports Per-LED direct mode, update    |
+    | the per-LED packet buffers                            |
+    \*-----------------------------------------------------*/
     if(per_led_mode == DIRECT_MODE_PER_LED)
     {
         Color* zone_data = GetPerLedZoneData(zone);
@@ -878,6 +977,9 @@ void MSIMotherboard185Controller::SetLedColor
             }
         }
     }
+    /*-----------------------------------------------------*\
+    | Otherwise, colors are set per zone.                   |
+    \*-----------------------------------------------------*/
     else
     {
         if(((zone == MSI_ZONE_J_RAINBOW_1) || (zone == MSI_ZONE_J_RAINBOW_2) || (zone == MSI_ZONE_J_PIPE_1) || (zone == MSI_ZONE_J_PIPE_2)) && (index != 0))
@@ -1079,6 +1181,8 @@ bool MSIMotherboard185Controller::ReadFwVersion()
     ret_val &= hid_write(dev, request, 64);
     ret_val &= hid_read(dev, response, 64);
 
+    version_APROM_val = response[2];
+
     /*-----------------------------------------------------*\
     | Extract high and low values from response             |
     \*-----------------------------------------------------*/
@@ -1165,10 +1269,10 @@ void MSIMotherboard185Controller::GetMode
     /*-----------------------------------------------------*\
     | 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;
+    mode            = (MSI_MODE)        zone_data->effect;
+    speed           = (MSI_SPEED)     ((zone_data->speedAndBrightnessFlags >> MSI_SPEED_BRIGHTNESS_FLAG_SPEED_SHIFT)      & MSI_SPEED_BRIGHTNESS_FLAG_SPEED_MASK);
+    brightness      = (MSI_BRIGHTNESS)((zone_data->speedAndBrightnessFlags >> MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT) & MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_MASK);
+    rainbow_color   = ((zone_data->colorFlags & MSI_COLOR_FLAG_USE_CUSTOM_COLOR) == 0 ? false : true);
     color           = ToRGBColor(zone_data->color.R, zone_data->color.G, zone_data->color.B);
 }
 

Controllers/MSIMotherboardController/MSIMotherboard185Controller/MSIMotherboard185Controller.h

@@ -46,6 +46,7 @@ public:
                         );
 
     MSI_MODE        GetMode();
+    bool            GetFirmwareVersionInvalid();
 
     void            GetMode
                         (
@@ -119,6 +120,8 @@ private:
     std::string                     name;
     std::string                     location;
     std::string                     version_APROM;
+    unsigned char                   version_APROM_val;
+    bool                            version_invalid;
     std::string                     version_LDROM;
 
     FeaturePacket_185               data;

Controllers/MSIMotherboardController/MSIMotherboard761Controller/MSIMotherboard761Controller.cpp

@@ -72,6 +72,7 @@ static const std::string board_names[] =
     "MSI MAG B850 TOMAHAWK WIFI (MS-7E53)",
     "MSI MEG Z890 UNIFY-X (MS-7E20)",
     "MSI PRO X870E-S EVO WIFI (MS-7E86)",
+    "MSI MAG X870E GAMING MAX WIFI (MS-7E86)",
     "MSI PRO Z890-P WIFI (MS-7E34)",
     "MSI B850 GAMING PLUS WIFI PZ (MS-7E75)",
     "MSI MAG X870E TOMAHAWK MAX WIFI PZ (MS-7E84)",
@@ -105,10 +106,11 @@ static const mystic_light_761_config board_configs[] =
     { &(board_names[22]), 0,  0,  0, 1, &zone_set1,  MSIMotherboard761Controller::DIRECT_MODE_ZONE_BASED },     // MSI MAG B850 TOMAHAWK WIFI (MS-7E53)
     { &(board_names[23]), 0,  0,  0, 1, &zone_set1,  MSIMotherboard761Controller::DIRECT_MODE_ZONE_BASED },     // MSI MEG Z890 UNIFY-X (MS-7E20)
     { &(board_names[24]), 0,  0,  0, 1, &zone_set1,  MSIMotherboard761Controller::DIRECT_MODE_ZONE_BASED },     // MSI PRO X870E-S EVO WIFI (MS-7E86)
-    { &(board_names[25]), 0,  0,  0, 1, &zone_set1,  MSIMotherboard761Controller::DIRECT_MODE_ZONE_BASED },     // MSI PRO Z890-P WIFI (MS-7E34)
-    { &(board_names[26]), 0,  0,  0, 1, &zone_set1,  MSIMotherboard761Controller::DIRECT_MODE_ZONE_BASED },     // MSI B850 GAMING PLUS WIFI PZ (MS-7E75)
-    { &(board_names[27]), 0,  0,  0, 1, &zone_set1,  MSIMotherboard761Controller::DIRECT_MODE_ZONE_BASED },     // MSI MAG X870E TOMAHAWK MAX WIFI PZ (MS-7E84)
-    { &(board_names[28]), 0,  0,  0, 1, &zone_set1,  MSIMotherboard761Controller::DIRECT_MODE_ZONE_BASED },     // MSI PRO B850M-A WIFI PZ (MS-7E78)
+    { &(board_names[25]), 0,  0,  0, 1, &zone_set1,  MSIMotherboard761Controller::DIRECT_MODE_ZONE_BASED },     // MSI MAG X870E GAMING MAX WIFI (MS-7E86)
+    { &(board_names[26]), 0,  0,  0, 1, &zone_set1,  MSIMotherboard761Controller::DIRECT_MODE_ZONE_BASED },     // MSI PRO Z890-P WIFI (MS-7E34)
+    { &(board_names[27]), 0,  0,  0, 1, &zone_set1,  MSIMotherboard761Controller::DIRECT_MODE_ZONE_BASED },     // MSI B850 GAMING PLUS WIFI PZ (MS-7E75)
+    { &(board_names[28]), 0,  0,  0, 1, &zone_set1,  MSIMotherboard761Controller::DIRECT_MODE_ZONE_BASED },     // MSI MAG X870E TOMAHAWK MAX WIFI PZ (MS-7E84)
+    { &(board_names[29]), 0,  0,  0, 1, &zone_set1,  MSIMotherboard761Controller::DIRECT_MODE_ZONE_BASED },     // MSI PRO B850M-A WIFI PZ (MS-7E78)
 };
 
 enum MSI_ZONE setup_map [] =

Controllers/MSIMotherboardController/MSIMotherboardCommon.h

@@ -122,13 +122,22 @@ enum MSI_BRIGHTNESS
 #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
+/*---------------------------------------------------------*\
+| Flag bitfield bit definitions                             |
+| Note that the sync flags split across the two fields      |
+\*---------------------------------------------------------*/
+#define MSI_SPEED_BRIGHTNESS_FLAG_SPEED_SHIFT       0
+#define MSI_SPEED_BRIGHTNESS_FLAG_SPEED_MASK        (0x03 << MSI_SPEED_BRIGHTNESS_FLAG_SPEED_SHIFT)
+#define MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT  2
+#define MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_MASK   (0x1F << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT)
+#define MSI_SPEED_BRIGHTNESS_FLAG_SYNC_SETTING_JRGB (1 << 7)
+#define MSI_COLOR_FLAG_SYNC_SETTING_ONBOARD         (1 << 0)
+#define MSI_COLOR_FLAG_SYNC_SETTING_JRAINBOW1       (1 << 1)
+#define MSI_COLOR_FLAG_SYNC_SETTING_JRAINBOW2       (1 << 2)
+#define MSI_COLOR_FLAG_SYNC_SETTING_JCORSAIR        (1 << 3)
+#define MSI_COLOR_FLAG_SYNC_SETTING_JPIPE1          (1 << 4)
+#define MSI_COLOR_FLAG_SYNC_SETTING_JPIPE2          (1 << 5)
+#define MSI_COLOR_FLAG_USE_CUSTOM_COLOR             (1 << 7)
 
 struct Color
 {

Controllers/MSIMotherboardController/MSIMotherboardControllerDetect.cpp

@@ -54,9 +54,17 @@ DetectedControllers DetectMSIMotherboardControllers(hid_device_info* info, const
         if((packet_length >= sizeof(FeaturePacket_185)) && (packet_length <= (sizeof(FeaturePacket_185) + 1)))  //WHY r we doing this ? why not ==
         {
             MSIMotherboard185Controller*     controller     = new MSIMotherboard185Controller(dev, info->path, info->product_id, dmi_name);
-            RGBController_MSIMotherboard185* rgb_controller = new RGBController_MSIMotherboard185(controller);
 
-            detected_controllers.push_back(rgb_controller);
+            if(controller->GetFirmwareVersionInvalid())
+            {
+                LOG_WARNING("[MSIMotherboard185] Controller firmware below minimum supported version, skipping");
+            }
+            else
+            {
+                RGBController_MSIMotherboard185* rgb_controller = new RGBController_MSIMotherboard185(controller);
+
+                detected_controllers.push_back(rgb_controller);
+            }
         }
         else if((packet_length >= sizeof(FeaturePacket_162)) && (packet_length <= (sizeof(FeaturePacket_162) + 1)))
         {
@@ -223,6 +231,7 @@ REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E70",    DetectMSIMotherboardCont
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E59",    DetectMSIMotherboardControllers,   MSI_USB_VID,    0x7E59,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E80",    DetectMSIMotherboardControllers,   MSI_USB_VID,    0x7E80,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E81",    DetectMSIMotherboardControllers,   MSI_USB_VID,    0x7E81,   0x0001, 0x00);
+REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E86",    DetectMSIMotherboardControllers,   MSI_USB_VID,    0x7E86,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E34",    DetectMSIMotherboardControllers,   MSI_USB_VID,    0x7E34,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E32",    DetectMSIMotherboardControllers,   MSI_USB_VID,    0x7E32,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E20",    DetectMSIMotherboardControllers,   MSI_USB_VID,    0x7E20,   0x0001, 0x00);

Controllers/NVIDIAIlluminationController/NVIDIAIlluminationControllerDetect_Windows_Linux.cpp

@@ -56,6 +56,7 @@ static const nv_gpu_pci_device device_list[] =
     {NVIDIA_VEN,    NVIDIA_RTX3060_8G_DEV,          NVIDIA_SUB_VEN,   NVIDIA_RTX3060_8G_DEV,                          NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "Gainward GeForce RTX 3060 Pegasus"           },
     {NVIDIA_VEN,    NVIDIA_RTX3060_LHR_DEV,         NVIDIA_SUB_VEN,   NVIDIA_RTX3060_LHR_DEV,                         NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "Palit GeForce RTX 3060 LHR"                  },
     {NVIDIA_VEN,    NVIDIA_RTX3060_LHR_DEV,         PNY_SUB_VEN,      PNY_RTX_3060_XLR8_REVEL_EPIC_X_SUB_DEV,         NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "PNY GeForce RTX 3060 XLR8 REVEL EPIC-X"      },
+    {NVIDIA_VEN,    NVIDIA_RTX3060_LHR_DEV,         PNY_SUB_VEN,      PNY_RTX_3060_XLR8_REVEL_EPIC_X_LHR_SUB_DEV,     NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "PNY GeForce RTX 3060 XLR8 REVEL EPIC-X LHR"  },
     {NVIDIA_VEN,    NVIDIA_RTX3060_GA104_DEV,       PNY_SUB_VEN,      PNY_RTX_3060_XLR8_REVEL_EPIC_X_SUB_DEV,         NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "PNY GeForce RTX 3060 XLR8 REVEL EPIC-X"      },
     {NVIDIA_VEN,    NVIDIA_RTX3060_GA104_DEV,       NVIDIA_SUB_VEN,   NVIDIA_RTX3060_GA104_DEV,                       NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "Palit GeForce RTX 3060 LHR"                  },
     {NVIDIA_VEN,    NVIDIA_RTX3060TI_LHR_DEV,       PNY_SUB_VEN,      PNY_RTX_3060TI_XLR8_REVEL_EPIC_X_SUB_DEV,       NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "PNY GeForce RTX 3060 Ti XLR8 REVEL EPIC-X"   },

Controllers/RazerController/RazerControllerDetect.cpp

@@ -260,6 +260,7 @@ REGISTER_HID_DETECTOR_IPU("Razer Huntsman V2 TKL",                           Det
 REGISTER_HID_DETECTOR_IPU("Razer Huntsman V2",                               DetectRazerControllers,        RAZER_VID,  RAZER_HUNTSMAN_V2_PID,                          0x03,   0x0C,   0x01);
 REGISTER_HID_DETECTOR_IPU("Razer Huntsman V3 Pro",                           DetectRazerControllers,        RAZER_VID,  RAZER_HUNTSMAN_V3_PRO_PID,                      0x03,   0x0C,   0x01);
 REGISTER_HID_DETECTOR_IPU("Razer Huntsman V3 Pro TKL White",                 DetectRazerControllers,        RAZER_VID,  RAZER_HUNTSMAN_V3_PRO_TKL_WHITE_PID,            0x03,   0x0C,   0x01);
+REGISTER_HID_DETECTOR_IPU("Razer Huntsman V3 HE Magnetic Mini",              DetectRazerControllers,        RAZER_VID,  RAZER_HUNTSMAN_V3_HE_MAGNETIC_MINI_PID,         0x03,   0x0C,   0x01);
 REGISTER_HID_DETECTOR_IPU("Razer Ornata Chroma",                             DetectRazerControllers,        RAZER_VID,  RAZER_ORNATA_CHROMA_PID,                        0x02,   0x01,   0x02);
 REGISTER_HID_DETECTOR_IPU("Razer Ornata Chroma V2",                          DetectRazerControllers,        RAZER_VID,  RAZER_ORNATA_CHROMA_V2_PID,                     0x02,   0x01,   0x02);
 REGISTER_HID_DETECTOR_IPU("Razer Ornata V3",                                 DetectRazerControllers,        RAZER_VID,  RAZER_ORNATA_V3_PID,                            0x02,   0x01,   0x02);

Controllers/RazerController/RazerDevices.cpp

@@ -3141,6 +3141,45 @@ static const razer_device huntsman_v3_pro_tkl_device =
     &razer_huntsman_v3_pro_tkl_layout
 };
 
+/*-------------------------------------------------------------*\
+|  Razer Huntsman V3 HE Magnetic Mini 1532:02E4                 |
+|                                                               |
+|  Zone "Keyboard"                                              |
+|       Matrix                                                  |
+|       6 Rows, 22 Columns (matrix dims borrowed from Huntsman  |
+|       V3 Pro pending confirmation on real hardware -- extra   |
+|       columns beyond the physical 65% board are simply inert. |
+|       No layout overlay yet: key names fall back to raw       |
+|       matrix positions until the mapping is verified.)        |
+\*-------------------------------------------------------------*/
+static const razer_zone huntsman_v3_he_magnetic_mini_keyboard_zone =
+{
+    ZONE_EN_KEYBOARD,
+    ZONE_TYPE_MATRIX,
+    6,
+    22
+};
+
+static const razer_device huntsman_v3_he_magnetic_mini_device =
+{
+    "Razer Huntsman V3 HE Magnetic Mini",
+    RAZER_HUNTSMAN_V3_HE_MAGNETIC_MINI_PID,
+    DEVICE_TYPE_KEYBOARD,
+    RAZER_MATRIX_TYPE_EXTENDED,
+    0x3F,
+    6,
+    22,
+    {
+        &huntsman_v3_he_magnetic_mini_keyboard_zone,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL
+    },
+    NULL
+};
+
 /*-------------------------------------------------------------------------*\
 |  LAPTOPS                                                                  |
 \*-------------------------------------------------------------------------*/
@@ -9446,6 +9485,7 @@ const razer_device* razer_device_list[] =
     &huntsman_v2_tkl_device,
     &huntsman_v3_pro_device,
     &huntsman_v3_pro_tkl_device,
+    &huntsman_v3_he_magnetic_mini_device,
     &ornata_chroma_device,
     &ornata_chroma_v2_device,
     &ornata_v3_device,

Controllers/RazerController/RazerDevices.h

@@ -124,6 +124,7 @@
 #define RAZER_HUNTSMAN_V2_PID                           0x026C
 #define RAZER_HUNTSMAN_V3_PRO_PID                       0x02A6
 #define RAZER_HUNTSMAN_V3_PRO_TKL_WHITE_PID             0x02A7
+#define RAZER_HUNTSMAN_V3_HE_MAGNETIC_MINI_PID          0x02E4
 #define RAZER_ORBWEAVER_CHROMA_PID                      0x0207
 #define RAZER_ORNATA_CHROMA_PID                         0x021E
 #define RAZER_ORNATA_CHROMA_V2_PID                      0x025D

Controllers/TurtleBeachKP7Controller/RGBController_TurtleBeachKP7.cpp

@@ -11,29 +11,66 @@
 
 #include <string>
 #include "RGBController_TurtleBeachKP7.h"
+#include "RGBControllerKeyNames.h"
 
-/*---------------------------------------------------------*\
-| Physical LED grid, mapped against the real device.  Six   |
-| columns by ten rows, [y][x] holds the LED index and NA    |
-| marks a grid cell with no LED behind it.                  |
-\*---------------------------------------------------------*/
 #define NA                                          0xFFFFFFFF
 
-#define TURTLE_BEACH_KP7_MATRIX_HEIGHT              10
-#define TURTLE_BEACH_KP7_MATRIX_WIDTH               6
+/*---------------------------------------------------------*\
+| The 33 LEDs are exposed as three zones: the Num Lock and  |
+| Shift Mode indicators along the top, the main keypad, and |
+| the two wrist rest LEDs, mirroring the split used for the |
+| KB7.                                                      |
+\*---------------------------------------------------------*/
+#define TURTLE_BEACH_KP7_INDICATOR_COUNT            3
+#define TURTLE_BEACH_KP7_KEYPAD_COUNT               28
+#define TURTLE_BEACH_KP7_WRIST_COUNT                2
+
+/*---------------------------------------------------------*\
+| The device numbers its LEDs 0-32 in an order that does    |
+| not follow the zone layout, so this table maps each LED   |
+| in zone/presentation order to its slot in the device's    |
+| color buffer.  Order: the three indicator LEDs, then the  |
+| keypad (the F13-F15 / profile row, then the number grid   |
+| row by row with that row's mode key last, then 0 / . /    |
+| Enter, then the space bar), then the two wrist rest LEDs. |
+\*---------------------------------------------------------*/
+static const unsigned int turtle_beach_kp7_led_order[TURTLE_BEACH_KP7_LED_COUNT] =
+{
+    28, 29, 30,
+    21,  0,  7, 14,
+     8, 22, 15,  1, 11,
+    23,  2,  9,  4, 18,
+    10, 24, 16, 25,  5,
+    17,  3, 13, 12, 19,
+    27,  6, 20,
+    26,
+    31, 32,
+};
+
+/*---------------------------------------------------------*\
+| Physical grid for the keypad zone.  [y][x] holds the LED  |
+| index within that zone (0-27, an index into the keypad    |
+| slice of the LED list, not the device LED number) and NA  |
+| marks a cell with no LED behind it.  Row 0 is the F13-F15 |
+| and profile switch row; the mode keys form the rightmost  |
+| column.  The two + keys and the two Enter keys are each   |
+| a stacked pair in one column, all normal size; the space  |
+| bar sits directly under the lower Enter so the device     |
+| view does not auto-grow that Enter downward.  The 0 key   |
+| is double width, filling the empty cell to its right.     |
+\*---------------------------------------------------------*/
+#define TURTLE_BEACH_KP7_MATRIX_HEIGHT              7
+#define TURTLE_BEACH_KP7_MATRIX_WIDTH               5
 
 static unsigned int turtle_beach_kp7_matrix_map[TURTLE_BEACH_KP7_MATRIX_HEIGHT][TURTLE_BEACH_KP7_MATRIX_WIDTH] =
 {
-    {  28,  NA,  29,  NA,  NA,  30 },
-    {  NA,  NA,  NA,  NA,  NA,  NA },
-    {  21,   0,   7,  14,  NA,  NA },
-    {  NA,  NA,  NA,  NA,  NA,  NA },
-    {   8,  22,  15,   1,  NA,  11 },
-    {  23,   2,   9,   4,  NA,  18 },
-    {  10,  24,  16,  25,  NA,   5 },
-    {  17,   3,  13,  12,  NA,  19 },
-    {  27,  NA,   6,  20,  NA,  NA },
-    {  31,  32,  NA,  26,  NA,  NA },
+    {   0,   1,   2,   3,  NA },
+    {   4,   5,   6,   7,   8 },
+    {   9,  10,  11,  12,  13 },
+    {  14,  15,  16,  17,  18 },
+    {  19,  20,  21,  22,  23 },
+    {  24,  NA,  25,  26,  NA },
+    {  NA,  NA,  NA,  27,  NA },
 };
 
 /**------------------------------------------------------------------*\
@@ -47,7 +84,9 @@ static unsigned int turtle_beach_kp7_matrix_map[TURTLE_BEACH_KP7_MATRIX_HEIGHT][
     @comment Only the raw per-LED color stream is implemented.  The
              onboard effects, the macro and profile feature report
              channel on report ID 0x11, and the internal hub the KB7
-             dock exposes as PID 0x503E are not handled.
+             dock exposes as PID 0x503E are not handled.  LEDs are
+             split into Indicators, Keypad, and Wrist Rest zones; the
+             keypad zone carries a matrix map.
 \*-------------------------------------------------------------------*/
 
 RGBController_TurtleBeachKP7::RGBController_TurtleBeachKP7(TurtleBeachKP7Controller* controller_ptr)
@@ -80,28 +119,100 @@ RGBController_TurtleBeachKP7::~RGBController_TurtleBeachKP7()
 
 void RGBController_TurtleBeachKP7::SetupZones()
 {
-    zone kp7_zone;
+    /*-----------------------------------------------------*\
+    | LED names in zone/presentation order.  Local arrays   |
+    | rather than file scope ones because the KEY_EN_       |
+    | values live in another translation unit and are not   |
+    | safe to read during static initialization.  The two   |
+    | indicator LEDs and the shift mode key are status      |
+    | lights rather than typing keys, so they get plain     |
+    | names.                                                |
+    \*-----------------------------------------------------*/
+    const char* indicator_names[TURTLE_BEACH_KP7_INDICATOR_COUNT] =
+    {
+        "Num Lock Indicator", "Shift Mode Indicator", "Key: Shift Mode",
+    };
 
-    kp7_zone.name               = "Keypad";
-    kp7_zone.type               = ZONE_TYPE_MATRIX;
-    kp7_zone.leds_min           = TURTLE_BEACH_KP7_LED_COUNT;
-    kp7_zone.leds_max           = TURTLE_BEACH_KP7_LED_COUNT;
-    kp7_zone.leds_count         = TURTLE_BEACH_KP7_LED_COUNT;
+    const char* keypad_names[TURTLE_BEACH_KP7_KEYPAD_COUNT] =
+    {
+        KEY_EN_F13,         KEY_EN_F14,          KEY_EN_F15,          "Key: Profile Switch",
 
-    kp7_zone.matrix_map.Set(TURTLE_BEACH_KP7_MATRIX_HEIGHT, TURTLE_BEACH_KP7_MATRIX_WIDTH, (unsigned int*)&turtle_beach_kp7_matrix_map);
+        KEY_EN_NUMPAD_LOCK, KEY_EN_NUMPAD_DIVIDE, KEY_EN_NUMPAD_TIMES, KEY_EN_NUMPAD_MINUS, "Key: Mode 1",
+        KEY_EN_NUMPAD_7,    KEY_EN_NUMPAD_8,     KEY_EN_NUMPAD_9,     KEY_EN_NUMPAD_PLUS,   "Key: Mode 2",
+        KEY_EN_NUMPAD_4,    KEY_EN_NUMPAD_5,     KEY_EN_NUMPAD_6,     KEY_EN_NUMPAD_PLUS,   "Key: Mode 3",
+        KEY_EN_NUMPAD_1,    KEY_EN_NUMPAD_2,     KEY_EN_NUMPAD_3,     KEY_EN_NUMPAD_ENTER,  "Key: Mode 4",
+        KEY_EN_NUMPAD_0,    KEY_EN_NUMPAD_PERIOD, KEY_EN_NUMPAD_ENTER,
 
-    zones.push_back(kp7_zone);
+        KEY_EN_SPACE,
+    };
 
-    for(unsigned int led_idx = 0; led_idx < TURTLE_BEACH_KP7_LED_COUNT; led_idx++)
+    /*-----------------------------------------------------*\
+    | Three zones: the indicator LEDs, the keypad, and the  |
+    | wrist rest.  Only the keypad carries a matrix map;    |
+    | the other two are short linear strips.                |
+    \*-----------------------------------------------------*/
+    zone indicator_zone;
+
+    indicator_zone.name         = "Indicators";
+    indicator_zone.type         = ZONE_TYPE_LINEAR;
+    indicator_zone.leds_min     = TURTLE_BEACH_KP7_INDICATOR_COUNT;
+    indicator_zone.leds_max     = TURTLE_BEACH_KP7_INDICATOR_COUNT;
+    indicator_zone.leds_count   = TURTLE_BEACH_KP7_INDICATOR_COUNT;
+
+    zones.push_back(indicator_zone);
+
+    zone keypad_zone;
+
+    keypad_zone.name            = "Keypad";
+    keypad_zone.type            = ZONE_TYPE_MATRIX;
+    keypad_zone.leds_min        = TURTLE_BEACH_KP7_KEYPAD_COUNT;
+    keypad_zone.leds_max        = TURTLE_BEACH_KP7_KEYPAD_COUNT;
+    keypad_zone.leds_count      = TURTLE_BEACH_KP7_KEYPAD_COUNT;
+
+    keypad_zone.matrix_map.Set(TURTLE_BEACH_KP7_MATRIX_HEIGHT, TURTLE_BEACH_KP7_MATRIX_WIDTH, (unsigned int*)&turtle_beach_kp7_matrix_map);
+
+    zones.push_back(keypad_zone);
+
+    zone wrist_zone;
+
+    wrist_zone.name             = "Wrist Rest";
+    wrist_zone.type             = ZONE_TYPE_LINEAR;
+    wrist_zone.leds_min         = TURTLE_BEACH_KP7_WRIST_COUNT;
+    wrist_zone.leds_max         = TURTLE_BEACH_KP7_WRIST_COUNT;
+    wrist_zone.leds_count       = TURTLE_BEACH_KP7_WRIST_COUNT;
+
+    zones.push_back(wrist_zone);
+
+    for(unsigned int led_idx = 0; led_idx < TURTLE_BEACH_KP7_INDICATOR_COUNT; led_idx++)
     {
         led new_led;
 
-        new_led.name            = "LED " + std::to_string(led_idx + 1);
+        new_led.name            = indicator_names[led_idx];
         new_led.value           = led_idx;
 
         leds.push_back(new_led);
     }
 
+    for(unsigned int led_idx = 0; led_idx < TURTLE_BEACH_KP7_KEYPAD_COUNT; led_idx++)
+    {
+        led new_led;
+
+        new_led.name            = keypad_names[led_idx];
+        new_led.value           = TURTLE_BEACH_KP7_INDICATOR_COUNT + led_idx;
+
+        leds.push_back(new_led);
+    }
+
+    for(unsigned int led_idx = 0; led_idx < TURTLE_BEACH_KP7_WRIST_COUNT; led_idx++)
+    {
+        led new_led;
+
+        new_led.name            = "Wrist Rest " + std::to_string(led_idx + 1);
+        new_led.value           = TURTLE_BEACH_KP7_INDICATOR_COUNT + TURTLE_BEACH_KP7_KEYPAD_COUNT + led_idx;
+
+        leds.push_back(new_led);
+    }
+
     SetupColors();
 }
 
@@ -109,11 +220,17 @@ void RGBController_TurtleBeachKP7::DeviceUpdateLEDs()
 {
     unsigned char led_data[TURTLE_BEACH_KP7_LED_COUNT * 3] = { 0 };
 
+    /*-----------------------------------------------------*\
+    | colors[] is in zone order; turtle_beach_kp7_led_order |
+    | gives the device color-buffer slot for each one.      |
+    \*-----------------------------------------------------*/
     for(unsigned int led_idx = 0; (led_idx < colors.size()) && (led_idx < TURTLE_BEACH_KP7_LED_COUNT); led_idx++)
     {
-        led_data[(led_idx * 3) + 0] = RGBGetRValue(colors[led_idx]);
-        led_data[(led_idx * 3) + 1] = RGBGetGValue(colors[led_idx]);
-        led_data[(led_idx * 3) + 2] = RGBGetBValue(colors[led_idx]);
+        unsigned int dev_led = turtle_beach_kp7_led_order[led_idx];
+
+        led_data[(dev_led * 3) + 0] = RGBGetRValue(colors[led_idx]);
+        led_data[(dev_led * 3) + 1] = RGBGetGValue(colors[led_idx]);
+        led_data[(dev_led * 3) + 2] = RGBGetBValue(colors[led_idx]);
     }
 
     controller->SendDirect(led_data, sizeof(led_data));

DetectionManager.cpp

@@ -1428,7 +1428,7 @@ void DetectionManager::BackgroundHIDInit()
             .hid_enumerate                      = (hidapi_wrapper_enumerate)                    dlsym(hidapi_libusb_handle,"hid_enumerate"),
             .hid_free_enumeration               = (hidapi_wrapper_free_enumeration)             dlsym(hidapi_libusb_handle,"hid_free_enumeration"),
             .hid_close                          = (hidapi_wrapper_close)                        dlsym(hidapi_libusb_handle,"hid_close"),
-            .hid_error                          = (hidapi_wrapper_error)                        dlsym(hidapi_libusb_handle,"hid_free_enumeration"),
+            .hid_error                          = (hidapi_wrapper_error)                        dlsym(hidapi_libusb_handle,"hid_error"),
 #if(HID_HOTPLUG_ENABLED)
             .hid_hotplug_register_callback      = (hidapi_wrapper_hotplug_register_callback)    dlsym(hidapi_libusb_handle,"hid_hotplug_register_callback"),
             .hid_hotplug_deregister_callback    = (hidapi_wrapper_hotplug_deregister_callback)  dlsym(hidapi_libusb_handle,"hid_hotplug_deregister_callback"),

i2c_smbus/MacOS/i2c_smbus_i801.cpp

@@ -506,9 +506,9 @@ s32 i2c_smbus_i801::i2c_xfer(u8 /*addr*/, char /*read_write*/, int* /*size*/, u8
 
 bool i2c_smbus_i801_detect()
 {
-    if(!GetMacUSPCIODriverStatus())
+    if(!InitMacUSPCIODriver())
     {
-        LOG_INFO("macUSPCIO is not loaded, i801 I2C bus detection aborted");
+        LOG_INFO("macUSPCIO initialization failed, i801 I2C bus detection aborted");
         return(false);
     }
 

i2c_smbus/MacOS/i2c_smbus_nct6775.cpp

@@ -213,9 +213,9 @@ s32 i2c_smbus_nct6775::i2c_xfer(u8 /*addr*/, char /*read_write*/, int* /*size*/,
 
 bool i2c_smbus_nct6775_detect()
 {
-    if(!GetMacUSPCIODriverStatus())
+    if(!InitMacUSPCIODriver())
     {
-        LOG_INFO("macUSPCIO is not loaded, nct6775 I2C bus detection aborted");
+        LOG_INFO("macUSPCIO initialization failed, nct6775 I2C bus detection aborted");
         return(false);
     }
 

i2c_smbus/MacOS/i2c_smbus_piix4.cpp

@@ -245,9 +245,9 @@ s32 i2c_smbus_piix4::i2c_xfer(u8 /*addr*/, char /*read_write*/, int* /*size*/, u
 
 bool i2c_smbus_piix4_detect()
 {
-    if(!GetMacUSPCIODriverStatus())
+    if(!InitMacUSPCIODriver())
     {
-        LOG_INFO("macUSPCIO is not loaded, piix4 I2C bus detection aborted");
+        LOG_INFO("macUSPCIO initialization failed, piix4 I2C bus detection aborted");
         return(false);
     }
 

pci_ids/pci_ids.h

@@ -886,6 +886,7 @@
 \*-----------------------------------------------------*/
 #define PNY_RTX_2060_XLR8_OC_SUB_DEV                            0x1363
 #define PNY_RTX_3060_XLR8_REVEL_EPIC_X_SUB_DEV                  0x138E
+#define PNY_RTX_3060_XLR8_REVEL_EPIC_X_LHR_SUB_DEV              0x138F
 #define PNY_RTX_3070_XLR8_REVEL_EPIC_X_SUB_DEV                  0x136E
 #define PNY_RTX_3070_XLR8_REVEL_EPIC_X_LHR_SUB_DEV              0x138A
 #define PNY_RTX_3070TI_XLR8_UPRISING_EPIC_X_SUB_DEV             0x138D