reverts #343 for the most part (#474)

quantum/matrix.c

@@ -26,32 +26,46 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "util.h"
 #include "matrix.h"
 
-#ifdef MATRIX_HAS_GHOST
+/* Set 0 if debouncing isn't needed */
-#   error "The universal matrix.c file cannot be used for this keyboard."
+/*
-#endif
+ * This constant define not debouncing time in msecs, but amount of matrix
+ * scan loops which should be made to get stable debounced results.
+ *
+ * On Ergodox matrix scan rate is relatively low, because of slow I2C.
+ * Now it's only 317 scans/second, or about 3.15 msec/scan.
+ * According to Cherry specs, debouncing time is 5 msec.
+ *
+ * And so, there is no sense to have DEBOUNCE higher than 2.
+ */
 
 #ifndef DEBOUNCING_DELAY
 #   define DEBOUNCING_DELAY 5
 #endif
+static uint8_t debouncing = DEBOUNCING_DELAY;
 
 static const uint8_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
 static const uint8_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
-/* matrix state */
+
-#if DIODE_DIRECTION == COL2ROW
+/* matrix state(1:on, 0:off) */
 static matrix_row_t matrix[MATRIX_ROWS];
-#else
+static matrix_row_t matrix_debouncing[MATRIX_ROWS];
-static matrix_col_t matrix[MATRIX_COLS];
+
+#if DIODE_DIRECTION == ROW2COL
+    static matrix_row_t matrix_reversed[MATRIX_COLS];
+    static matrix_row_t matrix_reversed_debouncing[MATRIX_COLS];
 #endif
-static int8_t debouncing_delay = -1;
 
-#if DIODE_DIRECTION == COL2ROW
+#if MATRIX_COLS > 16
-static void toggle_row(uint8_t row);
+    #define SHIFTER 1UL
-static matrix_row_t read_cols(void);
 #else
-static void toggle_col(uint8_t col);
+    #define SHIFTER 1
-static matrix_col_t read_rows(void);
 #endif
 
+static matrix_row_t read_cols(void);
+static void init_cols(void);
+static void unselect_rows(void);
+static void select_row(uint8_t row);
+
 __attribute__ ((weak))
 void matrix_init_quantum(void) {
     matrix_init_kb();
@@ -80,10 +94,12 @@ __attribute__ ((weak))
 void matrix_scan_user(void) {
 }
 
+inline
 uint8_t matrix_rows(void) {
     return MATRIX_ROWS;
 }
 
+inline
 uint8_t matrix_cols(void) {
     return MATRIX_COLS;
 }
@@ -113,161 +129,179 @@ uint8_t matrix_cols(void) {
 // }
 
 void matrix_init(void) {
-    /* frees PORTF by setting the JTD bit twice within four cycles */
+    // To use PORTF disable JTAG with writing JTD bit twice within four cycles.
     #ifdef __AVR_ATmega32U4__
         MCUCR |= _BV(JTD);
         MCUCR |= _BV(JTD);
     #endif
-    /* initializes the I/O pins */
+
-#if DIODE_DIRECTION == COL2ROW
+    // initialize row and col
-    for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
+    unselect_rows();
-        /* DDRxn */
+    init_cols();
-        _SFR_IO8((row_pins[r] >> 4) + 1) |= _BV(row_pins[r] & 0xF);
+
-        toggle_row(r);
+    // initialize matrix state: all keys off
-    }
+    for (uint8_t i=0; i < MATRIX_ROWS; i++) {
-    for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
+        matrix[i] = 0;
-        /* PORTxn */
+        matrix_debouncing[i] = 0;
-        _SFR_IO8((col_pins[c] >> 4) + 2) |= _BV(col_pins[c] & 0xF);
-    }
-#else
-    for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
-        /* DDRxn */
-        _SFR_IO8((col_pins[c] >> 4) + 1) |= _BV(col_pins[c] & 0xF);
-        toggle_col(c);
-    }
-    for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
-        /* PORTxn */
-        _SFR_IO8((row_pins[r] >> 4) + 2) |= _BV(row_pins[r] & 0xF);
     }
-#endif
+
     matrix_init_quantum();
 }
 
