[Keyboard] Corne - Remove legacy revision support (#12226)

keyboards/crkbd/keymaps/armand1m/keymap.c

@@ -69,7 +69,8 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
 #ifdef OLED_DRIVER_ENABLE
 oled_rotation_t oled_init_user(oled_rotation_t rotation) {
-  if (!is_master) {
+
+  if (!is_keyboard_master()) {
     return OLED_ROTATION_180; // flips the display 180 degrees if offhand
   }
   return rotation;

keyboards/crkbd/keymaps/default/keymap.c

@@ -17,6 +17,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include QMK_KEYBOARD_H
+#include <stdio.h>
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   [0] = LAYOUT_split_3x6_3(
@@ -71,7 +72,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
 #ifdef OLED_DRIVER_ENABLE
 oled_rotation_t oled_init_user(oled_rotation_t rotation) {
-  if (!is_master) {
+  if (!is_keyboard_master()) {
     return OLED_ROTATION_180;  // flips the display 180 degrees if offhand
   }
   return rotation;
@@ -157,7 +158,7 @@ void oled_render_logo(void) {
 }
 
 void oled_task_user(void) {
-    if (is_master) {
+    if (is_keyboard_master()) {
         oled_render_layer_state();
         oled_render_keylog();
     } else {

keyboards/crkbd/keymaps/dsanchezseco/keymap.c

@@ -1,15 +1,10 @@
 #include QMK_KEYBOARD_H
-#include "split_util.h"
-
-extern keymap_config_t keymap_config;
 
 #ifdef RGBLIGHT_ENABLE
 //Following line allows macro to read current RGB settings
 extern rgblight_config_t rgblight_config;
 #endif
 
-extern uint8_t is_master;
-
 #define LOWER MO(_LOWER)
 #define RAISE MO(_RAISE)
 #define ESC_CTL LCTL_T(KC_ESC)
@@ -26,7 +21,7 @@ enum crkbd_layers {
 };
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-  [_DVORAK] = LAYOUT( \
+  [_DVORAK] = LAYOUT_split_3x6_3( \
   //,-----------------------------------------------.          ,-----------------------------------------------.
      KC_TAB, KC_QUOT,KC_COMM, KC_DOT, KC_P,   KC_Y,              KC_F,   KC_G,   KC_C,   KC_R,   KC_L,  KC_SLSH,\
   //|-------+-------+-------+-------+-------+-------|          |-------+-------+-------+-------+-------+-------|
@@ -39,7 +34,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   ),
 
 
-  [_LOWER] = LAYOUT( \
+  [_LOWER] = LAYOUT_split_3x6_3( \
   //,-----------------------------------------------.          ,-----------------------------------------------.
      KC_TILD,KC_EXLM, KC_AT, KC_HASH, KC_DLR,KC_PERC,           KC_CIRC,KC_AMPR,KC_ASTR,KC_LPRN,KC_RIGHT,KC_RPRN,\
   //|-------+-------+-------+-------+-------+-------|          |-------+-------+-------+-------+-------+-------|
@@ -51,7 +46,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
                              //`-----------------------'  `----------------------'
   ),
 
-  [_RAISE] = LAYOUT( \
+  [_RAISE] = LAYOUT_split_3x6_3( \
   //,-----------------------------------------------.          ,-----------------------------------------------.
      KC_GRV,  KC_1,    KC_2,   KC_3,   KC_4,  KC_5,              KC_6,    KC_7,  KC_8,    KC_9,KC_RIGHT,  KC_0, \
   //|-------+-------+-------+-------+-------+-------|          |-------+-------+-------+-------+-------+-------|
@@ -63,7 +58,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
                              //`-----------------------'  `----------------------'
   ),
 
-  [_ADJUST] = LAYOUT( \
+  [_ADJUST] = LAYOUT_split_3x6_3( \
   //,-----------------------------------------------.          ,-----------------------------------------------.
      RGB_TOG,RGB_HUI,RGB_SAI,RGB_VAI,_______,RGB_M_T,          _______,_______,_______,_______,KC_RIGHT,_______,\
   //|-------+-------+-------+-------+-------+-------|          |-------+-------+-------+-------+-------+-------|
@@ -82,7 +77,7 @@ uint32_t layer_state_set_user(uint32_t state) {
 
 #ifdef OLED_DRIVER_ENABLE
 oled_rotation_t oled_init_user(oled_rotation_t rotation) {
-  if (!isLeftHand)
+  if (!is_keyboard_left())
     return OLED_ROTATION_180;  // flips the display 180 to see it from my side
   return rotation;
 }

keyboards/crkbd/keymaps/gotham/keymap.c

@@ -11,7 +11,7 @@
 
 // clang-format off
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-  [_QWERTY] = LAYOUT(
+  [_QWERTY] = LAYOUT_split_3x6_3(
   //|-----------------------------------------------------|                    |-----------------------------------------------------|
      KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,                         KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_BSLS,
   //|--------+--------+--------+--------+--------+--------|                    |--------+--------+--------+--------+--------+--------|
@@ -25,7 +25,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
   ),
 
-  [_LOWER] = LAYOUT(
+  [_LOWER] = LAYOUT_split_3x6_3(
   //|-----------------------------------------------------|                    |-----------------------------------------------------|
      KC_ESC,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,                         KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    _______,
   //|--------+--------+--------+--------+--------+--------|                    |--------+--------+--------+--------+--------+--------|
@@ -37,7 +37,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
                                       //|--------------------------|  |--------------------------|
   ),
 
-  [_RAISE] = LAYOUT(
+  [_RAISE] = LAYOUT_split_3x6_3(
   //|-----------------------------------------------------|                    |-----------------------------------------------------|
      KC_ESC,  KC_HASH, KC_DLR,  KC_LCBR, KC_RCBR, XXXXXXX,                      XXXXXXX, KC_AMPR, KC_PIPE, KC_EXLM, KC_ASTR, XXXXXXX,
   //|--------+--------+--------+--------+--------+--------|                    |--------+--------+--------+--------+--------+--------|
@@ -49,7 +49,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
                                       //|--------------------------|  |--------------------------|
   ),
 
-  [_ADJUST] = LAYOUT(
+  [_ADJUST] = LAYOUT_split_3x6_3(
   //|-----------------------------------------------------|                    |-----------------------------------------------------|
      XXXXXXX, CK_RST,  CK_DOWN, CK_UP,   CK_TOGG, RGB_TOG,                       MU_TOG, KC_F12,  KC_F7,   KC_F8,   KC_F9,   XXXXXXX,\
   //|--------+--------+--------+--------+--------+--------|                    |--------+--------+--------+--------+--------+--------|

keyboards/crkbd/keymaps/gotham/oled.c

@@ -257,7 +257,7 @@ void oled_task_user(void) {
     }
     #endif
 
-    if (is_master) {
+    if (is_keyboard_master()) {
         render_status_main();
     } else {
         render_status_secondary();

keyboards/crkbd/keymaps/hvp/config.h

@@ -29,6 +29,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // #define EE_HANDS
 
 #define SSD1306OLED
+#define USE_SSD_I2C
+
 
 #define USE_SERIAL_PD2
 

keyboards/crkbd/keymaps/hvp/keymap.c

@@ -1,13 +1,15 @@
 #include QMK_KEYBOARD_H
 #include "hvp.c"
+#ifdef SSD1306OLED
+#    include "ssd1306.h"
+#    include <string.h>
+#endif
 
 #ifdef RGBLIGHT_ENABLE
 //Following line allows macro to read current RGB settings
 extern rgblight_config_t rgblight_config;
 #endif
 
-extern uint8_t is_master;
-
 // Each layer gets a name for readability, which is then used in the keymap matrix below.
 // The underscores don't mean anything - you can have a layer called STUFF or any other name.
 // Layer names don't all need to be of the same length, obviously, and you can also skip them
@@ -25,7 +27,7 @@ enum custom_keycodes {
 };
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-  [_QWERTY] = LAYOUT(
+  [_QWERTY] = LAYOUT_split_3x6_3(
   //,-----------------------------------------.                ,-----------------------------------------.
      LT(_ADJUST,KC_TAB),  KC_Q,  KC_W,  KC_E,  KC_R,  KC_T,                   KC_Y,  KC_U,  KC_I,  KC_O,  KC_P,KC_BSPC,
   //|------+------+------+------+------+------|                |------+------+------+------+------+------|
@@ -37,7 +39,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
                               //`--------------------'  `--------------------'
   ),
 
-  [_RAISE] = LAYOUT( 
+  [_RAISE] = LAYOUT_split_3x6_3(
   //,-----------------------------------------.                ,-----------------------------------------.
      KC_GRV,  KC_1,  KC_2,  KC_3,  KC_4,  KC_5,                   KC_6,  KC_7,  KC_8,  KC_9,  KC_0,KC_BSPC,
   //|------+------+------+------+------+------|                |------+------+------+------+------+------|
@@ -49,7 +51,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
                               //`--------------------'  `--------------------'
   ),
 
-  [_LOWER] = LAYOUT(
+  [_LOWER] = LAYOUT_split_3x6_3(
   //,-----------------------------------------.                ,-----------------------------------------.
      KC_TAB,KC_EXLM,KC_AT,KC_HASH,KC_DLR,KC_PERC,              KC_CIRC,KC_AMPR,KC_ASTR,KC_LPRN,KC_RPRN,KC_BSPC,
   //|------+------+------+------+------+------|                |------+------+------+------+------+------|
@@ -61,7 +63,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
                               //`--------------------'  `--------------------'
   ),
 
-  [_ADJUST] = LAYOUT(
+  [_ADJUST] = LAYOUT_split_3x6_3(
   //,-----------------------------------------.                ,-----------------------------------------.
       _______,KC_F2, KC_F3, KC_F4, KC_F5, KC_F6,                  KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12,
   //|------+------+------+------+------+------|                |------+------+------+------+------+------|
@@ -91,7 +93,7 @@ void matrix_init_user(void) {
     #endif
     //SSD1306 OLED init, make sure to add #define SSD1306OLED in config.h
     #ifdef SSD1306OLED
-        iota_gfx_init(!has_usb());   // turns on the display
+        iota_gfx_init();   // turns on the display
     #endif
 }
 
@@ -115,10 +117,10 @@ void matrix_scan_user(void) {
 }
 
 void matrix_render_user(struct CharacterMatrix *matrix) {
-  if (is_master) {
+  if (is_keyboard_master()) {
     // If you want to change the display of OLED, you need to change here
-    matrix_write_ln(matrix, read_layer_state());
+    matrix_write(matrix, read_layer_state());
-    matrix_write_ln(matrix, read_keylog());
+    matrix_write(matrix, read_keylog());
     //matrix_write_ln(matrix, read_keylogs());
     //matrix_write_ln(matrix, read_mode_icon(keymap_config.swap_lalt_lgui));
     //matrix_write_ln(matrix, read_host_led_state());

keyboards/crkbd/keymaps/hvp/rules.mk

@@ -1,4 +1,7 @@
 
+VPATH += keyboards/crkbd/lib
+LIB_SRC += ssd1306.c i2c.c
+
 # If you want to change the display of OLED, you need to change here
 SRC +=  ./lib/glcdfont.c \
         ./lib/rgb_state_reader.c \

keyboards/crkbd/keymaps/jarred/config.h

@@ -29,6 +29,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // #define EE_HANDS
 
 #define SSD1306OLED
+#define USE_SSD_I2C
 
 #define USE_SERIAL_PD2
 

keyboards/crkbd/keymaps/jarred/keymap.c

@@ -9,8 +9,6 @@
   #include "ssd1306.h"
 #endif
 
-extern keymap_config_t keymap_config;
-extern uint8_t is_master;
 
 #ifdef RGBLIGHT_ENABLE
 //Following line allows macro to read current RGB settings
@@ -24,7 +22,7 @@ extern rgblight_config_t rgblight_config;
                    K31, K32, K33, K34, K35, K36 \
   )
 
-#define LAYOUT_crkbd_wrapper(...) LAYOUT(__VA_ARGS__)
+#define LAYOUT_crkbd_wrapper(...) LAYOUT_split_3x6_3(__VA_ARGS__)
 
 #define QWERTY_4_CRKBD KC_LCTL, MO(_LW), KC_SPC, KC_ENT, MO(_LW), KC_RALT
 
@@ -70,7 +68,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 void matrix_init_user(void) {
     //SSD1306 OLED init, make sure to add #define SSD1306OLED in config.h
     #ifdef SSD1306OLED
-        iota_gfx_init(!has_usb());   // turns on the display
+        iota_gfx_init();   // turns on the display
     #endif
 }
 
@@ -149,10 +147,13 @@ void matrix_scan_user(void) {
 }
 
 void matrix_render_user(struct CharacterMatrix *matrix) {
-  if (is_master) {
+  if (is_keyboard_master()) {
-    matrix_write_ln(matrix, read_layer_state());
+    matrix_write(matrix, read_layer_state());
-    matrix_write_ln(matrix, read_usb_state());
+    matrix_write(matrix, "\n");
-    matrix_write_ln(matrix, read_keylogs());
+    matrix_write(matrix, read_usb_state());
+    matrix_write(matrix, "\n");
+    matrix_write(matrix, read_keylogs());
+    matrix_write(matrix, "\n");
   } else {
     matrix_write(matrix, read_logo());
   }

keyboards/crkbd/keymaps/jarred/rules.mk

@@ -29,3 +29,6 @@ SRC +=  ./lib/glcdfont.c \
         # ./lib/mode_icon_reader.c \
         # ./lib/host_led_state_reader.c \
         # ./lib/timelogger.c \
+
+VPATH += keyboards/crkbd/lib
+LIB_SRC += ssd1306.c i2c.c

keyboards/crkbd/keymaps/kidbrazil/config.h

@@ -29,7 +29,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // #define MASTER_RIGHT
 // #define EE_HANDS
 
-//#define SSD1306OLED
+#define SSD1306OLED
+#define USE_SSD_I2C
 
 #define USE_SERIAL_PD2
 

keyboards/crkbd/keymaps/kidbrazil/keymap.c

@@ -1,9 +1,9 @@
 #include QMK_KEYBOARD_H
 #include "enums.h"
 #include "layer.h"
+#include "lufa.h"
 
 // [Init Variables] ----------------------------------------------------------//
-extern uint8_t is_master;
 // Oled timer similar to Drashna's
 static uint32_t oled_timer = 0;
 // Boolean to store LED state
@@ -13,35 +13,35 @@ bool master_oled_cleared = false;
 
 // [Keymaps] -----------------------------------------------------------------//
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-	  [_QWERTY] = LAYOUT(
+	  [_QWERTY] = LAYOUT_split_3x6_3(
       KC_ESC, KC_Q, KC_W, KC_E, KC_R, KC_T,                                  KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC,
       LSFT_T(KC_TAB), KC_A, KC_S, KC_D, KC_F, KC_G,                          KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT,
       KC_LCTL, KC_Z, KC_X, KC_C, KC_V, KC_B,                                 KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT,
                           LGUI_T(KC_PGUP), MO(_NUM), KC_SPC,         KC_ENT, MO(_SYM), LALT_T(KC_PGDN)
     ),
 
-	  [_NUM] = LAYOUT(
+	  [_NUM] = LAYOUT_split_3x6_3(
       KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5,                                      KC_6, KC_7, KC_8, KC_9, KC_0, KC_DEL,
       LSFT_T(KC_TAB), KC_F1, KC_F2, KC_F3, KC_F4, KC_F5,                         KC_LEFT, KC_DOWN, KC_UP, KC_RGHT, KC_F12, KC_NO,
       KC_LCTL, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10,                               KC_PGUP, KC_PGDN, KC_HOME, KC_END, KC_F11, KC_NO,
                                LGUI_T(KC_PGUP), KC_TRNS, KC_SPC,         KC_ENT, KC_TRNS, LALT_T(KC_PGDN)
     ),
 
-	  [_SYM] = LAYOUT(
+	  [_SYM] = LAYOUT_split_3x6_3(
       KC_ESC, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC,                                   KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_BSPC,
       LSFT_T(KC_TAB), RGB_TOG, KC_MPLY, KC_MUTE, KC_VOLU, KC_VOLD,                        KC_MINS, KC_EQL, KC_LCBR, KC_RCBR, KC_PIPE, KC_GRV,
       KC_LCTL, KC_CALC, KC_MYCM, KC_MPRV, KC_MNXT, TG(_GAME),                             KC_UNDS, KC_PLUS, KC_LBRC, KC_RBRC, KC_BSLS, KC_TILD,
                                           LGUI_T(KC_PGUP), KC_TRNS, KC_SPC,       KC_ENT, KC_TRNS, LALT_T(KC_PGDN)
     ),
 
-	  [_GAME] = LAYOUT(
+	  [_GAME] = LAYOUT_split_3x6_3(
       KC_ESC, KC_Q, KC_W, KC_E, KC_R, KC_T,                                   KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6,
       KC_LSFT, KC_A, KC_S, KC_D, KC_F, KC_G,                                  KC_F7, KC_F8, KC_F9, KC_F10, KC_NO, KC_NO,
       KC_LCTL, KC_Z, KC_X, KC_C, KC_V, KC_TRNS,                               KC_PGUP, KC_PGDN, KC_NO, KC_NO, KC_NO, KC_NO,
                             KC_TAB, MO(_WEAPON), KC_SPC,              KC_ENT, KC_TRNS, KC_NO
       ),
 
-	  [_WEAPON] = LAYOUT(
+	  [_WEAPON] = LAYOUT_split_3x6_3(
       KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5,                                   KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
       KC_TRNS, KC_LSFT, KC_A, KC_S, KC_D, KC_F,                               KC_6, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
       KC_TRNS, KC_LCTL, KC_Z, KC_X, KC_C, KC_V,                               KC_7, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, EEP_RST,
@@ -128,7 +128,7 @@ void matrix_scan_user(void) {
 #ifdef OLED_DRIVER_ENABLE
 // Init Oled and Rotate....
 oled_rotation_t oled_init_user(oled_rotation_t rotation) {
-    if (!has_usb())
+    if (!is_keyboard_master())
       return OLED_ROTATION_180;  // flips the display 180 to see it from my side
     return rotation;
 }
@@ -176,7 +176,7 @@ void oled_task_user(void) {
     // First time out switches to logo as first indication of iddle.
     if (timer_elapsed32(oled_timer) > 100000 && timer_elapsed32(oled_timer) < 479999) {
         // Render logo on both halves before full timeout
-        if (is_master && !master_oled_cleared) {
+        if (is_keyboard_master() && !master_oled_cleared) {
             // Clear master OLED once so the logo renders properly
             oled_clear();
             master_oled_cleared = true;
@@ -202,7 +202,7 @@ void oled_task_user(void) {
                 render_logo();
                 break;
             default:
-                if (is_master) {
+                if (is_keyboard_master()) {
                     render_master_oled();
                 } else {
                     render_slave_oled();

keyboards/crkbd/keymaps/kidbrazil/layer.c

@@ -1,5 +1,6 @@
 #include QMK_KEYBOARD_H
 #include "enums.h"
+#include "lufa.h"
 
 // Render Blank Space
 void render_space(void) {

keyboards/crkbd/keymaps/kidbrazil/rules.mk

@@ -10,3 +10,6 @@ OLED_DRIVER_ENABLE = yes
 # If you want to change the display of OLED, you need to change here
 SRC +=  logo_reader.c \
 				layer.c
+
+VPATH += keyboards/crkbd/lib
+LIB_SRC += ssd1306.c i2c.c

keyboards/crkbd/keymaps/madhatter/config.h

@@ -29,6 +29,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // #define EE_HANDS
 
 #define SSD1306OLED
+#define USE_SSD_I2C
 
 #define USE_SERIAL_PD2
 

keyboards/crkbd/keymaps/madhatter/keymap.c

@@ -17,8 +17,10 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include QMK_KEYBOARD_H
-
+#ifdef SSD1306OLED
-extern uint8_t is_master;
+#    include "ssd1306.h"
+#    include <string.h>
+#endif
 
 enum corny_layers {
   _QWERTY,
@@ -108,7 +110,7 @@ void matrix_init_user(void) {
     #endif
     //SSD1306 OLED init, make sure to add #define SSD1306OLED in config.h
     #ifdef SSD1306OLED
-        iota_gfx_init(!has_usb());   // turns on the display
+        iota_gfx_init();   // turns on the display
     #endif
 }
 
@@ -132,10 +134,10 @@ void matrix_scan_user(void) {
 }
 
 void matrix_render_user(struct CharacterMatrix *matrix) {
-  if (is_master) {
+  if (is_keyboard_master()) {
     // If you want to change the display of OLED, you need to change here
-    matrix_write_ln(matrix, read_layer_state());
+    matrix_write(matrix, read_layer_state());
-    matrix_write_ln(matrix, read_keylog());
+    matrix_write(matrix, read_keylog());
     //matrix_write_ln(matrix, read_keylogs());
     //matrix_write_ln(matrix, read_mode_icon(keymap_config.swap_lalt_lgui));
     //matrix_write_ln(matrix, read_host_led_state());

keyboards/crkbd/keymaps/madhatter/rules.mk

@@ -8,3 +8,6 @@ SRC +=  ./lib/glcdfont.c \
         # ./lib/mode_icon_reader.c \
         # ./lib/host_led_state_reader.c \
         # ./lib/timelogger.c \
+
+VPATH += keyboards/crkbd/lib
+LIB_SRC += ssd1306.c i2c.c

keyboards/crkbd/keymaps/manna-harbour_miryoku/config.h

@@ -8,7 +8,7 @@
        K20,   K21,   K22,   K23,   K24,   K25,   K26,   K27,   K28,   K29, \
        N30,   N31,   K32,   K33,   K34,   K35,   K36,   K37,   N38,   N39 \
 ) \
-LAYOUT( \
+LAYOUT_split_3x6_3( \
 KC_NO, K00,   K01,   K02,   K03,   K04,   K05,   K06,   K07,   K08,   K09,   KC_NO, \
 KC_NO, K10,   K11,   K12,   K13,   K14,   K15,   K16,   K17,   K18,   K19,   KC_NO, \
 KC_NO, K20,   K21,   K22,   K23,   K24,   K25,   K26,   K27,   K28,   K29,   KC_NO, \

keyboards/crkbd/keymaps/mcrown/oled.c

@@ -113,7 +113,7 @@ inline static char get_ascii(int16_t keycode){
 oled_rotation_t oled_init_user(oled_rotation_t rotation){
     oled_rotation_t oled_rot=OLED_ROTATION_180;
 
-    if(true==is_master){
+    if(true==is_keyboard_master()){
 #ifdef OLED_VERTICAL
         oled_rot=OLED_ROTATION_270;
 #else
@@ -313,7 +313,7 @@ void oled_task_user(void){
         oled_off();
     }else{
         oled_on();
-        if(true==is_master){
+        if(true==is_keyboard_master()){
             render_status();
         }else{
             render_logo();

keyboards/crkbd/keymaps/ninjonas/config.h

@@ -86,3 +86,5 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #define OLED_FONT_H "keyboards/crkbd/lib/glcdfont.c"
 #define OLED_DISABLE_TIMEOUT
+
+#define LAYOUT LAYOUT_split_3x6_3

keyboards/crkbd/keymaps/ninjonas/keymap.c

@@ -1,6 +1,8 @@
 #include QMK_KEYBOARD_H
 #include "ninjonas.h"
 
+uint8_t is_master;
+
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   [_QWERTY] = LAYOUT_wrapper(
   //,----------------------------------------------------.      ,----------------------------------------------------.

keyboards/crkbd/keymaps/oled_sample/keymap.c

@@ -38,21 +38,21 @@ enum crkbd_layers {
 #define ALTKN ALT_T(KC_LANG1)
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-  [_QWERTY] = LAYOUT(
+  [_QWERTY] = LAYOUT_split_3x6_3(
     KC_ESC,  KC_Q,    KC_W,    KC_E,    KC_R,     KC_T,                      KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_BSPC,
     CTLTB,   KC_A,    KC_S,    KC_D,    KC_F,     KC_G,                      KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT,
     KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,     KC_B,                      KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_RSFT,
                                         GUIEI,    LOWER,   KC_SPC,  KC_ENT,  RAISE,   ALTKN
   ),
 
-  [_LOWER] = LAYOUT(
+  [_LOWER] = LAYOUT_split_3x6_3(
     KC_ESC,  KC_1,    KC_2,    KC_3,    KC_4,     KC_5,                      KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_BSPC,
     CTLTB,   KC_F1,   KC_F2,   KC_F3,   KC_F4,    KC_F5,                     KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  XXXXXXX,
     KC_LSFT, KC_F11,  KC_F12,  KC_F13,  KC_F14,   KC_F15,                    KC_F16,  KC_F17,  KC_F18,  KC_F19,  KC_F20,  XXXXXXX,
                                         GUIEI,    LOWER,   KC_SPC,  KC_ENT,  RAISE,   ALTKN
   ),
 
-  [_RAISE] = LAYOUT(
+  [_RAISE] = LAYOUT_split_3x6_3(
     KC_ESC,  KC_EXLM, KC_AT,   KC_HASH, KC_DLR,  KC_PERC,                   KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_BSPC,
     CTLTB,   XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,                   KC_MINS, KC_EQL,  KC_LCBR, KC_RCBR, KC_PIPE, KC_GRV,
     KC_LSFT, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,                   KC_UNDS, KC_PLUS, KC_LBRC, KC_RBRC, KC_BSLS, KC_TILD,
@@ -60,7 +60,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
   ),
 
-  [_ADJUST] = LAYOUT(
+  [_ADJUST] = LAYOUT_split_3x6_3(
     RESET,   XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,                   XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
     RGB_TOG, RGB_HUI, RGB_SAI, RGB_VAI, XXXXXXX, XXXXXXX,                   XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
     RGB_MOD, RGB_HUD, RGB_SAD, RGB_VAD, XXXXXXX, XXXXXXX,                   XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
@@ -192,7 +192,7 @@ void render_status_main(void) {
 
 void oled_task_user(void) {
     update_log();
-    if (is_master) {
+    if (is_keyboard_master()) {
         render_status_main();  // Renders the current keyboard state (layer, lock, caps, scroll, etc)
     } else {
         render_crkbd_logo();

keyboards/crkbd/keymaps/oo/keymap.c

@@ -61,8 +61,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
 
 #ifdef OLED_DRIVER_ENABLE
+#include <stdio.h>
 oled_rotation_t oled_init_user(oled_rotation_t rotation) {
-  if (!is_master) {
+  if (!is_keyboard_master()) {
     return OLED_ROTATION_180;  // flips the display 180 degrees if offhand
   }
   return rotation;
@@ -148,7 +149,7 @@ void oled_render_logo(void) {
 }
 
 void oled_task_user(void) {
-    if (is_master) {
+    if (is_keyboard_master()) {
         oled_render_layer_state();
         oled_render_keylog();
     } else {

keyboards/crkbd/keymaps/rjhilgefort/keymap.c

@@ -104,8 +104,10 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 };
 
 #ifdef OLED_DRIVER_ENABLE
+#    include <stdio.h>
+
 oled_rotation_t oled_init_user(oled_rotation_t rotation) {
-  if (!is_master) {
+  if (!is_keyboard_master()) {
     return OLED_ROTATION_180;  // flips the display 180 degrees if offhand
   }
   return rotation;
@@ -203,7 +205,7 @@ void oled_render_logo(void) {
 }
 
 void oled_task_user(void) {
-    if (is_master) {
+    if (is_keyboard_master()) {
         oled_render_layer_state();
         oled_render_keylog();
     } else {

keyboards/crkbd/keymaps/rpbaptist/keymap.c

@@ -1,6 +1,5 @@
 #include QMK_KEYBOARD_H
 
-extern uint8_t  is_master;
 static uint32_t oled_timer = 0;
 
 #ifdef RGB_MATRIX_ENABLE
@@ -84,7 +83,7 @@ user_config_t user_config;
 #define KC_EUR ALGR(KC_5)
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-  [_COLEMAKDHM] = LAYOUT( \
+  [_COLEMAKDHM] = LAYOUT_split_3x6_3( \
   //,-----------------------------------------------------.                    ,-----------------------------------------------------.
        KC_ESC,    KC_Q,    KC_W,    KC_F,    KC_P,    KC_B,                         KC_J,    KC_L,    KC_U,    KC_Y, KC_SCLN, BSP_DEL,\
   //|--------+--------+--------+--------+--------+--------|                    |--------+--------+--------+--------+--------+--------|
@@ -96,7 +95,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
                                       //`--------------------------'  `--------------------------'
   ),
 
-  [_GAMING] = LAYOUT( \
+  [_GAMING] = LAYOUT_split_3x6_3( \
   //,-----------------------------------------------------.                    ,-----------------------------------------------------.
       _______, _______, _______, _______, _______, _______,                      _______, _______, _______, _______, _______, KC_BSPC,\
   //|--------+--------+--------+--------+--------+--------|                    |--------+--------+--------+--------+--------+--------|
@@ -108,7 +107,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
                                       //`--------------------------'  `--------------------------'
   ),
 
-  [_GAMING_EXT] = LAYOUT( \
+  [_GAMING_EXT] = LAYOUT_split_3x6_3( \
   //,-----------------------------------------------------.                    ,-----------------------------------------------------.
        KC_GRV,    KC_1,    KC_2, _______,    KC_3,    KC_4,                      _______, _______, _______, _______, _______,  KC_DEL,\
   //|--------+--------+--------+--------+--------+--------|                    |--------+--------+--------+--------+--------+--------|
@@ -120,7 +119,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
                                       //`--------------------------'  `--------------------------'
   ),
 
-  [_NUMPAD] = LAYOUT( \
+  [_NUMPAD] = LAYOUT_split_3x6_3( \
   //,-----------------------------------------------------.                    ,-----------------------------------------------------.
       _______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,                       KC_EUR,   KC_P7,   KC_P8,   KC_P9, XXXXXXX, _______,\
   //|--------+--------+--------+--------+--------+--------|                    |--------+--------+--------+--------+--------+--------|
@@ -132,7 +131,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
                                       //`--------------------------'  `--------------------------'
   ),
 
-  [_SYM] = LAYOUT( \
+  [_SYM] = LAYOUT_split_3x6_3( \
   //,-----------------------------------------------------.                    ,-----------------------------------------------------.
        KC_GRV,    KC_1,    KC_2,    KC_3,    KC_4,    KC_5,                         KC_6,    KC_7,    KC_8,    KC_9,    KC_0, _______,\
   //|--------+--------+--------+--------+--------+--------|                    |--------+--------+--------+--------+--------+--------|
@@ -144,7 +143,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
                                       //`--------------------------'  `--------------------------'
   ),
 
-  [_NAV] = LAYOUT( \
+  [_NAV] = LAYOUT_split_3x6_3( \
   //,-----------------------------------------------------.                    ,-----------------------------------------------------.
        KC_GRV,   KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,                      KC_PGUP, KC_HOME,   KC_UP,  KC_END, XXXXXXX, KC_BSPC,\
   //|--------+--------+--------+--------+--------+--------|                    |--------+--------+--------+--------+--------+--------|
@@ -156,7 +155,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
                                       //`--------------------------'  `--------------------------'
   ),
 
-  [_UTIL] = LAYOUT( \
+  [_UTIL] = LAYOUT_split_3x6_3( \
   //,-----------------------------------------------------.                    ,-----------------------------------------------------.
         RESET, XXXXXXX, KC_MPRV, KC_VOLU, KC_MNXT, COLEMAK,                      RGB_IDL, RGB_MAP, RGB_NXS, XXXXXXX, RGB_HUD, RGB_HUI,\
   //|--------+--------+--------+--------+--------+--------|                    |--------+--------+--------+--------+--------+--------|
@@ -183,7 +182,7 @@ layer_state_t layer_state_set_user(layer_state_t state) {
 
 #ifdef OLED_DRIVER_ENABLE
 oled_rotation_t oled_init_user(oled_rotation_t rotation) {
-    if (is_master) {
+    if (is_keyboard_master()) {
         return OLED_ROTATION_270;
     } else {
         return OLED_ROTATION_180;
@@ -299,7 +298,7 @@ void oled_task_user(void) {
         oled_on();
     }
 
-    if (is_master) {
+    if (is_keyboard_master()) {
         render_status();  // Renders the current keyboard state (layer, lock, caps, scroll, etc)
     } else {
         render_crkbd_logo();
@@ -344,7 +343,7 @@ void check_default_layer(uint8_t type) {
 
 void rgb_matrix_indicators_user(void) {
   if (
-    user_config.rgb_layer_change && !g_suspend_state && rgb_matrix_config.enable &&
+    user_config.rgb_layer_change && rgb_matrix_config.enable &&
       (!user_config.rgb_matrix_idle_anim || rgb_matrix_get_mode() != user_config.rgb_matrix_idle_mode)
   )
     {

keyboards/crkbd/keymaps/rs/config.h

@@ -28,7 +28,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // #define MASTER_RIGHT
 // #define EE_HANDS
 
-#define SSD1306OLED
+// #define SSD1306OLED
 
 #define USE_SERIAL_PD2
 

keyboards/crkbd/keymaps/soundmonster/keymap.c

@@ -11,8 +11,6 @@ extern rgblight_config_t rgblight_config;
 static uint32_t oled_timer = 0;
 #endif
 
-extern uint8_t is_master;
-
 // Each layer gets a name for readability, which is then used in the keymap matrix below.
 // The underscores don't mean anything - you can have a layer called STUFF or any other name.
 // Layer names don't all need to be of the same length, obviously, and you can also skip them
@@ -38,7 +36,7 @@ enum custom_keycodes {
 };
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-  [_QWERTY] = LAYOUT(
+  [_QWERTY] = LAYOUT_split_3x6_3(
   //,-----------------------------------------.                ,---------------------------------------------.
      KC_TAB,  KC_Q,  KC_W,  KC_E,  KC_R,  KC_T,                   KC_Y,  KC_U,  KC_I,  KC_O,  KC_P,  KC_BSPC,
   //|------+------+------+------+------+------|                |------+------+-------+------+-------+--------|
@@ -50,7 +48,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
                               //`--------------------'  `--------------------'
   ),
 
-  [_LOWER] = LAYOUT(
+  [_LOWER] = LAYOUT_split_3x6_3(
   //,---------------------------------------------.                ,-----------------------------------------.
      KC_ESC,  KC_1, KC_2,   KC_3,   KC_4,   KC_5,                    KC_6,  KC_7,  KC_8,  KC_9,  KC_0, KC_DEL,
   //|------+------+-------+-------+-------+-------|                |------+------+------+------+------+------|
@@ -62,7 +60,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
                                   //`--------------------'  `--------------------'
   ),
 
-  [_RAISE] = LAYOUT(
+  [_RAISE] = LAYOUT_split_3x6_3(
   //,-----------------------------------------.                ,-----------------------------------------.
      KC_ESC,KC_EXLM,KC_AT,KC_HASH,KC_DLR,KC_PERC,              KC_CIRC,KC_AMPR,KC_ASTR,KC_LPRN,KC_RPRN,KC_BSPC,
   //|------+------+------+------+------+------|                |------+------+------+------+------+------|
@@ -74,7 +72,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
                               //`--------------------'  `--------------------'
   ),
 
-  [_ADJUST] = LAYOUT(
+  [_ADJUST] = LAYOUT_split_3x6_3(
   //,-----------------------------------------.                ,-----------------------------------------.
       RESET,RGBRST, KC_NO, KC_NO, KC_NO, KC_NO,                  KC_NO,KC__MUTE, KC_NO, KC_NO, KC_NO, KC_NO,
   //|------+------+------+------+------+------|                |------+------+------+------+------+------|
@@ -311,7 +309,7 @@ void oled_task_user(void) {
     else { oled_on(); }
 #endif
 
-    if (is_master) {
+    if (is_keyboard_master()) {
         render_status_main();  // Renders the current keyboard state (layer, lock, caps, scroll, etc)
     } else {
         render_status_secondary();

keyboards/crkbd/keymaps/thumb_ctrl/config.h

@@ -28,7 +28,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // #define MASTER_RIGHT
 // #define EE_HANDS
 
-#define SSD1306OLED
+// #define SSD1306OLED
 
 #define USE_SERIAL_PD2
 

keyboards/crkbd/keymaps/thumb_ctrl/keymap.c

@@ -15,8 +15,6 @@ extern keymap_config_t keymap_config;
 extern rgblight_config_t rgblight_config;
 #endif
 
-extern uint8_t is_master;
-
 // Each layer gets a name for readability, which is then used in the keymap matrix below.
 // The underscores don't mean anything - you can have a layer called STUFF or any other name.
 // Layer names don't all need to be of the same length, obviously, and you can also skip them
@@ -250,4 +248,3 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   }
   return true;
 }
-

keyboards/crkbd/keymaps/thumb_ctrl/rules.mk

@@ -29,3 +29,6 @@ SRC +=  ./lib/glcdfont.c \
         # ./lib/mode_icon_reader.c \
         # ./lib/host_led_state_reader.c \
         # ./lib/timelogger.c \
+
+VPATH += keyboards/crkbd/lib
+LIB_SRC += ssd1306.c i2c.c

keyboards/crkbd/keymaps/via/keymap.c

@@ -70,8 +70,10 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 };
 
 #ifdef OLED_DRIVER_ENABLE
+#include <stdio.h>
+
 oled_rotation_t oled_init_user(oled_rotation_t rotation) {
-  if (!is_master) {
+  if (!is_keyboard_master()) {
     return OLED_ROTATION_180;  // flips the display 180 degrees if offhand
   }
   return rotation;
@@ -157,7 +159,7 @@ void oled_render_logo(void) {
 }
 
 void oled_task_user(void) {
-    if (is_master) {
+    if (is_keyboard_master()) {
         oled_render_layer_state();
         oled_render_keylog();
     } else {

keyboards/crkbd/keymaps/vlukash_trackpad_left/config.h

@@ -6,6 +6,7 @@
 // #define EE_HANDS
 
 #define SSD1306OLED
+#define USE_SSD_I2C
 
 #define USE_SERIAL_PD2
 

keyboards/crkbd/keymaps/vlukash_trackpad_left/keymap.c

@@ -13,8 +13,6 @@
 extern rgblight_config_t rgblight_config;
 #endif
 
-extern uint8_t is_master;
-
 enum layer_names {
   _QWERTY,
   _LOWER,
@@ -126,7 +124,7 @@ void matrix_init_user(void) {
     #endif
     //SSD1306 OLED init, make sure to add #define SSD1306OLED in config.h
     #ifdef SSD1306OLED
-        iota_gfx_init(!has_usb());   // turns on the display
+        iota_gfx_init();   // turns on the display
     #endif
 }
 
@@ -145,11 +143,14 @@ void matrix_scan_user(void) {
 }
 
 void matrix_render_user(struct CharacterMatrix *matrix) {
-  if (is_master) {
+  if (is_keyboard_master()) {
     // If you want to change the display of OLED, you need to change here
-    matrix_write_ln(matrix, read_layer_state());
+    matrix_write(matrix, read_layer_state());
-    matrix_write_ln(matrix, read_keylog());
+    matrix_write(matrix, "\n");
-    matrix_write_ln(matrix, read_keylogs());
+    matrix_write(matrix, read_keylog());
+    matrix_write(matrix, "\n");
+    matrix_write(matrix, read_keylogs());
+    matrix_write(matrix, "\n");
   } else {
     matrix_write(matrix, read_logo());
   }
@@ -222,4 +223,3 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   }
   return true;
 }
-

keyboards/crkbd/keymaps/vlukash_trackpad_left/rules.mk

@@ -9,3 +9,6 @@ SRC +=  ./lib/glcdfont.c \
         ./lib/layer_state_reader.c \
         ./lib/logo_reader.c \
         ./lib/keylogger.c \
+
+VPATH += keyboards/crkbd/lib
+LIB_SRC += ssd1306.c i2c.c

keyboards/crkbd/keymaps/vlukash_trackpad_right/keymap.c

@@ -16,7 +16,6 @@ extern bool isScrollMode;
 extern rgblight_config_t rgblight_config;
 #endif
 
-extern uint8_t is_master;
 
 enum layer_names {
   _QWERTY,

keyboards/crkbd/keymaps/vxid/config.h

@@ -29,6 +29,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // #define EE_HANDS
 
 #define SSD1306OLED
+#define USE_SSD_I2C
 
 #define USE_SERIAL_PD2
 

keyboards/crkbd/keymaps/vxid/keymap.c

@@ -7,8 +7,6 @@
 
 extern keymap_config_t keymap_config;
 
-extern uint8_t is_master;
-
 #define _QWERTY 0
 #define _LOWER 1
 #define _RAISE 2

keyboards/crkbd/keymaps/vxid/rules.mk

@@ -29,3 +29,6 @@ SRC +=  ./lib/glcdfont.c \
         # ./lib/mode_icon_reader.c \
         # ./lib/host_led_state_reader.c \
         # ./lib/timelogger.c \
+
+VPATH += keyboards/crkbd/lib
+LIB_SRC += ssd1306.c i2c.c

keyboards/crkbd/keymaps/xyverz/keymap.c

@@ -17,6 +17,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include QMK_KEYBOARD_H
+#include <stdio.h>
 
 enum layer_names {
   _DVORAK,
@@ -101,7 +102,7 @@ layer_state_t layer_state_set_user(layer_state_t state) {
 
 #ifdef OLED_DRIVER_ENABLE
 oled_rotation_t oled_init_user(oled_rotation_t rotation) {
-  if (!is_master) {
+  if (!is_keyboard_master()) {
     return OLED_ROTATION_180;  // flips the display 180 degrees if offhand
   }
   return rotation;
@@ -187,7 +188,7 @@ void oled_render_logo(void) {
 }
 
 void oled_task_user(void) {
-    if (is_master) {
+    if (is_keyboard_master()) {
         oled_render_layer_state();
         oled_render_keylog();
     } else {

keyboards/crkbd/lib/i2c.c

@@ -6,7 +6,7 @@
 #include <stdbool.h>
 #include "i2c.h"
 
-#if defined(USE_I2C) || defined(USE_MATRIX_I2C)
+#if defined(USE_SSD_I2C)
 
 // Limits the amount of we wait for any one i2c transaction.
 // Since were running SCL line 100kHz (=> 10μs/bit), and each transactions is

keyboards/crkbd/rev1/common/common.c

@@ -1,19 +0,0 @@
-/*
-Copyright 2019 @foostan
-Copyright 2020 Drashna Jaelre <@drashna>
-
-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 "common.h"

keyboards/crkbd/rev1/common/common.h

@@ -1,24 +0,0 @@
-/*
-Copyright 2019 @foostan
-Copyright 2020 Drashna Jaelre <@drashna>
-
-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/>.
-*/
-
-#pragma once
-
-#include "rev1.h"
-
-#define has_usb() is_keyboard_master()
-#define is_master is_keyboard_master()

keyboards/crkbd/rev1/common/config.h

@@ -1,29 +0,0 @@
-/*
-Copyright 2019 @foostan
-Copyright 2020 Drashna Jaelre <@drashna>
-
-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/>.
-*/
-
-#pragma once
-
-#define USE_SERIAL
-#define SOFT_SERIAL_PIN D2
-
-#ifdef RGB_MATRIX_ENABLE
-#    define RGB_MATRIX_SPLIT { 27, 27 }
-#    define SPLIT_TRANSPORT_MIRROR
-#endif
-
-#define DIODE_DIRECTION COL2ROW

keyboards/crkbd/rev1/common/rules.mk

@@ -1 +1 @@
-SPLIT_KEYBOARD = yes
+DEFAULT_FOLDER = crkbd/rev1

keyboards/crkbd/rev1/config.h

@@ -18,6 +18,9 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #pragma once
 
+#define USE_SERIAL
+#define SOFT_SERIAL_PIN D2
+
 /* ws2812 RGB LED */
 #define RGB_DI_PIN D3
 
@@ -29,4 +32,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #ifdef RGB_MATRIX_ENABLE
 #    define RGBLED_NUM 54  // Number of LEDs
 #    define DRIVER_LED_TOTAL RGBLED_NUM
+#    define RGB_MATRIX_SPLIT { 27, 27 }
+#    define SPLIT_TRANSPORT_MIRROR
 #endif
+
+#define DIODE_DIRECTION COL2ROW

keyboards/crkbd/rev1/legacy/config.h

@@ -1,22 +0,0 @@
-/*
-Copyright 2012 Jun Wako <wakojun@gmail.com>
-Copyright 2015 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
-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/>.
-*/
-
-#pragma once
-
-#include "serial_config.h"
-

keyboards/crkbd/rev1/legacy/legacy.c

@@ -1,19 +0,0 @@
-/*
-Copyright 2019 @foostan
-Copyright 2020 Drashna Jaelre <@drashna>
-
-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 "legacy.h"

keyboards/crkbd/rev1/legacy/legacy.h

@@ -1,23 +0,0 @@
-/*
-Copyright 2019 @foostan
-Copyright 2020 Drashna Jaelre <@drashna>
-
-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/>.
-*/
-
-#pragma once
-
-#include "rev1.h"
-
-extern uint8_t is_master;

keyboards/crkbd/rev1/legacy/matrix.c

@@ -1,397 +0,0 @@
-/*
-Copyright 2012 Jun Wako <wakojun@gmail.com>
-
-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/>.
-*/
-
-/*
- * scan matrix
- */
-#include <stdint.h>
-#include <stdbool.h>
-#include <string.h>
-#include <avr/io.h>
-#include <avr/wdt.h>
-#include <avr/interrupt.h>
-#include <util/delay.h>
-#include "print.h"
-#include "debug.h"
-#include "util.h"
-#include "matrix.h"
-#include "split_util.h"
-#include "quantum.h"
-
-#ifdef USE_MATRIX_I2C
-#  include "i2c.h"
-#else // USE_SERIAL
-#  include "split_scomm.h"
-#endif
-
-#ifndef DEBOUNCE
-#  define DEBOUNCE	5
-#endif
-
-#define ERROR_DISCONNECT_COUNT 5
-
-static uint8_t debouncing = DEBOUNCE;
-static const int ROWS_PER_HAND = MATRIX_ROWS/2;
-static uint8_t error_count = 0;
-uint8_t is_master = 0 ;
-
-static const uint8_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
-static const uint8_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
-
-/* matrix state(1:on, 0:off) */
-static matrix_row_t matrix[MATRIX_ROWS];
-static matrix_row_t matrix_debouncing[MATRIX_ROWS];
-
-static matrix_row_t read_cols(void);
-static void init_cols(void);
-static void unselect_rows(void);
-static void select_row(uint8_t row);
-static uint8_t matrix_master_scan(void);
-
-
-__attribute__ ((weak))
-void matrix_init_kb(void) {
-    matrix_init_user();
-}
-
-__attribute__ ((weak))
-void matrix_scan_kb(void) {
-    matrix_scan_user();
-}
-
-__attribute__ ((weak))
-void matrix_init_user(void) {
-}
-
-__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;
-}
-
-void tx_rx_leds_init(void)
-{
-#ifndef NO_DEBUG_LEDS
-    setPinOutput(B0);
-    setPinOutput(D5);
-    writePinHigh(B0);
-    writePinHigh(D5);
-#endif
-}
-
-void tx_led_on(void)
-{
-#ifndef NO_DEBUG_LEDS
-    writePinLow(D5);
-#endif
-}
-
-void tx_led_off(void)
-{
-#ifndef NO_DEBUG_LEDS
-    writePinHigh(D5);
-#endif
-}
-
-void rx_led_on(void)
-{
-#ifndef NO_DEBUG_LEDS
-    writePinLow(B0);
-#endif
-}
-
-void rx_led_off(void)
-{
-#ifndef NO_DEBUG_LEDS
-    writePinHigh(B0);
-#endif
-}
-
-
-void matrix_init(void)
-{
-    split_keyboard_setup();
-
-    // initialize row and col
-    unselect_rows();
-    init_cols();
-
-    tx_rx_leds_init();
-
-    // initialize matrix state: all keys off
-    for (uint8_t i=0; i < MATRIX_ROWS; i++) {
-        matrix[i] = 0;
-        matrix_debouncing[i] = 0;
-    }
-
-    is_master = has_usb();
-
-    matrix_init_quantum();
-}
-
-uint8_t _matrix_scan(void)
-{
-    bool changed = false;
-    // Right hand is stored after the left in the matirx so, we need to offset it
-    int offset = isLeftHand ? 0 : (ROWS_PER_HAND);
-
-    for (uint8_t i = 0; i < ROWS_PER_HAND; i++) {
-        select_row(i);
-        _delay_us(30);  // without this wait read unstable value.
-        matrix_row_t cols = read_cols();
-        if (matrix_debouncing[i+offset] != cols) {
-            changed = true;
-            matrix_debouncing[i+offset] = cols;
-            debouncing = DEBOUNCE;
-        }
-        unselect_rows();
-    }
-
-    if (debouncing) {
-        if (--debouncing) {
-            _delay_ms(1);
-        } else {
-            for (uint8_t i = 0; i < ROWS_PER_HAND; i++) {
-                matrix[i+offset] = matrix_debouncing[i+offset];
-            }
-        }
-    }
-
-    return changed;
-}
-
-#ifdef USE_MATRIX_I2C
-
-// Get rows from other half over i2c
-int i2c_transaction(void) {
-    int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
-
-    int err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE);
-    if (err) goto i2c_error;
-
-    // start of matrix stored at 0x00
-    err = i2c_master_write(0x00);
-    if (err) goto i2c_error;
-
-    // Start read
-    err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_READ);
-    if (err) goto i2c_error;
-
-    if (!err) {
-        int i;
-        for (i = 0; i < ROWS_PER_HAND-1; ++i) {
-            matrix[slaveOffset+i] = i2c_master_read(I2C_ACK);
-        }
-        matrix[slaveOffset+i] = i2c_master_read(I2C_NACK);
-        i2c_master_stop();
-    } else {
-i2c_error: // the cable is disconnceted, or something else went wrong
-        i2c_reset_state();
-        return err;
-    }
-
-    return 0;
-}
-
-#else // USE_SERIAL
-
-int serial_transaction(int master_changed) {
-    int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
-#ifdef SERIAL_USE_MULTI_TRANSACTION
-    int ret=serial_update_buffers(master_changed);
-#else
-    int ret=serial_update_buffers();
-#endif
-    if (ret ) {
-        if(ret==2) rx_led_on();
-        return 1;
-    }
-    rx_led_off();
-    memcpy(&matrix[slaveOffset],
-        (void *)serial_slave_buffer, SERIAL_SLAVE_BUFFER_LENGTH);
-    return 0;
-}
-#endif
-
-uint8_t matrix_scan(void)
-{
-    bool changed = false;
-    if (is_master) {
-        changed |= matrix_master_scan();
-    }else{
-        changed |= matrix_slave_scan();
-        int offset = (isLeftHand) ? ROWS_PER_HAND : 0;
-        memcpy(&matrix[offset],
-               (void *)serial_master_buffer, SERIAL_MASTER_BUFFER_LENGTH);
-        matrix_scan_quantum();
-    }
-    return (uint8_t) changed;
-}
-
-
-uint8_t matrix_master_scan(void) {
-
-    int ret = _matrix_scan();
-    int mchanged = 1;
-
-    int offset = (isLeftHand) ? 0 : ROWS_PER_HAND;
-
-#ifdef USE_MATRIX_I2C
-//    for (int i = 0; i < ROWS_PER_HAND; ++i) {
-        /* i2c_slave_buffer[i] = matrix[offset+i]; */
-//        i2c_slave_buffer[i] = matrix[offset+i];
-//    }
-#else // USE_SERIAL
-  #ifdef SERIAL_USE_MULTI_TRANSACTION
-    mchanged = memcmp((void *)serial_master_buffer,
-		      &matrix[offset], SERIAL_MASTER_BUFFER_LENGTH);
-  #endif
-    memcpy((void *)serial_master_buffer,
-	   &matrix[offset], SERIAL_MASTER_BUFFER_LENGTH);
-#endif
-
-#ifdef USE_MATRIX_I2C
-    if( i2c_transaction() ) {
-#else // USE_SERIAL
-    if( serial_transaction(mchanged) ) {
-#endif
-        // turn on the indicator led when halves are disconnected
-        tx_led_on();
-
-        error_count++;
-
-        if (error_count > ERROR_DISCONNECT_COUNT) {
-            // reset other half if disconnected
-            int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
-            for (int i = 0; i < ROWS_PER_HAND; ++i) {
-                matrix[slaveOffset+i] = 0;
-            }
-        }
-    } else {
-        // turn off the indicator led on no error
-        tx_led_off();
-        error_count = 0;
-    }
-    matrix_scan_quantum();
-    return ret;
-}
-
-uint8_t matrix_slave_scan(void) {
-    int ret = _matrix_scan();
-
-    int offset = (isLeftHand) ? 0 : ROWS_PER_HAND;
-
-#ifdef USE_MATRIX_I2C
-    for (int i = 0; i < ROWS_PER_HAND; ++i) {
-        /* i2c_slave_buffer[i] = matrix[offset+i]; */
-        i2c_slave_buffer[i] = matrix[offset+i];
-    }
-#else // USE_SERIAL
-  #ifdef SERIAL_USE_MULTI_TRANSACTION
-    int change = 0;
-  #endif
-    for (int i = 0; i < ROWS_PER_HAND; ++i) {
-  #ifdef SERIAL_USE_MULTI_TRANSACTION
-        if( serial_slave_buffer[i] != matrix[offset+i] )
-        change = 1;
-  #endif
-        serial_slave_buffer[i] = matrix[offset+i];
-    }
-  #ifdef SERIAL_USE_MULTI_TRANSACTION
-    slave_buffer_change_count += change;
-  #endif
-#endif
-    return ret;
-}
-
-bool matrix_is_modified(void)
-{
-    if (debouncing) return false;
-    return true;
-}
-
-inline
-bool matrix_is_on(uint8_t row, uint8_t col)
-{
-    return (matrix[row] & ((matrix_row_t)1<<col));
-}
-
-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++) {
-        print_hex8(row); print(": ");
-        print_bin_reverse16(matrix_get_row(row));
-        print("\n");
-    }
-}
-
-uint8_t matrix_key_count(void)
-{
-    uint8_t count = 0;
-    for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
-        count += bitpop16(matrix[i]);
-    }
-    return count;
-}
-
-static void  init_cols(void)
-{
-    for(int x = 0; x < MATRIX_COLS; x++) {
-        _SFR_IO8((col_pins[x] >> 4) + 1) &=  ~_BV(col_pins[x] & 0xF);
-        _SFR_IO8((col_pins[x] >> 4) + 2) |= _BV(col_pins[x] & 0xF);
-    }
-}
-
-static matrix_row_t read_cols(void)
-{
-    matrix_row_t result = 0;
-    for(int x = 0; x < MATRIX_COLS; x++) {
-        result |= (_SFR_IO8(col_pins[x] >> 4) & _BV(col_pins[x] & 0xF)) ? 0 : (1 << x);
-    }
-    return result;
-}
-
-static void unselect_rows(void)
-{
-    for(int x = 0; x < ROWS_PER_HAND; x++) {
-        _SFR_IO8((row_pins[x] >> 4) + 1) &=  ~_BV(row_pins[x] & 0xF);
-        _SFR_IO8((row_pins[x] >> 4) + 2) |= _BV(row_pins[x] & 0xF);
-    }
-}
-
-static void select_row(uint8_t row)
-{
-    _SFR_IO8((row_pins[row] >> 4) + 1) |=  _BV(row_pins[row] & 0xF);
-    _SFR_IO8((row_pins[row] >> 4) + 2) &= ~_BV(row_pins[row] & 0xF);
-}

keyboards/crkbd/rev1/legacy/post_config.h

@@ -1,27 +0,0 @@
-/*
-Copyright 2019 @foostan
-Copyright 2020 Drashna Jaelre <@drashna>
-
-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/>.
-*/
-
-#pragma once
-
-#ifdef SSD1306OLED
-#    define USE_I2C
-#endif
-
-#if defined(OLED_DRIVER_ENABLE) && (defined(USE_I2C) || defined(USE_MATRIX_I2C))
-#    error Cannot use both legacy i2c driver and new i2c_master driver at the same time. Undefine USE_I2C and/or USE_MATRIX_I2C
-#endif

keyboards/crkbd/rev1/legacy/rules.mk

@@ -1,10 +1 @@
-CUSTOM_MATRIX = yes
+DEFAULT_FOLDER = crkbd/rev1
-
-SRC += 	matrix.c \
-		split_util.c \
-		split_scomm.c
-
-QUANTUM_LIB_SRC += i2c.c serial.c
-
-# Disable unsupported hardware
-BACKLIGHT_SUPPORTED = no

keyboards/crkbd/rev1/legacy/serial.c

@@ -1,589 +0,0 @@
-/*
- * WARNING: be careful changing this code, it is very timing dependent
- *
- * 2018-10-28 checked
- *  avr-gcc 4.9.2
- *  avr-gcc 5.4.0
- *  avr-gcc 7.3.0
- */
-
-#ifndef F_CPU
-#define F_CPU 16000000
-#endif
-
-#include <avr/io.h>
-#include <avr/interrupt.h>
-#include <util/delay.h>
-#include <stddef.h>
-#include <stdbool.h>
-#include "serial.h"
-
-#ifdef SOFT_SERIAL_PIN
-
-#ifdef __AVR_ATmega32U4__
-  // if using ATmega32U4 I2C, can not use PD0 and PD1 in soft serial.
-  #ifdef USE_I2C
-    #if SOFT_SERIAL_PIN == D0 || SOFT_SERIAL_PIN == D1
-      #error Using ATmega32U4 I2C, so can not use PD0, PD1
-    #endif
-  #endif
-
-  #if SOFT_SERIAL_PIN >= D0 && SOFT_SERIAL_PIN <= D3
-    #define SERIAL_PIN_DDR   DDRD
-    #define SERIAL_PIN_PORT  PORTD
-    #define SERIAL_PIN_INPUT PIND
-    #if SOFT_SERIAL_PIN == D0
-      #define SERIAL_PIN_MASK _BV(PD0)
-      #define EIMSK_BIT       _BV(INT0)
-      #define EICRx_BIT       (~(_BV(ISC00) | _BV(ISC01)))
-      #define SERIAL_PIN_INTERRUPT INT0_vect
-    #elif  SOFT_SERIAL_PIN == D1
-      #define SERIAL_PIN_MASK _BV(PD1)
-      #define EIMSK_BIT       _BV(INT1)
-      #define EICRx_BIT       (~(_BV(ISC10) | _BV(ISC11)))
-      #define SERIAL_PIN_INTERRUPT INT1_vect
-    #elif  SOFT_SERIAL_PIN == D2
-      #define SERIAL_PIN_MASK _BV(PD2)
-      #define EIMSK_BIT       _BV(INT2)
-      #define EICRx_BIT       (~(_BV(ISC20) | _BV(ISC21)))
-      #define SERIAL_PIN_INTERRUPT INT2_vect
-    #elif  SOFT_SERIAL_PIN == D3
-      #define SERIAL_PIN_MASK _BV(PD3)
-      #define EIMSK_BIT       _BV(INT3)
-      #define EICRx_BIT       (~(_BV(ISC30) | _BV(ISC31)))
-      #define SERIAL_PIN_INTERRUPT INT3_vect
-    #endif
-  #elif  SOFT_SERIAL_PIN == E6
-    #define SERIAL_PIN_DDR   DDRE
-    #define SERIAL_PIN_PORT  PORTE
-    #define SERIAL_PIN_INPUT PINE
-    #define SERIAL_PIN_MASK  _BV(PE6)
-    #define EIMSK_BIT        _BV(INT6)
-    #define EICRx_BIT        (~(_BV(ISC60) | _BV(ISC61)))
-    #define SERIAL_PIN_INTERRUPT INT6_vect
-  #else
-  #error invalid SOFT_SERIAL_PIN value
-  #endif
-
-#else
- #error serial.c now support ATmega32U4 only
-#endif
-
-//////////////// for backward compatibility ////////////////////////////////
-#ifndef SERIAL_USE_MULTI_TRANSACTION
-/* --- USE Simple API (OLD API, compatible with let's split serial.c) */
-  #if SERIAL_SLAVE_BUFFER_LENGTH > 0
-  uint8_t volatile serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH] = {0};
-  #endif
-  #if SERIAL_MASTER_BUFFER_LENGTH > 0
-  uint8_t volatile serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH] = {0};
-  #endif
-  uint8_t volatile status0 = 0;
-
-SSTD_t transactions[] = {
-    { (uint8_t *)&status0,
-  #if SERIAL_MASTER_BUFFER_LENGTH > 0
-      sizeof(serial_master_buffer), (uint8_t *)serial_master_buffer,
-  #else
-      0, (uint8_t *)NULL,
-  #endif
-  #if SERIAL_SLAVE_BUFFER_LENGTH > 0
-      sizeof(serial_slave_buffer), (uint8_t *)serial_slave_buffer
-  #else
-      0, (uint8_t *)NULL,
-  #endif
-  }
-};
-
-void serial_master_init(void)
-{ soft_serial_initiator_init(transactions, TID_LIMIT(transactions)); }
-
-void serial_slave_init(void)
-{ soft_serial_target_init(transactions, TID_LIMIT(transactions)); }
-
-// 0 => no error
-// 1 => slave did not respond
-// 2 => checksum error
-int serial_update_buffers()
-{
-    int result;
-    result = soft_serial_transaction();
-    return result;
-}
-
-#endif // end of Simple API (OLD API, compatible with let's split serial.c)
-////////////////////////////////////////////////////////////////////////////
-
-#define ALWAYS_INLINE __attribute__((always_inline))
-#define NO_INLINE __attribute__((noinline))
-#define _delay_sub_us(x)    __builtin_avr_delay_cycles(x)
-
-// parity check
-#define ODD_PARITY 1
-#define EVEN_PARITY 0
-#define PARITY EVEN_PARITY
-
-#ifdef SERIAL_DELAY
-  // custom setup in config.h
-  // #define TID_SEND_ADJUST 2
-  // #define SERIAL_DELAY 6             // micro sec
-  // #define READ_WRITE_START_ADJUST 30 // cycles
-  // #define READ_WRITE_WIDTH_ADJUST 8 // cycles
-#else
-// ============ Standard setups ============
-
-#ifndef SELECT_SOFT_SERIAL_SPEED
-#define SELECT_SOFT_SERIAL_SPEED 1
-//  0: about 189kbps
-//  1: about 137kbps (default)
-//  2: about 75kbps
-//  3: about 39kbps
-//  4: about 26kbps
-//  5: about 20kbps
-#endif
-
-#if __GNUC__ < 6
-  #define TID_SEND_ADJUST 14
-#else
-  #define TID_SEND_ADJUST 2
-#endif
-
-#if SELECT_SOFT_SERIAL_SPEED == 0
-  // Very High speed
-  #define SERIAL_DELAY 4             // micro sec
-  #if __GNUC__ < 6
-    #define READ_WRITE_START_ADJUST 33 // cycles
-    #define READ_WRITE_WIDTH_ADJUST 3 // cycles
-  #else
-    #define READ_WRITE_START_ADJUST 34 // cycles
-    #define READ_WRITE_WIDTH_ADJUST 7 // cycles
-  #endif
-#elif SELECT_SOFT_SERIAL_SPEED == 1
-  // High speed
-  #define SERIAL_DELAY 6             // micro sec
-  #if __GNUC__ < 6
-    #define READ_WRITE_START_ADJUST 30 // cycles
-    #define READ_WRITE_WIDTH_ADJUST 3 // cycles
-  #else
-    #define READ_WRITE_START_ADJUST 33 // cycles
-    #define READ_WRITE_WIDTH_ADJUST 7 // cycles
-  #endif
-#elif SELECT_SOFT_SERIAL_SPEED == 2
-  // Middle speed
-  #define SERIAL_DELAY 12            // micro sec
-  #define READ_WRITE_START_ADJUST 30 // cycles
-  #if __GNUC__ < 6
-    #define READ_WRITE_WIDTH_ADJUST 3 // cycles
-  #else
-    #define READ_WRITE_WIDTH_ADJUST 7 // cycles
-  #endif
-#elif SELECT_SOFT_SERIAL_SPEED == 3
-  // Low speed
-  #define SERIAL_DELAY 24            // micro sec
-  #define READ_WRITE_START_ADJUST 30 // cycles
-  #if __GNUC__ < 6
-    #define READ_WRITE_WIDTH_ADJUST 3 // cycles
-  #else
-    #define READ_WRITE_WIDTH_ADJUST 7 // cycles
-  #endif
-#elif SELECT_SOFT_SERIAL_SPEED == 4
-  // Very Low speed
-  #define SERIAL_DELAY 36            // micro sec
-  #define READ_WRITE_START_ADJUST 30 // cycles
-  #if __GNUC__ < 6
-    #define READ_WRITE_WIDTH_ADJUST 3 // cycles
-  #else
-    #define READ_WRITE_WIDTH_ADJUST 7 // cycles
-  #endif
-#elif SELECT_SOFT_SERIAL_SPEED == 5
-  // Ultra Low speed
-  #define SERIAL_DELAY 48            // micro sec
-  #define READ_WRITE_START_ADJUST 30 // cycles
-  #if __GNUC__ < 6
-    #define READ_WRITE_WIDTH_ADJUST 3 // cycles
-  #else
-    #define READ_WRITE_WIDTH_ADJUST 7 // cycles
-  #endif
-#else
-#error invalid SELECT_SOFT_SERIAL_SPEED value
-#endif /* SELECT_SOFT_SERIAL_SPEED */
-#endif /* SERIAL_DELAY */
-
-#define SERIAL_DELAY_HALF1 (SERIAL_DELAY/2)
-#define SERIAL_DELAY_HALF2 (SERIAL_DELAY - SERIAL_DELAY/2)
-
-#define SLAVE_INT_WIDTH_US 1
-#ifndef SERIAL_USE_MULTI_TRANSACTION
-  #define SLAVE_INT_RESPONSE_TIME SERIAL_DELAY
-#else
-  #define SLAVE_INT_ACK_WIDTH_UNIT 2
-  #define SLAVE_INT_ACK_WIDTH 4
-#endif
-
-static SSTD_t *Transaction_table = NULL;
-static uint8_t Transaction_table_size = 0;
-
-inline static void serial_delay(void) ALWAYS_INLINE;
-inline static
-void serial_delay(void) {
-  _delay_us(SERIAL_DELAY);
-}
-
-inline static void serial_delay_half1(void) ALWAYS_INLINE;
-inline static
-void serial_delay_half1(void) {
-  _delay_us(SERIAL_DELAY_HALF1);
-}
-
-inline static void serial_delay_half2(void) ALWAYS_INLINE;
-inline static
-void serial_delay_half2(void) {
-  _delay_us(SERIAL_DELAY_HALF2);
-}
-
-inline static void serial_output(void) ALWAYS_INLINE;
-inline static
-void serial_output(void) {
-  SERIAL_PIN_DDR |= SERIAL_PIN_MASK;
-}
-
-// make the serial pin an input with pull-up resistor
-inline static void serial_input_with_pullup(void) ALWAYS_INLINE;
-inline static
-void serial_input_with_pullup(void) {
-  SERIAL_PIN_DDR  &= ~SERIAL_PIN_MASK;
-  SERIAL_PIN_PORT |= SERIAL_PIN_MASK;
-}
-
-inline static uint8_t serial_read_pin(void) ALWAYS_INLINE;
-inline static
-uint8_t serial_read_pin(void) {
-  return !!(SERIAL_PIN_INPUT & SERIAL_PIN_MASK);
-}
-
-inline static void serial_low(void) ALWAYS_INLINE;
-inline static
-void serial_low(void) {
-  SERIAL_PIN_PORT &= ~SERIAL_PIN_MASK;
-}
-
-inline static void serial_high(void) ALWAYS_INLINE;
-inline static
-void serial_high(void) {
-  SERIAL_PIN_PORT |= SERIAL_PIN_MASK;
-}
-
-void soft_serial_initiator_init(SSTD_t *sstd_table, int sstd_table_size)
-{
-    Transaction_table = sstd_table;
-    Transaction_table_size = (uint8_t)sstd_table_size;
-    serial_output();
-    serial_high();
-}
-
-void soft_serial_target_init(SSTD_t *sstd_table, int sstd_table_size)
-{
-    Transaction_table = sstd_table;
-    Transaction_table_size = (uint8_t)sstd_table_size;
-    serial_input_with_pullup();
-
-    // Enable INT0-INT3,INT6
-    EIMSK |= EIMSK_BIT;
-#if SERIAL_PIN_MASK == _BV(PE6)
-    // Trigger on falling edge of INT6
-    EICRB &= EICRx_BIT;
-#else
-    // Trigger on falling edge of INT0-INT3
-    EICRA &= EICRx_BIT;
-#endif
-}
-
-// Used by the sender to synchronize timing with the reciver.
-static void sync_recv(void) NO_INLINE;
-static
-void sync_recv(void) {
-  for (uint8_t i = 0; i < SERIAL_DELAY*5 && serial_read_pin(); i++ ) {
-  }
-  // This shouldn't hang if the target disconnects because the
-  // serial line will float to high if the target does disconnect.
-  while (!serial_read_pin());
-}
-
-// Used by the reciver to send a synchronization signal to the sender.
-static void sync_send(void) NO_INLINE;
-static
-void sync_send(void) {
-  serial_low();
-  serial_delay();
-  serial_high();
-}
-
-// Reads a byte from the serial line
-static uint8_t serial_read_chunk(uint8_t *pterrcount, uint8_t bit) NO_INLINE;
-static uint8_t serial_read_chunk(uint8_t *pterrcount, uint8_t bit) {
-    uint8_t byte, i, p, pb;
-
-  _delay_sub_us(READ_WRITE_START_ADJUST);
-  for( i = 0, byte = 0, p = PARITY; i < bit; i++ ) {
-      serial_delay_half1();   // read the middle of pulses
-      if( serial_read_pin() ) {
-          byte = (byte << 1) | 1; p ^= 1;
-      } else {
-          byte = (byte << 1) | 0; p ^= 0;
-      }
-      _delay_sub_us(READ_WRITE_WIDTH_ADJUST);
-      serial_delay_half2();
-  }
-  /* recive parity bit */
-  serial_delay_half1();   // read the middle of pulses
-  pb = serial_read_pin();
-  _delay_sub_us(READ_WRITE_WIDTH_ADJUST);
-  serial_delay_half2();
-
-  *pterrcount += (p != pb)? 1 : 0;
-
-  return byte;
-}
-
-// Sends a byte with MSB ordering
-void serial_write_chunk(uint8_t data, uint8_t bit) NO_INLINE;
-void serial_write_chunk(uint8_t data, uint8_t bit) {
-    uint8_t b, p;
-    for( p = PARITY, b = 1<<(bit-1); b ; b >>= 1) {
-        if(data & b) {
-            serial_high(); p ^= 1;
-        } else {
-            serial_low();  p ^= 0;
-        }
-        serial_delay();
-    }
-    /* send parity bit */
-    if(p & 1) { serial_high(); }
-    else      { serial_low(); }
-    serial_delay();
-
-    serial_low(); // sync_send() / senc_recv() need raise edge
-}
-
-static void serial_send_packet(uint8_t *buffer, uint8_t size) NO_INLINE;
-static
-void serial_send_packet(uint8_t *buffer, uint8_t size) {
-  for (uint8_t i = 0; i < size; ++i) {
-    uint8_t data;
-    data = buffer[i];
-    sync_send();
-    serial_write_chunk(data,8);
-  }
-}
-
-static uint8_t serial_recive_packet(uint8_t *buffer, uint8_t size) NO_INLINE;
-static
-uint8_t serial_recive_packet(uint8_t *buffer, uint8_t size) {
-  uint8_t pecount = 0;
-  for (uint8_t i = 0; i < size; ++i) {
-    uint8_t data;
-    sync_recv();
-    data = serial_read_chunk(&pecount, 8);
-    buffer[i] = data;
-  }
-  return pecount == 0;
-}
-
-inline static
-void change_sender2reciver(void) {
-    sync_send();          //0
-    serial_delay_half1(); //1
-    serial_low();         //2
-    serial_input_with_pullup(); //2
-    serial_delay_half1(); //3
-}
-
-inline static
-void change_reciver2sender(void) {
-    sync_recv();     //0
-    serial_delay();  //1
-    serial_low();    //3
-    serial_output(); //3
-    serial_delay_half1(); //4
-}
-
-static inline uint8_t nibble_bits_count(uint8_t bits)
-{
-    bits = (bits & 0x5) + (bits >> 1 & 0x5);
-    bits = (bits & 0x3) + (bits >> 2 & 0x3);
-    return bits;
-}
-
-// interrupt handle to be used by the target device
-ISR(SERIAL_PIN_INTERRUPT) {
-
-#ifndef SERIAL_USE_MULTI_TRANSACTION
-  serial_low();
-  serial_output();
-  SSTD_t *trans = Transaction_table;
-#else
-  // recive transaction table index
-  uint8_t tid, bits;
-  uint8_t pecount = 0;
-  sync_recv();
-  bits = serial_read_chunk(&pecount,7);
-  tid = bits>>3;
-  bits = (bits&7) != nibble_bits_count(tid);
-  if( bits || pecount> 0 || tid > Transaction_table_size ) {
-      return;
-  }
-  serial_delay_half1();
-
-  serial_high(); // response step1 low->high
-  serial_output();
-  _delay_sub_us(SLAVE_INT_ACK_WIDTH_UNIT*SLAVE_INT_ACK_WIDTH);
-  SSTD_t *trans = &Transaction_table[tid];
-  serial_low(); // response step2 ack high->low
-#endif
-
-  // target send phase
-  if( trans->target2initiator_buffer_size > 0 )
-      serial_send_packet((uint8_t *)trans->target2initiator_buffer,
-                         trans->target2initiator_buffer_size);
-  // target switch to input
-  change_sender2reciver();
-
-  // target recive phase
-  if( trans->initiator2target_buffer_size > 0 ) {
-      if (serial_recive_packet((uint8_t *)trans->initiator2target_buffer,
-                               trans->initiator2target_buffer_size) ) {
-          *trans->status = TRANSACTION_ACCEPTED;
-      } else {
-          *trans->status = TRANSACTION_DATA_ERROR;
-      }
-  } else {
-      *trans->status = TRANSACTION_ACCEPTED;
-  }
-
-  sync_recv(); //weit initiator output to high
-}
-
-/////////
-//  start transaction by initiator
-//
-// int  soft_serial_transaction(int sstd_index)
-//
-// Returns:
-//    TRANSACTION_END
-//    TRANSACTION_NO_RESPONSE
-//    TRANSACTION_DATA_ERROR
-// this code is very time dependent, so we need to disable interrupts
-#ifndef SERIAL_USE_MULTI_TRANSACTION
-int  soft_serial_transaction(void) {
-  SSTD_t *trans = Transaction_table;
-#else
-int  soft_serial_transaction(int sstd_index) {
-  if( sstd_index > Transaction_table_size )
-      return TRANSACTION_TYPE_ERROR;
-  SSTD_t *trans = &Transaction_table[sstd_index];
-#endif
-  cli();
-
-  // signal to the target that we want to start a transaction
-  serial_output();
-  serial_low();
-  _delay_us(SLAVE_INT_WIDTH_US);
-
-#ifndef SERIAL_USE_MULTI_TRANSACTION
-  // wait for the target response
-  serial_input_with_pullup();
-  _delay_us(SLAVE_INT_RESPONSE_TIME);
-
-  // check if the target is present
-  if (serial_read_pin()) {
-    // target failed to pull the line low, assume not present
-    serial_output();
-    serial_high();
-    *trans->status = TRANSACTION_NO_RESPONSE;
-    sei();
-    return TRANSACTION_NO_RESPONSE;
-  }
-
-#else
-  // send transaction table index
-  int tid = (sstd_index<<3) | (7 & nibble_bits_count(sstd_index));
-  sync_send();
-  _delay_sub_us(TID_SEND_ADJUST);
-  serial_write_chunk(tid, 7);
-  serial_delay_half1();
-
-  // wait for the target response (step1 low->high)
-  serial_input_with_pullup();
-  while( !serial_read_pin() ) {
-      _delay_sub_us(2);
-  }
-
-  // check if the target is present (step2 high->low)
-  for( int i = 0; serial_read_pin(); i++ ) {
-      if (i > SLAVE_INT_ACK_WIDTH + 1) {
-          // slave failed to pull the line low, assume not present
-          serial_output();
-          serial_high();
-          *trans->status = TRANSACTION_NO_RESPONSE;
-          sei();
-          return TRANSACTION_NO_RESPONSE;
-      }
-      _delay_sub_us(SLAVE_INT_ACK_WIDTH_UNIT);
-  }
-#endif
-
-  // initiator recive phase
-  // if the target is present syncronize with it
-  if( trans->target2initiator_buffer_size > 0 ) {
-      if (!serial_recive_packet((uint8_t *)trans->target2initiator_buffer,
-                                trans->target2initiator_buffer_size) ) {
-          serial_output();
-          serial_high();
-          *trans->status = TRANSACTION_DATA_ERROR;
-          sei();
-          return TRANSACTION_DATA_ERROR;
-      }
-   }
-
-  // initiator switch to output
-  change_reciver2sender();
-
-  // initiator send phase
-  if( trans->initiator2target_buffer_size > 0 ) {
-      serial_send_packet((uint8_t *)trans->initiator2target_buffer,
-                         trans->initiator2target_buffer_size);
-  }
-
-  // always, release the line when not in use
-  sync_send();
-
-  *trans->status = TRANSACTION_END;
-  sei();
-  return TRANSACTION_END;
-}
-
-#ifdef SERIAL_USE_MULTI_TRANSACTION
-int soft_serial_get_and_clean_status(int sstd_index) {
-    SSTD_t *trans = &Transaction_table[sstd_index];
-    cli();
-    int retval = *trans->status;
-    *trans->status = 0;;
-    sei();
-    return retval;
-}
-#endif
-
-#endif
-
-// Helix serial.c history
-//   2018-1-29 fork from let's split and add PD2, modify sync_recv() (#2308, bceffdefc)
-//   2018-6-28 bug fix master to slave comm and speed up (#3255, 1038bbef4)
-//             (adjusted with avr-gcc 4.9.2)
-//   2018-7-13 remove USE_SERIAL_PD2 macro (#3374, f30d6dd78)
-//             (adjusted with avr-gcc 4.9.2)
-//   2018-8-11 add support multi-type transaction (#3608, feb5e4aae)
-//             (adjusted with avr-gcc 4.9.2)
-//   2018-10-21 fix serial and RGB animation conflict (#4191, 4665e4fff)
-//             (adjusted with avr-gcc 7.3.0)
-//   2018-10-28 re-adjust compiler depend value of delay (#4269, 8517f8a66)
-//             (adjusted with avr-gcc 5.4.0, 7.3.0)

keyboards/crkbd/rev1/legacy/serial.h

@@ -1,84 +0,0 @@
-#ifndef SOFT_SERIAL_H
-#define SOFT_SERIAL_H
-
-#include <stdbool.h>
-
-// /////////////////////////////////////////////////////////////////
-// Need Soft Serial defines in config.h
-// /////////////////////////////////////////////////////////////////
-// ex.
-//  #define SOFT_SERIAL_PIN ??   // ?? = D0,D1,D2,D3,E6
-//  OPTIONAL: #define SELECT_SOFT_SERIAL_SPEED ? // ? = 1,2,3,4,5
-//                                               //  1: about 137kbps (default)
-//                                               //  2: about 75kbps
-//                                               //  3: about 39kbps
-//                                               //  4: about 26kbps
-//                                               //  5: about 20kbps
-//
-// //// USE Simple API (OLD API, compatible with let's split serial.c)
-// ex.
-//  #define SERIAL_SLAVE_BUFFER_LENGTH MATRIX_ROWS/2
-//  #define SERIAL_MASTER_BUFFER_LENGTH 1
-//
-// //// USE flexible API (using multi-type transaction function)
-//  #define SERIAL_USE_MULTI_TRANSACTION
-//
-// /////////////////////////////////////////////////////////////////
-
-
-#ifndef SERIAL_USE_MULTI_TRANSACTION
-/* --- USE Simple API (OLD API, compatible with let's split serial.c) */
-#if SERIAL_SLAVE_BUFFER_LENGTH > 0
-extern volatile uint8_t serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH];
-#endif
-#if SERIAL_MASTER_BUFFER_LENGTH > 0
-extern volatile uint8_t serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH];
-#endif
-
-void serial_master_init(void);
-void serial_slave_init(void);
-int serial_update_buffers(void);
-
-#endif // USE Simple API
-
-// Soft Serial Transaction Descriptor
-typedef struct _SSTD_t  {
-    uint8_t *status;
-    uint8_t initiator2target_buffer_size;
-    uint8_t *initiator2target_buffer;
-    uint8_t target2initiator_buffer_size;
-    uint8_t *target2initiator_buffer;
-} SSTD_t;
-#define TID_LIMIT( table ) (sizeof(table) / sizeof(SSTD_t))
-
-// initiator is transaction start side
-void soft_serial_initiator_init(SSTD_t *sstd_table, int sstd_table_size);
-// target is interrupt accept side
-void soft_serial_target_init(SSTD_t *sstd_table, int sstd_table_size);
-
-// initiator resullt
-#define TRANSACTION_END 0
-#define TRANSACTION_NO_RESPONSE 0x1
-#define TRANSACTION_DATA_ERROR  0x2
-#define TRANSACTION_TYPE_ERROR  0x4
-#ifndef SERIAL_USE_MULTI_TRANSACTION
-int  soft_serial_transaction(void);
-#else
-int  soft_serial_transaction(int sstd_index);
-#endif
-
-// target status
-// *SSTD_t.status has
-//   initiator:
-//       TRANSACTION_END
-//    or TRANSACTION_NO_RESPONSE
-//    or TRANSACTION_DATA_ERROR
-//   target:
-//       TRANSACTION_DATA_ERROR
-//    or TRANSACTION_ACCEPTED
-#define TRANSACTION_ACCEPTED 0x8
-#ifdef SERIAL_USE_MULTI_TRANSACTION
-int  soft_serial_get_and_clean_status(int sstd_index);
-#endif
-
-#endif /* SOFT_SERIAL_H */

keyboards/crkbd/rev1/legacy/serial_config.h

@@ -1,22 +0,0 @@
-/*
-Copyright 2019 @foostan
-Copyright 2020 Drashna Jaelre <@drashna>
-
-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/>.
-*/
-
-#ifndef SOFT_SERIAL_PIN
-#define SOFT_SERIAL_PIN D2
-#define SERIAL_USE_MULTI_TRANSACTION
-#endif

keyboards/crkbd/rev1/legacy/serial_config_simpleapi.h

@@ -1,23 +0,0 @@
-/*
-Copyright 2019 @foostan
-Copyright 2020 Drashna Jaelre <@drashna>
-
-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/>.
-*/
-
-#pragma once
-
-#undef SERIAL_USE_MULTI_TRANSACTION
-#define SERIAL_SLAVE_BUFFER_LENGTH MATRIX_ROWS/2
-#define SERIAL_MASTER_BUFFER_LENGTH MATRIX_ROWS/2

keyboards/crkbd/rev1/legacy/split_scomm.c

@@ -1,111 +0,0 @@
-/*
-Copyright 2019 @foostan
-Copyright 2020 Drashna Jaelre <@drashna>
-
-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/>.
-*/
-
-#ifdef USE_SERIAL
-#ifdef SERIAL_USE_MULTI_TRANSACTION
-/* --- USE flexible API (using multi-type transaction function) --- */
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stddef.h>
-#include "split_scomm.h"
-#include "serial.h"
-#ifdef CONSOLE_ENABLE
-  #include "debug.h"
-#endif
-
-uint8_t volatile serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH] = {0};
-uint8_t volatile serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH] = {0};
-uint8_t volatile status_com = 0;
-uint8_t volatile status1 = 0;
-uint8_t slave_buffer_change_count = 0;
-uint8_t s_change_old = 0xff;
-uint8_t s_change_new = 0xff;
-
-SSTD_t transactions[] = {
-#define GET_SLAVE_STATUS 0
-    /* master buffer not changed, only recive slave_buffer_change_count */
-    { (uint8_t *)&status_com,
-      0, NULL,
-      sizeof(slave_buffer_change_count), &slave_buffer_change_count,
-    },
-#define PUT_MASTER_GET_SLAVE_STATUS 1
-    /* master buffer changed need send, and recive slave_buffer_change_count  */
-    { (uint8_t *)&status_com,
-      sizeof(serial_master_buffer), (uint8_t *)serial_master_buffer,
-      sizeof(slave_buffer_change_count), &slave_buffer_change_count,
-    },
-#define GET_SLAVE_BUFFER 2
-    /* recive serial_slave_buffer */
-    { (uint8_t *)&status1,
-      0, NULL,
-      sizeof(serial_slave_buffer), (uint8_t *)serial_slave_buffer
-    }
-};
-
-void serial_master_init(void)
-{
-    soft_serial_initiator_init(transactions, TID_LIMIT(transactions));
-}
-
-void serial_slave_init(void)
-{
-    soft_serial_target_init(transactions, TID_LIMIT(transactions));
-}
-
-// 0 => no error
-// 1 => slave did not respond
-// 2 => checksum error
-int serial_update_buffers(int master_update)
-{
-    int status, smatstatus;
-    static int need_retry = 0;
-
-    if( s_change_old != s_change_new ) {
-        smatstatus = soft_serial_transaction(GET_SLAVE_BUFFER);
-        if( smatstatus == TRANSACTION_END ) {
-            s_change_old = s_change_new;
-#ifdef CONSOLE_ENABLE
-            if (debug_matrix) {
-                uprintf("slave matrix = %b %b %b %b\n",
-                    serial_slave_buffer[0], serial_slave_buffer[1],
-                    serial_slave_buffer[2], serial_slave_buffer[3]);
-            }
-#endif
-        }
-    } else {
-        // serial_slave_buffer dosen't change
-        smatstatus = TRANSACTION_END; // dummy status
-    }
-
-    if( !master_update && !need_retry) {
-        status = soft_serial_transaction(GET_SLAVE_STATUS);
-    } else {
-        status = soft_serial_transaction(PUT_MASTER_GET_SLAVE_STATUS);
-    }
-    if( status == TRANSACTION_END ) {
-        s_change_new = slave_buffer_change_count;
-        need_retry = 0;
-    } else {
-        need_retry = 1;
-    }
-    return smatstatus;
-}
-
-#endif // SERIAL_USE_MULTI_TRANSACTION
-#endif /* USE_SERIAL */

keyboards/crkbd/rev1/legacy/split_scomm.h

@@ -1,42 +0,0 @@
-/*
-Copyright 2019 @foostan
-Copyright 2020 Drashna Jaelre <@drashna>
-
-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/>.
-*/
-
-#ifndef SPLIT_COMM_H
-#define SPLIT_COMM_H
-
-#ifndef SERIAL_USE_MULTI_TRANSACTION
-/* --- USE Simple API (OLD API, compatible with let's split serial.c) --- */
-#include "serial.h"
-
-#else
-/* --- USE flexible API (using multi-type transaction function) --- */
-// Buffers for master - slave communication
-#define SERIAL_SLAVE_BUFFER_LENGTH MATRIX_ROWS/2
-#define SERIAL_MASTER_BUFFER_LENGTH MATRIX_ROWS/2
-
-extern volatile uint8_t serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH];
-extern volatile uint8_t serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH];
-extern uint8_t slave_buffer_change_count;
-
-void serial_master_init(void);
-void serial_slave_init(void);
-int serial_update_buffers(int master_changed);
-
-#endif
-
-#endif /* SPLIT_COMM_H */

keyboards/crkbd/rev1/legacy/split_util.c

@@ -1,127 +0,0 @@
-/*
-Copyright 2019 @foostan
-Copyright 2020 Drashna Jaelre <@drashna>
-
-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 <avr/io.h>
-#include <avr/wdt.h>
-#include <avr/power.h>
-#include <avr/interrupt.h>
-#include <util/delay.h>
-#include <avr/eeprom.h>
-#include "split_util.h"
-#include "matrix.h"
-#include "keyboard.h"
-#include "wait.h"
-
-#ifdef EE_HANDS
-#    include "eeconfig.h"
-#endif
-
-#ifdef USE_MATRIX_I2C
-#  include "i2c_master.h"
-#else
-#  include "split_scomm.h"
-#endif
-
-#ifndef SPLIT_USB_TIMEOUT
-#    define SPLIT_USB_TIMEOUT 2000
-#endif
-
-#ifndef SPLIT_USB_TIMEOUT_POLL
-#    define SPLIT_USB_TIMEOUT_POLL 10
-#endif
-
-volatile bool isLeftHand = true;
-
-bool waitForUsb(void) {
-    for (uint8_t i = 0; i < (SPLIT_USB_TIMEOUT / SPLIT_USB_TIMEOUT_POLL); i++) {
-        // This will return true if a USB connection has been established
-        if (UDADDR & _BV(ADDEN)) {
-            return true;
-        }
-        wait_ms(SPLIT_USB_TIMEOUT_POLL);
-    }
-
-    // Avoid NO_USB_STARTUP_CHECK - Disable USB as the previous checks seem to enable it somehow
-    (USBCON &= ~(_BV(USBE) | _BV(OTGPADE)));
-
-    return false;
-}
-
-__attribute__((weak)) bool is_keyboard_left(void) {
-#if defined(SPLIT_HAND_PIN)
-    // Test pin SPLIT_HAND_PIN for High/Low, if low it's right hand
-    setPinInput(SPLIT_HAND_PIN);
-    return readPin(SPLIT_HAND_PIN);
-#elif defined(EE_HANDS)
-    return eeconfig_read_handedness();
-#elif defined(MASTER_RIGHT)
-    return !has_usb();
-#endif
-
-    return has_usb();
-}
-
-__attribute__((weak)) bool has_usb(void) {
-    static enum { UNKNOWN, MASTER, SLAVE } usbstate = UNKNOWN;
-
-    // only check once, as this is called often
-    if (usbstate == UNKNOWN) {
-#if defined(SPLIT_USB_DETECT)
-        usbstate = waitForUsb() ? MASTER : SLAVE;
-#elif defined(__AVR__)
-        USBCON |= (1 << OTGPADE);  // enables VBUS pad
-        wait_us(5);
-
-        usbstate = (USBSTA & (1 << VBUS)) ? MASTER : SLAVE;  // checks state of VBUS
-#else
-        usbstate = MASTER;
-#endif
-    }
-
-    return (usbstate == MASTER);
-}
-
-static void keyboard_master_setup(void) {
-
-#ifdef USE_MATRIX_I2C
-    i2c_init();
-#else
-    serial_master_init();
-#endif
-}
-
-static void keyboard_slave_setup(void) {
-
-#ifdef USE_MATRIX_I2C
-    i2c_slave_init(SLAVE_I2C_ADDRESS);
-#else
-    serial_slave_init();
-#endif
-}
-
-// this code runs before the usb and keyboard is initialized
-void split_keyboard_setup(void) {
-    isLeftHand = is_keyboard_left();
-
-   if (has_usb()) {
-      keyboard_master_setup();
-   } else {
-      keyboard_slave_setup();
-   }
-   sei();
-}

keyboards/crkbd/rev1/legacy/split_util.h

@@ -1,37 +0,0 @@
-/*
-Copyright 2019 @foostan
-Copyright 2020 Drashna Jaelre <@drashna>
-
-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/>.
-*/
-
-#ifndef SPLIT_KEYBOARD_UTIL_H
-#define SPLIT_KEYBOARD_UTIL_H
-
-#include <stdbool.h>
-#include "eeconfig.h"
-
-#define SLAVE_I2C_ADDRESS           0x32
-
-extern volatile bool isLeftHand;
-
-// slave version of matix scan, defined in matrix.c
-uint8_t matrix_slave_scan(void);
-
-void split_keyboard_setup(void);
-bool has_usb(void);
-
-void matrix_master_OLED_init (void);
-
-#endif

keyboards/crkbd/rev1/legacy/ssd1306.c

@@ -1,357 +0,0 @@
-#ifdef SSD1306OLED
-
-#include "ssd1306.h"
-#include "i2c.h"
-#include <string.h>
-#include "print.h"
-#ifdef PROTOCOL_LUFA
-#include "lufa.h"
-#endif
-#include "sendchar.h"
-#include "timer.h"
-
-struct CharacterMatrix display;
-
-extern const unsigned char font[] PROGMEM;
-
-#ifndef OLED_BLANK_CHAR
-#define OLED_BLANK_CHAR ' '
-#endif
-
-#ifndef OLED_BITS_FILTER
-#define OLED_BITS_FILTER
-#endif
-
-// Set this to 1 to help diagnose early startup problems
-// when testing power-on with ble.  Turn it off otherwise,
-// as the latency of printing most of the debug info messes
-// with the matrix scan, causing keys to drop.
-#define DEBUG_TO_SCREEN 0
-
-//static uint16_t last_battery_update;
-//static uint32_t vbat;
-//#define BatteryUpdateInterval 10000 /* milliseconds */
-
-// 'last_flush' is declared as uint16_t,
-// so this must be less than 65535
-#ifndef ScreenOffInterval
-#define ScreenOffInterval 60000 /* milliseconds */
-#endif
-
-#if DEBUG_TO_SCREEN
-static uint8_t displaying;
-#endif
-static uint16_t last_flush;
-
-static bool force_dirty = true;
-
-// Write command sequence.
-// Returns true on success.
-static inline bool _send_cmd1(uint8_t cmd) {
-  bool res = false;
-
-  if (i2c_start_write(SSD1306_ADDRESS)) {
-    xprintf("failed to start write to %d\n", SSD1306_ADDRESS);
-    goto done;
-  }
-
-  if (i2c_master_write(0x0 /* command byte follows */)) {
-    print("failed to write control byte\n");
-
-    goto done;
-  }
-
-  if (i2c_master_write(cmd)) {
-    xprintf("failed to write command %d\n", cmd);
-    goto done;
-  }
-  res = true;
-done:
-  i2c_master_stop();
-  return res;
-}
-
-#define send_cmd1(c) if (!_send_cmd1(c)) {goto done;}
-#define send_cmds(c) if (!_send_cmds(c,sizeof(c))) {goto done;}
-#define cmd1(X) X
-#define cmd2(X,Y) X,Y
-#define cmd3(X,Y,Z) X,Y,Z
-
-static bool _send_cmds(const uint8_t* p,uint8_t sz) {
-  for(uint8_t i=sz;i;i--) {
-    send_cmd1( pgm_read_byte(p++) );
-  }
-  return true;
-done:
-  return false;
-}
-
-#define SEND_CMDS(...) {static const uint8_t _cmds[] PROGMEM = { __VA_ARGS__,0 };send_cmds(_cmds);}
-
-static void clear_display(void) {
-  matrix_clear(&display);
-
-  // Clear all of the display bits (there can be random noise
-  // in the RAM on startup)
-  SEND_CMDS(
-    cmd3(PageAddr, 0, (DisplayHeight / 8) - 1),
-    cmd3(ColumnAddr, 0, DisplayWidth - 1)
-  );
-
-  if (i2c_start_write(SSD1306_ADDRESS)) {
-    goto done;
-  }
-  if (i2c_master_write(0x40)) {
-    // Data mode
-    goto done;
-  }
-  for (uint8_t row = MatrixRows;row; row--) {
-    for (uint8_t col = DisplayWidth; col; col--) {
-      i2c_master_write(0);
-    }
-  }
-
-  display.dirty = false;
-
-done:
-  i2c_master_stop();
-}
-
-#if DEBUG_TO_SCREEN
-#undef sendchar
-static int8_t capture_sendchar(uint8_t c) {
-  sendchar(c);
-  iota_gfx_write_char(c);
-
-  if (!displaying) {
-    iota_gfx_flush();
-  }
-  return 0;
-}
-#endif
-
-bool iota_gfx_init(bool rotate) {
-  bool success = false;
-
-  i2c_master_init();
-  SEND_CMDS(
-    cmd1(DisplayOff),
-    cmd2(SetDisplayClockDiv, 0x80),
-    cmd2(SetMultiPlex, DisplayHeight - 1),
-    cmd2(SetDisplayOffset, 0),
-    cmd1(SetStartLine | 0x0),
-    cmd2(SetChargePump, 0x14 /* Enable */),
-    cmd2(SetMemoryMode, 0 /* horizontal addressing */)
-  );
-
-  if(rotate){
-    // the following Flip the display orientation 180 degrees
-  SEND_CMDS(
-    cmd1(SegRemap),
-    cmd1(ComScanInc)
-  );
-  }else{
-    // Flips the display orientation 0 degrees
-  SEND_CMDS(
-      cmd1(SegRemap | 0x1),
-      cmd1(ComScanDec)
-    );
-  }
-
-  SEND_CMDS(
-#ifdef SSD1306_128X64
-	cmd2(SetComPins, 0x12),
-#else
-	cmd2(SetComPins, 0x2),
-#endif
-    cmd2(SetContrast, 0x8f),
-    cmd2(SetPreCharge, 0xf1),
-    cmd2(SetVComDetect, 0x40),
-    cmd1(DisplayAllOnResume),
-    cmd1(NormalDisplay),
-    cmd1(DeActivateScroll),
-    cmd1(DisplayOn),
-
-    cmd2(SetContrast, 0) // Dim
-  );
-
-  clear_display();
-
-  success = true;
-
-  iota_gfx_flush();
-
-#if DEBUG_TO_SCREEN
-  print_set_sendchar(capture_sendchar);
-#endif
-
-done:
-  return success;
-}
-
-bool iota_gfx_off(void) {
-  bool success = false;
-
-  send_cmd1(DisplayOff);
-  success = true;
-
-done:
-  return success;
-}
-
-bool iota_gfx_on(void) {
-  bool success = false;
-
-  send_cmd1(DisplayOn);
-  success = true;
-
-done:
-  return success;
-}
-
-void matrix_write_char_inner(struct CharacterMatrix *matrix, uint8_t c) {
-  *matrix->cursor = c;
-  ++matrix->cursor;
-
-  if (matrix->cursor - &matrix->display[0][0] == sizeof(matrix->display)) {
-    // We went off the end; scroll the display upwards by one line
-    memmove(&matrix->display[0], &matrix->display[1],
-            MatrixCols * (MatrixRows - 1));
-    matrix->cursor = &matrix->display[MatrixRows - 1][0];
-    memset(matrix->cursor, OLED_BLANK_CHAR, MatrixCols);
-  }
-}
-
-void matrix_write_char(struct CharacterMatrix *matrix, uint8_t c) {
-  matrix->dirty = true;
-
-  if (c == '\n') {
-    // Clear to end of line from the cursor and then move to the
-    // start of the next line
-    uint8_t cursor_col = (matrix->cursor - &matrix->display[0][0]) % MatrixCols;
-
-    while (cursor_col++ < MatrixCols) {
-      matrix_write_char_inner(matrix, OLED_BLANK_CHAR);
-    }
-    return;
-  }
-
-  matrix_write_char_inner(matrix, c);
-}
-
-void iota_gfx_write_char(uint8_t c) {
-  matrix_write_char(&display, c);
-}
-
-void matrix_write(struct CharacterMatrix *matrix, const char *data) {
-  while (*data) {
-    matrix_write_char(matrix, *data);
-    ++data;
-  }
-}
-
-void matrix_write_ln(struct CharacterMatrix *matrix, const char *data) {
-  matrix_write(matrix, data);
-  matrix_write(matrix, "\n");
-}
-
-void iota_gfx_write(const char *data) {
-  matrix_write(&display, data);
-}
-
-void matrix_write_P(struct CharacterMatrix *matrix, const char *data) {
-  while (true) {
-    uint8_t c = pgm_read_byte(data);
-    if (c == 0) {
-      return;
-    }
-    matrix_write_char(matrix, c);
-    ++data;
-  }
-}
-
-void iota_gfx_write_P(const char *data) {
-  matrix_write_P(&display, data);
-}
-
-void matrix_clear(struct CharacterMatrix *matrix) {
-  memset(matrix->display, OLED_BLANK_CHAR, sizeof(matrix->display));
-  matrix->cursor = &matrix->display[0][0];
-  matrix->dirty = true;
-}
-
-void iota_gfx_clear_screen(void) {
-  matrix_clear(&display);
-}
-
-void matrix_render(struct CharacterMatrix *matrix) {
-  last_flush = timer_read();
-  iota_gfx_on();
-#if DEBUG_TO_SCREEN
-  ++displaying;
-#endif
-
-  // Move to the home position
-  SEND_CMDS(
-    cmd3(PageAddr, 0, MatrixRows - 1),
-    cmd3(ColumnAddr, 0, (MatrixCols * FontWidth) - 1)
-  );
-
-  if (i2c_start_write(SSD1306_ADDRESS)) {
-    goto done;
-  }
-  if (i2c_master_write(0x40)) {
-    // Data mode
-    goto done;
-  }
-
-  for (uint8_t row = 0; row < MatrixRows; ++row) {
-    for (uint8_t col = 0; col < MatrixCols; ++col) {
-      const uint8_t *glyph = font + (matrix->display[row][col] * FontWidth);
-
-      for (uint8_t glyphCol = 0; glyphCol < FontWidth; ++glyphCol) {
-        uint8_t colBits = pgm_read_byte(glyph + glyphCol);
-        i2c_master_write(colBits OLED_BITS_FILTER);
-      }
-
-      // 1 column of space between chars (it's not included in the glyph)
-      //i2c_master_write(0);
-    }
-  }
-
-  matrix->dirty = false;
-
-done:
-  i2c_master_stop();
-#if DEBUG_TO_SCREEN
-  --displaying;
-#endif
-}
-
-void iota_gfx_flush(void) {
-  matrix_render(&display);
-}
-
-__attribute__ ((weak))
-void iota_gfx_task_user(void) {
-}
-
-void iota_gfx_task(void) {
-  iota_gfx_task_user();
-
-  if (display.dirty|| force_dirty) {
-    iota_gfx_flush();
-    force_dirty = false;
-  }
-
-  if (ScreenOffInterval !=0 && timer_elapsed(last_flush) > ScreenOffInterval) {
-    iota_gfx_off();
-  }
-}
-
-bool process_record_gfx(uint16_t keycode, keyrecord_t *record) {
-  force_dirty = true;
-  return true;
-}
-
-#endif

keyboards/crkbd/rev1/legacy/ssd1306.h

@@ -1,90 +0,0 @@
-#pragma once
-
-#include <stdbool.h>
-#include <stdio.h>
-#include "action.h"
-
-enum ssd1306_cmds {
-  DisplayOff = 0xAE,
-  DisplayOn = 0xAF,
-
-  SetContrast = 0x81,
-  DisplayAllOnResume = 0xA4,
-
-  DisplayAllOn = 0xA5,
-  NormalDisplay = 0xA6,
-  InvertDisplay = 0xA7,
-  SetDisplayOffset = 0xD3,
-  SetComPins = 0xda,
-  SetVComDetect = 0xdb,
-  SetDisplayClockDiv = 0xD5,
-  SetPreCharge = 0xd9,
-  SetMultiPlex = 0xa8,
-  SetLowColumn = 0x00,
-  SetHighColumn = 0x10,
-  SetStartLine = 0x40,
-
-  SetMemoryMode = 0x20,
-  ColumnAddr = 0x21,
-  PageAddr = 0x22,
-
-  ComScanInc = 0xc0,
-  ComScanDec = 0xc8,
-  SegRemap = 0xa0,
-  SetChargePump = 0x8d,
-  ExternalVcc = 0x01,
-  SwitchCapVcc = 0x02,
-
-  ActivateScroll = 0x2f,
-  DeActivateScroll = 0x2e,
-  SetVerticalScrollArea = 0xa3,
-  RightHorizontalScroll = 0x26,
-  LeftHorizontalScroll = 0x27,
-  VerticalAndRightHorizontalScroll = 0x29,
-  VerticalAndLeftHorizontalScroll = 0x2a,
-};
-
-// Controls the SSD1306 128x32 OLED display via i2c
-
-#ifndef SSD1306_ADDRESS
-#define SSD1306_ADDRESS 0x3C
-#endif
-
-#define DisplayHeight 32
-#define DisplayWidth 128
-
-#define FontHeight 8
-#define FontWidth 6
-
-#define MatrixRows (DisplayHeight / FontHeight)
-#define MatrixCols (DisplayWidth / FontWidth)
-
-struct CharacterMatrix {
-  uint8_t display[MatrixRows][MatrixCols];
-  uint8_t *cursor;
-  bool dirty;
-};
-
-extern struct CharacterMatrix display;
-
-bool iota_gfx_init(bool rotate);
-void iota_gfx_task(void);
-bool iota_gfx_off(void);
-bool iota_gfx_on(void);
-void iota_gfx_flush(void);
-void iota_gfx_write_char(uint8_t c);
-void iota_gfx_write(const char *data);
-void iota_gfx_write_P(const char *data);
-void iota_gfx_clear_screen(void);
-
-void iota_gfx_task_user(void);
-
-void matrix_clear(struct CharacterMatrix *matrix);
-void matrix_write_char_inner(struct CharacterMatrix *matrix, uint8_t c);
-void matrix_write_char(struct CharacterMatrix *matrix, uint8_t c);
-void matrix_write(struct CharacterMatrix *matrix, const char *data);
-void matrix_write_ln(struct CharacterMatrix *matrix, const char *data);
-void matrix_write_P(struct CharacterMatrix *matrix, const char *data);
-void matrix_render(struct CharacterMatrix *matrix);
-
-bool process_record_gfx(uint16_t keycode, keyrecord_t *record);

keyboards/crkbd/rev1/rev1.c

@@ -83,47 +83,14 @@ led_config_t g_led_config = { {
     4, 4, 4, 4, 4, 4, 4,
     4, 4, 1, 1, 1
 } };
-#endif
 
-void matrix_init_kb(void) {
+void suspend_power_down_kb(void) {
-
+    rgb_matrix_set_suspend_state(true);
-#if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_SPLIT)
+    suspend_power_down_user();
-    if (!isLeftHand) {
-        g_led_config = (led_config_t){ {
-            {  51,  50,  45,  44,  37,  36 },
-            {  52,  49,  46,  43,  38,  35 },
-            {  53,  48,  47,  42,  39,  34 },
-            { NO_LED, NO_LED, NO_LED,  41,  40,  33 },
-            {  24,  23,  18,  17,  10,   9 },
-            {  25,  22,  19,  16,  11,   8 },
-            {  26,  21,  20,  15,  12,   7 },
-            { NO_LED, NO_LED, NO_LED,  14,  13,   6 }
-        }, {
-            { 139,  16 }, { 174,  13 }, { 208,  20 }, { 208,  38 }, { 174,  48 }, { 139,  52 }, { 129,  63 },
-            { 139,  39 }, { 139,  21 }, { 139,   4 }, { 156,   2 }, { 156,  19 }, { 156,  37 }, { 144,  58 },
-            { 164,  55 }, { 174,  35 }, { 174,  13 }, { 174,   0 }, { 191,   3 }, { 191,  20 }, { 191,  37 },
-            { 208,  42 }, { 208,  24 }, { 208,   7 }, { 224,   7 }, { 224,  24 }, { 224,  41 }, {  85,  16 },
-            {  50,  13 }, {  16,  20 }, {  16,  38 }, {  50,  48 }, {  85,  52 }, {  95,  63 }, {  85,  39 },
-            {  85,  21 }, {  85,   4 }, {  68,   2 }, {  68,  19 }, {  68,  37 }, {  80,  58 }, {  60,  55 },
-            {  50,  35 }, {  50,  13 }, {  50,   0 }, {  33,   3 }, {  33,  20 }, {  33,  37 }, {  16,  42 },
-            {  16,  24 }, {  16,   7 }, {   0,   7 }, {   0,  24 }, {   0,  41 }
-        }, {
-            2, 2, 2, 2, 2, 2, 1,
-            4, 4, 4, 4, 4, 4, 1,
-            1, 4, 4, 4, 4, 4, 4,
-            4, 4, 4, 1, 1, 1, 2,
-            2, 2, 2, 2, 2, 1, 4,
-            4, 4, 4, 4, 4, 1, 1,
-            4, 4, 4, 4, 4, 4, 4,
-            4, 4, 1, 1, 1
-        } };
-    }
-#endif
-    matrix_init_user();
 }
 
-#ifdef SSD1306OLED
+void suspend_wakeup_init_kb(void) {
-bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
+    rgb_matrix_set_suspend_state(false);
-  return process_record_gfx(keycode,record) && process_record_user(keycode, record);
+    suspend_wakeup_init_user();
 }
 #endif

keyboards/crkbd/rev1/rev1.h

@@ -26,14 +26,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #endif
 
 #include "quantum.h"
-#include "split_util.h"
-#ifdef PROTOCOL_LUFA
-#    include "lufa.h"
-#endif
-#ifdef SSD1306OLED
-#    include "ssd1306.h"
-#endif
-
 
 // clang-format off
 #define LAYOUT_split_3x6_3( \
@@ -70,4 +62,5 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
     { KC_NO, KC_NO, KC_NO, R32, R31, R30 } \
   }
 
+
 #define LAYOUT LAYOUT_split_3x6_3

keyboards/crkbd/rev1/rules.mk

@@ -1,3 +1 @@
-LIB_SRC += ssd1306.c
+SPLIT_KEYBOARD = yes
-
-DEFAULT_FOLDER = crkbd/rev1/legacy

keyboards/crkbd/rules.mk

@@ -34,7 +34,7 @@ RGB_MATRIX_DRIVER = WS2812
 SLEEP_LED_ENABLE = no    # Breathing sleep LED during USB suspend
 
 # if firmware size over limit, try this option
-# CFLAGS += -flto
+# LTO_ENABLE = yes
 LAYOUTS = split_3x5_3 split_3x6_3
 
-DEFAULT_FOLDER = crkbd/rev1/legacy
+DEFAULT_FOLDER = crkbd/rev1

layouts/community/split_3x6_3/drashna/rules.mk

@@ -20,7 +20,7 @@ SWAP_HANDS_ENABLE          = no  # Enable one-hand typing
 # Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
 SLEEP_LED_ENABLE = no    # Breathing sleep LED during USB suspend
 
-ifeq ($(strip $(KEYBOARD)), crkbd/rev1/common)
+ifeq ($(strip $(KEYBOARD)), crkbd/rev1)
     OLED_DRIVER_ENABLE = yes
     RGB_MATRIX_ENABLE = yes
     HAPTIC_ENABLE = SOLENOID