RGB Matrix support for Massdrop CTRL/ALT (#5328)

* port Massdrop CTRL/ALT to use RGB Matrix

Co-authored-by: Matt Schneeberger <helluvamatt@gmail.com>

* Massdrop lighting support working

This commit is to get the Massdrop lighting code working again through use of the compilation define USE_MASSDROP_CONFIGURATOR added to a keymap's rules.mk.
Added keymaps for both CTRL and ALT named default_md and mac_md. These should be used if the Massdrop style lighting is desired.

* Updating config based on testing results with patrickmt & compile errors

* Updates for PR5328

For CTRL and ALT:
Moved location of new RGB Matrix macros from config_led.h to config.h.
Added RGB_MATRIX_LED_FLUSH_LIMIT (time between flushes) to config.h for correct LED driver update timing.
Re-added missing breathing code for when Massdrop configurator mode is defined.

* remove prilik keymap form PR

9 files changed, 456 insertions, 352 deletions

diff --git a/tmk_core/common/arm_atsam/suspend.c b/tmk_core/common/arm_atsam/suspend.c
index e34965df64..9c2c47d561 100644
--- a/tmk_core/common/arm_atsam/suspend.c
+++ b/tmk_core/common/arm_atsam/suspend.c
@@ -35,7 +35,9 @@ void suspend_power_down_kb(void) {
  */
 void suspend_power_down(void)
 {
+#ifdef RGB_MATRIX_ENABLE
     I2C3733_Control_Set(0); //Disable LED driver
+#endif
 
     suspend_power_down_kb();
 }
@@ -75,10 +77,9 @@ void suspend_wakeup_init_kb(void) {
  * FIXME: needs doc
  */
 void suspend_wakeup_init(void) {
-    /* If LEDs are set to enabled, enable the hardware */
-    if (led_enabled) {
-        I2C3733_Control_Set(1);
-    }
+#ifdef RGB_MATRIX_ENABLE
+    I2C3733_Control_Set(1);
+#endif
 
     suspend_wakeup_init_kb();
 }
diff --git a/tmk_core/protocol/arm_atsam.mk b/tmk_core/protocol/arm_atsam.mk
index 04e02790a0..8d6f724f09 100644
--- a/tmk_core/protocol/arm_atsam.mk
+++ b/tmk_core/protocol/arm_atsam.mk
@@ -4,7 +4,10 @@ SRC += $(ARM_ATSAM_DIR)/adc.c
 SRC += $(ARM_ATSAM_DIR)/clks.c
 SRC += $(ARM_ATSAM_DIR)/d51_util.c
 SRC += $(ARM_ATSAM_DIR)/i2c_master.c
-SRC += $(ARM_ATSAM_DIR)/led_matrix.c
+ifeq ($(RGB_MATRIX_ENABLE),custom)
+  SRC += $(ARM_ATSAM_DIR)/led_matrix_programs.c
+  SRC += $(ARM_ATSAM_DIR)/led_matrix.c
+endif
 SRC += $(ARM_ATSAM_DIR)/main_arm_atsam.c
 SRC += $(ARM_ATSAM_DIR)/spi.c
 SRC += $(ARM_ATSAM_DIR)/startup.c
diff --git a/tmk_core/protocol/arm_atsam/arm_atsam_protocol.h b/tmk_core/protocol/arm_atsam/arm_atsam_protocol.h
index 928af8c7e1..88109186aa 100644
--- a/tmk_core/protocol/arm_atsam/arm_atsam_protocol.h
+++ b/tmk_core/protocol/arm_atsam/arm_atsam_protocol.h
@@ -34,7 +34,10 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #ifndef MD_BOOTLOADER
 
 #include "main_arm_atsam.h"
+#ifdef RGB_MATRIX_ENABLE
 #include "led_matrix.h"
+#include "rgb_matrix.h"
+#endif
 #include "issi3733_driver.h"
 #include "./usb/compiler.h"
 #include "./usb/udc.h"
diff --git a/tmk_core/protocol/arm_atsam/i2c_master.c b/tmk_core/protocol/arm_atsam/i2c_master.c
index d91a851f37..1741d9ac5b 100644
--- a/tmk_core/protocol/arm_atsam/i2c_master.c
+++ b/tmk_core/protocol/arm_atsam/i2c_master.c
@@ -17,7 +17,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #include "arm_atsam_protocol.h"
 
-#ifndef MD_BOOTLOADER
+#if !defined(MD_BOOTLOADER) && defined(RGB_MATRIX_ENABLE)
 
 #include <string.h>
 
@@ -37,7 +37,7 @@ static uint8_t dma_sendbuf[I2C_DMA_MAX_SEND]; //Data being written to I2C
 
 volatile uint8_t i2c_led_q_running;
 
-#endif //MD_BOOTLOADER
+#endif // !defined(MD_BOOTLOADER) && defined(RGB_MATRIX_ENABLE)
 
 void i2c0_init(void)
 {
@@ -112,7 +112,7 @@ void i2c0_stop(void)
     }
 }
 
-#ifndef MD_BOOTLOADER
+#if !defined(MD_BOOTLOADER) && defined(RGB_MATRIX_ENABLE)
 void i2c1_init(void)
 {
     DBGC(DC_I2C1_INIT_BEGIN);
@@ -583,4 +583,4 @@ uint8_t i2c_led_q_run(void)
 
     return 1;
 }
-#endif //MD_BOOTLOADER
+#endif // !defined(MD_BOOTLOADER) && defined(RGB_MATRIX_ENABLE)
diff --git a/tmk_core/protocol/arm_atsam/led_matrix.c b/tmk_core/protocol/arm_atsam/led_matrix.c
index 04d05af6db..e29fb6587c 100644
--- a/tmk_core/protocol/arm_atsam/led_matrix.c
+++ b/tmk_core/protocol/arm_atsam/led_matrix.c
@@ -17,9 +17,19 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #include "arm_atsam_protocol.h"
 #include "tmk_core/common/led.h"
+#include "rgb_matrix.h"
 #include <string.h>
 #include <math.h>
 
+#ifdef USE_MASSDROP_CONFIGURATOR
+__attribute__((weak))
+led_instruction_t led_instructions[] = { { .end = 1 } };
+static void led_matrix_massdrop_config_override(int i);
+#endif // USE_MASSDROP_CONFIGURATOR
+
+extern rgb_config_t rgb_matrix_config;
+extern rgb_counters_t g_rgb_counters;
+
 void SERCOM1_0_Handler( void )
 {
     if (SERCOM1->I2CM.INTFLAG.bit.ERROR)
@@ -51,14 +61,17 @@ void DMAC_0_Handler( void )
 
 issi3733_driver_t issidrv[ISSI3733_DRIVER_COUNT];
 
-issi3733_led_t led_map[ISSI3733_LED_COUNT+1] = ISSI3733_LED_MAP;
-issi3733_led_t *lede = led_map + ISSI3733_LED_COUNT; //End pointer of mapping
+issi3733_led_t led_map[ISSI3733_LED_COUNT] = ISSI3733_LED_MAP;
+RGB led_buffer[ISSI3733_LED_COUNT];
 
 uint8_t gcr_desired;
-uint8_t gcr_breathe;
-uint8_t gcr_use;
 uint8_t gcr_actual;
 uint8_t gcr_actual_last;
+#ifdef USE_MASSDROP_CONFIGURATOR
+uint8_t gcr_breathe;
+float breathe_mult;
+float pomod;
+#endif
 
 #define ACT_GCR_NONE    0
 #define ACT_GCR_INC     1
@@ -73,11 +86,14 @@ static uint8_t v_5v_cat_hit;
 void gcr_compute(void)
 {
     uint8_t action = ACT_GCR_NONE;
+    uint8_t gcr_use = gcr_desired;
 
+#ifdef USE_MASSDROP_CONFIGURATOR
     if (led_animation_breathing)
+    {
         gcr_use = gcr_breathe;
-    else
-        gcr_use = gcr_desired;
+    }
+#endif
 
     //If the 5v takes a catastrophic hit, disable the LED drivers briefly, assert auto gcr mode, min gcr and let the auto take over
     if (v_5v < V5_CAT)
@@ -151,6 +167,7 @@ void gcr_compute(void)
             gcr_actual -= LED_GCR_STEP_AUTO;
             gcr_min_counter = 0;
 
+#ifdef USE_MASSDROP_CONFIGURATOR
             //If breathe mode is active, the top end can fluctuate if the host can not supply enough current
             //So set the breathe GCR to where it becomes stable
             if (led_animation_breathing == 1)
@@ -160,12 +177,11 @@ void gcr_compute(void)
                 //    and the same would happen maybe one or two more times. Therefore I'm favoring
                 //    powering through one full breathe and letting gcr settle completely
             }
+#endif
         }
     }
 }
 
