Optimize matrix scanning (#343)

3 files changed, 213 insertions, 298 deletions

diff --git a/quantum/config_common.h b/quantum/config_common.h
index da53fce89..02f11d979 100644
--- a/quantum/config_common.h
+++ b/quantum/config_common.h
@@ -1,70 +1,74 @@
 #ifndef CONFIG_DEFINITIONS_H
 #define CONFIG_DEFINITIONS_H
 
-#define B0 0x20
-#define B1 0x21
-#define B2 0x22
-#define B3 0x23
-#define B4 0x24
-#define B5 0x25
-#define B6 0x26
-#define B7 0x27
-#define C0 0x30
-#define C1 0x31
-#define C2 0x32
-#define C3 0x33
-#define C4 0x34
-#define C5 0x35
-#define C6 0x36
-#define C7 0x37
-#define D0 0x40
-#define D1 0x41
-#define D2 0x42
-#define D3 0x43
-#define D4 0x44
-#define D5 0x45
-#define D6 0x46
-#define D7 0x47
-#define E0 0x50
-#define E1 0x51
-#define E2 0x52
-#define E3 0x53
-#define E4 0x54
-#define E5 0x55
-#define E6 0x56
-#define E7 0x57
-#define F0 0x60
-#define F1 0x61
-#define F2 0x62
-#define F3 0x63
-#define F4 0x64
-#define F5 0x65
-#define F6 0x66
-#define F7 0x67
-
-#define COL2ROW 0x0
-#define ROW2COL 0x1
+/* diode directions */
+#define COL2ROW 0
+#define ROW2COL 1
+/* I/O pins */
+#define B0 { .input_addr = 3, .bit = 0 }
+#define B1 { .input_addr = 3, .bit = 1 }
+#define B2 { .input_addr = 3, .bit = 2 }
+#define B3 { .input_addr = 3, .bit = 3 }
+#define B4 { .input_addr = 3, .bit = 4 }
+#define B5 { .input_addr = 3, .bit = 5 }
+#define B6 { .input_addr = 3, .bit = 6 }
+#define B7 { .input_addr = 3, .bit = 7 }
+#define C0 { .input_addr = 6, .bit = 0 }
+#define C1 { .input_addr = 6, .bit = 1 }
+#define C2 { .input_addr = 6, .bit = 2 }
+#define C3 { .input_addr = 6, .bit = 3 }
+#define C4 { .input_addr = 6, .bit = 4 }
+#define C5 { .input_addr = 6, .bit = 5 }
+#define C6 { .input_addr = 6, .bit = 6 }
+#define C7 { .input_addr = 6, .bit = 7 }
+#define D0 { .input_addr = 9, .bit = 0 }
+#define D1 { .input_addr = 9, .bit = 1 }
+#define D2 { .input_addr = 9, .bit = 2 }
+#define D3 { .input_addr = 9, .bit = 3 }
+#define D4 { .input_addr = 9, .bit = 4 }
+#define D5 { .input_addr = 9, .bit = 5 }
+#define D6 { .input_addr = 9, .bit = 6 }
+#define D7 { .input_addr = 9, .bit = 7 }
+#define E0 { .input_addr = 0xC, .bit = 0 }
+#define E1 { .input_addr = 0xC, .bit = 1 }
+#define E2 { .input_addr = 0xC, .bit = 2 }
+#define E3 { .input_addr = 0xC, .bit = 3 }
+#define E4 { .input_addr = 0xC, .bit = 4 }
+#define E5 { .input_addr = 0xC, .bit = 5 }
+#define E6 { .input_addr = 0xC, .bit = 6 }
+#define E7 { .input_addr = 0xC, .bit = 7 }
+#define F0 { .input_addr = 0xF, .bit = 0 }
+#define F1 { .input_addr = 0xF, .bit = 1 }
+#define F2 { .input_addr = 0xF, .bit = 2 }
+#define F3 { .input_addr = 0xF, .bit = 3 }
+#define F4 { .input_addr = 0xF, .bit = 4 }
+#define F5 { .input_addr = 0xF, .bit = 5 }
+#define F6 { .input_addr = 0xF, .bit = 6 }
+#define F7 { .input_addr = 0xF, .bit = 7 }
 
+/* USART configuration */
 #ifdef BLUETOOTH_ENABLE
-#ifdef __AVR_ATmega32U4__
-    #define SERIAL_UART_BAUD       9600
-    #define SERIAL_UART_DATA       UDR1
-    #define SERIAL_UART_UBRR       ((F_CPU/(16UL*SERIAL_UART_BAUD))-1)
-    #define SERIAL_UART_RXD_VECT   USART1_RX_vect
-    #define SERIAL_UART_TXD_READY  (UCSR1A&(1<<UDRE1))
-    #define SERIAL_UART_INIT()     do { \
-        UBRR1L = (uint8_t) SERIAL_UART_UBRR;       /* baud rate */ \
-        UBRR1H = (uint8_t) (SERIAL_UART_UBRR>>8);  /* baud rate */ \
-        UCSR1B = (1<<TXEN1);                /* TX: enable */ \
-        UCSR1C = (0<<UPM11) | (0<<UPM10) | /* parity: none(00), even(01), odd(11) */ \
-                 (0<<UCSZ12) | (1<<UCSZ11) | (1<<UCSZ10); /* data-8bit(011) */ \
-		sei(); \
-    } while(0)
-#else
-#   error "USART configuration is needed."
+#   ifdef __AVR_ATmega32U4__
+#      define SERIAL_UART_BAUD 9600
+#      define SERIAL_UART_DATA UDR1
+#      define SERIAL_UART_UBRR (F_CPU / (16UL * SERIAL_UART_BAUD) - 1)
+#      define SERIAL_UART_RXD_VECT USART1_RX_vect
+#      define SERIAL_UART_TXD_READY (UCSR1A & _BV(UDRE1))
+#      define SERIAL_UART_INIT() do { \
+            /* baud rate */ \
+            UBRR1L = SERIAL_UART_UBRR; \
+            /* baud rate */ \
+            UBRR1H = SERIAL_UART_UBRR >> 8; \
+            /* enable TX */ \
+            UCSR1B = _BV(TXEN1); \
+            /* 8-bit data */ \
+            UCSR1C = _BV(UCSZ11) | _BV(UCSZ10); \
+            sei(); \
+        } while(0)
+#   else
+#       error "USART configuration is needed."
 #endif
 
