Rework qmk compile to bypass Makefile. Add new --filter option.

* Update Japanese faq documents.

* Update Japanese summary.

* Update docs/ja/faq_debug.md

Co-authored-by: s-show <s1shimz@gmail.com>

* Update docs/ja/faq_misc.md

Co-authored-by: s-show <s1shimz@gmail.com>

* Apply suggestions from code review

Co-authored-by: s-show <s1shimz@gmail.com>

Makefile

@@ -393,7 +393,7 @@ define PARSE_KEYMAP
     # Specify the variables that we are passing forward to submake
     MAKE_VARS := KEYBOARD=$$(CURRENT_KB) KEYMAP=$$(CURRENT_KM) REQUIRE_PLATFORM_KEY=$$(REQUIRE_PLATFORM_KEY) QMK_BIN=$$(QMK_BIN)
     # And the first part of the make command
-    MAKE_CMD := $$(MAKE) -r -R -C $(ROOT_DIR) -f build_keyboard.mk $$(MAKE_TARGET)
+    MAKE_CMD := echo $$(MAKE) -r -R -C $(ROOT_DIR) -f build_keyboard.mk $$(MAKE_TARGET)
     # The message to display
     MAKE_MSG := $$(MSG_MAKE_KB)
     # We run the command differently, depending on if we want more output or not

Vagrantfile

@@ -6,7 +6,7 @@ Vagrant.configure(2) do |config|
   config.vm.define "qmk_firmware"
 
   # VMware/Virtualbox ( and also Hyperv/Parallels) 64 bit
-  config.vm.box = "generic/debian10"
+  config.vm.box = "generic/debian9"
   
   config.vm.synced_folder '.', '/vagrant'
 

build_json.mk

@@ -1,22 +1,22 @@
 # Look for a json keymap file
 ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_5)/keymap.json)","")
-    KEYMAP_C := $(KEYMAP_OUTPUT)/keymap.c
+    KEYMAP_C := $(KEYBOARD_OUTPUT)/src/keymap.c
     KEYMAP_JSON := $(MAIN_KEYMAP_PATH_5)/keymap.json
     KEYMAP_PATH := $(MAIN_KEYMAP_PATH_5)
 else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_4)/keymap.json)","")
-    KEYMAP_C := $(KEYMAP_OUTPUT)/keymap.c
+    KEYMAP_C := $(KEYBOARD_OUTPUT)/src/keymap.c
     KEYMAP_JSON := $(MAIN_KEYMAP_PATH_4)/keymap.json
     KEYMAP_PATH := $(MAIN_KEYMAP_PATH_4)
 else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_3)/keymap.json)","")
-    KEYMAP_C := $(KEYMAP_OUTPUT)/keymap.c
+    KEYMAP_C := $(KEYBOARD_OUTPUT)/src/keymap.c
     KEYMAP_JSON := $(MAIN_KEYMAP_PATH_3)/keymap.json
     KEYMAP_PATH := $(MAIN_KEYMAP_PATH_3)
 else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_2)/keymap.json)","")
-    KEYMAP_C := $(KEYMAP_OUTPUT)/keymap.c
+    KEYMAP_C := $(KEYBOARD_OUTPUT)/src/keymap.c
     KEYMAP_JSON := $(MAIN_KEYMAP_PATH_2)/keymap.json
     KEYMAP_PATH := $(MAIN_KEYMAP_PATH_2)
 else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_1)/keymap.json)","")
-    KEYMAP_C := $(KEYMAP_OUTPUT)/keymap.c
+    KEYMAP_C := $(KEYBOARD_OUTPUT)/src/keymap.c
     KEYMAP_JSON := $(MAIN_KEYMAP_PATH_1)/keymap.json
     KEYMAP_PATH := $(MAIN_KEYMAP_PATH_1)
 endif
@@ -27,5 +27,5 @@ ifneq ("$(wildcard $(KEYMAP_PATH))", "")
 endif
 
 # Generate the keymap.c
-$(KEYMAP_C): $(KEYMAP_JSON)
+$(KEYBOARD_OUTPUT)/src/keymap.c: $(KEYMAP_JSON)
 	$(QMK_BIN) json2c --quiet --output $(KEYMAP_C) $(KEYMAP_JSON)

build_keyboard.mk

@@ -103,15 +103,6 @@ MAIN_KEYMAP_PATH_5 := $(KEYBOARD_PATH_5)/keymaps/$(KEYMAP)
 INFO_RULES_MK = $(shell $(QMK_BIN) generate-rules-mk --quiet --escape --keyboard $(KEYBOARD) --output $(KEYBOARD_OUTPUT)/src/rules.mk)
 include $(INFO_RULES_MK)
 
-ifneq ($(FORCE_LAYOUT),)
-    TARGET := $(TARGET)_$(FORCE_LAYOUT)
-endif
-
-# Object files and generated keymap directory
-#     To put object files in current directory, use a dot (.), do NOT make
-#     this an empty or blank macro!
-KEYMAP_OUTPUT := $(BUILD_DIR)/obj_$(TARGET)
-
 # Check for keymap.json first, so we can regenerate keymap.c
 include build_json.mk
 
@@ -154,6 +145,10 @@ ifeq ($(strip $(CONVERT_TO_PROTON_C)), yes)
     include platforms/chibios/QMK_PROTON_C/convert_to_proton_c.mk
 endif
 
+ifneq ($(FORCE_LAYOUT),)
+    TARGET := $(TARGET)_$(FORCE_LAYOUT)
+endif
+
 include quantum/mcu_selection.mk
 
 # Find all the C source files to be compiled in subfolders.
@@ -332,6 +327,11 @@ endif
 # Disable features that a keyboard doesn't support
 -include disable_features.mk
 
+# Object files directory
+#     To put object files in current directory, use a dot (.), do NOT make
+#     this an empty or blank macro!
+KEYMAP_OUTPUT := $(BUILD_DIR)/obj_$(TARGET)
+
 ifneq ("$(wildcard $(KEYMAP_PATH)/config.h)","")
     CONFIG_H += $(KEYMAP_PATH)/config.h
 endif

build_test.mk

@@ -49,7 +49,6 @@ endif
 
 include common_features.mk
 include $(TMK_PATH)/common.mk
-include $(QUANTUM_PATH)/debounce/tests/rules.mk
 include $(QUANTUM_PATH)/sequencer/tests/rules.mk
 include $(QUANTUM_PATH)/serial_link/tests/rules.mk
 ifneq ($(filter $(FULL_TESTS),$(TEST)),)

common_features.mk

@@ -244,7 +244,7 @@ endif
 endif
 
 RGB_MATRIX_ENABLE ?= no
-VALID_RGB_MATRIX_TYPES := AW20216 IS31FL3731 IS31FL3733 IS31FL3737 IS31FL3741 WS2812 custom
+VALID_RGB_MATRIX_TYPES := IS31FL3731 IS31FL3733 IS31FL3737 IS31FL3741 WS2812 custom
 
 ifeq ($(strip $(RGB_MATRIX_ENABLE)), yes)
     ifeq ($(filter $(RGB_MATRIX_DRIVER),$(VALID_RGB_MATRIX_TYPES)),)
@@ -261,13 +261,6 @@ endif
     CIE1931_CURVE := yes
     RGB_KEYCODES_ENABLE := yes
 
-    ifeq ($(strip $(RGB_MATRIX_DRIVER)), AW20216)
-        OPT_DEFS += -DAW20216 -DSTM32_SPI -DHAL_USE_SPI=TRUE
-        COMMON_VPATH += $(DRIVER_PATH)/awinic
-        SRC += aw20216.c
-        QUANTUM_LIB_SRC += spi_master.c
-    endif
-
     ifeq ($(strip $(RGB_MATRIX_DRIVER)), IS31FL3731)
         OPT_DEFS += -DIS31FL3731 -DSTM32_I2C -DHAL_USE_I2C=TRUE
         COMMON_VPATH += $(DRIVER_PATH)/issi
@@ -536,11 +529,7 @@ ifeq ($(strip $(SPLIT_KEYBOARD)), yes)
 
     # Determine which (if any) transport files are required
     ifneq ($(strip $(SPLIT_TRANSPORT)), custom)
-        QUANTUM_SRC += $(QUANTUM_DIR)/split_common/transport.c \
-                       $(QUANTUM_DIR)/split_common/transactions.c
-
-        OPT_DEFS += -DSPLIT_COMMON_TRANSACTIONS
-
+        QUANTUM_LIB_SRC += $(QUANTUM_DIR)/split_common/transport.c
         # Functions added via QUANTUM_LIB_SRC are only included in the final binary if they're called.
         # Unused functions are pruned away, which is why we can add multiple drivers here without bloat.
         ifeq ($(PLATFORM),AVR)
@@ -561,11 +550,6 @@ ifeq ($(strip $(SPLIT_KEYBOARD)), yes)
     COMMON_VPATH += $(QUANTUM_PATH)/split_common
 endif
 
-ifeq ($(strip $(CRC_ENABLE)), yes)
-    OPT_DEFS += -DCRC_ENABLE
-    QUANTUM_LIB_SRC += crc.c
-endif
-
 HAPTIC_ENABLE ?= no
 ifneq ($(strip $(HAPTIC_ENABLE)),no)
     COMMON_VPATH += $(DRIVER_PATH)/haptic
@@ -596,14 +580,6 @@ ifeq ($(strip $(OLED_DRIVER_ENABLE)), yes)
     SRC += oled_driver.c
 endif
 
-ifeq ($(strip $(ST7565_ENABLE)), yes)
-    OPT_DEFS += -DST7565_ENABLE
-    COMMON_VPATH += $(DRIVER_PATH)/oled # For glcdfont.h
-    COMMON_VPATH += $(DRIVER_PATH)/lcd
-    QUANTUM_LIB_SRC += spi_master.c
-    SRC += st7565.c
-endif
-
 include $(DRIVER_PATH)/qwiic/qwiic.mk
 
 ifeq ($(strip $(UCIS_ENABLE)), yes)

data/schemas/api_keyboard.jsonschema

@@ -1,22 +1,34 @@
 {
-    "$id": "qmk.api.keyboard.v1",
     "allOf": [
-        {"$ref": "qmk.keyboard.v1"},
+        { "$ref": "qmk.keyboard.v1" },
         {
-            "properties": {
-                "keymaps": {
-                    "type": "object",
-                    "properties": {
-                        "url": {"type": "string"}
-                    }
-
-                },
-                "parse_errors": {"$ref": "qmk.definitions.v1#/string_array"},
-                "parse_warnings": {"$ref": "qmk.definitions.v1#/string_array"},
-                "processor_type": {"type": "string"},
-                "protocol": {"type": "string"},
-                "keyboard_folder": {"type": "string"},
-                "platform": {"type": "string"}
+            "$id": "qmk.api.keyboard.v1",
+            "keymaps": {
+                "type": "string"
+            },
+            "parse_errors": {
+                "type": "array",
+                "items": {
+                    "type": "string"
+                }
+            },
+            "parse_warnings": {
+                "type": "array",
+                "items": {
+                    "type": "string"
+                }
+            },
+            "processor_type": {
+                "type": "string"
+            },
+            "protocol": {
+                "type": "string"
+            },
+            "keyboard_folder": {
+                "type": "string"
+            },
+            "platform": {
+                "type": "string"
             }
         }
     ]

data/schemas/definitions.jsonschema

@@ -1,107 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-07/schema#",
-    "$id": "qmk.definitions.v1",
-    "title": "Common definitions used across QMK's jsonschemas.",
-    "type": "object",
-    "boolean_array": {
-        "type": "object",
-        "additionalProperties": {"type": "boolean"}
-    },
-    "filename": {
-        "type": "string",
-        "minLength": 1,
-        "pattern": "^[0-9a-z_]*$"
-    },
-    "hex_number_2d": {
-        "type": "string",
-        "pattern": "^0x[0-9A-F]{2}$"
-    },
-    "hex_number_4d": {
-        "type": "string",
-        "pattern": "^0x[0-9A-F]{4}$"
-    },
-    "text_identifier": {
-        "type": "string",
-        "minLength": 1,
-        "maxLength": 250
-    },
-    "layout_macro": {
-        "oneOf": [
-            {
-                "type": "string",
-                "enum": ["LAYOUT", "LAYOUT_planck_1x2uC"]
-            },
-            {
-                "type": "string",
-                "pattern": "^LAYOUT_[0-9a-z_]*$"
-            }
-        ]
-    },
-    "key_unit": {
-        "type": "number",
-        "min": 0.25
-    },
-    "mcu_pin_array": {
-        "type": "array",
-        "items": {"$ref": "#/mcu_pin"}
-    },
-    "mcu_pin": {
-        "oneOf": [
-            {
-                "type": "string",
-                "pattern": "^[A-K]\\d{1,2}$"
-            },
-            {
-                "type": "string",
-                "pattern": "^LINE_PIN\\d{1,2}$"
-            },
-            {
-                "type": "number",
-                "multipleOf": 1
-            },
-            {
-                "type": "null"
-            }
-        ]
-    },
-    "signed_decimal": {
-        "type": "number"
-    },
-    "signed_int": {
-        "type": "number",
-        "multipleOf": 1
-    }
-    "signed_int_8": {
-        "type": "number",
-        "min": -127,
-        "max": 127,
-        "multipleOf": 1
-    }
-    "string_array": {
-        "type": "array",
-        "items": {
-            "type": "string"
-        }
-    },
-    "string_object": {
-        "type": "object",
-        "additionalProperties": {
-            "type": "string"
-        }
-    },
-    "unsigned_decimal": {
-        "type": "number",
-        "min": 0
-    },
-    "unsigned_int": {
-        "type": "number",
-        "min": 0,
-        "multipleOf": 1
-    }
-    "unsigned_int_8": {
-        "type": "number",
-        "min": 0,
-        "max": 255,
-        "multipleOf": 1
-    }
-}

data/schemas/keyboard.jsonschema

@@ -1,12 +1,24 @@
 {
-    "$schema": "http://json-schema.org/draft-07/schema#",
+    "$schema": "http://json-schema.org/schema#",
     "$id": "qmk.keyboard.v1",
     "title": "Keyboard Information",
     "type": "object",
     "properties": {
-        "keyboard_name": {"$ref": "qmk.definitions.v1#/text_identifier"},
-        "maintainer": {"$ref": "qmk.definitions.v1#/text_identifier"},
-        "manufacturer": {"$ref": "qmk.definitions.v1#/text_identifier"},
+        "keyboard_name": {
+            "type": "string",
+            "minLength": 2,
+            "maxLength": 250
+        },
+        "maintainer": {
+            "type": "string",
+            "minLength": 2,
+            "maxLength": 250
+        },
+        "manufacturer": {
+            "type": "string",
+            "minLength": 2,
+            "maxLength": 250
+        },
         "url": {
             "type": "string",
             "format": "uri"
@@ -28,25 +40,62 @@
             "type": "string",
             "enum": ["COL2ROW", "ROW2COL"]
         },
-        "debounce": {"$ref": "qmk.definitions.v1#/unsigned_int"},
-        "height": {"$ref": "qmk.definitions.v1#/key_unit"},
-        "width": {"$ref": "qmk.definitions.v1#/key_unit"},
+        "debounce": {
+            "type": "number",
+            "min": 0,
+            "multipleOf": 1
+        },
+        "height": {
+            "type": "number",
+            "min": 0.25
+        },
+        "width": {
+            "type": "number",
+            "min": 0.25
+        },
         "community_layouts": {
             "type": "array",
-            "items": {"$ref": "qmk.definitions.v1#/filename"}
+            "items": {
+                "type": "string",
+                "minLength": 2,
+                "pattern": "^[0-9a-z_]*$"
+            }
+        },
+        "features": {
+            "type": "object",
+            "additionalProperties": {"type": "boolean"}
         },
-        "features": {"$ref": "qmk.definitions.v1#/boolean_array"},
         "indicators": {
             "type": "object",
             "properties": {
-                "caps_lock": {"$ref": "qmk.definitions.v1#/mcu_pin"},
-                "num_lock": {"$ref": "qmk.definitions.v1#/mcu_pin"},
-                "scroll_lock": {"$ref": "qmk.definitions.v1#/mcu_pin"}
+                "caps_lock": {
+                    "type": "string",
+                    "pattern": "^[A-K]\\d{1,2}$"
+                },
+                "num_lock": {
+                    "type": "string",
+                    "pattern": "^[A-K]\\d{1,2}$"
+                },
+                "scroll_lock": {
+                    "type": "string",
+                    "pattern": "^[A-K]\\d{1,2}$"
+                }
             }
         },
         "layout_aliases": {
             "type": "object",
-            "additionalProperties": {"$ref": "qmk.definitions.v1#/layout_macro"}
+            "additionalProperties": {
+                "oneOf": [
+                    {
+                        "type": "string",
+                        "enum": ["LAYOUT", "LAYOUT_planck_1x2uC"]
+                    },
+                    {
+                        "type": "string",
+                        "pattern": "^LAYOUT_[0-9a-z_]*$"
+                    }
+                ]
+            }
         },
         "layouts": {
             "type": "object",
@@ -60,7 +109,11 @@
                     "c_macro": {
                         "type": "boolean"
                     },
-                    "key_count": {"$ref": "qmk.definitions.v1#/key_unit"},
+                    "key_count": {
+                        "type": "number",
+                        "min": 0,
+                        "multipleOf": 1
+                    },
                     "layout": {
                         "type": "array",
                         "items": {
@@ -78,14 +131,34 @@
                                         "multipleOf": 1
                                     }
                                 },
-                                "key_count": {"$ref": "qmk.definitions.v1#/key_unit"},
-                                "r": {"$ref": "qmk.definitions.v1#/unsigned_decimal"},
-                                "rx": {"$ref": "qmk.definitions.v1#/unsigned_decimal"},
-                                "ry": {"$ref": "qmk.definitions.v1#/unsigned_decimal"},
-                                "h": {"$ref": "qmk.definitions.v1#/key_unit"},
-                                "w": {"$ref": "qmk.definitions.v1#/key_unit"},
-                                "x": {"$ref": "qmk.definitions.v1#/key_unit"},
-                                "y": {"$ref": "qmk.definitions.v1#/key_unit"}
+                                "h": {
+                                    "type": "number",
+                                    "min": 0.25
+                                },
+                                "r": {
+                                    "type": "number",
+                                    "min": 0
+                                },
+                                "rx": {
+                                    "type": "number",
+                                    "min": 0
+                                },
+                                "ry": {
+                                    "type": "number",
+                                    "min": 0
+                                },
+                                "w": {
+                                    "type": "number",
+                                    "min": 0.25
+                                },
+                                "x": {
+                                    "type": "number",
+                                    "min": 0
+                                },
+                                "y": {
+                                    "type": "number",
+                                    "min": 0
+                                }
                             }
                         }
                     }
@@ -98,10 +171,61 @@
             "properties": {
                 "direct": {
                     "type": "array",
-                    "items": {$ref": "qmk.definitions.v1#/mcu_pin_array"}
+                    "items": {
+                        "type": "array",
+                        "items": {
+                            "oneOf": [
+                                {
+                                    "type": "string",
+                                    "pattern": "^[A-K]\\d{1,2}$"
+                                },
+                                {
+                                    "type": "number",
+                                    "multipleOf": 1
+                                },
+                                {
+                                    "type": "null"
+                                }
+                            ]
+                        }
+                    }
                 },
-                "cols": {"$ref": "qmk.definitions.v1#/mcu_pin_array"},
-                "rows": {"$ref": "qmk.definitions.v1#/mcu_pin_array"}
+                "cols": {
+                    "type": "array",
+                    "items": {
+                        "oneOf": [
+                            {
+                                "type": "string",
+                                "pattern": "^[A-K]\\d{1,2}$"
+                            },
+                            {
+                                "type": "number",
+                                "multipleOf": 1
+                            },
+                            {
+                                "type": "null"
+                            }
+                        ]
+                    }
+                },
+                "rows": {
+                    "type": "array",
+                    "items": {
+                        "oneOf": [
+                            {
+                                "type": "string",
+                                "pattern": "^[A-K]\\d{1,2}$"
+                            },
+                            {
+                                "type": "number",
+                                "multipleOf": 1
+                            },
+                            {
+                                "type": "null"
+                            }
+                        ]
+                    }
+                }
             }
         },
         "rgblight": {
@@ -114,19 +238,47 @@
                         "type": "boolean"
                     }
                 },
-                "brightness_steps": {"$ref": "qmk.definitions.v1#/unsigned_int"},
-                "hue_steps": {"$ref": "qmk.definitions.v1#/unsigned_int"},
-                "led_count": {"$ref": "qmk.definitions.v1#/unsigned_int"},
-                "max_brightness": {"$ref": "qmk.definitions.v1#/unsigned_int_8"},
-                "pin": {"$ref": "qmk.definitions.v1#/mcu_pin"},
-                "saturation_steps": {"$ref": "qmk.definitions.v1#/unsigned_int"},
+                "brightness_steps": {
+                    "type": "number",
+                    "min": 0,
+                    "multipleOf": 1
+                },
+                "hue_steps": {
+                    "type": "number",
+                    "min": 0,
+                    "multipleOf": 1
+                },
+                "led_count": {
+                    "type": "number",
+                    "min": 0,
+                    "multipleOf": 1
+                },
+                "max_brightness": {
+                    "type": "number",
+                    "min": 0,
+                    "max": 255,
+                    "multipleOf": 1
+                },
+                "pin": {
+                    "type": "string",
+                    "pattern": "^[A-K]\\d{1,2}$"
+                },
+                "saturation_steps": {
+                    "type": "number",
+                    "min": 0,
+                    "multipleOf": 1
+                },
                 "sleep": {"type": "boolean"},
                 "split": {"type": "boolean"},
                 "split_count": {
                     "type": "array",
                     "minLength": 2,
                     "maxLength": 2,
-                    "items": {"$ref": "qmk.definitions.v1#/unsigned_int"}
+                    "items": {
+                        "type": "number",
+                        "min": 0,
+                        "multipleOf": 1
+                    }
                 }
             }
         },
@@ -134,19 +286,40 @@
             "type": "object",
             "additionalProperties": false,
             "properties": {
-                "device_ver": {"$ref": "qmk.definitions.v1#/hex_number_4d"},
-                "pid": {"$ref": "qmk.definitions.v1#/hex_number_4d"},
-                "vid": {"$ref": "qmk.definitions.v1#/hex_number_4d"}
+                "device_ver": {
+                    "type": "string",
+                    "pattern": "^[0-9A-F]x[0-9A-F][0-9A-F][0-9A-F][0-9A-F]"
+                },
+                "pid": {
+                    "type": "string",
+                    "pattern": "^[0-9A-F]x[0-9A-F][0-9A-F][0-9A-F][0-9A-F]"
+                },
+                "vid": {
+                    "type": "string",
+                    "pattern": "^[0-9A-F]x[0-9A-F][0-9A-F][0-9A-F][0-9A-F]"
+                }
             }
         },
         "qmk_lufa_bootloader": {
             "type": "object",
             "additionalProperties": false,
             "properties": {
-                "esc_output": {"$ref": "qmk.definitions.v1#/mcu_pin"},
-                "esc_input": {"$ref": "qmk.definitions.v1#/mcu_pin"},
-                "led": {"$ref": "qmk.definitions.v1#/mcu_pin"},
-                "speaker": {"$ref": "qmk.definitions.v1#/mcu_pin"}
+                "esc_output": {
+                    "type": "string",
+                    "pattern": "^[A-K]\\d{1,2}$"
+                },
+                "esc_input": {
+                    "type": "string",
+                    "pattern": "^[A-K]\\d{1,2}$"
+                },
+                "led": {
+                    "type": "string",
+                    "pattern": "^[A-K]\\d{1,2}$"
+                },
+                "speaker": {
+                    "type": "string",
+                    "pattern": "^[A-K]\\d{1,2}$"
+                }
             }
         }
     }

docs/_summary.md

@@ -93,7 +93,6 @@
   * Hardware Features
     * Displays
       * [HD44780 LCD Controller](feature_hd44780.md)
-      * [ST7565 LCD Driver](feature_st7565.md)
       * [OLED Driver](feature_oled_driver.md)
     * Lighting
       * [Backlight](feature_backlight.md)

docs/breaking_changes.md

@@ -100,7 +100,3 @@ This happens immediately after the previous `develop` branch is merged.
     * [ ] `git pull --ff-only`
     * [ ] `git merge --no-ff develop`
     * [ ] `git push upstream master`
-
-## Post-merge operations
-
-* (Optional) [update ChibiOS + ChibiOS-Contrib on `develop`](chibios_upgrade_instructions.md)

docs/chibios_upgrade_instructions.md

@@ -1,56 +0,0 @@
-# ChibiOS Upgrade Procedure
-
-ChibiOS and ChibiOS-Contrib need to be updated in tandem -- the latter has a branch tied to the ChibiOS version in use and should not be mixed with different versions.
-
-## Getting ChibiOS
-
-* `svn` Initialisation:
-    * Only needed to be done once
-    * You might need to separately install `git-svn` package in your OS's package manager
-    * `git svn init --stdlayout --prefix='svn/' http://svn.osdn.net/svnroot/chibios/`
-    * `git remote add qmk git@github.com:qmk/ChibiOS.git`
-* Updating:
-    * `git svn fetch`
-    * First time around this will take several hours
-    * Subsequent updates will be incremental only
-* Tagging example (work out which version first!):
-    * `git tag -a ver20.3.3 -m ver20.3.3 svn/tags/ver20.3.3`
-    * `git push qmk ver20.3.3`
-    * `git tag -a breaking_YYYY_qN -m breaking_YYYY_qN svn/tags/ver20.3.3`
-    * `git push qmk breaking_YYYY_qN`
-
-## Getting ChibiOS-Contrib
-
-* `git` Initialisation:
-    * `git clone git@github.com:qmk/ChibiOS-Contrib`
-    * `git remote add upstream https://github.com/ChibiOS/ChibiOS-Contrib`
-    * `git checkout -b chibios-20.3.x upstream/chibios-20.3.x`
-* Updating:
-    * `git fetch --all --tags --prune`
-    * `git checkout chibios-20.3.x`
-    * `git pull --ff-only`
-    * `git push origin chibios-20.3.x`
-    * `git tag -a breaking_YYYY_qN -m breaking_YYYY_qN chibios-20.3.x`
-    * `git push origin breaking_YYYY_qN`
-
-## Updating submodules
-
-* Update the submodules
-    * `cd $QMK_FIRMWARE`
-    * `git checkout develop`
-    * `git pull --ff-only`
-    * `git checkout -b chibios-version-bump`
-    * `cd lib/chibios`
-    * `git fetch --all --tags --prune`
-    * `git checkout breaking_YYYY_qN`
-    * `cd ../chibios-contrib`
-    * `git fetch --all --tags --prune`
-    * `git checkout breaking_YYYY_qN`
-* Build everything
-    * `cd $QMK_FIRMWARE`
-    * `qmk multibuild -j4`
-    * Make sure there are no errors
-* Push to the repo
-    * `git commit -am 'Update ChibiOS to XXXXXXXXX'`
-    * `git push --set-upstream origin chibios-version-bump`
-* Make a PR to qmk_firmware with the new branch

docs/config_options.md

@@ -51,10 +51,8 @@ This is a C header file that is one of the first things included, and will persi
   * the number of columns in your keyboard's matrix
 * `#define MATRIX_ROW_PINS { D0, D5, B5, B6 }`
   * pins of the rows, from top to bottom
-  * may be omitted by the keyboard designer if matrix reads are handled in an alternate manner. See [low-level matrix overrides](custom_quantum_functions.md?id=low-level-matrix-overrides) for more information.
 * `#define MATRIX_COL_PINS { F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7 }`
   * pins of the columns, from left to right
-  * may be omitted by the keyboard designer if matrix reads are handled in an alternate manner. See [low-level matrix overrides](custom_quantum_functions.md?id=low-level-matrix-overrides) for more information.
 * `#define MATRIX_IO_DELAY 30`
   * the delay in microseconds when between changing matrix pin state and reading values
 * `#define UNUSED_PINS { D1, D2, D3, B1, B2, B3 }`
@@ -274,7 +272,7 @@ There are a few different ways to set handedness for split keyboards (listed in
 ### Other Options
 
 * `#define USE_I2C`
-  * For using I2C instead of Serial (default is serial; serial transport is supported on ARM -- I2C is AVR-only)
+  * For using I2C instead of Serial (defaults to serial)
 
 * `#define SOFT_SERIAL_PIN D0`
   * When using serial, define this. `D0` or `D1`,`D2`,`D3`,`E6`.
@@ -282,7 +280,6 @@ There are a few different ways to set handedness for split keyboards (listed in
 * `#define MATRIX_ROW_PINS_RIGHT { <row pins> }`
 * `#define MATRIX_COL_PINS_RIGHT { <col pins> }`
   * If you want to specify a different pinout for the right half than the left half, you can define `MATRIX_ROW_PINS_RIGHT`/`MATRIX_COL_PINS_RIGHT`. Currently, the size of `MATRIX_ROW_PINS` must be the same as `MATRIX_ROW_PINS_RIGHT` and likewise for the definition of columns.
-  * may be omitted by the keyboard designer if matrix reads are handled in an alternate manner. See [low-level matrix overrides](custom_quantum_functions.md?id=low-level-matrix-overrides) for more information.
 
 * `#define DIRECT_PINS_RIGHT { { F1, F0, B0, C7 }, { F4, F5, F6, F7 } }`
   * If you want to specify a different direct pinout for the right half than the left half, you can define `DIRECT_PINS_RIGHT`. Currently, the size of `DIRECT_PINS` must be the same as `DIRECT_PINS_RIGHT`.
@@ -303,7 +300,7 @@ There are a few different ways to set handedness for split keyboards (listed in
 * `#define SPLIT_USB_DETECT`
   * Detect (with timeout) USB connection when delegating master/slave
   * Default behavior for ARM
-  * Required for AVR Teensy (without hardware mods)
+  * Required for AVR Teensy
 
 * `#define SPLIT_USB_TIMEOUT 2000`
   * Maximum timeout when detecting master/slave when using `SPLIT_USB_DETECT`
@@ -311,28 +308,6 @@ There are a few different ways to set handedness for split keyboards (listed in
 * `#define SPLIT_USB_TIMEOUT_POLL 10`
   * Poll frequency when detecting master/slave when using `SPLIT_USB_DETECT`
 
-* `#define FORCED_SYNC_THROTTLE_MS 100`
-  * Deadline for synchronizing data from master to slave when using the QMK-provided split transport.
-
-* `#define SPLIT_TRANSPORT_MIRROR`
-  * Mirrors the master-side matrix on the slave when using the QMK-provided split transport.
-
-* `#define SPLIT_LAYER_STATE_ENABLE`
-  * Ensures the current layer state is available on the slave when using the QMK-provided split transport.
-
-* `#define SPLIT_LED_STATE_ENABLE`
-  * Ensures the current host indicator state (caps/num/scroll) is available on the slave when using the QMK-provided split transport.
-
-* `#define SPLIT_MODS_ENABLE`
-  * Ensures the current modifier state (normal, weak, and oneshot) is available on the slave when using the QMK-provided split transport.
-
-* `#define SPLIT_WPM_ENABLE`
-  * Ensures the current WPM is available on the slave when using the QMK-provided split transport.
-
-* `#define SPLIT_TRANSACTION_IDS_KB .....`
-* `#define SPLIT_TRANSACTION_IDS_USER .....`
-  * Allows for custom data sync with the slave when using the QMK-provided split transport. See [custom data sync between sides](feature_split_keyboard.md#custom-data-sync) for more information.
-
 # The `rules.mk` File
 
 This is a [make](https://www.gnu.org/software/make/manual/make.html) file that is included by the top-level `Makefile`. It is used to set some information about the MCU that we will be compiling for as well as enabling and disabling certain features.

docs/custom_quantum_functions.md

@@ -144,14 +144,6 @@ This is useful for setting up stuff that you may need elsewhere, but isn't hardw
 * Keyboard/Revision: `void matrix_init_kb(void)`
 * Keymap: `void matrix_init_user(void)`
 
-### Low-level Matrix Overrides Function Documentation :id=low-level-matrix-overrides
-
-* GPIO pin initialisation: `void matrix_init_pins(void)`
-  * This needs to perform the low-level initialisation of all row and column pins. By default this will initialise the input/output state of each of the GPIO pins listed in `MATRIX_ROW_PINS` and `MATRIX_COL_PINS`, based on whether or not the keyboard is set up for `ROW2COL`, `COL2ROW`, or `DIRECT_PINS`. Should the keyboard designer override this function, no initialisation of pin state will occur within QMK itself, instead deferring to the keyboard's override.
-* `COL2ROW`-based row reads: `void matrix_read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)`
-* `ROW2COL`-based column reads: `void matrix_read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)`
-* `DIRECT_PINS`-based reads: `void matrix_read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)`
-  * These three functions need to perform the low-level retrieval of matrix state of relevant input pins, based on the matrix type. Only one of the functions should be implemented, if needed. By default this will iterate through `MATRIX_ROW_PINS` and `MATRIX_COL_PINS`, configuring the inputs and outputs based on whether or not the keyboard is set up for `ROW2COL`, `COL2ROW`, or `DIRECT_PINS`. Should the keyboard designer override this function, no manipulation of matrix GPIO pin state will occur within QMK itself, instead deferring to the keyboard's override.
 
 ## Keyboard Post Initialization code
 

docs/feature_advanced_keycodes.md

@@ -2,24 +2,27 @@
 
 These allow you to combine a modifier with a keycode. When pressed, the keydown event for the modifier, then `kc` will be sent. On release, the keyup event for `kc`, then the modifier will be sent.
 
-|Key       |Aliases                        |Description                                           |
-|----------|-------------------------------|------------------------------------------------------|
-|`LCTL(kc)`|`C(kc)`                        |Hold Left Control and press `kc`                      |
-|`LSFT(kc)`|`S(kc)`                        |Hold Left Shift and press `kc`                        |
-|`LALT(kc)`|`A(kc)`, `LOPT(kc)`            |Hold Left Alt and press `kc`                          |
-|`LGUI(kc)`|`G(kc)`, `LCMD(kc)`, `LWIN(kc)`|Hold Left GUI and press `kc`                          |
-|`RCTL(kc)`|                               |Hold Right Control and press `kc`                     |
-|`RSFT(kc)`|                               |Hold Right Shift and press `kc`                       |
-|`RALT(kc)`|`ROPT(kc)`, `ALGR(kc)`         |Hold Right Alt and press `kc`                         |
-|`RGUI(kc)`|`RCMD(kc)`, `LWIN(kc)`         |Hold Right GUI and press `kc`                         |
-|`SGUI(kc)`|`SCMD(kc)`, `SWIN(kc)`         |Hold Left Shift and GUI and press `kc`                |
-|`LCA(kc)` |                               |Hold Left Control and Alt and press `kc`              |
-|`LSA(kc)` |                               |Hold Left Shift and Left Alt and press `kc`           |
-|`RSA(kc)` |`SAGR(kc)`                     |Hold Right Shift and Right Alt (AltGr) and press `kc` |
-|`RCS(kc)` |                               |Hold Right Control and Right Shift and press `kc`     |
-|`LCAG(kc)`|                               |Hold Left Control, Alt and GUI and press `kc`         |
-|`MEH(kc)` |                               |Hold Left Control, Shift and Alt and press `kc`       |
-|`HYPR(kc)`|                               |Hold Left Control, Shift, Alt and GUI and press `kc`  |
+|Key       |Aliases                           |Description                                           |
+|----------|----------------------------------|------------------------------------------------------|
+|`LCTL(kc)`|`C(kc)`                           |Hold Left Control and press `kc`                      |
+|`LSFT(kc)`|`S(kc)`                           |Hold Left Shift and press `kc`                        |
+|`LALT(kc)`|`A(kc)`, `LOPT(kc)`               |Hold Left Alt and press `kc`                          |
+|`LGUI(kc)`|`G(kc)`, `LCMD(kc)`, `LWIN(kc)`   |Hold Left GUI and press `kc`                          |
+|`RCTL(kc)`|                                  |Hold Right Control and press `kc`                     |
+|`RSFT(kc)`|                                  |Hold Right Shift and press `kc`                       |
+|`RALT(kc)`|`ROPT(kc)`, `ALGR(kc)`            |Hold Right Alt and press `kc`                         |
+|`RGUI(kc)`|`RCMD(kc)`, `LWIN(kc)`            |Hold Right GUI and press `kc`                         |
+|`LSG(kc)` |`SGUI(kc)`, `SCMD(kc)`, `SWIN(kc)`|Hold Left Shift and GUI and press `kc`                |
+|`LAG(kc)` |                                  |Hold Left Alt and Left GUI and press `kc`             |
+|`RSG(kc)` |                                  |Hold Right Shift and Right GUI and press `kc`         |
+|`RAG(kc)` |                                  |Hold Right Alt and Right GUI and press `kc`           |
+|`LCA(kc)` |                                  |Hold Left Control and Alt and press `kc`              |
+|`LSA(kc)` |                                  |Hold Left Shift and Left Alt and press `kc`           |
+|`RSA(kc)` |`SAGR(kc)`                        |Hold Right Shift and Right Alt (AltGr) and press `kc` |
+|`RCS(kc)` |                                  |Hold Right Control and Right Shift and press `kc`     |
+|`LCAG(kc)`|                                  |Hold Left Control, Alt and GUI and press `kc`         |
+|`MEH(kc)` |                                  |Hold Left Control, Shift and Alt and press `kc`       |
+|`HYPR(kc)`|                                  |Hold Left Control, Shift, Alt and GUI and press `kc`  |
 
 You can also chain them, for example `LCTL(LALT(KC_DEL))` or `C(A(KC_DEL))` makes a key that sends Control+Alt+Delete with a single keypress.
 

docs/feature_debounce_type.md

@@ -121,16 +121,16 @@ DEBOUNCE_TYPE = <name of algorithm>
 Where name of algorithm is one of:
 * ```sym_defer_g``` - debouncing per keyboard. On any state change, a global timer is set. When ```DEBOUNCE``` milliseconds of no changes has occurred, all input changes are pushed.
   * This is the current default algorithm. This is the highest performance algorithm with lowest memory usage, and it's also noise-resistant.
-* ```sym_eager_pr``` - debouncing per row. On any state change, response is immediate, followed by locking the row ```DEBOUNCE``` milliseconds of no further input for that row.
+* ```sym_eager_pr``` - debouncing per row. On any state change, response is immediate, followed by locking the row ```DEBOUNCE``` milliseconds of no further input for that row. 
 For use in keyboards where refreshing ```NUM_KEYS``` 8-bit counters is computationally expensive / low scan rate, and fingers usually only hit one row at a time. This could be
 appropriate for the ErgoDox models; the matrix is rotated 90°, and hence its "rows" are really columns, and each finger only hits a single "row" at a time in normal use.
 * ```sym_eager_pk``` - debouncing per key. On any state change, response is immediate, followed by ```DEBOUNCE``` milliseconds of no further input for that key
 * ```sym_defer_pk``` - debouncing per key. On any state change, a per-key timer is set. When ```DEBOUNCE``` milliseconds of no changes have occurred on that key, the key status change is pushed.
-* ```asym_eager_defer_pk``` - debouncing per key. On a key-down state change, response is immediate, followed by ```DEBOUNCE``` milliseconds of no further input for that key. On a key-up state change, a per-key timer is set. When ```DEBOUNCE``` milliseconds of no changes have occurred on that key, the key-up status change is pushed.
 
 ### A couple algorithms that could be implemented in the future:
 * ```sym_defer_pr```
 * ```sym_eager_g```
+* ```asym_eager_defer_pk```
 
 ### Use your own debouncing code
 You have the option to implement you own debouncing algorithm. To do this:

docs/feature_haptic_feedback.md

@@ -162,28 +162,4 @@ This will set what sequence HPT_RST will set as the active mode. If not defined,
 
 ### DRV2605L Continuous Haptic Mode
 
-This mode sets continuous haptic feedback with the option to increase or decrease strength.
-
-## Haptic Key Exclusion
-The Haptic Exclusion is implemented as `__attribute__((weak)) bool get_haptic_enabled_key(uint16_t keycode, keyrecord_t *record)` in haptic.c. This allows a re-definition at the required level with the specific requirement / exclusion.
-
-### NO_HAPTIC_MOD
-With the entry of `#define NO_HAPTIC_MOD` in config.h, modifiers from Left Control to Right GUI will not trigger a feedback. This also includes modifiers in a Mod Tap configuration.
-
-### NO_HAPTIC_FN
-With the entry of `#define NO_HAPTIC_FN` in config.h, layer keys will not rigger a feedback.
-
-### NO_HAPTIC_ALPHA
-With the entry of `#define NO_HAPTIC_ALPHA` in config.h, none of the alpha keys (A ... Z) will trigger a feedback.
-
-### NO_HAPTIC_PUNCTUATION
-With the entry of `#define NO_HAPTIC_PUNCTUATION` in config.h, none of the following keys will trigger a feedback: Enter, ESC, Backspace, Space, Minus, Equal, Left Bracket, Right Bracket, Backslash, Non-US Hash, Semicolon, Quote, Grave, Comma, Slash, Dot, Non-US Backslash.
-
-### NO_HAPTIC_LOCKKEYS
-With the entry of `#define NO_HAPTIC_LOCKKEYS` in config.h, none of the following keys will trigger a feedback: Caps Lock, Scroll Lock, Num Lock.
-
-### NO_HAPTIC_NAV
-With the entry of `#define NO_HAPTIC_NAV` in config.h, none of the following keys will trigger a feedback: Print Screen, Pause, Insert, Delete, Page Down, Page Up, Left Arrow, Up Arrow, Right Arrow, Down Arrow, End, Home.
-
-### NO_HAPTIC_NUMERIC
-With the entry of `#define NO_HAPTIC_NUMERIC` in config.h, none of the following keys between 0 and 9 (KC_1 ... KC_0) will trigger a feedback.
+This mode sets continuous haptic feedback with the option to increase or decrease strength. 

docs/feature_oled_driver.md

@@ -346,10 +346,6 @@ bool oled_scroll_left(void);
 // Returns true if the screen was not scrolling or stops scrolling
 bool oled_scroll_off(void);
 
-// Inverts the display
-// Returns true if the screen was or is inverted
-bool oled_invert(bool invert);
-
 // Returns the maximum number of characters that will fit on a line
 uint8_t oled_max_chars(void);
 

docs/feature_rgb_matrix.md

@@ -227,74 +227,6 @@ Configure the hardware via your `config.h`:
 #define DRIVER_LED_TOTAL 70
 ```
 
----
-### AW20216 :id=aw20216
-There is basic support for addressable RGB matrix lighting with the SPI AW20216 RGB controller. To enable it, add this to your `rules.mk`:
-
-```makefile
-RGB_MATRIX_ENABLE = yes
-RGB_MATRIX_DRIVER = AW20216
-```
-
-You can use up to 2 AW20216 IC's. Do not specify `DRIVER_<N>_xxx` defines for IC's that are not present on your keyboard. You can define the following items in `config.h`:
-
-| Variable | Description | Default |
-|----------|-------------|---------|
-| `DRIVER_1_CS` | (Required) MCU pin connected to first RGB driver chip select line  | B13 |
-| `DRIVER_2_CS` | (Optional) MCU pin connected to second RGB driver chip select line  | |
-| `DRIVER_1_EN` | (Required) MCU pin connected to first RGB driver hardware enable line  | C13 |
-| `DRIVER_2_EN` | (Optional) MCU pin connected to second RGB driver hardware enable line  | |
-| `DRIVER_1_LED_TOTAL` | (Required) How many RGB lights are connected to first RGB driver  | |
-| `DRIVER_2_LED_TOTAL` | (Optional) How many RGB lights are connected to second RGB driver  | |
-| `DRIVER_COUNT` | (Required) How many RGB driver IC's are present | |
-| `DRIVER_LED_TOTAL` | (Required) How many RGB lights are present across all drivers | |
-| `AW_SCALING_MAX` | (Optional) LED current scaling value (0-255, higher values mean LED is brighter at full PWM) | 150 |
-| `AW_GLOBAL_CURRENT_MAX` | (Optional) Driver global current limit (0-255, higher values means the driver may consume more power) | 150 |
-
-Here is an example using 2 drivers.
-
-```c
-#define DRIVER_1_CS B13
-#define DRIVER_2_CS B14
-// Hardware enable lines may be connected to the same pin
-#define DRIVER_1_EN C13
-#define DRIVER_2_EN C13
-
-#define DRIVER_COUNT 2
-#define DRIVER_1_LED_TOTAL 66
-#define DRIVER_2_LED_TOTAL 32
-#define DRIVER_LED_TOTAL (DRIVER_1_LED_TOTAL + DRIVER_2_LED_TOTAL)
-```
-
-!> Note the parentheses, this is so when `DRIVER_LED_TOTAL` is used in code and expanded, the values are added together before any additional math is applied to them. As an example, `rand() % (DRIVER_1_LED_TOTAL + DRIVER_2_LED_TOTAL)` will give very different results than `rand() % DRIVER_1_LED_TOTAL + DRIVER_2_LED_TOTAL`.
-
-Define these arrays listing all the LEDs in your `<keyboard>.c`:
-
-```c
-const aw_led g_aw_leds[DRIVER_LED_TOTAL] = {
-/* Each AW20216 channel is controlled by a register at some offset between 0x00
- * and 0xD7 inclusive.
- * See drivers/awinic/aw20216.h for the mapping between register offsets and
- * driver pin locations.
- *    driver
- *    |  R location
- *    |  |        G location
- *    |  |        |        B location
- *    |  |        |        | */
-    { 0, CS1_SW1, CS2_SW1, CS3_SW1 },
-    { 0, CS4_SW1, CS5_SW1, CS6_SW1 },
-    { 0, CS7_SW1, CS8_SW1, CS9_SW1 },
-    { 0, CS10_SW1, CS11_SW1, CS12_SW1 },
-    { 0, CS13_SW1, CS14_SW1, CS15_SW1 },
-    ...
-    { 1, CS1_SW1, CS2_SW1, CS3_SW1 },
-    { 1, CS13_SW1, CS14_SW1, CS15_SW1 },
-    { 1, CS16_SW1, CS17_SW1, CS18_SW1 },
-    { 1, CS4_SW2, CS5_SW2, CS6_SW2 },
-    ...
-};
-```
-
 ---
 
 ## Common Configuration :id=common-configuration

docs/feature_split_keyboard.md

@@ -8,7 +8,8 @@ QMK Firmware has a generic implementation that is usable by any board, as well a
 
 For this, we will mostly be talking about the generic implementation used by the Let's Split and other keyboards. 
 
-!> ARM split supports most QMK subsystems when using the 'serial' and 'serial_usart' drivers. I2C slave is currently unsupported.
+!> ARM is not yet fully supported for Split Keyboards and has many limitations. Progress is being made, but we have not yet reached 100% feature parity.
+
 
 ## Compatibility Overview
 
@@ -168,7 +169,7 @@ Because not every split keyboard is identical, there are a number of additional
 #define USE_I2C
 ```
 
-This configures the use of I<sup>2</sup>C support for split keyboard transport (AVR only).  
+This enables I<sup>2</sup>C support for split keyboards. This isn't strictly for communication, but can be used for OLED or other I<sup>2</sup>C-based devices. 
 
 ```c
 #define SOFT_SERIAL_PIN D0
@@ -192,115 +193,20 @@ If you're having issues with serial communication, you can change this value, as
 * **`5`**: about 20kbps
 
 ```c
-#define FORCED_SYNC_THROTTLE_MS 100
+#define SPLIT_MODS_ENABLE
 ```
 
-This sets the maximum number of milliseconds before forcing a synchronization of data from master to slave. Under normal circumstances this sync occurs whenever the data _changes_, for safety a data transfer occurs after this number of milliseconds if no change has been detected since the last sync. 
+This enables transmitting modifier state (normal, weak and oneshot) to the non
+primary side of the split keyboard.  This adds a few bytes of data to the split
+communication protocol and may impact the matrix scan speed when enabled.
+The purpose of this feature is to support cosmetic use of modifer state (e.g.
+displaying status on an OLED screen).
 
 ```c
 #define SPLIT_TRANSPORT_MIRROR
 ```
 
-This mirrors the master side matrix to the slave side for features that react or require knowledge of master side key presses on the slave side. The purpose of this feature is to support cosmetic use of key events (e.g. RGB reacting to keypresses). This adds overhead to the split communication protocol and may negatively impact the matrix scan speed when enabled. 
-
-```c
-#define SPLIT_LAYER_STATE_ENABLE
-```
-
-This enables syncing of the layer state between both halves of the split keyboard. The main purpose of this feature is to enable support for use of things like OLED display of the currently active layer. This adds overhead to the split communication protocol and may negatively impact the matrix scan speed when enabled. 
-
-```c
-#define SPLIT_LED_STATE_ENABLE
-```
-
-This enables syncing of the Host LED status (caps lock, num lock, etc) between both halves of the split keyboard. The main purpose of this feature is to enable support for use of things like OLED display of the Host LED status. This adds overhead to the split communication protocol and may negatively impact the matrix scan speed when enabled. 
-
-```c
-#define SPLIT_MODS_ENABLE
-```
-
-This enables transmitting modifier state (normal, weak and oneshot) to the non primary side of the split keyboard. The purpose of this feature is to support cosmetic use of modifer state (e.g. displaying status on an OLED screen). This adds overhead to the split communication protocol and may negatively impact the matrix scan speed when enabled. 
-
-```c
-#define SPLIT_WPM_ENABLE
-```
-
-This enables transmitting the current WPM to the slave side of the split keyboard. The purpose of this feature is to support cosmetic use of WPM (e.g. displaying the current value on an OLED screen). This adds overhead to the split communication protocol and may negatively impact the matrix scan speed when enabled. 
-
-### Custom data sync between sides :id=custom-data-sync
-
-QMK's split transport allows for arbitrary data transactions at both the keyboard and user levels. This is modelled on a remote procedure call, with the master invoking a function on the slave side, with the ability to send data from master to slave, process it slave side, and send data back from slave to master.
-
-To leverage this, a keyboard or user/keymap can define a comma-separated list of _transaction IDs_:
-
-```c
-// for keyboard-level data sync:
-#define SPLIT_TRANSACTION_IDS_KB KEYBOARD_SYNC_A, KEYBOARD_SYNC_B
-// or, for user:
-#define SPLIT_TRANSACTION_IDS_USER USER_SYNC_A, USER_SYNC_B, USER_SYNC_C
-```
-
-These _transaction IDs_ then need a slave-side handler function to be registered with the split transport, for example:
-
-```c
-typedef struct _master_to_slave_t {
-    int m2s_data;
-} master_to_slave_t;
-
-typedef struct _slave_to_master_t {
-    int s2m_data;
-} slave_to_master_t;
-
-void user_sync_a_slave_handler(uint8_t in_buflen, const void* in_data, uint8_t out_buflen, void* out_data) {
-    const master_to_slave_t *m2s = (const master_to_slave_t*)in_data;
-    slave_to_master_t *s2m = (slave_to_master_t*)out_data;
-    s2m->s2m_data = m2s->m2s_data + 5; // whatever comes in, add 5 so it can be sent back
-}
-
-void keyboard_post_init_user(void) {
-    transaction_register_rpc(USER_SYNC_A, user_sync_a_slave_handler);
-}
-```
-
-The master side can then invoke the slave-side handler - for normal keyboard functionality to be minimally affected, any keyboard- or user-level code attempting to sync data should be throttled:
-
-```c
-void housekeeping_task_user(void) {
-    if (is_keyboard_master()) {
-        // Interact with slave every 500ms
-        static uint32_t last_sync = 0;
-        if (timer_elapsed32(last_sync) > 500) {
-            master_to_slave_t m2s = {6};
-            slave_to_master_t s2m = {0};
-            if(transaction_rpc_exec(USER_SYNC_A, sizeof(m2s), &m2s, sizeof(s2m), &s2m)) {
-                last_sync = timer_read32();
-                dprintf("Slave value: %d\n", s2m.s2m_data); // this will now be 11, as the slave adds 5
-            } else {
-                dprint("Slave sync failed!\n");
-            }
-        }
-    }
-}
-```
-
-!> It is recommended that any data sync between halves happens during the master side's _housekeeping task_. This ensures timely retries should failures occur.
-
-If only one-way data transfer is needed, helper methods are provided:
-
-```c
-bool transaction_rpc_exec(int8_t transaction_id, uint8_t initiator2target_buffer_size, const void *initiator2target_buffer, uint8_t target2initiator_buffer_size, void *target2initiator_buffer);
-bool transaction_rpc_send(int8_t transaction_id, uint8_t initiator2target_buffer_size, const void *initiator2target_buffer);
-bool transaction_rpc_recv(int8_t transaction_id, uint8_t target2initiator_buffer_size, void *target2initiator_buffer);
-```
-
-By default, the inbound and outbound data is limited to a maximum of 32 bytes each. The sizes can be altered if required:
-
-```c
-// Master to slave:
-#define RPC_M2S_BUFFER_SIZE 48
-// Slave to master:
-#define RPC_S2M_BUFFER_SIZE 48
-```
+This mirrors the master side matrix to the slave side for features that react or require knowledge of master side key presses on the slave side.  This adds a few bytes of data to the split communication protocol and may impact the matrix scan speed when enabled. The purpose of this feature is to support cosmetic use of key events (e.g. RGB reacting to Keypresses).
 
 ###  Hardware Configuration Options
 

docs/feature_st7565.md

@@ -1,274 +0,0 @@
-# ST7565 LCD Driver
-
-## Supported Hardware
-
-LCD modules using ST7565 driver IC, communicating over SPI.
-
-|Module                        |IC     |Size  |Notes                                                     |
-|------------------------------|-------|------|----------------------------------------------------------|
-|Newhaven Display NHD-C12832A1Z|ST7565R|128x32|Used by Ergodox Infinity; primary consumer of this feature|
-|Zolentech ZLE12864B           |ST7565P|128x64|Requires contrast adjustment                              |
-
-## Usage
-
-To enable the feature, there are three steps. First, when compiling your keyboard, you'll need to add the following to your `rules.mk`:
-
-```make
-ST7565_ENABLE = yes
-```
-
-Then in your `keymap.c` file, implement the ST7565 task call. This example assumes your keymap has three layers named `_QWERTY`, `_FN` and `_ADJ`:
-
-```c
-#ifdef ST7565_ENABLE
-void st7565_task_user(void) {
-    // Host Keyboard Layer Status
-    st7565_write_P(PSTR("Layer: "), false);
-
-    switch (get_highest_layer(layer_state)) {
-        case _QWERTY:
-            st7565_write_P(PSTR("Default\n"), false);
-            break;
-        case _FN:
-            st7565_write_P(PSTR("FN\n"), false);
-            break;
-        case _ADJ:
-            st7565_write_P(PSTR("ADJ\n"), false);
-            break;
-        default:
-            // Or use the write_ln shortcut over adding '\n' to the end of your string
-            st7565_write_ln_P(PSTR("Undefined"), false);
-    }
-
-    // Host Keyboard LED Status
-    led_t led_state = host_keyboard_led_state();
-    st7565_write_P(led_state.num_lock ? PSTR("NUM ") : PSTR("    "), false);
-    st7565_write_P(led_state.caps_lock ? PSTR("CAP ") : PSTR("    "), false);
-    st7565_write_P(led_state.scroll_lock ? PSTR("SCR ") : PSTR("    "), false);
-}
-#endif
-```
-
-## Logo Example
-
-In the default font, certain ranges of characters are reserved for a QMK logo. To render this logo to the screen, use the following code example:
-
-```c
-static void render_logo(void) {
-    static const char PROGMEM qmk_logo[] = {
-        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94,
-        0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4,
-        0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0x00
-    };
-
-    st7565_write_P(qmk_logo, false);
-}
-```
-
-## Buffer Read Example
-For some purposes, you may need to read the current state of the display buffer. The `st7565_read_raw` function can be used to safely read bytes from the buffer.
-
-In this example, calling `fade_display` in the `st7565_task_user` function will slowly fade away whatever is on the screen by turning random pixels off over time.
-```c
-//Setup some mask which can be or'd with bytes to turn off pixels
-const uint8_t single_bit_masks[8] = {127, 191, 223, 239, 247, 251, 253, 254};
-
-static void fade_display(void) {
-    //Define the reader structure
-    display_buffer_reader_t reader;
-    uint8_t buff_char;
-    if (random() % 30 == 0) {
-        srand(timer_read());
-        // Fetch a pointer for the buffer byte at index 0. The return structure
-        // will have the pointer and the number of bytes remaining from this
-        // index position if we want to perform a sequential read by
-        // incrementing the buffer pointer
-        reader = st7565_read_raw(0);
-        //Loop over the remaining buffer and erase pixels as we go
-        for (uint16_t i = 0; i < reader.remaining_element_count; i++) {
-            //Get the actual byte in the buffer by dereferencing the pointer
-            buff_char = *reader.current_element;
-            if (buff_char != 0) {
-                st7565_write_raw_byte(buff_char & single_bit_masks[rand() % 8], i);
-            }
-            //increment the pointer to fetch a new byte during the next loop
-            reader.current_element++;
-        }
-    }
-}
-```
-
-## Other Examples
-
-In split keyboards, it is very common to have two displays that each render different content and are oriented or flipped differently. You can do this by switching which content to render by using the return value from `is_keyboard_master()` or `is_keyboard_left()` found in `split_util.h`, e.g:
-
-```c
-#ifdef ST7565_ENABLE
-display_rotation_t st7565_init_user(display_rotation_t rotation) {
-    if (!is_keyboard_master()) {
-        return DISPLAY_ROTATION_180;  // flips the display 180 degrees if offhand
-    }
-
-    return rotation;
-}
-
-void st7565_task_user(void) {
-    if (is_keyboard_master()) {
-        render_status();  // Renders the current keyboard state (layer, lock, caps, scroll, etc)
-    } else {
-        render_logo();  // Renders a static logo
-    }
-}
-#endif
-```
-
-## Basic Configuration
-
-|Define                  |Default       |Description                                                                                          |
-|------------------------|--------------|-----------------------------------------------------------------------------------------------------|
-|`ST7565_A0_PIN`         |*Not defined* |(Required) The GPIO connected to the display's A0 (data/command) pin                                 |
-|`ST7565_RST_PIN`        |*Not defined* |(Required) The GPIO connected to the display's reset pin                                             |
-|`ST7565_SS_PIN`         |*Not defined* |(Required) The GPIO connected to the display's slave select pin                                      |
-|`ST7565_SPI_CLK_DIVISOR`|`4`           |The SPI clock divisor to use                                                                         |
-|`ST7565_FONT_H`         |`"glcdfont.c"`|The font code file to use for custom fonts                                                           |
-|`ST7565_FONT_START`     |`0`           |The starting character index for custom fonts                                                        |
-|`ST7565_FONT_END`       |`223`         |The ending character index for custom fonts                                                          |
-|`ST7565_FONT_WIDTH`     |`6`           |The font width                                                                                       |
-|`ST7565_FONT_HEIGHT`    |`8`           |The font height (untested)                                                                           |
-|`ST7565_TIMEOUT`        |`60000`       |Turns off the screen after 60000ms of keyboard inactivity. Helps reduce burn-in. Set to 0 to disable.|
-|`ST7565_COLUMN_OFFSET`  |`0`           |Shift output to the right this many pixels.                                                          |
-|`ST7565_CONTRAST`       |`32`          |The default contrast level of the display, from 0 to 255.                                            |
-|`ST7565_UPDATE_INTERVAL`|`0`           |Set the time interval for updating the display in ms. This will improve the matrix scan rate.        |
-
-## Custom sized displays
-
-The default display size for this feature is 128x32 and all necessary defines are precalculated with that in mind.
-
-|Define                 |Default   |Description                                                                                                |
-|-----------------------|----------|-----------------------------------------------------------------------------------------------------------|
-|`ST7565_DISPLAY_WIDTH` |`128`     |The width of the display.                                                                                  |
-|`ST7565_DISPLAY_HEIGHT`|`32`      |The height of the display.                                                                                 |
-|`ST7565_MATRIX_SIZE`   |`512`     |The local buffer size to allocate.<br>`(ST7565_DISPLAY_HEIGHT / 8 * ST7565_DISPLAY_WIDTH)`.                |
-|`ST7565_BLOCK_TYPE`    |`uint16_t`|The unsigned integer type to use for dirty rendering.                                                      |
-|`ST7565_BLOCK_COUNT`   |`16`      |The number of blocks the display is divided into for dirty rendering.<br>`(sizeof(ST7565_BLOCK_TYPE) * 8)`.|
-|`ST7565_BLOCK_SIZE`    |`32`      |The size of each block for dirty rendering<br>`(ST7565_MATRIX_SIZE / ST7565_BLOCK_COUNT)`.                 |
-
-## API
-
-```c
-// Rotation enum values are flags
-typedef enum {
-    DISPLAY_ROTATION_0,
-    DISPLAY_ROTATION_180
-} display_rotation_t;
-
-// Initialize the display, rotating the rendered output based on the define passed in.
-// Returns true if the was initialized successfully
-bool st7565_init(display_rotation_t rotation);
-
-// Called at the start of st7565_init, weak function overridable by the user
-// rotation - the value passed into st7565_init
-// Return new display_rotation_t if you want to override default rotation
-display_rotation_t st7565_init_user(display_rotation_t rotation);
-
-// Clears the display buffer, resets cursor position to 0, and sets the buffer to dirty for rendering
-void st7565_clear(void);
-
-// Renders the dirty chunks of the buffer to display
-void st7565_render(void);
-
-// Moves cursor to character position indicated by column and line, wraps if out of bounds
-// Max column denoted by 'st7565_max_chars()' and max lines by 'st7565_max_lines()' functions
-void st7565_set_cursor(uint8_t col, uint8_t line);
-
-// Advances the cursor to the next page, writing ' ' if true
-// Wraps to the begining when out of bounds
-void st7565_advance_page(bool clearPageRemainder);
-
-// Moves the cursor forward 1 character length
-// Advance page if there is not enough room for the next character
-// Wraps to the begining when out of bounds
-void st7565_advance_char(void);
-
-// Writes a single character to the buffer at current cursor position
-// Advances the cursor while writing, inverts the pixels if true
-// Main handler that writes character data to the display buffer
-void st7565_write_char(const char data, bool invert);
-
-// Writes a string to the buffer at current cursor position
-// Advances the cursor while writing, inverts the pixels if true
-void st7565_write(const char *data, bool invert);
-
-// Writes a string to the buffer at current cursor position
-// Advances the cursor while writing, inverts the pixels if true
-// Advances the cursor to the next page, wiring ' ' to the remainder of the current page
-void st7565_write_ln(const char *data, bool invert);
-
-// Pans the buffer to the right (or left by passing true) by moving contents of the buffer
-// Useful for moving the screen in preparation for new drawing
-void st7565_pan(bool left);
-
-// Returns a pointer to the requested start index in the buffer plus remaining
-// buffer length as struct
-display_buffer_reader_t st7565_read_raw(uint16_t start_index);
-
-// Writes a string to the buffer at current cursor position
-void st7565_write_raw(const char *data, uint16_t size);
-
-// Writes a single byte into the buffer at the specified index
-void st7565_write_raw_byte(const char data, uint16_t index);
-
-// Sets a specific pixel on or off
-// Coordinates start at top-left and go right and down for positive x and y
-void st7565_write_pixel(uint8_t x, uint8_t y, bool on);
-
-// Writes a PROGMEM string to the buffer at current cursor position
-// Advances the cursor while writing, inverts the pixels if true
-// Remapped to call 'void st7565_write(const char *data, bool invert);' on ARM
-void st7565_write_P(const char *data, bool invert);
-
-// Writes a PROGMEM string to the buffer at current cursor position
-// Advances the cursor while writing, inverts the pixels if true
-// Advances the cursor to the next page, wiring ' ' to the remainder of the current page
-// Remapped to call 'void st7565_write_ln(const char *data, bool invert);' on ARM
-void st7565_write_ln_P(const char *data, bool invert);
-
-// Writes a PROGMEM string to the buffer at current cursor position
-void st7565_write_raw_P(const char *data, uint16_t size);
-
-// Can be used to manually turn on the screen if it is off
-// Returns true if the screen was on or turns on
-bool st7565_on(void);
-
-// Called when st7565_on() turns on the screen, weak function overridable by the user
-// Not called if the screen is already on
-void st7565_on_user(void);
-
-// Can be used to manually turn off the screen if it is on
-// Returns true if the screen was off or turns off
-bool st7565_off(void);
-
-// Called when st7565_off() turns off the screen, weak function overridable by the user
-// Not called if the screen is already off
-void st7565_off_user(void);
-
-// Returns true if the screen is currently on, false if it is
-// not
-bool st7565_is_on(void);
-
-// Basically it's st7565_render, but with timeout management and st7565_task_user calling!
-void st7565_task(void);
-
-// Called at the start of st7565_task, weak function overridable by the user
-void st7565_task_user(void);
-
-// Inverts the display
-// Returns true if the screen was or is inverted
-bool st7565_invert(bool invert);
-
-// Returns the maximum number of characters that will fit on a line
-uint8_t st7565_max_chars(void);
-
-// Returns the maximum number of lines that will fit on the display
-uint8_t st7565_max_lines(void);
-```

docs/fr-fr/README.md

@@ -7,9 +7,9 @@
 [![Contributeurs GitHub](https://img.shields.io/github/contributors/qmk/qmk_firmware.svg)](https://github.com/qmk/qmk_firmware/pulse/monthly)
 [![Forks GitHub](https://img.shields.io/github/forks/qmk/qmk_firmware.svg?style=social&label=Fork)](https://github.com/qmk/qmk_firmware/)
 
-## Qu'est-ce que QMK Firmware ?
+## Qu'est-ce que QMK Firmware?
 
-QMK (*Quantum Mechanical Keyboard*) est une communauté open source qui maintient le firmware QMK, la QMK Toolbox (*Boite à outil*), qmk.fm et leurs documentations. QMK Firmware est un firmware dédié aux claviers qui est basé sur [tmk\_keyboard](https://github.com/tmk/tmk_keyboard). Il offre des fonctionnalités très utiles pour les contrôleurs Atmel AVR, et, plus spécifiquement pour [les produits d'OLKB](https://olkb.com), le clavier [ErgoDox EZ](https://www.ergodox-ez.com), et pour les [produits Clueboard](https://clueboard.co/). Il prend désormais aussi en charge les processeurs ARM qui utilisent ChibiOS. Vous pouvez l'utiliser pour contrôler un clavier personnalisé soudé à la main ou alors sur un clavier avec un PCB personnalisé.
+QMK (*Quantum Mechanical Keyboard*) est une communauté open source qui maintient le firmware QMK, la QMK Toolbox (*Boite à outil*), qmk.fm et leurs documentations. QMK Firmware est un firmware dédié aux claviers qui est basé sur [tmk\_keyboard](https://github.com/tmk/tmk_keyboard). Il offre des fonctionnalités très utiles pour les contrôleurs Atmel AVR, et, plus spécifiquement pour [les produits d'OLKB](https://olkb.com), le clavier [ErgoDox EZ](https://www.ergodox-ez.com), et pour les [produits Clueboard](https://clueboard.co/). Il prend désormais aussi en charge les processeurs ARM qui utilisent ChibiOS. Vous pouvez l'utiliser pour contrôler un clavier personnalisé soudé à la main ou alors sur un clavier avec un PCB personnalisé.
 
 ## Comment l'obtenir
 
@@ -23,7 +23,7 @@ Avant d'être prêt à compiler vous allez devoir [installer un environnement](f
 
     make planck/rev4:default
 
-Cette commande compilera la révision `rev4` du clavier `planck` avec la disposition `default`. Notez que tous les claviers n'ont pas forcément de révisions (aussi appelées sous-projects ou dossiers, ou en anglais « subprojects » ou « folder »). Cette option peut donc être omise :
+Cette commande compilera la révision `rev4` du clavier `planck` avec la disposition `default`. Notez que tous les claviers n'ont pas forcément de révisions (aussi appelées sous-projects ou dossiers, ou en anglais «subprojects» ou «folder»). Cette option peut donc être omise:
 
     make preonic:default
 

docs/fr-fr/driver_installation_zadig.md

@@ -9,7 +9,7 @@ Nous vous recommandons d'utiliser l'utilitaire [Zadig](https://zadig.akeo.ie/).
 ## Installation
 
 Passez votre clavier en mode bootloader, soit en appuyant sur le keycode `RESET` (qui peut se trouver dans un calque différent) ou en appuyant sur le bouton reset qui se trouve en général sous la board. Si votre clavier n'a aucune de ces options, essayez de le brancher en maintenant Escape ou Espace+`B` appuyés (voir la documentation de [Bootmagic](feature_bootmagic.md) pour plus de détails). Certaines boards utilisent [Command](feature_command.md) à la place de Bootmagic. Dans ce cas, vous pouvez entrer en mode bootloader en appuyant, à n'importe quel moment lorsque le clavier est branché, sur les combinaisons de touches Shift Gauche+Shift Droit+`B` ou Shift Gauche+Shift Droit+Escape.
-Certains claviers ont des instructions spécifiques pour passer en mode bootloader. Par exemple, la touche [Bootmagic Lite]](feature_bootmagic.md#bootmagic-lite) (défaut : Échap) peut être sur une touche différente telle que Contrôle Gauche. La combinaison pour la Command (défaut : Shift Gauche+Shift Droit) peut être différente, par exemple Contrôle Gauche+Contrôle Droit. Référez-vous au fichier README de votre clavier.
+Certains claviers ont des instructions spécifiques pour passer en mode bootloader. Par exemple, la touche [Bootmagic Lite]](feature_bootmagic.md#bootmagic-lite) (défaut: Échap) peut être sur une touche différente telle que Contrôle Gauche. La combinaison pour la Command (défaut: Shift Gauche+Shift Droit) peut être différente, par exemple Contrôle Gauche+Contrôle Droit. Référez-vous au fichier README de votre clavier.
 
 Pour mettre un clavier en mode bootloader avec USBaspLoader, appuyez sur le bouton `RESET` tout en maintenant le bouton `BOOT`. Vous pouvez aussi maintenir le bouton `BOOT` en branchant le câble USB.
 
@@ -43,4 +43,4 @@ Cliquez dessus avec le bouton droit et sélectionner **Désinstaller le périph
 
 ![Le dialogue Suppression de périphérique, avec la boîte "suppression de pilote" cochée](https://i.imgur.com/aEs2RuA.png)
 
-Appuyez sur **Action → Analyser les changements de hardware**. A ce stade, vous devriez pouvoir saisir à nouveau. Vérifiez dans Zadig que les périphériques utilisent bien le pilote `HidUsb`. Si c'est le cas, vous avez corrigé le problème, votre clavier devrait fonctionner à nouveau !
+Appuyez sur **Action → Analyser les changements de hardware**. A ce stade, vous devriez pouvoir saisir à nouveau. Vérifiez dans Zadig que les périphériques utilisent bien le pilote `HidUsb`. Si c'est le cas, vous avez corrigé le problème, votre clavier devrait fonctionner à nouveau!

docs/fr-fr/faq_build.md

@@ -20,7 +20,7 @@ Veuillez noter que lancer `make` avec `sudo` est généralement une **mauvaise**
 
 ### Règles `udev` pour Linux
 
-Sous Linux, vous aurez besoin des permissions appropriées pour accéder au MCU (le micro-contrôleur). Vous avez le choix d'utiliser `sudo` en flashant le firmware, ou placer ces fichiers dans `/etc/udev/rules.d`. Une fois ajouté, lancez les commandes suivantes :
+Sous Linux, vous aurez besoin des permissions appropriées pour accéder au MCU (le micro-contrôleur). Vous avez le choix d'utiliser `sudo` en flashant le firmware, ou placer ces fichiers dans `/etc/udev/rules.d`. Une fois ajouté, lancez les commandes suivantes:
 
 ```console
 sudo udevadm control --reload-rules

docs/fr-fr/faq_debug.md

@@ -6,13 +6,13 @@ Cette page détaille diverses questions fréquemment posées par les utilisateur
 
 ## `hid_listen` ne reconnaît pas de périphérique
 
-Lorsque la console de débugage sur votre périphérique n'est pas prêt, vous obtiendrez un message similaire :
+Lorsque la console de débugage sur votre périphérique n'est pas prêt, vous obtiendrez un message similaire:
 
 ```
 Waiting for device:.........
 ```
 
-Une fois le périphérique connecté, *hid_listen* le trouve et vous obtiendrez ce message :
+Une fois le périphérique connecté, *hid_listen* le trouve et vous obtiendrez ce message:
 
 ```
 Waiting for new device:.........................
@@ -61,7 +61,7 @@ Vous ne voulez probablement pas "briquer" votre clavier, rendre impossible d'éc
 
 - Si votre map de clavier n'inclut pas de RESET, pour entrer en mode DFU, vous devrez appuyer sur le bouton reset du PCB. Cela implique que vous devrez certainement dévisser certaines pièces de votre clavier pour y accéder.
 - Modifier les fichiers tmk_core / common peut rendre le clavier inutilisable
-- Si un fichier .hex trop large est la cause du problème : `make dfu` supprime le bloc puis teste la taille (il ne fait pas les choses dans le bon ordre), ce qui provoque une erreur. En résultat, le flash n’aura pas été fait et le clavier restera en mode DFU.
+- Si un fichier .hex trop large est la cause du problème: `make dfu` supprime le bloc puis teste la taille (il ne fait pas les choses dans le bon ordre), ce qui provoque une erreur. En résultat, le flash n’aura pas été fait et le clavier restera en mode DFU.
 - Pour finir, notez que la taille maximale d'un fichier .hex sur un Plank est de 7000h (28672 decimal)
 
 ```
@@ -118,7 +118,7 @@ Sous Windows, activez l'option `Permettre au périphérique de sortir l'ordinate
 
 Appuyer sur n'importe quelle touche en mode veille devrait sortir l'ordinateur de veille.
 
-## Vous utilisez un Arduino ?
+## Vous utilisez un Arduino?
 
 **Faites attention au fait que le nommage des pin d'un Arduino diffère de la puce**. Par exemple, la pin `D0` n'est pas `PD0`. Vérifiez le circuit avec la fiche technique.
 

docs/fr-fr/faq_keymap.md

@@ -44,7 +44,7 @@ Le premier n'est reconnu que sur macOS, alors que le dernier, `KC_SLEP` et `KC_W
 
 ## Modificateur "One Shot"
 
-Cette fonctionnalité permet de corriger un problème avec la touche Shift. En effet, il arrive de saisir plusieurs majuscules en ne voulant en saisir qu'une sur un mot. Ex : `CEtte` à la place de `Cette`. La fonctionnalité « One shot » shift permet de corriger ça.
+Cette fonctionnalité permet de corriger un problème avec la touche Shift. En effet, il arrive de saisir plusieurs majuscules en ne voulant en saisir qu'une sur un mot. Ex: `CEtte` à la place de `Cette`. La fonctionnalité «One shot» shift permet de corriger ça.
 
 https://github.com/tmk/tmk_keyboard/issues/67
 
@@ -59,7 +59,7 @@ Pour les touches de modification et les actions de calque, vous devez placer `KC
 
 ## Support de touche à verrouillage mécanique
 
-Cette fonctionnalité permet l'usage de *touches à verrouillage mécanique* comme [ces interrupteurs Alps](https://deskthority.net/wiki/Alps_SKCL_Lock). Vous pouvez l'activer en ajoutant ceci à votre `config.h` :
+Cette fonctionnalité permet l'usage de *touches à verrouillage mécanique* comme [ces interrupteurs Alps](https://deskthority.net/wiki/Alps_SKCL_Lock). Vous pouvez l'activer en ajoutant ceci à votre `config.h`:
 
 ```
 #define LOCKING_SUPPORT_ENABLE

docs/fr-fr/flashing.md

@@ -27,15 +27,15 @@ Méthodes de flash compatibles :
 * [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) (interface graphique recommandé)
 * [dfu-programmer](https://github.com/dfu-programmer/dfu-programmer) / `:dfu` avec QMK (outil en ligne de commande recommandé)
 
-Ordre des actions :
+Ordre des actions:
 
 1. Pressez le keycode `RESET`, ou appuyez sur le bouton physique RESET ou alors créez un contact entre RST et GND.
 2. Attendez que l'OS detecte l'appareil.
 3. Éffacez la mémoire, cela peut être fait automatiquement.
 4. Flasher le fichier .hex.
-5. Redémarrez l'appareil en mode « application », cela peut être fait automatiquement.
+5. Redémarrez l'appareil en mode «application», cela peut être fait automatiquement.
 
-Alternativement :
+Alternativement:
 
     make <keyboard>:<keymap>:dfu
 
@@ -48,11 +48,11 @@ QMK a un fork du bootloader LUFA DFU qui vous permet de faire un simple scan de
     #define QMK_LED E6
     #define QMK_SPEAKER C6
 
-Le fabricant et le nom du produit proviennent de vos définitions dans fichier  `config.h`, et la chaîne de caractère « bootloader » est ajoutée au nom du produit.
+Le fabricant et le nom du produit proviennent de vos définitions dans fichier  `config.h`, et la chaîne de caractère «bootloader» est ajoutée au nom du produit.
 
-Pour génerer le bootloader, utilisez la cible `bootloader`. Exemple : `make planck/rev4:default:bootloader`.
+Pour génerer le bootloader, utilisez la cible `bootloader`. Exemple: `make planck/rev4:default:bootloader`.
 
-Pour génerer un fichier .hex prêt pour la production qui contiendra tant l'application que le bootloader, utilisez la cible `production`. Exemple : `make planck/rev4:default:production`.
+Pour génerer un fichier .hex prêt pour la production qui contiendra tant l'application que le bootloader, utilisez la cible `production`. Exemple: `make planck/rev4:default:production`.
 
 ### Commandes DFU
 
@@ -67,7 +67,7 @@ Il y a plusieurs commandes DFU que vous pouvez utiliser pour flasher le firmware
 
 Les cartes arduinos et leurs clones utilisent le [bootloader Caterina](https://github.com/arduino/ArduinoCore-avr/tree/master/bootloaders/caterina) (tous les claviers utilisant un Pro Micro, ou un clone). Ils utilisent aussi le protocole avr109 pour communiquer en virtuellement en série (serial en anglais). Les bootloaders comme le [A-Star](https://www.pololu.com/docs/0J61/9) sont basés sur Caterina.
 
-Pour vérifier la compatibilité avec un bootloader Caterina, vérifiez que ce bloc est présent dans votre fichier `rules.mk` :
+Pour vérifier la compatibilité avec un bootloader Caterina, vérifiez que ce bloc est présent dans votre fichier `rules.mk`:
 
 ```make
 # Bootloader selection
@@ -81,20 +81,20 @@ Pour vérifier la compatibilité avec un bootloader Caterina, vérifiez que ce b
 BOOTLOADER = caterina
 ```
 
-Flashers compatibles :
+Flashers compatibles:
 
 * [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) (Interface graphique recommandée)
 * [avrdude](https://www.nongnu.org/avrdude/) avec avr109 / `:avrdude` (Outil en ligne de commande recommandé)
 * [AVRDUDESS](https://github.com/zkemble/AVRDUDESS)
 
-Séquence de flash : 
+Séquence de flash :
 
 1. Pressez la touche avec le keycode `RESET`, ou reliez les ports GND et RST. Vous n'avez que 7 secondes pour flasher une fois que l'opération a été faite.
 2. Attendez que l'OS détecte l'appareil.
 3. Flasher le fichier .hex.
 4. Attendez que l'appareil redémarre automatiquement.
 
-ou, utilisez :
+ou, utilisez:
 
     make <keyboard>:<keymap>:avrdude
 
@@ -111,7 +111,7 @@ Il existe un certain nombre de commandes DFU que vous pouvez utiliser pour mettr
 
 Halfkay est un protocole ultra-simple développé par PJRC qui utilise HID et qui est fourni avec tous les Teensys après le modèle 2.0.
 
-Pour vérifier la compatibilité avec le booloader Halfkay, vérifiez que ce bloc est présent dans votre fichier `rules.mk` :
+Pour vérifier la compatibilité avec le booloader Halfkay, vérifiez que ce bloc est présent dans votre fichier `rules.mk`:
 
 ```make
 # Bootloader selection
@@ -125,24 +125,24 @@ Pour vérifier la compatibilité avec le booloader Halfkay, vérifiez que ce blo
 BOOTLOADER = halfkay
 ```
 
-Flasher compatibles :
+Flasher compatibles:
 
 * [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) (Interface graphique recomandée)
 * [Teensy Loader](https://www.pjrc.com/teensy/loader.html) (petit utilitaire ultra simple)
  [Teensy Loader en ligne de commande](https://www.pjrc.com/teensy/loader_cli.html) (Outil en ligne de commande recommandé)
 
-Séquence de flash :
+Séquence de flash:
 
 1. Pressez la touche du keycode `RESET`, ou reliez les ports RST et GND rapidement. Vous avez ensuite 7 secondes pour réaliser le flash.
 2. Attendez que l'OS détecte l'appareil.
 3. Flasher le fichier .hex.
-4. Redémarrez l'appareil en mode « application ». Cela peut être fait automatiquement.
+4. Redémarrez l'appareil en mode «application». Cela peut être fait automatiquement.
 
 ## USBasploader
 
 USBasploader est un bootloader développé par matrixstorm. Il est utilisé sur des processeurs AVR non-USB comme le ATmega328P, qui fonctionne grâce à V-USB.
 
-Pour vérifier la compatibilité avec le booloader USBasploader, vérifiez que ce bloc est présent dans votre fichier `rules.mk` :
+Pour vérifier la compatibilité avec le booloader USBasploader, vérifiez que ce bloc est présent dans votre fichier `rules.mk`:
 
 ```make
 # Bootloader selection
@@ -156,24 +156,24 @@ Pour vérifier la compatibilité avec le booloader USBasploader, vérifiez que c
 BOOTLOADER = USBasp
 ```
 
-Flashers compatibles :
+Flashers compatibles:
 
 * [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) (Interface graphique recommandé)
 * [avrdude](https://www.nongnu.org/avrdude/) avec le programmeur `usbasp`.
 * [AVRDUDESS](https://github.com/zkemble/AVRDUDESS)
 
-Séquence de flash :
+Séquence de flash:
 
 1. Pressez la touche du keycode `RESET`, ou reliez le port de boot pendant que RST et GND snt reliés. Cela doit être fait très rapidement.
 2. Attendez que l'OS détecte l'appareil.
 3. Flasher le fichier .hex.
-4. Redémarrez l'appareil en mode « application ». Cela peut être fait automatiquement.
+4. Redémarrez l'appareil en mode «application». Cela peut être fait automatiquement.
 
 ## BootloadHID
 
 BootloadHID est un bootloader pour les microcontrôleurs AVR. L'utilitaire de téleversement ne demande pas de drivers au niveau du kernel et peut être lancé sans installer aucune DLLs.
 
-Pour vérifier la compatibilité avec le bootloader bootloadHID, vérifiez que ce bloc existe dans votre fichier `rules.mk` : 
+Pour vérifier la compatibilité avec le bootloader bootloadHID, vérifiez que ce bloc existe dans votre fichier `rules.mk` :
 
 ```make
 # Bootloader selection
@@ -187,50 +187,50 @@ Pour vérifier la compatibilité avec le bootloader bootloadHID, vérifiez que c
 BOOTLOADER = bootloadHID
 ```
 
-Utilitaires de flash compatibles :
+Utilitaires de flash compatibles:
 
 * [HIDBootFlash](http://vusb.wikidot.com/project:hidbootflash) (Utilitaire avec interface graphique recommandé)
 * [bootloadhid Command Line](https://www.obdev.at/products/vusb/bootloadhid.html) / `:BootloadHID` avec QMK (utilitaire en ligne de commande recommandé)
 
 Séquence de flash
 
-1. Entrez dans le bootloader en utilisant l'une de ces méthodes :
+1. Entrez dans le bootloader en utilisant l'une de ces méthodes:
     * Pressez la touche du keycode `RESET` (Cela ne fonctionnera pas sur certains appareils).
-    * Verrouillez la touche « Salt » tout en branchant le clavier (Généralement ce principe est documenté dans le fichier readme du clavier)
+    * Verrouillez la touche «Salt» tout en branchant le clavier (Généralement ce principe est documenté dans le fichier readme du clavier)
 2. Attendez que l'OS détecte l'appareil.
 3. Flasher le fichier .hex.
-4. Redémarrez l'appareil en mode « application ». Cela peut être fait automatiquement.
+4. Redémarrez l'appareil en mode «application». Cela peut être fait automatiquement.
 
-Ou alors :
+Ou alors:
 
     make <keyboard>:<keymap>:bootloadHID
 
 ## STM32
 
-Tous les processeurs STM32 contiennent un bootloader installé en usine qui ne peut pas être modifié ou supprimé. Certains processeurs STM32 ont des bootloaders qui ne peuvent pas être programmés par USB (ex : STM32F103) mais le processus reste le même.
+Tous les processeurs STM32 contiennent un bootloader installé en usine qui ne peut pas être modifié ou supprimé. Certains processeurs STM32 ont des bootloaders qui ne peuvent pas être programmés par USB (ex: STM32F103) mais le processus reste le même.
 
 Pour le moment, aucune variable `BOOTLOADER` n'est nécessaire dans le fichier `rules.mk`.
 
-Flashers compatibles :
+Flashers compatibles:
 
 * [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) (interface graphique recommandé)
 * [dfu-util](https://github.com/Stefan-Schmidt/dfu-util) / `:dfu-util` (utilitaire en ligne de commande recommandé)
 
 Séquence pour flasher:
 
-1. Entrez dans le bootloader en utilisant l'une de ces méthodes :
+1. Entrez dans le bootloader en utilisant l'une de ces méthodes:
     * Utilisez une touche sur laquelle le keycode `RESET` (Cela peut ne pas fonctionner sur les appareils STM32F042)
     * Si un circuit de réinitialisation (Reset) est présent alors utilisé le bouton qui lui est dédié.
     * Autrement, vous devez réaliser une liaison entre BOOT0 et VCC (en appuyant sur le bouton ou à l'aide d'un pont) puis faire un pont entre RESET et GND et enfin relacher le pont BOOT0.
 2. Attendre que l'os détecte l'appareil.
 3. Flasher un fichier `.bin`.h
     * Vous allez recevoir un avertissement à propos de la signature DFU. Ignorez-la.
-4. Réinitialisez l'appareil en mode « application ». Cela peut être fait automatiquement.
-    * Si vous êtes en train de travailler en ligne de commande, par exemple avec un `make planck/rev6:default:dfu-util` alors soyez bien sur que l'argument `:leave` est passé aux arguments DFU grâce à la variable `DFU_ARGS` à l'intérieur de votre fichier `rules.mk` (Ex : `DFU_ARGS = -d 0483:df11 -a 0 -s 0x08000000:leave`) afin que votre appareil redémarre après avoir été flashé.
+4. Réinitialisez l'appareil en mode «application». Cela peut être fait automatiquement.
+    * Si vous êtes en train de travailler en ligne de commande, par exemple avec un `make planck/rev6:default:dfu-util` alors soyez bien sur que l'argument `:leave` est passé aux arguments DFU grâce à la variable `DFU_ARGS` à l'intérieur de votre fichier `rules.mk` (Ex: `DFU_ARGS = -d 0483:df11 -a 0 -s 0x08000000:leave`) afin que votre appareil redémarre après avoir été flashé.
 
 ### Commandes STM32
 
-Il y a différentes commandes que vous pouvez utiliser pour flasher un firmware dans un appareil STM32  :
+Il y a différentes commandes que vous pouvez utiliser pour flasher un firmware dans un appareil STM32:
 
 * `:dfu-util` - C'est l'option standard pour flasher un appareil STM32. Le script attendra qu'un bootloader STM32 soit présent.
 * `:dfu-util-split-left` - Permet de flasher un firmware normalement, tout comme l'option précédente mais permet de configurer le côté gauche des paramètres EEPROM sur un clavier scindé.

docs/fr-fr/newbs_flashing.md

@@ -88,7 +88,7 @@ Par exemple, si votre keymap s'appelle "xyverz" et que vous fabriquez une keymap
 
 La commande va vérifier la configuration du clavier, puis tentera de le flasher en fonction du bootloader (chargeur d’amorçage) spécifié. Cela signifie que vous n'avez pas besoin de savoir quel bootloader votre clavier utilise. Exécutez simplement la commande et laissez-le faire le gros du travail.
 
-Cependant, tout dépend du bootloader qui est installé sur le clavier. Si cette information n’est pas configurée ou si vous tentez de flasher un clavier qui ne permet pas d’être flashé alors vous obtiendrez cette erreur :
+Cependant, tout dépend du bootloader qui est installé sur le clavier. Si cette information n’est pas configurée ou si vous tentez de flasher un clavier qui ne permet pas d’être flashé alors vous obtiendrez cette erreur:
 
     WARNING: This board's bootloader is not specified or is not supported by the ":flash" target at this time.
 
@@ -326,7 +326,7 @@ Il y  aun certain nombre de commandes du DFU que vous pouvez utiliser pour flash
 
 ### BootloadHID
 
-Pour les claviers basés sur Bootmapper Client(BMC)/bootloadHID/ATmega32A, si vous êtes prêts à compiler et flasher le firmware, ouvrez votre fenêtre de terminal et lancez la commande suivante :
+Pour les claviers basés sur Bootmapper Client(BMC)/bootloadHID/ATmega32A, si vous êtes prêts à compiler et flasher le firmware, ouvrez votre fenêtre de terminal et lancez la commande suivante:
 
     make <my_keyboard>:<my_keymap>:bootloaderHID
 
@@ -351,7 +351,7 @@ Error opening HIDBoot device: The specified device was not found
 Trying again in 5s.
 ```
 
-Une fois ce résultat obtenu, réinitialisez le contrôleur. Le résultat suivant devrait s’afficher :
+Une fois ce résultat obtenu, réinitialisez le contrôleur. Le résultat suivant devrait s’afficher:
 
 ```
 Page size   = 128 (0x80)

docs/ja/_summary.md

@@ -3,7 +3,6 @@
   * [セットアップ](ja/newbs_getting_started.md)
   * [初めてのファームウェアの構築](ja/newbs_building_firmware.md)
   * [ファームウェアのフラッシュ](ja/newbs_flashing.md)
-  * [テストとデバッグ](ja/newbs_testing_debugging.md)
   * [手助けを得る/サポート](ja/support.md)
   * [他のリソース](ja/newbs_learn_more_resources.md)
   * [シラバス](ja/syllabus.md)
@@ -11,7 +10,8 @@
 * FAQ
   * [一般的な FAQ](ja/faq_general.md)
   * [QMK のビルド/コンパイル](ja/faq_build.md)
-  * [QMK のデバッグ/トラブルシューティング](ja/faq_debug.md)
+  * [QMK のデバッグ](ja/faq_debug.md)
+  * [QMK のトラブルシューティング](ja/faq_misc.md)
   * [キーマップ FAQ](ja/faq_keymap.md)
   * [用語](ja/reference_glossary.md)
 
@@ -23,11 +23,13 @@
     * [概要](ja/api_overview.md)
     * [API ドキュメント](ja/api_docs.md)
     * [キーボードサポート](ja/reference_configurator_support.md)
+    * [デフォルトキーマップの追加](ja/configurator_default_keymaps.md)
 
 * CLI
     * [概要](ja/cli.md)
     * [設定](ja/cli_configuration.md)
     * [コマンド](ja/cli_commands.md)
+    * [Tab 補完](ja/cli_tab_complete.md)
 
 * QMK を使う
   * ガイド
@@ -41,8 +43,8 @@
       * [書き込み](ja/flashing.md)
       * [ATmega32A の書き込み (ps2avrgb)](ja/flashing_bootloadhid.md)
     * IDE
-      * [Eclipse で QMK を使用](ja/other_eclipse.md)
-      * [VSCode で QMK を使用](ja/other_vscode.md)
+      * [QMK での Eclipse の使用](ja/other_eclipse.md)
+      * [QMK での VSCode の使用](ja/other_vscode.md)
     * Git のベストプラクティス
       * [入門](ja/newbs_git_best_practices.md)
       * [フォーク](ja/newbs_git_using_your_master_branch.md)
@@ -79,6 +81,7 @@
     * [ワンショットキー](ja/one_shot_keys.md)
     * [ポインティング デバイス](ja/feature_pointing_device.md)
     * [ロー HID](ja/feature_rawhid.md)
+    * [シーケンサー](ja/feature_sequencer.md)
     * [スワップハンド](ja/feature_swap_hands.md)
     * [タップダンス](ja/feature_tap_dance.md)
     * [タップホールド設定](ja/tap_hold.md)
@@ -103,6 +106,7 @@
     * [DIP スイッチ](ja/feature_dip_switch.md)
     * [エンコーダ](ja/feature_encoders.md)
     * [触覚フィードバック](ja/feature_haptic_feedback.md)
+    * [ジョイスティック](ja/feature_joystick.md)
     * [LED インジケータ](ja/feature_led_indicators.md)
     * [Proton C 変換](ja/proton_c_conversion.md)
     * [PS/2 マウス](ja/feature_ps2_mouse.md)
@@ -116,11 +120,8 @@
   * 互換性を破る変更/Breaking changes
     * [概要](ja/breaking_changes.md)
     * [プルリクエストにフラグが付けられた](ja/breaking_changes_instructions.md)
-    * 履歴
-      * [2020年8月29日](ja/ChangeLog/20200829.md)
-      * [2020年5月30日](ja/ChangeLog/20200530.md)
-      * [2020年2月29日](ja/ChangeLog/20200229.md)
-      * [2019年8月30日](ja/ChangeLog/20190830.md)
+    * [最近の変更履歴](ChangeLog/20210227.md "QMK v0.12.0 - 2021 Feb 27")
+    * [過去の互換性を破る変更](ja/breaking_changes_history.md)
 
   * C 開発
     * [ARM デバッグ ガイド](ja/arm_debugging.md)
@@ -129,11 +130,13 @@
     * [互換性のあるマイクロコントローラ](ja/compatible_microcontrollers.md)
     * [ドライバ](ja/hardware_drivers.md)
       * [ADC ドライバ](ja/adc_driver.md)
+      * [オーディオドライバ](ja/audio_driver.md)
       * [I2C ドライバ](ja/i2c_driver.md)
       * [SPI ドライバ](ja/spi_driver.md)
       * [WS2812 ドライバ](ja/ws2812_driver.md)
       * [EEPROM ドライバ](ja/eeprom_driver.md)
       * [シリアル ドライバ](ja/serial_driver.md)
+      * [UART ドライバ](ja/uart_driver.md)
     * [GPIO 制御](ja/internals_gpio_control.md)
     * [キーボード ガイドライン](ja/hardware_keyboard_guidelines.md)
 

docs/ja/cli_configuration.md

@@ -74,7 +74,7 @@ default.keymap: None -> default
 
     qmk config compile
 
-### 単一キーの例
+### 単一キーの例 :id=single-key-example
 
     qmk config compile.keyboard
 

docs/ja/faq_debug.md

@@ -1,13 +1,100 @@
 # デバッグの FAQ
 
 <!---
-  original document: 0.10.33:docs/faq_debug.md
-  git diff 0.10.33 HEAD -- docs/faq_debug.md | cat
+  original document: 0.12.45:docs/faq_debug.md
+  git diff 0.12.45 HEAD -- docs/faq_debug.md | cat
 -->
 
 このページは、キーボードのトラブルシューティングについての様々な一般的な質問を説明します。
 
-# デバッグコンソール
+## デバッグ :id=debugging
+
+`rules.mk` へ `CONSOLE_ENABLE = yes` の設定をするとキーボードはデバッグ情報を出力します。デフォルトの出力は非常に限られたものですが、デバッグモードをオンにすることでデバッグ情報の量を増やすことが出来ます。キーマップの `DEBUG` キーコードを使用するか、デバッグモードを有効にする[コマンド](ja/feature_command.md)機能を使用するか、以下のコードをキーマップに追加します。
+
+```c
+void keyboard_post_init_user(void) {
+  // 希望する動作に合わせて値をカスタマイズします
+  debug_enable=true;
+  debug_matrix=true;
+  //debug_keyboard=true;
+  //debug_mouse=true;
+}
+```
+
+## デバッグツール
+
+キーボードのデバッグに使えるツールは2つあります。
+
+### QMK Toolbox を使ったデバッグ
+
+互換性のある環境では、[QMK Toolbox](https://github.com/qmk/qmk_toolbox) を使うことでキーボードからのデバッグメッセージを表示できます。
+
+### hid_listen を使ったデバッグ
+
+ターミナルベースの方法がお好みですか？PJRC が提供する [hid_listen](https://www.pjrc.com/teensy/hid_listen.html) もデバッグメッセージの表示に使用できます。ビルド済みの実行ファイルは Windows、Linux、MacOS 用が用意されています。
+
+## 独自のデバッグメッセージを送信する
+
+[カスタムコード](ja/custom_quantum_functions.md)内からデバッグメッセージを出力すると便利な場合があります。それはとても簡単です。ファイルの先頭に `print.h` のインクルードを追加します:
+
+```c
+#include "print.h"
+```
+
+その後は、いくつかの異なった print 関数を使用することが出来ます:
+
+* `print("string")`: シンプルな文字列を出力します
+* `uprintf("%s string", var)`: フォーマットされた文字列を出力します
+* `dprint("string")` デバッグモードが有効な場合のみ、シンプルな文字列を出力します
+* `dprintf("%s string", var)`: デバッグモードが有効な場合のみ、フォーマットされた文字列を出力します
+
+## デバッグの例
+
+以下は現実世界での実際のデバッグ手法の例を集めたものです。
+
+### マトリックス上のどの場所でキー押下が起こったか？
+
+移植する場合や、PCB の問題を診断する場合、キー入力が正しくスキャンされているかどうかを確認することが役立つ場合があります。この手法でのロギングを有効化するには、`keymap.c` へ以下のコードを追加します。
+
+```c
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  // コンソールが有効化されている場合、マトリックス上の位置とキー押下状態を出力します
+#ifdef CONSOLE_ENABLE
+    uprintf("KL: kc: 0x%04X, col: %u, row: %u, pressed: %b, time: %u, interrupt: %b, count: %u\n", keycode, record->event.key.col, record->event.key.row, record->event.pressed, record->event.time, record->tap.interrupted, record->tap.count);
+#endif
+  return true;
+}
+```
+
+出力例
+```text
+Waiting for device:.......
+Listening:
+KL: kc: 169, col: 0, row: 0, pressed: 1
+KL: kc: 169, col: 0, row: 0, pressed: 0
+KL: kc: 174, col: 1, row: 0, pressed: 1
+KL: kc: 174, col: 1, row: 0, pressed: 0
+KL: kc: 172, col: 2, row: 0, pressed: 1
+KL: kc: 172, col: 2, row: 0, pressed: 0
+```
+
+### キースキャンにかかる時間の測定
+
+パフォーマンスの問題をテストする場合、スイッチマトリックスをスキャンする頻度を知ることが役立ちます。この手法でのロギングを有効化するには `config.h` へ以下のコードを追加します。
+
+```c
+#define DEBUG_MATRIX_SCAN_RATE
+```
+
+出力例
+```text
+  > matrix scan frequency: 315
+  > matrix scan frequency: 313
+  > matrix scan frequency: 316
+  > matrix scan frequency: 316
+  > matrix scan frequency: 316
+  > matrix scan frequency: 316
+```
 
 ## `hid_listen` がデバイスを認識できない
 デバイスのデバッグコンソールの準備ができていない場合、以下のように表示されます:
@@ -25,116 +112,20 @@ Listening:
 
 この 'Listening:' のメッセージが表示されない場合は、[Makefile] を `CONSOLE_ENABLE=yes` に設定してビルドしてみてください
 
-Linux のような OS でデバイスにアクセスするには、権限が必要かもしれません。
-- `sudo hid_listen` を試してください
+Linux のような OS でデバイスにアクセスするには、特権が必要かもしれません。`sudo hid_listen` を試してください。
+
+多くの Linux ディストリビューションでは、次の内容で `/etc/udev/rules.d/70-hid-listen.rules` というファイルを作成することで、root として hid_listen を実行する必要がなくなります:
+
+```
+SUBSYSTEM=="hidraw", ATTRS{idVendor}=="abcd", ATTRS{idProduct}=="def1", TAG+="uaccess", RUN{builtin}+="uaccess"
+```
+
+abcd と def1 をキーボードのベンダーとプロダクト IDに置き換えてください。文字は小文字でなければなりません。`RUN{builtin}+="uaccess"` の部分は、古いディストリビューションでのみ必要です。
 
 ## コンソールにメッセージが表示されない
 以下を調べてください:
 - *hid_listen* がデバイスを検出する。上記を見てください。
 - **Magic**+d を使ってデバッグを有効にする。[マジックコマンド](https://github.com/tmk/tmk_keyboard#magic-commands)を見てください。
-- `debug_enable=true` を設定します。[テストとデバッグ](ja/newbs_testing_debugging.md#debugging)を見てください
-- デバッグ print の代わりに 'print' 関数を使ってみてください。**common/print.h** を見てください。
+- `debug_enable=true` を設定します。[デバッグ](#debugging)を見てください。
+- デバッグプリントの代わりに `print` 関数を使ってみてください。**common/print.h** を見てください。
 - コンソール機能を持つ他のデバイスを切断します。[Issue #97](https://github.com/tmk/tmk_keyboard/issues/97) を見てください。
-
-***
-
-# 雑多なこと
-## 安全性の考慮
-
-あなたはおそらくキーボードを「文鎮化」したくないでしょう。文鎮化するとファームウェアを書き換えられないようになります。リスクがあまりに高い(そしてそうでないかもしれない)ものの一部のリストを示します。
-
-- キーボードマップに RESET が含まれない場合、DFU モードに入るには、PCB のリセットボタンを押す必要があります。底部のネジを外す必要があります。
-- tmk_core / common にあるファイルを触るとキーボードが操作不能になるかもしれません。
-- .hex ファイルが大きすぎると問題を引き起こします; `make dfu` コマンドはブロックを削除し、
-サイズを検査し(おっと、間違った順序です！)、エラーを出力し、
-キーボードへの書き込みに失敗し、DFU モードのままになります。
-   - この目的のためには、Planck の最大の .hex ファイルサイズは 7000h (10進数で28672)であることに注意してください。
-
-```
-Linking: .build/planck_rev4_cbbrowne.elf                                                            [OK]
-Creating load file for Flash: .build/planck_rev4_cbbrowne.hex                                       [OK]
-
-Size after:
-   text    data     bss     dec     hex filename
-      0   22396       0   22396    577c planck_rev4_cbbrowne.hex
-```
-
-- 上のファイルのサイズは 22396/577ch で、28672/7000h より小さいです
-- 適切な替わりの .hex ファイルがある限り、それをロードして再試行することができます
-- あなたがキーボードの Makefile で指定したかもしれない一部のオプションは、余分なメモリを消費します; BOOTMAGIC_ENABLE、MOUSEKEY_ENABLE、EXTRAKEY_ENABLE、CONSOLE_ENABLE、API_SYSEX_ENABLE に注意してください
-- DFU ツールは(オプションの余計なフルーツサラダを投げ込まない限り)ブートローダに書き込むことを許可しないので、
-ここにはリスクはほとんどありません。
-- EEPROM の書き込みサイクルは、約100000です。ファームウェアを繰り返し継続的に書き換えるべきではありません。それは最終的に EEPROM を焼き焦がします。
-
-## NKRO が動作しません
-最初に、**Makefile** 内でビルドオプション `NKRO_ENABLE` を使ってファームウェアをコンパイルする必要があります。
-
-**NKRO** がまだ動作しない場合は、`Magic` **N** コマンド(デフォルトでは `LShift+RShift+N`)を試してみてください。**NKRO** モードと **6KRO** モード間を一時的に切り替えるためにこのコマンドを使うことができます。**NKRO** が機能しない状況、特に BIOS の場合は **6KRO** モードに切り替える必要があります。
-
-ファームウェアを `BOOTMAGIC_ENABLE` でビルドした場合、`ブートマジック` **N** コマンドで切り替える必要があります (デフォルトでは `Space+N`)。この設定は EEPROM に格納され、電源を入れ直しても保持されます。
-
-https://github.com/tmk/tmk_keyboard#boot-magic-configuration---virtual-dip-switch
-
-
-## TrackPoint はリセット回路が必要です (PS/2 マウスサポート)
-リセット回路が無いとハードウェアの不適切な初期化のために一貫性の無い結果になります。TPM754 の回路図を見てください。
-
-- https://geekhack.org/index.php?topic=50176.msg1127447#msg1127447
-- https://www.mikrocontroller.net/attachment/52583/tpm754.pdf
-
-
-## 16 を超えるマトリックの列を読み込めない
-列が 16 を超える場合、[matrix.h] の `read_cols()` 内の `1<<16` の代わりに `1UL<<16` を使ってください。
-
-C では、AVR の場合 `1` は [16 bit] である [int] 型の1を意味し、15 を超えて左にシフトすることはできません。`1<<16` すると予期しないゼロが発生します。`1UL` として [unsigned long] 型を使う必要があります。
-
-https://deskthority.net/workshop-f7/rebuilding-and-redesigning-a-classic-thinkpad-keyboard-t6181-60.html#p146279
-
-## 特別なエクストラキーが動作しない (システム、オーディオコントロールキー)
-QMK でそれらを使うには、`rules.mk` 内で `EXTRAKEY_ENABLE` を定義する必要があります。
-
-```
-EXTRAKEY_ENABLE = yes          # オーディオ制御とシステム制御
-```
-
-## スリープから復帰しない
-
-Windows では、**デバイスマネージャ**の**電源の管理**タブ内の `このデバイスで、コンピュータのスタンバイ状態を解除できるようにする` 設定を調べてください。また BIOS 設定も調べてください。
-
-スリープ中に任意のキーを押すとホストが起動するはずです。
-
-## Arduino を使っていますか？
-
-**Arduino のピンの命名は実際のチップと異なることに注意してください。** 例えば、Arduino のピン `D0` は `PD0` ではありません。回路図を自身で確認してください。
-
-- https://arduino.cc/en/uploads/Main/arduino-leonardo-schematic_3b.pdf
-- https://arduino.cc/en/uploads/Main/arduino-micro-schematic.pdf
-
-Arduino の Leonardo と micro には **ATMega32U4** が載っていて、TMK 用に使うことができますが、Arduino のブートローダが問題になることがあります。
-
-## JTAG を有効にする
-
-デフォルトでは、キーボードが起動するとすぐに JTAG デバッグインタフェースが無効になります。JTAG 対応 MCU は `JTAGEN` ヒューズが設定された状態で出荷されており、キーボードがスイッチマトリックス、LED などに使用している可能性のある MCU の特定のピンを乗っ取ります。
-
-JTAG を有効にしたままにしたい場合は、単に以下のものを `config.h` に追加します:
-
-```c
-#define NO_JTAG_DISABLE
-```
-
-## USB 3 の互換性
-USB 3 ポートで問題がある人がいると聞きました。USB 2 ポートを試してください。
-
-
-## Mac の互換性
-### OS X 10.11 と Hub
-https://geekhack.org/index.php?topic=14290.msg1884034#msg1884034
-
-
-## リジューム (スリープとウェークアップ)/電源サイクルの問題
-一部の人がキーボードが BIOS で動作しなくなった、またはリジューム(電源サイクル)の後で動作しなくなったと報告しました。
-
-今のところ、この問題の根本は明確ではないですが、幾つかのビルドオプションが関係しているようです。Makefileで、`CONSOLE_ENABLE`、`NKRO_ENABLE`、`SLEEP_LED_ENABLE` あるいは他のオプションを無効にしてみてください。
-
-https://github.com/tmk/tmk_keyboard/issues/266
-https://geekhack.org/index.php?topic=41989.msg1967778#msg1967778

docs/ja/faq_misc.md

@@ -0,0 +1,107 @@
+# その他の FAQ
+
+<!---
+  original document: 0.12.45:docs/faq_misc.md
+  git diff 0.12.45 HEAD -- docs/faq_misc.md | cat
+-->
+
+## どうやってキーボードをテストすればいいですか？ :id=testing
+
+通常、キーボードのテストは非常に簡単です。全てのキーをひとつずつ押して、期待するキーが送信されることを確認します。例え QMK で動作していない場合でも、[QMK Configurator](https://config.qmk.fm/#/test/) のテストモードを使用すると、キーボードをチェックできます。
+
+## 安全性の考慮
+
+あなたはおそらくキーボードを「文鎮化」したくないでしょう。文鎮化するとファームウェアを書き換えられないようになります。リスクがあまりに高い(そしてそうでないかもしれない)ものの一部のリストを示します。
+
+- キーボードマップに RESET が含まれない場合、DFU モードに入るには、PCB のリセットボタンを押す必要があります。底部のネジを外す必要があります。
+- tmk_core / common にあるファイルを触るとキーボードが操作不能になるかもしれません。
+- .hex ファイルが大きすぎると問題を引き起こします; `make dfu` コマンドはブロックを削除し、サイズを検査し(おっと、間違った順序です！)、エラーを出力し、
+キーボードへの書き込みに失敗し、DFU モードのままになります。
+  - この目的のためには、Planck の最大の .hex ファイルサイズは 7000h (10進数で28672)であることに注意してください。
+
+```
+Linking: .build/planck_rev4_cbbrowne.elf                                                            [OK]
+Creating load file for Flash: .build/planck_rev4_cbbrowne.hex                                       [OK]
+
+Size after:
+   text    data     bss     dec     hex filename
+      0   22396       0   22396    577c planck_rev4_cbbrowne.hex
+```
+
+  - 上のファイルのサイズは 22396/577ch で、28672/7000h より小さいです。
+  - 適切な代わりの .hex ファイルがある限り、それをロードして再試行することができます。
+  - あなたがキーボードの Makefile で指定したかもしれない一部のオプションは、余分なメモリを消費します; BOOTMAGIC_ENABLE、MOUSEKEY_ENABLE、EXTRAKEY_ENABLE、CONSOLE_ENABLE、API_SYSEX_ENABLE に注意してください。
+- DFU ツールは(オプションの余計なフルーツサラダを投げ込まない限り)ブートローダに書き込むことを許可しないので、ここにはリスクはほとんどありません。
+- EEPROM の書き込みサイクルは、約100000(10万)です。ファームウェアを繰り返し継続的に書き換えるべきではありません。それは最終的に EEPROM を焼き焦がします。
+
+## NKRO が動作しません
+最初に、**Makefile** 内でビルドオプション `NKRO_ENABLE` を使ってファームウェアをコンパイルする必要があります。
+
+**NKRO** がまだ動作しない場合は、`Magic` **N** コマンド(デフォルトでは `LShift+RShift+N`)を試してみてください。**NKRO** モードと **6KRO** モード間を一時的に切り替えるためにこのコマンドを使うことができます。**NKRO** が機能しない状況、特に BIOS の場合は **6KRO** モードに切り替える必要があります。
+
+ファームウェアを `BOOTMAGIC_ENABLE` でビルドした場合、`ブートマジック` **N** コマンドで切り替える必要があります(デフォルトでは `Space+N`)。この設定は EEPROM に格納され、電源を入れ直しても保持されます。
+
+https://github.com/tmk/tmk_keyboard#boot-magic-configuration---virtual-dip-switch
+
+
+## トラックポイントははリセット回路が必要です (PS/2 マウスサポート)
+リセット回路が無いとハードウェアの不適切な初期化のために一貫性の無い結果になります。TPM754 の回路図を見てください:
+
+- https://geekhack.org/index.php?topic=50176.msg1127447#msg1127447
+- https://www.mikrocontroller.net/attachment/52583/tpm754.pdf
+
+
+## 16 を超えるマトリックの列を読み込めない
+列が 16 を超える場合、[matrix.h] の `read_cols()` 内の `1<<16` の代わりに `1UL<<16` を使ってください。
+
+C では、AVR の場合 `1` は [16 bit] である [int] 型の1を意味し、15を超えて左にシフトすることはできません。従って、`1<<16` を計算すると予期せずゼロになります。これを回避するには `1UL` として [unsigned long] 型を使う必要があります。
+
+https://deskthority.net/workshop-f7/rebuilding-and-redesigning-a-classic-thinkpad-keyboard-t6181-60.html#p146279
+
+## 特別なエクストラキーが動作しない(システム、オーディオコントロールキー)
+QMK でそれらを使うには、`rules.mk` 内で `EXTRAKEY_ENABLE` を定義する必要があります。
+
+```
+EXTRAKEY_ENABLE = yes          # オーディオ制御とシステム制御
+```
+
+## スリープから復帰しない
+
+**デバイスマネージャ**の**電源の管理**タブ内の `このデバイスで、コンピュータのスタンバイ状態を解除できるようにする` 設定を調べてください。また BIOS 設定も調べてください。スリープ中に任意のキーを押すとホストが起動するはずです。
+
+## Arduino を使っていますか？
+
+**Arduino のピンの命名は実際のチップと異なることに注意してください。** 例えば、Arduino のピン `D0` は `PD0` ではありません。回路図を自身で確認してください。
+
+- https://arduino.cc/en/uploads/Main/arduino-leonardo-schematic_3b.pdf
+- https://arduino.cc/en/uploads/Main/arduino-micro-schematic.pdf
+
+Arduino の Leonardo と micro には **ATMega32U4** が載っていて、TMK 用に使うことができますが、Arduino のブートローダが問題になることがあります。
+
+## JTAG を有効にする
+
+デフォルトでは、キーボードが起動するとすぐに JTAG デバッグインタフェースが無効になります。JTAG 対応 MCU は `JTAGEN` ヒューズが設定された状態で出荷されており、キーボードがスイッチマトリックス、LED などに使用している可能性のある MCU の特定のピンを乗っ取ります。
+
+JTAG を有効にしたままにしたい場合は、単に以下のものを `config.h` に追加します:
+
+```c
+#define NO_JTAG_DISABLE
+```
+
+## USB 3 の互換性
+一部の問題は、USB 3.x ポートから USB 2.0 ポートに切り替えることで修正できます。
+
+
+## Mac の互換性
+### OS X 10.11 と Hub
+こちらを見てください: https://geekhack.org/index.php?topic=14290.msg1884034#msg1884034
+
+
+## BIOS (UEFI) 設定/リジューム (スリープとウェークアップ)/電源サイクルの問題
+一部の人がキーボードが BIOS で動作しなくなった、またはリジューム(電源サイクル)の後で動作しなくなったと報告しました。
+
+今のところ、この問題の根本は明確ではないですが、幾つかのビルドオプションが関係しているようです。Makefile で、`CONSOLE_ENABLE`、`NKRO_ENABLE`、`SLEEP_LED_ENABLE` あるいは他のオプションを無効にしてみてください。
+
+より詳しい情報:
+- https://github.com/tmk/tmk_keyboard/issues/266
+- https://geekhack.org/index.php?topic=41989.msg1967778#msg1967778

docs/ja/feature_advanced_keycodes.md

@@ -1,27 +1,30 @@
 # 修飾キー :id=modifier-keys
 
 <!---
-  original document: 0.9.0:docs/feature_advanced_keycodes.md
-  git diff 0.9.0 HEAD -- docs/feature_advanced_keycodes.md | cat
+  original document: 0.10.36:docs/feature_advanced_keycodes.md
+  git diff 0.10.36 HEAD -- docs/feature_advanced_keycodes.md | cat
 -->
 
 以下のようにキーコードとモディファイアを組み合わせることができます。押すと、モディファイアのキーダウンイベントが送信され、次に `kc` のキーダウンイベントが送信されます。放すと、`kc` のキーアップイベントが送信され、次にモディファイアのキーアップイベントが送信されます。
 
-| キー | エイリアス | 説明 |
-|----------|-------------------------------|----------------------------------------------------|
-| `LCTL(kc)` | `C(kc)` | 左 Control を押しながら `kc` を押します。 |
-| `LSFT(kc)` | `S(kc)` | 左 Shift を押しながら `kc` を押します。 |
-| `LALT(kc)` | `A(kc)`, `LOPT(kc)` | 左 Alt を押しながら `kc`を押します。 |
-| `LGUI(kc)` | `G(kc)`, `LCMD(kc)`, `LWIN(kc)` | 左 GUI を押しながら `kc` を押します。 |
-| `RCTL(kc)` |  | 右 Control を押しながら `kc` を押します。 |
-| `RSFT(kc)` |  | 右 Shift を押しながら `kc` を押します。 |
-| `RALT(kc)` | `ROPT(kc)`, `ALGR(kc)` | 右 Alt を押しながら `kc` を押します。 |
-| `RGUI(kc)` | `RCMD(kc)`, `LWIN(kc)` | 右 GUI を押しながら `kc` を押します。 |
-| `SGUI(kc)` | `SCMD(kc)`, `SWIN(kc)` | 左 Shift と左 GUI を押しながら `kc` を押します。 |
-| `LCA(kc)` |  | 左 Control と左 Alt を押しながら `kc` を押します。 |
-| `LCAG(kc)` |  | 左 Control、左 Alt、左 GUI を押しながら `kc` を押します。 |
-| `MEH(kc)` |  | 左 Control、左 Shift、左 Alt を押しながら `kc` を押します。 |
-| `HYPR(kc)` |  | 左 Control、左 Shift、左 Alt、左 GUI を押しながら `kc` を押します。 |
+| キー       | エイリアス                      | 説明                                                                |
+| ---------- | ------------------------------- | ------------------------------------------------------------------- |
+| `LCTL(kc)` | `C(kc)`                         | 左 Control を押しながら `kc` を押します。                           |
+| `LSFT(kc)` | `S(kc)`                         | 左 Shift を押しながら `kc` を押します。                             |
+| `LALT(kc)` | `A(kc)`, `LOPT(kc)`             | 左 Alt を押しながら `kc`を押します。                                |
+| `LGUI(kc)` | `G(kc)`, `LCMD(kc)`, `LWIN(kc)` | 左 GUI を押しながら `kc` を押します。                               |
+| `RCTL(kc)` |                                 | 右 Control を押しながら `kc` を押します。                           |
+| `RSFT(kc)` |                                 | 右 Shift を押しながら `kc` を押します。                             |
+| `RALT(kc)` | `ROPT(kc)`, `ALGR(kc)`          | 右 Alt を押しながら `kc` を押します。                               |
+| `RGUI(kc)` | `RCMD(kc)`, `LWIN(kc)`          | 右 GUI を押しながら `kc` を押します。                               |
+| `SGUI(kc)` | `SCMD(kc)`, `SWIN(kc)`          | 左 Shift と左 GUI を押しながら `kc` を押します。                    |
+| `LCA(kc)`  |                                 | 左 Control と左 Alt を押しながら `kc` を押します。                  |
+| `LSA(kc)`  |                                 | 左 Shift と左 Alt を押しながら `kc` を押します。                    |
+| `RSA(kc)`  | `SAGR(kc)`                      | 右 Shift と右 Alt (AltGr) を押しながら `kc` を押します。            |
+| `RCS(kc)`  |                                 | 右 Control と右 Shift を押しながら `kc` を押します。                |
+| `LCAG(kc)` |                                 | 左 Control、左 Alt、左 GUI を押しながら `kc` を押します。           |
+| `MEH(kc)`  |                                 | 左 Control、左 Shift、左 Alt を押しながら `kc` を押します。         |
+| `HYPR(kc)` |                                 | 左 Control、左 Shift、左 Alt、左 GUI を押しながら `kc` を押します。 |
 
 また、それらを繋げることができます。例えば、`LCTL(LALT(KC_DEL))` または  `C(A(KC_DEL))` は1回のキー押下で Control+Alt+Delete を送信するキーを作成します。
 

docs/ja/feature_macros.md

@@ -210,7 +210,7 @@ SEND_STRING(".."SS_TAP(X_END));
 ```
 
 
-## 高度なマクロ関数
+## 高度なマクロ関数 :id=advanced-macro-functions
 
 マクロの生成に役立つ関数が幾つかあります。マクロの中にかなり高度なコードを書くことができますが、機能が複雑になりすぎる場合は、代わりにカスタムキーコードを定義することをお勧めします。マクロはシンプルにしなければなりません。
 

docs/ja/newbs_getting_started.md

@@ -2,125 +2,182 @@
 
 <!---
   grep --no-filename "^[ ]*git diff" docs/ja/*.md | sh
-  original document: 0.9.44:docs/newbs_getting_started.md
-  git diff 0.9.44 HEAD -- docs/newbs_getting_started.md | cat
+  original document: 0.12.45:docs/newbs_getting_started.md
+  git diff 0.12.45 HEAD -- docs/newbs_getting_started.md | cat
 -->
 
 キーマップをビルドする前に、いくつかのソフトウェアをインストールしてビルド環境を構築する必要があります。
 ファームウェアをコンパイルするキーボードの数に関わらず、この作業を一度だけ実行する必要があります。
 
-## 1. ソフトウェアのダウンロード
+## 1. 前提条件
 
 始めるために必要なソフトウェアがいくつかあります。
 
-### テキストエディタ
+* [テキストエディタ](ja/newbs_learn_more_resources.md#text-editor-resources)
+  * プレーンテキストファイルを編集して保存できるプログラムが必要です。多くの OS に付属するデフォルトのエディタはプレーンテキストファイルを保存しないため、選択したエディタがプレーンテキストファイルを保存することを確認する必要があります。
+* [Toolbox (オプション)](https://github.com/qmk/qmk_toolbox)
+  * Windows と macOS で使える GUI を備えたプログラムで、カスタムキーボードのプログラミングとデバッグの両方ができます。
 
-**プレーンテキスト** ファイルを編集して保存できるプログラムが必要です。
-Windows の場合、メモ帳が使えます。Linux の場合、gedit が使えます。どちらもシンプルですが機能的なテキストエディタです。
-macOS では、デフォルトのテキストエディットアプリに注意してください。_フォーマット_ メニューから _標準テキストにする_ を選択しない限り、プレーンテキストとして保存されません。
-
-[Sublime Text](https://www.sublimetext.com/) や [VS Code](https://code.visualstudio.com/) のような専用のテキストエディタをダウンロードしてインストールすることもできます。これらのプログラムはコードを編集するために特別に作成されているため、これはプラットフォームに関係なくベストな方法です。
-
-?> どのエディタを使えば良いか分からない場合、Laurence Bradford が書いたこの記事 [a great introduction](https://learntocodewith.me/programming/basics/text-editors/) を読んでください。
-
-### QMK Toolbox
-
-QMK Toolbox は、Windows と macOS で使える GUI を備えたプログラムで、カスタムキーボードのプログラミングとデバッグの両方ができます。
-このプログラムは、キーボードに簡単にファームウェアを書き込んだり、出力されるデバッグメッセージを確認する際に、かけがえのないものであることがわかるでしょう。
-
-[QMK Toolbox の最新版](https://github.com/qmk/qmk_toolbox/releases/latest)
-
-* Windows 版: `qmk_toolbox.exe` (portable) または `qmk_toolbox_install.exe` (installer)
-* macOS 版: `QMK.Toolbox.app.zip` (portable) または `QMK.Toolbox.pkg` (installer)
-
-### Unix ライクな環境
-
-Linux や macOS には既に実行可能な unix シェルが付属しています。ビルド環境を構築するだけで済みます。
-
-Windows では、MSYS2 や WSL をインストールして、これらの環境を使う必要があります。MSYS2 の構築手順を以下に示します。
+?> もし、Linux か Unix のコマンドを使ったことがない場合、こちらで基本的な概念や各種コマンドを学んでください。[これらの教材](ja/newbs_learn_more_resources.md#command-line-resources)で QMK を使うのに必要なことを学ぶことができます。
 
 ## 2. ビルド環境を準備する :id=set-up-your-environment
 
-私たちは、QMK を可能な限り簡単に構築できるように努力しています。
-Linux か Unix 環境を用意するだけで、QMK に残りをインストールさせることができます。
+私たちは、QMK を可能な限り簡単に構築できるように努力しています。Linux か Unix 環境を用意するだけで、QMK に残りをインストールさせることができます。
 
-?> もし、Linux か Unix のコマンドを使ったことがない場合、こちらで基本的な概念や各種コマンドを学んでください。これらの教材で QMK を使うのに必要なことを学ぶことができます:<br>
-[Must Know Linux Commands](https://www.guru99.com/must-know-linux-commands.html)<br>
-[Some Basic Unix Commands](https://www.tjhsst.edu/~dhyatt/superap/unixcmd.html)
+<!-- tabs:start -->
 
-### Windows
+### ** Windows **
 
-MSYS2 と Git と QMK CLI のインストールが必要です。
+QMK は、MSYS2、CLI、および必要な全ての依存関係のバンドルを保守しています。また、正しい環境で直接起動するための便利な `QMK MSYS` ターミナルショートカットも提供しています。
 
-[MSYS2 homepage](https://www.msys2.org) のインストール手順に従ってください。開いている MSYS2 の全ターミナル画面を閉じて、新しい MinGW 64-bit ターミナル画面を開きます。**注意: これはインストールが完了した時に開く MSYS ターミナルと同じ *ではありません*。**
+#### 前提条件
+
+[QMK MSYS](https://msys.qmk.fm/) をインストールする必要があります。最新リリースは[ここ](https://github.com/qmk/qmk_distro_msys/releases/latest)から入手できます。
+
+または、MSYS2 を手動でインストールしたい場合、次のセクションでプロセスを説明します。
+
+<details>
+  <summary>手動インストール</summary>
+
+?> `QMK MSYS` を使う場合、次のステップは無視してください。
+
+#### 前提条件
+
+MSYS2 と Git と Python をインストールする必要があります。https://www.msys2.org のインストール手順に従ってください。
+
+MSYS2 をインストールしたら、開いている MSYS の全ターミナル画面を閉じて、新しい MinGW 64-bit ターミナル画面を開きます。
+
+!> **注意:** MinGW 64-bit ターミナルは、インストールが完了した時に開く MSYS ターミナルと*同じではありません*。プロンプトには、「MSYS」ではなく、紫色のテキストで「MINGW64」と表示されます。違いについての詳細は[このページ](https://www.msys2.org/wiki/MSYS2-introduction/#subsystems)を参照してください。
 
 それから、次のように実行します:
 
     pacman --needed --noconfirm --disable-download-timeout -S git mingw-w64-x86_64-toolchain mingw-w64-x86_64-python3-pip
-    python3 -m pip install qmk
 
-### macOS
+#### インストール
 
-Homebrew のインストールが必要です。[Homebrew homepage](https://brew.sh) の手順に従ってください。
+次のコマンドを実行して、QMK CLI をインストールします:
 
-Homebrew をインストールした後で、以下のコマンドを実行します:
+    PYTHONUTF8=1 python3 -m pip install qmk
+
+!> **訳注:** 現在、日本語版 Windows 環境では、環境変数として `PYTHONUTF8=1` を指定してインストールする必要があります。この環境変数を指定しない場合、システムのロケール設定が原因で一部の Python モジュールのインストールでエラーが発生します。この問題は該当モジュールのソースコードでは修正済みですが、配布モジュールはまだ修正されていません。
+
+</details>
+
+### ** macOS **
+
+QMK は CLI と全ての必要な依存関係を自動的にインストールする Homebrew tap と formula を保守しています。
+
+#### 前提条件
+
+Homebrew のインストールが必要です。https://brew.sh の手順に従ってください。
+
+#### インストール
+
+次のコマンドを実行して、QMK CLI をインストールします:
 
     brew install qmk/qmk/qmk
 
-### Linux
+### ** Linux/WSL **
+
+?> **WSL ユーザーへの注意**: デフォルトでは、インストールプロセスは QMK リポジトリを WSL ホームディレクトリに clone しますが、手動で clone した場合、Windows ファイルシステムではなく、WSL インスタンス内にある(つまり `/mnt` 内にない)ことを確認してください。これは、現在アクセスが[非常に遅い](https://github.com/microsoft/WSL/issues/4197)ためです。
+
+#### 前提条件
 
 Git と Python をインストールする必要があります。両方とも既にインストールされている可能性は高いですが、そうでない場合、次のコマンドのいずれかでそれらをインストールできます:
 
-* Debian / Ubuntu / Devuan: `sudo apt install git python3 python3-pip`
-* Fedora / Red Hat / CentOS: `sudo yum install git python3 python3-pip`
-* Arch / Manjaro: `sudo pacman -S git python python-pip python-setuptools libffi`
+* Debian / Ubuntu / Devuan: `sudo apt install -y git python3-pip`
+* Fedora / Red Hat / CentOS: `sudo yum -y install git python3-pip`
+* Arch / Manjaro: `sudo pacman --needed --noconfirm -S git python-pip libffi`
+* Void: `sudo xbps-install -y git python3-pip`
+* Solus: `sudo eopkg -y install git python3`
+* Sabayon: `sudo equo install dev-vcs/git dev-python/pip`
+* Gentoo: `sudo emerge dev-vcs/git dev-python/pip`
 
-グローバル CLI をインストールして、システムをブートストラップします:
+#### インストール
 
-`python3 -m pip install --user qmk` (Arch ベースのディストリビューションでは AUR から `qmk` パッケージを試すこともできます(**メモ**: コミュニティメンバーによって保守されています): `yay -S qmk`)
-
-### FreeBSD
-
-Git と Python をインストールする必要があります。両方とも既にインストールされている可能性は高いですが、そうでない場合、次のコマンドを実行してそれらをインストールします:
-
-    pkg install git python3
-
-ローカルにインストールした Python パッケージが利用できるように、`$HOME/.local/bin` が `$PATH` に追加されていることを確認してください。
-
-インストール完了後、QMK CLI をインストールできます:
+次のコマンドを実行して、QMK CLI をインストールします:
 
     python3 -m pip install --user qmk
 
+#### コミュニティパッケージ
+
+これらのパッケージはコミュニティメンバーによって保守されているため、最新ではないか、完全には機能しない可能性があります。問題が発生した場合は、それぞれのメンテナに報告してください。
+
+Arch ベースのディストリビューションでは、公式リポジトリから CLI をインストールできます(注意: 執筆時点では、このパッケージは一部の依存関係をオプションとしてマークしていますが、そうではありません):
+
+    sudo pacman -S qmk
+
+AUR から `qmk-git` パッケージを試すこともできます:
+
+    yay -S qmk-git
+
+###  ** FreeBSD **
+
+#### インストール
+
+次のコマンドを実行して、QMK CLI の FreeBSD パッケージをインストールします:
+
+    pkg install -g "py*-qmk"
+
+注意: インストールの最後に表示された指示に従うことを忘れないでください(再度表示するには、`pkg info -Dg "py*-qmk"` を使ってください)。
+
+<!-- tabs:end -->
+
 ## 3. QMK の設定を行う :id=set-up-qmk
 
+<!-- tabs:start -->
+
+### ** Windows **
+
 QMK のインストール後に、このコマンドで設定できます:
 
     qmk setup
 
-ほとんどの場合、全てのプロンプトに Yes と答えます。
+ほとんどの場合、全てのプロンプトに `y` と答えます。
+
+### ** macOS **
+
+QMK のインストール後に、このコマンドで設定できます:
+
+    qmk setup
+
+ほとんどの場合、全てのプロンプトに `y` と答えます。
+
+### ** Linux/WSL **
+
+QMK のインストール後に、このコマンドで設定できます:
+
+    qmk setup
+
+ほとんどの場合、全てのプロンプトに `y` と答えます。
 
 ?>**Debian、Ubuntu、それらの派生に関する注意**:
 次のようなエラーが表示される可能性があります: `bash: qmk: command not found`.
-これは Debian の Bash 4.4 リリースで導入された [バグ](https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=839155) で、`$HOME/.local/bin` が PATH から削除されました。このバグは後に Debian や Ubuntu で修正されました。
+これは Debian の Bash 4.4 リリースで導入された[バグ](https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=839155)で、`$HOME/.local/bin` が PATH から削除されました。このバグは後に Debian や Ubuntu で修正されました。
 残念なことに、Ubuntu はこのバグを再導入し、[まだ修正していません](https://bugs.launchpad.net/ubuntu/+source/bash/+bug/1588562)。
 幸い、修正は簡単です。これをあなたのユーザで実行します: `echo 'PATH="$HOME/.local/bin:$PATH"' >> $HOME/.bashrc && source $HOME/.bashrc`
 
-?>**FreeBSD に関する注意**:
-まず、`root` 以外のユーザで `qmk setup` を実行することをお勧めしますが、これはおそらく `pkg` を使って基本システムにインストールする必要があるパッケージを識別します。
-しかし、特権のないユーザで実行すると、インストールはおそらく失敗します。
-基本的な依存関係を手動でインストールするには、`./util/qmk_install.sh` を `root` として実行するか、`sudo` をつけて実行します。
-それが完了したら、`qmk setup` を再実行して設定と確認を完了させます。
+###  ** FreeBSD **
 
-?> 既に [GitHub の使いかた](ja/getting_started_github.md)を知っているなら、fork を作成し、`qmk setup <github_username>/qmk_firmware` を使って個人用の fork から clone することをお勧めします。この一文の意味が分からない場合、このメッセージは無視してかまいません。
+QMK のインストール後に、このコマンドで設定できます:
+
+    qmk setup
+
+ほとんどの場合、全てのプロンプトに `y` と答えます。
+
+<!-- tabs:end -->
+
+?> qmk ホームフォルダは、セットアップ時に `qmk setup -H <path>` を使って指定し、[cli 構成](ja/cli_configuration.md?id=single-key-example)と変数 `user.qmk_home` を使って変更できます。利用可能な全てのオプションについては、`qmk setup --help` を実行します。
+
+?> 既に GitHub の使い方を知っている場合、[これらの手順に従うことをお勧めします](ja/getting_started_github.md)。そして `qmk setup <github_username>/qmk_firmware` を使って個人用の fork から clone します。この一文の意味が分からない場合、このメッセージは無視してかまいません。
 
 ## 4. ビルド環境の確認
 
-これで QMK のビルド環境が用意できたので、キーボードのファームウェアをビルドできます。
-キーボードのデフォルトキーマップをビルドすることから始めます。次の形式のコマンドでビルドできるはずです。
+これで QMK のビルド環境が用意できたので、キーボードのファームウェアをビルドできます。キーボードのデフォルトキーマップをビルドすることから始めます。次の形式のコマンドでビルドできるはずです:
 
     qmk compile -kb <keyboard> -km default
 
-例えば、Clueboard 66% のファームウェアをビルドする場合:
+例えば、Clueboard 66% のファームウェアをビルドする場合、次のようにします:
 
     qmk compile -kb clueboard/66/rev3 -km default
 
@@ -152,5 +209,4 @@ QMK を初めて使うほとんどの人は、キーボードを1つしか持っ
 
 # キーマップの作成
 
-これであなた専用のキーマップを作成する準備ができました！
-次は [初めてのファームウェアの構築](ja/newbs_building_firmware.md) で専用のキーマップを作成します。
+これであなた専用のキーマップを作成する準備ができました！次は[初めてのファームウェアの構築](ja/newbs_building_firmware.md)で専用のキーマップを作成します。

docs/ja/newbs_testing_debugging.md

@@ -2,105 +2,14 @@
 
 <!---
   grep --no-filename "^[ ]*git diff" docs/ja/*.md | sh
-  original document: 0.9.0:docs/newbs_testing_debugging.md
-  git diff 0.9.0 HEAD -- docs/newbs_testing_debugging.md | cat
+  original document: 0.12.45:docs/newbs_testing_debugging.md
+  git diff 0.12.45 HEAD -- docs/newbs_testing_debugging.md | cat
 -->
 
-カスタムファームウェアをキーボードへ書き込んだら、テストする準備が整います。運が良ければ全て問題なく動作しているはずですが、もしそうでなければこのドキュメントがどこが悪いのか調べるのに役立ちます。
-
 ## テスト
 
-通常、キーボードをテストするのは非常に簡単です。
-全てのキーをひとつずつ押して、期待されるキーが送信されていることを確認します。
-QMK を実行していなくても、[QMK Configurator](https://config.qmk.fm/#/test/) のテストモードを使ってキーボードを確認することができます。
+[ここに移動しました](ja/faq_misc.md#testing)
 
 ## デバッグ :id=debugging
 
-`rules.mk`へ`CONSOLE_ENABLE = yes`の設定をするとキーボードはデバッグ情報を出力します。デフォルトの出力は非常に限られたものですが、デバッグモードをオンにすることでデバッグ情報の量を増やすことが出来ます。キーマップの`DEBUG`キーコードを使用するか、デバッグモードを有効にする [コマンド](ja/feature_command.md) 機能を使用するか、以下のコードをキーマップに追加します。
-
-```c
-void keyboard_post_init_user(void) {
-  // Customise these values to desired behaviour
-  debug_enable=true;
-  debug_matrix=true;
-  //debug_keyboard=true;
-  //debug_mouse=true;
-}
-```
-
-## デバッグツール :id=debugging-tools
-
-キーボードのデバッグに使えるツールは2つあります。
-
-### QMK Toolboxを使ったデバッグ
-
-互換性のある環境では、[QMK Toolbox](https://github.com/qmk/qmk_toolbox)を使うことでキーボードからのデバッグメッセージを表示できます。
-
-### hid_listenを使ったデバッグ
-
-ターミナルベースの方法がお好みですか？PJRC が提供する[hid_listen](https://www.pjrc.com/teensy/hid_listen.html)もデバッグメッセージの表示に使用できます。ビルド済みの実行ファイルは Windows, Linux, MacOS 用が用意されています。
-
-
-## 独自のデバッグメッセージを送信する
-
-[custom code](ja/custom_quantum_functions.md)内からデバッグメッセージを出力すると便利な場合があります。それはとても簡単です。ファイルの先頭に`print.h`のインクルードを追加します:
-
-```c
-#include "print.h"
-```
-
-そのあとは、いくつかの異なった print 関数を使用することが出来ます。
-
-* `print("string")`: シンプルな文字列を出力します
-* `uprintf("%s string", var)`: フォーマットされた文字列を出力します
-* `dprint("string")` デバッグモードが有効な場合のみ、シンプルな文字列を出力します
-* `dprintf("%s string", var)`: デバッグモードが有効な場合のみ、フォーマットされた文字列を出力します
-
-## デバッグの例
-
-以下は現実世界での実際のデバッグ手法の例を集めたものです。追加情報は[Debugging/Troubleshooting QMK](ja/faq_debug.md)を参照してください。
-
-### マトリックス上のどの場所でキー押下が起こったか？
-
-移植する、PCBの問題を診断する場合、キー入力が正しくスキャンされているかどうかを確認することが役立つ場合があります。この手法でのロギングを有効化するには、`keymap.c`へ以下のコードを追加します。
-
-```c
-bool process_record_user(uint16_t keycode, keyrecord_t *record) {
-  // コンソールが有効化されている場合、マトリックス上の位置とキー押下状態を出力します
-#ifdef CONSOLE_ENABLE
-    uprintf("KL: kc: %u, col: %u, row: %u, pressed: %u\n", keycode, record->event.key.col, record->event.key.row, record->event.pressed);
-#endif 
-  return true;
-}
-```
-
-出力の例
-```text
-Waiting for device:.......
-Listening:
-KL: kc: 169, col: 0, row: 0, pressed: 1
-KL: kc: 169, col: 0, row: 0, pressed: 0
-KL: kc: 174, col: 1, row: 0, pressed: 1
-KL: kc: 174, col: 1, row: 0, pressed: 0
-KL: kc: 172, col: 2, row: 0, pressed: 1
-KL: kc: 172, col: 2, row: 0, pressed: 0
-```
-
-### キースキャンにかかる時間の測定
-
-パフォーマンスの問題をテストする場合、スイッチマトリックスをスキャンする頻度を知ることが役立ちます。この手法でのロギングを有効化するには`config.h`へ以下のコードを追加します。
-
-
-```c
-#define DEBUG_MATRIX_SCAN_RATE
-```
-
-出力例
-```text
-  > matrix scan frequency: 315
-  > matrix scan frequency: 313
-  > matrix scan frequency: 316
-  > matrix scan frequency: 316
-  > matrix scan frequency: 316
-  > matrix scan frequency: 316
-```
+[ここに移動しました](ja/faq_debug.md#debugging)

docs/pr_checklist.md

@@ -68,7 +68,7 @@ https://github.com/qmk/qmk_firmware/pulls?q=is%3Apr+is%3Aclosed+label%3Akeyboard
     - bare minimum required code for a board to boot into QMK should be present
         - initialisation code for the matrix and critical devices
         - mirroring existing functionality of a commercial board (like custom keycodes and special animations etc.) should be handled through non-`default` keymaps
-    - VIAL-related files or changes will not be accepted, as they are not used by QMK firmware (no VIAL-specific core code has been submitted or merged)
+    - Vial-related files or changes will not be accepted, as they are not used by QMK firmware (no Vial-specific core code has been submitted or merged)
 - `keyboard.c`
     - empty `xxxx_xxxx_kb()` or other weak-defined default implemented functions removed
     - commented-out functions removed too

drivers/avr/i2c_master.c

@@ -28,14 +28,8 @@
 #    define F_SCL 400000UL  // SCL frequency
 #endif
 
-#ifndef I2C_START_RETRY_COUNT
-#    define I2C_START_RETRY_COUNT 20
-#endif  // I2C_START_RETRY_COUNT
-
 #define TWBR_val (((F_CPU / F_SCL) - 16) / 2)
 
-#define MAX(X, Y) ((X) > (Y) ? (X) : (Y))
-
 void i2c_init(void) {
     TWSR = 0; /* no prescaler */
     TWBR = (uint8_t)TWBR_val;
@@ -53,7 +47,7 @@ void i2c_init(void) {
 #endif
 }
 
-static i2c_status_t i2c_start_impl(uint8_t address, uint16_t timeout) {
+i2c_status_t i2c_start(uint8_t address, uint16_t timeout) {
     // reset TWI control register
     TWCR = 0;
     // transmit START condition
@@ -92,17 +86,6 @@ static i2c_status_t i2c_start_impl(uint8_t address, uint16_t timeout) {
     return I2C_STATUS_SUCCESS;
 }
 
-i2c_status_t i2c_start(uint8_t address, uint16_t timeout) {
-    // Retry i2c_start_impl a bunch times in case the remote side has interrupts disabled.
-    uint16_t     timeout_timer = timer_read();
-    uint16_t     time_slice    = MAX(1, (timeout == (I2C_TIMEOUT_INFINITE)) ? 5 : (timeout / (I2C_START_RETRY_COUNT)));  // if it's infinite, wait 1ms between attempts, otherwise split up the entire timeout into the number of retries
-    i2c_status_t status;
-    do {
-        status = i2c_start_impl(address, time_slice);
-    } while ((status < 0) && ((timeout == I2C_TIMEOUT_INFINITE) || (timer_elapsed(timeout_timer) < timeout)));
-    return status;
-}
-
 i2c_status_t i2c_write(uint8_t data, uint16_t timeout) {
     // load data into data register
     TWDR = data;

drivers/avr/i2c_slave.c

@@ -17,7 +17,6 @@
  * GitHub repository: https://github.com/g4lvanix/I2C-slave-lib
  */
 
-#include <stddef.h>
 #include <avr/io.h>
 #include <util/twi.h>
 #include <avr/interrupt.h>
@@ -25,12 +24,6 @@
 
 #include "i2c_slave.h"
 
-#if defined(USE_I2C) && defined(SPLIT_COMMON_TRANSACTIONS)
-#    include "transactions.h"
-
-static volatile bool is_callback_executor = false;
-#endif  // defined(USE_I2C) && defined(SPLIT_COMMON_TRANSACTIONS)
-
 volatile uint8_t i2c_slave_reg[I2C_SLAVE_REG_COUNT];
 
 static volatile uint8_t buffer_address;
@@ -55,14 +48,11 @@ ISR(TWI_vect) {
         case TW_SR_SLA_ACK:
             // The device is now a slave receiver
             slave_has_register_set = false;
-#if defined(USE_I2C) && defined(SPLIT_COMMON_TRANSACTIONS)
-            is_callback_executor = false;
-#endif  // defined(USE_I2C) && defined(SPLIT_COMMON_TRANSACTIONS)
             break;
 
         case TW_SR_DATA_ACK:
             // This device is a slave receiver and has received data
-            // First byte is the location then the bytes will be writen in buffer with auto-increment
+            // First byte is the location then the bytes will be writen in buffer with auto-incriment
             if (!slave_has_register_set) {
                 buffer_address = TWDR;
 
@@ -70,25 +60,10 @@ ISR(TWI_vect) {
                     ack            = 0;
                     buffer_address = 0;
                 }
-                slave_has_register_set = true;  // address has been received now fill in buffer
-
-#if defined(USE_I2C) && defined(SPLIT_COMMON_TRANSACTIONS)
-                // Work out if we're attempting to execute a callback
-                is_callback_executor = buffer_address == split_transaction_table[I2C_EXECUTE_CALLBACK].initiator2target_offset;
-#endif  // defined(USE_I2C) && defined(SPLIT_COMMON_TRANSACTIONS)
+                slave_has_register_set = true;  // address has been receaved now fill in buffer
             } else {
                 i2c_slave_reg[buffer_address] = TWDR;
                 buffer_address++;
-
-#if defined(USE_I2C) && defined(SPLIT_COMMON_TRANSACTIONS)
-                // If we're intending to execute a transaction callback, do so, as we've just received the transaction ID
-                if (is_callback_executor) {
-                    split_transaction_desc_t *trans = &split_transaction_table[split_shmem->transaction_id];
-                    if (trans->slave_callback) {
-                        trans->slave_callback(trans->initiator2target_buffer_size, split_trans_initiator2target_buffer(trans), trans->target2initiator_buffer_size, split_trans_target2initiator_buffer(trans));
-                    }
-                }
-#endif  // defined(USE_I2C) && defined(SPLIT_COMMON_TRANSACTIONS)
             }
             break;
 

drivers/avr/i2c_slave.h

@@ -22,18 +22,7 @@
 
 #pragma once
 
-#ifndef I2C_SLAVE_REG_COUNT
-
-#    if defined(USE_I2C) && defined(SPLIT_COMMON_TRANSACTIONS)
-#        include "transport.h"
-#        define I2C_SLAVE_REG_COUNT sizeof(split_shared_memory_t)
-#    else  // defined(USE_I2C) && defined(SPLIT_COMMON_TRANSACTIONS)
-#        define I2C_SLAVE_REG_COUNT 30
-#    endif  // defined(USE_I2C) && defined(SPLIT_COMMON_TRANSACTIONS)
-
-#endif  // I2C_SLAVE_REG_COUNT
-
-_Static_assert(I2C_SLAVE_REG_COUNT < 256, "I2C target registers must be single byte");
+#define I2C_SLAVE_REG_COUNT 30
 
 extern volatile uint8_t i2c_slave_reg[I2C_SLAVE_REG_COUNT];
 

drivers/avr/serial.c

@@ -224,8 +224,15 @@
 #    define SERIAL_DELAY_HALF2 (SERIAL_DELAY - SERIAL_DELAY / 2)
 
 #    define SLAVE_INT_WIDTH_US 1
-#    define SLAVE_INT_ACK_WIDTH_UNIT 2
-#    define SLAVE_INT_ACK_WIDTH 4
+#    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); }
@@ -252,12 +259,16 @@ inline static void serial_low(void) { writePinLow(SOFT_SERIAL_PIN); }
 inline static void serial_high(void) ALWAYS_INLINE;
 inline static void serial_high(void) { writePinHigh(SOFT_SERIAL_PIN); }
 
-void soft_serial_initiator_init(void) {
+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(void) {
+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-INT7
@@ -384,14 +395,19 @@ static inline uint8_t nibble_bits_count(uint8_t 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, 8);
+    bits = serial_read_chunk(&pecount, 7);
     tid  = bits >> 3;
-    bits = (bits & 7) != (nibble_bits_count(tid) & 7);
-    if (bits || pecount > 0 || tid > NUM_TOTAL_TRANSACTIONS) {
+    bits = (bits & 7) != nibble_bits_count(tid);
+    if (bits || pecount > 0 || tid > Transaction_table_size) {
         return;
     }
     serial_delay_half1();
@@ -399,22 +415,18 @@ ISR(SERIAL_PIN_INTERRUPT) {
     serial_high();  // response step1 low->high
     serial_output();
     _delay_sub_us(SLAVE_INT_ACK_WIDTH_UNIT * SLAVE_INT_ACK_WIDTH);
-    split_transaction_desc_t *trans = &split_transaction_table[tid];
+    SSTD_t *trans = &Transaction_table[tid];
     serial_low();  // response step2 ack high->low
-
-    // If the transaction has a callback, we can execute it now
-    if (trans->slave_callback) {
-        trans->slave_callback(trans->initiator2target_buffer_size, split_trans_initiator2target_buffer(trans), trans->target2initiator_buffer_size, split_trans_target2initiator_buffer(trans));
-    }
+#    endif
 
     // target send phase
-    if (trans->target2initiator_buffer_size > 0) serial_send_packet((uint8_t *)split_trans_target2initiator_buffer(trans), trans->target2initiator_buffer_size);
+    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 *)split_trans_initiator2target_buffer(trans), trans->initiator2target_buffer_size)) {
+        if (serial_recive_packet((uint8_t *)trans->initiator2target_buffer, trans->initiator2target_buffer_size)) {
             *trans->status = TRANSACTION_ACCEPTED;
         } else {
             *trans->status = TRANSACTION_DATA_ERROR;
@@ -436,12 +448,14 @@ ISR(SERIAL_PIN_INTERRUPT) {
 //    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 > NUM_TOTAL_TRANSACTIONS) return TRANSACTION_TYPE_ERROR;
-    split_transaction_desc_t *trans = &split_transaction_table[sstd_index];
-
-    if (!trans->status) return TRANSACTION_TYPE_ERROR;  // not registered
-
+    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
@@ -449,11 +463,27 @@ int soft_serial_transaction(int sstd_index) {
     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, 8);
+    serial_write_chunk(tid, 7);
     serial_delay_half1();
 
     // wait for the target response (step1 low->high)
@@ -474,11 +504,12 @@ int soft_serial_transaction(int sstd_index) {
         }
         _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 *)split_trans_target2initiator_buffer(trans), trans->target2initiator_buffer_size)) {
+        if (!serial_recive_packet((uint8_t *)trans->target2initiator_buffer, trans->target2initiator_buffer_size)) {
             serial_output();
             serial_high();
             *trans->status = TRANSACTION_DATA_ERROR;
@@ -492,7 +523,7 @@ int soft_serial_transaction(int sstd_index) {
 
     // initiator send phase
     if (trans->initiator2target_buffer_size > 0) {
-        serial_send_packet((uint8_t *)split_trans_initiator2target_buffer(trans), trans->initiator2target_buffer_size);
+        serial_send_packet((uint8_t *)trans->initiator2target_buffer, trans->initiator2target_buffer_size);
     }
 
     // always, release the line when not in use
@@ -503,8 +534,9 @@ int soft_serial_transaction(int sstd_index) {
     return TRANSACTION_END;
 }
 
+#    ifdef SERIAL_USE_MULTI_TRANSACTION
 int soft_serial_get_and_clean_status(int sstd_index) {
-    split_transaction_desc_t *trans = &split_transaction_table[sstd_index];
+    SSTD_t *trans = &Transaction_table[sstd_index];
     cli();
     int retval     = *trans->status;
     *trans->status = 0;
@@ -512,6 +544,8 @@ int soft_serial_get_and_clean_status(int sstd_index) {
     sei();
     return retval;
 }
+#    endif
+
 #endif
 
 // Helix serial.c history

drivers/avr/serial.h

@@ -0,0 +1,62 @@
+#pragma once
+
+#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 (using signle-type transaction function)
+//   /* nothing */
+// //// USE flexible API (using multi-type transaction function)
+//   #define SERIAL_USE_MULTI_TRANSACTION
+//
+// /////////////////////////////////////////////////////////////////
+
+// 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

drivers/awinic/aw20216.c

@@ -1,166 +0,0 @@
-/* Copyright 2021 Jasper Chan
- *
- * 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 "aw20216.h"
-#include "spi_master.h"
-
-/* The AW20216 appears to be somewhat similar to the IS31FL743, although quite
- * a few things are different, such as the command byte format and page ordering.
- * The LED addresses start from 0x00 instead of 0x01.
- */
-#define AWINIC_ID 0b1010 << 4
-
-#define AW_PAGE_FUNCTION 0x00 << 1    // PG0, Function registers
-#define AW_PAGE_PWM 0x01 << 1         // PG1, LED PWM control
-#define AW_PAGE_SCALING 0x02 << 1     // PG2, LED current scaling control
-#define AW_PAGE_PATCHOICE 0x03 << 1   // PG3, Pattern choice?
-#define AW_PAGE_PWMSCALING 0x04 << 1  // PG4, LED PWM + Scaling control?
-
-#define AW_WRITE 0
-#define AW_READ 1
-
-#define AW_REG_CONFIGURATION 0x00  // PG0
-#define AW_REG_GLOBALCURRENT 0x01  // PG0
-
-// Default value of AW_REG_CONFIGURATION
-// D7:D4 = 1011, SWSEL (SW1~SW12 active)
-// D3 = 0?, reserved (apparently this should be 1 but it doesn't seem to matter)
-// D2:D1 = 00, OSDE (open/short detection enable)
-// D0 = 0, CHIPEN (write 1 to enable LEDs when hardware enable pulled high)
-#define AW_CONFIG_DEFAULT 0b10110000
-#define AW_CHIPEN 1
-
-#ifndef AW_SCALING_MAX
-#    define AW_SCALING_MAX 150
-#endif
-
-#ifndef AW_GLOBAL_CURRENT_MAX
-#    define AW_GLOBAL_CURRENT_MAX 150
-#endif
-
-#ifndef DRIVER_1_CS
-#    define DRIVER_1_CS B13
-#endif
-
-#ifndef DRIVER_1_EN
-#    define DRIVER_1_EN C13
-#endif
-
-uint8_t g_spi_transfer_buffer[20] = {0};
-aw_led  g_pwm_buffer[DRIVER_LED_TOTAL];
-bool    g_pwm_buffer_update_required[DRIVER_LED_TOTAL];
-
-bool AW20216_write_register(pin_t slave_pin, uint8_t page, uint8_t reg, uint8_t data) {
-    // Do we need to call spi_stop() if this fails?
-    if (!spi_start(slave_pin, false, 0, 16)) {
-        return false;
-    }
-
-    g_spi_transfer_buffer[0] = (AWINIC_ID | page | AW_WRITE);
-    g_spi_transfer_buffer[1] = reg;
-    g_spi_transfer_buffer[2] = data;
-
-    if (spi_transmit(g_spi_transfer_buffer, 3) != SPI_STATUS_SUCCESS) {
-        spi_stop();
-        return false;
-    }
-    spi_stop();
-    return true;
-}
-
-bool AW20216_init_scaling(void) {
-    // Set constant current to the max, control brightness with PWM
-    aw_led led;
-    for (uint8_t i = 0; i < DRIVER_LED_TOTAL; i++) {
-        led = g_aw_leds[i];
-        if (led.driver == 0) {
-            AW20216_write_register(DRIVER_1_CS, AW_PAGE_SCALING, led.r, AW_SCALING_MAX);
-            AW20216_write_register(DRIVER_1_CS, AW_PAGE_SCALING, led.g, AW_SCALING_MAX);
-            AW20216_write_register(DRIVER_1_CS, AW_PAGE_SCALING, led.b, AW_SCALING_MAX);
-        }
-#ifdef DRIVER_2_CS
-        else if (led.driver == 1) {
-            AW20216_write_register(DRIVER_2_CS, AW_PAGE_SCALING, led.r, AW_SCALING_MAX);
-            AW20216_write_register(DRIVER_2_CS, AW_PAGE_SCALING, led.g, AW_SCALING_MAX);
-            AW20216_write_register(DRIVER_2_CS, AW_PAGE_SCALING, led.b, AW_SCALING_MAX);
-        }
-#endif
-    }
-    return true;
-}
-
-bool AW20216_soft_enable(void) {
-    AW20216_write_register(DRIVER_1_CS, AW_PAGE_FUNCTION, AW_REG_CONFIGURATION, AW_CONFIG_DEFAULT | AW_CHIPEN);
-#ifdef DRIVER_2_CS
-    AW20216_write_register(DRIVER_2_CS, AW_PAGE_FUNCTION, AW_REG_CONFIGURATION, AW_CONFIG_DEFAULT | AW_CHIPEN);
-#endif
-    return true;
-}
-
-void AW20216_update_pwm(int index, uint8_t red, uint8_t green, uint8_t blue) {
-    aw_led led = g_aw_leds[index];
-    if (led.driver == 0) {
-        AW20216_write_register(DRIVER_1_CS, AW_PAGE_PWM, led.r, red);
-        AW20216_write_register(DRIVER_1_CS, AW_PAGE_PWM, led.g, green);
-        AW20216_write_register(DRIVER_1_CS, AW_PAGE_PWM, led.b, blue);
-    }
-#ifdef DRIVER_2_CS
-    else if (led.driver == 1) {
-        AW20216_write_register(DRIVER_2_CS, AW_PAGE_PWM, led.r, red);
-        AW20216_write_register(DRIVER_2_CS, AW_PAGE_PWM, led.g, green);
-        AW20216_write_register(DRIVER_2_CS, AW_PAGE_PWM, led.b, blue);
-    }
-#endif
-    return;
-}
-
-void AW20216_init(void) {
-    // All LEDs should start with all scaling and PWM registers as off
-    setPinOutput(DRIVER_1_EN);
-    writePinHigh(DRIVER_1_EN);
-    AW20216_write_register(DRIVER_1_CS, AW_PAGE_FUNCTION, AW_REG_GLOBALCURRENT, AW_GLOBAL_CURRENT_MAX);
-#ifdef DRIVER_2_EN
-    setPinOutput(DRIVER_2_EN);
-    writePinHigh(DRIVER_2_EN);
-    AW20216_write_register(DRIVER_2_CS, AW_PAGE_FUNCTION, AW_REG_GLOBALCURRENT, AW_GLOBAL_CURRENT_MAX);
-#endif
-    AW20216_init_scaling();
-    AW20216_soft_enable();
-    return;
-}
-
-void AW20216_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) {
-    g_pwm_buffer[index].r               = red;
-    g_pwm_buffer[index].g               = green;
-    g_pwm_buffer[index].b               = blue;
-    g_pwm_buffer_update_required[index] = true;
-    return;
-}
-void AW20216_set_color_all(uint8_t red, uint8_t green, uint8_t blue) {
-    for (uint8_t i = 0; i < DRIVER_LED_TOTAL; i++) {
-        AW20216_set_color(i, red, green, blue);
-    }
-    return;
-}
-void AW20216_update_pwm_buffers(void) {
-    for (uint8_t i = 0; i < DRIVER_LED_TOTAL; i++) {
-        if (g_pwm_buffer_update_required[i]) {
-            AW20216_update_pwm(i, g_pwm_buffer[i].r, g_pwm_buffer[i].g, g_pwm_buffer[i].b);
-            g_pwm_buffer_update_required[i] = false;
-        }
-    }
-    return;
-}

drivers/awinic/aw20216.h

@@ -1,251 +0,0 @@
-/* Copyright 2021 Jasper Chan (Gigahawk)
- *
- * 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 <stdint.h>
-#include <stdbool.h>
-
-typedef struct aw_led {
-    uint8_t driver : 2;
-    uint8_t r;
-    uint8_t g;
-    uint8_t b;
-} aw_led;
-
-extern const aw_led g_aw_leds[DRIVER_LED_TOTAL];
-
-void AW20216_init(void);
-void AW20216_set_color(int index, uint8_t red, uint8_t green, uint8_t blue);
-void AW20216_set_color_all(uint8_t red, uint8_t green, uint8_t blue);
-void AW20216_update_pwm_buffers(void);
-
-#define CS1_SW1 0x00
-#define CS2_SW1 0x01
-#define CS3_SW1 0x02
-#define CS4_SW1 0x03
-#define CS5_SW1 0x04
-#define CS6_SW1 0x05
-#define CS7_SW1 0x06
-#define CS8_SW1 0x07
-#define CS9_SW1 0x08
-#define CS10_SW1 0x09
-#define CS11_SW1 0x0A
-#define CS12_SW1 0x0B
-#define CS13_SW1 0x0C
-#define CS14_SW1 0x0D
-#define CS15_SW1 0x0E
-#define CS16_SW1 0x0F
-#define CS17_SW1 0x10
-#define CS18_SW1 0x11
-#define CS1_SW2 0x12
-#define CS2_SW2 0x13
-#define CS3_SW2 0x14
-#define CS4_SW2 0x15
-#define CS5_SW2 0x16
-#define CS6_SW2 0x17
-#define CS7_SW2 0x18
-#define CS8_SW2 0x19
-#define CS9_SW2 0x1A
-#define CS10_SW2 0x1B
-#define CS11_SW2 0x1C
-#define CS12_SW2 0x1D
-#define CS13_SW2 0x1E
-#define CS14_SW2 0x1F
-#define CS15_SW2 0x20
-#define CS16_SW2 0x21
-#define CS17_SW2 0x22
-#define CS18_SW2 0x23
-#define CS1_SW3 0x24
-#define CS2_SW3 0x25
-#define CS3_SW3 0x26
-#define CS4_SW3 0x27
-#define CS5_SW3 0x28
-#define CS6_SW3 0x29
-#define CS7_SW3 0x2A
-#define CS8_SW3 0x2B
-#define CS9_SW3 0x2C
-#define CS10_SW3 0x2D
-#define CS11_SW3 0x2E
-#define CS12_SW3 0x2F
-#define CS13_SW3 0x30
-#define CS14_SW3 0x31
-#define CS15_SW3 0x32
-#define CS16_SW3 0x33
-#define CS17_SW3 0x34
-#define CS18_SW3 0x35
-#define CS1_SW4 0x36
-#define CS2_SW4 0x37
-#define CS3_SW4 0x38
-#define CS4_SW4 0x39
-#define CS5_SW4 0x3A
-#define CS6_SW4 0x3B
-#define CS7_SW4 0x3C
-#define CS8_SW4 0x3D
-#define CS9_SW4 0x3E
-#define CS10_SW4 0x3F
-#define CS11_SW4 0x40
-#define CS12_SW4 0x41
-#define CS13_SW4 0x42
-#define CS14_SW4 0x43
-#define CS15_SW4 0x44
-#define CS16_SW4 0x45
-#define CS17_SW4 0x46
-#define CS18_SW4 0x47
-#define CS1_SW5 0x48
-#define CS2_SW5 0x49
-#define CS3_SW5 0x4A
-#define CS4_SW5 0x4B
-#define CS5_SW5 0x4C
-#define CS6_SW5 0x4D
-#define CS7_SW5 0x4E
-#define CS8_SW5 0x4F
-#define CS9_SW5 0x50
-#define CS10_SW5 0x51
-#define CS11_SW5 0x52
-#define CS12_SW5 0x53
-#define CS13_SW5 0x54
-#define CS14_SW5 0x55
-#define CS15_SW5 0x56
-#define CS16_SW5 0x57
-#define CS17_SW5 0x58
-#define CS18_SW5 0x59
-#define CS1_SW6 0x5A
-#define CS2_SW6 0x5B
-#define CS3_SW6 0x5C
-#define CS4_SW6 0x5D
-#define CS5_SW6 0x5E
-#define CS6_SW6 0x5F
-#define CS7_SW6 0x60
-#define CS8_SW6 0x61
-#define CS9_SW6 0x62
-#define CS10_SW6 0x63
-#define CS11_SW6 0x64
-#define CS12_SW6 0x65
-#define CS13_SW6 0x66
-#define CS14_SW6 0x67
-#define CS15_SW6 0x68
-#define CS16_SW6 0x69
-#define CS17_SW6 0x6A
-#define CS18_SW6 0x6B
-#define CS1_SW7 0x6C
-#define CS2_SW7 0x6D
-#define CS3_SW7 0x6E
-#define CS4_SW7 0x6F
-#define CS5_SW7 0x70
-#define CS6_SW7 0x71
-#define CS7_SW7 0x72
-#define CS8_SW7 0x73
-#define CS9_SW7 0x74
-#define CS10_SW7 0x75
-#define CS11_SW7 0x76
-#define CS12_SW7 0x77
-#define CS13_SW7 0x78
-#define CS14_SW7 0x79
-#define CS15_SW7 0x7A
-#define CS16_SW7 0x7B
-#define CS17_SW7 0x7C
-#define CS18_SW7 0x7D
-#define CS1_SW8 0x7E
-#define CS2_SW8 0x7F
-#define CS3_SW8 0x80
-#define CS4_SW8 0x81
-#define CS5_SW8 0x82
-#define CS6_SW8 0x83
-#define CS7_SW8 0x84
-#define CS8_SW8 0x85
-#define CS9_SW8 0x86
-#define CS10_SW8 0x87
-#define CS11_SW8 0x88
-#define CS12_SW8 0x89
-#define CS13_SW8 0x8A
-#define CS14_SW8 0x8B
-#define CS15_SW8 0x8C
-#define CS16_SW8 0x8D
-#define CS17_SW8 0x8E
-#define CS18_SW8 0x8F
-#define CS1_SW9 0x90
-#define CS2_SW9 0x91
-#define CS3_SW9 0x92
-#define CS4_SW9 0x93
-#define CS5_SW9 0x94
-#define CS6_SW9 0x95
-#define CS7_SW9 0x96
-#define CS8_SW9 0x97
-#define CS9_SW9 0x98
-#define CS10_SW9 0x99
-#define CS11_SW9 0x9A
-#define CS12_SW9 0x9B
-#define CS13_SW9 0x9C
-#define CS14_SW9 0x9D
-#define CS15_SW9 0x9E
-#define CS16_SW9 0x9F
-#define CS17_SW9 0xA0
-#define CS18_SW9 0xA1
-#define CS1_SW10 0xA2
-#define CS2_SW10 0xA3
-#define CS3_SW10 0xA4
-#define CS4_SW10 0xA5
-#define CS5_SW10 0xA6
-#define CS6_SW10 0xA7
-#define CS7_SW10 0xA8
-#define CS8_SW10 0xA9
-#define CS9_SW10 0xAA
-#define CS10_SW10 0xAB
-#define CS11_SW10 0xAC
-#define CS12_SW10 0xAD
-#define CS13_SW10 0xAE
-#define CS14_SW10 0xAF
-#define CS15_SW10 0xB0
-#define CS16_SW10 0xB1
-#define CS17_SW10 0xB2
-#define CS18_SW10 0xB3
-#define CS1_SW11 0xB4
-#define CS2_SW11 0xB5
-#define CS3_SW11 0xB6
-#define CS4_SW11 0xB7
-#define CS5_SW11 0xB8
-#define CS6_SW11 0xB9
-#define CS7_SW11 0xBA
-#define CS8_SW11 0xBB
-#define CS9_SW11 0xBC
-#define CS10_SW11 0xBD
-#define CS11_SW11 0xBE
-#define CS12_SW11 0xBF
-#define CS13_SW11 0xC0
-#define CS14_SW11 0xC1
-#define CS15_SW11 0xC2
-#define CS16_SW11 0xC3
-#define CS17_SW11 0xC4
-#define CS18_SW11 0xC5
-#define CS1_SW12 0xC6
-#define CS2_SW12 0xC7
-#define CS3_SW12 0xC8
-#define CS4_SW12 0xC9
-#define CS5_SW12 0xCA
-#define CS6_SW12 0xCB
-#define CS7_SW12 0xCC
-#define CS8_SW12 0xCD
-#define CS9_SW12 0xCE
-#define CS10_SW12 0xCF
-#define CS11_SW12 0xD0
-#define CS12_SW12 0xD1
-#define CS13_SW12 0xD2
-#define CS14_SW12 0xD3
-#define CS15_SW12 0xD4
-#define CS16_SW12 0xD5
-#define CS17_SW12 0xD6
-#define CS18_SW12 0xD7

drivers/chibios/serial.c

@@ -74,12 +74,21 @@ static THD_FUNCTION(Thread1, arg) {
     }
 }
 
-void soft_serial_initiator_init(void) {
+static SSTD_t *Transaction_table      = NULL;
+static uint8_t Transaction_table_size = 0;
+
+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(void) {
+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();
 
     palEnablePadEvent(PAL_PORT(SOFT_SERIAL_PIN), PAL_PAD(SOFT_SERIAL_PIN), PAL_EVENT_MODE_FALLING_EDGE);
@@ -145,14 +154,16 @@ void interrupt_handler(void *arg) {
     uint8_t checksum_computed = 0;
     int     sstd_index        = 0;
 
+#ifdef SERIAL_USE_MULTI_TRANSACTION
     sstd_index = serial_read_byte();
     sync_send();
+#endif
 
-    split_transaction_desc_t *trans = &split_transaction_table[sstd_index];
+    SSTD_t *trans = &Transaction_table[sstd_index];
     for (int i = 0; i < trans->initiator2target_buffer_size; ++i) {
-        split_trans_initiator2target_buffer(trans)[i] = serial_read_byte();
+        trans->initiator2target_buffer[i] = serial_read_byte();
         sync_send();
-        checksum_computed += split_trans_initiator2target_buffer(trans)[i];
+        checksum_computed += trans->initiator2target_buffer[i];
     }
     checksum_computed ^= 7;
     uint8_t checksum_received = serial_read_byte();
@@ -161,17 +172,12 @@ void interrupt_handler(void *arg) {
     // wait for the sync to finish sending
     serial_delay();
 
-    // Allow any slave processing to occur
-    if (trans->slave_callback) {
-        trans->slave_callback(trans->initiator2target_buffer_size, split_trans_initiator2target_buffer(trans), trans->target2initiator_buffer_size, split_trans_target2initiator_buffer(trans));
-    }
-
     uint8_t checksum = 0;
     for (int i = 0; i < trans->target2initiator_buffer_size; ++i) {
-        serial_write_byte(split_trans_target2initiator_buffer(trans)[i]);
+        serial_write_byte(trans->target2initiator_buffer[i]);
         sync_send();
         serial_delay_half();
-        checksum += split_trans_target2initiator_buffer(trans)[i];
+        checksum += trans->target2initiator_buffer[i];
     }
     serial_write_byte(checksum ^ 7);
     sync_send();
@@ -200,10 +206,15 @@ void interrupt_handler(void *arg) {
 //    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) {
+    int sstd_index = 0;
+#else
 int soft_serial_transaction(int sstd_index) {
-    if (sstd_index > NUM_TOTAL_TRANSACTIONS) return TRANSACTION_TYPE_ERROR;
-    split_transaction_desc_t *trans = &split_transaction_table[sstd_index];
-    if (!trans->status) return TRANSACTION_TYPE_ERROR;  // not registered
+#endif
+
+    if (sstd_index > Transaction_table_size) return TRANSACTION_TYPE_ERROR;
+    SSTD_t *trans = &Transaction_table[sstd_index];
 
     // TODO: remove extra delay between transactions
     serial_delay();
@@ -233,13 +244,14 @@ int soft_serial_transaction(int sstd_index) {
 
     uint8_t checksum = 0;
     // send data to the slave
+#ifdef SERIAL_USE_MULTI_TRANSACTION
     serial_write_byte(sstd_index);  // first chunk is transaction id
     sync_recv();
-
+#endif
     for (int i = 0; i < trans->initiator2target_buffer_size; ++i) {
-        serial_write_byte(split_trans_initiator2target_buffer(trans)[i]);
+        serial_write_byte(trans->initiator2target_buffer[i]);
         sync_recv();
-        checksum += split_trans_initiator2target_buffer(trans)[i];
+        checksum += trans->initiator2target_buffer[i];
     }
     serial_write_byte(checksum ^ 7);
     sync_recv();
@@ -250,9 +262,9 @@ int soft_serial_transaction(int sstd_index) {
     // receive data from the slave
     uint8_t checksum_computed = 0;
     for (int i = 0; i < trans->target2initiator_buffer_size; ++i) {
-        split_trans_target2initiator_buffer(trans)[i] = serial_read_byte();
+        trans->target2initiator_buffer[i] = serial_read_byte();
         sync_recv();
-        checksum_computed += split_trans_target2initiator_buffer(trans)[i];
+        checksum_computed += trans->target2initiator_buffer[i];
     }
     checksum_computed ^= 7;
     uint8_t checksum_received = serial_read_byte();

drivers/chibios/serial.h

@@ -0,0 +1,62 @@
+#pragma once
+
+#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 (using signle-type transaction function)
+//   /* nothing */
+// //// USE flexible API (using multi-type transaction function)
+//   #define SERIAL_USE_MULTI_TRANSACTION
+//
+// /////////////////////////////////////////////////////////////////
+
+// 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 result
+#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

drivers/chibios/serial_usart.c

@@ -113,29 +113,37 @@ void usart_slave_init(void) {
     chThdCreateStatic(waSlaveThread, sizeof(waSlaveThread), HIGHPRIO, SlaveThread, NULL);
 }
 
-void soft_serial_initiator_init(void) { usart_master_init(); }
+static SSTD_t* Transaction_table      = NULL;
+static uint8_t Transaction_table_size = 0;
 
-void soft_serial_target_init(void) { usart_slave_init(); }
+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;
+
+    usart_master_init();
+}
+
+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;
+
+    usart_slave_init();
+}
 
 void handle_soft_serial_slave(void) {
-    uint8_t                   sstd_index = sdGet(&SERIAL_USART_DRIVER);  // first chunk is always transaction id
-    split_transaction_desc_t* trans      = &split_transaction_table[sstd_index];
+    uint8_t sstd_index = sdGet(&SERIAL_USART_DRIVER);  // first chunk is always transaction id
+    SSTD_t* trans      = &Transaction_table[sstd_index];
 
     // Always write back the sstd_index as part of a basic handshake
     sstd_index ^= HANDSHAKE_MAGIC;
     sdWrite(&SERIAL_USART_DRIVER, &sstd_index, sizeof(sstd_index));
 
     if (trans->initiator2target_buffer_size) {
-        sdRead(&SERIAL_USART_DRIVER, split_trans_initiator2target_buffer(trans), trans->initiator2target_buffer_size);
-    }
-
-    // Allow any slave processing to occur
-    if (trans->slave_callback) {
-        trans->slave_callback(trans->initiator2target_buffer_size, split_trans_initiator2target_buffer(trans), trans->target2initiator_buffer_size, split_trans_target2initiator_buffer(trans));
+        sdRead(&SERIAL_USART_DRIVER, trans->initiator2target_buffer, trans->initiator2target_buffer_size);
     }
 
     if (trans->target2initiator_buffer_size) {
-        sdWrite(&SERIAL_USART_DRIVER, split_trans_target2initiator_buffer(trans), trans->target2initiator_buffer_size);
+        sdWrite(&SERIAL_USART_DRIVER, trans->target2initiator_buffer, trans->target2initiator_buffer_size);
     }
 
     if (trans->status) {
@@ -152,14 +160,17 @@ void handle_soft_serial_slave(void) {
 //    TRANSACTION_END
 //    TRANSACTION_NO_RESPONSE
 //    TRANSACTION_DATA_ERROR
+#ifndef SERIAL_USE_MULTI_TRANSACTION
+int soft_serial_transaction(void) {
+    uint8_t sstd_index = 0;
+#else
 int soft_serial_transaction(int index) {
     uint8_t sstd_index = index;
+#endif
 
-    if (sstd_index > NUM_TOTAL_TRANSACTIONS) return TRANSACTION_TYPE_ERROR;
-    split_transaction_desc_t* trans = &split_transaction_table[sstd_index];
-    msg_t                     res   = 0;
-
-    if (!trans->status) return TRANSACTION_TYPE_ERROR;  // not registered
+    if (sstd_index > Transaction_table_size) return TRANSACTION_TYPE_ERROR;
+    SSTD_t* trans = &Transaction_table[sstd_index];
+    msg_t   res   = 0;
 
     sdClear(&SERIAL_USART_DRIVER);
 
@@ -178,7 +189,7 @@ int soft_serial_transaction(int index) {
     }
 
     if (trans->initiator2target_buffer_size) {
-        res = sdWriteTimeout(&SERIAL_USART_DRIVER, split_trans_initiator2target_buffer(trans), trans->initiator2target_buffer_size, TIME_MS2I(SERIAL_USART_TIMEOUT));
+        res = sdWriteTimeout(&SERIAL_USART_DRIVER, trans->initiator2target_buffer, trans->initiator2target_buffer_size, TIME_MS2I(SERIAL_USART_TIMEOUT));
         if (res < 0) {
             dprintf("serial::usart_transmit NO_RESPONSE\n");
             return TRANSACTION_NO_RESPONSE;
@@ -186,7 +197,7 @@ int soft_serial_transaction(int index) {
     }
 
     if (trans->target2initiator_buffer_size) {
-        res = sdReadTimeout(&SERIAL_USART_DRIVER, split_trans_target2initiator_buffer(trans), trans->target2initiator_buffer_size, TIME_MS2I(SERIAL_USART_TIMEOUT));
+        res = sdReadTimeout(&SERIAL_USART_DRIVER, trans->target2initiator_buffer, trans->target2initiator_buffer_size, TIME_MS2I(SERIAL_USART_TIMEOUT));
         if (res < 0) {
             dprintf("serial::usart_receive NO_RESPONSE\n");
             return TRANSACTION_NO_RESPONSE;

drivers/chibios/spi_master.c

@@ -18,13 +18,8 @@
 
 #include "timer.h"
 
-static pin_t currentSlavePin = NO_PIN;
-
-#if defined(K20x) || defined(KL2x)
-static SPIConfig spiConfig = {NULL, 0, 0, 0};
-#else
-static SPIConfig spiConfig = {false, NULL, 0, 0, 0, 0};
-#endif
+static pin_t     currentSlavePin = NO_PIN;
+static SPIConfig spiConfig       = {false, NULL, 0, 0, 0, 0};
 
 __attribute__((weak)) void spi_init(void) {
     static bool is_initialised = false;
@@ -32,15 +27,15 @@ __attribute__((weak)) void spi_init(void) {
         is_initialised = true;
 
         // Try releasing special pins for a short time
-        setPinInput(SPI_SCK_PIN);
-        setPinInput(SPI_MOSI_PIN);
-        setPinInput(SPI_MISO_PIN);
+        palSetPadMode(PAL_PORT(SPI_SCK_PIN), PAL_PAD(SPI_SCK_PIN), PAL_MODE_INPUT);
+        palSetPadMode(PAL_PORT(SPI_MOSI_PIN), PAL_PAD(SPI_MOSI_PIN), PAL_MODE_INPUT);
+        palSetPadMode(PAL_PORT(SPI_MISO_PIN), PAL_PAD(SPI_MISO_PIN), PAL_MODE_INPUT);
 
         chThdSleepMilliseconds(10);
 #if defined(USE_GPIOV1)
-        palSetPadMode(PAL_PORT(SPI_SCK_PIN), PAL_PAD(SPI_SCK_PIN), SPI_SCK_PAL_MODE);
-        palSetPadMode(PAL_PORT(SPI_MOSI_PIN), PAL_PAD(SPI_MOSI_PIN), SPI_MOSI_PAL_MODE);
-        palSetPadMode(PAL_PORT(SPI_MISO_PIN), PAL_PAD(SPI_MISO_PIN), SPI_MISO_PAL_MODE);
+        palSetPadMode(PAL_PORT(SPI_SCK_PIN), PAL_PAD(SPI_SCK_PIN), PAL_MODE_STM32_ALTERNATE_PUSHPULL);
+        palSetPadMode(PAL_PORT(SPI_MOSI_PIN), PAL_PAD(SPI_MOSI_PIN), PAL_MODE_STM32_ALTERNATE_PUSHPULL);
+        palSetPadMode(PAL_PORT(SPI_MISO_PIN), PAL_PAD(SPI_MISO_PIN), PAL_MODE_STM32_ALTERNATE_PUSHPULL);
 #else
         palSetPadMode(PAL_PORT(SPI_SCK_PIN), PAL_PAD(SPI_SCK_PIN), PAL_MODE_ALTERNATE(SPI_SCK_PAL_MODE) | PAL_STM32_OTYPE_PUSHPULL | PAL_STM32_OSPEED_HIGHEST);
         palSetPadMode(PAL_PORT(SPI_MOSI_PIN), PAL_PAD(SPI_MOSI_PIN), PAL_MODE_ALTERNATE(SPI_MOSI_PAL_MODE) | PAL_STM32_OTYPE_PUSHPULL | PAL_STM32_OSPEED_HIGHEST);
@@ -63,54 +58,6 @@ bool spi_start(pin_t slavePin, bool lsbFirst, uint8_t mode, uint16_t divisor) {
         return false;
     }
 
-#if defined(K20x) || defined(KL2x)
-    spiConfig.tar0 = SPIx_CTARn_FMSZ(7) | SPIx_CTARn_ASC(1);
-
-    if (lsbFirst) {
-        spiConfig.tar0 |= SPIx_CTARn_LSBFE;
-    }
-
-    switch (mode) {
-        case 0:
-            break;
-        case 1:
-            spiConfig.tar0 |= SPIx_CTARn_CPHA;
-            break;
-        case 2:
-            spiConfig.tar0 |= SPIx_CTARn_CPOL;
-            break;
-        case 3:
-            spiConfig.tar0 |= SPIx_CTARn_CPHA | SPIx_CTARn_CPOL;
-            break;
-    }
-
-    switch (roundedDivisor) {
-        case 2:
-            spiConfig.tar0 |= SPIx_CTARn_BR(0);
-            break;
-        case 4:
-            spiConfig.tar0 |= SPIx_CTARn_BR(1);
-            break;
-        case 8:
-            spiConfig.tar0 |= SPIx_CTARn_BR(3);
-            break;
-        case 16:
-            spiConfig.tar0 |= SPIx_CTARn_BR(4);
-            break;
-        case 32:
-            spiConfig.tar0 |= SPIx_CTARn_BR(5);
-            break;
-        case 64:
-            spiConfig.tar0 |= SPIx_CTARn_BR(6);
-            break;
-        case 128:
-            spiConfig.tar0 |= SPIx_CTARn_BR(7);
-            break;
-        case 256:
-            spiConfig.tar0 |= SPIx_CTARn_BR(8);
-            break;
-    }
-#else
     spiConfig.cr1 = 0;
 
     if (lsbFirst) {
@@ -156,7 +103,6 @@ bool spi_start(pin_t slavePin, bool lsbFirst, uint8_t mode, uint16_t divisor) {
             spiConfig.cr1 |= SPI_CR1_BR_2 | SPI_CR1_BR_1 | SPI_CR1_BR_0;
             break;
     }
-#endif
 
     currentSlavePin  = slavePin;
     spiConfig.ssport = PAL_PORT(slavePin);

drivers/chibios/spi_master.h

@@ -21,7 +21,6 @@
 #include <stdbool.h>
 
 #include "gpio.h"
-#include "chibios_config.h"
 
 #ifndef SPI_DRIVER
 #    define SPI_DRIVER SPID2
@@ -32,11 +31,7 @@
 #endif
 
 #ifndef SPI_SCK_PAL_MODE
-#    if defined(USE_GPIOV1)
-#        define SPI_SCK_PAL_MODE PAL_MODE_STM32_ALTERNATE_PUSHPULL
-#    else
-#        define SPI_SCK_PAL_MODE 5
-#    endif
+#    define SPI_SCK_PAL_MODE 5
 #endif
 
 #ifndef SPI_MOSI_PIN
@@ -44,11 +39,7 @@
 #endif
 
 #ifndef SPI_MOSI_PAL_MODE
-#    if defined(USE_GPIOV1)
-#        define SPI_MOSI_PAL_MODE PAL_MODE_STM32_ALTERNATE_PUSHPULL
-#    else
-#        define SPI_MOSI_PAL_MODE 5
-#    endif
+#    define SPI_MOSI_PAL_MODE 5
 #endif
 
 #ifndef SPI_MISO_PIN
@@ -56,11 +47,7 @@
 #endif
 
 #ifndef SPI_MISO_PAL_MODE
-#    if defined(USE_GPIOV1)
-#        define SPI_MISO_PAL_MODE PAL_MODE_STM32_ALTERNATE_PUSHPULL
-#    else
-#        define SPI_MISO_PAL_MODE 5
-#    endif
+#    define SPI_MISO_PAL_MODE 5
 #endif
 
 typedef int16_t spi_status_t;

drivers/haptic/haptic.c

@@ -291,73 +291,6 @@ void haptic_play(void) {
 #endif
 }
 
-__attribute__((weak)) bool get_haptic_enabled_key(uint16_t keycode, keyrecord_t *record) {
-    switch(keycode) {
-#    ifdef NO_HAPTIC_MOD
-        case QK_MOD_TAP ... QK_MOD_TAP_MAX:
-            if (record->tap.count == 0) return false;
-            break;
-        case QK_LAYER_TAP_TOGGLE ... QK_LAYER_TAP_TOGGLE_MAX:
-            if (record->tap.count != TAPPING_TOGGLE) return false;
-            break;
-        case QK_LAYER_TAP ... QK_LAYER_TAP_MAX:
-            if (record->tap.count == 0) return false;
-            break;
-        case KC_LCTRL ... KC_RGUI:
-        case QK_MOMENTARY ... QK_MOMENTARY_MAX:
-#    endif
-#    ifdef NO_HAPTIC_FN
-        case KC_FN0 ... KC_FN31:
-#    endif
-#    ifdef NO_HAPTIC_ALPHA
-        case KC_A ... KC_Z:
-#    endif
-#    ifdef NO_HAPTIC_PUNCTUATION
-        case KC_ENTER:
-        case KC_ESCAPE:
-        case KC_BSPACE:
-        case KC_SPACE:
-        case KC_MINUS:
-        case KC_EQUAL:
-        case KC_LBRACKET:
-        case KC_RBRACKET:
-        case KC_BSLASH:
-        case KC_NONUS_HASH:
-        case KC_SCOLON:
-        case KC_QUOTE:
-        case KC_GRAVE:
-        case KC_COMMA:
-        case KC_SLASH:
-        case KC_DOT:
-        case KC_NONUS_BSLASH:
-#    endif
-#    ifdef NO_HAPTIC_LOCKKEYS
-        case KC_CAPSLOCK:
-        case KC_SCROLLLOCK:
-        case KC_NUMLOCK:
-#    endif
-#    ifdef NO_HAPTIC_NAV
-        case KC_PSCREEN:
-        case KC_PAUSE:
-        case KC_INSERT:
-        case KC_DELETE:
-        case KC_PGDOWN:
-        case KC_PGUP:
-        case KC_LEFT:
-        case KC_UP:
-        case KC_RIGHT:
-        case KC_DOWN:
-        case KC_END:
-        case KC_HOME:
-#    endif
-#    ifdef NO_HAPTIC_NUMERIC
-        case KC_1 ... KC_0:
-#    endif
-         return false;
-    }
-    return true;
-}
-
 bool process_haptic(uint16_t keycode, keyrecord_t *record) {
     if (keycode == HPT_ON && record->event.pressed) {
         haptic_enable();
@@ -402,12 +335,12 @@ bool process_haptic(uint16_t keycode, keyrecord_t *record) {
     if (haptic_config.enable) {
         if (record->event.pressed) {
             // keypress
-            if (haptic_config.feedback < 2 && get_haptic_enabled_key(keycode, record)) {
+            if (haptic_config.feedback < 2) {
                 haptic_play();
             }
         } else {
             // keyrelease
-            if (haptic_config.feedback > 0 && get_haptic_enabled_key(keycode, record)) {
+            if (haptic_config.feedback > 0) {
                 haptic_play();
             }
         }

drivers/lcd/st7565.c

@@ -1,496 +0,0 @@
-/*
-Copyright 2021
-
-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 "st7565.h"
-
-#include <string.h>
-
-#include "keyboard.h"
-#include "progmem.h"
-#include "timer.h"
-#include "wait.h"
-
-#include ST7565_FONT_H
-
-// Fundamental Commands
-#define CONTRAST 0x81
-#define DISPLAY_ALL_ON 0xA5
-#define DISPLAY_ALL_ON_RESUME 0xA4
-#define NORMAL_DISPLAY 0xA6
-#define INVERT_DISPLAY 0xA7
-#define DISPLAY_ON 0xAF
-#define DISPLAY_OFF 0xAE
-#define NOP 0xE3
-
-// Addressing Setting Commands
-#define PAM_SETCOLUMN_LSB 0x00
-#define PAM_SETCOLUMN_MSB 0x10
-#define PAM_PAGE_ADDR 0xB0  // 0xb0 -- 0xb7
-
-// Hardware Configuration Commands
-#define DISPLAY_START_LINE 0x40
-#define SEGMENT_REMAP 0xA0
-#define SEGMENT_REMAP_INV 0xA1
-#define COM_SCAN_INC 0xC0
-#define COM_SCAN_DEC 0xC8
-#define LCD_BIAS_7 0xA3
-#define LCD_BIAS_9 0xA2
-#define RESISTOR_RATIO 0x20
-#define POWER_CONTROL 0x28
-
-// Misc defines
-#ifndef ST7565_BLOCK_COUNT
-#    define ST7565_BLOCK_COUNT (sizeof(ST7565_BLOCK_TYPE) * 8)
-#endif
-#ifndef ST7565_BLOCK_SIZE
-#    define ST7565_BLOCK_SIZE (ST7565_MATRIX_SIZE / ST7565_BLOCK_COUNT)
-#endif
-
-#define ST7565_ALL_BLOCKS_MASK (((((ST7565_BLOCK_TYPE)1 << (ST7565_BLOCK_COUNT - 1)) - 1) << 1) | 1)
-
-#define HAS_FLAGS(bits, flags) ((bits & flags) == flags)
-
-// Display buffer's is the same as the display memory layout
-// this is so we don't end up with rounding errors with
-// parts of the display unusable or don't get cleared correctly
-// and also allows for drawing & inverting
-uint8_t            st7565_buffer[ST7565_MATRIX_SIZE];
-uint8_t *          st7565_cursor;
-ST7565_BLOCK_TYPE  st7565_dirty       = 0;
-bool               st7565_initialized = false;
-bool               st7565_active      = false;
-bool               st7565_inverted    = false;
-display_rotation_t st7565_rotation    = DISPLAY_ROTATION_0;
-#if ST7565_TIMEOUT > 0
-uint32_t st7565_timeout;
-#endif
-#if ST7565_UPDATE_INTERVAL > 0
-uint16_t st7565_update_timeout;
-#endif
-
-// Flips the rendering bits for a character at the current cursor position
-static void InvertCharacter(uint8_t *cursor) {
-    const uint8_t *end = cursor + ST7565_FONT_WIDTH;
-    while (cursor < end) {
-        *cursor = ~(*cursor);
-        cursor++;
-    }
-}
-
-bool st7565_init(display_rotation_t rotation) {
-    setPinOutput(ST7565_A0_PIN);
-    writePinHigh(ST7565_A0_PIN);
-    setPinOutput(ST7565_RST_PIN);
-    writePinHigh(ST7565_RST_PIN);
-
-    st7565_rotation = st7565_init_user(rotation);
-
-    spi_init();
-    spi_start(ST7565_SS_PIN, false, 0, ST7565_SPI_CLK_DIVISOR);
-
-    st7565_reset();
-
-    st7565_send_cmd(LCD_BIAS_7);
-    if (!HAS_FLAGS(st7565_rotation, DISPLAY_ROTATION_180)) {
-        st7565_send_cmd(SEGMENT_REMAP);
-        st7565_send_cmd(COM_SCAN_DEC);
-    } else {
-        st7565_send_cmd(SEGMENT_REMAP_INV);
-        st7565_send_cmd(COM_SCAN_INC);
-    }
-    st7565_send_cmd(DISPLAY_START_LINE | 0x00);
-    st7565_send_cmd(CONTRAST);
-    st7565_send_cmd(ST7565_CONTRAST);
-    st7565_send_cmd(RESISTOR_RATIO | 0x01);
-    st7565_send_cmd(POWER_CONTROL | 0x04);
-    wait_ms(50);
-    st7565_send_cmd(POWER_CONTROL | 0x06);
-    wait_ms(50);
-    st7565_send_cmd(POWER_CONTROL | 0x07);
-    wait_ms(10);
-    st7565_send_cmd(DISPLAY_ON);
-    st7565_send_cmd(DISPLAY_ALL_ON_RESUME);
-    st7565_send_cmd(NORMAL_DISPLAY);
-
-    spi_stop();
-
-#if ST7565_TIMEOUT > 0
-    st7565_timeout = timer_read32() + ST7565_TIMEOUT;
-#endif
-
-    st7565_clear();
-    st7565_initialized = true;
-    st7565_active      = true;
-    return true;
-}
-
-__attribute__((weak)) display_rotation_t st7565_init_user(display_rotation_t rotation) { return rotation; }
-
-void st7565_clear(void) {
-    memset(st7565_buffer, 0, sizeof(st7565_buffer));
-    st7565_cursor = &st7565_buffer[0];
-    st7565_dirty  = ST7565_ALL_BLOCKS_MASK;
-}
-
-uint8_t crot(uint8_t a, int8_t n) {
-    const uint8_t mask = 0x7;
-    n &= mask;
-    return a << n | a >> (-n & mask);
-}
-
-void st7565_render(void) {
-    if (!st7565_initialized) {
-        return;
-    }
-
-    // Do we have work to do?
-    st7565_dirty &= ST7565_ALL_BLOCKS_MASK;
-    if (!st7565_dirty) {
-        return;
-    }
-
-    // Find first dirty block
-    uint8_t update_start = 0;
-    while (!(st7565_dirty & ((ST7565_BLOCK_TYPE)1 << update_start))) {
-        ++update_start;
-    }
-
-    // Calculate commands to set memory addressing bounds.
-    uint8_t start_page   = ST7565_BLOCK_SIZE * update_start / ST7565_DISPLAY_WIDTH;
-    uint8_t start_column = ST7565_BLOCK_SIZE * update_start % ST7565_DISPLAY_WIDTH;
-    // IC has 132 segment drivers, for panels with less width we need to offset the starting column
-    if (HAS_FLAGS(st7565_rotation, DISPLAY_ROTATION_180)) {
-        start_column += (132 - ST7565_DISPLAY_WIDTH);
-    }
-
-    spi_start(ST7565_SS_PIN, false, 0, ST7565_SPI_CLK_DIVISOR);
-
-    st7565_send_cmd(PAM_PAGE_ADDR | start_page);
-    st7565_send_cmd(PAM_SETCOLUMN_LSB | ((ST7565_COLUMN_OFFSET + start_column) & 0x0f));
-    st7565_send_cmd(PAM_SETCOLUMN_MSB | ((ST7565_COLUMN_OFFSET + start_column) >> 4 & 0x0f));
-
-    st7565_send_data(&st7565_buffer[ST7565_BLOCK_SIZE * update_start], ST7565_BLOCK_SIZE);
-
-    // Turn on display if it is off
-    st7565_on();
-
-    // Clear dirty flag
-    st7565_dirty &= ~((ST7565_BLOCK_TYPE)1 << update_start);
-}
-
-void st7565_set_cursor(uint8_t col, uint8_t line) {
-    uint16_t index = line * ST7565_DISPLAY_WIDTH + col * ST7565_FONT_WIDTH;
-
-    // Out of bounds?
-    if (index >= ST7565_MATRIX_SIZE) {
-        index = 0;
-    }
-
-    st7565_cursor = &st7565_buffer[index];
-}
-
-void st7565_advance_page(bool clearPageRemainder) {
-    uint16_t index     = st7565_cursor - &st7565_buffer[0];
-    uint8_t  remaining = ST7565_DISPLAY_WIDTH - (index % ST7565_DISPLAY_WIDTH);
-
-    if (clearPageRemainder) {
-        // Remaining Char count
-        remaining = remaining / ST7565_FONT_WIDTH;
-
-        // Write empty character until next line
-        while (remaining--) st7565_write_char(' ', false);
-    } else {
-        // Next page index out of bounds?
-        if (index + remaining >= ST7565_MATRIX_SIZE) {
-            index     = 0;
-            remaining = 0;
-        }
-
-        st7565_cursor = &st7565_buffer[index + remaining];
-    }
-}
-
-void st7565_advance_char(void) {
-    uint16_t nextIndex      = st7565_cursor - &st7565_buffer[0] + ST7565_FONT_WIDTH;
-    uint8_t  remainingSpace = ST7565_DISPLAY_WIDTH - (nextIndex % ST7565_DISPLAY_WIDTH);
-
-    // Do we have enough space on the current line for the next character
-    if (remainingSpace < ST7565_FONT_WIDTH) {
-        nextIndex += remainingSpace;
-    }
-
-    // Did we go out of bounds
-    if (nextIndex >= ST7565_MATRIX_SIZE) {
-        nextIndex = 0;
-    }
-
-    // Update cursor position
-    st7565_cursor = &st7565_buffer[nextIndex];
-}
-
-// Main handler that writes character data to the display buffer
-void st7565_write_char(const char data, bool invert) {
-    // Advance to the next line if newline
-    if (data == '\n') {
-        // Old source wrote ' ' until end of line...
-        st7565_advance_page(true);
-        return;
-    }
-
-    if (data == '\r') {
-        st7565_advance_page(false);
-        return;
-    }
-
-    // copy the current render buffer to check for dirty after
-    static uint8_t st7565_temp_buffer[ST7565_FONT_WIDTH];
-    memcpy(&st7565_temp_buffer, st7565_cursor, ST7565_FONT_WIDTH);
-
-    _Static_assert(sizeof(font) >= ((ST7565_FONT_END + 1 - ST7565_FONT_START) * ST7565_FONT_WIDTH), "ST7565_FONT_END references outside array");
-
-    // set the reder buffer data
-    uint8_t cast_data = (uint8_t)data;  // font based on unsigned type for index
-    if (cast_data < ST7565_FONT_START || cast_data > ST7565_FONT_END) {
-        memset(st7565_cursor, 0x00, ST7565_FONT_WIDTH);
-    } else {
-        const uint8_t *glyph = &font[(cast_data - ST7565_FONT_START) * ST7565_FONT_WIDTH];
-        memcpy_P(st7565_cursor, glyph, ST7565_FONT_WIDTH);
-    }
-
-    // Invert if needed
-    if (invert) {
-        InvertCharacter(st7565_cursor);
-    }
-
-    // Dirty check
-    if (memcmp(&st7565_temp_buffer, st7565_cursor, ST7565_FONT_WIDTH)) {
-        uint16_t index = st7565_cursor - &st7565_buffer[0];
-        st7565_dirty |= ((ST7565_BLOCK_TYPE)1 << (index / ST7565_BLOCK_SIZE));
-        // Edgecase check if the written data spans the 2 chunks
-        st7565_dirty |= ((ST7565_BLOCK_TYPE)1 << ((index + ST7565_FONT_WIDTH - 1) / ST7565_BLOCK_SIZE));
-    }
-
-    // Finally move to the next char
-    st7565_advance_char();
-}
-
-void st7565_write(const char *data, bool invert) {
-    const char *end = data + strlen(data);
-    while (data < end) {
-        st7565_write_char(*data, invert);
-        data++;
-    }
-}
-
-void st7565_write_ln(const char *data, bool invert) {
-    st7565_write(data, invert);
-    st7565_advance_page(true);
-}
-
-void st7565_pan(bool left) {
-    uint16_t i = 0;
-    for (uint16_t y = 0; y < ST7565_DISPLAY_HEIGHT / 8; y++) {
-        if (left) {
-            for (uint16_t x = 0; x < ST7565_DISPLAY_WIDTH - 1; x++) {
-                i                = y * ST7565_DISPLAY_WIDTH + x;
-                st7565_buffer[i] = st7565_buffer[i + 1];
-            }
-        } else {
-            for (uint16_t x = ST7565_DISPLAY_WIDTH - 1; x > 0; x--) {
-                i                = y * ST7565_DISPLAY_WIDTH + x;
-                st7565_buffer[i] = st7565_buffer[i - 1];
-            }
-        }
-    }
-    st7565_dirty = ST7565_ALL_BLOCKS_MASK;
-}
-
-display_buffer_reader_t st7565_read_raw(uint16_t start_index) {
-    if (start_index > ST7565_MATRIX_SIZE) start_index = ST7565_MATRIX_SIZE;
-    display_buffer_reader_t ret_reader;
-    ret_reader.current_element         = &st7565_buffer[start_index];
-    ret_reader.remaining_element_count = ST7565_MATRIX_SIZE - start_index;
-    return ret_reader;
-}
-
-void st7565_write_raw_byte(const char data, uint16_t index) {
-    if (index > ST7565_MATRIX_SIZE) index = ST7565_MATRIX_SIZE;
-    if (st7565_buffer[index] == data) return;
-    st7565_buffer[index] = data;
-    st7565_dirty |= ((ST7565_BLOCK_TYPE)1 << (index / ST7565_BLOCK_SIZE));
-}
-
-void st7565_write_raw(const char *data, uint16_t size) {
-    uint16_t cursor_start_index = st7565_cursor - &st7565_buffer[0];
-    if ((size + cursor_start_index) > ST7565_MATRIX_SIZE) size = ST7565_MATRIX_SIZE - cursor_start_index;
-    for (uint16_t i = cursor_start_index; i < cursor_start_index + size; i++) {
-        uint8_t c = *data++;
-        if (st7565_buffer[i] == c) continue;
-        st7565_buffer[i] = c;
-        st7565_dirty |= ((ST7565_BLOCK_TYPE)1 << (i / ST7565_BLOCK_SIZE));
-    }
-}
-
-void st7565_write_pixel(uint8_t x, uint8_t y, bool on) {
-    if (x >= ST7565_DISPLAY_WIDTH) {
-        return;
-    }
-    uint16_t index = x + (y / 8) * ST7565_DISPLAY_WIDTH;
-    if (index >= ST7565_MATRIX_SIZE) {
-        return;
-    }
-    uint8_t data = st7565_buffer[index];
-    if (on) {
-        data |= (1 << (y % 8));
-    } else {
-        data &= ~(1 << (y % 8));
-    }
-    if (st7565_buffer[index] != data) {
-        st7565_buffer[index] = data;
-        st7565_dirty |= ((ST7565_BLOCK_TYPE)1 << (index / ST7565_BLOCK_SIZE));
-    }
-}
-
-#if defined(__AVR__)
-void st7565_write_P(const char *data, bool invert) {
-    uint8_t c = pgm_read_byte(data);
-    while (c != 0) {
-        st7565_write_char(c, invert);
-        c = pgm_read_byte(++data);
-    }
-}
-
-void st7565_write_ln_P(const char *data, bool invert) {
-    st7565_write_P(data, invert);
-    st7565_advance_page(true);
-}
-
-void st7565_write_raw_P(const char *data, uint16_t size) {
-    uint16_t cursor_start_index = st7565_cursor - &st7565_buffer[0];
-    if ((size + cursor_start_index) > ST7565_MATRIX_SIZE) size = ST7565_MATRIX_SIZE - cursor_start_index;
-    for (uint16_t i = cursor_start_index; i < cursor_start_index + size; i++) {
-        uint8_t c = pgm_read_byte(data++);
-        if (st7565_buffer[i] == c) continue;
-        st7565_buffer[i] = c;
-        st7565_dirty |= ((ST7565_BLOCK_TYPE)1 << (i / ST7565_BLOCK_SIZE));
-    }
-}
-#endif  // defined(__AVR__)
-
-bool st7565_on(void) {
-    if (!st7565_initialized) {
-        return st7565_active;
-    }
-
-#if ST7565_TIMEOUT > 0
-    st7565_timeout = timer_read32() + ST7565_TIMEOUT;
-#endif
-
-    if (!st7565_active) {
-        spi_start(ST7565_SS_PIN, false, 0, ST7565_SPI_CLK_DIVISOR);
-        st7565_send_cmd(DISPLAY_ON);
-        spi_stop();
-        st7565_active = true;
-        st7565_on_user();
-    }
-    return st7565_active;
-}
-
-__attribute__((weak)) void st7565_on_user(void) {}
-
-bool st7565_off(void) {
-    if (!st7565_initialized) {
-        return !st7565_active;
-    }
-
-    if (st7565_active) {
-        spi_start(ST7565_SS_PIN, false, 0, ST7565_SPI_CLK_DIVISOR);
-        st7565_send_cmd(DISPLAY_OFF);
-        spi_stop();
-        st7565_active = false;
-        st7565_off_user();
-    }
-    return !st7565_active;
-}
-
-__attribute__((weak)) void st7565_off_user(void) {}
-
-bool st7565_is_on(void) { return st7565_active; }
-
-bool st7565_invert(bool invert) {
-    if (!st7565_initialized) {
-        return st7565_inverted;
-    }
-
-    if (invert != st7565_inverted) {
-        spi_start(ST7565_SS_PIN, false, 0, ST7565_SPI_CLK_DIVISOR);
-        st7565_send_cmd(invert ? INVERT_DISPLAY : NORMAL_DISPLAY);
-        spi_stop();
-        st7565_inverted = invert;
-    }
-    return st7565_inverted;
-}
-
-uint8_t st7565_max_chars(void) { return ST7565_DISPLAY_WIDTH / ST7565_FONT_WIDTH; }
-
-uint8_t st7565_max_lines(void) { return ST7565_DISPLAY_HEIGHT / ST7565_FONT_HEIGHT; }
-
-void st7565_task(void) {
-    if (!st7565_initialized) {
-        return;
-    }
-
-#if ST7565_UPDATE_INTERVAL > 0
-    if (timer_elapsed(st7565_update_timeout) >= ST7565_UPDATE_INTERVAL) {
-        st7565_update_timeout = timer_read();
-        st7565_set_cursor(0, 0);
-        st7565_task_user();
-    }
-#else
-    st7565_set_cursor(0, 0);
-    st7565_task_user();
-#endif
-
-    // Smart render system, no need to check for dirty
-    st7565_render();
-
-    // Display timeout check
-#if ST7565_TIMEOUT > 0
-    if (st7565_active && timer_expired32(timer_read32(), st7565_timeout)) {
-        st7565_off();
-    }
-#endif
-}
-
-__attribute__((weak)) void st7565_task_user(void) {}
-
-void st7565_reset(void) {
-    writePinLow(ST7565_RST_PIN);
-    wait_ms(20);
-    writePinHigh(ST7565_RST_PIN);
-    wait_ms(20);
-}
-
-spi_status_t st7565_send_cmd(uint8_t cmd) {
-    writePinLow(ST7565_A0_PIN);
-    return spi_write(cmd);
-}
-
-spi_status_t st7565_send_data(uint8_t *data, uint16_t length) {
-    writePinHigh(ST7565_A0_PIN);
-    return spi_transmit(data, length);
-}

drivers/lcd/st7565.h

@@ -1,219 +0,0 @@
-/*
-Copyright 2021
-
-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 <stdint.h>
-#include <stdbool.h>
-
-#include "spi_master.h"
-
-#ifndef ST7565_DISPLAY_WIDTH
-#    define ST7565_DISPLAY_WIDTH 128
-#endif
-#ifndef ST7565_DISPLAY_HEIGHT
-#    define ST7565_DISPLAY_HEIGHT 32
-#endif
-#ifndef ST7565_MATRIX_SIZE
-#    define ST7565_MATRIX_SIZE (ST7565_DISPLAY_HEIGHT / 8 * ST7565_DISPLAY_WIDTH)  // 1024 (compile time mathed)
-#endif
-#ifndef ST7565_BLOCK_TYPE
-#    define ST7565_BLOCK_TYPE uint16_t
-#endif
-#ifndef ST7565_BLOCK_COUNT
-#    define ST7565_BLOCK_COUNT (sizeof(ST7565_BLOCK_TYPE) * 8)  // 32 (compile time mathed)
-#endif
-#ifndef ST7565_BLOCK_SIZE
-#    define ST7565_BLOCK_SIZE (ST7565_MATRIX_SIZE / ST7565_BLOCK_COUNT)  // 32 (compile time mathed)
-#endif
-
-// the column address corresponding to the first column in the display hardware
-#if !defined(ST7565_COLUMN_OFFSET)
-#    define ST7565_COLUMN_OFFSET 0
-#endif
-
-// spi clock divisor
-#if !defined(ST7565_SPI_CLK_DIVISOR)
-#    define ST7565_SPI_CLK_DIVISOR 4
-#endif
-
-// Custom font file to use
-#if !defined(ST7565_FONT_H)
-#    define ST7565_FONT_H "glcdfont.c"
-#endif
-// unsigned char value of the first character in the font file
-#if !defined(ST7565_FONT_START)
-#    define ST7565_FONT_START 0
-#endif
-// unsigned char value of the last character in the font file
-#if !defined(ST7565_FONT_END)
-#    define ST7565_FONT_END 223
-#endif
-// Font render width
-#if !defined(ST7565_FONT_WIDTH)
-#    define ST7565_FONT_WIDTH 6
-#endif
-// Font render height
-#if !defined(ST7565_FONT_HEIGHT)
-#    define ST7565_FONT_HEIGHT 8
-#endif
-// Default contrast level
-#if !defined(ST7565_CONTRAST)
-#    define ST7565_CONTRAST 32
-#endif
-
-#if !defined(ST7565_TIMEOUT)
-#    if defined(ST7565_DISABLE_TIMEOUT)
-#        define ST7565_TIMEOUT 0
-#    else
-#        define ST7565_TIMEOUT 60000
-#    endif
-#endif
-
-#if !defined(ST7565_UPDATE_INTERVAL) && defined(SPLIT_KEYBOARD)
-#    define ST7565_UPDATE_INTERVAL 50
-#endif
-
-typedef struct __attribute__((__packed__)) {
-    uint8_t *current_element;
-    uint16_t remaining_element_count;
-} display_buffer_reader_t;
-
-// Rotation enum values are flags
-typedef enum { DISPLAY_ROTATION_0, DISPLAY_ROTATION_180 } display_rotation_t;
-
-// Initialize the display, rotating the rendered output based on the define passed in.
-// Returns true if the display was initialized successfully
-bool st7565_init(display_rotation_t rotation);
-
-// Called at the start of st7565_init, weak function overridable by the user
-// rotation - the value passed into st7565_init
-// Return new display_rotation_t if you want to override default rotation
-display_rotation_t st7565_init_user(display_rotation_t rotation);
-
-// Clears the display buffer, resets cursor position to 0, and sets the buffer to dirty for rendering
-void st7565_clear(void);
-
-// Renders the dirty chunks of the buffer to display
-void st7565_render(void);
-
-// Moves cursor to character position indicated by column and line, wraps if out of bounds
-// Max column denoted by 'st7565_max_chars()' and max lines by 'st7565_max_lines()' functions
-void st7565_set_cursor(uint8_t col, uint8_t line);
-
-// Advances the cursor to the next page, writing ' ' if true
-// Wraps to the begining when out of bounds
-void st7565_advance_page(bool clearPageRemainder);
-
-// Moves the cursor forward 1 character length
-// Advance page if there is not enough room for the next character
-// Wraps to the begining when out of bounds
-void st7565_advance_char(void);
-
-// Writes a single character to the buffer at current cursor position
-// Advances the cursor while writing, inverts the pixels if true
-// Main handler that writes character data to the display buffer
-void st7565_write_char(const char data, bool invert);
-
-// Writes a string to the buffer at current cursor position
-// Advances the cursor while writing, inverts the pixels if true
-void st7565_write(const char *data, bool invert);
-
-// Writes a string to the buffer at current cursor position
-// Advances the cursor while writing, inverts the pixels if true
-// Advances the cursor to the next page, wiring ' ' to the remainder of the current page
-void st7565_write_ln(const char *data, bool invert);
-
-// Pans the buffer to the right (or left by passing true) by moving contents of the buffer
-// Useful for moving the screen in preparation for new drawing
-void st7565_pan(bool left);
-
-// Returns a pointer to the requested start index in the buffer plus remaining
-// buffer length as struct
-display_buffer_reader_t st7565_read_raw(uint16_t start_index);
-
-// Writes a string to the buffer at current cursor position
-void st7565_write_raw(const char *data, uint16_t size);
-
-// Writes a single byte into the buffer at the specified index
-void st7565_write_raw_byte(const char data, uint16_t index);
-
-// Sets a specific pixel on or off
-// Coordinates start at top-left and go right and down for positive x and y
-void st7565_write_pixel(uint8_t x, uint8_t y, bool on);
-
-#if defined(__AVR__)
-// Writes a PROGMEM string to the buffer at current cursor position
-// Advances the cursor while writing, inverts the pixels if true
-// Remapped to call 'void st7565_write(const char *data, bool invert);' on ARM
-void st7565_write_P(const char *data, bool invert);
-
-// Writes a PROGMEM string to the buffer at current cursor position
-// Advances the cursor while writing, inverts the pixels if true
-// Advances the cursor to the next page, wiring ' ' to the remainder of the current page
-// Remapped to call 'void st7565_write_ln(const char *data, bool invert);' on ARM
-void st7565_write_ln_P(const char *data, bool invert);
-
-// Writes a PROGMEM string to the buffer at current cursor position
-void st7565_write_raw_P(const char *data, uint16_t size);
-#else
-#    define st7565_write_P(data, invert) st7565_write(data, invert)
-#    define st7565_write_ln_P(data, invert) st7565_write_ln(data, invert)
-#    define st7565_write_raw_P(data, size) st7565_write_raw(data, size)
-#endif  // defined(__AVR__)
-
-// Can be used to manually turn on the screen if it is off
-// Returns true if the screen was on or turns on
-bool st7565_on(void);
-
-// Called when st7565_on() turns on the screen, weak function overridable by the user
-// Not called if the screen is already on
-void st7565_on_user(void);
-
-// Can be used to manually turn off the screen if it is on
-// Returns true if the screen was off or turns off
-bool st7565_off(void);
-
-// Called when st7565_off() turns off the screen, weak function overridable by the user
-// Not called if the screen is already off
-void st7565_off_user(void);
-
-// Returns true if the screen is currently on, false if it is
-// not
-bool st7565_is_on(void);
-
-// Basically it's st7565_render, but with timeout management and st7565_task_user calling!
-void st7565_task(void);
-
-// Called at the start of st7565_task, weak function overridable by the user
-void st7565_task_user(void);
-
-// Inverts the display
-// Returns true if the screen was or is inverted
-bool st7565_invert(bool invert);
-
-// Returns the maximum number of characters that will fit on a line
-uint8_t st7565_max_chars(void);
-
-// Returns the maximum number of lines that will fit on the display
-uint8_t st7565_max_lines(void);
-
-void st7565_reset(void);
-
-spi_status_t st7565_send_cmd(uint8_t cmd);
-
-spi_status_t st7565_send_data(uint8_t *data, uint16_t length);

drivers/oled/oled_driver.c

@@ -34,7 +34,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define DISPLAY_ALL_ON 0xA5
 #define DISPLAY_ALL_ON_RESUME 0xA4
 #define NORMAL_DISPLAY 0xA6
-#define INVERT_DISPLAY 0xA7
 #define DISPLAY_ON 0xAF
 #define DISPLAY_OFF 0xAE
 #define NOP 0xE3
@@ -115,7 +114,6 @@ OLED_BLOCK_TYPE oled_dirty          = 0;
 bool            oled_initialized    = false;
 bool            oled_active         = false;
 bool            oled_scrolling      = false;
-bool            oled_inverted       = false;
 uint8_t         oled_brightness     = OLED_BRIGHTNESS;
 oled_rotation_t oled_rotation       = 0;
 uint8_t         oled_rotation_width = 0;
@@ -692,30 +690,6 @@ bool oled_scroll_off(void) {
     return !oled_scrolling;
 }
 
-bool oled_invert(bool invert) {
-    if (!oled_initialized) {
-        return oled_inverted;
-    }
-
-    if (invert && !oled_inverted) {
-        static const uint8_t PROGMEM display_inverted[] = {I2C_CMD, INVERT_DISPLAY};
-        if (I2C_TRANSMIT_P(display_inverted) != I2C_STATUS_SUCCESS) {
-            print("oled_invert cmd failed\n");
-            return oled_inverted;
-        }
-        oled_inverted = true;
-    } else if (!invert && oled_inverted) {
-        static const uint8_t PROGMEM display_normal[] = {I2C_CMD, NORMAL_DISPLAY};
-        if (I2C_TRANSMIT_P(display_normal) != I2C_STATUS_SUCCESS) {
-            print("oled_invert cmd failed\n");
-            return oled_inverted;
-        }
-        oled_inverted = false;
-    }
-
-    return oled_inverted;
-}
-
 uint8_t oled_max_chars(void) {
     if (!HAS_FLAGS(oled_rotation, OLED_ROTATION_90)) {
         return OLED_DISPLAY_WIDTH / OLED_FONT_WIDTH;

drivers/oled/oled_driver.h

@@ -313,10 +313,6 @@ bool oled_scroll_left(void);
 // Returns true if the screen was not scrolling or stops scrolling
 bool oled_scroll_off(void);
 
-// Inverts the display
-// Returns true if the screen was or is inverted
-bool oled_invert(bool invert);
-
 // Returns the maximum number of characters that will fit on a line
 uint8_t oled_max_chars(void);
 

drivers/qwiic/micro_oled.c

@@ -70,25 +70,28 @@ static uint8_t micro_oled_screen_current[LCDWIDTH * LCDHEIGHT / 8] = {0};
    D6 D6.............D6       /
    D7 D7.............D7  ----
   */
-
-#if LCDWIDTH == 64
-#    if LCDHEIGHT == 48
+#ifdef NO_LCD_SPLASH
+// do not initialize with a splash screen
+static uint8_t micro_oled_screen_buffer[LCDWIDTH * LCDHEIGHT / 8] = {0};
+#else
+#    if LCDWIDTH == 64
+#        if LCDHEIGHT == 48
 static uint8_t micro_oled_screen_buffer[] = {
     // QMK Logo - generated at http://www.majer.ch/lcd/adf_bitmap.php
     // 64x48 image
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xF0, 0x00, 0x00, 0x00, 0xF0, 0xF0, 0x00, 0x00, 0x00, 0xF0, 0xF0, 0x00, 0x00, 0x00, 0xF0, 0xF0, 0x00, 0x00, 0x00, 0xF0, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x60, 0x60, 0x60, 0xF8, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0x1F, 0x1F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1F, 0x1F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1F, 0x1F, 0xFF, 0xFF, 0xFF, 0xFE, 0xFE, 0xF8, 0x60, 0x60, 0x60, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8C, 0x8C, 0x8C, 0x8C, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x8C, 0x8C, 0x8C, 0x8C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x31, 0x31, 0x31, 0x31, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xF8, 0xF1, 0xE3, 0xE7, 0xCF, 0xCF, 0xCF, 0xCF, 0x00, 0x00, 0xCF, 0xCF, 0xCF, 0xC7, 0xE7, 0xE3, 0xF1, 0xF8, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x31, 0x31, 0x31, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 0x06, 0x06, 0x1F, 0x7F, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF8, 0xF8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x7F, 0x1F, 0x06, 0x06, 0x06, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x0F, 0x00, 0x00, 0x00, 0x0F, 0x0F, 0x00, 0x00, 0x00, 0x0F, 0x0F, 0x00, 0x00, 0x00, 0x0F, 0x0F, 0x00, 0x00, 0x00, 0x0F, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-#    endif
-#elif LCDWIDTH == 128
-#    if LCDHEIGHT == 32
+#        endif
+#    elif LCDWIDTH == 128
+#        if LCDHEIGHT == 32
 static uint8_t micro_oled_screen_buffer[LCDWIDTH * LCDHEIGHT / 8] = {
     // 128x32 qmk image
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xE0, 0xE0, 0xFC, 0xFC, 0xE0, 0xFC, 0xFC, 0xE0, 0xF0, 0xFC, 0xE0, 0xE0, 0xFC, 0xE0, 0xE0, 0xFC, 0xFC, 0xE0, 0xE0, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x10, 0x10, 0x30, 0xE0, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xB2, 0xB2, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0x03, 0xFF, 0xFF, 0xFF, 0x03, 0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0x03, 0xFF, 0xFF, 0xFF, 0xFF, 0xB7, 0xB2, 0xB2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x02, 0x02, 0x03, 0x01, 0x00, 0x06, 0x1F, 0x10, 0x10, 0x10, 0x1F, 0x06, 0x00, 0x03, 0x1E, 0x18, 0x0F, 0x01, 0x0F, 0x18, 0x1E, 0x01, 0x00, 0x0F, 0x1F, 0x12, 0x02, 0x12, 0x13, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x0E, 0x1F, 0x12, 0x02, 0x12, 0x13, 0x00, 0x00, 0x1F, 0x10, 0x10, 0x10, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x4D, 0x4D, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xF8, 0xF9, 0xF3, 0xF3, 0xC0, 0x80, 0xF3, 0xF3, 0xF3, 0xF9, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xED, 0x4D, 0x4D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x20, 0x10, 0x10, 0xE0, 0xC0, 0x00, 0x70, 0xC0, 0x00, 0x80, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x0C, 0x04, 0x04, 0x04, 0x04, 0x1C, 0xF0, 0x00, 0x00, 0xFC, 0x0C, 0x38, 0xE0, 0x00, 0x00, 0xC0, 0x38, 0x0C, 0xFC, 0x00, 0x00, 0xFC, 0xFC, 0x60, 0x90, 0x0C, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x07, 0x07, 0x3F, 0x3F, 0x07, 0x3F, 0x3F, 0x07, 0x0F, 0x3F, 0x07, 0x07, 0x3F, 0x07, 0x07, 0x3F, 0x3F, 0x07, 0x07, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x06, 0x04, 0x04, 0x07, 0x01, 0x00, 0x00, 0x13, 0x1E, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x06, 0x04, 0x04, 0x04, 0x04, 0x07, 0x0D, 0x08, 0x00, 0x07, 0x00, 0x00, 0x01, 0x07, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x07, 0x07, 0x00, 0x01, 0x03, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-#    elif LCDHEIGHT == 64
+#        elif LCDHEIGHT == 64
 static uint8_t micro_oled_screen_buffer[LCDWIDTH * LCDHEIGHT / 8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xC0, 0x00, 0x00, 0xC0, 0xC0, 0x00, 0x00, 0xC0, 0xC0, 0x00, 0x00, 0xC0, 0xC0, 0x00, 0x00, 0xC0, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xC0, 0xC0, 0xC0, 0xF8, 0xFC, 0xFC, 0xFE, 0xFE, 0xFF, 0x7F, 0x7E, 0xFE, 0xFF, 0xFF, 0xFE, 0xFE, 0x7F, 0x7F, 0xFE, 0xFE, 0xFF, 0xFF, 0xFE, 0x7E, 0x7F, 0xFF, 0xFE, 0xFE, 0xFC, 0xFC, 0xF8, 0xC0, 0xC0, 0xC0, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0x88, 0x88, 0xDD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDD, 0x88, 0x88, 0x88, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -99,10 +102,11 @@ static uint8_t micro_oled_screen_buffer[LCDWIDTH * LCDHEIGHT / 8] = {0x00, 0x00,
                                                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x03, 0x02, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 // TODO: generate bitmap of QMK logo here
-#    endif
-#else
+#        endif
+#    else
 // catchall for custom screen sizes
 static uint8_t micro_oled_screen_buffer[LCDWIDTH * LCDHEIGHT / 8] = {0};
+#    endif
 #endif
 
 void micro_oled_init(void) {
@@ -145,7 +149,7 @@ void micro_oled_init(void) {
 #endif
 
     send_command(MEMORYMODE);
-    send_command(0x10);
+    send_command(0x02);   //  0x02 = 10b, Page addressing mode
 
     send_command(SETCOMPINS);  // 0xDA
     if (LCDHEIGHT > 32) {
@@ -250,13 +254,14 @@ void send_buffer(void) {
             if (micro_oled_screen_buffer[i * LCDWIDTH + j] != micro_oled_screen_current[i * LCDWIDTH + j]) {
                 if (page_addr != i) {
                     set_page_address(i);
+                    page_addr = i;
                 }
                 if (col_addr != j) {
                     set_column_address(j);
+                    col_addr = j + 1;
                 }
                 send_data(micro_oled_screen_buffer[i * LCDWIDTH + j]);
                 micro_oled_screen_current[i * LCDWIDTH + j] = micro_oled_screen_buffer[i * LCDWIDTH + j];
-                col_addr                                    = j + 1;
             }
         }
     }

drivers/serial.h

@@ -1,46 +0,0 @@
-/* Copyright 2021 QMK
- *
- * 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 <stdint.h>
-#include <stdbool.h>
-
-#include <transactions.h>
-
-// initiator is transaction start side
-void soft_serial_initiator_init(void);
-// target is interrupt accept side
-void soft_serial_target_init(void);
-
-// initiator result
-#define TRANSACTION_END 0
-#define TRANSACTION_NO_RESPONSE 0x1
-#define TRANSACTION_DATA_ERROR 0x2
-#define TRANSACTION_TYPE_ERROR 0x4
-int soft_serial_transaction(int sstd_index);
-
-// 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
-int soft_serial_get_and_clean_status(int sstd_index);

keyboards/4pplet/eagle_viper_rep/info.json

@@ -0,0 +1,77 @@
+{
+    "keyboard_name": "Eagle/Viper Rep",
+    "url": "https://github.com/4pplet/eagle_viper_rep",
+    "maintainer": "4pplet",
+    "width": 15,
+    "height": 5,
+    "layouts": {
+        "LAYOUT_all": {
+            "layout": [
+                { "label": "Esc", "x": 0, "y": 0 },
+                { "label": "!", "x": 1, "y": 0 },
+                { "label": "@", "x": 2, "y": 0 },
+                { "label": "#", "x": 3, "y": 0 },
+                { "label": "$", "x": 4, "y": 0 },
+                { "label": "%", "x": 5, "y": 0 },
+                { "label": "^", "x": 6, "y": 0 },
+                { "label": "&", "x": 7, "y": 0 },
+                { "label": "*", "x": 8, "y": 0 },
+                { "label": "(", "x": 9, "y": 0 },
+                { "label": ")", "x": 10, "y": 0 },
+                { "label": "_", "x": 11, "y": 0 },
+                { "label": "+", "x": 12, "y": 0 },
+                { "label": "|", "x": 13, "y": 0 },
+                { "label": "~", "x": 14, "y": 0 },
+                { "label": "Tab", "x": 0, "y": 1, "w": 1.5 },
+                { "label": "Q", "x": 1.5, "y": 1 },
+                { "label": "W", "x": 2.5, "y": 1 },
+                { "label": "E", "x": 3.5, "y": 1 },
+                { "label": "R", "x": 4.5, "y": 1 },
+                { "label": "T", "x": 5.5, "y": 1 },
+                { "label": "Y", "x": 6.5, "y": 1 },
+                { "label": "U", "x": 7.5, "y": 1 },
+                { "label": "I", "x": 8.5, "y": 1 },
+                { "label": "O", "x": 9.5, "y": 1 },
+                { "label": "P", "x": 10.5, "y": 1 },
+                { "label": "{", "x": 11.5, "y": 1 },
+                { "label": "}", "x": 12.5, "y": 1 },
+                { "label": "Backsp.", "x": 13.5, "y": 1, "w": 1.5 },
+                { "label": "Caps Lock", "x": 0, "y": 2, "w": 1.75 },
+                { "label": "A", "x": 1.75, "y": 2 },
+                { "label": "S", "x": 2.75, "y": 2 },
+                { "label": "D", "x": 3.75, "y": 2 },
+                { "label": "F", "x": 4.75, "y": 2 },
+                { "label": "G", "x": 5.75, "y": 2 },
+                { "label": "H", "x": 6.75, "y": 2 },
+                { "label": "J", "x": 7.75, "y": 2 },
+                { "label": "K", "x": 8.75, "y": 2 },
+                { "label": "L", "x": 9.75, "y": 2 },
+                { "label": ":", "x": 10.75, "y": 2 },
+                { "label": "\"", "x": 11.75, "y": 2 },
+                { "label": "Enter", "x": 12.75, "y": 2, "w": 2.25 },
+                { "label": "Shift", "x": 0, "y": 3, "w": 1.25 },
+                { "label": "|", "x": 1.25, "y": 3 },
+                { "label": "Z", "x": 2.25, "y": 3 },
+                { "label": "X", "x": 3.25, "y": 3 },
+                { "label": "C", "x": 4.25, "y": 3 },
+                { "label": "V", "x": 5.25, "y": 3 },
+                { "label": "B", "x": 6.25, "y": 3 },
+                { "label": "N", "x": 7.25, "y": 3 },
+                { "label": "M", "x": 8.25, "y": 3 },
+                { "label": "<", "x": 9.25, "y": 3 },
+                { "label": ">", "x": 10.25, "y": 3 },
+                { "label": "?", "x": 11.25, "y": 3 },
+                { "label": "Shift", "x": 12.25, "y": 3, "w": 1.75 },
+                { "label": "Fn", "x": 14, "y": 3, "w": 1 },
+                { "label": "Ctrl", "x": 0, "y": 4, "w": 1.25 },
+                { "label": "Win", "x": 1.25, "y": 4, "w": 1.25 },
+                { "label": "Alt", "x": 2.5, "y": 4, "w": 1.25 },
+                { "label": "Space", "x": 3.75, "y": 4, "w": 6.25 },
+                { "label": "Alt", "x": 10, "y": 4, "w": 1.25 },
+                { "label": "Menu", "x": 11.25, "y": 4, "w": 1.25 },
+                { "label": "Win", "x": 12.5, "y": 4, "w": 1.25 },
+                { "label": "Ctrl", "x": 13.75, "y": 4, "w": 1.25 }
+            ]
+        }
+    }
+}

keyboards/4pplet/eagle_viper_rep/keymaps/default/keymap.c

@@ -0,0 +1,34 @@
+/*
+Copyright 2021 Stefan Sundin "4pplet" <4pplet@protonmail.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/>.
+*/
+#include QMK_KEYBOARD_H
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+// main layer
+[0] = LAYOUT_all(
+  KC_ESC,   KC_1,     KC_2,     KC_3,     KC_4,     KC_5,       KC_6,      KC_7,      KC_8,      KC_9,       KC_0,    KC_MINS, KC_EQL,  KC_BSLS, KC_GRV,
+  KC_TAB,   KC_Q,     KC_W,     KC_E,     KC_R,     KC_T,       KC_Y,      KC_U,      KC_I,      KC_O,       KC_P,    KC_LBRC, KC_RBRC, KC_BSPC,
+  KC_LCTRL, KC_A,     KC_S,     KC_D,     KC_F,     KC_G,       KC_H,      KC_J,      KC_K,      KC_L,       KC_SCLN, KC_QUOT, KC_NUHS, KC_ENT,
+  KC_LSFT,  KC_NUBS,  KC_Z,     KC_X,     KC_C,     KC_V,       KC_B,      KC_N,      KC_M,      KC_COMM,    KC_DOT,  KC_SLSH, KC_RSFT, MO(1),
+  KC_LCTL,  KC_LGUI,  KC_LALT,                           KC_SPC,                                 KC_NO,      KC_RALT, KC_RGUI, MO(1)),
+  // basic function layer
+[1] = LAYOUT_all(
+  RESET,    KC_F1,    KC_F2,    KC_F3,    KC_F4,     KC_F5,     KC_F6,     KC_F7,     KC_F8,     KC_F9,      KC_F10,  KC_F11,   KC_F12,  KC_TRNS, KC_TRNS,
+  KC_TRNS,  KC_TRNS,  KC_UP,    KC_TRNS,  KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,    KC_TRNS, KC_TRNS,  KC_TRNS, KC_TRNS,
+  KC_TRNS,  KC_LEFT,  KC_DOWN,  KC_RIGHT, KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,    KC_TRNS, KC_TRNS,  KC_TRNS, KC_TRNS,
+  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,    KC_TRNS, KC_TRNS,  KC_TRNS, KC_TRNS,
+  KC_TRNS,  KC_TRNS,  KC_TRNS,                        KC_TRNS,                            KC_TRNS, KC_TRNS,  KC_TRNS, KC_TRNS)
+};

keyboards/4pplet/eagle_viper_rep/keymaps/via/keymap.c

@@ -0,0 +1,55 @@
+/*
+Copyright 2021 Stefan Sundin "4pplet" <4pplet@protonmail.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/>.
+*/
+#include QMK_KEYBOARD_H
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+// main layer
+[0] = LAYOUT_all(
+  KC_ESC,   KC_1,     KC_2,     KC_3,     KC_4,     KC_5,       KC_6,      KC_7,      KC_8,      KC_9,       KC_0,    KC_MINS, KC_EQL,  KC_BSLS, KC_GRV,
+  KC_TAB,   KC_Q,     KC_W,     KC_E,     KC_R,     KC_T,       KC_Y,      KC_U,      KC_I,      KC_O,       KC_P,    KC_LBRC, KC_RBRC, KC_BSPC,
+  KC_LCTRL, KC_A,     KC_S,     KC_D,     KC_F,     KC_G,       KC_H,      KC_J,      KC_K,      KC_L,       KC_SCLN, KC_QUOT, KC_NUHS, KC_ENT,
+  KC_LSFT,  KC_NUBS,  KC_Z,     KC_X,     KC_C,     KC_V,       KC_B,      KC_N,      KC_M,      KC_COMM,    KC_DOT,  KC_SLSH, KC_RSFT, MO(1),
+  KC_LCTL,  KC_LGUI,  KC_LALT,                           KC_SPC,                                 KC_NO,      KC_RALT, KC_RGUI, MO(1)),
+// basic function layer
+[1] = LAYOUT_all(
+  RESET,    KC_F1,    KC_F2,    KC_F3,    KC_F4,     KC_F5,     KC_F6,     KC_F7,     KC_F8,     KC_F9,      KC_F10,  KC_F11,   KC_F12,  KC_TRNS, KC_TRNS,
+  KC_TRNS,  KC_TRNS,  KC_UP,    KC_TRNS,  KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,    KC_TRNS, KC_TRNS,  KC_TRNS, KC_TRNS,
+  KC_TRNS,  KC_LEFT,  KC_DOWN,  KC_RIGHT, KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,    KC_TRNS, KC_TRNS,  KC_TRNS, KC_TRNS,
+  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,    KC_TRNS, KC_TRNS,  KC_TRNS, KC_TRNS,
+  KC_TRNS,  KC_TRNS,  KC_TRNS,                          KC_TRNS,                             KC_TRNS, KC_TRNS,  KC_TRNS, KC_TRNS),
+// extra layer for VIA
+[2] = LAYOUT_all(
+  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,    KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS, KC_TRNS,
+  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,    KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,    KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,    KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+  KC_TRNS,  KC_TRNS,  KC_TRNS,                          KC_TRNS,                             KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS),
+// extra layer for VIA
+[3] = LAYOUT_all(
+  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,    KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS, KC_TRNS,
+  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,    KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,    KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,    KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+  KC_TRNS,  KC_TRNS,  KC_TRNS,                          KC_TRNS,                             KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS),
+// extra layer for VIA
+[4] = LAYOUT_all(
+  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,    KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS, KC_TRNS,
+  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,    KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,    KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,    KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+  KC_TRNS,  KC_TRNS,  KC_TRNS,                         KC_TRNS,                             KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS)
+};

keyboards/4pplet/eagle_viper_rep/readme.md

@@ -0,0 +1,19 @@
+# Viper/Eagle REP Rev A
+
+A alternative PCB for Viper and Eagle V2 and V3
+
+* Keyboard Maintainer: [4pplet](https://github.com/4pplet)
+* Hardware Supported: Viper/Eagle REP Rev A
+
+Make example for this keyboard (after setting up your build environment):
+
+    make 4pplet/eagle_viper_rep/rev_a:default
+
+See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs).
+
+How to enter bootloader (DFU):
+* Press and hold the button on the keyboard (the small one on the same side as the MCU) for more than 1 second. The keyboard will then enter bootloader (DFU) mode and it's ready to flash the firmware.
+* Note: If holding the button a shorter time, the keyboard will just reset. If you want to exit bootloader mode without flashing a firmware, dissconnect the keyboard from your PC and reconnect it.
+
+Alternative option if the firmware is already pre-flashed:
+* Unplug your keyboard, hold down the Spacebar and B at the same time, plug in your keyboard and wait a second before releasing the keys. Bootmagic lite is enabled by default.

keyboards/4pplet/eagle_viper_rep/rev_a/chconf.h

@@ -1,4 +1,4 @@
-/* Copyright 2021 Simon Arlott
+/* Copyright 2020 QMK
  *
  * 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
@@ -13,7 +13,11 @@
  * 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
 
-// The platform is 32-bit, so prefer 32-bit timers to avoid overflow
-#define FAST_TIMER_T_SIZE 32
+#define CH_CFG_ST_FREQUENCY 10000
+
+#define CH_CFG_ST_RESOLUTION 16
+
+#include_next <chconf.h>

keyboards/4pplet/eagle_viper_rep/rev_a/config.h

@@ -0,0 +1,72 @@
+/*
+Copyright 2021 Stefan Sundin "4pplet" <4pplet@protonmail.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/>.
+*/
+#pragma once
+
+/* USB Device descriptor parameter */
+#define VENDOR_ID       0x4444
+#define PRODUCT_ID      0x0007
+#define DEVICE_VER      0x0001
+#define MANUFACTURER    4pplet
+#define PRODUCT         Eagle Viper REP Rev A
+
+#define MATRIX_ROWS 10
+#define MATRIX_COLS 7
+
+#define MATRIX_COL_PINS { A0, B1, B0, A4, B5, B4, B3 }
+#define MATRIX_ROW_PINS { A2, A1, B8, A10, C15, A15, B7, B6, C14, C13}
+#define DIODE_DIRECTION COL2ROW
+
+/* In switch leds */
+#define BACKLIGHT_PIN           A3
+#define BACKLIGHT_PWM_DRIVER    PWMD2
+#define BACKLIGHT_PWM_CHANNEL   4
+#define BACKLIGHT_PAL_MODE      2
+#define BACKLIGHT_ON_STATE      1
+#define BACKLIGHT_LEVELS        10
+#define BACKLIGHT_BREATHING     TRUE
+
+/* Underglow */
+#define RGB_DI_PIN  A7
+#define WS2812_SPI  SPID1
+#define WS2812_SPI_MOSI_PAL_MODE 0
+#define WS2812_SPI_SCK_PIN A5
+#define WS2812_SPI_SCK_PAL_MODE 0
+#define RGBLED_NUM  16
+#define RGBLIGHT_ANIMATIONS
+
+/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
+#define LOCKING_SUPPORT_ENABLE
+/* Locking resynchronize hack */
+#define LOCKING_RESYNC_ENABLE
+
+/* Indicator leds */
+#define LOCK_LIGHTS     TRUE
+#define DISPLAY_LAYERS  TRUE
+#define CAPS_PIN        B2
+#define NUM_PIN         B12
+#define SCROLL_PIN      B13
+#define LAYER_1         B14
+#define LAYER_2         B15
+#define LAYER_3         A8
+#define LAYER_4         A9
+#define LAYER_5         B9
+
+/* Set 0 if debouncing isn't needed */
+#define DEBOUNCE    5
+
+/* Added extra layer for use of layer leds */
+#define DYNAMIC_KEYMAP_LAYER_COUNT 5

keyboards/4pplet/eagle_viper_rep/rev_a/halconf.h

@@ -0,0 +1,25 @@
+/* Copyright 2020 QMK
+ *
+ * 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 HAL_USE_I2C FALSE
+
+#define HAL_USE_PWM TRUE
+
+#define HAL_USE_SPI TRUE
+
+#include_next <halconf.h>

keyboards/4pplet/eagle_viper_rep/rev_a/mcuconf.h

@@ -0,0 +1,34 @@
+/* Copyright 2020 QMK
+ *
+ * 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/>.
+ */
+
+/*
+ * This file was auto-generated by:
+ *    `qmk chibios-confmigrate -i keyboards/cannonkeys/db60/mcuconf.h -r platforms/chibios/GENERIC_STM32_F072XB/configs/mcuconf.h`
+ */
+
+#pragma once
+
+#include_next <mcuconf.h>
+
+#undef STM32_PWM_USE_TIM2
+#define STM32_PWM_USE_TIM2 TRUE
+
+#undef STM32_SPI_USE_SPI1
+#define STM32_SPI_USE_SPI1 TRUE
+
+/* Reallocate the SysTick timer from TIM2 to TIM3, TIM2 is used for in switch leds */
+#undef STM32_ST_USE_TIMER
+#define STM32_ST_USE_TIMER 3

keyboards/4pplet/eagle_viper_rep/rev_a/readme.md

@@ -0,0 +1,19 @@
+# Viper/Eagle REP Rev A
+
+A alternative PCB for Viper and Eagle V2 and V3
+
+* Keyboard Maintainer: [4pplet](https://github.com/4pplet)
+* Hardware Supported: Viper/Eagle REP Rev A
+
+Make example for this keyboard (after setting up your build environment):
+
+    make 4pplet/eagle_viper_rep/rev_a:default
+
+See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs).
+
+How to enter bootloader (DFU):
+* Press and hold the button on the keyboard (the small one on the same side as the MCU) for more than 1 second. The keyboard will then enter bootloader (DFU) mode and it's ready to flash the firmware.
+* Note: If holding the button a shorter time, the keyboard will just reset. If you want to exit bootloader mode without flashing a firmware, dissconnect the keyboard from your PC and reconnect it.
+
+Alternative option if the firmware is already pre-flashed:
+* Unplug your keyboard, hold down the Spacebar and B at the same time, plug in your keyboard and wait a second before releasing the keys. Bootmagic lite is enabled by default.

keyboards/4pplet/eagle_viper_rep/rev_a/rev_a.c

@@ -0,0 +1,108 @@
+/*
+Copyright 2021 Stefan Sundin "4pplet" <4pplet@protonmail.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/>.
+*/
+#include "rev_a.h"
+
+void board_init(void) {
+    setPinInputHigh(CAPS_PIN);
+    setPinInputHigh(SCROLL_PIN);
+    setPinInputHigh(NUM_PIN);
+}
+
+/* Set indicator leds to indicate lock states */
+bool led_update_kb(led_t led_state) {
+    bool res = led_update_user(led_state);
+    if(res && LOCK_LIGHTS) {
+        if(led_state.caps_lock){
+            setPinOutput(CAPS_PIN);
+            writePin(CAPS_PIN, 0);
+        }
+        else
+            setPinInputHigh(CAPS_PIN);
+        if(led_state.scroll_lock){
+            setPinOutput(SCROLL_PIN);
+            writePin(SCROLL_PIN, 0);
+        }
+        else
+            setPinInputHigh(SCROLL_PIN);
+        if(led_state.num_lock){
+            setPinOutput(NUM_PIN);
+            writePin(NUM_PIN, 0);
+        }
+        else
+            setPinInputHigh(NUM_PIN);
+    }
+    return res;
+}
+
+layer_state_t layer_state_set_kb(layer_state_t state) {
+    state = layer_state_set_user(state);
+    if(DISPLAY_LAYERS){
+        setLayerLed(state);
+    }
+    return state;
+}
+/* Set indicator leds to indicate which layer is active */
+void setLayerLed(layer_state_t state){
+    switch(get_highest_layer(state)){
+        case 0 :
+            setPinOutput(LAYER_1);
+            writePin(LAYER_1, 0);
+            setPinInputHigh(LAYER_2);
+            setPinInputHigh(LAYER_3);
+            setPinInputHigh(LAYER_4);
+            setPinInputHigh(LAYER_5);
+            break;
+        case 1 :
+            setPinOutput(LAYER_2);
+            writePin(LAYER_2, 0);
+            setPinInputHigh(LAYER_1);
+            setPinInputHigh(LAYER_3);
+            setPinInputHigh(LAYER_4);
+            setPinInputHigh(LAYER_5);
+            break;
+        case 2 :
+            setPinOutput(LAYER_3);
+            writePin(LAYER_3, 0);
+            setPinInputHigh(LAYER_1);
+            setPinInputHigh(LAYER_2);
+            setPinInputHigh(LAYER_4);
+            setPinInputHigh(LAYER_5);
+            break;
+        case 3 :
+            writePin(LAYER_4, 0);
+            setPinInputHigh(LAYER_5);
+            setPinInputHigh(LAYER_1);
+            setPinInputHigh(LAYER_2);
+            setPinInputHigh(LAYER_3);
+            setPinOutput(LAYER_4);
+            break;
+        case 4 :
+            setPinOutput(LAYER_5);
+            writePin(LAYER_5, 0);
+            setPinInputHigh(LAYER_1);
+            setPinInputHigh(LAYER_2);
+            setPinInputHigh(LAYER_3);
+            setPinInputHigh(LAYER_4);
+            break;
+        default :
+            setPinInputHigh(LAYER_1);
+            setPinInputHigh(LAYER_2);
+            setPinInputHigh(LAYER_3);
+            setPinInputHigh(LAYER_4);
+            setPinInputHigh(LAYER_5);
+    }
+}

keyboards/4pplet/eagle_viper_rep/rev_a/rev_a.h

@@ -0,0 +1,41 @@
+/*
+Copyright 2021 Stefan Sundin "4pplet" <4pplet@protonmail.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/>.
+*/
+#pragma once
+
+#include "quantum.h"
+
+void setLayerLed(layer_state_t state);
+
+#define LAYOUT_all( \
+    k00, k10, k01, k11, k02, k12, k03, k13, k04, k14, k05, k15, k06, k16, k36, \
+    k20, k30, k21, k31, k22, k32, k23, k33, k24, k34, k25, k35, k26, k56,\
+    k40, k50, k41, k51, k42, k52, k43, k53, k44, k54, k45, k55, k46, k76,\
+    k60, k70, k61, k71, k62, k72, k63, k73, k64, k74, k65, k75, k66, k96,\
+    k80, k90, k91, k93, k94, k85, k95, k86  \
+) \
+{ \
+    {k00, k01, k02, k03, k04, k05, k06}, \
+    {k10, k11, k12, k13, k14, k15, k16}, \
+    {k20, k21, k22, k23, k24, k25, k26}, \
+    {k30, k31, k32, k33, k34, k35, k36}, \
+    {k40, k41, k42, k43, k44, k45, k46}, \
+    {k50, k51, k52, k53, k54, k55, k56}, \
+    {k60, k61, k62, k63, k64, k65, k66}, \
+    {k70, k71, k72, k73, k74, k75, k76}, \
+    {k80, KC_NO, KC_NO, KC_NO, KC_NO, k85, k86}, \
+    {k90, k91, KC_NO, k93, k94, k95, k96}  \
+}

keyboards/4pplet/eagle_viper_rep/rev_a/rules.mk

@@ -0,0 +1,23 @@
+# MCU name
+MCU = STM32F072
+
+# Build Options
+#   comment out to disable the options.
+#
+BOOTMAGIC_ENABLE = lite # Virtual DIP switch configuration
+MOUSEKEY_ENABLE = yes   # Mouse keys
+EXTRAKEY_ENABLE = yes   # Audio control and System control
+CONSOLE_ENABLE = yes    # Console for debug
+COMMAND_ENABLE = yes    # Commands for debug and configuration
+SLEEP_LED_ENABLE = no  # Breathing sleep LED during USB suspend
+NKRO_ENABLE = yes       # USB Nkey Rollover
+BACKLIGHT_ENABLE = yes
+BACKLIGHT_DRIVER = pwm
+RGBLIGHT_ENABLE = yes
+WS2812_DRIVER = spi
+
+# Wildcard to allow APM32 MCU
+DFU_SUFFIX_ARGS = -p FFFF -v FFFF
+
+# Enter lower-power sleep mode when on the ChibiOS idle thread
+OPT_DEFS += -DCORTEX_ENABLE_WFI_IDLE=TRUE

keyboards/basekeys/trifecta/config.h

@@ -80,11 +80,11 @@
 #   define RGB_MATRIX_KEYPRESSES // reacts to keypresses
 // #   define RGB_MATRIX_KEYRELEASES // reacts to keyreleases (instead of keypresses)
 // #   define RGB_DISABLE_AFTER_TIMEOUT 0 // number of ticks to wait until disabling effects
-//#   define RGB_DISABLE_WHEN_USB_SUSPENDED // turn off effects when suspended
+//#   define RGB_DISABLE_WHEN_USB_SUSPENDED true // turn off effects when suspended
 #   define RGB_MATRIX_FRAMEBUFFER_EFFECTS
 #   define RGB_MATRIX_LED_PROCESS_LIMIT (DRIVER_LED_TOTAL + 4) / 5 // limits the number of LEDs to process in an animation per task run (increases keyboard responsiveness)
 #   define RGB_MATRIX_LED_FLUSH_LIMIT 16 // limits in milliseconds how frequently an animation will update the LEDs. 16 (16ms) is equivalent to limiting to 60fps (increases keyboard responsiveness)
-#    define RGB_MATRIX_MAXIMUM_BRIGHTNESS 150 // limits maximum brightness of LEDs to 150 out of 255. Higher may cause the controller to crash.
+#    define RGB_MATRIX_MAXIMUM_BRIGHTNESS 150 // limits maximum brightness of LEDs to 150 out of 255. Higher may cause the controller to crash. 
 #    define RGB_MATRIX_HUE_STEP 8
 #    define RGB_MATRIX_SAT_STEP 8
 #    define RGB_MATRIX_VAL_STEP 8

keyboards/bm40hsrgb/config.h

@@ -50,6 +50,6 @@
 #ifdef RGB_DI_PIN
     #define RGB_MATRIX_KEYPRESSES // reacts to keypresses
 #endif
-#ifdef RGB_MATRIX_ENABLE
-#    define RGB_DISABLE_WHEN_USB_SUSPENDED // turn off effects when suspended
+#ifndef RGB_DISABLE_WHEN_USB_SUSPENDED
+#    define RGB_DISABLE_WHEN_USB_SUSPENDED true // turn off effects when suspended
 #endif

keyboards/bm68rgb/keymaps/peepeetee/config.h

@@ -64,7 +64,7 @@
 // #define RGBLIGHT_SAT_STEP 25        // Units to step when in/decreasing saturation
 // #define RGBLIGHT_VAL_STEP 12        // Units to step when in/decreasing value (brightness)
 // #define RGB_DISABLE_AFTER_TIMEOUT 0   // number of ticks to wait until disabling effects
-// #define RGB_DISABLE_WHEN_USB_SUSPENDED // turn off effects when suspended
+// #define RGB_DISABLE_WHEN_USB_SUSPENDED false // turn off effects when suspended
 // #define RGB_MATRIX_LED_PROCESS_LIMIT (DRIVER_LED_TOTAL + 4) / 5 // limits the number of LEDs to process in an animation per task run (increases keyboard responsiveness)
 // #define RGB_MATRIX_LED_FLUSH_LIMIT 16 // limits in milliseconds how frequently an animation will update the LEDs. 16 (16ms) is equivalent to limiting to 60fps (increases keyboard responsiveness)
 // #define RGBLIGHT_ANIMATIONS             // Run RGB animations

keyboards/boardsource/the_mark/config.h

@@ -59,7 +59,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define DRIVER_LED_TOTAL 24 // Number of LEDs
 #define RGB_MATRIX_MAXIMUM_BRIGHTNESS 200
 #    ifndef RGB_DISABLE_WHEN_USB_SUSPENDED
-#    define RGB_DISABLE_WHEN_USB_SUSPENDED // turn off effects when suspended
+#    define RGB_DISABLE_WHEN_USB_SUSPENDED true // turn off effects when suspended
 #    endif
 #endif
 

keyboards/checkerboards/nop60/info.json

@@ -1,143 +1,15 @@
 {
     "keyboard_name": "nop60",
-    "maintainer": "nasp",
-    "height": 5,
-    "width": 15,
     "url": "",
+    "maintainer": "nasp",
+    "width": 15,
+    "height": 5,
     "layouts": {
         "LAYOUT": {
-            "layout": [
-                { "label": "Esc", "x": 0, "y": 0 },
-                { "label": "!", "x": 1, "y": 0 },
-                { "label": "@", "x": 2, "y": 0 },
-                { "label": "#", "x": 3, "y": 0 },
-                { "label": "$", "x": 4, "y": 0 },
-                { "label": "%", "x": 5, "y": 0 },
-                { "label": "^", "x": 6, "y": 0 },
-                { "label": "&", "x": 7, "y": 0 },
-                { "label": "*", "x": 8, "y": 0 },
-                { "label": "(", "x": 9, "y": 0 },
-                { "label": ")", "x": 10, "y": 0 },
-                { "label": "_", "x": 11, "y": 0 },
-                { "label": "+", "x": 12, "y": 0 },
-                { "label": "~", "x": 13, "y": 0 },
-                { "label": "Bksp", "x": 14, "y": 0 },
-                { "label": "Tab", "w": 1.5, "x": 0, "y": 1 },
-                { "label": "Q", "x": 1.5, "y": 1 },
-                { "label": "W", "x": 2.5, "y": 1 },
-                { "label": "E", "x": 3.5, "y": 1 },
-                { "label": "R", "x": 4.5, "y": 1 },
-                { "label": "T", "x": 5.5, "y": 1 },
-                { "label": "Y", "x": 6.5, "y": 1 },
-                { "label": "U", "x": 7.5, "y": 1 },
-                { "label": "I", "x": 8.5, "y": 1 },
-                { "label": "O", "x": 9.5, "y": 1 },
-                { "label": "P", "x": 10.5, "y": 1 },
-                { "label": "{", "x": 11.5, "y": 1 },
-                { "label": "}", "x": 12.5, "y": 1 },
-                { "label": "|", "w": 1.5, "x": 13.5, "y": 1 },
-                { "label": "Caps Lock", "w": 1.75, "x": 0, "y": 2 },
-                { "label": "A", "x": 1.75, "y": 2 },
-                { "label": "S", "x": 2.75, "y": 2 },
-                { "label": "D", "x": 3.75, "y": 2 },
-                { "label": "F", "x": 4.75, "y": 2 },
-                { "label": "G", "x": 5.75, "y": 2 },
-                { "label": "H", "x": 6.75, "y": 2 },
-                { "label": "J", "x": 7.75, "y": 2 },
-                { "label": "K", "x": 8.75, "y": 2 },
-                { "label": "L", "x": 9.75, "y": 2 },
-                { "label": ":", "x": 10.75, "y": 2 },
-                { "label": "\"", "x": 11.75, "y": 2 },
-                { "label": "Enter", "w": 2.25, "x": 12.75, "y": 2 },
-                { "label": "Shift", "w": 2.25, "x": 0, "y": 3 },
-                { "label": "Z", "x": 2.25, "y": 3 },
-                { "label": "X", "x": 3.25, "y": 3 },
-                { "label": "C", "x": 4.25, "y": 3 },
-                { "label": "V", "x": 5.25, "y": 3 },
-                { "label": "B", "x": 6.25, "y": 3 },
-                { "label": "N", "x": 7.25, "y": 3 },
-                { "label": "M", "x": 8.25, "y": 3 },
-                { "label": "<", "x": 9.25, "y": 3 },
-                { "label": ">", "x": 10.25, "y": 3 },
-                { "label": "?", "x": 11.25, "y": 3 },
-                { "label": "Shift", "w": 1.75, "x": 12.25, "y": 3 },
-                { "label": "Fn", "x": 14, "y": 3 },
-                { "label": "Ctrl", "w": 1.5, "x": 0, "y": 4 },
-                { "label": "Win", "x": 1.5, "y": 4 },
-                { "label": "Alt", "w": 1.5, "x": 2.5, "y": 4 },
-                { "w": 7, "x": 4, "y": 4 },
-                { "label": "Alt", "w": 1.5, "x": 11, "y": 4 },
-                { "label": "Win", "x": 12.5, "y": 4 },
-                { "label": "Ctrl", "w": 1.5, "x": 13.5, "y": 4 }
-            ]
+            "2x3u": [{"label":"Esc", "x":0, "y":0}, {"label":"!", "x":1, "y":0}, {"label":"@", "x":2, "y":0}, {"label":"#", "x":3, "y":0}, {"label":"$", "x":4, "y":0}, {"label":"%", "x":5, "y":0}, {"label":"^", "x":6, "y":0}, {"label":"&", "x":7, "y":0}, {"label":"*", "x":8, "y":0}, {"label":"(", "x":9, "y":0}, {"label":")", "x":10, "y":0}, {"label":"_", "x":11, "y":0}, {"label":"+", "x":12, "y":0}, {"label":"~", "x":13, "y":0}, {"label":"Bksp", "x":14, "y":0}, {"label":"Tab", "x":0, "y":1, "w":1.5}, {"label":"Q", "x":1.5, "y":1}, {"label":"W", "x":2.5, "y":1}, {"label":"E", "x":3.5, "y":1}, {"label":"R", "x":4.5, "y":1}, {"label":"T", "x":5.5, "y":1}, {"label":"Y", "x":6.5, "y":1}, {"label":"U", "x":7.5, "y":1}, {"label":"I", "x":8.5, "y":1}, {"label":"O", "x":9.5, "y":1}, {"label":"P", "x":10.5, "y":1}, {"label":"{", "x":11.5, "y":1}, {"label":"}", "x":12.5, "y":1}, {"label":"|", "x":13.5, "y":1, "w":1.5}, {"label":"Caps Lock", "x":0, "y":2, "w":1.75}, {"label":"A", "x":1.75, "y":2}, {"label":"S", "x":2.75, "y":2}, {"label":"D", "x":3.75, "y":2}, {"label":"F", "x":4.75, "y":2}, {"label":"G", "x":5.75, "y":2}, {"label":"H", "x":6.75, "y":2}, {"label":"J", "x":7.75, "y":2}, {"label":"K", "x":8.75, "y":2}, {"label":"L", "x":9.75, "y":2}, {"label":":", "x":10.75, "y":2}, {"label":"\"", "x":11.75, "y":2}, {"label":"Enter", "x":12.75, "y":2, "w":2.25}, {"label":"Shift", "x":0, "y":3, "w":2.25}, {"label":"Z", "x":2.25, "y":3}, {"label":"X", "x":3.25, "y":3}, {"label":"C", "x":4.25, "y":3}, {"label":"V", "x":5.25, "y":3}, {"label":"B", "x":6.25, "y":3}, {"label":"N", "x":7.25, "y":3}, {"label":"M", "x":8.25, "y":3}, {"label":"<", "x":9.25, "y":3}, {"label":">", "x":10.25, "y":3}, {"label":"?", "x":11.25, "y":3}, {"label":"Shift", "x":12.25, "y":3, "w":1.75}, {"label":"Fn", "x":14, "y":3}, {"label":"Ctrl", "x":0, "y":4, "w":1.5}, {"label":"Win", "x":1.5, "y":4}, {"label":"Alt", "x":2.5, "y":4, "w":1.5}, {"x":4, "y":4, "w":3}, {"x":7, "y":4}, {"x":8, "y":4, "w":3}, {"label":"Alt", "x":11, "y":4, "w":1.5}, {"label":"Win", "x":12.5, "y":4}, {"label":"Ctrl", "x":13.5, "y":4, "w":1.5}]
         },
-        "LAYOUT_2x3u": {
-            "layout": [
-                { "label": "Esc", "x": 0, "y": 0 },
-                { "label": "!", "x": 1, "y": 0 },
-                { "label": "@", "x": 2, "y": 0 },
-                { "label": "#", "x": 3, "y": 0 },
-                { "label": "$", "x": 4, "y": 0 },
-                { "label": "%", "x": 5, "y": 0 },
-                { "label": "^", "x": 6, "y": 0 },
-                { "label": "&", "x": 7, "y": 0 },
-                { "label": "*", "x": 8, "y": 0 },
-                { "label": "(", "x": 9, "y": 0 },
-                { "label": ")", "x": 10, "y": 0 },
-                { "label": "_", "x": 11, "y": 0 },
-                { "label": "+", "x": 12, "y": 0 },
-                { "label": "~", "x": 13, "y": 0 },
-                { "label": "Bksp", "x": 14, "y": 0 },
-                { "label": "Tab", "w": 1.5, "x": 0, "y": 1 },
-                { "label": "Q", "x": 1.5, "y": 1 },
-                { "label": "W", "x": 2.5, "y": 1 },
-                { "label": "E", "x": 3.5, "y": 1 },
-                { "label": "R", "x": 4.5, "y": 1 },
-                { "label": "T", "x": 5.5, "y": 1 },
-                { "label": "Y", "x": 6.5, "y": 1 },
-                { "label": "U", "x": 7.5, "y": 1 },
-                { "label": "I", "x": 8.5, "y": 1 },
-                { "label": "O", "x": 9.5, "y": 1 },
-                { "label": "P", "x": 10.5, "y": 1 },
-                { "label": "{", "x": 11.5, "y": 1 },
-                { "label": "}", "x": 12.5, "y": 1 },
-                { "label": "|", "w": 1.5, "x": 13.5, "y": 1 },
-                { "label": "Caps Lock", "w": 1.75, "x": 0, "y": 2 },
-                { "label": "A", "x": 1.75, "y": 2 },
-                { "label": "S", "x": 2.75, "y": 2 },
-                { "label": "D", "x": 3.75, "y": 2 },
-                { "label": "F", "x": 4.75, "y": 2 },
-                { "label": "G", "x": 5.75, "y": 2 },
-                { "label": "H", "x": 6.75, "y": 2 },
-                { "label": "J", "x": 7.75, "y": 2 },
-                { "label": "K", "x": 8.75, "y": 2 },
-                { "label": "L", "x": 9.75, "y": 2 },
-                { "label": ":", "x": 10.75, "y": 2 },
-                { "label": "\"", "x": 11.75, "y": 2 },
-                { "label": "Enter", "w": 2.25, "x": 12.75, "y": 2 },
-                { "label": "Shift", "w": 2.25, "x": 0, "y": 3 },
-                { "label": "Z", "x": 2.25, "y": 3 },
-                { "label": "X", "x": 3.25, "y": 3 },
-                { "label": "C", "x": 4.25, "y": 3 },
-                { "label": "V", "x": 5.25, "y": 3 },
-                { "label": "B", "x": 6.25, "y": 3 },
-                { "label": "N", "x": 7.25, "y": 3 },
-                { "label": "M", "x": 8.25, "y": 3 },
-                { "label": "<", "x": 9.25, "y": 3 },
-                { "label": ">", "x": 10.25, "y": 3 },
-                { "label": "?", "x": 11.25, "y": 3 },
-                { "label": "Shift", "w": 1.75, "x": 12.25, "y": 3 },
-                { "label": "Fn", "x": 14, "y": 3 },
-                { "label": "Ctrl", "w": 1.5, "x": 0, "y": 4 },
-                { "label": "Win", "x": 1.5, "y": 4 },
-                { "label": "Alt", "w": 1.5, "x": 2.5, "y": 4 },
-                { "w": 3, "x": 4, "y": 4 },
-                { "x": 7, "y": 4 },
-                { "w": 3, "x": 8, "y": 4 },
-                { "label": "Alt", "w": 1.5, "x": 11, "y": 4 },
-                { "label": "Win", "x": 12.5, "y": 4 },
-                { "label": "Ctrl", "w": 1.5, "x": 13.5, "y": 4 }
-            ]
+	    "LAYOUT": {
+            "7u": [{"label":"Esc", "x":0, "y":0}, {"label":"!", "x":1, "y":0}, {"label":"@", "x":2, "y":0}, {"label":"#", "x":3, "y":0}, {"label":"$", "x":4, "y":0}, {"label":"%", "x":5, "y":0}, {"label":"^", "x":6, "y":0}, {"label":"&", "x":7, "y":0}, {"label":"*", "x":8, "y":0}, {"label":"(", "x":9, "y":0}, {"label":")", "x":10, "y":0}, {"label":"_", "x":11, "y":0}, {"label":"+", "x":12, "y":0}, {"label":"~", "x":13, "y":0}, {"label":"Bksp", "x":14, "y":0}, {"label":"Tab", "x":0, "y":1, "w":1.5}, {"label":"Q", "x":1.5, "y":1}, {"label":"W", "x":2.5, "y":1}, {"label":"E", "x":3.5, "y":1}, {"label":"R", "x":4.5, "y":1}, {"label":"T", "x":5.5, "y":1}, {"label":"Y", "x":6.5, "y":1}, {"label":"U", "x":7.5, "y":1}, {"label":"I", "x":8.5, "y":1}, {"label":"O", "x":9.5, "y":1}, {"label":"P", "x":10.5, "y":1}, {"label":"{", "x":11.5, "y":1}, {"label":"}", "x":12.5, "y":1}, {"label":"|", "x":13.5, "y":1, "w":1.5}, {"label":"Caps Lock", "x":0, "y":2, "w":1.75}, {"label":"A", "x":1.75, "y":2}, {"label":"S", "x":2.75, "y":2}, {"label":"D", "x":3.75, "y":2}, {"label":"F", "x":4.75, "y":2}, {"label":"G", "x":5.75, "y":2}, {"label":"H", "x":6.75, "y":2}, {"label":"J", "x":7.75, "y":2}, {"label":"K", "x":8.75, "y":2}, {"label":"L", "x":9.75, "y":2}, {"label":":", "x":10.75, "y":2}, {"label":"\"", "x":11.75, "y":2}, {"label":"Enter", "x":12.75, "y":2, "w":2.25}, {"label":"Shift", "x":0, "y":3, "w":2.25}, {"label":"Z", "x":2.25, "y":3}, {"label":"X", "x":3.25, "y":3}, {"label":"C", "x":4.25, "y":3}, {"label":"V", "x":5.25, "y":3}, {"label":"B", "x":6.25, "y":3}, {"label":"N", "x":7.25, "y":3}, {"label":"M", "x":8.25, "y":3}, {"label":"<", "x":9.25, "y":3}, {"label":">", "x":10.25, "y":3}, {"label":"?", "x":11.25, "y":3}, {"label":"Shift", "x":12.25, "y":3, "w":1.75}, {"label":"Fn", "x":14, "y":3}, {"label":"Ctrl", "x":0, "y":4, "w":1.5}, {"label":"Win", "x":1.5, "y":4}, {"label":"Alt", "x":2.5, "y":4, "w":1.5}, {"x":4, "y":4, "w":7}, {"label":"Alt", "x":11, "y":4, "w":1.5}, {"label":"Win", "x":12.5, "y":4}, {"label":"Ctrl", "x":13.5, "y":4, "w":1.5}]
         }
     }
 }

keyboards/crkbd/keymaps/devdev/config.h

@@ -32,7 +32,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #define CUSTOM_FONT
 
-#define CUSTOM_LAYER_READ //if you remove this it causes issues - needs better guarding
+#define CUSTOM_LAYER_READ //if you remove this it causes issues - needs better guarding 
 
 #define TAPPING_FORCE_HOLD
 #define TAPPING_TERM 200
@@ -43,7 +43,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #ifdef RGBLIGHT_ENABLE
     #undef RGBLED_NUM
-
+	
     //#define RGBLIGHT_ANIMATIONS
 	#define RGBLIGHT_EFFECT_BREATHING
 	#define RGBLIGHT_EFFECT_RAINBOW_MOOD
@@ -55,11 +55,11 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 	//#define RGBLIGHT_EFFECT_RGB_TEST
 	//#define RGBLIGHT_EFFECT_ALTERNATING
 	//#define RGBLIGHT_EFFECT_TWINKLE
-
+	
     //#define RGBLED_NUM 54
 	//#define RGBLED_SPLIT 27
-	//#define RGBLED_SPLIT { 27, 27 } // haven't figured out how to use this yet
-
+	//#define RGBLED_SPLIT { 27, 27 } // haven't figured out how to use this yet 
+	
 	#define RGBLED_NUM 27
     #define RGBLIGHT_LIMIT_VAL 120
     #define RGBLIGHT_HUE_STEP 10
@@ -71,11 +71,11 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #   define RGB_MATRIX_KEYPRESSES // reacts to keypresses
 // #   define RGB_MATRIX_KEYRELEASES // reacts to keyreleases (instead of keypresses)
 // #   define RGB_DISABLE_AFTER_TIMEOUT 0 // number of ticks to wait until disabling effects
-#   define RGB_DISABLE_WHEN_USB_SUSPENDED // turn off effects when suspended
+#   define RGB_DISABLE_WHEN_USB_SUSPENDED true // turn off effects when suspended
 #   define RGB_MATRIX_FRAMEBUFFER_EFFECTS
 // #   define RGB_MATRIX_LED_PROCESS_LIMIT (DRIVER_LED_TOTAL + 4) / 5 // limits the number of LEDs to process in an animation per task run (increases keyboard responsiveness)
 // #   define RGB_MATRIX_LED_FLUSH_LIMIT 16 // limits in milliseconds how frequently an animation will update the LEDs. 16 (16ms) is equivalent to limiting to 60fps (increases keyboard responsiveness)
-#    define RGB_MATRIX_MAXIMUM_BRIGHTNESS 150 // limits maximum brightness of LEDs to 150 out of 255. Higher may cause the controller to crash.
+#    define RGB_MATRIX_MAXIMUM_BRIGHTNESS 150 // limits maximum brightness of LEDs to 150 out of 255. Higher may cause the controller to crash. 
 
 #define RGB_MATRIX_STARTUP_MODE RGB_MATRIX_GRADIENT_LEFT_RIGHT
 

keyboards/crkbd/keymaps/gotham/config.h

@@ -39,7 +39,7 @@
 
 #ifdef RGB_MATRIX_ENABLE
 #    define RGB_MATRIX_KEYPRESSES                // reacts to keypresses
-#    define RGB_DISABLE_WHEN_USB_SUSPENDED  // turn off effects when suspended
+#    define RGB_DISABLE_WHEN_USB_SUSPENDED true  // turn off effects when suspended
 #    define RGB_MATRIX_MAXIMUM_BRIGHTNESS 150    // limits maximum brightness of LEDs to 150 out of 255. Higher may cause the controller to crash.
 #    define RGB_MATRIX_HUE_STEP 32
 #    define RGB_MATRIX_SAT_STEP 64

keyboards/crkbd/keymaps/kidbrazil/config.h

@@ -56,7 +56,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
     //#   define RGB_MATRIX_KEYPRESSES // reacts to keypresses
     // #   define RGB_MATRIX_KEYRELEASES // reacts to keyreleases (instead of keypresses)
     // #   define RGB_DISABLE_AFTER_TIMEOUT 0 // number of ticks to wait until disabling effects
-    #define RGB_DISABLE_WHEN_USB_SUSPENDED // turn off effects when suspended
+    #define RGB_DISABLE_WHEN_USB_SUSPENDED true // turn off effects when suspended
     #define RGB_MATRIX_FRAMEBUFFER_EFFECTS
     // #   define RGB_MATRIX_LED_PROCESS_LIMIT (DRIVER_LED_TOTAL + 4) / 5 // limits the number of LEDs to process in an animation per task run (increases keyboard responsiveness)
     // #   define RGB_MATRIX_LED_FLUSH_LIMIT 16 // limits in milliseconds how frequently an animation will update the LEDs. 16 (16ms) is equivalent to limiting to 60fps (increases keyboard responsiveness)

keyboards/crkbd/keymaps/rpbaptist/config.h

@@ -42,7 +42,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define NO_ACTION_ONESHOT
 
 #ifdef RGB_MATRIX_ENABLE
-#    define RGB_DISABLE_WHEN_USB_SUSPENDED  // turn off effects when suspended
+#    define RGB_DISABLE_WHEN_USB_SUSPENDED true  // turn off effects when suspended
 #    define RGB_MATRIX_MAXIMUM_BRIGHTNESS 150
 
 #    define RGB_MATRIX_HUE_STEP 8

keyboards/crkbd/keymaps/snowe/config.h

@@ -0,0 +1,55 @@
+/*
+This is the c configuration file for the keymap
+
+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
+
+//#define USE_MATRIX_I2C
+
+/* Select hand configuration */
+
+#define MASTER_LEFT
+// #define MASTER_RIGHT
+// #define EE_HANDS
+
+#define USE_SERIAL_PD2
+
+#define TAPPING_FORCE_HOLD
+#define TAPPING_TERM 200
+
+#define IGNORE_MOD_TAP_INTERRUPT
+#undef PERMISSIVE_HOLD
+
+#ifdef RGBLIGHT_ENABLE
+    #undef RGBLED_NUM
+    #define RGBLIGHT_ANIMATIONS
+    #define RGBLED_NUM 27
+    #define RGBLIGHT_LIMIT_VAL 120
+    #define RGBLIGHT_HUE_STEP 10
+    #define RGBLIGHT_SAT_STEP 17
+    #define RGBLIGHT_VAL_STEP 17
+#endif
+
+#define OLED_FONT_H "keyboards/crkbd/lib/glcdfont.c"
+
+// fix for me putting alt under A and being a fast typist
+#define IGNORE_MOD_TAP_INTERRUPT
+//#define IGNORE_MOD_TAP_INTERRUPT_PER_KEY
+
+#define LAYER_STATE_8BIT

keyboards/crkbd/keymaps/snowe/keycode_aliases.h

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2020 Drashna Jaelre <@drashna>
+ * Copyright 2021 Tyler Thrailkill <@snowe/@snowe2010>
+ *
+ * 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 GUI_ESC GUI_T(KC_ESC)
+#define CTL_ESC CTL_T(KC_ESC)
+#define SH_BKSP SFT_T(KC_BSPC)
+#define SP_RAIS LT(_UPPER, KC_SPC)
+
+#define LOWER MO(_LOWER)
+#define RAISE MO(_UPPER)
+#define ADJUST MO(_ADJUST)
+#define TG_MODS TG(_MODS)
+//#define TG_GAME TG(_GAMEPAD)
+//#define OS_LWR OSL(_LOWER)
+//#define OS_RSE OSL(_UPPER)
+
+//#define KC_SEC1 KC_SECRET_1
+//#define KC_SEC2 KC_SECRET_2
+//#define KC_SEC3 KC_SECRET_3
+//#define KC_SEC4 KC_SECRET_4
+//#define KC_SEC5 KC_SECRET_5
+
+#define QWERTY KC_QWERTY
+#define DVORAK KC_DVORAK
+#define COLEMAK KC_COLEMAK
+#define WORKMAN KC_WORKMAN
+
+#define KC_RESET RESET
+#define KC_RST KC_RESET
+
+#ifdef SWAP_HANDS_ENABLE
+#    define KC_C1R3 SH_TT
+#else  // SWAP_HANDS_ENABLE
+#    define KC_C1R3 KC_BSPC
+#endif  // SWAP_HANDS_ENABLE
+
+#define BK_LWER LT(_LOWER, KC_BSPC)
+#define SP_LWER LT(_LOWER, KC_SPC)
+#define DL_RAIS LT(_UPPER, KC_DEL)
+#define ET_RAIS LT(_UPPER, KC_ENTER)
+#define SFT_ENT SFT_T(KC_ENTER)
+#define SP_RAIS LT(_UPPER, KC_SPC)
+
+/* OSM keycodes, to keep things clean and easy to change */
+#define KC_MLSF OSM(MOD_LSFT)
+#define KC_MRSF OSM(MOD_RSFT)
+
+#define OS_LGUI OSM(MOD_LGUI)
+#define OS_RGUI OSM(MOD_RGUI)
+#define OS_LSFT OSM(MOD_LSFT)
+#define OS_RSFT OSM(MOD_RSFT)
+#define OS_LCTL OSM(MOD_LCTL)
+#define OS_RCTL OSM(MOD_RCTL)
+#define OS_LALT OSM(MOD_LALT)
+#define OS_RALT OSM(MOD_RALT)
+#define OS_MEH OSM(MOD_MEH)
+#define OS_HYPR OSM(MOD_HYPR)
+
+#define ALT_APP ALT_T(KC_APP)
+
+#define MG_NKRO MAGIC_TOGGLE_NKRO
+
+#define UC_IRNY UC(0x2E2E)
+#define UC_CLUE UC(0x203D)

keyboards/crkbd/keymaps/snowe/keymap.c

@@ -0,0 +1,190 @@
+/*
+Copyright 2019 @foostan
+Copyright 2020 Drashna Jaelre <@drashna>
+Copyright 2021 Tyler Thrailkill <@snowe/@snowe2010>
+
+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 QMK_KEYBOARD_H
+#include "snowe.h"
+
+// Symbols chart
+// ↯ hyper key (ctrl, alt, shift, super)
+// ⌘ command
+// ⌥ option
+// ⌃ control
+// ⇧ shift
+// ⌫ backspace
+// ⌦ delete
+// ⎋ escape
+// ↩ enter
+
+/* Wrapper
+ * ,-----------------------------------------------. .-----------------------------------------------.
+ * |  Tab  |  K01  |  K02  |  K03  |  K04  |  K05  | |  K06  |  K07  |  K08  |  K09  |  K0A  |       |
+ * |-------+-------+-------+-------+-------+-------| |-------+-------+-------+-------+-------+-------|
+ * |  ⌘/⎋  | ⌃/K11 |  K12  |  K13  |  K14  |  K15  | |  K16  |  K17  |  K18  |  K19  | ⌥/K1A |       |
+ * |-------+-------+-------+-------+-------+-------| |-------+-------+-------+-------+-------+-------|
+ * |  ↯/⌦  | ⌥/K21 |  K22  |  K23  |  K24  |  K25  | |  K26  |  K27  |  K28  |  K29  | ⌃/K2A |       |
+ * `-----------------------.                       | |                       .-----------------------'
+ *                         |-------+-------+-------| |-------+-------+-------|
+ *                         |   ⌃   |  ⇧/↩  | ⌫/LWR | | ␣/RAY |   ␣   |  R ⌥  |
+ *                         `-----------------------' '-----------------------'
+ */
+// clang-format off
+#define LAYOUT_crkbd_base( \
+    K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, \
+    K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, \
+    K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A  \
+  ) \
+  LAYOUT_wrapper( \
+    KC_TAB,         K01,         K02, K03, K04, K05,     K06, K07, K08, K09,        K0A,  KC_MINS, \
+    GUI_ESC,        CTL_T(K11),  K12, K13, K14, K15,     K16, K17, K18, K19, ALT_T(K1A),  KC_QUOT, \
+    HYPR_T(KC_DEL), ALT_T(K21),  K22, K23, K24, K25,     K26, K27, K28, K29, RCTL_T(K2A), KC_BSLS, \
+                        KC_LCTL,    LOWER,  SH_BKSP,       KC_ENTER, SP_RAIS,  KC_LALT             \
+  )
+// clang-format on
+#define LAYOUT_crkbd_base_wrapper(...) LAYOUT_crkbd_base(__VA_ARGS__)
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+    // clang-format off
+    /* QWERTY
+     * ,-----------------------------------------------. .-----------------------------------------------.
+     * |       |   Q   |   W   |   E   |   R   |   T   | |   Y   |   U   |   I   |   O   |   P   |       |
+     * |-------+-------+-------+-------+-------+-------| |-------+-------+-------+-------+-------+-------|
+     * |       |   A   |   S   |   D   |   F   |   G   | |   H   |   J   |   K   |   L   |   ;   |  '    |
+     * |-------+-------+-------+-------+-------+-------| |-------+-------+-------+-------+-------+-------|
+     * |       |   Z   |   X   |   C   |   V   |   B   | |   N   |   M   |   ,   |   .   |   /   |       |
+     * `-----------------------.                       | |                       .-----------------------'
+     *                         |-------+-------+-------| |-------+-------+-------|
+     *                         |       |       |       | |       |       |       |
+     *                         `-----------------------' '-----------------------'
+     */
+    [_MAIN] = LAYOUT_crkbd_base_wrapper(
+        _________________QWERTY_L1_________________, _________________QWERTY_R1_________________,
+        _________________QWERTY_L2_________________, _________________QWERTY_R2_________________,
+        _________________QWERTY_L3_________________, _________________QWERTY_R3_________________
+    ),
+
+    /* Lower
+     * ,-----------------------------------------------. .-----------------------------------------------.
+     * |   ~   |   !   |   @   |   #   |   $   |   %   | |   ^   |   &   |   *   |   (   |   )   |       |
+     * |-------+-------+-------+-------+-------+-------| |-------+-------+-------+-------+-------+-------|
+     * |       |       |       |       |       |       | |       |   _   |   +   |   [   |   ]   |       |
+     * |-------+-------+-------+-------+-------+-------| |-------+-------+-------+-------+-------+-------|
+     * |       |       |       |       |       |       | |       |   ←   |   ↑   |   ↓   |   →   |       |
+     * `-----------------------.                       | |                       .-----------------------'
+     *                         |-------+-------+-------| |-------+-------+-------|
+     *                         |       |       |       | |       |       |       |
+     *                         `-----------------------' '-----------------------'
+     */
+    [_LOWER] = LAYOUT_wrapper(
+        KC_TILDE,  _________________LOWER_L1__________________,                    _________________LOWER_R1__________________, KC_F11,
+        KC_F12  ,  _________________LOWER_L2__________________,                    _________________LOWER_R2__________________, KC_PIPE,
+        _______ ,  _________________LOWER_L3__________________,                    _________________LOWER_R3__________________, _______,
+                                            _______, _______, _______,        _______, _______, _______
+    ),
+
+
+    /*
+     * ,-----------------------------------------------. .-----------------------------------------------.
+     * |       |       |       |       |       |       | |       |       |       |       |       |       |
+     * |-------+-------+-------+-------+-------+-------| |-------+-------+-------+-------+-------+-------|
+     * |       |       |       |       |       |       | |       |       |       |       |       |       |
+     * |-------+-------+-------+-------+-------+-------| |-------+-------+-------+-------+-------+-------|
+     * |       |       |       |       |       |       | |       |       |       |       |       |       |
+     * `-----------------------.                       | |                       .-----------------------'
+     *                         |-------+-------+-------| |-------+-------+-------|
+     *                         |       |       |       | |       |       |       |
+     *                         `-----------------------' '-----------------------'
+     */
+    /* Raise
+     * ,-----------------------------------------------. .-----------------------------------------------.
+     * |   `   |   1   |   2   |   3   |   4   |   5   | |   6   |   7   |   8   |   9   |   0   |       |
+     * |-------+-------+-------+-------+-------+-------| |-------+-------+-------+-------+-------+-------|
+     * |       |       |       |       |       |       | |       |   ←   |   ↑   |   ↓   |   →   |       |
+     * |-------+-------+-------+-------+-------+-------| |-------+-------+-------+-------+-------+-------|
+     * |       |       |       |       |       |       | |       | home  |pg down| pg up |  end  |       |
+     * `-----------------------.                       | |                       .-----------------------'
+     *                         |-------+-------+-------| |-------+-------+-------|
+     *                         |       |       |       | |       |       |       |
+     *                         `-----------------------' '-----------------------'
+     */
+    [_UPPER] = LAYOUT_wrapper( \
+         KC_GRV, _________________RAISE_L1__________________,                    _________________RAISE_R1__________________, _______,
+        _______, _________________RAISE_L2__________________,                    _________________RAISE_R2__________________, KC_BSLS,
+        _______, _________________RAISE_L3__________________,                    _________________RAISE_R3__________________, _______,
+                                         _______, _______, _______,        _______, _______, _______
+    ),
+
+    [_ADJUST] = LAYOUT_wrapper( \
+        _______, _________________ADJUST_L1_________________,                         _________________ADJUST_R1_________________, KC_RESET,
+        _______, _________________ADJUST_L2_________________,                         _________________ADJUST_R2_________________, EEP_RST,
+        _______, _________________ADJUST_L3_________________,                         _________________ADJUST_R3_________________, KC_MPLY,
+                                            _______, _______, _______,        _______, _______, _______
+    )
+    // clang-format on
+};
+
+layer_state_t layer_state_set_user(layer_state_t state) { return update_tri_layer_state(state, _LOWER, _UPPER, _ADJUST); }
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+    switch (keycode) {
+        case KC_LCTL:
+        case KC_RCTL:
+#ifdef OCEAN_DREAM_ENABLE
+            is_calm = (record->event.pressed) ? true : false;
+#endif
+#ifdef LUNA_ENABLE
+            if (record->event.pressed) {
+                isSneaking = true;
+            } else {
+                isSneaking = false;
+            }
+#endif
+            break;
+        case KC_SPC:
+#ifdef LUNA_ENABLE
+            if (record->event.pressed) {
+                isJumping  = true;
+                showedJump = false;
+            } else {
+                isJumping = false;
+            }
+#endif
+            break;
+    }
+    return true;
+}
+
+// uint16_t get_tapping_term(uint16_t keycode, keyrecord_t *record) {
+//    switch (keycode) {
+//        case ALT_T(KC_A):
+//        case SH_BKSP:
+//            return TAPPING_TERM + 500;
+//        default:
+//            return TAPPING_TERM;
+//    }
+//}
+//
+// bool get_ignore_mod_tap_interrupt(uint16_t keycode, keyrecord_t *record) {
+//    switch (keycode) {
+//        case ALT_T(KC_A):
+//        case SH_BKSP:
+//            return true;
+//        default:
+//            return false;
+//    }
+//}

keyboards/crkbd/keymaps/snowe/rules.mk

@@ -0,0 +1,25 @@
+BOOTMAGIC_ENABLE = no       # Virtual DIP switch configuration(+1000)
+MOUSEKEY_ENABLE = no        # Mouse keys(+4700)
+EXTRAKEY_ENABLE = yes       # Audio control and System control(+450)
+CONSOLE_ENABLE = no         # Console for debug(+400)
+COMMAND_ENABLE = no         # Commands for debug and configuration
+NKRO_ENABLE = no            # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
+AUDIO_ENABLE = no           # Audio output on port C6
+BACKLIGHT_ENABLE = no       # Enable keyboard backlight functionality
+RGBLIGHT_ENABLE = no       # Enable WS2812 RGB underlight.
+LEADER_ENABLE = no
+MIDI_ENABLE = no            # MIDI controls
+UNICODE_ENABLE = no         # Unicode
+BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
+SWAP_HANDS_ENABLE = no      # Enable one-hand typing
+RGBLIGHT_TWINKLE = no
+OLED_DRIVER_ENABLE = yes
+RGB_MATRIX_ENABLE = yes
+
+OCEAN_DREAM_ENABLE = yes
+LUNA_ENABLE = no # disabled so travis build succeeds
+
+# if firmware size over limit, try this option
+CFLAGS += -flto
+
+WPM_ENABLE = yes

keyboards/crkbd/keymaps/soundmonster/config.h

@@ -59,11 +59,11 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #   define RGB_MATRIX_KEYPRESSES // reacts to keypresses
 // #   define RGB_MATRIX_KEYRELEASES // reacts to keyreleases (instead of keypresses)
 // #   define RGB_DISABLE_AFTER_TIMEOUT 0 // number of ticks to wait until disabling effects
-#   define RGB_DISABLE_WHEN_USB_SUSPENDED // turn off effects when suspended
+#   define RGB_DISABLE_WHEN_USB_SUSPENDED true // turn off effects when suspended
 #   define RGB_MATRIX_FRAMEBUFFER_EFFECTS
 #   define RGB_MATRIX_LED_PROCESS_LIMIT (DRIVER_LED_TOTAL + 4) / 5 // limits the number of LEDs to process in an animation per task run (increases keyboard responsiveness)
 #   define RGB_MATRIX_LED_FLUSH_LIMIT 16 // limits in milliseconds how frequently an animation will update the LEDs. 16 (16ms) is equivalent to limiting to 60fps (increases keyboard responsiveness)
-#   define RGB_MATRIX_MAXIMUM_BRIGHTNESS 150 // limits maximum brightness of LEDs to 150 out of 255. Higher may cause the controller to crash.
+#   define RGB_MATRIX_MAXIMUM_BRIGHTNESS 150 // limits maximum brightness of LEDs to 150 out of 255. Higher may cause the controller to crash. 
 #   define RGB_MATRIX_HUE_STEP 8
 #   define RGB_MATRIX_SAT_STEP 8
 #   define RGB_MATRIX_VAL_STEP 8

keyboards/crkbd/readme.md

@@ -38,7 +38,7 @@ And in your `config.h` file, add the following:
 #   define RGB_MATRIX_KEYPRESSES // reacts to keypresses
 // #   define RGB_MATRIX_KEYRELEASES // reacts to keyreleases (instead of keypresses)
 // #   define RGB_DISABLE_AFTER_TIMEOUT 0 // number of ticks to wait until disabling effects
-#   define RGB_DISABLE_WHEN_USB_SUSPENDED // turn off effects when suspended
+#   define RGB_DISABLE_WHEN_USB_SUSPENDED true // turn off effects when suspended
 #   define RGB_MATRIX_FRAMEBUFFER_EFFECTS
 // #   define RGB_MATRIX_LED_PROCESS_LIMIT (DRIVER_LED_TOTAL + 4) / 5 // limits the number of LEDs to process in an animation per task run (increases keyboard responsiveness)
 // #   define RGB_MATRIX_LED_FLUSH_LIMIT 16 // limits in milliseconds how frequently an animation will update the LEDs. 16 (16ms) is equivalent to limiting to 60fps (increases keyboard responsiveness)

keyboards/draculad/config.h

@@ -65,5 +65,3 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define UNUSED_PINS
 
 #define EE_HANDS
-
-#define LAYER_STATE_8BIT

keyboards/dztech/dz60rgb/v1/config.h

@@ -37,7 +37,7 @@
 
 #ifdef RGB_MATRIX_ENABLE
 #    define RGB_DISABLE_AFTER_TIMEOUT 0 // number of ticks to wait until disabling effects
-#    define RGB_DISABLE_WHEN_USB_SUSPENDED // turn off effects when suspended
+#    define RGB_DISABLE_WHEN_USB_SUSPENDED true // turn off effects when suspended
 #    define RGB_MATRIX_KEYPRESSES
 #    define RGB_MATRIX_LED_PROCESS_LIMIT 4
 #    define RGB_MATRIX_LED_FLUSH_LIMIT 26

keyboards/dztech/dz60rgb/v2/config.h

@@ -37,7 +37,7 @@
 
 #ifdef RGB_MATRIX_ENABLE
 #    define RGB_DISABLE_AFTER_TIMEOUT 0 // number of ticks to wait until disabling effects
-#    define RGB_DISABLE_WHEN_USB_SUSPENDED // turn off effects when suspended
+#    define RGB_DISABLE_WHEN_USB_SUSPENDED true // turn off effects when suspended
 #    define RGB_MATRIX_KEYPRESSES
 #    define RGB_MATRIX_FRAMEBUFFER_EFFECTS
 #    define DISABLE_RGB_MATRIX_GRADIENT_UP_DOWN

keyboards/dztech/dz60rgb_ansi/v1/config.h

@@ -37,7 +37,7 @@
 
 #ifdef RGB_MATRIX_ENABLE
 #    define RGB_DISABLE_AFTER_TIMEOUT 0 // number of ticks to wait until disabling effects
-#    define RGB_DISABLE_WHEN_USB_SUSPENDED // turn off effects when suspended
+#    define RGB_DISABLE_WHEN_USB_SUSPENDED true // turn off effects when suspended
 #    define RGB_MATRIX_KEYPRESSES
 #    define RGB_MATRIX_LED_PROCESS_LIMIT 4
 #    define RGB_MATRIX_LED_FLUSH_LIMIT 26

keyboards/dztech/dz60rgb_ansi/v2/config.h

@@ -37,7 +37,7 @@
 
 #ifdef RGB_MATRIX_ENABLE
 #    define RGB_DISABLE_AFTER_TIMEOUT 0 // number of ticks to wait until disabling effects
-#    define RGB_DISABLE_WHEN_USB_SUSPENDED // turn off effects when suspended
+#    define RGB_DISABLE_WHEN_USB_SUSPENDED true // turn off effects when suspended
 #    define RGB_MATRIX_KEYPRESSES
 #    define RGB_MATRIX_FRAMEBUFFER_EFFECTS
 #    define DISABLE_RGB_MATRIX_GRADIENT_UP_DOWN

keyboards/dztech/dz60rgb_wkl/v1/config.h

@@ -37,7 +37,7 @@
 
 #ifdef RGB_MATRIX_ENABLE
 #    define RGB_DISABLE_AFTER_TIMEOUT 0 // number of ticks to wait until disabling effects
-#    define RGB_DISABLE_WHEN_USB_SUSPENDED // turn off effects when suspended
+#    define RGB_DISABLE_WHEN_USB_SUSPENDED true // turn off effects when suspended
 #    define RGB_MATRIX_KEYPRESSES
 #    define RGB_MATRIX_LED_PROCESS_LIMIT 4
 #    define RGB_MATRIX_LED_FLUSH_LIMIT 26

keyboards/dztech/dz60rgb_wkl/v2/config.h

@@ -37,7 +37,7 @@
 
 #ifdef RGB_MATRIX_ENABLE
 #    define RGB_DISABLE_AFTER_TIMEOUT 0 // number of ticks to wait until disabling effects
-#    define RGB_DISABLE_WHEN_USB_SUSPENDED // turn off effects when suspended
+#    define RGB_DISABLE_WHEN_USB_SUSPENDED true // turn off effects when suspended
 #    define RGB_MATRIX_KEYPRESSES
 #    define RGB_MATRIX_FRAMEBUFFER_EFFECTS
 #    define DISABLE_RGB_MATRIX_GRADIENT_UP_DOWN

keyboards/dztech/dz65rgb/v1/config.h

@@ -51,9 +51,9 @@
 #    define RGB_MATRIX_LED_FLUSH_LIMIT 26
 #    define DEBOUNCE 3
 #    define RGB_DISABLE_AFTER_TIMEOUT 0 // number of ticks to wait until disabling effects
-#    define RGB_DISABLE_WHEN_USB_SUSPENDED // turn off effects when suspended
+#    define RGB_DISABLE_WHEN_USB_SUSPENDED true // turn off effects when suspended
 #    define RGB_MATRIX_KEYPRESSES
-#    define DISABLE_RGB_MATRIX_GRADIENT_UP_DOWN
+#    define DISABLE_RGB_MATRIX_GRADIENT_UP_DOWN	
 #    define DISABLE_RGB_MATRIX_BAND_SAT
 #    define DISABLE_RGB_MATRIX_BAND_PINWHEEL_SAT
 #    define DISABLE_RGB_MATRIX_BAND_SPIRAL_SAT

keyboards/dztech/dz65rgb/v2/config.h

@@ -51,7 +51,7 @@
 #    define RGB_MATRIX_LED_FLUSH_LIMIT 26
 #    define DEBOUNCE 3
 #    define RGB_DISABLE_AFTER_TIMEOUT 0 // number of ticks to wait until disabling effects
-#    define RGB_DISABLE_WHEN_USB_SUSPENDED // turn off effects when suspended
+#    define RGB_DISABLE_WHEN_USB_SUSPENDED true // turn off effects when suspended
 #    define RGB_MATRIX_KEYPRESSES
 #    define DISABLE_RGB_MATRIX_GRADIENT_UP_DOWN
 #    define DISABLE_RGB_MATRIX_BAND_SAT

keyboards/ergodox_ez/config.h

@@ -129,7 +129,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define RGB_MATRIX_LED_PROCESS_LIMIT 5
 #define RGB_MATRIX_LED_FLUSH_LIMIT 26
 
-#define RGB_DISABLE_WHEN_USB_SUSPENDED
+#define RGB_DISABLE_WHEN_USB_SUSPENDED true
 
 // #define RGBLIGHT_COLOR_LAYER_0 0x00, 0x00, 0xFF
 /* #define RGBLIGHT_COLOR_LAYER_1 0x00, 0x00, 0xFF */

keyboards/ergodox_ez/keymaps/hacker_dvorak/config.h

@@ -14,7 +14,7 @@
 #undef  IGNORE_MOD_TAP_INTERRUPT
 #define IGNORE_MOD_TAP_INTERRUPT
 
-#define RGB_DISABLE_WHEN_USB_SUSPENDED
+#define RGB_DISABLE_WHEN_USB_SUSPENDED true
 
 #undef  FORCE_NKRO
 #define FORCE_NKRO

keyboards/ergodox_ez/util/keymap_beautifier/KeymapBeautifier.py

@@ -164,7 +164,16 @@ class KeymapBeautifier:
                 key_symbols = [key_symbols[i] for i in self.index_conversion_map_reversed(self.INDEX_CONVERSTION_LAYOUT_ergodox_pretty_to_LAYOUT_ergodox)]
 
             padded_key_symbols = self.pad_key_symbols(key_symbols, input_layout)
-            current_pretty_output_layer = self.pretty_output_layer(layer.name[0].value, padded_key_symbols)
+           
+            layer_identifier = None
+            if hasattr(layer.name[0], "value"):
+                layer_identifier = layer.name[0].value
+            elif hasattr(layer.name[0], "name"):
+                layer_identifier = layer.name[0].name
+            else:
+                raise AttributeError("Layer is missing both index and name (e.g., [BASE] = LAYOUT_ergodox(...))")
+
+            current_pretty_output_layer = self.pretty_output_layer(layer_identifier, padded_key_symbols)
             # strip trailing spaces from padding
             layer_output.append(re.sub(r" +\n", "\n", current_pretty_output_layer))
 

keyboards/ergodox_infinity/config.h

@@ -62,21 +62,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define LED_BRIGHTNESS_LO       100
 #define LED_BRIGHTNESS_HI       255
 
-/* LED matrix driver */
-#define LED_DRIVER_ADDR_1 0x74
-#define LED_DRIVER_COUNT 1
-#define DRIVER_LED_TOTAL 76
-#define LED_MATRIX_SPLIT { 38, 38 }
-#define LED_DISABLE_WHEN_USB_SUSPENDED
-
-/* i2c (for LED matrix) */
-#define I2C1_CLOCK_SPEED 400000
-#define I2C1_SCL_PAL_MODE PAL_MODE_ALTERNATIVE_2
-#define I2C1_SDA_PAL_MODE PAL_MODE_ALTERNATIVE_2
-#define I2C1_BANK GPIOB
-#define I2C1_SCL 0
-#define I2C1_SDA 1
-
 /* define if matrix has ghost */
 //#define MATRIX_HAS_GHOST
 

keyboards/ergodox_infinity/ergodox_infinity.c

@@ -1,45 +1,20 @@
 #include QMK_KEYBOARD_H
 #include <ch.h>
 #include <hal.h>
-#include <string.h>
-#include "eeconfig.h"
 #include "serial_link/system/serial_link.h"
 #ifdef VISUALIZER_ENABLE
-#    include "lcd_backlight.h"
+#include "lcd_backlight.h"
 #endif
 
-#if (defined(LED_MATRIX_ENABLE) || defined(WPM_ENABLE))
-#    include "serial_link/protocol/transport.h"
+#ifdef WPM_ENABLE
+#   include "serial_link/protocol/transport.h"
+#   include "wpm.h"
 
-#    ifdef LED_MATRIX_ENABLE
-MASTER_TO_ALL_SLAVES_OBJECT(led_matrix, led_eeconfig_t);
-MASTER_TO_ALL_SLAVES_OBJECT(led_suspend_state, bool);
-static led_eeconfig_t last_sent_led_matrix;
-static uint16_t       led_matrix_sent_timer = 0;
-
-void send_led_suspend_state(void) {
-    if (is_serial_link_master()) {
-        *begin_write_led_suspend_state() = led_matrix_get_suspend_state();
-        end_write_led_suspend_state();
-    }
-}
-#    endif
-
-#    ifdef WPM_ENABLE
-#        include "wpm.h"
 MASTER_TO_ALL_SLAVES_OBJECT(current_wpm, uint8_t);
-static uint8_t last_sent_wpm = 0;
-#    endif
-
-static remote_object_t *remote_objects[] = {
-#    ifdef LED_MATRIX_ENABLE
-    REMOTE_OBJECT(led_matrix),
-    REMOTE_OBJECT(led_suspend_state),
-#    endif
-#    ifdef WPM_ENABLE
+static remote_object_t* remote_objects[] = {
     REMOTE_OBJECT(current_wpm),
-#    endif
 };
+static uint8_t last_sent_wpm = 0;
 #endif
 
 void init_serial_link_hal(void) {
@@ -77,7 +52,7 @@ void init_serial_link_hal(void) {
 void lcd_backlight_hal_init(void) {
     // Setup Backlight
     SIM->SCGC6 |= SIM_SCGC6_FTM0;
-    FTM0->CNT = 0;  // Reset counter
+    FTM0->CNT = 0; // Reset counter
 
     // PWM Period
     // 16-bit maximum
@@ -85,25 +60,25 @@ void lcd_backlight_hal_init(void) {
 
     // Set FTM to PWM output - Edge Aligned, Low-true pulses
 #define CNSC_MODE FTM_SC_CPWMS | FTM_SC_PS(4) | FTM_SC_CLKS(0)
-    CHANNEL_RED.CnSC   = CNSC_MODE;
+    CHANNEL_RED.CnSC = CNSC_MODE;
     CHANNEL_GREEN.CnSC = CNSC_MODE;
-    CHANNEL_BLUE.CnSC  = CNSC_MODE;
+    CHANNEL_BLUE.CnSC = CNSC_MODE;
 
     // System clock, /w prescalar setting
     FTM0->SC = FTM_SC_CLKS(1) | FTM_SC_PS(PRESCALAR_DEFINE);
 
-    CHANNEL_RED.CnV   = 0;
+    CHANNEL_RED.CnV = 0;
     CHANNEL_GREEN.CnV = 0;
-    CHANNEL_BLUE.CnV  = 0;
+    CHANNEL_BLUE.CnV = 0;
 
     RGB_PORT_GPIO->PDDR |= (1 << RED_PIN);
     RGB_PORT_GPIO->PDDR |= (1 << GREEN_PIN);
     RGB_PORT_GPIO->PDDR |= (1 << BLUE_PIN);
 
 #define RGB_MODE PORTx_PCRn_SRE | PORTx_PCRn_DSE | PORTx_PCRn_MUX(4)
-    RGB_PORT->PCR[RED_PIN]   = RGB_MODE;
+    RGB_PORT->PCR[RED_PIN] = RGB_MODE;
     RGB_PORT->PCR[GREEN_PIN] = RGB_MODE;
-    RGB_PORT->PCR[BLUE_PIN]  = RGB_MODE;
+    RGB_PORT->PCR[BLUE_PIN] = RGB_MODE;
 }
 
 static uint16_t cie_lightness(uint16_t v) {
@@ -114,11 +89,12 @@ static uint16_t cie_lightness(uint16_t v) {
     // Y = (L* / 902.3)           if L* <= 8
     // Y = ((L* + 16) / 116)^3    if L* > 8
 
-    float l = 100.0f * (v / 65535.0f);
+    float l =  100.0f * (v / 65535.0f);
     float y = 0.0f;
     if (l <= 8.0f) {
-        y = l / 902.3;
-    } else {
+       y = l / 902.3;
+    }
+    else {
         y = ((l + 16.0f) / 116.0f);
         y = y * y * y;
         if (y > 1.0f) {
@@ -129,48 +105,31 @@ static uint16_t cie_lightness(uint16_t v) {
 }
 
 void lcd_backlight_hal_color(uint16_t r, uint16_t g, uint16_t b) {
-    CHANNEL_RED.CnV   = cie_lightness(r);
+    CHANNEL_RED.CnV = cie_lightness(r);
     CHANNEL_GREEN.CnV = cie_lightness(g);
-    CHANNEL_BLUE.CnV  = cie_lightness(b);
+    CHANNEL_BLUE.CnV = cie_lightness(b);
 }
 
-__attribute__ ((weak)) void matrix_init_user(void) {}
-
-__attribute__ ((weak)) void matrix_scan_user(void) {}
-
-
-void keyboard_pre_init_kb() {
-#ifdef LED_MATRIX_ENABLE
-    // Turn on LED controller
-    setPinOutput(B16);
-    writePinHigh(B16);
-#endif
-    keyboard_pre_init_user();
+__attribute__ ((weak))
+void matrix_init_user(void) {
 }
 
+__attribute__ ((weak))
+void matrix_scan_user(void) {
+}
+
+
 void matrix_init_kb(void) {
     // put your keyboard start-up code here
     // runs once when the firmware starts up
 
-#ifdef LED_MATRIX_ENABLE
-    /*
-     * Since K20x is stuck with a 32 byte EEPROM (see tmk_core/common/chibios/eeprom_teensy.c),
-     * and neither led_matrix_eeconfig.speed or .flags fit in this boundary, just force their values to default on boot.
-     */
-#    if !defined(LED_MATRIX_STARTUP_SPD)
-#        define LED_MATRIX_STARTUP_SPD UINT8_MAX / 2
-#    endif
-    led_matrix_set_speed(LED_MATRIX_STARTUP_SPD);
-    led_matrix_set_flags(LED_FLAG_ALL);
-#endif
-
     matrix_init_user();
     // The backlight always has to be initialized, otherwise it will stay lit
 #ifndef VISUALIZER_ENABLE
     lcd_backlight_hal_init();
 #endif
-#if (defined(LED_MATRIX_ENABLE) || defined(WPM_ENABLE))
-    add_remote_objects(remote_objects, sizeof(remote_objects) / sizeof(remote_object_t *));
+#ifdef WPM_ENABLE
+    add_remote_objects(remote_objects, sizeof(remote_objects) / sizeof(remote_object_t*));
 #endif
 }
 
@@ -178,30 +137,6 @@ void matrix_scan_kb(void) {
     // put your looping keyboard code here
     // runs every cycle (a lot)
 
-#ifdef LED_MATRIX_ENABLE
-    if (is_serial_link_master()) {
-        if (!led_matrix_get_suspend_state()) {
-            if (timer_elapsed(led_matrix_sent_timer) >= 5000 || memcmp((void *)&last_sent_led_matrix, (void *)&led_matrix_eeconfig, sizeof(last_sent_led_matrix))) {
-                led_matrix_sent_timer = timer_read();
-                memcpy((void *)&last_sent_led_matrix, (void *)&led_matrix_eeconfig, sizeof(last_sent_led_matrix));
-                *begin_write_led_matrix() = last_sent_led_matrix;
-                end_write_led_matrix();
-            }
-        }
-    } else if (is_serial_link_connected()) {
-        bool *new_led_suspend_state = read_led_suspend_state();
-        if (new_led_suspend_state) {
-            led_matrix_set_suspend_state(*new_led_suspend_state);
-        }
-        if (!led_matrix_get_suspend_state()) {
-            led_eeconfig_t *new_led_matrix = read_led_matrix();
-            if (new_led_matrix) {
-                memcpy((void *)&led_matrix_eeconfig, (void *)new_led_matrix, sizeof(last_sent_led_matrix));
-            }
-        }
-    }
-#endif
-
 #ifdef WPM_ENABLE
     if (is_serial_link_master()) {
         uint8_t current_wpm = get_current_wpm();
@@ -211,68 +146,67 @@ void matrix_scan_kb(void) {
             last_sent_wpm = current_wpm;
         }
     } else if (is_serial_link_connected()) {
-        uint8_t *new_wpm = read_current_wpm();
+        uint8_t* new_wpm = read_current_wpm();
         if (new_wpm) {
             set_current_wpm(*new_wpm);
         }
     }
 #endif
-
     matrix_scan_user();
 }
 
-bool is_keyboard_master(void) { return is_serial_link_master(); }
-
-bool is_keyboard_left(void) {
-#if defined(EE_HANDS)
-    return eeconfig_read_handedness();
-#elif defined(MASTER_IS_ON_RIGHT)
-    return !is_keyboard_master();
-#else
-    return is_keyboard_master();
-#endif
+bool is_keyboard_master(void) {
+    return is_serial_link_master();
 }
 
-__attribute__ ((weak)) void ergodox_board_led_on(void) {}
-
-__attribute__ ((weak)) void ergodox_right_led_1_on(void) {}
-
-__attribute__ ((weak)) void ergodox_right_led_2_on(void) {}
-
-__attribute__ ((weak)) void ergodox_right_led_3_on(void) {}
-
-__attribute__ ((weak)) void ergodox_board_led_off(void) {}
-
-__attribute__ ((weak)) void ergodox_right_led_1_off(void) {}
-
-__attribute__ ((weak)) void ergodox_right_led_2_off(void) {}
-
-__attribute__ ((weak)) void ergodox_right_led_3_off(void) {}
-
-__attribute__ ((weak)) void ergodox_right_led_1_set(uint8_t n) {}
-
-__attribute__ ((weak)) void ergodox_right_led_2_set(uint8_t n) {}
-
-__attribute__ ((weak)) void ergodox_right_led_3_set(uint8_t n) {}
-
-void suspend_power_down_kb(void) {
-#ifdef LED_MATRIX_ENABLE
-    send_led_suspend_state();
-#endif
-    suspend_power_down_user();
+__attribute__ ((weak))
+void ergodox_board_led_on(void){
 }
 
-void suspend_wakeup_init_kb(void) {
-#ifdef LED_MATRIX_ENABLE
-    send_led_suspend_state();
-#endif
-    suspend_wakeup_init_user();
+__attribute__ ((weak))
+void ergodox_right_led_1_on(void){
+}
+
+__attribute__ ((weak))
+void ergodox_right_led_2_on(void){
+}
+
+__attribute__ ((weak))
+void ergodox_right_led_3_on(void){
+}
+
+__attribute__ ((weak))
+void ergodox_board_led_off(void){
+}
+
+__attribute__ ((weak))
+void ergodox_right_led_1_off(void){
+}
+
+__attribute__ ((weak))
+void ergodox_right_led_2_off(void){
+}
+
+__attribute__ ((weak))
+void ergodox_right_led_3_off(void){
+}
+
+__attribute__ ((weak))
+void ergodox_right_led_1_set(uint8_t n) {
+}
+
+__attribute__ ((weak))
+void ergodox_right_led_2_set(uint8_t n) {
+}
+
+__attribute__ ((weak))
+void ergodox_right_led_3_set(uint8_t n) {
 }
 
 #ifdef SWAP_HANDS_ENABLE
 __attribute__ ((weak))
 const keypos_t PROGMEM hand_swap_config[MATRIX_ROWS][MATRIX_COLS] = {
-    {{0,  9}, {1,  9}, {2,  9}, {3,  9}, {4,  9}},
+    {{0, 9}, {1, 9}, {2, 9}, {3, 9}, {4, 9}},
     {{0, 10}, {1, 10}, {2, 10}, {3, 10}, {4, 10}},
     {{0, 11}, {1, 11}, {2, 11}, {3, 11}, {4, 11}},
     {{0, 12}, {1, 12}, {2, 12}, {3, 12}, {4, 12}},
@@ -292,115 +226,3 @@ const keypos_t PROGMEM hand_swap_config[MATRIX_ROWS][MATRIX_COLS] = {
     {{0, 8}, {1, 8}, {2, 8}, {3, 8}, {4, 8}},
 };
 #endif
-
-#ifdef LED_MATRIX_ENABLE
-const is31_led g_is31_leds[DRIVER_LED_TOTAL] = {
-// The numbers in the comments are the led numbers DXX on the PCB
-/* Refer to IS31 manual for these locations
- *  driver
- *  |   LED address
- *  |   | */
-// Left half
-//      45           44           43           42           41           40           39
-   { 0, C2_2 }, { 0, C1_2 }, { 0, C5_1 }, { 0, C4_1 }, { 0, C3_1 }, { 0, C2_1 }, { 0, C1_1 },
-//      52           51           50           49           48           47           46
-   { 0, C4_3 }, { 0, C3_3 }, { 0, C2_3 }, { 0, C1_3 }, { 0, C5_2 }, { 0, C4_2 }, { 0, C3_2 },
-//      58           57           56           55           54           53
-   { 0, C5_4 }, { 0, C4_4 }, { 0, C3_4 }, { 0, C2_4 }, { 0, C1_4 }, { 0, C5_3 },
-//      67           66           65           64           63           62           61
-   { 0, C4_6 }, { 0, C3_6 }, { 0, C2_6 }, { 0, C1_6 }, { 0, C5_5 }, { 0, C4_5 }, { 0, C3_5 },
-//      76           75           74           73           72
-   { 0, C4_8 }, { 0, C3_8 }, { 0, C2_8 }, { 0, C1_8 }, { 0, C4_7 },
-//                                                                                    60           59
-                                                                                 { 0, C2_5 }, { 0, C1_5 },
-//                                                                                                 68
-                                                                                              { 0, C5_6 },
-//                                                                       71           70           69
-                                                                    { 0, C3_7 }, { 0, C2_7 }, { 0, C1_7 },
-// Right half (mirrored)
-// Due to how LED_MATRIX_SPLIT is implemented, only the first half of g_is31_leds is actually used.
-// Luckily, the right half has the same LED pinouts, just mirrored.
-//      45           44           43           42           41           40           39
-   { 0, C2_2 }, { 0, C1_2 }, { 0, C5_1 }, { 0, C4_1 }, { 0, C3_1 }, { 0, C2_1 }, { 0, C1_1 },
-//      52           51           50           49           48           47           46
-   { 0, C4_3 }, { 0, C3_3 }, { 0, C2_3 }, { 0, C1_3 }, { 0, C5_2 }, { 0, C4_2 }, { 0, C3_2 },
-//      58           57           56           55           54           53
-   { 0, C5_4 }, { 0, C4_4 }, { 0, C3_4 }, { 0, C2_4 }, { 0, C1_4 }, { 0, C5_3 },
-//      67           66           65           64           63           62           61
-   { 0, C4_6 }, { 0, C3_6 }, { 0, C2_6 }, { 0, C1_6 }, { 0, C5_5 }, { 0, C4_5 }, { 0, C3_5 },
-//      76           75           74           73           72
-   { 0, C4_8 }, { 0, C3_8 }, { 0, C2_8 }, { 0, C1_8 }, { 0, C4_7 },
-//                                                                                    60           59
-                                                                                 { 0, C2_5 }, { 0, C1_5 },
-//                                                                                                 68
-                                                                                              { 0, C5_6 },
-//                                                                       71           70           69
-                                                                    { 0, C3_7 }, { 0, C2_7 }, { 0, C1_7 },
-};
-
-led_config_t g_led_config = {
-    {
-        // Key Matrix to LED Index
-        // Left half
-        { NO_LED, NO_LED, NO_LED,     33,     34 },
-        { NO_LED, NO_LED, NO_LED,     32,     37 },
-        {      6,     13, NO_LED,     26,     36 },
-        {      5,     12,     19,     25,     35 },
-        {      4,     11,     18,     24,     31 },
-        {      3,     10,     17,     23,     30 },
-        {      2,      9,     16,     22,     29 },
-        {      1,      8,     15,     21,     28 },
-        {      0,      7,     14,     20,     27 },
-        // Right half
-        { NO_LED, NO_LED, NO_LED,     71,     72 },
-        { NO_LED, NO_LED, NO_LED,     70,     75 },
-        {     44,     51, NO_LED,     64,     74 },
-        {     43,     50,     57,     63,     73 },
-        {     42,     49,     56,     62,     69 },
-        {     41,     48,     55,     61,     68 },
-        {     40,     47,     54,     60,     67 },
-        {     39,     46,     53,     59,     66 },
-        {     38,     45,     52,     58,     65 },
-    }, {
-        // LED Index to Physical Position (assumes a reasonable gap between halves)
-	// Left half
-        {   0,  3 }, {  15,  3 }, {  27,  1 }, {  39,  0 }, {  51,  1 }, {  63,  2 }, {  75,  2 },
-        {   0, 13 }, {  15, 13 }, {  27, 11 }, {  39, 10 }, {  51, 11 }, {  63, 12 }, {  78, 17 },
-        {   0, 23 }, {  15, 23 }, {  27, 21 }, {  39, 20 }, {  51, 21 }, {  63, 22 },
-        {   0, 33 }, {  15, 33 }, {  27, 31 }, {  39, 30 }, {  51, 31 }, {  63, 32 }, {  78, 32 },
-        {   4, 43 }, {  15, 43 }, {  27, 41 }, {  39, 40 }, {  51, 41 },
-                                                                                      {  89, 41 }, { 100, 46 },
-                                                                                                   {  95, 55 },
-                                                                         {  72, 54 }, {  83, 59 }, {  90, 64 },
-        // Right half (mirrored)
-        { 224,  3 }, { 209,  3 }, { 197,  1 }, { 185,  0 }, { 173,  1 }, { 161,  2 }, { 149,  2 },
-        { 224, 13 }, { 209, 13 }, { 197, 11 }, { 185, 10 }, { 173, 11 }, { 161, 12 }, { 146, 17 },
-        { 224, 23 }, { 209, 23 }, { 197, 21 }, { 185, 20 }, { 173, 21 }, { 161, 22 },
-        { 224, 33 }, { 209, 33 }, { 197, 31 }, { 185, 30 }, { 173, 31 }, { 161, 32 }, { 146, 32 },
-        { 220, 43 }, { 209, 43 }, { 197, 41 }, { 185, 40 }, { 173, 41 },
-                                                                                      { 135, 41 }, { 124, 46 },
-                                                                                                   { 129, 55 },
-                                                                         { 152, 54 }, { 141, 59 }, { 134, 64 },
-    }, {
-        // LED Index to Flag
-        // Left half
-        1, 4, 4, 4, 4, 4, 1,
-        1, 4, 4, 4, 4, 4, 1,
-        1, 4, 4, 4, 4, 4,
-        1, 4, 4, 4, 4, 4, 1,
-        1, 1, 1, 1, 1,
-                          1, 1,
-                             1,
-                       1, 1, 1,
-        // Right half (mirrored)
-        1, 4, 4, 4, 4, 4, 1,
-        1, 4, 4, 4, 4, 4, 1,
-        1, 4, 4, 4, 4, 4,
-        1, 4, 4, 4, 4, 4, 1,
-        1, 1, 1, 1, 1,
-                          1, 1,
-                             1,
-                       1, 1, 1,
-    }
-};
-#endif

keyboards/ergodox_infinity/matrix.c

@@ -24,7 +24,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "print.h"
 #include "debug.h"
 #include "matrix.h"
-#include "keyboard.h"
+#include "eeconfig.h"
 #include "serial_link/system/serial_link.h"
 
 
@@ -119,9 +119,15 @@ uint8_t matrix_scan(void)
     }
 
     uint8_t offset = 0;
-    if (is_serial_link_master() && !is_keyboard_left()) {
+#if (defined(EE_HANDS) || defined(MASTER_IS_ON_RIGHT))
+#ifdef EE_HANDS
+    if (is_serial_link_master() && !eeconfig_read_handedness()) {
+#else
+    if (is_serial_link_master()) {
+#endif
         offset = MATRIX_ROWS - LOCAL_MATRIX_ROWS;
     }
+#endif
 
     if (debouncing && timer_elapsed(debouncing_time) > DEBOUNCE) {
         for (int row = 0; row < LOCAL_MATRIX_ROWS; row++) {
@@ -161,11 +167,17 @@ void matrix_print(void)
 
 void matrix_set_remote(matrix_row_t* rows, uint8_t index) {
     uint8_t offset = 0;
-    if (is_keyboard_left()) {
+#ifdef EE_HANDS
+    if (eeconfig_read_handedness()) {
         offset = LOCAL_MATRIX_ROWS * (index + 1);
     } else {
         offset = MATRIX_ROWS - LOCAL_MATRIX_ROWS * (index + 2);
     }
+#elif defined(MASTER_IS_ON_RIGHT)
+    offset = MATRIX_ROWS - LOCAL_MATRIX_ROWS * (index + 2);
+#else
+    offset = LOCAL_MATRIX_ROWS * (index + 1);
+#endif
     for (int row = 0; row < LOCAL_MATRIX_ROWS; row++) {
         matrix[offset + row] = rows[row];
     }

keyboards/ergodox_infinity/rules.mk

@@ -22,6 +22,8 @@ CUSTOM_MATRIX = yes # Custom matrix file
 SERIAL_LINK_ENABLE = yes
 VISUALIZER_ENABLE = yes
 LCD_ENABLE = yes
+BACKLIGHT_ENABLE = yes
+BACKLIGHT_DRIVER = custom
 LCD_BACKLIGHT_ENABLE = yes
 MIDI_ENABLE = no
 RGBLIGHT_ENABLE = no
@@ -30,8 +32,9 @@ LCD_DRIVER = st7565
 LCD_WIDTH = 128
 LCD_HEIGHT = 32
 
-LED_MATRIX_ENABLE = yes
-LED_MATRIX_DRIVER = IS31FL3731
+LED_DRIVER = is31fl3731c
+LED_WIDTH = 7
+LED_HEIGHT = 7
 
 # project specific files
 SRC = matrix.c \