2020 November 28 Breaking Changes Update (#11053)

* Branch point for 2020 November 28 Breaking Change                                                

* Remove matrix_col_t to allow MATRIX_ROWS > 32 (#10183)                                           

* Add support for soft serial to ATmega32U2 (#10204)                                               

* Change MIDI velocity implementation to allow direct control of velocity value (#9940)            

* Add ability to build a subset of all keyboards based on platform.                                

* Actually use eeprom_driver_init().                                                               

* Make bootloader_jump weak for ChibiOS. (#10417)                                                  

* Joystick 16-bit support (#10439)                                                                 

* Per-encoder resolutions (#10259)                                                                 

* Share button state from mousekey to pointing_device (#10179)                                     

* Add hotfix for chibios keyboards not wake (#10088)                                               

* Add advanced/efficient RGB Matrix Indicators (#8564)                                             

* Naming change.                                                                                   

* Support for STM32 GPIOF,G,H,I,J,K (#10206)                                                       

* Add milc as a dependency and remove the installed milc (#10563)                                  

* ChibiOS upgrade: early init conversions (#10214)                                                 

* ChibiOS upgrade: configuration file migrator (#9952)                                             

* Haptic and solenoid cleanup (#9700)                                                              

* XD75 cleanup (#10524)                                                                            

* OLED display update interval support (#10388)                                                    

* Add definition based on currently-selected serial driver. (#10716)                               

* New feature: Retro Tapping per key (#10622)                                                      

* Allow for modification of output RGB values when using rgblight/rgb_matrix. (#10638)             

* Add housekeeping task callbacks so that keyboards/keymaps are capable of executing code for each main loop iteration. (#10530)

* Rescale both ChibiOS and AVR backlighting.                                                       

* Reduce Helix keyboard build variation (#8669)                                                    

* Minor change to behavior allowing display updates to continue between task ticks (#10750)        

* Some GPIO manipulations in matrix.c change to atomic. (#10491)                                   

* qmk cformat (#10767)                                                                             

* [Keyboard] Update the Speedo firmware for v3.0 (#10657)                                          

* Maartenwut/Maarten namechange to evyd13/Evy (#10274)                                             

* [quantum] combine repeated lines of code (#10837)                                                

* Add step sequencer feature (#9703)                                                               

* aeboards/ext65 refactor (#10820)                                                                 

* Refactor xelus/dawn60 for Rev2 later (#10584)                                                    

* add DEBUG_MATRIX_SCAN_RATE_ENABLE to common_features.mk (#10824)                                 

* [Core] Added `add_oneshot_mods` & `del_oneshot_mods` (#10549)                                    

* update chibios os usb for the otg driver (#8893)                                                 

* Remove HD44780 References, Part 4 (#10735)                                                       

* [Keyboard] Add Valor FRL TKL (+refactor) (#10512)                                                

* Fix cursor position bug in oled_write_raw functions (#10800)                                     

* Fixup version.h writing when using SKIP_VERSION=yes (#10972)                                     

* Allow for certain code in the codebase assuming length of string. (#10974)                       

* Add AT90USB support for serial.c (#10706)                                                        

* Auto shift: support repeats and early registration (#9826)                                       

* Rename ledmatrix.h to match .c file (#7949)                                                      

* Split RGB_MATRIX_ENABLE into _ENABLE and _DRIVER (#10231)                                        

* Split LED_MATRIX_ENABLE into _ENABLE and _DRIVER (#10840)                                        

* Merge point for 2020 Nov 28 Breaking Change                                                      

1 files changed, 344 insertions, 0 deletions

diff --git a/keyboards/evyd13/wasdat/matrix.c b/keyboards/evyd13/wasdat/matrix.c
new file mode 100644
index 0000000000..6dd79b5330
--- /dev/null
+++ b/keyboards/evyd13/wasdat/matrix.c
@@ -0,0 +1,344 @@
+/*
+Copyright 2012-2018 Jun Wako, Jack Humbert, Yiancar
+
+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
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+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/>.
+*/
+#include <stdint.h>
+#include <stdbool.h>
+#include "wait.h"
+#include "util.h"
+#include "matrix.h"
+#include "debounce.h"
+#include "quantum.h"
+
+#ifdef DIRECT_PINS
+static pin_t direct_pins[MATRIX_ROWS][MATRIX_COLS] = DIRECT_PINS;
+#elif (DIODE_DIRECTION == ROW2COL) || (DIODE_DIRECTION == COL2ROW)
+static const pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
+//static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
+#endif
+
+// matrix code
+
+#ifdef DIRECT_PINS
+
+static void init_pins(void) {
+    for (int row = 0; row < MATRIX_ROWS; row++) {
+        for (int col = 0; col < MATRIX_COLS; col++) {
+            pin_t pin = direct_pins[row][col];
+            if (pin != NO_PIN) {
+                setPinInputHigh(pin);
+            }
+        }
+    }
+}
+
+static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) {
+    matrix_row_t last_row_value = current_matrix[current_row];
+    current_matrix[current_row] = 0;
+
+    for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
+        pin_t pin = direct_pins[current_row][col_index];
+        if (pin != NO_PIN) {
+            current_matrix[current_row] |= readPin(pin) ? 0 : (MATRIX_ROW_SHIFTER << col_index);
+        }
+    }
+
+    return (last_row_value != current_matrix[current_row]);
+}
+
+#elif (DIODE_DIRECTION == COL2ROW)
+
+static void select_row(uint8_t row) {
+    setPinOutput(row_pins[row]);
+    writePinLow(row_pins[row]);
+}
+
+static void unselect_row(uint8_t row) { setPinInputHigh(row_pins[row]); }
+
+static void unselect_rows(void) {
+    for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
+        setPinInputHigh(row_pins[x]);
+    }
+}
+
+static void init_pins(void) {
+    unselect_rows();
+    for (uint8_t x = 0; x < MATRIX_COLS; x++) {
+        setPinInputHigh(col_pins[x]);
+    }
+}
+
+static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) {
+    // Store last value of row prior to reading
+    matrix_row_t last_row_value = current_matrix[current_row];
+
+    // Clear data in matrix row
+    current_matrix[current_row] = 0;
+
+    // Select row and wait for row selecton to stabilize
+    select_row(current_row);
+    wait_us(30);
+
+    // For each col...
+    for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
+
+        // Select the col pin to read (active low)
+        uint8_t pin_state = readPin(col_pins[col_index]);
+
+        // Populate the matrix row with the state of the col pin
+        current_matrix[current_row] |= pin_state ? 0 : (MATRIX_ROW_SHIFTER << col_index);
+    }
+
+    // Unselect row
+    unselect_row(current_row);
+
+    return (last_row_value != current_matrix[current_row]);
+}
+
+#elif (DIODE_DIRECTION == ROW2COL)
+
+/* Cols 0 - 15
+ * col 0: C7
+ * col 1:  B6
+ * col 2: C6
+ * col 3:  B4
+ * col 4:  B5
+ * col 5:   D7
+ * These columns use a 74HC237D 3 to 8 bit demultiplexer.
+ *                A0   A1   A2
+ * col / pin:    PD2  PD1  PD0
+ * 6:             1    1    1
+ * 7:             0    1    1
+ * 8:             1    0    1
+ * 9:             0    0    1
+ * 10:            1    1    0
+ * 11:            0    1    0
+ * 12:            1    0    0
+ * col 13:  D3
+ * col 14:  B7
+ * col 15:  B3
+ */
+static void select_col(uint8_t col) {
+    switch (col) {
+        case 0:
+            writePinLow(C7);
+            break;
+        case 1:
+            writePinLow(B6);
+            break;
+        case 2:
+            writePinLow(C6);
+            break;
+        case 3:
+            writePinLow(B4);
+            break;
+        case 4:
+            writePinLow(B5);
+            break;
+        case 5:
+            writePinLow(D7);
+            break;
+        case 6:
+            writePinHigh(D0);
+            writePinHigh(D1);
+            writePinHigh(D2);
+            break;
+        case 7:
+            writePinHigh(D0);
+            writePinHigh(D1);
+            break;
+        case 8:
+            writePinHigh(D0);
+            writePinHigh(D2);
+            break;
+        case 9:
+            writePinHigh(D0);
+            break;
+        case 10:
+            writePinHigh(D1);
+            writePinHigh(D2);
+            break;
+        case 11:
+            writePinHigh(D1);
+            break;
+        case 12:
+            writePinHigh(D2);
+            break;
+        case 13:
+            writePinLow(D3);
+            break;
+        case 14:
+            writePinLow(B7);
+            break;
+        case 15:
+            writePinLow(B3);
+            break;
+    }
+}
+
+static void unselect_col(uint8_t col) {
+    switch (col) {
+        case 0:
+            writePinHigh(C7);
+            break;
+        case 1:
+            writePinHigh(B6);
+            break;
+        case 2:
+            writePinHigh(C6);
+            break;
+        case 3:
+            writePinHigh(B4);
+            break;
+        case 4:
+            writePinHigh(B5);
+            break;
+        case 5:
+            writePinHigh(D7);
+            break;
+        case 6:
+            writePinLow(D0);
+            writePinLow(D1);
+            writePinLow(D2);
+            break;
+        case 7:
+            writePinLow(D0);
+            writePinLow(D1);
+            break;
+        case 8:
+            writePinLow(D0);
+            writePinLow(D2);
+            break;
+        case 9:
+            writePinLow(D0);
+            break;
+        case 10:
+            writePinLow(D1);
+            writePinLow(D2);
+            break;
+        case 11:
+            writePinLow(D1);
+            break;
+        case 12:
+            writePinLow(D2);
+            break;
+        case 13:
+            writePinHigh(D3);
+            break;
+        case 14:
+            writePinHigh(B7);
+            break;
+        case 15:
+            writePinHigh(B3);
+            break;
+    }
+}
+
+static void unselect_cols(void) {
+    //Native
+    setPinOutput(D3);
+    setPinOutput(D7);
+    writePinHigh(D3);
+    writePinHigh(D7);
+
+    setPinOutput(C6);
+    setPinOutput(C7);
+    writePinHigh(C6);
+    writePinHigh(C7);
+
+    setPinOutput(B3);
+    setPinOutput(B4);
+    setPinOutput(B5);
+    setPinOutput(B6);
+    setPinOutput(B7);
+    writePinHigh(B3);
+    writePinHigh(B4);
+    writePinHigh(B5);
+    writePinHigh(B6);
+    writePinHigh(B7);
+
+    //Demultiplexer
+    setPinOutput(D0);
+    setPinOutput(D1);
+    setPinOutput(D2);
+    writePinLow(D0);
+    writePinLow(D1);
+    writePinLow(D2);
+}
+
+static void init_pins(void) {
+    unselect_cols();
+    for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
+        setPinInputHigh(row_pins[x]);
+    }
+}
+
+static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col) {
+    bool matrix_changed = false;
+
+    // Select col and wait for col selecton to stabilize
+    select_col(current_col);
+    wait_us(30);
+
+    // For each row...
+    for (uint8_t row_index = 0; row_index < MATRIX_ROWS; row_index++) {
+        // Store last value of row prior to reading
+        matrix_row_t last_row_value = current_matrix[row_index];
+
+        // Check row pin state
+        if (readPin(row_pins[row_index]) == 0) {
+            // Pin LO, set col bit
+            current_matrix[row_index] |= (MATRIX_ROW_SHIFTER << current_col);
+        } else {
+            // Pin HI, clear col bit
+            current_matrix[row_index] &= ~(MATRIX_ROW_SHIFTER << current_col);
+        }
+
+        // Determine if the matrix changed state
+        if ((last_row_value != current_matrix[row_index]) && !(matrix_changed)) {
+            matrix_changed = true;
+        }
+    }
+
+    // Unselect col
+    unselect_col(current_col);
+
+    return matrix_changed;
+}
+
+#endif
+
+void matrix_init_custom(void) {
+    // initialize key pins
+    init_pins();
+}
+
+bool matrix_scan_custom(matrix_row_t current_matrix[]) {
+    bool changed = false;
+
+#if defined(DIRECT_PINS) || (DIODE_DIRECTION == COL2ROW)
+    // Set row, read cols
+    for (uint8_t current_row = 0; current_row < MATRIX_ROWS; current_row++) {
+        changed |= read_cols_on_row(current_matrix, current_row);
+    }
+#elif (DIODE_DIRECTION == ROW2COL)
+    // Set col, read rows
+    for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++) {
+        changed |= read_rows_on_col(current_matrix, current_col);
+    }
+#endif
+
+    return changed;
+}