g1smo
/
qmk_firmware
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'jackhumbert/master' into patch-1

daktil_thumb_popravljen
Josh Colbeck 2016-07-04 15:41:58 -05:00
parent 497b92c3bd 9e01b219f3
commit a5fb2b58a5
8 changed files with 278 additions and 240 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
doc/keycode.txt
View File

@ -62,7 +62,7 @@ KC_NONUS_HASH KC_NUHS 32 Keyboard Non-US # and ~
KC_SCOLON KC_SCLN 33 Keyboard ; and :
KC_QUOTE KC_QUOT 34 Keyboard ‘ and “
KC_GRAVE KC_GRV 35 Keyboard Grave Accent and Tilde
KC_COMMA KC_COMM 36 Keyboard, and <
KC_COMMA KC_COMM 36 Keyboard , and <
KC_DOT 37 Keyboard . and >
KC_SLASH KC_SLSH 38 Keyboard / and ?
KC_CAPSLOCK KC_CAPS 39 Keyboard Caps Lock
@ -92,7 +92,7 @@ KC_LEFT 50 Keyboard LeftArrow1
KC_DOWN 51 Keyboard DownArrow1
KC_UP 52 Keyboard UpArrow1
KC_NUMLOCK KC_NLCK 53 Keypad Num Lock and Clear11
KC_KP_SLASH KC_PSLS 54 Keypad /1
KC_KP_SLASH KC_PSLS 54 Keypad /
KC_KP_ASTERISK KC_PAST 55 Keypad *
KC_KP_MINUS KC_PMNS 56 Keypad -
KC_KP_PLUS KC_PPLS 57 Keypad +

10
keyboards/ergodox_ez/config.h
View File

@ -27,7 +27,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define DEVICE_VER 0x0001
#define MANUFACTURER ErgoDox EZ
#define PRODUCT ErgoDox EZ
#define DESCRIPTION t.m.k. keyboard firmware for Ergodox
#define DESCRIPTION QMK keyboard firmware for Ergodox EZ
/* key matrix size */
#define MATRIX_ROWS 14
@ -40,12 +40,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define TAPPING_TOGGLE 1
#define COLS (int []){ F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7 }
#define ROWS (int []){ D0, D5, B5, B6 }
/* COL2ROW or ROW2COL */
#define DIODE_DIRECTION COL2ROW
/* define if matrix has ghost */
//#define MATRIX_HAS_GHOST
@ -53,7 +47,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define BACKLIGHT_LEVELS 3
/* Set 0 if debouncing isn't needed */
#define DEBOUNCE 2
#define DEBOUNCE 5
#define TAPPING_TERM 200
#define IGNORE_MOD_TAP_INTERRUPT // this makes it possible to do rolling combos (zx) with keys that convert to other keys on hold (z becomes ctrl when you hold it, and when this option isn't enabled, z rapidly followed by x actually sends Ctrl-x. That's bad.)

6
keyboards/ergodox_ez/matrix.c
View File

@ -27,7 +27,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <stdint.h>
#include <stdbool.h>
#include <avr/io.h>
#include <util/delay.h>
#include "wait.h"
#include "action_layer.h"
#include "print.h"
#include "debug.h"
@ -166,6 +166,7 @@ uint8_t matrix_scan(void)
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
select_row(i);
wait_us(30); // without this wait read unstable value.
matrix_row_t cols = read_cols(i);
if (matrix_debouncing[i] != cols) {
matrix_debouncing[i] = cols;
@ -179,7 +180,7 @@ uint8_t matrix_scan(void)
if (debouncing) {
if (--debouncing) {
_delay_ms(1);
wait_us(1);
} else {
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
matrix[i] = matrix_debouncing[i];
@ -267,7 +268,6 @@ static matrix_row_t read_cols(uint8_t row)
return data;
}
} else {
_delay_us(30); // without this wait read unstable value.
// read from teensy
return
(PINF&(1<<0) ? 0 : (1<<0)) |

310
quantum/matrix.c
View File

@ -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
# error "The universal matrix.c file cannot be used for this keyboard."
#endif
/* Set 0 if debouncing isn't needed */
/*
* 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
static matrix_row_t matrix[MATRIX_ROWS];
#else
static matrix_col_t 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);
#else
static void toggle_col(uint8_t col);
static matrix_col_t read_rows(void);
/* 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];
#endif
#if MATRIX_COLS > 16
#define SHIFTER 1UL
#else
#define SHIFTER 1
#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
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
/* DDRxn */
_SFR_IO8((row_pins[r] >> 4) + 1) |= _BV(row_pins[r] & 0xF);
toggle_row(r);
// 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;
}
for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
/* PORTxn */
_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) {
static matrix_row_t debouncing_matrix[MATRIX_ROWS];
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;
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
select_row(i);
wait_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 = DEBOUNCING_DELAY;
}
toggle_row(r);
unselect_rows();
}
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];
if (debouncing) {
if (--debouncing) {
wait_us(1);
} else {
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
matrix[i] = matrix_debouncing[i];
}
}
}
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) {
matrix_row_t state = 0;
for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
/* PINxn */
if (!(_SFR_IO8((col_pins[c] >> 4)) & _BV(col_pins[c] & 0xF))) {
state |= (matrix_row_t)1 << c;
}
}
return state;
}
matrix_row_t matrix_get_row(uint8_t row) {
return matrix[row];
}
#else
uint8_t matrix_scan(void) {
static matrix_col_t debouncing_matrix[MATRIX_COLS];
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;
for (uint8_t i = 0; i < MATRIX_COLS; i++) {
select_row(i);
wait_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");
}
debouncing = DEBOUNCING_DELAY;
}
toggle_col(c);
unselect_rows();
}
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];
if (debouncing) {
if (--debouncing) {
wait_us(1);
} else {
for (uint8_t i = 0; i < MATRIX_COLS; i++) {
matrix_reversed[i] = matrix_reversed_debouncing[i];
}
}
}
matrix_scan_quantum();
return 1;
}
static void toggle_col(uint8_t col) {
/* PINxn */
_SFR_IO8((col_pins[col] >> 4)) = _BV(col_pins[col] & 0xF);
}
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] >> 4)) & _BV(row_pins[r] & 0xF))) {
state |= (matrix_col_t)1 << r;
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;
}
return state;
}
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;
}
#endif
bool matrix_is_modified(void) {
if (debouncing_delay >= 0) return false;
matrix_scan_quantum();
return 1;
}
bool matrix_is_modified(void)
{
if (debouncing) return false;
return true;
}
bool matrix_is_on(uint8_t row, uint8_t col) {
return matrix_get_row(row) & (matrix_row_t)1 << col;
inline
bool matrix_is_on(uint8_t row, uint8_t col)
{
return (matrix[row] & ((matrix_row_t)1<col));
}
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)));
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 matrix_key_count(void)
{
uint8_t count = 0;
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
count += bitpop16(matrix_get_row(r));
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
count += bitpop16(matrix[i]);
}
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);
_SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF);
}
}
static matrix_row_t read_cols(void)
{
matrix_row_t result = 0;
#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
result |= (_SFR_IO8(pin >> 4) & _BV(pin & 0xF)) ? 0 : (SHIFTER << x);
}
return result;
}
static void unselect_rows(void)
{
#if DIODE_DIRECTION == COL2ROW
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);
}
}
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);
}

