DO NOT USE Merge branch 'master' into debounce_refactor

Merged, however now there are two debounce.h and debounce.c to mess around with and coalesce.
# Conflicts:
#	quantum/matrix.c

3 files changed, 3 insertions, 646 deletions

diff --git a/keyboards/miniaxe/config.h b/keyboards/miniaxe/config.h
index 2b732ca16f..7a68476a54 100644
--- a/keyboards/miniaxe/config.h
+++ b/keyboards/miniaxe/config.h
@@ -44,8 +44,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 // #define MATRIX_ROW_PINS { D0, D5 }
 // #define MATRIX_COL_PINS { F1, F0, B0 }
-#define NO_PIN 0xFF
-#define MATRIX_ROW_COL_PINS { \
+#define DIRECT_PINS { \
     { F1, E6, B0, B2, B3 }, \
     { F5, F0, B1, B7, D2 }, \
     { F6, F7, C7, D5, D3 }, \
@@ -54,7 +53,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define UNUSED_PINS
 
 /* COL2ROW, ROW2COL, or CUSTOM_MATRIX */
-#define DIODE_DIRECTION CUSTOM_MATRIX
+//#define DIODE_DIRECTION CUSTOM_MATRIX
 
 // #define BACKLIGHT_PIN B7
 // #define BACKLIGHT_BREATHING