-led_disp_t disp;
-
 void issi3733_prepare_arrays(void)
 {
     memset(issidrv,0,sizeof(issi3733_driver_t) * ISSI3733_DRIVER_COUNT);
@@ -178,361 +194,309 @@ void issi3733_prepare_arrays(void)
         issidrv[i].addr = addrs[i];
     }
 
-    issi3733_led_t *cur = led_map;
-
-    while (cur < lede)
+    for (uint8_t i = 0; i < ISSI3733_LED_COUNT; i++)
     {
         //BYTE: 1 + (SW-1)*16 + (CS-1)
-        cur->rgb.g = issidrv[cur->adr.drv-1].pwm + 1 + ((cur->adr.swg-1)*16 + (cur->adr.cs-1));
-        cur->rgb.r = issidrv[cur->adr.drv-1].pwm + 1 + ((cur->adr.swr-1)*16 + (cur->adr.cs-1));
-        cur->rgb.b = issidrv[cur->adr.drv-1].pwm + 1 + ((cur->adr.swb-1)*16 + (cur->adr.cs-1));
+        led_map[i].rgb.g = issidrv[led_map[i].adr.drv-1].pwm + 1 + ((led_map[i].adr.swg-1)*16 + (led_map[i].adr.cs-1));
+        led_map[i].rgb.r = issidrv[led_map[i].adr.drv-1].pwm + 1 + ((led_map[i].adr.swr-1)*16 + (led_map[i].adr.cs-1));
+        led_map[i].rgb.b = issidrv[led_map[i].adr.drv-1].pwm + 1 + ((led_map[i].adr.swb-1)*16 + (led_map[i].adr.cs-1));
 
         //BYTE: 1 + (SW-1)*2 + (CS-1)/8
         //BIT: (CS-1)%8
-        *(issidrv[cur->adr.drv-1].onoff + 1 + (cur->adr.swg-1)*2+(cur->adr.cs-1)/8) |= (1<<((cur->adr.cs-1)%8));
-        *(issidrv[cur->adr.drv-1].onoff + 1 + (cur->adr.swr-1)*2+(cur->adr.cs-1)/8) |= (1<<((cur->adr.cs-1)%8));
-        *(issidrv[cur->adr.drv-1].onoff + 1 + (cur->adr.swb-1)*2+(cur->adr.cs-1)/8) |= (1<<((cur->adr.cs-1)%8));
-
-        cur++;
+        *(issidrv[led_map[i].adr.drv-1].onoff + 1 + (led_map[i].adr.swg-1)*2+(led_map[i].adr.cs-1)/8) |= (1<<((led_map[i].adr.cs-1)%8));
+        *(issidrv[led_map[i].adr.drv-1].onoff + 1 + (led_map[i].adr.swr-1)*2+(led_map[i].adr.cs-1)/8) |= (1<<((led_map[i].adr.cs-1)%8));
+        *(issidrv[led_map[i].adr.drv-1].onoff + 1 + (led_map[i].adr.swb-1)*2+(led_map[i].adr.cs-1)/8) |= (1<<((led_map[i].adr.cs-1)%8));
     }
 }
 
-void disp_calc_extents(void)
+void led_matrix_prepare(void)
 {
-    issi3733_led_t *cur = led_map;
-
-    disp.left = 1e10;
-    disp.right = -1e10;
-    disp.top = -1e10;
-    disp.bottom = 1e10;
-
-    while (cur < lede)
+    for (uint8_t i = 0; i < ISSI3733_LED_COUNT; i++)
     {
-        if (cur->x < disp.left) disp.left = cur->x;
-        if (cur->x > disp.right) disp.right = cur->x;
-        if (cur->y < disp.bottom) disp.bottom = cur->y;
-        if (cur->y > disp.top) disp.top = cur->y;
-
-        cur++;
+        *led_map[i].rgb.r = 0;
+        *led_map[i].rgb.g = 0;
+        *led_map[i].rgb.b = 0;
     }
-
-    disp.width = disp.right - disp.left;
-    disp.height = disp.top - disp.bottom;
-    disp.max_distance = sqrtf(powf(disp.width, 2) + powf(disp.height, 2));
 }
 
