non working code

drivers/arm/twi2c.c

@@ -75,11 +75,6 @@ void twi2c_catch_error(I2CDriver *i2cp)
 /**
  * Callback after sending of response complete - restores default reply in case polled
  */
-void twi2c_clear_after_send(I2CDriver *i2cp)
-{
-  // echoReply.size = 0;               // Clear receive message
-  // i2cSlaveReplyI(i2cp, &initialReply);
-}
 
 uint8_t twi2c_start(void) {
   i2cStart(&I2C_DRIVER, &i2cconfig);
@@ -100,11 +95,11 @@ void twi2c_init(void) {
 }
 
 uint8_t twi2c_write(uint8_t data) {
-  return i2cMasterTransmitTimeout(&I2C_DRIVER, twi2c_address/2, &data, 1, 0, 0, MS2ST(100));
+  return i2cMasterTransmitTimeout(&I2C_DRIVER, twi2c_address/2, &data, 1, NULL, 0, MS2ST(100));
 }
 
 uint8_t twi2c_transmit(uint8_t address, uint8_t * data, uint16_t length) {
-  return i2cMasterTransmitTimeout(&I2C_DRIVER, address/2, data, length, 0, 0, MS2ST(100));
+  return i2cMasterTransmitTimeout(&I2C_DRIVER, address/2, data, length, NULL, 0, MS2ST(100));
 }
 
 uint8_t twi2c_receive(uint8_t address, uint8_t * data, uint16_t length) {
@@ -112,8 +107,8 @@ uint8_t twi2c_receive(uint8_t address, uint8_t * data, uint16_t length) {
 }
 
 
-uint8_t twi2c_incoming_body[50];
-uint8_t twi2c_outgoing_body[1024];
+uint8_t twi2c_incoming_body[50] = {0};
+uint8_t twi2c_outgoing_body[1024] = {0};
 
 // Response to received messages
 I2CSlaveMsg twi2c_incoming_message = {
@@ -138,6 +133,11 @@ I2CSlaveMsg twi2c_outgoing_message = {
   twi2c_catch_error
 };
 
+void twi2c_clear_after_send(I2CDriver *i2cp) {
+  twi2c_outgoing_message.size = 0; // Clear receive message
+  //i2cSlaveReplyI(i2cp, &initialReply);
+}
+
 uint8_t twi2c_reply(I2CDriver * i2cp, uint8_t * data, uint16_t length) {
   memcpy(twi2c_outgoing_body, data, length);
   twi2c_outgoing_message.size = length;
@@ -157,11 +157,26 @@ uint8_t twi2c_start_listening(uint8_t address, twi2c_message_received callback)
   return 0;
 }
 
-uint8_t twi2c_restart_listening(uint8_t address) {
+uint8_t twi2c_remove_listening(uint8_t address) {
+  i2cUnmatchAddress(&I2C_DRIVER, address/2);
+  return 0;
+}
+
+uint8_t twi2c_add_listening(uint8_t address) {
   i2cMatchAddress(&I2C_DRIVER, address/2);
   return 0;
 }
 
+uint8_t twi2c_remove_listening_i(uint8_t address) {
+  i2cUnmatchAddressI(&I2C_DRIVER, address/2);
+  return 0;
+}
+
+uint8_t twi2c_add_listening_i(uint8_t address) {
+  i2cMatchAddressI(&I2C_DRIVER, address/2);
+  return 0;
+}
+
 void twi2c_stop(void) {
   i2cUnmatchAll(&I2C_DRIVER);
   i2cStop(&I2C_DRIVER);

drivers/arm/twi2c.h

@@ -43,6 +43,9 @@ void twi2c_stop(void);
 uint8_t twi2c_reply(I2CDriver * i2cp, uint8_t * data, uint16_t length);
 uint8_t twi2c_transmit_receive(uint8_t address, uint8_t * tx_body, uint16_t tx_length, uint8_t * rx_body, uint16_t rx_length);
 uint8_t twi2c_start_listening(uint8_t address, twi2c_message_received callback);
-uint8_t twi2c_restart_listening(uint8_t address);
+uint8_t twi2c_add_listening(uint8_t address);
+uint8_t twi2c_remove_listening(uint8_t address);
+uint8_t twi2c_add_listening_i(uint8_t address);
+uint8_t twi2c_remove_listening_i(uint8_t address);
 
 #endif

drivers/qwiic/qwiic_keyboard.c

@@ -24,28 +24,42 @@
 #include "usb_driver.h"
 
 #define QWIIC_KEYBOARD_LAYERS 16
-#define QWIIC_KEYBOARD_ROWS 8
-#define QWIIC_KEYBOARD_COLS 8
+#define QWIIC_KEYBOARD_ROWS   8
+#define QWIIC_KEYBOARD_COLS   8
 
-#define qwiic_matrix_t uint8_t
+#if (QWIIC_KEYBOARD_COLS <= 8)
+typedef uint8_t qwiic_row_t;
+#elif (QWIIC_KEYBOARD_COLS <= 16)
+typedef uint16_t qwiic_row_t;
+#elif (QWIIC_KEYBOARD_COLS <= 32)
+typedef uint32_t qwiic_row_t;
+#else
+#error "QWIIC_KEYBOARD_COLS: invalid value"
+#endif
 
 #define QWIIC_KEYBOARD_HANDSHAKE_ADDRESS       0b01010100
 #define QWIIC_KEYBOARD_LISTENING_ADDRESS_START 0b01010110
-#define QWIIC_KEYBOARD_HANDSHAKE_MESSAGE_SIZE  (QWIIC_KEYBOARD_LAYERS * QWIIC_KEYBOARD_ROWS * QWIIC_KEYBOARD_COLS)
-#define QWIIC_KEYBOARD_MATRIX_MESSAGE_SIZE     MATRIX_ROWS
+#define QWIIC_KEYBOARD_MAX_DEVICES             1
+
+#define QWIIC_KEYBOARD_KEYMAP_MESSAGE_SIZE     (QWIIC_KEYBOARD_LAYERS * QWIIC_KEYBOARD_ROWS * QWIIC_KEYBOARD_COLS)
+#define QWIIC_KEYBOARD_MATRIX_MESSAGE_SIZE     (QWIIC_KEYBOARD_ROWS)
 
 void qwiic_keyboard_write_keymap(uint8_t * pointer);
-void qwiic_keyboard_read_keymap(uint8_t * pointer);
+void qwiic_keyboard_read_keymap(uint8_t * pointer, uint8_t index);
 
 bool qwiic_keyboard_master = false;
-bool qwiic_keyboard_connected = false;
-uint8_t qwiic_keyboard_handshake_message[QWIIC_KEYBOARD_HANDSHAKE_MESSAGE_SIZE] = {0};
-uint8_t qwiic_keyboard_matrix_message[QWIIC_KEYBOARD_ROWS] = {0};
+bool qwiic_keyboard_connected[QWIIC_KEYBOARD_MAX_DEVICES] = { false };
+uint8_t qwiic_keyboard_keymap_message[QWIIC_KEYBOARD_KEYMAP_MESSAGE_SIZE] = {0};
+uint8_t qwiic_keyboard_matrix_message[QWIIC_KEYBOARD_MATRIX_MESSAGE_SIZE] = {0};
 twi2c_message_received qwiic_keyboard_message_received_ptr = qwiic_keyboard_message_received;
+float song_one_up[][2]  = SONG(ONE_UP_SOUND);
+uint8_t first_message = 0;
 
-uint16_t qwiic_keyboard_keymap[QWIIC_KEYBOARD_LAYERS][QWIIC_KEYBOARD_ROWS][QWIIC_KEYBOARD_COLS] = {0};
-uint8_t qwiic_keyboard_listening_address = QWIIC_KEYBOARD_LISTENING_ADDRESS_START;
-uint8_t qwiic_keyboard_processing_slave = false;
+uint16_t qwiic_keyboard_keymap[QWIIC_KEYBOARD_MAX_DEVICES][QWIIC_KEYBOARD_LAYERS][QWIIC_KEYBOARD_ROWS][QWIIC_KEYBOARD_COLS] = {0};
+bool qwiic_keyboard_keymap_initialised[QWIIC_KEYBOARD_MAX_DEVICES] = { false };
+uint8_t qwiic_keyboard_listening_address[QWIIC_KEYBOARD_MAX_DEVICES] = { 0 };
+#define QWIIC_KEYBOARD_NOT_PROCESSING 255
+uint8_t qwiic_keyboard_processing_slave = QWIIC_KEYBOARD_NOT_PROCESSING;
 
 void qwiic_keyboard_init(void) {
   twi2c_init();
@@ -54,106 +68,148 @@ void qwiic_keyboard_init(void) {
 }
 
 void qwiic_keyboard_set_master(void) {
-  twi2c_stop();
-  twi2c_start();
+  //twi2c_stop();
+  //twi2c_start();
+  twi2c_remove_listening(QWIIC_KEYBOARD_HANDSHAKE_ADDRESS);
   qwiic_keyboard_master = true;
 }
 
-uint8_t command[1] = { 0x00 };
+uint8_t keymap_command[1] = { 0x01 };
+uint8_t matrix_command[1] = { 0x02 };
+uint8_t look_counter = 0;
+
+// uint8_t get_available_device_index(void) {
+//   for (uint8_t i = 0; i < QWIIC_KEYBOARD_MAX_DEVICES; i++) {
+//     if (!qwiic_keyboard_connected[i])
+//       return i;
+//   }
+//   return 255;
+// }
 
 void qwiic_keyboard_task(void) {
   if (USB_DRIVER.state == USB_ACTIVE)
-    qwiic_keyboard_master = true;
-  else
-    qwiic_keyboard_master = false;
+    qwiic_keyboard_set_master();
   if (qwiic_keyboard_master) {
-    if (qwiic_keyboard_connected) {
-      // send empty message, expecting matrix info
-      if (MSG_OK == twi2c_transmit_receive(qwiic_keyboard_listening_address,
-        command, 1,
-        qwiic_keyboard_matrix_message, QWIIC_KEYBOARD_MATRIX_MESSAGE_SIZE
-      )) {
-        // majority of this is pulled from keyboard.c:keyboard_task()
-        static qwiic_matrix_t matrix_prev[QWIIC_KEYBOARD_ROWS];
-        qwiic_matrix_t matrix_row = 0;
-        qwiic_matrix_t matrix_change = 0;
-        #ifdef QMK_KEYS_PER_SCAN
-          uint8_t keys_processed = 0;
-        #endif
-        qwiic_keyboard_processing_slave = true;
-        for (uint8_t r = 0; r < QWIIC_KEYBOARD_ROWS; r++) {
-          matrix_row = qwiic_keyboard_matrix_message[r];
-          matrix_change = matrix_row ^ matrix_prev[r];
-          if (matrix_change) {
-            for (uint8_t c = 0; c < QWIIC_KEYBOARD_COLS; c++) {
-              if (matrix_change & ((qwiic_matrix_t)1<<c)) {
-                action_exec((keyevent_t){
-                  .key = (keypos_t){ .row = r, .col = c },
-                  .pressed = (matrix_row & ((qwiic_matrix_t)1<<c)),
-                  .time = (timer_read() | 1) /* time should not be 0 */
-                });
-                // record a processed key
-                matrix_prev[r] ^= ((qwiic_matrix_t)1<<c);
-                #ifdef QMK_KEYS_PER_SCAN
-                  // only jump out if we have processed "enough" keys.
-                  if (++keys_processed >= QMK_KEYS_PER_SCAN)
-                #endif
-                // process a key per task call
-                goto QWIIC_MATRIX_LOOP_END;
+    for (uint8_t device_i = 0; device_i < QWIIC_KEYBOARD_MAX_DEVICES; device_i++) {
+      if (qwiic_keyboard_connected[device_i]) {
+        // send empty message, expecting matrix info
+        // twi2c_transmit(qwiic_keyboard_listening_address[device_i], command, 1);
+        // if (MSG_OK == twi2c_receive(qwiic_keyboard_listening_address[device_i],
+        //   qwiic_keyboard_matrix_message, QWIIC_KEYBOARD_MATRIX_MESSAGE_SIZE
+        // )) {
+        if (!qwiic_keyboard_keymap_initialised[device_i]) {
+          if (MSG_OK == twi2c_transmit_receive(qwiic_keyboard_listening_address[device_i],
+            keymap_command, 1,
+            qwiic_keyboard_keymap_message, QWIIC_KEYBOARD_KEYMAP_MESSAGE_SIZE
+          )) {
+            // load keymap into memory
+            qwiic_keyboard_keymap_initialised[device_i] = true;
+            qwiic_keyboard_read_keymap(qwiic_keyboard_keymap_message, device_i);
+          }
+        } else {
+          if (MSG_OK == twi2c_transmit_receive(qwiic_keyboard_listening_address[device_i],
+            matrix_command, 1,
+            qwiic_keyboard_matrix_message, QWIIC_KEYBOARD_MATRIX_MESSAGE_SIZE
+          )) {
+            // majority of this is pulled from keyboard.c:keyboard_task()
+            static qwiic_row_t matrix_prev[QWIIC_KEYBOARD_ROWS];
+            qwiic_row_t matrix_row = 0;
+            qwiic_row_t matrix_change = 0;
+            #ifdef QMK_KEYS_PER_SCAN
+              uint8_t keys_processed = 0;
+            #endif
+            qwiic_keyboard_processing_slave = device_i;
+            for (uint8_t r = 0; r < QWIIC_KEYBOARD_ROWS; r++) {
+              matrix_row = qwiic_keyboard_matrix_message[r];
+              matrix_change = matrix_row ^ matrix_prev[r];
+              if (matrix_change) {
+                for (uint8_t c = 0; c < QWIIC_KEYBOARD_COLS; c++) {
+                  if (matrix_change & ((qwiic_row_t)1<<c)) {
+                    action_exec((keyevent_t){
+                      .key = (keypos_t){ .row = r, .col = c },
+                      .pressed = (matrix_row & ((qwiic_row_t)1<<c)),
+                      .time = (timer_read() | 1) /* time should not be 0 */
+                    });
+                    // record a processed key
+                    matrix_prev[r] ^= ((qwiic_row_t)1<<c);
+                    #ifdef QMK_KEYS_PER_SCAN
+                      // only jump out if we have processed "enough" keys.
+                      if (++keys_processed >= QMK_KEYS_PER_SCAN)
+                    #endif
+                    // process a key per task call
+                    goto QWIIC_MATRIX_LOOP_END;
+                  }
+                }
               }
             }
+            // call with pseudo tick event when no real key event.
+            #ifdef QMK_KEYS_PER_SCAN
+              // we can get here with some keys processed now.
+              if (!keys_processed)
+            #endif
+            action_exec(TICK);
+            QWIIC_MATRIX_LOOP_END:
+            qwiic_keyboard_processing_slave = QWIIC_KEYBOARD_NOT_PROCESSING;
+          // if (first_message == 100) {
+          //   PLAY_SONG(song_one_up);
+          // }
+          // first_message += 1;
           }
-        }
-        // call with pseudo tick event when no real key event.
-        #ifdef QMK_KEYS_PER_SCAN
-          // we can get here with some keys processed now.
-          if (!keys_processed)
-        #endif
-        action_exec(TICK);
-        QWIIC_MATRIX_LOOP_END:
-        qwiic_keyboard_processing_slave = false;
-      } else {
-        // disconnect
-        // qwiic_keyboard_connected = false;
-      }
-    } else { // if not connected
-      // send new address to listen on, expect back keymap
-      if (MSG_OK == twi2c_transmit_receive(QWIIC_KEYBOARD_HANDSHAKE_ADDRESS,
-        &qwiic_keyboard_listening_address, 1,
-        qwiic_keyboard_handshake_message, QWIIC_KEYBOARD_HANDSHAKE_MESSAGE_SIZE
-      )) {
-        qwiic_keyboard_connected = true;
-        // load keymap into memory
-        qwiic_keyboard_read_keymap(qwiic_keyboard_handshake_message);
-      }
-    }
-  }
+        } // end else - not init
+      } else { // if not connected
+        //if (look_counter == 0) {
+          // send new address to listen on, expect back keymap
+          uint8_t new_address = QWIIC_KEYBOARD_LISTENING_ADDRESS_START + (device_i*2);
+          uint8_t address_copy = 0;
+          // twi2c_transmit(QWIIC_KEYBOARD_HANDSHAKE_ADDRESS, &new_address, 1);
+          // if (MSG_OK == twi2c_receive(QWIIC_KEYBOARD_HANDSHAKE_ADDRESS,
+          //   &address_copy, 1
+          // )) {
+          if (MSG_OK == twi2c_transmit_receive(QWIIC_KEYBOARD_HANDSHAKE_ADDRESS,
+            &new_address, 1,
+            &address_copy, 1
+          )) {
+            send_byte(address_copy);
+            if (address_copy == new_address) {
+              SEND_STRING(".");
+              PLAY_SONG(song_one_up);
+              qwiic_keyboard_connected[device_i] = true;
+              qwiic_keyboard_listening_address[device_i] = new_address;
+            }
+          }
+        //} // end if - look for new
+      } // end else - connected
+    } // end for - devices
+    look_counter = ((look_counter + 1) % 150);
+  } // end if - master
 }
 
-float song_one_up[][2]  = SONG(ONE_UP_SOUND);
-bool first_message = true;
-
 void qwiic_keyboard_message_received(I2CDriver *i2cp, uint8_t * body, uint16_t size) {
-  if (qwiic_keyboard_connected) {
-    for (uint8_t row = 0; row < QWIIC_KEYBOARD_ROWS; row++) {
-      if (row < MATRIX_ROWS) {
-        qwiic_keyboard_matrix_message[row] = matrix_get_row(row);
-      } else {
-        qwiic_keyboard_matrix_message[row] = 0;
+  switch (body[0]) {
+    // send keymap
+    case 0x01:
+      qwiic_keyboard_write_keymap(qwiic_keyboard_keymap_message);
+      twi2c_reply(i2cp, qwiic_keyboard_keymap_message, QWIIC_KEYBOARD_KEYMAP_MESSAGE_SIZE);
+      break;
+    // send matrix
+    case 0x02:
+      for (uint8_t row = 0; row < QWIIC_KEYBOARD_ROWS; row++) {
+        if (row < MATRIX_ROWS) {
+          qwiic_keyboard_matrix_message[row] = matrix_get_row(row);
+        } else {
+          qwiic_keyboard_matrix_message[row] = 0;
+        }
       }
-    }
-    twi2c_reply(i2cp, qwiic_keyboard_matrix_message, QWIIC_KEYBOARD_MATRIX_MESSAGE_SIZE);
-    if (first_message) {
-      PLAY_SONG(song_one_up);
-      first_message = false;
-    }
-  } else {
-    qwiic_keyboard_connected = true;
-    qwiic_keyboard_master = false;
-    qwiic_keyboard_listening_address = body[0];
-    twi2c_restart_listening(qwiic_keyboard_listening_address);
-    qwiic_keyboard_write_keymap(qwiic_keyboard_handshake_message);
-    twi2c_reply(i2cp, qwiic_keyboard_handshake_message, QWIIC_KEYBOARD_HANDSHAKE_MESSAGE_SIZE);
+      twi2c_reply(i2cp, qwiic_keyboard_matrix_message, QWIIC_KEYBOARD_MATRIX_MESSAGE_SIZE);
+      break;
+    default:
+      twi2c_remove_listening_i(QWIIC_KEYBOARD_HANDSHAKE_ADDRESS);
+      qwiic_keyboard_connected[0] = true;
+      //qwiic_keyboard_master = false;
+      qwiic_keyboard_listening_address[0] = body[0];
+      twi2c_reply(i2cp, body, size);
+      twi2c_add_listening_i(qwiic_keyboard_listening_address[0]);
+      break;
   }
 }
 
@@ -164,7 +220,8 @@ void qwiic_keyboard_write_keymap(uint8_t * pointer) {
   for (uint8_t layer = 0; layer < QWIIC_KEYBOARD_LAYERS; layer++) {
     for (uint8_t row = 0; row < QWIIC_KEYBOARD_ROWS; row++) {
       for (uint8_t col = 0; col < QWIIC_KEYBOARD_COLS; col++) {
-        uint16_t keycode = pgm_read_word(&keymaps[layer][row][col]);
+        uint16_t keycode = 0;
+        keycode = pgm_read_word(&keymaps[layer][row][col]);
         *pointer++ = (keycode >> 8);
         *pointer++ = (keycode & 0xFF);
       }
@@ -172,13 +229,13 @@ void qwiic_keyboard_write_keymap(uint8_t * pointer) {
   }
 }
 
-void qwiic_keyboard_read_keymap(uint8_t * pointer) {
+void qwiic_keyboard_read_keymap(uint8_t * pointer, uint8_t index) {
   for (uint8_t layer = 0; layer < QWIIC_KEYBOARD_LAYERS; layer++) {
     for (uint8_t row = 0; row < QWIIC_KEYBOARD_ROWS; row++) {
       for (uint8_t col = 0; col < QWIIC_KEYBOARD_COLS; col++) {
         uint16_t keycode = ((*pointer++) << 8);
         keycode |= (*pointer++);
-        qwiic_keyboard_keymap[layer][row][col] = keycode;
+        qwiic_keyboard_keymap[index][layer][row][col] = keycode;
       }
     }
   }
@@ -191,12 +248,11 @@ bool is_keyboard_master(void) {
 
 // overwrite the built-in function
 uint16_t keymap_key_to_keycode(uint8_t layer, keypos_t key) {
-  if (qwiic_keyboard_processing_slave) {
-    // trick the built-in handling to accept our replacement keymap
-    return qwiic_keyboard_keymap[(layer)][(key.row)][(key.col)];
-    //return KC_A;
-  } else {
+  if (qwiic_keyboard_processing_slave == QWIIC_KEYBOARD_NOT_PROCESSING) {
     // Read entire word (16bits)
     return pgm_read_word(&keymaps[(layer)][(key.row)][(key.col)]);
+  } else {
+    // trick the built-in handling to accept our replacement keymap
+    return qwiic_keyboard_keymap[qwiic_keyboard_processing_slave][(layer)][(key.row)][(key.col)];
   }
 }

keyboards/muon_light/config.h

@@ -141,11 +141,11 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // 0b1110111 AD <-> VCC
 // 0b1110101 AD <-> SCL
 // 0b1110110 AD <-> SDA
-#define DRIVER_ADDR_1 0b1110100
-#define DRIVER_ADDR_2 0b1110110
+#define DRIVER_ADDR_1 0b1110111
+#define DRIVER_ADDR_2 0b1110101
 
 #define DRIVER_COUNT 2
-#define DRIVER_1_LED_TOTAL 25
+#define DRIVER_1_LED_TOTAL 24
 #define DRIVER_2_LED_TOTAL 24
 #define DRIVER_LED_TOTAL DRIVER_1_LED_TOTAL + DRIVER_2_LED_TOTAL
 

keyboards/muon_light/muon_light.c

@@ -43,73 +43,123 @@ const uint8_t music_map[MATRIX_ROWS][MATRIX_COLS] = LAYOUT_ortho_4x6(
   0,  1,  2,  3,  4,  5
 );
 
-// const is31_led g_is31_leds[DRIVER_LED_TOTAL] = {
-// /* Refer to IS31 manual for these locations
-//  *   driver
-//  *   |  R location
-//  *   |  |      G location
-//  *   |  |      |      B location
-//  *   |  |      |      | */
-//     {0, C1_3,  C2_3,  C3_3},
-//     {0, C1_4,  C2_4,  C3_4},
-//     {0, C1_5,  C2_5,  C3_5},
-//     {0, C1_11, C2_11, C3_11},
-//     {0, C1_12, C2_12, C3_12},
-//     {0, C1_13, C2_13, C3_13},
-
-//     {0, C1_6,  C2_6,  C3_6},
-//     {0, C1_7,  C2_7,  C3_7},
-//     {0, C1_8,  C2_8,  C3_8},
-//     {0, C1_14, C2_14, C3_14},
-//     {0, C1_15, C2_15, C3_15},
-//     {0, C1_16, C2_16, C3_16},
-
-//     {0, C9_1,  C8_1,  C7_1},
-//     {0, C9_2,  C8_2,  C7_2},
-//     {0, C9_3,  C8_3,  C7_3},
-//     {0, C9_9,  C8_9,  C7_9},
-//     {0, C9_10, C8_10, C7_10},
-//     {0, C9_11, C8_11, C7_11},
-
-//     {0, C9_4,  C8_4,  C7_4},
-//     {0, C9_5,  C8_5,  C7_5},
-//     {0, C9_6,  C8_6,  C7_6},
-//     {0, C9_12, C8_12, C7_12},
-//     {0, C9_13, C8_13, C7_13},
-//     {0, C9_14, C8_14, C7_14}
-// };
-
-// const rgb_led g_rgb_leds[DRIVER_LED_TOTAL] = {
-
-//     {row | col << 4}
-//       |             {x=0..224, y=0..64}
-//       |              |                 modifier
-//       |              |                 |
-//     {{0|(0<<4)},   {20.36*0, 21.33*0}, 1},
-//     {{0|(1<<4)},   {20.36*1, 21.33*0}, 0},
-//     {{0|(2<<4)},   {20.36*2, 21.33*0}, 0},
-//     {{0|(3<<4)},   {20.36*3, 21.33*0}, 0},
-//     {{0|(4<<4)},   {20.36*4, 21.33*0}, 0},
-//     {{0|(5<<4)},   {20.36*5, 21.33*0}, 0},
-
-//     {{1|(0<<4)},   {20.36*0, 21.33*1}, 1},
-//     {{1|(1<<4)},   {20.36*1, 21.33*1}, 0},
-//     {{1|(2<<4)},   {20.36*2, 21.33*1}, 0},
-//     {{1|(3<<4)},   {20.36*3, 21.33*1}, 0},
-//     {{1|(4<<4)},   {20.36*4, 21.33*1}, 0},
-//     {{1|(5<<4)},   {20.36*5, 21.33*1}, 0},
-
-//     {{2|(0<<4)},   {20.36*0, 21.33*2}, 1},
-//     {{2|(1<<4)},   {20.36*1, 21.33*2}, 0},
-//     {{2|(2<<4)},   {20.36*2, 21.33*2}, 0},
-//     {{2|(3<<4)},   {20.36*3, 21.33*2}, 0},
-//     {{2|(4<<4)},   {20.36*4, 21.33*2}, 0},
-//     {{2|(5<<4)},   {20.36*5, 21.33*2}, 0},
-
-//     {{3|(0<<4)},   {20.36*0, 21.33*3}, 1},
-//     {{3|(1<<4)},   {20.36*1, 21.33*3}, 1},
-//     {{3|(2<<4)},   {20.36*2, 21.33*3}, 1},
-//     {{3|(3<<4)},   {20.36*3, 21.33*3}, 1},
-//     {{3|(4<<4)},   {20.36*4, 21.33*3}, 1},
-//     {{3|(5<<4)},   {20.36*5, 21.33*3}, 0}
-// };
+#ifdef RGB_MATRIX_ENABLE
+const is31_led g_is31_leds[DRIVER_LED_TOTAL] = {
+/* Refer to IS31 manual for these locations
+ *   driver
+ *   |  R location
+ *   |  |      G location
+ *   |  |      |      B location
+ *   |  |      |      | */
+    {0, C1_3,  C2_3,  C3_3},
+    {0, C1_4,  C2_4,  C3_4},
+    {0, C1_5,  C2_5,  C3_5},
+    {0, C1_11, C2_11, C3_11},
+    {0, C1_12, C2_12, C3_12},
+    {0, C1_13, C2_13, C3_13},
+    {1, C1_3,  C2_3,  C3_3},
+    {1, C1_4,  C2_4,  C3_4},
+    {1, C1_5,  C2_5,  C3_5},
+    {1, C1_11, C2_11, C3_11},
+    {1, C1_12, C2_12, C3_12},
+    {1, C1_13, C2_13, C3_13},
+
+    {0, C1_6,  C2_6,  C3_6},
+    {0, C1_7,  C2_7,  C3_7},
+    {0, C1_8,  C2_8,  C3_8},
+    {0, C1_14, C2_14, C3_14},
+    {0, C1_15, C2_15, C3_15},
+    {0, C1_16, C2_16, C3_16},
+    {1, C1_6,  C2_6,  C3_6},
+    {1, C1_7,  C2_7,  C3_7},
+    {1, C1_8,  C2_8,  C3_8},
+    {1, C1_14, C2_14, C3_14},
+    {1, C1_15, C2_15, C3_15},
+    {1, C1_16, C2_16, C3_16},
+
+    {0, C9_1,  C8_1,  C7_1},
+    {0, C9_2,  C8_2,  C7_2},
+    {0, C9_3,  C8_3,  C7_3},
+    {0, C9_9,  C8_9,  C7_9},
+    {0, C9_10, C8_10, C7_10},
+    {0, C9_11, C8_11, C7_11},
+    {1, C9_1,  C8_1,  C7_1},
+    {1, C9_2,  C8_2,  C7_2},
+    {1, C9_3,  C8_3,  C7_3},
+    {1, C9_9,  C8_9,  C7_9},
+    {1, C9_10, C8_10, C7_10},
+    {1, C9_11, C8_11, C7_11},
+
+    {0, C9_4,  C8_4,  C7_4},
+    {0, C9_5,  C8_5,  C7_5},
+    {0, C9_6,  C8_6,  C7_6},
+    {0, C9_12, C8_12, C7_12},
+    {0, C9_13, C8_13, C7_13},
+    {0, C9_14, C8_14, C7_14},
+    {1, C9_4,  C8_4,  C7_4},
+    {1, C9_5,  C8_5,  C7_5},
+    {1, C9_6,  C8_6,  C7_6},
+    {1, C9_12, C8_12, C7_12},
+    {1, C9_13, C8_13, C7_13},
+    {1, C9_14, C8_14, C7_14}
+};
+
+const rgb_led g_rgb_leds[DRIVER_LED_TOTAL] = {
+
+    /*{row | col << 4}
+      |             {x=0..224, y=0..64}
+      |              |                 modifier
+      |              |                 | */
+    {{0|(0<<4)},   {20.36*0, 21.33*0}, 1},
+    {{0|(1<<4)},   {20.36*1, 21.33*0}, 0},
+    {{0|(2<<4)},   {20.36*2, 21.33*0}, 0},
+    {{0|(3<<4)},   {20.36*3, 21.33*0}, 0},
+    {{0|(4<<4)},   {20.36*4, 21.33*0}, 0},
+    {{0|(5<<4)},   {20.36*5, 21.33*0}, 0},
+    {{0|(6<<4)},   {20.36*6, 21.33*0}, 0},
+    {{0|(7<<4)},   {20.36*7, 21.33*0}, 0},
+    {{0|(8<<4)},   {20.36*8, 21.33*0}, 0},
+    {{0|(9<<4)},   {20.36*9, 21.33*0}, 0},
+    {{0|(10<<4)},  {20.36*10,21.33*0}, 0},
+    {{0|(11<<4)},  {20.36*11,21.33*0}, 1},
+
+    {{1|(0<<4)},   {20.36*0, 21.33*1}, 1},
+    {{1|(1<<4)},   {20.36*1, 21.33*1}, 0},
+    {{1|(2<<4)},   {20.36*2, 21.33*1}, 0},
+    {{1|(3<<4)},   {20.36*3, 21.33*1}, 0},
+    {{1|(4<<4)},   {20.36*4, 21.33*1}, 0},
+    {{1|(5<<4)},   {20.36*5, 21.33*1}, 0},
+    {{1|(6<<4)},   {20.36*6, 21.33*1}, 0},
+    {{1|(7<<4)},   {20.36*7, 21.33*1}, 0},
+    {{1|(8<<4)},   {20.36*8, 21.33*1}, 0},
+    {{1|(9<<4)},   {20.36*9, 21.33*1}, 0},
+    {{1|(10<<4)},  {20.36*10,21.33*1}, 0},
+    {{1|(11<<4)},  {20.36*11,21.33*1}, 1},
+
+    {{2|(0<<4)},   {20.36*0, 21.33*2}, 1},
+    {{2|(1<<4)},   {20.36*1, 21.33*2}, 0},
+    {{2|(2<<4)},   {20.36*2, 21.33*2}, 0},
+    {{2|(3<<4)},   {20.36*3, 21.33*2}, 0},
+    {{2|(4<<4)},   {20.36*4, 21.33*2}, 0},
+    {{2|(5<<4)},   {20.36*5, 21.33*2}, 0},
+    {{2|(6<<4)},   {20.36*6, 21.33*2}, 0},
+    {{2|(7<<4)},   {20.36*7, 21.33*2}, 0},
+    {{2|(8<<4)},   {20.36*8, 21.33*2}, 0},
+    {{2|(9<<4)},   {20.36*9, 21.33*2}, 0},
+    {{2|(10<<4)},  {20.36*10,21.33*2}, 0},
+    {{2|(11<<4)},  {20.36*11,21.33*2}, 1},
+
+    {{3|(0<<4)},   {20.36*0, 21.33*3}, 1},
+    {{3|(1<<4)},   {20.36*1, 21.33*3}, 1},
+    {{3|(2<<4)},   {20.36*2, 21.33*3}, 1},
+    {{3|(3<<4)},   {20.36*3, 21.33*3}, 1},
+    {{3|(4<<4)},   {20.36*4, 21.33*3}, 1},
+    {{3|(5<<4)},   {20.36*5, 21.33*3}, 0},
+    {{3|(6<<4)},   {20.36*6, 21.33*3}, 0},
+    {{3|(7<<4)},   {20.36*7, 21.33*3}, 1},
+    {{3|(8<<4)},   {20.36*8, 21.33*3}, 1},
+    {{3|(9<<4)},   {20.36*9, 21.33*3}, 1},
+    {{3|(10<<4)},  {20.36*10,21.33*3}, 1},
+    {{3|(11<<4)},  {20.36*11,21.33*3}, 1}
+};
+#endif