6
tmk_core/common/avr/suspend.c
View File

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

16
tmk_core/common/bootmagic.c
View File

@ -106,13 +106,15 @@ void bootmagic(void)
}
}
static bool scan_keycode(uint8_t keycode) {
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
static bool scan_keycode(uint8_t keycode)
{
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) {
if (matrix_row & (matrix_row_t)1 << c) {
keypos_t key = (keypos_t){ .row = r, .col = c };
if (keycode == keymap_key_to_keycode(0, key)) return true;
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 })) {
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);
}
}

109
tmk_core/common/keyboard.c
View File

@ -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){
matrix_row_t state = matrix_get_row(row);
/* no ghosting happens when only one key in the row is pressed */
if (!(state - 1 & state)) return false;
/* ghosting occurs when two keys in the same column are pressed */
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
if (r != row && matrix_get_row(r) & state) return true;
static bool has_ghost_in_row(uint8_t row)
{
matrix_row_t matrix_row = matrix_get_row(row);
// No ghost exists when less than 2 keys are down on the row
if (((matrix_row - 1) & matrix_row) == 0)
return false;
// 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) {
static uint8_t led_status;
matrix_scan();
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
static matrix_row_t previous_matrix[MATRIX_ROWS];
matrix_row_t state = matrix_get_row(r);
matrix_row_t changes = state ^ previous_matrix[r];
if (changes) {
/*
* Do keyboard routine jobs: scan mantrix, light LEDs, ...
* 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 deghosting_matrix[MATRIX_ROWS];
if (is_row_ghosting(r)) {
/* debugs the deghosting mechanism */
/* doesn't update previous_matrix until the ghosting has stopped
* in order to prevent the last key from being lost
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 (uint8_t r = 0; r < MATRIX_ROWS; r++) {
matrix_row = matrix_get_row(r);
matrix_change = matrix_row ^ matrix_prev[r];
if (matrix_change) {
#ifdef MATRIX_HAS_GHOST
if (has_ghost_in_row(r)) {
/* Keep track of whether ghosted status has changed for
* debugging. But don't update matrix_prev until un-ghosted, or
* the last key would be 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) {
matrix_row_t mask = (matrix_row_t)1 << c;
if (changes & mask) {
keyevent_t event;
event.key = (keypos_t){ .row = r, .col = c };
event.pressed = state & mask;
/* the time should not be 0 */
event.time = timer_read() | 1;
action_exec(event);
/* records the processed key event */
previous_matrix[r] ^= mask;
/* processes one key event per call */
goto event_processed;
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 },
.pressed = (matrix_row & ((matrix_row_t)1<<c)),
.time = (timer_read() | 1) /* time should not be 0 */
});
// record a processed key
matrix_prev[r] ^= ((matrix_row_t)1<<c);
// process a key per task call
goto MATRIX_LOOP_END;
}
}
}
}
/* 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) {
if (debug_keyboard) dprintf("Keyboard LEDs state: %x\n", leds);
void keyboard_set_leds(uint8_t leds)
{
if (debug_keyboard) { debug("keyboard_set_led: "); debug_hex8(leds); debug("\n"); }
led_set(leds);
}

57
tmk_core/common/matrix.h
View File

@ -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;
#elif MATRIX_COLS <= 16
typedef uint16_t matrix_row_t;
#elif MATRIX_COLS <= 32
typedef uint32_t matrix_row_t;
#if (MATRIX_COLS <= 8)
typedef uint8_t matrix_row_t;
#elif (MATRIX_COLS <= 16)
typedef uint16_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
# 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
#define MATRIX_IS_ON(row, col) (matrix_get_row(row) && (1<<col))
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);