diff --git a/keyboards/miniaxe/matrix.c b/keyboards/miniaxe/matrix.c
deleted file mode 100644
index 5fec1281df..0000000000
--- a/keyboards/miniaxe/matrix.c
+++ /dev/null
@@ -1,641 +0,0 @@
-/*
-Copyright 2012 Jun Wako <wakojun@gmail.com>
-
-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/>.
-*/
-
-/*
- * scan matrix
- */
-#include <stdint.h>
-#include <stdbool.h>
-#include <avr/io.h>
-#include "wait.h"
-#include "print.h"
-#include "debug.h"
-#include "util.h"
-#include "matrix.h"
-#include "split_util.h"
-#include "pro_micro.h"
-#include "config.h"
-#include "timer.h"
-#include "split_flags.h"
-
-#ifdef BACKLIGHT_ENABLE
-#   include "backlight.h"
-    extern backlight_config_t backlight_config;
-#endif
-
-#if defined(USE_I2C) || defined(EH)
-#  include "i2c.h"
-#else // USE_SERIAL
-#  include "serial.h"
-#endif
-
-#ifndef DEBOUNCING_DELAY
-#   define DEBOUNCING_DELAY 5
-#endif
-
-#if (DEBOUNCING_DELAY > 0)
-    static uint16_t debouncing_time;
-    static bool debouncing = false;
-#endif
-
-#if defined(USE_I2C) || defined(EH)
-
-#if (MATRIX_COLS <= 8)
-#    define print_matrix_header()  print("\nr/c 01234567\n")
-#    define print_matrix_row(row)  print_bin_reverse8(matrix_get_row(row))
-#    define matrix_bitpop(i)       bitpop(matrix[i])
-#    define ROW_SHIFTER ((uint8_t)1)
-#else
-#    error "Currently only supports 8 COLS"
-#endif
-
-#else // USE_SERIAL
-
-#if (MATRIX_COLS <= 8)
-#    define print_matrix_header()  print("\nr/c 01234567\n")
-#    define print_matrix_row(row)  print_bin_reverse8(matrix_get_row(row))
-#    define matrix_bitpop(i)       bitpop(matrix[i])
-#    define ROW_SHIFTER ((uint8_t)1)
-#elif (MATRIX_COLS <= 16)
-#    define print_matrix_header()  print("\nr/c 0123456789ABCDEF\n")
-#    define print_matrix_row(row)  print_bin_reverse16(matrix_get_row(row))
-#    define matrix_bitpop(i)       bitpop16(matrix[i])
-#    define ROW_SHIFTER ((uint16_t)1)
-#elif (MATRIX_COLS <= 32)
-#    define print_matrix_header()  print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n")
-#    define print_matrix_row(row)  print_bin_reverse32(matrix_get_row(row))
-#    define matrix_bitpop(i)       bitpop32(matrix[i])
-#    define ROW_SHIFTER  ((uint32_t)1)
-#endif
-
-#endif
-static matrix_row_t matrix_debouncing[MATRIX_ROWS];
-
-#define ERROR_DISCONNECT_COUNT 5
-
-#define ROWS_PER_HAND (MATRIX_ROWS/2)
-
-static uint8_t error_count = 0;
-
-#if ((DIODE_DIRECTION == COL2ROW) || (DIODE_DIRECTION == ROW2COL))
-static uint8_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
-static uint8_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
-#elif (DIODE_DIRECTION == CUSTOM_MATRIX)
-static uint8_t row_col_pins[MATRIX_ROWS][MATRIX_COLS] = MATRIX_ROW_COL_PINS;
-#endif
-
-/* matrix state(1:on, 0:off) */
-static matrix_row_t matrix[MATRIX_ROWS];
-static matrix_row_t matrix_debouncing[MATRIX_ROWS];
-
-#if (DIODE_DIRECTION == COL2ROW)
-    static void init_cols(void);
-    static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row);
-    static void unselect_rows(void);
-    static void select_row(uint8_t row);
-    static void unselect_row(uint8_t row);
-#elif (DIODE_DIRECTION == ROW2COL)
-    static void init_rows(void);
-    static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col);
-    static void unselect_cols(void);
-    static void unselect_col(uint8_t col);
-    static void select_col(uint8_t col);
-#elif (DIODE_DIRECTION == CUSTOM_MATRIX)
-    static void init_cols_rows(void);
-    static bool read_cols(matrix_row_t current_matrix[], uint8_t current_row);
-#endif
-
-__attribute__ ((weak))
-void matrix_init_kb(void) {
-    matrix_init_user();
-}
-
-__attribute__ ((weak))
-void matrix_scan_kb(void) {
-    matrix_scan_user();
-}
-
-__attribute__ ((weak))
-void matrix_init_user(void) {
-}
-
-__attribute__ ((weak))
-void matrix_scan_user(void) {
-}
-
-__attribute__ ((weak))
-void matrix_slave_scan_user(void) {
-}
-
-inline
-uint8_t matrix_rows(void)
-{
-    return MATRIX_ROWS;
-}
-
-inline
-uint8_t matrix_cols(void)
-{
-    return MATRIX_COLS;
-}
-
-void matrix_init(void)
-{
-#ifdef DISABLE_JTAG
-  // JTAG disable for PORT F. write JTD bit twice within four cycles.
-  MCUCR |= (1<<JTD);
-  MCUCR |= (1<<JTD);
-#endif
-
-    debug_enable = true;
-    debug_matrix = true;
-    debug_mouse = true;
-
-    // Set pinout for right half if pinout for that half is defined
-    if (!isLeftHand) {
-#ifdef MATRIX_ROW_PINS_RIGHT
-        const uint8_t row_pins_right[MATRIX_ROWS] = MATRIX_ROW_PINS_RIGHT;
-        for (uint8_t i = 0; i < MATRIX_ROWS; i++)
-            row_pins[i] = row_pins_right[i];
-#endif
-#ifdef MATRIX_COL_PINS_RIGHT
-        const uint8_t col_pins_right[MATRIX_COLS] = MATRIX_COL_PINS_RIGHT;
-        for (uint8_t i = 0; i < MATRIX_COLS; i++)
-            col_pins[i] = col_pins_right[i];
-#endif
-    }
-
-    // initialize row and col
-#if (DIODE_DIRECTION == COL2ROW)
-    unselect_rows();
-    init_cols();
-#elif (DIODE_DIRECTION == ROW2COL)
-    unselect_cols();
-    init_rows();
-#elif (DIODE_DIRECTION == CUSTOM_MATRIX)
-    init_cols_rows();
-#endif
-
-    // initialize matrix state: all keys off
-    for (uint8_t i=0; i < MATRIX_ROWS; i++) {
-        matrix[i] = 0;
-        matrix_debouncing[i] = 0;
-    }
-    
-    matrix_init_quantum();
-    
-}
-
-uint8_t _matrix_scan(void)
-{
-    int offset = isLeftHand ? 0 : (ROWS_PER_HAND);
-#if (DIODE_DIRECTION == COL2ROW)
-    // Set row, read cols
-    for (uint8_t current_row = 0; current_row < ROWS_PER_HAND; current_row++) {
-#       if (DEBOUNCING_DELAY > 0)
-            bool matrix_changed = read_cols_on_row(matrix_debouncing+offset, current_row);
-
-            if (matrix_changed) {
-                debouncing = true;
-                debouncing_time = timer_read();
-            }
-
-#       else
-            read_cols_on_row(matrix+offset, current_row);
-#       endif
-
-    }
-
-#elif (DIODE_DIRECTION == ROW2COL)
-    // Set col, read rows
-    for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++) {
-#       if (DEBOUNCING_DELAY > 0)
-            bool matrix_changed = read_rows_on_col(matrix_debouncing+offset, current_col);
-            if (matrix_changed) {
-                debouncing = true;
-                debouncing_time = timer_read();
-            }
-#       else
-             read_rows_on_col(matrix+offset, current_col);
-#       endif
-
-    }
-
-#elif (DIODE_DIRECTION == CUSTOM_MATRIX)
-    // Set row, read cols
-    for (uint8_t current_row = 0; current_row < ROWS_PER_HAND; current_row++) {
-#       if (DEBOUNCING_DELAY > 0)
-            bool matrix_changed = read_cols(matrix_debouncing+offset, current_row);
-            if (matrix_changed) {
-                debouncing = true;
-                debouncing_time = timer_read();
-            }
-#       else
-            read_cols(matrix+offset, current_row);
-#       endif
-    }
-#endif
-
-#   if (DEBOUNCING_DELAY > 0)
-        if (debouncing && (timer_elapsed(debouncing_time) > DEBOUNCING_DELAY)) {
-            for (uint8_t i = 0; i < ROWS_PER_HAND; i++) {
-                matrix[i+offset] = matrix_debouncing[i+offset];
-            }
-            debouncing = false;
-        }
-#   endif
-
-    return 1;
-}
-
-#if defined(USE_I2C) || defined(EH)
-
-// Get rows from other half over i2c
-int i2c_transaction(void) {
-    int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
-    int err = 0;
-    
-    // write backlight info
-    #ifdef BACKLIGHT_ENABLE
-        if (BACKLIT_DIRTY) {
-            err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE);
-            if (err) goto i2c_error;
-            
-            // Backlight location
-            err = i2c_master_write(I2C_BACKLIT_START);
-            if (err) goto i2c_error;
-            
-            // Write backlight 
-            i2c_master_write(get_backlight_level());
-            
-            BACKLIT_DIRTY = false;
-        }
-    #endif
-
-    err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE);
-    if (err) goto i2c_error;
-
-    // start of matrix stored at I2C_KEYMAP_START
-    err = i2c_master_write(I2C_KEYMAP_START);
-    if (err) goto i2c_error;
-
-    // Start read
-    err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_READ);
-    if (err) goto i2c_error;
-
-    if (!err) {
-        int i;
-        for (i = 0; i < ROWS_PER_HAND-1; ++i) {
-            matrix[slaveOffset+i] = i2c_master_read(I2C_ACK);
-        }
-        matrix[slaveOffset+i] = i2c_master_read(I2C_NACK);
-        i2c_master_stop();
-    } else {
-i2c_error: // the cable is disconnceted, or something else went wrong
-        i2c_reset_state();
-        return err;
-    }
-    
-    #ifdef RGBLIGHT_ENABLE
-        if (RGB_DIRTY) {
-            err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE);
-            if (err) goto i2c_error;
-            
-            // RGB Location
-            err = i2c_master_write(I2C_RGB_START);
-            if (err) goto i2c_error;
-            
-            uint32_t dword = eeconfig_read_rgblight();
-            
-            // Write RGB
-            err = i2c_master_write_data(&dword, 4);
-            if (err) goto i2c_error;
-            
-            RGB_DIRTY = false;
-            i2c_master_stop();
-        }
-    #endif
-
-    return 0;
-}
-
-#else // USE_SERIAL
-
-
-typedef struct _Serial_s2m_buffer_t {
-    // TODO: if MATRIX_COLS > 8 change to uint8_t packed_matrix[] for pack/unpack
-    matrix_row_t smatrix[ROWS_PER_HAND];
-} Serial_s2m_buffer_t;
-
-volatile Serial_s2m_buffer_t serial_s2m_buffer = {};
-volatile Serial_m2s_buffer_t serial_m2s_buffer = {};
-uint8_t volatile status0 = 0;
-
-SSTD_t transactions[] = {
-    { (uint8_t *)&status0,
-      sizeof(serial_m2s_buffer), (uint8_t *)&serial_m2s_buffer,
-      sizeof(serial_s2m_buffer), (uint8_t *)&serial_s2m_buffer
-  }
-};
-
-void serial_master_init(void)
-{ soft_serial_initiator_init(transactions, TID_LIMIT(transactions)); }
-
-void serial_slave_init(void)
-{ soft_serial_target_init(transactions, TID_LIMIT(transactions)); }
-
-int serial_transaction(void) {
-    int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
-
-    if (soft_serial_transaction()) {
-        return 1;
-    }
-
-    // TODO:  if MATRIX_COLS > 8 change to unpack()
-    for (int i = 0; i < ROWS_PER_HAND; ++i) {
-        matrix[slaveOffset+i] = serial_s2m_buffer.smatrix[i];
-    }
-    
-    #ifdef RGBLIGHT_ENABLE
-        // Code to send RGB over serial goes here (not implemented yet)
-    #endif
-    
-    #ifdef BACKLIGHT_ENABLE
-        // Write backlight level for slave to read
-        serial_m2s_buffer.backlight_level = backlight_config.enable ? backlight_config.level : 0;
-    #endif
-
-    return 0;
-}
-#endif
-
-uint8_t matrix_scan(void)
-{
-    uint8_t ret = _matrix_scan();
-
-#if defined(USE_I2C) || defined(EH)
-    if( i2c_transaction() ) {
-#else // USE_SERIAL
-    if( serial_transaction() ) {
-#endif
-
-        error_count++;
-
-        if (error_count > ERROR_DISCONNECT_COUNT) {
-            // reset other half if disconnected
-            int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
-            for (int i = 0; i < ROWS_PER_HAND; ++i) {
-                matrix[slaveOffset+i] = 0;
-            }
-        }
-    } else {
-        error_count = 0;
-    }
-    matrix_scan_quantum();
-    return ret;
-}
-
-void matrix_slave_scan(void) {
-    _matrix_scan();
-
-    int offset = (isLeftHand) ? 0 : ROWS_PER_HAND;
-
-#if defined(USE_I2C) || defined(EH)
-    for (int i = 0; i < ROWS_PER_HAND; ++i) {
-        i2c_slave_buffer[I2C_KEYMAP_START+i] = matrix[offset+i];
-    }   
-#else // USE_SERIAL
-    // TODO: if MATRIX_COLS > 8 change to pack()
-    for (int i = 0; i < ROWS_PER_HAND; ++i) {
-        serial_s2m_buffer.smatrix[i] = matrix[offset+i];
-    }
-#endif
-    matrix_slave_scan_user();
-}
-
-bool matrix_is_modified(void)
-{
-    if (debouncing) return false;
-    return true;
-}
-
-inline
-bool matrix_is_on(uint8_t row, uint8_t col)
-{
-    return (matrix[row] & ((matrix_row_t)1<<col));
-}
-
-inline
-matrix_row_t matrix_get_row(uint8_t row)
-{
-    return matrix[row];
-}
-
-void matrix_print(void)
-{
-    print("\nr/c 0123456789ABCDEF\n");
-    for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
-        phex(row); print(": ");
-        pbin_reverse16(matrix_get_row(row));
-        print("\n");
-    }
-}
-
-uint8_t matrix_key_count(void)
-{
-    uint8_t count = 0;
-    for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
-        count += bitpop16(matrix[i]);
-    }
-    return count;
-}
-
-#if (DIODE_DIRECTION == COL2ROW)
-
-static void init_cols(void)
-{
-    for(uint8_t x = 0; x < MATRIX_COLS; x++) {
-        uint8_t pin = col_pins[x];
-        _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
-        _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
-    }
-}
-
-static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
-{
-    // Store last value of row prior to reading
-    matrix_row_t last_row_value = current_matrix[current_row];
-
-    // Clear data in matrix row
-    current_matrix[current_row] = 0;
-
-    // Select row and wait for row selecton to stabilize
-    select_row(current_row);
-    wait_us(30);
-
-    // For each col...
-    for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
-
-        // Select the col pin to read (active low)
-        uint8_t pin = col_pins[col_index];
-        uint8_t pin_state = (_SFR_IO8(pin >> 4) & _BV(pin & 0xF));
-
-        // Populate the matrix row with the state of the col pin
-        current_matrix[current_row] |=  pin_state ? 0 : (ROW_SHIFTER << col_index);
-    }
-
-    // Unselect row
-    unselect_row(current_row);
-
-    return (last_row_value != current_matrix[current_row]);
-}
-
-static void select_row(uint8_t row)
-{
-    uint8_t pin = row_pins[row];
-    _SFR_IO8((pin >> 4) + 1) |=  _BV(pin & 0xF); // OUT
-    _SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); // LOW
-}
-
-static void unselect_row(uint8_t row)
-{
-    uint8_t pin = row_pins[row];
-    _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
-    _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
-}
-
-static void unselect_rows(void)
-{
-    for(uint8_t x = 0; x < ROWS_PER_HAND; x++) {
-        uint8_t pin = row_pins[x];
-        _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
-        _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
-    }
-}
-
-#elif (DIODE_DIRECTION == ROW2COL)
-
-static void init_rows(void)
-{
-    for(uint8_t x = 0; x < ROWS_PER_HAND; x++) {
-        uint8_t pin = row_pins[x];
-        _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
-        _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
-    }
-}
-
-static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
-{
-    bool matrix_changed = false;
-
-    // Select col and wait for col selecton to stabilize
-    select_col(current_col);
-    wait_us(30);
-
-    // For each row...
-    for(uint8_t row_index = 0; row_index < ROWS_PER_HAND; row_index++)
-    {
-
-        // Store last value of row prior to reading
-        matrix_row_t last_row_value = current_matrix[row_index];
-
-        // Check row pin state
-        if ((_SFR_IO8(row_pins[row_index] >> 4) & _BV(row_pins[row_index] & 0xF)) == 0)
-        {
-            // Pin LO, set col bit
-            current_matrix[row_index] |= (ROW_SHIFTER << current_col);
-        }
-        else
-        {
-            // Pin HI, clear col bit
-            current_matrix[row_index] &= ~(ROW_SHIFTER << current_col);
-        }
-
-        // Determine if the matrix changed state
-        if ((last_row_value != current_matrix[row_index]) && !(matrix_changed))
-        {
-            matrix_changed = true;
-        }
-    }
-
-    // Unselect col
-    unselect_col(current_col);
-
-    return matrix_changed;
-}
-
-static void select_col(uint8_t col)
-{
-    uint8_t pin = col_pins[col];
-    _SFR_IO8((pin >> 4) + 1) |=  _BV(pin & 0xF); // OUT
-    _SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); // LOW
-}
-
-static void unselect_col(uint8_t col)
-{
-    uint8_t pin = col_pins[col];
-    _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
-    _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
-}
-
-static void unselect_cols(void)
-{
-    for(uint8_t x = 0; x < MATRIX_COLS; x++) {
-        uint8_t pin = col_pins[x];
-        _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
-        _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
-    }
-}
-
-#elif (DIODE_DIRECTION == CUSTOM_MATRIX)
-
-static void init_cols_rows(void)
-{
-    for(int row = 0; row < MATRIX_ROWS; row++) {
-        for(int col = 0; col < MATRIX_COLS; col++) {
-            uint8_t pin = row_col_pins[row][col];
-            if(pin == NO_PIN) {
-                continue;
-            }
-            // DDxn set 0 for input
-            _SFR_IO8((pin >> 4) + 1) &=  ~_BV(pin & 0xF);
-            // PORTxn set 1 for input/pullup
-            _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF);
-        }
-    }
-}
-
-static bool read_cols(matrix_row_t current_matrix[], uint8_t current_row)
-{
-    matrix_row_t last_row_value = current_matrix[current_row];
-    current_matrix[current_row] = 0;
-
-    for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
-        uint8_t pin = row_col_pins[current_row][col_index];
-        if(pin == NO_PIN) {
-            current_matrix[current_row] |= 0;
-        }
-        else {
-            uint8_t pin_state = (_SFR_IO8(pin >> 4) & _BV(pin & 0xF));
-            current_matrix[current_row] |= pin_state ? 0 : (ROW_SHIFTER << col_index);
-        }
-    }
-
-    return (last_row_value != current_matrix[current_row]);
-}
-
-#endif
diff --git a/keyboards/miniaxe/rules.mk b/keyboards/miniaxe/rules.mk
index 96e27686b8..2f56a907ba 100644
--- a/keyboards/miniaxe/rules.mk
+++ b/keyboards/miniaxe/rules.mk
@@ -1,4 +1,3 @@
-SRC += matrix.c
 
 # MCU name
 #MCU = at90usb1286
@@ -83,6 +82,6 @@ FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
 HD44780_ENABLE = no 		# Enable support for HD44780 based LCDs (+400)
 
 DEBUG_ENABLE = no
-CUSTOM_MATRIX = yes         # Use custom matrix code 
+CUSTOM_MATRIX = no         # Use custom matrix code
 SPLIT_KEYBOARD = yes        # Use shared split_common code