-
 // I'm fairly sure these aren't needed, but oh well - Jack
 
 /*
@@ -113,4 +117,3 @@
 #endif
 
 #endif
-
diff --git a/quantum/matrix.c b/quantum/matrix.c
index cab39e117..22126aa7a 100644
--- a/quantum/matrix.c
+++ b/quantum/matrix.c
@@ -1,6 +1,6 @@
 /*
-Copyright 2012 Jun Wako 
-Generated by planckkeyboard.com (2014 Jack Humbert)
+Copyright 2012 Jun Wako
+Copyright 2014 Jack Humbert
 
 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
@@ -15,300 +15,211 @@ 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 <util/delay.h>
+#include "wait.h"
 #include "print.h"
 #include "debug.h"
 #include "util.h"
 #include "matrix.h"
 
-#ifndef DEBOUNCE
-#   define DEBOUNCE 10
+#ifdef MATRIX_HAS_GHOST
+#   error "The universal matrix.c file cannot be used for this keyboard."
 #endif
-static uint8_t debouncing = DEBOUNCE;
 
-/* matrix state(1:on, 0:off) */
-static matrix_row_t matrix[MATRIX_ROWS];
-static matrix_row_t matrix_debouncing[MATRIX_ROWS];
-
-#if DIODE_DIRECTION == ROW2COL
-    static matrix_row_t matrix_reversed[MATRIX_COLS];
-    static matrix_row_t matrix_reversed_debouncing[MATRIX_COLS];
+#ifndef DEBOUNCING_DELAY
+#   define DEBOUNCING_DELAY 5
 #endif
 