-void disp_pixel_setup(void)
+void led_set_one(int i, uint8_t r, uint8_t g, uint8_t b)
 {
-    issi3733_led_t *cur = led_map;
-
-    while (cur < lede)
+    if (i < ISSI3733_LED_COUNT)
     {
-        cur->px = (cur->x - disp.left) / disp.width * 100;
-        cur->py = (cur->y - disp.bottom) / disp.height * 100;
-        *cur->rgb.r = 0;
-        *cur->rgb.g = 0;
-        *cur->rgb.b = 0;
-
-        cur++;
+#ifdef USE_MASSDROP_CONFIGURATOR
+        led_matrix_massdrop_config_override(i);
+#else
+        led_buffer[i].r = r;
+        led_buffer[i].g = g;
+        led_buffer[i].b = b;
+#endif
     }
 }
 
-void led_matrix_prepare(void)
+void led_set_all(uint8_t r, uint8_t g, uint8_t b)
 {
-    disp_calc_extents();
-    disp_pixel_setup();
+  for (uint8_t i = 0; i < ISSI3733_LED_COUNT; i++)
+  {
+    led_set_one(i, r, g, b);
+  }
 }
 
-uint8_t led_enabled;
-float led_animation_speed;
-uint8_t led_animation_direction;
-uint8_t led_animation_orientation;
-uint8_t led_animation_breathing;
-uint8_t led_animation_breathe_cur;
-uint8_t breathe_step;
-uint8_t breathe_dir;
-uint8_t led_animation_circular;
-uint64_t led_next_run;
-
-uint8_t led_animation_id;
-uint8_t led_lighting_mode;
-
-issi3733_led_t *led_cur;
-uint8_t led_per_run = 15;
-float breathe_mult;
-
-__attribute__ ((weak))
-void led_matrix_run(void)
+void init(void)
 {
-    float ro;
-    float go;
-    float bo;
-    float po;
-
-    uint8_t led_this_run = 0;
-    led_setup_t *f = (led_setup_t*)led_setups[led_animation_id];
-
-    if (led_cur == 0) //Denotes start of new processing cycle in the case of chunked processing
-    {
-        led_cur = led_map;
+    DBGC(DC_LED_MATRIX_INIT_BEGIN);
 
-        disp.frame += 1;
+    issi3733_prepare_arrays();
 
-        breathe_mult = 1;
+    led_matrix_prepare();
 
-        if (led_animation_breathing)
-        {
-            led_animation_breathe_cur += breathe_step * breathe_dir;
+    gcr_min_counter = 0;
+    v_5v_cat_hit = 0;
 
-            if (led_animation_breathe_cur >= BREATHE_MAX_STEP)
-                breathe_dir = -1;
-            else if (led_animation_breathe_cur <= BREATHE_MIN_STEP)
-                breathe_dir = 1;
+    DBGC(DC_LED_MATRIX_INIT_COMPLETE);
+}
 
-            //Brightness curve created for 256 steps, 0 - ~98%
-            breathe_mult = 0.000015 * led_animation_breathe_cur * led_animation_breathe_cur;
-            if (breathe_mult > 1) breathe_mult = 1;
-            else if (breathe_mult < 0) breathe_mult = 0;
-        }
-    }
+void flush(void)
+{
+#ifdef USE_MASSDROP_CONFIGURATOR
+    if (!led_enabled) { return; } //Prevent calculations and I2C traffic if LED drivers are not enabled
+#else
+    if (!sr_exp_data.bit.SDB_N) { return; } //Prevent calculations and I2C traffic if LED drivers are not enabled
+#endif
 
-    uint8_t fcur = 0;
-    uint8_t fmax = 0;
+    // Wait for previous transfer to complete
+    while (i2c_led_q_running) {}
 
-    //Frames setup
-    while (f[fcur].end != 1)
+    // Copy buffer to live DMA region
+    for (uint8_t i = 0; i < ISSI3733_LED_COUNT; i++)
     {
-        fcur++; //Count frames
+        *led_map[i].rgb.r = led_buffer[i].r;
+        *led_map[i].rgb.g = led_buffer[i].g;
+        *led_map[i].rgb.b = led_buffer[i].b;
     }
 
-    fmax = fcur; //Store total frames count
+#ifdef USE_MASSDROP_CONFIGURATOR
+    breathe_mult = 1;
 
-    while (led_cur < lede && led_this_run < led_per_run)
+    if (led_animation_breathing)
     {
-        ro = 0;
-        go = 0;
-        bo = 0;
-
-        if (led_lighting_mode == LED_MODE_KEYS_ONLY && led_cur->scan == 255)
-        {
-            //Do not act on this LED
-        }
-        else if (led_lighting_mode == LED_MODE_NON_KEYS_ONLY && led_cur->scan != 255)
-        {
-            //Do not act on this LED
-        }
-        else if (led_lighting_mode == LED_MODE_INDICATORS_ONLY)
-        {
-            //Do not act on this LED (Only show indicators)
-        }
-        else
-        {
-            //Act on LED
-            for (fcur = 0; fcur < fmax; fcur++)
-            {
-
-                if (led_animation_circular) {
-                    po = sqrtf((powf(fabsf((disp.width / 2) - (led_cur->x - disp.left)), 2) + powf(fabsf((disp.height / 2) - (led_cur->y - disp.bottom)), 2))) / disp.max_distance * 100;
-                }
-                else {
-                    if (led_animation_orientation)
-                    {
-                        po = led_cur->py;
-                    }
-                    else
-                    {
-                        po = led_cur->px;
-                    }
-                }
-
-                float pomod;
-                pomod = (float)(disp.frame % (uint32_t)(1000.0f / led_animation_speed)) / 10.0f * led_animation_speed;
-
-                //Add in any moving effects
-                if ((!led_animation_direction && f[fcur].ef & EF_SCR_R) || (led_animation_direction && (f[fcur].ef & EF_SCR_L)))
-                {
-                    pomod *= 100.0f;
-                    pomod = (uint32_t)pomod % 10000;
-                    pomod /= 100.0f;
-
-                    po -= pomod;
-
-                    if (po > 100) po -= 100;
-                    else if (po < 0) po += 100;
-                }
-                else if ((!led_animation_direction && f[fcur].ef & EF_SCR_L) || (led_animation_direction && (f[fcur].ef & EF_SCR_R)))
-                {
-                    pomod *= 100.0f;
-                    pomod = (uint32_t)pomod % 10000;
-                    pomod /= 100.0f;
-                    po += pomod;
-
-                    if (po > 100) po -= 100;
-                    else if (po < 0) po += 100;
-                }
+        //+60us 119 LED
+        led_animation_breathe_cur += BREATHE_STEP * breathe_dir;
+
+        if (led_animation_breathe_cur >= BREATHE_MAX_STEP)
+            breathe_dir = -1;
+        else if (led_animation_breathe_cur <= BREATHE_MIN_STEP)
+            breathe_dir = 1;
+
+        //Brightness curve created for 256 steps, 0 - ~98%
+        breathe_mult = 0.000015 * led_animation_breathe_cur * led_animation_breathe_cur;
+        if (breathe_mult > 1) breathe_mult = 1;
+        else if (breathe_mult < 0) breathe_mult = 0;
+    }
 
-                //Check if LED's po is in current frame
-                if (po < f[fcur].hs) continue;
-                if (po > f[fcur].he) continue;
-                //note: < 0 or > 100 continue
+    //This should only be performed once per frame
+    pomod = (float)((g_rgb_counters.tick / 10) % (uint32_t)(1000.0f / led_animation_speed)) / 10.0f * led_animation_speed;
+    pomod *= 100.0f;
+    pomod = (uint32_t)pomod % 10000;
+    pomod /= 100.0f;
 
-                //Calculate the po within the start-stop percentage for color blending
-                po = (po - f[fcur].hs) / (f[fcur].he - f[fcur].hs);
+#endif // USE_MASSDROP_CONFIGURATOR
 
-                //Add in any color effects
-                if (f[fcur].ef & EF_OVER)
-                {
-                    ro = (po * (f[fcur].re - f[fcur].rs)) + f[fcur].rs;// + 0.5;
-                    go = (po * (f[fcur].ge - f[fcur].gs)) + f[fcur].gs;// + 0.5;
-                    bo = (po * (f[fcur].be - f[fcur].bs)) + f[fcur].bs;// + 0.5;
-                }
-                else if (f[fcur].ef & EF_SUBTRACT)
-                {
-                    ro -= (po * (f[fcur].re - f[fcur].rs)) + f[fcur].rs;// + 0.5;
-                    go -= (po * (f[fcur].ge - f[fcur].gs)) + f[fcur].gs;// + 0.5;
-                    bo -= (po * (f[fcur].be - f[fcur].bs)) + f[fcur].bs;// + 0.5;
-                }
-                else
-                {
-                    ro += (po * (f[fcur].re - f[fcur].rs)) + f[fcur].rs;// + 0.5;
-                    go += (po * (f[fcur].ge - f[fcur].gs)) + f[fcur].gs;// + 0.5;
-                    bo += (po * (f[fcur].be - f[fcur].bs)) + f[fcur].bs;// + 0.5;
-                }
-            }
-        }
+    uint8_t drvid;
 
-        //Clamp values 0-255
-        if (ro > 255) ro = 255; else if (ro < 0) ro = 0;
-        if (go > 255) go = 255; else if (go < 0) go = 0;
-        if (bo > 255) bo = 255; else if (bo < 0) bo = 0;
+    //NOTE: GCR does not need to be timed with LED processing, but there is really no harm
+    if (gcr_actual != gcr_actual_last)
+    {
+        for (drvid=0;drvid<ISSI3733_DRIVER_COUNT;drvid++)
+            I2C_LED_Q_GCR(drvid); //Queue data
+        gcr_actual_last = gcr_actual;
+    }
 
-        if (led_animation_breathing)
-        {
-            ro *= breathe_mult;
-            go *= breathe_mult;
-            bo *= breathe_mult;
-        }
+    for (drvid=0;drvid<ISSI3733_DRIVER_COUNT;drvid++)
+        I2C_LED_Q_PWM(drvid); //Queue data
 
-        *led_cur->rgb.r = (uint8_t)ro;
-        *led_cur->rgb.g = (uint8_t)go;
-        *led_cur->rgb.b = (uint8_t)bo;
+    i2c_led_q_run();
+}
 
