matrix.c (6256B)
1 /* Copyright 2022 @ Keychron (https://www.keychron.com) 2 * 3 * This program is free software: you can redistribute it and/or modify 4 * it under the terms of the GNU General Public License as published by 5 * the Free Software Foundation, either version 2 of the License, or 6 * (at your option) any later version. 7 * 8 * This program is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 * GNU General Public License for more details. 12 * 13 * You should have received a copy of the GNU General Public License 14 * along with this program. If not, see <http://www.gnu.org/licenses/>. 15 */ 16 17 #include "matrix.h" 18 #include "atomic_util.h" 19 #include <string.h> 20 21 // Pin connected to DS of 74HC595 22 #define DATA_PIN A7 23 // Pin connected to SH_CP of 74HC595 24 #define CLOCK_PIN B1 25 // Pin connected to ST_CP of 74HC595 26 #define LATCH_PIN B0 27 28 #ifdef MATRIX_ROW_PINS 29 static pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS; 30 #endif // MATRIX_ROW_PINS 31 #ifdef MATRIX_COL_PINS 32 static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; 33 #endif // MATRIX_COL_PINS 34 35 #define ROWS_PER_HAND MATRIX_ROWS 36 37 static inline void gpio_atomic_set_pin_output_low(pin_t pin) { 38 ATOMIC_BLOCK_FORCEON { 39 gpio_set_pin_output(pin); 40 gpio_write_pin_low(pin); 41 } 42 } 43 44 static inline void gpio_atomic_set_pin_output_high(pin_t pin) { 45 ATOMIC_BLOCK_FORCEON { 46 gpio_set_pin_output(pin); 47 gpio_write_pin_high(pin); 48 } 49 } 50 51 static inline void gpio_atomic_set_pin_input_high(pin_t pin) { 52 ATOMIC_BLOCK_FORCEON { 53 gpio_set_pin_input_high(pin); 54 } 55 } 56 57 static inline uint8_t readMatrixPin(pin_t pin) { 58 if (pin != NO_PIN) { 59 return gpio_read_pin(pin); 60 } else { 61 return 1; 62 } 63 } 64 65 // At 3.6V input, three nops (37.5ns) should be enough for all signals 66 #define small_delay() __asm__ __volatile__("nop;nop;nop;\n\t" ::: "memory") 67 #define compiler_barrier() __asm__ __volatile__("" ::: "memory") 68 69 static void shiftOut(uint8_t dataOut) { 70 ATOMIC_BLOCK_FORCEON { 71 for (uint8_t i = 0; i < 8; i++) { 72 compiler_barrier(); 73 if (dataOut & 0x1) { 74 gpio_write_pin_high(DATA_PIN); 75 } else { 76 gpio_write_pin_low(DATA_PIN); 77 } 78 dataOut = dataOut >> 1; 79 compiler_barrier(); 80 gpio_write_pin_high(CLOCK_PIN); 81 small_delay(); 82 gpio_write_pin_low(CLOCK_PIN); 83 } 84 compiler_barrier(); 85 gpio_write_pin_high(LATCH_PIN); 86 small_delay(); 87 gpio_write_pin_low(LATCH_PIN); 88 compiler_barrier(); 89 } 90 } 91 92 static void shiftOut_single(uint8_t data) { 93 ATOMIC_BLOCK_FORCEON { 94 compiler_barrier(); 95 if (data & 0x1) { 96 gpio_write_pin_high(DATA_PIN); 97 } else { 98 gpio_write_pin_low(DATA_PIN); 99 } 100 compiler_barrier(); 101 gpio_write_pin_high(CLOCK_PIN); 102 small_delay(); 103 gpio_write_pin_low(CLOCK_PIN); 104 compiler_barrier(); 105 gpio_write_pin_high(LATCH_PIN); 106 small_delay(); 107 gpio_write_pin_low(LATCH_PIN); 108 compiler_barrier(); 109 } 110 } 111 112 static bool select_col(uint8_t col) { 113 pin_t pin = col_pins[col]; 114 115 if (pin != NO_PIN) { 116 gpio_atomic_set_pin_output_low(pin); 117 return true; 118 } else { 119 if (col == 8) { 120 shiftOut_single(0x00); 121 } 122 return true; 123 } 124 return false; 125 } 126 127 static void unselect_col(uint8_t col) { 128 pin_t pin = col_pins[col]; 129 130 if (pin != NO_PIN) { 131 #ifdef MATRIX_UNSELECT_DRIVE_HIGH 132 gpio_atomic_set_pin_output_high(pin); 133 #else 134 gpio_atomic_set_pin_input_high(pin); 135 #endif 136 } else { 137 shiftOut_single(0x01); 138 } 139 } 140 141 static void unselect_cols(void) { 142 for (uint8_t x = 0; x < MATRIX_COLS; x++) { 143 pin_t pin = col_pins[x]; 144 if (pin != NO_PIN) { 145 #ifdef MATRIX_UNSELECT_DRIVE_HIGH 146 gpio_atomic_set_pin_output_high(pin); 147 #else 148 gpio_atomic_set_pin_input_high(pin); 149 #endif 150 } else { 151 if (x == 8) 152 // unselect shift Register 153 shiftOut(0xFF); 154 } 155 } 156 } 157 158 static void matrix_init_pins(void) { 159 gpio_set_pin_output(DATA_PIN); 160 gpio_set_pin_output(CLOCK_PIN); 161 gpio_set_pin_output(LATCH_PIN); 162 #ifdef MATRIX_UNSELECT_DRIVE_HIGH 163 for (uint8_t x = 0; x < MATRIX_COLS; x++) { 164 if (col_pins[x] != NO_PIN) { 165 gpio_set_pin_output(col_pins[x]); 166 } 167 } 168 #endif 169 unselect_cols(); 170 for (uint8_t x = 0; x < MATRIX_ROWS; x++) { 171 if (row_pins[x] != NO_PIN) { 172 gpio_atomic_set_pin_input_high(row_pins[x]); 173 } 174 } 175 } 176 177 static void matrix_read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col, matrix_row_t row_shifter) { 178 bool key_pressed = false; 179 180 // Select col 181 if (!select_col(current_col)) { // select col 182 return; // skip NO_PIN col 183 } 184 185 matrix_output_select_delay(); 186 187 // For each row... 188 for (uint8_t row_index = 0; row_index < ROWS_PER_HAND; row_index++) { 189 // Check row pin state 190 if (readMatrixPin(row_pins[row_index]) == 0) { 191 // Pin LO, set col bit 192 current_matrix[row_index] |= row_shifter; 193 key_pressed = true; 194 } else { 195 // Pin HI, clear col bit 196 current_matrix[row_index] &= ~row_shifter; 197 } 198 } 199 200 // Unselect col 201 unselect_col(current_col); 202 matrix_output_unselect_delay(current_col, key_pressed); // wait for all Row signals to go HIGH 203 } 204 205 void matrix_init_custom(void) { 206 // initialize key pins 207 matrix_init_pins(); 208 } 209 210 bool matrix_scan_custom(matrix_row_t current_matrix[]) { 211 matrix_row_t curr_matrix[MATRIX_ROWS] = {0}; 212 213 // Set col, read rows 214 matrix_row_t row_shifter = MATRIX_ROW_SHIFTER; 215 for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++, row_shifter <<= 1) { 216 matrix_read_rows_on_col(curr_matrix, current_col, row_shifter); 217 } 218 219 bool changed = memcmp(current_matrix, curr_matrix, sizeof(curr_matrix)) != 0; 220 if (changed) memcpy(current_matrix, curr_matrix, sizeof(curr_matrix)); 221 222 return changed; 223 }