-
-#if MATRIX_COLS > 16
-    #define SHIFTER 1UL
+static const io_pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
+static const io_pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
+/* matrix state */
+#if DIODE_DIRECTION == COL2ROW
+static matrix_row_t matrix[MATRIX_ROWS];
+static matrix_row_t debouncing_matrix[MATRIX_ROWS];
 #else
-    #define SHIFTER 1
+static matrix_col_t matrix[MATRIX_COLS];
+static matrix_col_t debouncing_matrix[MATRIX_COLS];
 #endif
+static int8_t debouncing_delay = -1;
 
+#if DIODE_DIRECTION == COL2ROW
+static void toggle_row(uint8_t row);
 static matrix_row_t read_cols(void);
-static void init_cols(void);
-static void unselect_rows(void);
-static void select_row(uint8_t row);
+#else
+static void toggle_col(uint8_t col);
+static matrix_col_t read_rows(void);
+#endif
 
 __attribute__ ((weak))
 void matrix_init_quantum(void) {
-
 }
 
 __attribute__ ((weak))
 void matrix_scan_quantum(void) {
-
 }
 
-inline
-uint8_t matrix_rows(void)
-{
+uint8_t matrix_rows(void) {
     return MATRIX_ROWS;
 }
 
-inline
-uint8_t matrix_cols(void)
-{
+uint8_t matrix_cols(void) {
     return MATRIX_COLS;
 }
 
-void matrix_init(void)
-{
-    // To use PORTF disable JTAG with writing JTD bit twice within four cycles.
-    MCUCR |= (1<<JTD);
-    MCUCR |= (1<<JTD);
-
-
-    // initialize row and col
-    unselect_rows();
-    init_cols();
-
-    // initialize matrix state: all keys off
-    for (uint8_t i=0; i < MATRIX_ROWS; i++) {
-        matrix[i] = 0;
-        matrix_debouncing[i] = 0;
+void matrix_init(void) {
+    /* frees PORTF by setting the JTD bit twice within four cycles */
+    MCUCR |= _BV(JTD);
+    MCUCR |= _BV(JTD);
+    /* initializes the I/O pins */
+#if DIODE_DIRECTION == COL2ROW
+    for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
+        /* DDRxn */
+        _SFR_IO8(row_pins[r].input_addr + 1) |= _BV(row_pins[r].bit);
+        toggle_row(r);
     }
-
+    for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
+        /* PORTxn */
+        _SFR_IO8(col_pins[c].input_addr + 2) |= _BV(col_pins[c].bit);
+    }
+#else
+    for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
+        /* DDRxn */
+        _SFR_IO8(col_pins[c].input_addr + 1) |= _BV(col_pins[c].bit);
+        toggle_col(c);
+    }
+    for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
+        /* PORTxn */
+        _SFR_IO8(row_pins[r].input_addr + 2) |= _BV(row_pins[r].bit);
+    }
+#endif
     matrix_init_quantum();
 }
 