-#ifdef USB_LED_INDICATOR_ENABLE
-        if (keyboard_leds())
+void led_matrix_indicators(void)
+{
+    uint8_t kbled = keyboard_leds();
+    if (kbled && rgb_matrix_config.enable)
+    {
+        for (uint8_t i = 0; i < ISSI3733_LED_COUNT; i++)
         {
-            uint8_t kbled = keyboard_leds();
             if (
-                #if USB_LED_NUM_LOCK_SCANCODE != 255
-                (led_cur->scan == USB_LED_NUM_LOCK_SCANCODE && kbled & (1<<USB_LED_NUM_LOCK)) ||
-                #endif //NUM LOCK
-                #if USB_LED_CAPS_LOCK_SCANCODE != 255
-                (led_cur->scan == USB_LED_CAPS_LOCK_SCANCODE && kbled & (1<<USB_LED_CAPS_LOCK)) ||
-                #endif //CAPS LOCK
-                #if USB_LED_SCROLL_LOCK_SCANCODE != 255
-                (led_cur->scan == USB_LED_SCROLL_LOCK_SCANCODE && kbled & (1<<USB_LED_SCROLL_LOCK)) ||
-                #endif //SCROLL LOCK
-                #if USB_LED_COMPOSE_SCANCODE != 255
-                (led_cur->scan == USB_LED_COMPOSE_SCANCODE && kbled & (1<<USB_LED_COMPOSE)) ||
-                #endif //COMPOSE
-                #if USB_LED_KANA_SCANCODE != 255
-                (led_cur->scan == USB_LED_KANA_SCANCODE && kbled & (1<<USB_LED_KANA)) ||
-                #endif //KANA
-                (0))
+            #if USB_LED_NUM_LOCK_SCANCODE != 255
+                (led_map[i].scan == USB_LED_NUM_LOCK_SCANCODE && (kbled & (1<<USB_LED_NUM_LOCK))) ||
+            #endif //NUM LOCK
+            #if USB_LED_CAPS_LOCK_SCANCODE != 255
+                (led_map[i].scan == USB_LED_CAPS_LOCK_SCANCODE && (kbled & (1<<USB_LED_CAPS_LOCK))) ||
+            #endif //CAPS LOCK
+            #if USB_LED_SCROLL_LOCK_SCANCODE != 255
+                (led_map[i].scan == USB_LED_SCROLL_LOCK_SCANCODE && (kbled & (1<<USB_LED_SCROLL_LOCK))) ||
+            #endif //SCROLL LOCK
+            #if USB_LED_COMPOSE_SCANCODE != 255
+                (led_map[i].scan == USB_LED_COMPOSE_SCANCODE && (kbled & (1<<USB_LED_COMPOSE))) ||
+            #endif //COMPOSE
+            #if USB_LED_KANA_SCANCODE != 255
+                (led_map[i].scan == USB_LED_KANA_SCANCODE && (kbled & (1<<USB_LED_KANA))) ||
+            #endif //KANA
+            (0))
             {
-                if (*led_cur->rgb.r > 127) *led_cur->rgb.r = 0;
-                else *led_cur->rgb.r = 255;
-                if (*led_cur->rgb.g > 127) *led_cur->rgb.g = 0;
-                else *led_cur->rgb.g = 255;
-                if (*led_cur->rgb.b > 127) *led_cur->rgb.b = 0;
-                else *led_cur->rgb.b = 255;
+                led_buffer[i].r = 255 - led_buffer[i].r;
+                led_buffer[i].g = 255 - led_buffer[i].g;
+                led_buffer[i].b = 255 - led_buffer[i].b;
             }
         }
-#endif //USB_LED_INDICATOR_ENABLE
-
-        led_cur++;
-        led_this_run++;
     }