+uint8_t matrix_scan(void)
+{
+
 #if DIODE_DIRECTION == COL2ROW
-uint8_t matrix_scan(void) {
+    for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
-    static matrix_row_t debouncing_matrix[MATRIX_ROWS];
+        select_row(i);
-    for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
+        wait_us(30);  // without this wait read unstable value.
-        toggle_row(r);
+        matrix_row_t cols = read_cols();
-        matrix_row_t state = read_cols();
+        if (matrix_debouncing[i] != cols) {
-        if (debouncing_matrix[r] != state) {
+            matrix_debouncing[i] = cols;
-            debouncing_matrix[r] = state;
+            if (debouncing) {
-            debouncing_delay = DEBOUNCING_DELAY;
+                debug("bounce!: "); debug_hex(debouncing); debug("\n");
-        }
-        toggle_row(r);
-    }
-    if (debouncing_delay >= 0) {
-        dprintf("Debouncing delay remaining: %X\n", debouncing_delay);
-        --debouncing_delay;
-        if (debouncing_delay >= 0) {
-            wait_ms(1);
-        }
-        else {
-            for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
-                matrix[r] = debouncing_matrix[r];
             }
+            debouncing = DEBOUNCING_DELAY;
         }
+        unselect_rows();
     }
-    matrix_scan_quantum();
-    return 1;
-}
-
-static void toggle_row(uint8_t row) {
-    /* PINxn */
-    _SFR_IO8((row_pins[row] >> 4)) = _BV(row_pins[row] & 0xF);
-}
 
-static matrix_row_t read_cols(void) {
+    if (debouncing) {
-    matrix_row_t state = 0;
+        if (--debouncing) {
-    for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
+            wait_us(1);
-        /* PINxn */
+        } else {
-        if (!(_SFR_IO8((col_pins[c] >> 4)) & _BV(col_pins[c] & 0xF))) {
+            for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
-            state |= (matrix_row_t)1 << c;
+                matrix[i] = matrix_debouncing[i];
+            }
         }
     }
-    return state;
-}
-
-matrix_row_t matrix_get_row(uint8_t row) {
-    return matrix[row];
-}
-
 #else
-uint8_t matrix_scan(void) {
+    for (uint8_t i = 0; i < MATRIX_COLS; i++) {
-    static matrix_col_t debouncing_matrix[MATRIX_COLS];
+        select_row(i);
-    for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
+        wait_us(30);  // without this wait read unstable value.
-        toggle_col(c);
+        matrix_row_t rows = read_cols();
-        matrix_col_t state = read_rows();
+        if (matrix_reversed_debouncing[i] != rows) {
-        if (debouncing_matrix[c] != state) {
+            matrix_reversed_debouncing[i] = rows;
-            debouncing_matrix[c] = state;
+            if (debouncing) {
-            debouncing_delay = DEBOUNCING_DELAY;
+                debug("bounce!: "); debug_hex(debouncing); debug("\n");
+            }
+            debouncing = DEBOUNCING_DELAY;
         }
-        toggle_col(c);
+        unselect_rows();
     }
-    if (debouncing_delay >= 0) {
+
-        dprintf("Debouncing delay remaining: %X\n", debouncing_delay);
+    if (debouncing) {
-        --debouncing_delay;
+        if (--debouncing) {
-        if (debouncing_delay >= 0) {
+            wait_us(1);
-            wait_ms(1);
+        } else {
-        }
+            for (uint8_t i = 0; i < MATRIX_COLS; i++) {
-        else {
+                matrix_reversed[i] = matrix_reversed_debouncing[i];
-            for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
-                matrix[c] = debouncing_matrix[c];
             }
         }
     }
+    for (uint8_t y = 0; y < MATRIX_ROWS; y++) {
+        matrix_row_t row = 0;
+        for (uint8_t x = 0; x < MATRIX_COLS; x++) {
+            row |= ((matrix_reversed[x] & (1<<y)) >> y) << x;
+        }
+        matrix[y] = row;
+    }
+#endif
+
     matrix_scan_quantum();
+
     return 1;
 }
 
-static void toggle_col(uint8_t col) {
+bool matrix_is_modified(void)
-    /* PINxn */
+{
-    _SFR_IO8((col_pins[col] >> 4)) = _BV(col_pins[col] & 0xF);
+    if (debouncing) return false;
+    return true;
 }
 
-static matrix_col_t read_rows(void) {
+inline
-    matrix_col_t state = 0;
+bool matrix_is_on(uint8_t row, uint8_t col)
-    for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
+{
-        /* PINxn */
+    return (matrix[row] & ((matrix_row_t)1<col));
-        if (!(_SFR_IO8((row_pins[r] >> 4)) & _BV(row_pins[r] & 0xF))) {
+}
-            state |= (matrix_col_t)1 << r;
+
-        }
+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");
     }
-    return state;
 }
 
-matrix_row_t matrix_get_row(uint8_t row) {
+uint8_t matrix_key_count(void)
-    matrix_row_t state = 0;
+{
-    matrix_col_t mask = (matrix_col_t)1 << row;
+    uint8_t count = 0;
-    for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
+    for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
-        if (matrix[c] & mask) {
+        count += bitpop16(matrix[i]);
-            state |= (matrix_row_t)1 << c;
-        }
     }
-    return state;
+    return count;
 }
 
+static void init_cols(void)
+{
+#if DIODE_DIRECTION == COL2ROW
+    for(int x = 0; x < MATRIX_COLS; x++) {
+        int pin = col_pins[x];
+#else
+    for(int x = 0; x < MATRIX_ROWS; x++) {
+        int pin = row_pins[x];
 #endif
-
+        _SFR_IO8((pin >> 4) + 1) &=  ~_BV(pin & 0xF);
-bool matrix_is_modified(void) {
+        _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF);
-    if (debouncing_delay >= 0) return false;
+    }
-    return true;
 }
 
-bool matrix_is_on(uint8_t row, uint8_t col) {
+static matrix_row_t read_cols(void)
-    return matrix_get_row(row) & (matrix_row_t)1 << col;
+{
-}
+    matrix_row_t result = 0;
 
-void matrix_print(void) {
+#if DIODE_DIRECTION == COL2ROW
-    dprintln("Human-readable matrix state:");
+    for(int x = 0; x < MATRIX_COLS; x++) {     
-    for (uint8_t r = 0; r < MATRIX_ROWS; r++) {
+        int pin = col_pins[x];
-        dprintf("State of row %X: %016b\n", r, bitrev16(matrix_get_row(r)));
+#else
+    for(int x = 0; x < MATRIX_ROWS; x++) {
+        int pin = row_pins[x];
+#endif
+        result |= (_SFR_IO8(pin >> 4) & _BV(pin & 0xF)) ? 0 : (SHIFTER << x);
     }
+    return result;
 }
 
-uint8_t matrix_key_count(void) {
+static void unselect_rows(void)
-    uint8_t count = 0;
+{
-    for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
+#if DIODE_DIRECTION == COL2ROW
-        count += bitpop16(matrix_get_row(r));
+    for(int x = 0; x < MATRIX_ROWS; x++) { 
+        int pin = row_pins[x];
+#else
+    for(int x = 0; x < MATRIX_COLS; x++) { 
+        int pin = col_pins[x];
+#endif
+        _SFR_IO8((pin >> 4) + 1) &=  ~_BV(pin & 0xF);
+        _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF);
     }
-    return count;
+}
+
+static void select_row(uint8_t row)
+{
+
+#if DIODE_DIRECTION == COL2ROW
+    int pin = row_pins[row];
+#else
+    int pin = col_pins[row];
+#endif
+    _SFR_IO8((pin >> 4) + 1) |=  _BV(pin & 0xF);
+    _SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF);
 }

tmk_core/common/avr/suspend.c

@@ -114,8 +114,10 @@ bool suspend_wakeup_condition(void)
     matrix_power_up();
     matrix_scan();
     matrix_power_down();
-    if (matrix_key_count()) return true;
+    for (uint8_t r = 0; r < MATRIX_ROWS; r++) {
-    return false;
+        if (matrix_get_row(r)) return true;
+    }
+     return false;
 }
 
 // run immediately after wakeup

tmk_core/common/bootmagic.c

@@ -106,13 +106,15 @@ void bootmagic(void)
     }
 }
 
-static bool scan_keycode(uint8_t keycode) {
+static bool scan_keycode(uint8_t keycode)
-    for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
+{
+    for (uint8_t r = 0; r < MATRIX_ROWS; r++) {
         matrix_row_t matrix_row = matrix_get_row(r);
-        for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
+        for (uint8_t c = 0; c < MATRIX_COLS; c++) {
-            if (matrix_row & (matrix_row_t)1 << c) {
+            if (matrix_row & ((matrix_row_t)1<<c)) {
-                keypos_t key = (keypos_t){ .row = r, .col = c };
+                if (keycode == keymap_key_to_keycode(0, (keypos_t){ .row = r, .col = c })) {
-                if (keycode == keymap_key_to_keycode(0, key)) return true;
+                    return true;
+                }
             }
         }
     }
@@ -124,4 +126,4 @@ bool bootmagic_scan_keycode(uint8_t keycode)
     if (!scan_keycode(BOOTMAGIC_KEY_SALT)) return false;
 
     return scan_keycode(keycode);
-}
+}

tmk_core/common/keyboard.c

@@ -51,17 +51,20 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #endif
 
 #ifdef MATRIX_HAS_GHOST
-static bool is_row_ghosting(uint8_t row){
+static bool has_ghost_in_row(uint8_t row)
-    matrix_row_t state = matrix_get_row(row);
+{
-    /* no ghosting happens when only one key in the row is pressed */
+    matrix_row_t matrix_row = matrix_get_row(row);
-    if (!(state - 1 & state)) return false;
+    // No ghost exists when less than 2 keys are down on the row
-    /* ghosting occurs when two keys in the same column are pressed */
+    if (((matrix_row - 1) & matrix_row) == 0)
-    for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
+        return false;
-        if (r != row && matrix_get_row(r) & state) return true;
+
+    // Ghost occurs when the row shares column line with other row
+    for (uint8_t i=0; i < MATRIX_ROWS; i++) {
+        if (i != row && (matrix_get_row(i) & matrix_row))
+            return true;
     }
     return false;
 }
-
 #endif
 
 __attribute__ ((weak))
@@ -100,72 +103,86 @@ void keyboard_init(void) {
 #endif
 }
 
-/* does routine keyboard jobs */
+/*
-void keyboard_task(void) {
+ * Do keyboard routine jobs: scan mantrix, light LEDs, ...
-    static uint8_t led_status;
+ * This is repeatedly called as fast as possible.
+ */
+void keyboard_task(void)
+{
+    static matrix_row_t matrix_prev[MATRIX_ROWS];
+#ifdef MATRIX_HAS_GHOST
+    static matrix_row_t matrix_ghost[MATRIX_ROWS];
+#endif
+    static uint8_t led_status = 0;
+    matrix_row_t matrix_row = 0;
+    matrix_row_t matrix_change = 0;
+
     matrix_scan();
-    for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
+    for (uint8_t r = 0; r < MATRIX_ROWS; r++) {
-        static matrix_row_t previous_matrix[MATRIX_ROWS];
+        matrix_row = matrix_get_row(r);
-        matrix_row_t state = matrix_get_row(r);
+        matrix_change = matrix_row ^ matrix_prev[r];
-        matrix_row_t changes = state ^ previous_matrix[r];
+        if (matrix_change) {
-        if (changes) {
 #ifdef MATRIX_HAS_GHOST
-            static matrix_row_t deghosting_matrix[MATRIX_ROWS];
+            if (has_ghost_in_row(r)) {
-            if (is_row_ghosting(r)) {
+                /* Keep track of whether ghosted status has changed for
-                /* debugs the deghosting mechanism */
+                 * debugging. But don't update matrix_prev until un-ghosted, or
-                /* doesn't update previous_matrix until the ghosting has stopped
+                 * the last key would be lost.
-                 * in order to prevent the last key from being lost
                  */
-                if (debug_matrix && deghosting_matrix[r] != state) {
+                if (debug_matrix && matrix_ghost[r] != matrix_row) {
                     matrix_print();
                 }
-                deghosting_matrix[r] = state;
+                matrix_ghost[r] = matrix_row;
                 continue;
             }
-            deghosting_matrix[r] = state;
+            matrix_ghost[r] = matrix_row;
 #endif
             if (debug_matrix) matrix_print();
-            for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
+            for (uint8_t c = 0; c < MATRIX_COLS; c++) {
-                matrix_row_t mask = (matrix_row_t)1 << c;
+                if (matrix_change & ((matrix_row_t)1<<c)) {
-                if (changes & mask) {
+                    action_exec((keyevent_t){
-                    keyevent_t event;
+                        .key = (keypos_t){ .row = r, .col = c },
-                    event.key = (keypos_t){ .row = r, .col = c };
+                        .pressed = (matrix_row & ((matrix_row_t)1<<c)),
-                    event.pressed = state & mask;
+                        .time = (timer_read() | 1) /* time should not be 0 */
-                    /* the time should not be 0 */
+                    });
-                    event.time = timer_read() | 1;
+                    // record a processed key
-                    action_exec(event);
+                    matrix_prev[r] ^= ((matrix_row_t)1<<c);
-                    /* records the processed key event */
+                    // process a key per task call
-                    previous_matrix[r] ^= mask;
+                    goto MATRIX_LOOP_END;
-                    /* processes one key event per call */
-                    goto event_processed;
                 }
             }
         }
     }
-    /* sends tick events when the keyboard is idle */
+    // call with pseudo tick event when no real key event.
     action_exec(TICK);
-event_processed:
+
+MATRIX_LOOP_END:
+
 #ifdef MOUSEKEY_ENABLE
-    /* repeats and accelerates the mouse keys */
+    // mousekey repeat & acceleration
     mousekey_task();
 #endif
+
 #ifdef PS2_MOUSE_ENABLE
     ps2_mouse_task();
 #endif
+
 #ifdef SERIAL_MOUSE_ENABLE
-    serial_mouse_task();
+        serial_mouse_task();
 #endif
+
 #ifdef ADB_MOUSE_ENABLE
-    adb_mouse_task();
+        adb_mouse_task();
 #endif
-    /* updates the LEDs */
+
+    // update LED
     if (led_status != host_keyboard_leds()) {
         led_status = host_keyboard_leds();
         keyboard_set_leds(led_status);
     }
 }
 
-void keyboard_set_leds(uint8_t leds) {
+void keyboard_set_leds(uint8_t leds)
-    if (debug_keyboard) dprintf("Keyboard LEDs state: %x\n", leds);
+{
+    if (debug_keyboard) { debug("keyboard_set_led: "); debug_hex8(leds); debug("\n"); }
     led_set(leds);
 }

tmk_core/common/matrix.h

@@ -20,59 +20,48 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include <stdint.h>
 #include <stdbool.h>
 
-#if MATRIX_COLS <= 8
+
-typedef uint8_t matrix_row_t;
+#if (MATRIX_COLS <= 8)
-#elif MATRIX_COLS <= 16
+typedef  uint8_t    matrix_row_t;
-typedef uint16_t matrix_row_t;
+#elif (MATRIX_COLS <= 16)
-#elif MATRIX_COLS <= 32
+typedef  uint16_t   matrix_row_t;
-typedef uint32_t matrix_row_t;
+#elif (MATRIX_COLS <= 32)
+typedef  uint32_t   matrix_row_t;
 #else
-#   error "There are too many columns."
+#error "MATRIX_COLS: invalid value"
 #endif
 
-#if DIODE_DIRECTION == ROW2COL
+#define MATRIX_IS_ON(row, col)  (matrix_get_row(row) && (1<<col))
-#   if MATRIX_ROWS <= 8
-typedef uint8_t matrix_col_t;
-#   elif MATRIX_ROWS <= 16
-typedef uint16_t matrix_col_t;
-#   elif MATRIX_ROWS <= 32
-typedef uint32_t matrix_col_t;
-#   else
-#       error "There are too many rows."
-#   endif
-#endif
 
-typedef struct {
-    uint8_t input_addr:4;
-    uint8_t bit:4;
-} io_pin_t;
 
 #ifdef __cplusplus
 extern "C" {
 #endif
-/* counts the number of rows in the matrix */
+
+/* number of matrix rows */
 uint8_t matrix_rows(void);
-/* counts the number of columns in the matrix */
+/* number of matrix columns */
 uint8_t matrix_cols(void);
-/* sets up the matrix before matrix_init */
+/* should be called at early stage of startup before matrix_init.(optional) */
 void matrix_setup(void);
-/* intializes the matrix */
+/* intialize matrix for scaning. */
 void matrix_init(void);
-/* scans the entire matrix */
+/* scan all key states on matrix */
 uint8_t matrix_scan(void);
-/* checks if the matrix has been modified */
+/* whether modified from previous scan. used after matrix_scan. */
 bool matrix_is_modified(void) __attribute__ ((deprecated));
-/* checks if a key is pressed */
+/* whether a swtich is on */
 bool matrix_is_on(uint8_t row, uint8_t col);
-/* inspects the state of a row in the matrix */
+/* matrix state on row */
 matrix_row_t matrix_get_row(uint8_t row);
-/* prints the matrix for debugging */
+/* print matrix for debug */
 void matrix_print(void);
-/* counts the total number of keys pressed */
+
-uint8_t matrix_key_count(void);
+
-/* controls power to the matrix */
+/* power control */
 void matrix_power_up(void);
 void matrix_power_down(void);
+
 /* executes code for Quantum */
 void matrix_init_quantum(void);
 void matrix_scan_quantum(void);