logo

qmk_firmware

custom branch of QMK firmware git clone https://anongit.hacktivis.me/git/qmk_firmware.git

matrix.c (10310B)

    

  1. /*
  2. Copyright 2012-2018 Jun Wako, Jack Humbert, Yiancar
  4. This program is free software: you can redistribute it and/or modify
  5. it under the terms of the GNU General Public License as published by
  6. the Free Software Foundation, either version 2 of the License, or
  7. (at your option) any later version.
  9. This program is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. GNU General Public License for more details.
  14. You should have received a copy of the GNU General Public License
  15. along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16. */
  17. #include "atomic_util.h"
  18. #include "util.h"
  19. #include "wait.h"
  20. #include "matrix.h"
  21. #include "debounce.h"
  22. #ifndef readPort
  23. #    include "gpio_extr.h"
  24. #endif
  26. #ifndef MATRIX_DEBUG_PIN
  27. #    define MATRIX_DEBUG_PIN_INIT()
  28. #    define MATRIX_DEBUG_SCAN_START()
  29. #    define MATRIX_DEBUG_SCAN_END()
  30. #    define MATRIX_DEBUG_DELAY_START()
  31. #    define MATRIX_DEBUG_DELAY_END()
  32. #    define MATRIX_DEBUG_GAP()
  33. #else
  34. #    define MATRIX_DEBUG_GAP() asm volatile("nop \n nop" ::: "memory")
  35. #endif
  37. #ifndef MATRIX_IO_DELAY_ALWAYS
  38. #    define MATRIX_IO_DELAY_ALWAYS 0
  39. #endif
  41. #ifdef DIRECT_PINS
  42. static pin_t direct_pins[MATRIX_ROWS][MATRIX_COLS] = DIRECT_PINS;
  43. #elif (DIODE_DIRECTION == ROW2COL) || (DIODE_DIRECTION == COL2ROW)
  44. static const pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
  45. static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
  46. #    ifdef MATRIX_MUL_SELECT
  47. static const pin_t col_sel[MATRIX_COLS]  = MATRIX_MUL_SEL;
  48. #    endif
  49. #endif
  51. #ifdef MATRIX_IO_DELAY_PORTS
  52. static const pin_t       delay_ports[] = {MATRIX_IO_DELAY_PORTS};
  53. static const port_data_t delay_masks[] = {MATRIX_IO_DELAY_MASKS};
  54. #    ifdef MATRIX_IO_DELAY_MULSEL
  55. static const uint8_t delay_sel[] = {MATRIX_IO_DELAY_MULSEL};
  56. #    endif
  57. #endif
  59. /* matrix state(1:on, 0:off) */
  60. extern matrix_row_t raw_matrix[MATRIX_ROWS];  // raw values
  61. extern matrix_row_t matrix[MATRIX_ROWS];      // debounced values
  63. static inline void gpio_atomic_set_pin_output_low(pin_t pin) {
  64.     ATOMIC_BLOCK_FORCEON {
  65.         gpio_set_pin_output(pin);
  66.         gpio_write_pin_low(pin);
  67.     }
  68. }
  70. static inline void gpio_atomic_set_pin_input_high(pin_t pin) {
  71.     ATOMIC_BLOCK_FORCEON { gpio_set_pin_input_high(pin); }
  72. }
  74. // matrix code
  76. #ifdef DIRECT_PINS
  78. static void init_pins(void) {
  79.     for (int row = 0; row < MATRIX_ROWS; row++) {
  80.         for (int col = 0; col < MATRIX_COLS; col++) {
  81.             pin_t pin = direct_pins[row][col];
  82.             if (pin != NO_PIN) {
  83.                 gpio_set_pin_input_high(pin);
  84.             }
  85.         }
  86.     }
  87. }
  89. static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) {
  90.     // Start with a clear matrix row
  91.     matrix_row_t current_row_value = 0;
  93.     for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
  94.         pin_t pin = direct_pins[current_row][col_index];
  95.         if (pin != NO_PIN) {
  96.             current_row_value |= gpio_read_pin(pin) ? 0 : (MATRIX_ROW_SHIFTER << col_index);
  97.         }
  98.     }
  100.     // If the row has changed, store the row and return the changed flag.
  101.     if (current_matrix[current_row] != current_row_value) {
  102.         current_matrix[current_row] = current_row_value;
  103.         return true;
  104.     }
  105.     return false;
  106. }
  108. #elif defined(DIODE_DIRECTION)
  109. #    if (DIODE_DIRECTION == COL2ROW)
  111. static void select_row(uint8_t row) { gpio_atomic_set_pin_output_low(row_pins[row]); }
  113. static void unselect_row(uint8_t row) { gpio_atomic_set_pin_input_high(row_pins[row]); }
  115. static void unselect_rows(void) {
  116.     for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
  117.         gpio_atomic_set_pin_input_high(row_pins[x]);
  118.     }
  119. }
  121. static void init_pins(void) {
  122. #        ifdef MATRIX_MUL_SELECT
  123.     gpio_set_pin_output(MATRIX_MUL_SELECT);
  124.     gpio_write_pin_low(MATRIX_MUL_SELECT);
  125. #        endif
  126.     unselect_rows();
  127.     for (uint8_t x = 0; x < MATRIX_COLS; x++) {
  128.         gpio_atomic_set_pin_input_high(col_pins[x]);
  129.     }
  130. }
  132. static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) {
  133.     // Start with a clear matrix row
  134.     matrix_row_t current_row_value = 0;
  136.     // Select row
  137.     select_row(current_row);
  138.     matrix_output_select_delay();
  140.     // For each col...
  141.     for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
  142.         // Select the col pin to read (active low)
  143. #        ifdef MATRIX_MUL_SELECT
  144.         gpio_write_pin(MATRIX_MUL_SELECT, col_sel[col_index]);
  145.         waitInputPinDelay();
  146. #        endif
  147.         uint8_t pin_state = gpio_read_pin(col_pins[col_index]);
  149.         // Populate the matrix row with the state of the col pin
  150.         current_row_value |= pin_state ? 0 : (MATRIX_ROW_SHIFTER << col_index);
  151.     }
  153.     // Unselect row
  154.     unselect_row(current_row);
  155. #        ifdef MATRIX_IO_DELAY_PORTS
  156.     if (current_row_value) {  // wait for col signal to go HIGH
  157.         bool is_pressed;
  158.         do {
  159.             MATRIX_DEBUG_DELAY_START();
  160.             is_pressed = false;
  161.             for (uint8_t i = 0; i < ARRAY_SIZE(delay_ports); i++) {
  162. #            ifdef MATRIX_IO_DELAY_MULSEL
  163.                 gpio_write_pin(MATRIX_MUL_SELECT, delay_sel[i]);
  164.                 waitInputPinDelay();
  165. #            endif
  166.                 is_pressed |= ((readPort(delay_ports[i]) & delay_masks[i]) != delay_masks[i]);
  167.             }
  168.             MATRIX_DEBUG_DELAY_END();
  169.         } while (is_pressed);
  170.     }
  171. #        endif
  172. #        ifdef MATRIX_IO_DELAY_ADAPTIVE
  173.     if (current_row_value) {  // wait for col signal to go HIGH
  174.         for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
  175.             MATRIX_DEBUG_DELAY_START();
  176. #            ifdef MATRIX_MUL_SELECT
  177.             gpio_write_pin(MATRIX_MUL_SELECT, col_sel[col_index]);
  178.             waitInputPinDelay();
  179. #            endif
  180.             while (gpio_read_pin(col_pins[col_index]) == 0) {
  181.             }
  182.             MATRIX_DEBUG_DELAY_END();
  183.         }
  184.     }
  185. #        endif
  186. #        ifdef MATRIX_IO_DELAY_ADAPTIVE2
  187.     if (current_row_value) {  // wait for col signal to go HIGH
  188.         pin_t state;
  189.         do {
  190.             MATRIX_DEBUG_DELAY_START();
  191.             state = 0;
  192.             for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
  193.                 MATRIX_DEBUG_DELAY_END();
  194.                 MATRIX_DEBUG_DELAY_START();
  195. #            ifdef MATRIX_MUL_SELECT
  196.                 gpio_write_pin(MATRIX_MUL_SELECT, col_sel[col_index]);
  197.                 waitInputPinDelay();
  198. #            endif
  199.                 state |= (gpio_read_pin(col_pins[col_index]) == 0);
  200.             }
  201.             MATRIX_DEBUG_DELAY_END();
  202.         } while (state);
  203.     }
  204. #        endif
  205.     if (MATRIX_IO_DELAY_ALWAYS || current_row + 1 < MATRIX_ROWS) {
  206.         MATRIX_DEBUG_DELAY_START();
  207.         matrix_output_unselect_delay(current_row, current_row_value != 0);  // wait for col signal to go HIGH
  208.         MATRIX_DEBUG_DELAY_END();
  209.     }
  211.     // If the row has changed, store the row and return the changed flag.
  212.     if (current_matrix[current_row] != current_row_value) {
  213.         current_matrix[current_row] = current_row_value;
  214.         return true;
  215.     }
  216.     return false;
  217. }
  219. #    elif (DIODE_DIRECTION == ROW2COL)
  221. static void select_col(uint8_t col) { gpio_atomic_set_pin_output_low(col_pins[col]); }
  223. static void unselect_col(uint8_t col) { gpio_atomic_set_pin_input_high(col_pins[col]); }
  225. static void unselect_cols(void) {
  226.     for (uint8_t x = 0; x < MATRIX_COLS; x++) {
  227.         gpio_atomic_set_pin_input_high(col_pins[x]);
  228.     }
  229. }
  231. static void init_pins(void) {
  232.     unselect_cols();
  233.     for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
  234.         gpio_atomic_set_pin_input_high(row_pins[x]);
  235.     }
  236. }
  238. static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col) {
  239.     bool matrix_changed = false;
  240.     bool key_pressed = false;
  242.     // Select col
  243.     select_col(current_col);
  244.     matrix_output_select_delay();
  246.     // For each row...
  247.     for (uint8_t row_index = 0; row_index < MATRIX_ROWS; row_index++) {
  248.         // Store last value of row prior to reading
  249.         matrix_row_t last_row_value    = current_matrix[row_index];
  250.         matrix_row_t current_row_value = last_row_value;
  252.         // Check row pin state
  253.         if (gpio_read_pin(row_pins[row_index]) == 0) {
  254.             // Pin LO, set col bit
  255.             current_row_value |= (MATRIX_ROW_SHIFTER << current_col);
  256.             key_pressed = true;
  257.         } else {
  258.             // Pin HI, clear col bit
  259.             current_row_value &= ~(MATRIX_ROW_SHIFTER << current_col);
  260.         }
  262.         // Determine if the matrix changed state
  263.         if ((last_row_value != current_row_value)) {
  264.             matrix_changed |= true;
  265.             current_matrix[row_index] = current_row_value;
  266.         }
  267.     }
  269.     // Unselect col
  270.     unselect_col(current_col);
  271.     if (MATRIX_IO_DELAY_ALWAYS || current_col + 1 < MATRIX_COLS) {
  272.         matrix_output_unselect_delay(current_col, key_pressed);  // wait for col signal to go HIGH
  273.     }
  275.     return matrix_changed;
  276. }
  278. #    else
  279. #        error DIODE_DIRECTION must be one of COL2ROW or ROW2COL!
  280. #    endif
  281. #else
  282. #    error DIODE_DIRECTION is not defined!
  283. #endif
  285. void matrix_init(void) {
  286.     // initialize key pins
  287.     init_pins();
  289.     // initialize matrix state: all keys off
  290.     for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
  291.         raw_matrix[i] = 0;
  292.         matrix[i]     = 0;
  293.     }
  295.     debounce_init(MATRIX_ROWS);
  297.     matrix_init_kb();
  298. }
  300. uint8_t matrix_scan(void) {
  301.     bool changed = false;
  302.     MATRIX_DEBUG_PIN_INIT();
  304.     MATRIX_DEBUG_SCAN_START();
  305. #if defined(DIRECT_PINS) || (DIODE_DIRECTION == COL2ROW)
  306.     // Set row, read cols
  307.     for (uint8_t current_row = 0; current_row < MATRIX_ROWS; current_row++) {
  308.         changed |= read_cols_on_row(raw_matrix, current_row);
  309.     }
  310. #elif (DIODE_DIRECTION == ROW2COL)
  311.     // Set col, read rows
  312.     for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++) {
  313.         changed |= read_rows_on_col(raw_matrix, current_col);
  314.     }
  315. #endif
  316.     MATRIX_DEBUG_SCAN_END();
  317.     MATRIX_DEBUG_GAP();
  319.     MATRIX_DEBUG_SCAN_START();
  320.     debounce(raw_matrix, matrix, MATRIX_ROWS, changed);
  321.     MATRIX_DEBUG_SCAN_END();
  322.     MATRIX_DEBUG_GAP();
  324.     MATRIX_DEBUG_SCAN_START();
  325.     matrix_scan_kb();
  326.     MATRIX_DEBUG_SCAN_END();
  327.     return (uint8_t)changed;
  328. }