-}
 
-uint8_t led_matrix_init(void)
-{
-    DBGC(DC_LED_MATRIX_INIT_BEGIN);
+}
 
-    issi3733_prepare_arrays();
+const rgb_matrix_driver_t rgb_matrix_driver = {
+  .init = init,
+  .flush = flush,
+  .set_color = led_set_one,
+  .set_color_all = led_set_all
+};
+
+/*==============================================================================
+=                           Legacy Lighting Support                            =
+==============================================================================*/
+
+#ifdef USE_MASSDROP_CONFIGURATOR
+// Ported from Massdrop QMK Github Repo
+
+// TODO?: wire these up to keymap.c
+uint8_t led_animation_orientation = 0;
+uint8_t led_animation_direction = 0;
+uint8_t led_animation_breathing = 0;
+uint8_t led_animation_id = 0;
+float led_animation_speed = 4.0f;
+uint8_t led_lighting_mode = LED_MODE_NORMAL;
+uint8_t led_enabled = 1;
+uint8_t led_animation_breathe_cur = BREATHE_MIN_STEP;
+uint8_t breathe_dir = 1;
+
+static void led_run_pattern(led_setup_t *f, float* ro, float* go, float* bo, float pos) {
+    float po;
 
-    led_matrix_prepare();
+    while (f->end != 1)
+    {
+        po = pos; //Reset po for new frame
 
-    disp.frame = 0;
-    led_next_run = 0;
-
-    led_enabled = 1;
-    led_animation_id = 0;
-    led_lighting_mode = LED_MODE_NORMAL;
-    led_animation_speed = 4.0f;
-    led_animation_direction = 0;
-    led_animation_orientation = 0;
-    led_animation_breathing = 0;
-    led_animation_breathe_cur = BREATHE_MIN_STEP;
-    breathe_step = 1;
-    breathe_dir = 1;
-    led_animation_circular = 0;
+        //Add in any moving effects
+        if ((!led_animation_direction && f->ef & EF_SCR_R) || (led_animation_direction && (f->ef & EF_SCR_L)))
+        {
+            po -= pomod;
 
-    gcr_min_counter = 0;
-    v_5v_cat_hit = 0;
+            if (po > 100) po -= 100;
+            else if (po < 0) po += 100;
+        }
+        else if ((!led_animation_direction && f->ef & EF_SCR_L) || (led_animation_direction && (f->ef & EF_SCR_R)))
+        {
+            po += pomod;
 
-    //Run led matrix code once for initial LED coloring
-    led_cur = 0;
-    rgb_matrix_init_user();
-    led_matrix_run();
+            if (po > 100) po -= 100;
+            else if (po < 0) po += 100;
+        }
 
-    DBGC(DC_LED_MATRIX_INIT_COMPLETE);
+        //Check if LED's po is in current frame
+        if (po < f->hs) { f++; continue; }
+        if (po > f->he) { f++; continue; }
+        //note: < 0 or > 100 continue
 
-    return 0;
-}
+        //Calculate the po within the start-stop percentage for color blending
+        po = (po - f->hs) / (f->he - f->hs);
 
-__attribute__ ((weak))
-void rgb_matrix_init_user(void) {
+        //Add in any color effects
+        if (f->ef & EF_OVER)
+        {
+            *ro = (po * (f->re - f->rs)) + f->rs;// + 0.5;
+            *go = (po * (f->ge - f->gs)) + f->gs;// + 0.5;
+            *bo = (po * (f->be - f->bs)) + f->bs;// + 0.5;
+        }
+        else if (f->ef & EF_SUBTRACT)
+        {
+            *ro -= (po * (f->re - f->rs)) + f->rs;// + 0.5;
+            *go -= (po * (f->ge - f->gs)) + f->gs;// + 0.5;
+            *bo -= (po * (f->be - f->bs)) + f->bs;// + 0.5;
+        }
+        else
+        {
+            *ro += (po * (f->re - f->rs)) + f->rs;// + 0.5;
+            *go += (po * (f->ge - f->gs)) + f->gs;// + 0.5;
+            *bo += (po * (f->be - f->bs)) + f->bs;// + 0.5;
+        }
 
+        f++;
+    }
 }
 