-
-uint8_t matrix_scan(void)
-{
-
 #if DIODE_DIRECTION == COL2ROW
-    for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
-        select_row(i);
-        _delay_us(30);  // without this wait read unstable value.
-        matrix_row_t cols = read_cols();
-        if (matrix_debouncing[i] != cols) {
-            matrix_debouncing[i] = cols;
-            if (debouncing) {
-                debug("bounce!: "); debug_hex(debouncing); debug("\n");
-            }
-            debouncing = DEBOUNCE;
+uint8_t matrix_scan(void) {
+    for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
+        toggle_row(r);
+        matrix_row_t state = read_cols();
+        if (debouncing_matrix[r] != state) {
+            debouncing_matrix[r] = state;
+            debouncing_delay = DEBOUNCING_DELAY;
         }
-        unselect_rows();
+        toggle_row(r);
     }
-
-    if (debouncing) {
-        if (--debouncing) {
-            _delay_ms(1);
-        } else {
-            for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
-                matrix[i] = matrix_debouncing[i];
-            }
+    if (debouncing_delay >= 0) {
+        dprintf("Debouncing delay remaining: %X\n", debouncing_delay);
+        --debouncing_delay;
+        if (debouncing_delay >= 0) {
+            wait_ms(1);
         }
-    }
-#else
-    for (uint8_t i = 0; i < MATRIX_COLS; i++) {
-        select_row(i);
-        _delay_us(30);  // without this wait read unstable value.
-        matrix_row_t rows = read_cols();
-        if (matrix_reversed_debouncing[i] != rows) {
-            matrix_reversed_debouncing[i] = rows;
-            if (debouncing) {
-                debug("bounce!: "); debug_hex(debouncing); debug("\n");
+        else {
+            for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
+                matrix[r] = debouncing_matrix[r];
             }
-            debouncing = DEBOUNCE;
         }
-        unselect_rows();
     }
-
-    if (debouncing) {
-        if (--debouncing) {
-            _delay_ms(1);
-        } else {
-            for (uint8_t i = 0; i < MATRIX_COLS; i++) {
-                matrix_reversed[i] = matrix_reversed_debouncing[i];
-            }
-        }
-    }
-    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;
 }
 
-bool matrix_is_modified(void)
-{
-    if (debouncing) return false;
-    return true;
+static void toggle_row(uint8_t row) {
+    /* PINxn */
+    _SFR_IO8(row_pins[row].input_addr) = _BV(row_pins[row].bit);
 }
 
-inline
-bool matrix_is_on(uint8_t row, uint8_t col)
-{
-    return (matrix[row] & ((matrix_row_t)1<col));
+static matrix_row_t read_cols(void) {
+    matrix_row_t state = 0;
+    for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
+        /* PINxn */
+        if (!(_SFR_IO8(col_pins[c].input_addr) & _BV(col_pins[c].bit))) {
+            state |= (matrix_row_t)1 << c;
+        }
+    }
+    return state;
 }
 
-inline
-matrix_row_t matrix_get_row(uint8_t row)
-{
+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");
+#else
+uint8_t matrix_scan(void) {
+    for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
+        toggle_col(c);
+        matrix_col_t state = read_rows();
+        if (debouncing_matrix[c] != state) {
+            debouncing_matrix[c] = state;
+            debouncing_delay = DEBOUNCING_DELAY;
+        }
+        toggle_col(c);
     }
-}
-
-uint8_t matrix_key_count(void)
-{
-    uint8_t count = 0;
-    for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
-        count += bitpop16(matrix[i]);
+    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 c = MATRIX_COLS - 1; c >= 0; --c) {
+                matrix[c] = debouncing_matrix[c];
+            }
+        }
     }
-    return count;
+    matrix_scan_quantum();
+    return 1;
 }
 
-static void init_cols(void)
-{
-    int B = 0, C = 0, D = 0, E = 0, F = 0;
+static void toggle_col(uint8_t col) {
+    /* PINxn */
+    _SFR_IO8(col_pins[col].input_addr) = _BV(col_pins[col].bit);
+}
 
-#if DIODE_DIRECTION == COL2ROW
-    for(int x = 0; x < MATRIX_COLS; x++) {
-        int col = COLS[x];
-#else
-    for(int x = 0; x < MATRIX_ROWS; x++) {
-        int col = ROWS[x];
-#endif
-        if ((col & 0xF0) == 0x20) { 
-            B |= (1<<(col & 0x0F)); 
-        } else if ((col & 0xF0) == 0x30) { 
-            C |= (1<<(col & 0x0F)); 
-        } else if ((col & 0xF0) == 0x40) { 
-            D |= (1<<(col & 0x0F)); 
-        } else if ((col & 0xF0) == 0x50) { 
-            E |= (1<<(col & 0x0F)); 
-        } else if ((col & 0xF0) == 0x60) { 
-            F |= (1<<(col & 0x0F)); 
-        } 
+static matrix_col_t read_rows(void) {
+    matrix_col_t state = 0;
+    for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
+        /* PINxn */
+        if (!(_SFR_IO8(row_pins[r].input_addr) & _BV(row_pins[r].bit))) {
+            state |= (matrix_col_t)1 << r;
+        }
     }
-    DDRB &= ~(B); PORTB |= (B);
-    DDRC &= ~(C); PORTC |= (C); 
-    DDRD &= ~(D); PORTD |= (D);
-    DDRE &= ~(E); PORTE |= (E);
-    DDRF &= ~(F); PORTF |= (F);
+    return state;
 }
 
-static matrix_row_t read_cols(void)
-{
-    matrix_row_t result = 0;
+matrix_row_t matrix_get_row(uint8_t row) {
+    matrix_row_t state = 0;
+    matrix_col_t mask = (matrix_col_t)1 << row;
+    for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
+        if (matrix[c] & mask) {
+            state |= (matrix_row_t)1 << c;
+        }
+    }
+    return state;
+}
 
-#if DIODE_DIRECTION == COL2ROW
-    for(int x = 0; x < MATRIX_COLS; x++) {     
-        int col = COLS[x];
-#else
-    for(int x = 0; x < MATRIX_ROWS; x++) {
-        int col = ROWS[x];
 #endif
 
-        if ((col & 0xF0) == 0x20) { 
-            result |= (PINB&(1<<(col & 0x0F)) ? 0 : (SHIFTER<<x)); 
-        } else if ((col & 0xF0) == 0x30) { 
-            result |= (PINC&(1<<(col & 0x0F)) ? 0 : (SHIFTER<<x)); 
-        } else if ((col & 0xF0) == 0x40) { 
-            result |= (PIND&(1<<(col & 0x0F)) ? 0 : (SHIFTER<<x)); 
-        } else if ((col & 0xF0) == 0x50) { 
-            result |= (PINE&(1<<(col & 0x0F)) ? 0 : (SHIFTER<<x)); 
-        } else if ((col & 0xF0) == 0x60) { 
-            result |= (PINF&(1<<(col & 0x0F)) ? 0 : (SHIFTER<<x)); 
-        } 
-    }
-    return result;
+bool matrix_is_modified(void) {
+    if (debouncing_delay >= 0) return false;
+    return true;
 }
 
-static void unselect_rows(void)
-{
-    int B = 0, C = 0, D = 0, E = 0, F = 0;
+bool matrix_is_on(uint8_t row, uint8_t col) {
+    return matrix_get_row(row) & (matrix_row_t)1 << col;
+}
 
-#if DIODE_DIRECTION == COL2ROW
-    for(int x = 0; x < MATRIX_ROWS; x++) { 
-        int row = ROWS[x];
-#else
-    for(int x = 0; x < MATRIX_COLS; x++) { 
-        int row = COLS[x];
-#endif
-        if ((row & 0xF0) == 0x20) { 
-            B |= (1<<(row & 0x0F)); 
-        } else if ((row & 0xF0) == 0x30) { 
-            C |= (1<<(row & 0x0F)); 
-        } else if ((row & 0xF0) == 0x40) { 
-            D |= (1<<(row & 0x0F)); 
-        } else if ((row & 0xF0) == 0x50) { 
-            E |= (1<<(row & 0x0F)); 
-        } else if ((row & 0xF0) == 0x60) { 
-            F |= (1<<(row & 0x0F)); 
-        } 
+void matrix_print(void) {
+    dprintln("Human-readable matrix state:");
+    for (uint8_t r = 0; r < MATRIX_ROWS; r++) {
+        dprintf("State of row %X: %016b\n", r, bitrev16(matrix_get_row(r)));
     }
-    DDRB &= ~(B); PORTB |= (B);
-    DDRC &= ~(C); PORTC |= (C); 
-    DDRD &= ~(D); PORTD |= (D);
-    DDRE &= ~(E); PORTE |= (E);
-    DDRF &= ~(F); PORTF |= (F);
 }
 
-static void select_row(uint8_t row)
-{
-
-#if DIODE_DIRECTION == COL2ROW
-    int row_pin = ROWS[row];
-#else
-    int row_pin = COLS[row];
-#endif
-
-    if ((row_pin & 0xF0) == 0x20) { 
-        DDRB  |= (1<<(row_pin & 0x0F));
-        PORTB &= ~(1<<(row_pin & 0x0F));
-    } else if ((row_pin & 0xF0) == 0x30) { 
-        DDRC  |= (1<<(row_pin & 0x0F));
-        PORTC &= ~(1<<(row_pin & 0x0F));
-    } else if ((row_pin & 0xF0) == 0x40) { 
-        DDRD  |= (1<<(row_pin & 0x0F));
-        PORTD &= ~(1<<(row_pin & 0x0F));
-    } else if ((row_pin & 0xF0) == 0x50) { 
-        DDRE  |= (1<<(row_pin & 0x0F));
-        PORTE &= ~(1<<(row_pin & 0x0F));
-    } else if ((row_pin & 0xF0) == 0x60) { 
-        DDRF  |= (1<<(row_pin & 0x0F));
-        PORTF &= ~(1<<(row_pin & 0x0F));
-    }  
-}
\ No newline at end of file
+uint8_t matrix_key_count(void) {
+    uint8_t count = 0;
+    for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
+        count += bitpop16(matrix_get_row(r));
+    }
+    return count;
+}
diff --git a/quantum/template/config.h b/quantum/template/config.h
index e6fb7866c..cad3e3260 100644
--- a/quantum/template/config.h
+++ b/quantum/template/config.h
@@ -41,15 +41,16 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
  * DIODE_DIRECTION: COL2ROW = COL = Anode (+), ROW = Cathode (-, marked on diode)
  *                  ROW2COL = ROW = Anode (+), COL = Cathode (-, marked on diode)
  *
-*/ 
-#define COLS (int []){ F1, F0, B0 }
-#define ROWS (int []){ D0, D5 }
+*/
+#define MATRIX_ROW_PINS { D0, D5 }
+#define MATRIX_COL_PINS { F1, F0, B0 }
+#define UNUSED_PINS
 
 /* COL2ROW or ROW2COL */
 #define DIODE_DIRECTION COL2ROW
 
 /* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
-#define DEBOUNCE    5
+#define DEBOUNCING_DELAY 5
 
 /* define if matrix has ghost (lacks anti-ghosting diodes) */
 //#define MATRIX_HAS_GHOST
@@ -62,17 +63,17 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 /* Locking resynchronize hack */
 #define LOCKING_RESYNC_ENABLE
 
-/* 
+/*
  * Force NKRO
  *
- * Force NKRO (nKey Rollover) to be enabled by default, regardless of the saved 
+ * Force NKRO (nKey Rollover) to be enabled by default, regardless of the saved
  * state in the bootmagic EEPROM settings. (Note that NKRO must be enabled in the
  * makefile for this to work.)
  *
  * If forced on, NKRO can be disabled via magic key (default = LShift+RShift+N)
  * until the next keyboard reset.
  *
- * NKRO may prevent your keystrokes from being detected in the BIOS, but it is 
+ * NKRO may prevent your keystrokes from being detected in the BIOS, but it is
  * fully operational during normal computer usage.
  *
  * For a less heavy-handed approach, enable NKRO via magic key (LShift+RShift+N)
@@ -90,7 +91,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
  * the keyboard. They are best used in combination with the HID Listen program,
  * found here: https://www.pjrc.com/teensy/hid_listen.html
  *
- * The options below allow the magic key functionality to be changed. This is 
+ * The options below allow the magic key functionality to be changed. This is
  * useful if your keyboard/keypad is missing keys and you want magic key support.
  *
  */