Add a keymatrix_t type

This contains both the matrix number and key position, in preparation
for multi-matrix support

drivers/qwiic/qwiic_keyboard.c

@@ -80,7 +80,6 @@ void qwiic_keyboard_task(void) {
         #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];
@@ -88,7 +87,8 @@ void qwiic_keyboard_task(void) {
             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 },
+                  // Always use matrix 1 for remotes now
+                  .key = (keymatrix_t){.pos = (keypos_t){ .row = r, .col = c }, .matrix = 1},
                   .pressed = (matrix_row & ((qwiic_matrix_t)1<<c)),
                   .time = (timer_read() | 1) /* time should not be 0 */
                 });
@@ -190,13 +190,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 {
+uint16_t keymap_key_to_keycode(uint8_t layer, keymatrix_t key) {
+  if (key.matrix == 0) {
     // Read entire word (16bits)
-    return pgm_read_word(&keymaps[(layer)][(key.row)][(key.col)]);
+    return pgm_read_word(&keymaps[(layer)][(key.pos.row)][(key.pos.col)]);
+  } else {
+    return qwiic_keyboard_keymap[(layer)][(key.pos.row)][(key.pos.col)];
   }
 }

keyboards/planck/old_keymap_files/keymap_common.c

@@ -18,7 +18,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
 /* translates key to keycode */
-uint8_t keymap_key_to_keycode(uint8_t layer, keypos_t key)
+uint8_t keymap_key_to_keycode(uint8_t layer, keymatrix_t key)
 {
     return pgm_read_byte(&keymaps[(layer)][(key.row)][(key.col)]);
 }

quantum/keymap.h

@@ -44,7 +44,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "quantum_keycodes.h"
 
 // translates key to keycode
-uint16_t keymap_key_to_keycode(uint8_t layer, keypos_t key);
+uint16_t keymap_key_to_keycode(uint8_t layer, keymatrix_t key);
 
 // translates function id to action
 uint16_t keymap_function_id_to_action( uint16_t function_id );

quantum/keymap_common.c

@@ -38,7 +38,7 @@ extern keymap_config_t keymap_config;
 #include <inttypes.h>
 
 /* converts key to action */
-action_t action_for_key(uint8_t layer, keypos_t key)
+action_t action_for_key(uint8_t layer, keymatrix_t key)
 {
     // 16bit keycodes - important
     uint16_t keycode = keymap_key_to_keycode(layer, key);
@@ -184,10 +184,12 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt)
 
 // translates key to keycode
 __attribute__ ((weak))
-uint16_t keymap_key_to_keycode(uint8_t layer, keypos_t key)
+uint16_t keymap_key_to_keycode(uint8_t layer, keymatrix_t key)
 {
     // Read entire word (16bits)
-    return pgm_read_word(&keymaps[(layer)][(key.row)][(key.col)]);
+    // The default implmention does not have multiple matrix support
+    // and therfore it ignores the matrix field of the key
+    return pgm_read_word(&keymaps[(layer)][(key.pos.row)][(key.pos.col)]);
 }
 
 // translates function id to action

quantum/process_keycode/process_music.c

@@ -198,22 +198,23 @@ bool process_music(uint16_t keycode, keyrecord_t *record) {
       }
 
       uint8_t note = 36;
+      // Note: Multimatrix support is missing from this (it's probablly better to define it using keycodes)
       #ifdef MUSIC_MAP
         if (music_mode == MUSIC_MODE_CHROMATIC) {
-          note = music_starting_note + music_offset + 36 + music_map[record->event.key.row][record->event.key.col];
+          note = music_starting_note + music_offset + 36 + music_map[record->event.key.pos.row][record->event.key.pos.col];
         } else {
-          uint8_t position = music_map[record->event.key.row][record->event.key.col];
+          uint8_t position = music_map[record->event.key.pos.row][record->event.key.pos.col];
           note = music_starting_note + music_offset + 36 + SCALE[position % 12] + (position / 12)*12;
         }
       #else
         if (music_mode == MUSIC_MODE_CHROMATIC)
-          note = (music_starting_note + record->event.key.col + music_offset - 3)+12*(MATRIX_ROWS - record->event.key.row);
+          note = (music_starting_note + record->event.key.pos.col + music_offset - 3)+12*(MATRIX_ROWS - record->event.key.pos.row);
         else if (music_mode == MUSIC_MODE_GUITAR)
-          note = (music_starting_note + record->event.key.col + music_offset + 32)+5*(MATRIX_ROWS - record->event.key.row);
+          note = (music_starting_note + record->event.key.pos.col + music_offset + 32)+5*(MATRIX_ROWS - record->event.key.pos.row);
         else if (music_mode == MUSIC_MODE_VIOLIN)
-          note = (music_starting_note + record->event.key.col + music_offset + 32)+7*(MATRIX_ROWS - record->event.key.row);
+          note = (music_starting_note + record->event.key.pos.col + music_offset + 32)+7*(MATRIX_ROWS - record->event.key.pos.row);
         else if (music_mode == MUSIC_MODE_MAJOR)
-          note = (music_starting_note + SCALE[record->event.key.col + music_offset] - 3)+12*(MATRIX_ROWS - record->event.key.row);
+          note = (music_starting_note + SCALE[record->event.key.pos.col + music_offset] - 3)+12*(MATRIX_ROWS - record->event.key.pos.row);
         else
           note = music_starting_note;
       #endif

quantum/quantum.c

@@ -190,7 +190,7 @@ static bool grave_esc_was_shifted = false;
 bool process_record_quantum(keyrecord_t *record) {
 
   /* This gets the keycode from the key pressed */
-  keypos_t key = record->event.key;
+  keymatrix_t key = record->event.key;
   uint16_t keycode;
 
   #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS)

tests/layer_cache/test_layer_cache.cpp

@@ -34,16 +34,18 @@ namespace
 
 
   uint8_t read_cache(uint8_t col, uint8_t row) {
-    keypos_t key;
-    key.col = col;
-    key.row =  row;
+    keymatrix_t key;
+    key.pos.col = col;
+    key.pos.row =  row;
+    key.matrix = 0;
     return read_source_layers_cache(key);
   }
 
   void write_cache(uint8_t col, uint8_t row, uint8_t value) {
-    keypos_t key;
-    key.col = col;
-    key.row =  row;
+    keymatrix_t key;
+    key.pos.col = col;
+    key.pos.row = row;
+    key.matrix = 0;
     return update_source_layers_cache(key, value);
   }
 

tmk_core/common/action.c

@@ -892,7 +892,7 @@ void clear_keyboard_but_mods(void)
  *
  * FIXME: Needs documentation.
  */
-bool is_tap_key(keypos_t key)
+bool is_tap_key(keymatrix_t key)
 {
     action_t action = layer_switch_get_action(key);
 

tmk_core/common/action.h

@@ -50,7 +50,7 @@ typedef struct {
 void action_exec(keyevent_t event);
 
 /* action for key */
-action_t action_for_key(uint8_t layer, keypos_t key);
+action_t action_for_key(uint8_t layer, keymatrix_t key);
 
 /* macro */
 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt);
@@ -94,7 +94,7 @@ void unregister_mods(uint8_t mods);
 void clear_keyboard(void);
 void clear_keyboard_but_mods(void);
 void layer_switch(uint8_t new_layer);
-bool is_tap_key(keypos_t key);
+bool is_tap_key(keymatrix_t key);
 
 #ifndef NO_ACTION_TAPPING
 void process_record_tap_hint(keyrecord_t *record);

tmk_core/common/action_layer.c

@@ -223,9 +223,9 @@ void layer_debug(void)
 uint8_t source_layers_cache[(MATRIX_ROWS * MATRIX_COLS * MAX_LAYER_BITS + 7) / 8] = {0};
 static const uint8_t layer_cache_mask = (1u << MAX_LAYER_BITS) - 1;
 
-void update_source_layers_cache(keypos_t key, uint8_t layer)
+void update_source_layers_cache(keymatrix_t key, uint8_t layer)
 {
-  const uint16_t key_number = key.col + (key.row * MATRIX_COLS);
+  const uint16_t key_number = key.pos.col + (key.pos.row * MATRIX_COLS);
   const uint32_t bit_number = key_number * MAX_LAYER_BITS;
   const uint16_t byte_number = bit_number / 8;
   if (byte_number >= sizeof(source_layers_cache)) {
@@ -261,9 +261,9 @@ void update_source_layers_cache(keypos_t key, uint8_t layer)
   }
 }
 
-uint8_t read_source_layers_cache(keypos_t key)
+uint8_t read_source_layers_cache(keymatrix_t key)
 {
-  const uint16_t key_number = key.col + (key.row * MATRIX_COLS);
+  const uint16_t key_number = key.pos.col + (key.pos.row * MATRIX_COLS);
   const uint32_t bit_number = key_number * MAX_LAYER_BITS;
   const uint16_t byte_number = bit_number / 8;
   if (byte_number >= sizeof(source_layers_cache)) {
@@ -296,7 +296,7 @@ uint8_t read_source_layers_cache(keypos_t key)
  * when the layer is switched after the down event but before the up
  * event as they may get stuck otherwise.
  */
-action_t store_or_get_action(bool pressed, keypos_t key)
+action_t store_or_get_action(bool pressed, keymatrix_t key)
 {
 #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS)
     if (disable_action_cache) {
@@ -323,7 +323,7 @@ action_t store_or_get_action(bool pressed, keypos_t key)
  *
  * FIXME: Needs docs
  */
-int8_t layer_switch_get_layer(keypos_t key)
+int8_t layer_switch_get_layer(keymatrix_t key)
 {
 #ifndef NO_ACTION_LAYER
     action_t action;
@@ -350,7 +350,7 @@ int8_t layer_switch_get_layer(keypos_t key)
  *
  * FIXME: Needs docs
  */
-action_t layer_switch_get_action(keypos_t key)
+action_t layer_switch_get_action(keymatrix_t key)
 {
     return action_for_key(layer_switch_get_layer(key), key);
 }

tmk_core/common/action_layer.h

@@ -91,15 +91,15 @@ uint32_t layer_state_set_kb(uint32_t state);
 #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS)
 /* The number of bits needed to represent the layer number: log2(32). */
 #define MAX_LAYER_BITS 5
-void update_source_layers_cache(keypos_t key, uint8_t layer);
-uint8_t read_source_layers_cache(keypos_t key);
+void update_source_layers_cache(keymatrix_t key, uint8_t layer);
+uint8_t read_source_layers_cache(keymatrix_t key);
 #endif
-action_t store_or_get_action(bool pressed, keypos_t key);
+action_t store_or_get_action(bool pressed, keymatrix_t key);
 
 /* return the topmost non-transparent layer currently associated with key */
-int8_t layer_switch_get_layer(keypos_t key);
+int8_t layer_switch_get_layer(keymatrix_t key);
 
 /* return action depending on current layer status */
-action_t layer_switch_get_action(keypos_t key);
+action_t layer_switch_get_action(keymatrix_t key);
 
 #endif

tmk_core/common/bootmagic.c

@@ -116,7 +116,7 @@ static bool scan_keycode(uint8_t keycode)
         matrix_row_t matrix_row = matrix_get_row(r);
         for (uint8_t c = 0; c < MATRIX_COLS; c++) {
             if (matrix_row & ((matrix_row_t)1<<c)) {
-                if (keycode == keymap_key_to_keycode(0, (keypos_t){ .row = r, .col = c })) {
+                if (keycode == keymap_key_to_keycode(0, (keymatrix_t){ (keypos_t){.row = r, .col = c }, .matrix=0 })) {
                     return true;
                 }
             }

tmk_core/common/keyboard.c

@@ -238,7 +238,8 @@ void keyboard_task(void)
                 for (uint8_t c = 0; c < MATRIX_COLS; c++) {
                     if (matrix_change & ((matrix_row_t)1<<c)) {
                         action_exec((keyevent_t){
-                            .key = (keypos_t){ .row = r, .col = c },
+                            // The main matrix is always 0
+                            .key = (keymatrix_t){.pos = (keypos_t){ .row = r, .col = c }, .matrix = 0},
                             .pressed = (matrix_row & ((matrix_row_t)1<<c)),
                             .time = (timer_read() | 1) /* time should not be 0 */
                         });

tmk_core/common/keyboard.h

@@ -32,27 +32,33 @@ typedef struct {
     uint8_t row;
 } keypos_t;
 
+/* the key and matrix position */
+typedef struct {
+  keypos_t pos;
+  uint8_t matrix;
+} keymatrix_t;
+
 /* key event */
 typedef struct {
-    keypos_t key;
+    keymatrix_t    key;
     bool     pressed;
     uint16_t time;
 } keyevent_t;
 
-/* equivalent test of keypos_t */
-#define KEYEQ(keya, keyb)       ((keya).row == (keyb).row && (keya).col == (keyb).col)
+/* equivalent test of keymatrix_t */
+#define KEYEQ(keya, keyb)       (keya.pos.row == keyb.pos.row && keya.pos.col == keyb.pos.col && keya.matrix == keyb.matrix)
 
 /* Rules for No Event:
  * 1) (time == 0) to handle (keyevent_t){} as empty event
  * 2) Matrix(255, 255) to make TICK event available
  */
-static inline bool IS_NOEVENT(keyevent_t event) { return event.time == 0 || (event.key.row == 255 && event.key.col == 255); }
+static inline bool IS_NOEVENT(keyevent_t event) { return event.time == 0 || (event.key.pos.row == 255 && event.key.pos.col == 255); }
 static inline bool IS_PRESSED(keyevent_t event) { return (!IS_NOEVENT(event) && event.pressed); }
 static inline bool IS_RELEASED(keyevent_t event) { return (!IS_NOEVENT(event) && !event.pressed); }
 
 /* Tick event */
 #define TICK                    (keyevent_t){           \
-    .key = (keypos_t){ .row = 255, .col = 255 },           \
+    .key = (keymatrix_t){ .pos = (keypos_t){.row = 255, .col = 255}, .matrix = 0 },           \
     .pressed = false,                                   \
     .time = (timer_read() | 1)                          \
 }