-#define LED_UPDATE_RATE 10  //ms
-
-//led data processing can take time, so process data in chunks to free up the processor
-//this is done through led_cur and lede
-void led_matrix_task(void)
+static void led_matrix_massdrop_config_override(int i)
 {
-    if (led_enabled)
-    {
-        //If an update may run and frame processing has completed
-        if (timer_read64() >= led_next_run && led_cur == lede)
-        {
-            uint8_t drvid;
+    float ro = 0;
+    float go = 0;
+    float bo = 0;
+
+    float po = (led_animation_orientation)
+        ? (float)g_rgb_leds[i].point.y / 64.f * 100
+        : (float)g_rgb_leds[i].point.x / 224.f * 100;
+
+    uint8_t highest_active_layer = biton32(layer_state);
+
+    if (led_lighting_mode == LED_MODE_KEYS_ONLY && g_rgb_leds[i].matrix_co.raw == 0xff) {
+        //Do not act on this LED
+    } else if (led_lighting_mode == LED_MODE_NON_KEYS_ONLY && g_rgb_leds[i].matrix_co.raw != 0xff) {
+        //Do not act on this LED
+    } else if (led_lighting_mode == LED_MODE_INDICATORS_ONLY) {
+        //Do not act on this LED (Only show indicators)
+    } else {
+        led_instruction_t* led_cur_instruction = led_instructions;
+        while (!led_cur_instruction->end) {
+            // Check if this applies to current layer
+            if ((led_cur_instruction->flags & LED_FLAG_MATCH_LAYER) &&
+                (led_cur_instruction->layer != highest_active_layer)) {
+                goto next_iter;
+            }
 
-            led_next_run = timer_read64() + LED_UPDATE_RATE;  //Set next frame update time
+            // Check if this applies to current index
+            if (led_cur_instruction->flags & LED_FLAG_MATCH_ID) {
+                uint8_t modid = i / 32;                                     //Calculate which id# contains the led bit
+                uint32_t modidbit = 1 << (i % 32);                          //Calculate the bit within the id#
+                uint32_t *bitfield = &led_cur_instruction->id0 + modid;     //Add modid as offset to id0 address. *bitfield is now idX of the led id
+                if (~(*bitfield) & modidbit) {                              //Check if led bit is not set in idX
+                    goto next_iter;
+                }
+            }
 
-            //NOTE: GCR does not need to be timed with LED processing, but there is really no harm
-            if (gcr_actual != gcr_actual_last)
-            {
-                for (drvid=0;drvid<ISSI3733_DRIVER_COUNT;drvid++)
-                    I2C_LED_Q_GCR(drvid); //Queue data
-                gcr_actual_last = gcr_actual;
+            if (led_cur_instruction->flags & LED_FLAG_USE_RGB) {
+                ro = led_cur_instruction->r;
+                go = led_cur_instruction->g;
+                bo = led_cur_instruction->b;
+            } else if (led_cur_instruction->flags & LED_FLAG_USE_PATTERN) {
+                led_run_pattern(led_setups[led_cur_instruction->pattern_id], &ro, &go, &bo, po);
+            } else if (led_cur_instruction->flags & LED_FLAG_USE_ROTATE_PATTERN) {
+                led_run_pattern(led_setups[led_animation_id], &ro, &go, &bo, po);
             }
 
-            for (drvid=0;drvid<ISSI3733_DRIVER_COUNT;drvid++)
-                I2C_LED_Q_PWM(drvid); //Queue data
+            next_iter:
+                led_cur_instruction++;
+        }
 
-            i2c_led_q_run();
+        if (ro > 255) ro = 255; else if (ro < 0) ro = 0;
+        if (go > 255) go = 255; else if (go < 0) go = 0;
+        if (bo > 255) bo = 255; else if (bo < 0) bo = 0;
 
-            led_cur = 0; //Signal next frame calculations may begin
+        if (led_animation_breathing)
+        {
+            ro *= breathe_mult;
+            go *= breathe_mult;
+            bo *= breathe_mult;
         }
     }
 
-    //Process more data if not finished
-    if (led_cur != lede)
-    {
-        //DBG_1_OFF; //debug profiling
-        led_matrix_run();
-        //DBG_1_ON; //debug profiling
-    }
+    led_buffer[i].r = (uint8_t)ro;
+    led_buffer[i].g = (uint8_t)go;
+    led_buffer[i].b = (uint8_t)bo;
 }
 
+#endif // USE_MASSDROP_CONFIGURATOR
diff --git a/tmk_core/protocol/arm_atsam/led_matrix.h b/tmk_core/protocol/arm_atsam/led_matrix.h
index 4513234e7f..1316efd9a4 100644
--- a/tmk_core/protocol/arm_atsam/led_matrix.h
+++ b/tmk_core/protocol/arm_atsam/led_matrix.h
@@ -18,6 +18,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #ifndef _LED_MATRIX_H_
 #define _LED_MATRIX_H_
 
+#include "quantum.h"
+
 //From keyboard
 #include "config_led.h"
 
@@ -75,25 +77,20 @@ typedef struct issi3733_led_s {
     uint8_t scan;               //Key scan code from wiring (set 0xFF if no key)
 } issi3733_led_t;
 
-typedef struct led_disp_s {
-    uint64_t frame;
-    float left;
-    float right;
-    float top;
-    float bottom;
-    float width;
-    float height;
-    float max_distance;
-} led_disp_t;
+extern issi3733_driver_t issidrv[ISSI3733_DRIVER_COUNT];
 
-uint8_t led_matrix_init(void);
-void rgb_matrix_init_user(void);
+extern uint8_t gcr_desired;
+extern uint8_t gcr_breathe;
+extern uint8_t gcr_actual;
+extern uint8_t gcr_actual_last;
 
-#define LED_MODE_NORMAL             0   //Must be 0
-#define LED_MODE_KEYS_ONLY          1
-#define LED_MODE_NON_KEYS_ONLY      2
-#define LED_MODE_INDICATORS_ONLY    3
-#define LED_MODE_MAX_INDEX          LED_MODE_INDICATORS_ONLY   //Must be highest value
+void gcr_compute(void);
+
+void led_matrix_indicators(void);
+
+/*-------------------------  Legacy Lighting Support  ------------------------*/
+
+#ifdef USE_MASSDROP_CONFIGURATOR
 
 #define EF_NONE         0x00000000  //No effect
 #define EF_OVER         0x00000001  //Overwrite any previous color information with new
@@ -114,33 +111,48 @@ typedef struct led_setup_s {
   uint8_t end;      //Set to signal end of the setup
 } led_setup_t;
 
-extern issi3733_driver_t issidrv[ISSI3733_DRIVER_COUNT];
+extern const uint8_t led_setups_count;
+extern void *led_setups[];
 
-extern uint8_t gcr_desired;
-extern uint8_t gcr_breathe;
-extern uint8_t gcr_actual;
-extern uint8_t gcr_actual_last;
+//LED Extra Instructions
+#define LED_FLAG_NULL                0x00       //Matching and coloring not used (default)
+#define LED_FLAG_MATCH_ID            0x01       //Match on the ID of the LED (set id#'s to desired bit pattern, first LED is id 1)
+#define LED_FLAG_MATCH_LAYER         0x02       //Match on the current active layer (set layer to desired match layer)
+#define LED_FLAG_USE_RGB             0x10       //Use a specific RGB value (set r, g, b to desired output color values)
+#define LED_FLAG_USE_PATTERN         0x20       //Use a specific pattern ID (set pattern_id to desired output pattern)
+#define LED_FLAG_USE_ROTATE_PATTERN  0x40       //Use pattern the user has cycled to manually
+
+typedef struct led_instruction_s {
+    uint16_t flags; // Bitfield for LED instructions
+    uint32_t id0; // Bitwise id, IDs 0-31
+    uint32_t id1; // Bitwise id, IDs 32-63
+    uint32_t id2; // Bitwise id, IDs 64-95
+    uint32_t id3; // Bitwise id, IDs 96-127
+    uint8_t layer;
+    uint8_t r;
+    uint8_t g;
+    uint8_t b;
+    uint8_t pattern_id;
+    uint8_t end;
+} led_instruction_t;
+
+extern led_instruction_t led_instructions[];
 
+extern uint8_t led_animation_breathing;
 extern uint8_t led_animation_id;
-extern uint8_t led_enabled;
 extern float led_animation_speed;
 extern uint8_t led_lighting_mode;
-extern uint8_t led_animation_direction;
-extern uint8_t led_animation_orientation;
-extern uint8_t led_animation_breathing;
+extern uint8_t led_enabled;
 extern uint8_t led_animation_breathe_cur;
+extern uint8_t led_animation_direction;
 extern uint8_t breathe_dir;
-extern uint8_t led_animation_circular;
-extern const uint8_t led_setups_count;
 
-extern void *led_setups[];
-
-extern issi3733_led_t *led_cur;
-extern issi3733_led_t *lede;
-
-void led_matrix_run(void);
-void led_matrix_task(void);
+#define LED_MODE_NORMAL             0   //Must be 0
+#define LED_MODE_KEYS_ONLY          1
+#define LED_MODE_NON_KEYS_ONLY      2
+#define LED_MODE_INDICATORS_ONLY    3
+#define LED_MODE_MAX_INDEX          LED_MODE_INDICATORS_ONLY   //Must be highest value
 
-void gcr_compute(void);
+#endif // USE_MASSDROP_CONFIGURATOR
 
 #endif //_LED_MATRIX_H_
diff --git a/tmk_core/protocol/arm_atsam/led_matrix_programs.c b/tmk_core/protocol/arm_atsam/led_matrix_programs.c
new file mode 100644
index 0000000000..cf7478dc31
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/led_matrix_programs.c
@@ -0,0 +1,123 @@
+/*
+Copyright 2018 Massdrop Inc.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifdef USE_MASSDROP_CONFIGURATOR
+
+#include "led_matrix.h"
+
+//Teal <-> Salmon
+led_setup_t leds_teal_salmon[] = {
+    { .hs = 0,  .he = 33,  .rs = 24,  .re = 24,  .gs = 215, .ge = 215, .bs = 204, .be = 204, .ef = EF_NONE },
+    { .hs = 33, .he = 66,  .rs = 24,  .re = 255, .gs = 215, .ge = 114, .bs = 204, .be = 118, .ef = EF_NONE },
+    { .hs = 66, .he = 100, .rs = 255, .re = 255, .gs = 114, .ge = 114, .bs = 118, .be = 118, .ef = EF_NONE },
+    { .end = 1 },
+};
+
+//Yellow
+led_setup_t leds_yellow[] = {
+    { .hs = 0, .he = 100, .rs = 255, .re = 255, .gs = 255, .ge = 255, .bs = 0, .be = 0, .ef = EF_NONE },
+    { .end = 1 },
+};
+
+//Off
+led_setup_t leds_off[] = {
+    { .hs = 0, .he = 100, .rs = 0, .re = 0, .gs = 0, .ge = 0, .bs = 0, .be = 0, .ef = EF_NONE },
+    { .end = 1 },
+};
+
+//Red
+led_setup_t leds_red[] = {
+    { .hs = 0, .he = 100, .rs = 255, .re = 255, .gs = 0, .ge = 0, .bs = 0, .be = 0, .ef = EF_NONE },
+    { .end = 1 },
+};
+
+//Green
+led_setup_t leds_green[] = {
+    { .hs = 0, .he = 100, .rs = 0, .re = 0, .gs = 255, .ge = 255, .bs = 0, .be = 0, .ef = EF_NONE },
+    { .end = 1 },
+};
+
+//Blue
+led_setup_t leds_blue[] = {
+    { .hs = 0, .he = 100, .rs = 0, .re = 0, .gs = 0, .ge = 0, .bs = 255, .be = 255, .ef = EF_NONE },
+    { .end = 1 },
+};
+
+//White
+led_setup_t leds_white[] = {
+    { .hs = 0, .he = 100, .rs = 255, .re = 255, .gs = 255, .ge = 255, .bs = 255, .be = 255, .ef = EF_NONE },
+    { .end = 1 },
+};
+
+//White with moving red stripe
+led_setup_t leds_white_with_red_stripe[] = {
+    { .hs = 0, .he = 100, .rs = 255, .re = 255, .gs = 255, .ge = 255, .bs = 255, .be = 255, .ef = EF_NONE },
+    { .hs = 0, .he = 15, .rs = 0, .re = 0, .gs = 0, .ge = 255, .bs = 0, .be = 255, .ef = EF_SCR_R | EF_SUBTRACT },
+    { .hs = 15, .he = 30, .rs = 0, .re = 0, .gs = 255, .ge = 0, .bs = 255, .be = 0, .ef = EF_SCR_R | EF_SUBTRACT },
+    { .end = 1 },
+};
+
+//Black with moving red stripe
+led_setup_t leds_black_with_red_stripe[] = {
+    { .hs = 0, .he = 15, .rs = 0, .re = 255, .gs = 0, .ge = 0, .bs = 0, .be = 0, .ef = EF_SCR_R },
+    { .hs = 15, .he = 30, .rs = 255, .re = 0, .gs = 0, .ge = 0, .bs = 0, .be = 0, .ef = EF_SCR_R },
+    { .end = 1 },
+};
+
+//Rainbow no scrolling
+led_setup_t leds_rainbow_ns[] = {
+    { .hs = 0,      .he = 16.67,  .rs = 255, .re = 255, .gs = 0,   .ge = 255, .bs = 0,   .be = 0,   .ef = EF_OVER },
+    { .hs = 16.67,  .he = 33.33,  .rs = 255, .re = 0,   .gs = 255, .ge = 255, .bs = 0,   .be = 0,   .ef = EF_OVER },
+    { .hs = 33.33,  .he = 50,     .rs = 0,   .re = 0,   .gs = 255, .ge = 255, .bs = 0,   .be = 255, .ef = EF_OVER },
+    { .hs = 50,     .he = 66.67,  .rs = 0,   .re = 0,   .gs = 255, .ge = 0,   .bs = 255, .be = 255, .ef = EF_OVER },
+    { .hs = 66.67,  .he = 83.33,  .rs = 0,   .re = 255, .gs = 0,   .ge = 0,   .bs = 255, .be = 255, .ef = EF_OVER },
+    { .hs = 83.33,  .he = 100,    .rs = 255, .re = 255, .gs = 0,   .ge = 0,   .bs = 255, .be = 0,   .ef = EF_OVER },
+    { .end = 1 },
+};
+
+//Rainbow scrolling
+led_setup_t leds_rainbow_s[] = {
+    { .hs = 0,      .he = 16.67,  .rs = 255, .re = 255, .gs = 0,   .ge = 255, .bs = 0,   .be = 0,   .ef = EF_OVER | EF_SCR_R },
+    { .hs = 16.67,  .he = 33.33,  .rs = 255, .re = 0,   .gs = 255, .ge = 255, .bs = 0,   .be = 0,   .ef = EF_OVER | EF_SCR_R },
+    { .hs = 33.33,  .he = 50,     .rs = 0,   .re = 0,   .gs = 255, .ge = 255, .bs = 0,   .be = 255, .ef = EF_OVER | EF_SCR_R },
+    { .hs = 50,     .he = 66.67,  .rs = 0,   .re = 0,   .gs = 255, .ge = 0,   .bs = 255, .be = 255, .ef = EF_OVER | EF_SCR_R },
+    { .hs = 66.67,  .he = 83.33,  .rs = 0,   .re = 255, .gs = 0,   .ge = 0,   .bs = 255, .be = 255, .ef = EF_OVER | EF_SCR_R },
+    { .hs = 83.33,  .he = 100,    .rs = 255, .re = 255, .gs = 0,   .ge = 0,   .bs = 255, .be = 0,   .ef = EF_OVER | EF_SCR_R },
+    { .end = 1 },
+};
+
+//Add new LED animations here using one from above as example
+//The last entry must be { .end = 1 }
+//Add the new animation name to the list below following its format
+
+void *led_setups[] = {
+    leds_rainbow_s,
+    leds_rainbow_ns,
+    leds_teal_salmon,
+    leds_yellow,
+    leds_red,
+    leds_green,
+    leds_blue,
+    leds_white,
+    leds_white_with_red_stripe,
+    leds_black_with_red_stripe,
+    leds_off
+};
+
+const uint8_t led_setups_count = sizeof(led_setups) / sizeof(led_setups[0]);
+
+#endif
diff --git a/tmk_core/protocol/arm_atsam/main_arm_atsam.c b/tmk_core/protocol/arm_atsam/main_arm_atsam.c
index eaad66e9fc..0974a230d4 100644
--- a/tmk_core/protocol/arm_atsam/main_arm_atsam.c
+++ b/tmk_core/protocol/arm_atsam/main_arm_atsam.c
@@ -203,13 +203,6 @@ void main_subtask_usb_state(void)
     }
 }
 
-void main_subtask_led(void)
-{
-    if (g_usb_state != USB_FSMSTATUS_FSMSTATE_ON_Val) return; //Only run LED tasks if USB is operating
-
-    led_matrix_task();
-}
-
 void main_subtask_power_check(void)
 {
     static uint64_t next_5v_checkup = 0;
@@ -221,7 +214,9 @@ void main_subtask_power_check(void)
         v_5v = adc_get(ADC_5V);
         v_5v_avg = 0.9 * v_5v_avg + 0.1 * v_5v;
 
+#ifdef RGB_MATRIX_ENABLE
         gcr_compute();
+#endif
     }
 }
 
@@ -240,7 +235,6 @@ void main_subtask_usb_extra_device(void)
 void main_subtasks(void)
 {
     main_subtask_usb_state();
-    main_subtask_led();
     main_subtask_power_check();
     main_subtask_usb_extra_device();
 }
@@ -263,7 +257,9 @@ int main(void)
 
     SR_EXP_Init();
 
+#ifdef RGB_MATRIX_ENABLE
     i2c1_init();
+#endif // RGB_MATRIX_ENABLE
 
     matrix_init();
 
@@ -281,8 +277,7 @@ int main(void)
 
     DBG_LED_OFF;
 
-    led_matrix_init();
-
+#ifdef RGB_MATRIX_ENABLE
     while (I2C3733_Init_Control() != 1) {}
     while (I2C3733_Init_Drivers() != 1) {}
 
@@ -292,6 +287,7 @@ int main(void)
 
     for (uint8_t drvid = 0; drvid < ISSI3733_DRIVER_COUNT; drvid++)
         I2C_LED_Q_ONOFF(drvid); //Queue data
+#endif // RGB_MATRIX_ENABLE
 
     keyboard_setup();
 
diff --git a/tmk_core/protocol/arm_atsam/usb/usb2422.c b/tmk_core/protocol/arm_atsam/usb/usb2422.c
index d6e1922429..76ec3aaaa7 100644
--- a/tmk_core/protocol/arm_atsam/usb/usb2422.c
+++ b/tmk_core/protocol/arm_atsam/usb/usb2422.c
@@ -365,8 +365,10 @@ void USB_ExtraSetState(uint8_t state)
     if (usb_extra_state == USB_EXTRA_STATE_ENABLED) CDC_print("USB: Extra enabled\r\n");
     else if (usb_extra_state == USB_EXTRA_STATE_DISABLED)
     {
-      CDC_print("USB: Extra disabled\r\n");
-      if (led_animation_breathing) gcr_breathe = gcr_desired;
+        CDC_print("USB: Extra disabled\r\n");
+#ifdef USE_MASSDROP_CONFIGURATOR
+        if (led_animation_breathing) gcr_breathe = gcr_desired;
+#endif
     }
     else if (usb_extra_state == USB_EXTRA_STATE_DISABLED_UNTIL_REPLUG) CDC_print("USB: Extra disabled until replug\r\n");
     else CDC_print("USB: Extra state unknown\r\n");