Add rgblight_reload_from_eeprom() (#11411)

* Add rgblight_reset_from_eeprom()

* reset->reload

bootloader.mk

@@ -20,15 +20,19 @@
 # Sets the bootloader defined in the keyboard's/keymap's rules.mk
 # Current options:
 #
-# halfkay        PJRC Teensy
-# caterina       Pro Micro (Sparkfun/generic)
-# atmel-dfu      Atmel factory DFU
-# lufa-dfu       LUFA DFU
-# qmk-dfu        QMK DFU (LUFA + blinkenlight)
-# bootloadHID    HIDBootFlash compatible (ATmega32A)
-# USBasp         USBaspLoader (ATmega328P)
-# kiibohd        Input:Club Kiibohd bootloader (only used on their boards)
-# stm32duino     STM32Duino (STM32F103x8)
+# AVR:
+#     halfkay     PJRC Teensy
+#     caterina    Pro Micro (Sparkfun/generic)
+#     atmel-dfu   Atmel factory DFU
+#     lufa-dfu    LUFA DFU
+#     qmk-dfu     QMK DFU (LUFA + blinkenlight)
+#     bootloadHID HIDBootFlash compatible (ATmega32A)
+#     USBasp      USBaspLoader (ATmega328P)
+# ARM:
+#     kiibohd     Input:Club Kiibohd bootloader (only used on their boards)
+#     stm32duino  STM32Duino (STM32F103x8)
+#     stm32-dfu   STM32 USB DFU in ROM
+#     apm32-dfu   APM32 USB DFU in ROM
 #
 # BOOTLOADER_SIZE can still be defined manually, but it's recommended
 # you add any possible configuration to this list
@@ -95,6 +99,20 @@ ifdef BOOTLOADER_SIZE
     OPT_DEFS += -DBOOTLOADER_SIZE=$(strip $(BOOTLOADER_SIZE))
 endif
 
+ifeq ($(strip $(BOOTLOADER)), stm32-dfu)
+    OPT_DEFS += -DBOOTLOADER_STM32_DFU
+
+    # Options to pass to dfu-util when flashing
+    DFU_ARGS ?= -d 0483:DF11 -a 0 -s 0x08000000:leave
+    DFU_SUFFIX_ARGS ?= -v 0483 -p DF11
+endif
+ifeq ($(strip $(BOOTLOADER)), apm32-dfu)
+    OPT_DEFS += -DBOOTLOADER_APM32_DFU
+
+    # Options to pass to dfu-util when flashing
+    DFU_ARGS ?= -d 314B:0106 -a 0 -s 0x08000000:leave
+    DFU_SUFFIX_ARGS ?= -v 314B -p 0106
+endif
 ifeq ($(strip $(BOOTLOADER)), kiibohd)
     OPT_DEFS += -DBOOTLOADER_KIIBOHD
     ifeq ($(strip $(MCU_ORIG)), MK20DX128)
@@ -104,10 +122,10 @@ ifeq ($(strip $(BOOTLOADER)), kiibohd)
         MCU_LDSCRIPT = MK20DX256BLDR8
     endif
 
+    # Options to pass to dfu-util when flashing
     DFU_ARGS = -d 1C11:B007
     DFU_SUFFIX_ARGS = -v 1C11 -p B007
 endif
-
 ifeq ($(strip $(BOOTLOADER)), stm32duino)
     OPT_DEFS += -DBOOTLOADER_STM32DUINO
     MCU_LDSCRIPT = STM32F103x8_stm32duino_bootloader
@@ -115,6 +133,7 @@ ifeq ($(strip $(BOOTLOADER)), stm32duino)
     # STM32F103 does NOT have an USB bootloader in ROM (only serial), so setting anything here does not make much sense
     STM32_BOOTLOADER_ADDRESS = 0x80000000
 
-    DFU_ARGS = -d 1EAF:0003 -a2 -R
+    # Options to pass to dfu-util when flashing
+    DFU_ARGS = -d 1EAF:0003 -a 2 -R
     DFU_SUFFIX_ARGS = -v 1EAF -p 0003
 endif

common_features.mk

@@ -24,6 +24,8 @@ QUANTUM_SRC += \
 ifeq ($(strip $(DEBUG_MATRIX_SCAN_RATE_ENABLE)), yes)
     OPT_DEFS += -DDEBUG_MATRIX_SCAN_RATE
     CONSOLE_ENABLE = yes
+else ifeq ($(strip $(DEBUG_MATRIX_SCAN_RATE_ENABLE)), api)
+    OPT_DEFS += -DDEBUG_MATRIX_SCAN_RATE
 endif
 
 ifeq ($(strip $(API_SYSEX_ENABLE)), yes)

docs/README.md

@@ -1,26 +1,20 @@
 # Quantum Mechanical Keyboard Firmware
 
-[![Current Version](https://img.shields.io/github/tag/qmk/qmk_firmware.svg)](https://github.com/qmk/qmk_firmware/tags)
-[![Build Status](https://travis-ci.org/qmk/qmk_firmware.svg?branch=master)](https://travis-ci.org/qmk/qmk_firmware)
-[![Discord](https://img.shields.io/discord/440868230475677696.svg)](https://discord.gg/Uq7gcHh)
-[![Docs Status](https://img.shields.io/badge/docs-ready-orange.svg)](https://docs.qmk.fm)
-[![GitHub contributors](https://img.shields.io/github/contributors/qmk/qmk_firmware.svg)](https://github.com/qmk/qmk_firmware/pulse/monthly)
-[![GitHub forks](https://img.shields.io/github/forks/qmk/qmk_firmware.svg?style=social&label=Fork)](https://github.com/qmk/qmk_firmware/)
-
 ## What is QMK Firmware?
 
 QMK (*Quantum Mechanical Keyboard*) is an open source community centered around developing computer input devices. The community encompasses all sorts of input devices, such as keyboards, mice, and MIDI devices. A core group of collaborators maintains [QMK Firmware](https://github.com/qmk/qmk_firmware), [QMK Configurator](https://config.qmk.fm), [QMK Toolbox](https://github.com/qmk/qmk_toolbox), [qmk.fm](https://qmk.fm), and this documentation with the help of community members like you.
 
 ## Get Started
 
-Totally new to QMK? There are two ways to get started:
+<div class="flex-container">
 
-* Basic: [QMK Configurator](https://config.qmk.fm)
-    * Just select your keyboard from the dropdown and program your keyboard.
-    * We have an [introductory video](https://www.youtube.com/watch?v=-imgglzDMdY) you can watch.
-    * There is also an overview [document you can read](newbs_building_firmware_configurator.md).
-* Advanced: [Use The Source](newbs.md)
-    * More powerful, but harder to use
+?> **Basic** [QMK Configurator](newbs_building_firmware_configurator.md) <br>
+User friendly graphical interfaces, no programming knowledge required.
+
+?> **Advanced** [Use The Source](newbs.md) <br> 
+More powerful, but harder to use.
+
+</div>
 
 ## Make It Yours
 

docs/_summary.md

@@ -3,7 +3,6 @@
   * [Setup](newbs_getting_started.md)
   * [Building Your First Firmware](newbs_building_firmware.md)
   * [Flashing Firmware](newbs_flashing.md)
-  * [Testing and Debugging](newbs_testing_debugging.md)
   * [Getting Help/Support](support.md)
   * [Other Resources](newbs_learn_more_resources.md)
   * [Syllabus](syllabus.md)
@@ -11,7 +10,8 @@
 * FAQs
   * [General FAQ](faq_general.md)
   * [Build/Compile QMK](faq_build.md)
-  * [Debugging/Troubleshooting QMK](faq_debug.md)
+  * [Troubleshooting QMK](faq_misc.md)
+  * [Debugging QMK](faq_debug.md)
   * [Keymap FAQ](faq_keymap.md)
   * [Glossary](reference_glossary.md)
 

docs/cli_commands.md

@@ -11,13 +11,13 @@ This command is directory aware. It will automatically fill in KEYBOARD and/or K
 **Usage for Configurator Exports**:
 
 ```
-qmk compile <configuratorExport.json>
+qmk compile [-c] <configuratorExport.json>
 ```
 
 **Usage for Keymaps**:
 
 ```
-qmk compile -kb <keyboard_name> -km <keymap_name>
+qmk compile [-c] [-e <var>=<value>] -kb <keyboard_name> -km <keymap_name>
 ```
 
 **Usage in Keyboard Directory**:  
@@ -82,13 +82,13 @@ This command is directory aware. It will automatically fill in KEYBOARD and/or K
 **Usage for Configurator Exports**:
 
 ```
-qmk flash <configuratorExport.json> -bl <bootloader>
+qmk flash [-bl <bootloader>] [-c] [-e <var>=<value>] <configuratorExport.json>
 ```
 
 **Usage for Keymaps**:
 
 ```
-qmk flash -kb <keyboard_name> -km <keymap_name> -bl <bootloader>
+qmk flash -kb <keyboard_name> -km <keymap_name> [-bl <bootloader>] [-c] [-e <var>=<value>]
 ```
 
 **Listing the Bootloaders**

docs/faq_build.md

@@ -17,7 +17,7 @@ or just:
 
 Note that running `make` with `sudo` is generally ***not*** a good idea, and you should use one of the former methods, if possible.
 
-### Linux `udev` Rules
+### Linux `udev` Rules :id=linux-udev-rules
 
 On Linux, you'll need proper privileges to communicate with the bootloader device. You can either use `sudo` when flashing firmware (not recommended), or place [this file](https://github.com/qmk/qmk_firmware/tree/master/util/udev/50-qmk.rules) into `/etc/udev/rules.d/`.
 

docs/faq_debug.md

@@ -2,7 +2,94 @@
 
 This page details various common questions people have about troubleshooting their keyboards.
 
-# Debug Console
+## Debugging :id=debugging
+
+Your keyboard will output debug information if you have `CONSOLE_ENABLE = yes` in your `rules.mk`. By default the output is very limited, but you can turn on debug mode to increase the amount of debug output. Use the `DEBUG` keycode in your keymap, use the [Command](feature_command.md) feature to enable debug mode, or add the following code to your keymap.
+
+```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;
+}
+```
+
+## Debugging Tools
+
+There are two different tools you can use to debug your keyboard.
+
+### Debugging With QMK Toolbox
+
+For compatible platforms, [QMK Toolbox](https://github.com/qmk/qmk_toolbox) can be used to display debug messages from your keyboard.
+
+### Debugging With hid_listen
+
+Prefer a terminal based solution? [hid_listen](https://www.pjrc.com/teensy/hid_listen.html), provided by PJRC, can also be used to display debug messages. Prebuilt binaries for Windows,Linux,and MacOS are available.
+
+## Sending Your Own Debug Messages
+
+Sometimes it's useful to print debug messages from within your [custom code](custom_quantum_functions.md). Doing so is pretty simple. Start by including `print.h` at the top of your file:
+
+```c
+#include "print.h"
+```
+
+After that you can use a few different print functions:
+
+* `print("string")`: Print a simple string.
+* `uprintf("%s string", var)`: Print a formatted string
+* `dprint("string")` Print a simple string, but only when debug mode is enabled
+* `dprintf("%s string", var)`: Print a formatted string, but only when debug mode is enabled
+
+## Debug Examples
+
+Below is a collection of real world debugging examples. For additional information, refer to [Debugging/Troubleshooting QMK](faq_debug.md).
+
+### Which matrix position is this keypress?
+
+When porting, or when attempting to diagnose pcb issues, it can be useful to know if a keypress is scanned correctly. To enable logging for this scenario, add the following code to your keymaps `keymap.c`
+
+```c
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  // If console is enabled, it will print the matrix position and status of each key pressed
+#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;
+}
+```
+
+Example output
+```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
+```
+
+### How long did it take to scan for a keypress?
+
+When testing performance issues, it can be useful to know the frequency at which the switch matrix is being scanned. To enable logging for this scenario, add the following code to your keymaps `config.h`
+
+```c
+#define DEBUG_MATRIX_SCAN_RATE
+```
+
+Example output
+```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` Can't Recognize Device
 When debug console of your device is not ready you will see like this:
@@ -11,7 +98,7 @@ When debug console of your device is not ready you will see like this:
 Waiting for device:.........
 ```
 
-once the device is plugged in then *hid_listen* finds it you will get this message:
+Once the device is plugged in then *hid_listen* finds it you will get this message:
 
 ```
 Waiting for new device:.........................
@@ -20,129 +107,12 @@ Listening:
 
 If you can't get this 'Listening:' message try building with `CONSOLE_ENABLE=yes` in [Makefile]
 
-You may need privilege to access the device on OS like Linux.
-- try `sudo hid_listen`
+You may need privileges to access the device an OS like Linux. Try `sudo hid_listen`.
 
 ## Can't Get Message on Console
 Check:
 - *hid_listen* finds your device. See above.
-- Enable debug with pressing **Magic**+d. See [Magic Commands](https://github.com/tmk/tmk_keyboard#magic-commands).
-- set `debug_enable=true`. See [Testing and Debugging](newbs_testing_debugging.md#debugging)
-- try using 'print' function instead of debug print. See **common/print.h**.
-- disconnect other devices with console function. See [Issue #97](https://github.com/tmk/tmk_keyboard/issues/97).
-
-***
-
-# Miscellaneous
-## Safety Considerations
-
-You probably don't want to "brick" your keyboard, making it impossible
-to rewrite firmware onto it.  Here are some of the parameters to show
-what things are (and likely aren't) too risky.
-
-- If your keyboard map does not include RESET, then, to get into DFU
-  mode, you will need to press the reset button on the PCB, which
-  requires unscrewing the bottom.
-- Messing with tmk_core / common files might make the keyboard
-  inoperable
-- Too large a .hex file is trouble; `make dfu` will erase the block,
-  test the size (oops, wrong order!), which errors out, failing to
-  flash the keyboard, leaving it in DFU mode.
-  - To this end, note that the maximum .hex file size on Planck is
-    7000h (28672 decimal)
-
-```
-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
-```
-
-  - The above file is of size 22396/577ch, which is less than
-    28672/7000h
-  - As long as you have a suitable alternative .hex file around, you
-    can retry, loading that one
-  - Some of the options you might specify in your keyboard's Makefile
-    consume extra memory; watch out for BOOTMAGIC_ENABLE,
-    MOUSEKEY_ENABLE, EXTRAKEY_ENABLE, CONSOLE_ENABLE, API_SYSEX_ENABLE
-- DFU tools do /not/ allow you to write into the bootloader (unless
-  you throw in extra fruit salad of options), so there is little risk
-  there.
-- EEPROM has around a 100000 write cycle.  You shouldn't rewrite the
-  firmware repeatedly and continually; that'll burn the EEPROM
-  eventually.
-
-## NKRO Doesn't work
-First you have to compile firmware with this build option `NKRO_ENABLE` in **Makefile**.
-
-Try `Magic` **N** command(`LShift+RShift+N` by default) when **NKRO** still doesn't work. You can use this command to toggle between **NKRO** and **6KRO** mode temporarily. In some situations **NKRO** doesn't work you need to switch to **6KRO** mode, in particular when you are in BIOS.
-
-If your firmware built with `BOOTMAGIC_ENABLE` you need to turn its switch on by `BootMagic` **N** command(`Space+N` by default). This setting is stored in EEPROM and kept over power cycles.
-
-https://github.com/tmk/tmk_keyboard#boot-magic-configuration---virtual-dip-switch
-
-
-## TrackPoint Needs Reset Circuit (PS/2 Mouse Support)
-Without reset circuit you will have inconsistent result due to improper initialize of the hardware. See circuit schematic of TPM754.
-
-- http://geekhack.org/index.php?topic=50176.msg1127447#msg1127447
-- http://www.mikrocontroller.net/attachment/52583/tpm754.pdf
-
-
-## Can't Read Column of Matrix Beyond 16
-Use `1UL<<16` instead of `1<<16` in `read_cols()` in [matrix.h] when your columns goes beyond 16.
-
-In C `1` means one of [int] type which is [16 bit] in case of AVR so you can't shift left more than 15. You will get unexpected zero when you say `1<<16`. You have to use [unsigned long] type with `1UL`.
-
-http://deskthority.net/workshop-f7/rebuilding-and-redesigning-a-classic-thinkpad-keyboard-t6181-60.html#p146279
-
-## Special Extra Key Doesn't Work (System, Audio Control Keys)
-You need to define `EXTRAKEY_ENABLE` in `rules.mk` to use them in QMK.
-
-```
-EXTRAKEY_ENABLE = yes          # Audio control and System control
-```
-
-## Wakeup from Sleep Doesn't Work
-
-In Windows check `Allow this device to wake the computer` setting in Power **Management property** tab of **Device Manager**. Also check BIOS setting.
-
-Pressing any key during sleep should wake host.
-
-## Using Arduino?
-
-**Note that Arduino pin naming is different from actual chip.** For example, Arduino pin `D0` is not `PD0`. Check circuit with its schematics yourself.
-
-- http://arduino.cc/en/uploads/Main/arduino-leonardo-schematic_3b.pdf
-- http://arduino.cc/en/uploads/Main/arduino-micro-schematic.pdf
-
-Arduino Leonardo and micro have **ATMega32U4** and can be used for TMK, though Arduino bootloader may be a problem.
-
-## Enabling JTAG
-
-By default, the JTAG debugging interface is disabled as soon as the keyboard starts up. JTAG-capable MCUs come from the factory with the `JTAGEN` fuse set, and it takes over certain pins of the MCU that the board may be using for the switch matrix, LEDs, etc.
-
-If you would like to keep JTAG enabled, just add the following to your `config.h`:
-
-```c
-#define NO_JTAG_DISABLE
-```
-
-## USB 3 Compatibility
-I heard some people have a problem with USB 3 port, try USB 2 port.
-
-
-## Mac Compatibility
-### OS X 10.11 and Hub
-https://geekhack.org/index.php?topic=14290.msg1884034#msg1884034
-
-
-## Problem on BIOS (UEFI)/Resume (Sleep & Wake)/Power Cycles
-Some people reported their keyboard stops working on BIOS and/or after resume(power cycles).
-
-As of now root of its cause is not clear but some build options seem to be related. In Makefile try to disable those options like `CONSOLE_ENABLE`, `NKRO_ENABLE`, `SLEEP_LED_ENABLE` and/or others.
-
-https://github.com/tmk/tmk_keyboard/issues/266
-https://geekhack.org/index.php?topic=41989.msg1967778#msg1967778
+- Enable debug by pressing **Magic**+d. See [Magic Commands](https://github.com/tmk/tmk_keyboard#magic-commands).
+- Set `debug_enable=true`. See [Debugging](#debugging)
+- Try using `print` function instead of debug print. See **common/print.h**.
+- Disconnect other devices with console function. See [Issue #97](https://github.com/tmk/tmk_keyboard/issues/97).

docs/faq_general.md

@@ -34,7 +34,7 @@ Additionally, you can find additional `git` and GitHub related links [here](newb
 
 Awesome! Open up a Pull Request for it. We'll review the code, and merge it!
 
-### What if I want to do brand it with `QMK`?
+### What if I want to brand it with `QMK`?
 
 That's amazing! We would love to assist you with that!
 

docs/faq_misc.md

@@ -0,0 +1,117 @@
+# Miscellaneous FAQ
+
+## How do I test my keyboard? :id=testing
+
+Testing your keyboard is usually pretty straightforward. Press every single key and make sure it sends the keys you expect. You can use [QMK Configurator](https://config.qmk.fm/#/test/)'s test mode to check your keyboard, even if it doesn't run QMK.
+
+## Safety Considerations
+
+You probably don't want to "brick" your keyboard, making it impossible
+to rewrite firmware onto it.  Here are some of the parameters to show
+what things are (and likely aren't) too risky.
+
+- If your keyboard map does not include RESET, then, to get into DFU
+  mode, you will need to press the reset button on the PCB, which
+  requires unscrewing the bottom.
+- Messing with tmk_core / common files might make the keyboard
+  inoperable
+- Too large a .hex file is trouble; `make dfu` will erase the block,
+  test the size (oops, wrong order!), which errors out, failing to
+  flash the keyboard, leaving it in DFU mode.
+  - To this end, note that the maximum .hex file size on e.g. Planck
+    is 7000h (28672 decimal)
+
+```
+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
+```
+
+  - The above file is of size 22396/577ch, which is less than
+    28672/7000h
+  - As long as you have a suitable alternative .hex file around, you
+    can retry, loading that one
+  - Some of the options you might specify in your keyboard's Makefile
+    consume extra memory; watch out for BOOTMAGIC_ENABLE,
+    MOUSEKEY_ENABLE, EXTRAKEY_ENABLE, CONSOLE_ENABLE, API_SYSEX_ENABLE
+- DFU tools do /not/ allow you to write into the bootloader (unless
+  you throw in an extra fruit salad of options), so there is little risk
+  there.
+- EEPROM has around a 100000 (100k) write cycle.  You shouldn't rewrite
+  the firmware repeatedly and continually; that'll burn the EEPROM
+  eventually.
+
+## NKRO Doesn't work
+First you have to compile firmware with the build option `NKRO_ENABLE` in **Makefile**.
+
+Try `Magic` **N** command(`LShift+RShift+N` by default) when **NKRO** still doesn't work. You can use this command to toggle between **NKRO** and **6KRO** mode temporarily. In some situations **NKRO** doesn't work and you will need to switch to **6KRO** mode, in particular when you are in BIOS.
+
+If your firmware was built with `BOOTMAGIC_ENABLE` you need to turn its switch on by `BootMagic` **N** command(`Space+N` by default). This setting is stored in EEPROM and kept over power cycles.
+
+https://github.com/tmk/tmk_keyboard#boot-magic-configuration---virtual-dip-switch
+
+
+## TrackPoint Needs Reset Circuit (PS/2 Mouse Support)
+Without reset circuit you will have inconsistent result due to improper initialization of the hardware. See circuit schematic of TPM754:
+
+- http://geekhack.org/index.php?topic=50176.msg1127447#msg1127447
+- http://www.mikrocontroller.net/attachment/52583/tpm754.pdf
+
+
+## Can't Read Column of Matrix Beyond 16
+Use `1UL<<16` instead of `1<<16` in `read_cols()` in [matrix.h] when your columns goes beyond 16.
+
+In C `1` means one of [int] type which is [16 bit] in case of AVR, so you can't shift left more than 15. Thus, calculating `1<<16` will unexpectedly equal zero. To work around this, you have to use [unsigned long] type with `1UL`.
+
+http://deskthority.net/workshop-f7/rebuilding-and-redesigning-a-classic-thinkpad-keyboard-t6181-60.html#p146279
+
+## Special Extra Key Doesn't Work (System, Audio Control Keys)
+You need to define `EXTRAKEY_ENABLE` in `rules.mk` to use them in QMK.
+
+```
+EXTRAKEY_ENABLE = yes          # Audio control and System control
+```
+
+## Wake from Sleep Doesn't Work
+
+In Windows check `Allow this device to wake the computer` setting in **Power Management** property tab of **Device Manager**. Also check your BIOS settings. Pressing any key during sleep should wake host.
+
+## Using Arduino?
+
+**Note that Arduino pin naming is different from actual chip.** For example, Arduino pin `D0` is not `PD0`. Check circuit with its schematics yourself.
+
+- http://arduino.cc/en/uploads/Main/arduino-leonardo-schematic_3b.pdf
+- http://arduino.cc/en/uploads/Main/arduino-micro-schematic.pdf
+
+Arduino Leonardo and micro have **ATMega32U4** and can be used for TMK, though Arduino bootloader may be a problem.
+
+## Enabling JTAG
+
+By default, the JTAG debugging interface is disabled as soon as the keyboard starts up. JTAG-capable MCUs come from the factory with the `JTAGEN` fuse set, and it takes over certain pins of the MCU that the board may be using for the switch matrix, LEDs, etc.
+
+If you would like to keep JTAG enabled, just add the following to your `config.h`:
+
+```c
+#define NO_JTAG_DISABLE
+```
+
+## USB 3 Compatibility
+Some problems can be fixed by switching from a USB 3.x port to a USB 2.0 port.
+
+
+## Mac Compatibility
+### OS X 10.11 and Hub
+See here: https://geekhack.org/index.php?topic=14290.msg1884034#msg1884034
+
+
+## Problem in BIOS (UEFI) Setup/Resume (Sleep & Wake)/Power Cycles
+Some people reported their keyboard stops working in BIOS and/or after resume(power cycles).
+
+As of now the root cause is not clear, but some build options seem to be related. In Makefile, try to disable options like `CONSOLE_ENABLE`, `NKRO_ENABLE`, `SLEEP_LED_ENABLE` and/or others.
+
+More info:
+- https://github.com/tmk/tmk_keyboard/issues/266
+- https://geekhack.org/index.php?topic=41989.msg1967778#msg1967778

docs/feature_ps2_mouse.md

@@ -206,7 +206,7 @@ It's possible to enable a "scroll button/s" that when pressed will cause the mou
 To enable the feature, you must set a scroll button mask as follows:
 
 ```c
-#define PS2_MOUSE_SCROLL_BTN_MASK (1<<PS2_MOUSE_BUTTON_MIDDLE) /* Default */
+#define PS2_MOUSE_SCROLL_BTN_MASK (1<<PS2_MOUSE_BTN_MIDDLE) /* Default */
 ```
 
 To disable the scroll button feature:

docs/feature_rgb_matrix.md

@@ -296,6 +296,19 @@ You can disable a single effect by defining `DISABLE_[EFFECT_NAME]` in your `con
 |`#define DISABLE_RGB_MATRIX_SOLID_SPLASH`              |Disables `RGB_MATRIX_SOLID_SPLASH`             |
 |`#define DISABLE_RGB_MATRIX_SOLID_MULTISPLASH`         |Disables `RGB_MATRIX_SOLID_MULTISPLASH`        |
 
+### RGB Matrix Effect Typing Heatmap :id=rgb-matrix-effect-typing-heatmap
+
+This effect will color the RGB matrix according to a heatmap of recently pressed
+keys. Whenever a key is pressed its "temperature" increases as well as that of
+its neighboring keys. The temperature of each key is then decreased
+automatically every 25 milliseconds by default.
+
+In order to change the delay of temperature decrease define
+`RGB_MATRIX_TYPING_HEATMAP_DECREASE_DELAY_MS`:
+
+```c
+#define RGB_MATRIX_TYPING_HEATMAP_DECREASE_DELAY_MS 50
+```
 
 ## Custom RGB Matrix Effects :id=custom-rgb-matrix-effects
 

docs/feature_rgblight.md

@@ -187,6 +187,8 @@ const uint8_t RGBLED_GRADIENT_RANGES[] PROGMEM = {255, 170, 127, 85, 64};
 
 ## Lighting Layers
 
+?> **Note:** Lighting Layers is an RGB Light feature, it will not work for RGB Matrix. See [RGB Matrix Indicators](feature_rgb_matrix.md?indicators) for details on how to do so.
+
 By including `#define RGBLIGHT_LAYERS` in your `config.h` file you can enable lighting layers. These make
 it easy to use your underglow LEDs as status indicators to show which keyboard layer is currently active, or the state of caps lock, all without disrupting any animations. [Here's a video](https://youtu.be/uLGE1epbmdY) showing an example of what you can do.
 
@@ -194,7 +196,7 @@ it easy to use your underglow LEDs as status indicators to show which keyboard l
 
 By default, 8 layers are possible. This can be expanded to as many as 32 by overriding the definition of `RGBLIGHT_MAX_LAYERS` in `config.h` (e.g. `#define RGBLIGHT_MAX_LAYERS 32`). Please note, if you use a split keyboard, you will need to flash both sides of the split after changing this. Also, increasing the maximum will increase the firmware size, and will slow sync on split keyboards.
 
-To define a layer, we modify `keymap.c` to list out LED ranges and the colors we want to overlay on them using an array of `rgblight_segment_t` using the `RGBLIGHT_LAYER_SEGMENTS` macro. We can define multiple layers and enable/disable them independently:
+To define a layer, we modify `keymap.c` to list the LED ranges and the colors we want to overlay on them using an array of `rgblight_segment_t` using the `RGBLIGHT_LAYER_SEGMENTS` macro. We can define multiple layers and enable/disable them independently:
 
 ```c
 // Light LEDs 6 to 9 and 12 to 15 red when caps lock is active. Hard to ignore!
@@ -210,6 +212,10 @@ const rgblight_segment_t PROGMEM my_layer1_layer[] = RGBLIGHT_LAYER_SEGMENTS(
 const rgblight_segment_t PROGMEM my_layer2_layer[] = RGBLIGHT_LAYER_SEGMENTS(
     {11, 2, HSV_PURPLE}
 );
+// Light LEDs 13 & 14 in green when keyboard layer 3 is active
+const rgblight_segment_t PROGMEM my_layer3_layer[] = RGBLIGHT_LAYER_SEGMENTS(
+    {13, 2, HSV_GREEN}
+);
 // etc..
 ```
 
@@ -220,7 +226,8 @@ We combine these layers into an array using the `RGBLIGHT_LAYERS_LIST` macro, an
 const rgblight_segment_t* const PROGMEM my_rgb_layers[] = RGBLIGHT_LAYERS_LIST(
     my_capslock_layer,
     my_layer1_layer,    // Overrides caps lock layer
-    my_layer2_layer     // Overrides other layers
+    my_layer2_layer,    // Overrides other layers
+    my_layer3_layer     // Overrides other layers
 );
 
 void keyboard_post_init_user(void) {
@@ -236,17 +243,21 @@ Everything above just configured the definition of each lighting layer.
 We can now enable and disable the lighting layers whenever the state of the keyboard changes:
 
 ```c
-layer_state_t layer_state_set_user(layer_state_t state) {
-    // Both layers will light up if both kb layers are active
-    rgblight_set_layer_state(1, layer_state_cmp(state, 1));
-    rgblight_set_layer_state(2, layer_state_cmp(state, 2));
-    return state;
-}
-
 bool led_update_user(led_t led_state) {
     rgblight_set_layer_state(0, led_state.caps_lock);
     return true;
 }
+
+layer_state_t default_layer_state_set_user(layer_state_t state) {
+    rgblight_set_layer_state(1, layer_state_cmp(state, _DVORAK));
+    return state;
+}
+
+layer_state_t layer_state_set_user(layer_state_t state) {
+    rgblight_set_layer_state(2, layer_state_cmp(state, _FN));
+    rgblight_set_layer_state(3, layer_state_cmp(state, _ADJUST));
+    return state;
+}
 ```
 
 ### Lighting layer blink :id=lighting-layer-blink
@@ -350,6 +361,7 @@ rgblight_sethsv(HSV_GREEN, 2); // led 2
 |`rgblight_step_noeeprom()`                  |Change the mode to the next RGB animation in the list of enabled RGB animations (not written to EEPROM) |
 |`rgblight_step_reverse()`                   |Change the mode to the previous RGB animation in the list of enabled RGB animations |
 |`rgblight_step_reverse_noeeprom()`          |Change the mode to the previous RGB animation in the list of enabled RGB animations (not written to EEPROM) |
+|`rgblight_reload_from_eeprom()`             |Reload the effect configuration (enabled, mode and color) from EEPROM |
 
 #### effects mode disable/enable
 |Function                                    |Description  |
@@ -368,14 +380,14 @@ rgblight_sethsv(HSV_GREEN, 2); // led 2
 |`rgblight_increase_hue_noeeprom()`          |Increase the hue for effect range LEDs. This wraps around at maximum hue (not written to EEPROM) |
 |`rgblight_decrease_hue()`                   |Decrease the hue for effect range LEDs. This wraps around at minimum hue |
 |`rgblight_decrease_hue_noeeprom()`          |Decrease the hue for effect range LEDs. This wraps around at minimum hue (not written to EEPROM) |
-|`rgblight_increase_sat()`                   |Increase the saturation for effect range LEDs. This wraps around at maximum saturation |
-|`rgblight_increase_sat_noeeprom()`          |Increase the saturation for effect range LEDs. This wraps around at maximum saturation (not written to EEPROM) |
-|`rgblight_decrease_sat()`                   |Decrease the saturation for effect range LEDs. This wraps around at minimum saturation |
-|`rgblight_decrease_sat_noeeprom()`          |Decrease the saturation for effect range LEDs. This wraps around at minimum saturation (not written to EEPROM) |
-|`rgblight_increase_val()`                   |Increase the value for effect range LEDs. This wraps around at maximum value |
-|`rgblight_increase_val_noeeprom()`          |Increase the value for effect range LEDs. This wraps around at maximum value (not written to EEPROM) |
-|`rgblight_decrease_val()`                   |Decrease the value for effect range LEDs. This wraps around at minimum value |
-|`rgblight_decrease_val_noeeprom()`          |Decrease the value for effect range LEDs. This wraps around at minimum value (not written to EEPROM) |
+|`rgblight_increase_sat()`                   |Increase the saturation for effect range LEDs. This stops at maximum saturation |
+|`rgblight_increase_sat_noeeprom()`          |Increase the saturation for effect range LEDs. This stops at maximum saturation (not written to EEPROM) |
+|`rgblight_decrease_sat()`                   |Decrease the saturation for effect range LEDs. This stops at minimum saturation |
+|`rgblight_decrease_sat_noeeprom()`          |Decrease the saturation for effect range LEDs. This stops at minimum saturation (not written to EEPROM) |
+|`rgblight_increase_val()`                   |Increase the value for effect range LEDs. This stops at maximum value |
+|`rgblight_increase_val_noeeprom()`          |Increase the value for effect range LEDs. This stops at maximum value (not written to EEPROM) |
+|`rgblight_decrease_val()`                   |Decrease the value for effect range LEDs. This stops at minimum value |
+|`rgblight_decrease_val_noeeprom()`          |Decrease the value for effect range LEDs. This stops at minimum value (not written to EEPROM) |
 |`rgblight_sethsv(h, s, v)`                  |Set effect range LEDs to the given HSV value where `h`/`s`/`v` are between 0 and 255 |
 |`rgblight_sethsv_noeeprom(h, s, v)`         |Set effect range LEDs to the given HSV value where `h`/`s`/`v` are between 0 and 255 (not written to EEPROM) |
 

docs/feature_unicode.md

@@ -87,7 +87,7 @@ const qk_ucis_symbol_t ucis_symbol_table[] = UCIS_TABLE(
     UCIS_SYM("poop", 0x1F4A9),                // 💩
     UCIS_SYM("rofl", 0x1F923),                // 🤣
     UCIS_SYM("cuba", 0x1F1E8, 0x1F1FA),       // 🇨🇺
-    UCIS_SYM("look", 0x0CA0, 0x005F, 0x0CA0), // ಠ_ಠ
+    UCIS_SYM("look", 0x0CA0, 0x005F, 0x0CA0)  // ಠ_ಠ
 );
 ```
 

docs/flashing.md

@@ -1,242 +1,251 @@
 # Flashing Instructions and Bootloader Information
 
-There are quite a few different types of bootloaders that keyboards use, and just about all of them use a different flashing method. Luckily, projects like the [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) aim to be compatible with all the different types without having to think about it much, but this article will describe the different types of bootloaders, and available methods for flashing them.
+There are quite a few different types of bootloaders that keyboards use, and almost all of them use their own flashing method and tools. Luckily, projects like the [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) aim to support as many of them as possible, but this article will describe the different types of bootloaders, and available methods for flashing them.
 
-If you have a bootloader selected with the `BOOTLOADER` variable in your `rules.mk`, QMK will automatically calculate if your .hex file is the right size to be flashed to the device, and output the total size in bytes (along with the max).
+For AVR-based keyboards, QMK will automatically calculate if your `.hex` file is the right size to be flashed to the device based on the `BOOTLOADER` value set in `rules.mk`, and output the total size in bytes (along with the max).
 
-## DFU
+You will also be able to use the CLI to flash your keyboard, by running:
+```
+$ qmk flash -kb <keyboard> -km <keymap>
+```
+See the [`qmk flash`](cli_commands.md#qmk-flash) documentation for more information.
 
-Atmel's DFU bootloader comes on all atmega32u4 chips by default, and is used by many keyboards that have their own ICs on their PCBs (Older OLKB boards, Clueboards). Some keyboards may also use LUFA's DFU bootloader (or QMK's fork) (Newer OLKB boards) that adds in additional features specific to that hardware.
+## Atmel DFU
 
-To ensure compatibility with the DFU bootloader, make sure this block is present your `rules.mk` (optionally with `lufa-dfu` or `qmk-dfu` instead):
+Atmel's DFU bootloader comes on all USB AVRs by default (except for 16/32U4RC), and is used by many keyboards that have their own ICs on their PCBs (older OLKB boards, Clueboards). Some keyboards may also use LUFA's DFU bootloader, or QMK's fork of it (newer OLKB boards), that adds in additional features specific to that hardware.
+
+To ensure compatibility with the DFU bootloader, make sure this block is present in your `rules.mk` (optionally with `lufa-dfu` or `qmk-dfu` instead):
 
 ```make
 # Bootloader selection
-#   Teensy       halfkay
-#   Pro Micro    caterina
-#   Atmel DFU    atmel-dfu
-#   LUFA DFU     lufa-dfu
-#   QMK DFU      qmk-dfu
-#   ATmega32A    bootloadHID
-#   ATmega328P   USBasp
 BOOTLOADER = atmel-dfu
 ```
 
 Compatible flashers:
 
 * [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) (recommended GUI)
-* [dfu-programmer](https://github.com/dfu-programmer/dfu-programmer) / `:dfu` in QMK (recommended command line)
+* [dfu-programmer](https://github.com/dfu-programmer/dfu-programmer) / `:dfu` target in QMK (recommended command line)
 
 Flashing sequence:
 
-1. Press the `RESET` keycode, or tap the RESET button (or short RST to GND).
+1. Enter the bootloader using any of the following methods:
+    * Press the `RESET` keycode
+    * Press the `RESET` button on the PCB if available
+    * Short RST to GND quickly
 2. Wait for the OS to detect the device
-3. Erase the memory (may be done automatically)
+3. Erase the flash memory (will be done automatically if using the Toolbox or CLI/`make` command)
 4. Flash a .hex file
-5. Reset the device into application mode (may be done automatically)
-
-or:
-
-    make <keyboard>:<keymap>:dfu
+5. Reset the device into application mode (will be done automatically as above)
 
 ### QMK DFU
 
-QMK has a fork of the LUFA DFU bootloader that allows for a simple matrix scan for exiting the bootloader and returning to the application, as well as flashing an LED/making a ticking noise with a speaker when things are happening. To enable these features, use this block in your `config.h` (The key that exits the bootloader needs to be hooked-up to the INPUT and OUTPUT defined here):
+QMK maintains [a fork of the LUFA DFU bootloader](https://github.com/qmk/lufa/tree/master/Bootloaders/DFU) that additionally performs a simple matrix scan for exiting the bootloader and returning to the application, as well as flashing an LED/making a ticking noise with a speaker when things are happening. To enable these features, add the following defines to your `config.h`:
 
-    #define QMK_ESC_OUTPUT F1 // usually COL
-    #define QMK_ESC_INPUT D5 // usually ROW
-    #define QMK_LED E6
-    #define QMK_SPEAKER C6
+```c
+#define QMK_ESC_OUTPUT F1  // COL pin if COL2ROW
+#define QMK_ESC_INPUT  D5  // ROW pin if COL2ROW
+// Optional:
+//#define QMK_LED E6
+//#define QMK_SPEAKER C6
+```
+Currently we do not recommend making `QMK_ESC` the same key as the one designated for [Bootmagic Lite](feature_bootmagic.md#bootmagic-lite), as holding it down will cause the MCU to loop back and forth between entering and exiting the bootloader.
 
-The Manufacturer and Product names are automatically pulled from your `config.h`, and "Bootloader" is added to the product.
+The manufacturer and product strings are automatically pulled from `config.h`, with " Bootloader" appended to the product string.
 
-To generate this bootloader, use the `bootloader` target, eg `make planck/rev4:default:bootloader`.
+To generate this bootloader, use the `bootloader` target, eg. `make planck/rev4:default:bootloader`. To generate a production-ready .hex file (combining QMK and the bootloader), use the `production` target, eg. `make planck/rev4:default:production`.
 
-To generate a production-ready .hex file (containing the application and the bootloader), use the `production` target, eg `make planck/rev4:default:production`.
+### `make` Targets
 
-### DFU commands
-
-There are a number of DFU commands that you can use to flash firmware to a DFU device:
-
-* `:dfu` - This is the normal option and waits until a DFU device is available, and then flashes the firmware. This will check every 5 seconds, to see if a DFU device has appeared.
-* `:dfu-ee` - This flashes an `eep` file instead of the normal hex.  This is uncommon. 
-* `:dfu-split-left` - This flashes the normal firmware, just like the default option (`:dfu`). However, this also flashes the "Left Side" EEPROM file for split keyboards. _This is ideal for Elite C based split keyboards._
-* `:dfu-split-right` - This flashes the normal firmware, just like the default option (`:dfu`). However, this also flashes the "Right Side" EEPROM file for split keyboards. _This is ideal for Elite C based split keyboards._
+* `:dfu`: Checks every 5 seconds until a DFU device is available, and then flashes the firmware.
+* `:dfu-split-left` and `:dfu-split-right`: Flashes the firmware as with `:dfu`, but also sets the handedness setting in EEPROM. This is ideal for Elite-C-based split keyboards.
 
 ## Caterina
 
-Arduino boards and their clones use the [Caterina bootloader](https://github.com/arduino/ArduinoCore-avr/tree/master/bootloaders/caterina) (any keyboard built with a Pro Micro, or clone), and uses the avr109 protocol to communicate through virtual serial. Bootloaders like [A-Star](https://www.pololu.com/docs/0J61/9) are based on Caterina.
+Arduino boards and their clones use the [Caterina bootloader](https://github.com/arduino/ArduinoCore-avr/tree/master/bootloaders/caterina) or a variant of it (any keyboard built with a Pro Micro or clone, and the Pololu A-Star), and uses the AVR109 protocol to communicate through virtual serial.
 
-To ensure compatibility with the Caterina bootloader, make sure this block is present your `rules.mk`:
+To ensure compatibility with the Caterina bootloader, make sure this block is present in your `rules.mk`:
 
 ```make
 # Bootloader selection
-#   Teensy       halfkay
-#   Pro Micro    caterina
-#   Atmel DFU    atmel-dfu
-#   LUFA DFU     lufa-dfu
-#   QMK DFU      qmk-dfu
-#   ATmega32A    bootloadHID
-#   ATmega328P   USBasp
 BOOTLOADER = caterina
 ```
 
 Compatible flashers:
 
 * [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) (recommended GUI)
-* [avrdude](http://www.nongnu.org/avrdude/) with avr109 / `:avrdude` (recommended command line)
+* [avrdude](http://www.nongnu.org/avrdude/) with the `avr109` programmer / `:avrdude` target in QMK (recommended command line)
 * [AVRDUDESS](https://github.com/zkemble/AVRDUDESS)
 
 Flashing sequence:
 
-1. Press the `RESET` keycode, or short RST to GND quickly (you only have 7 seconds to flash once it enters)
+1. Enter the bootloader using any of the following methods (you only have 7 seconds to flash once it enters; some variants may require you to reset twice within 750 milliseconds):
+    * Press the `RESET` keycode
+    * Press the `RESET` button on the PCB if available
+    * Short RST to GND quickly
 2. Wait for the OS to detect the device
 3. Flash a .hex file
 4. Wait for the device to reset automatically
 
-or
+### `make` Targets
 
-    make <keyboard>:<keymap>:avrdude
+* `:avrdude`: Checks every 5 seconds until a Caterina device is available (by detecting a new COM port), and then flashes the firmware.
+* `:avrdude-loop`: Flashes the firmware as with `:avrdude`, but after each device is flashed, will attempt to flash again. This is useful for bulk flashing. Hit Ctrl+C to escape the loop.
+* `:avrdude-split-left` and `:avrdude-split-right`: Flashes the firmware as with `:avrdude`, but also sets the handedness setting in EEPROM. This is ideal for Pro Micro-based split keyboards.
 
+## HalfKay
 
-### Caterina commands
+HalfKay is a super-slim bootloader developed by PJRC that presents itself as an HID device (which requires no additional driver), and comes preflashed on all Teensys, namely the 2.0. It is currently closed-source, and thus once overwritten (eg. via ISP flashing another bootloader), cannot be restored.
 
-There are a number of DFU commands that you can use to flash firmware to a DFU device:
-
-* `:avrdude` - This is the normal option which waits until a Caterina device is available (by detecting a new COM port), and then flashes the firmware.
-* `:avrdude-loop` - This runs the same command as `:avrdude`, but after each device is flashed, it will attempt to flash again.  This is useful for bulk flashing. _This requires you to manually escape the loop by hitting Ctrl+C._
-* `:avrdude-split-left` - This flashes the normal firmware, just like the default option (`:avrdude`). However, this also flashes the "Left Side" EEPROM file for split keyboards. _This is ideal for Pro Micro based split keyboards._
-* `:avrdude-split-right` - This flashes the normal firmware, just like the default option (`:avrdude`). However, this also flashes the "Right Side" EEPROM file for split keyboards. _This is ideal for Pro Micro based split keyboards._
-
-
-
-## Halfkay
-
-Halfkay is a super-slim protocol developed by PJRC that uses HID, and comes on all Teensys (namely the 2.0).
-
-To ensure compatibility with the Halfkay bootloader, make sure this block is present your `rules.mk`:
+To ensure compatibility with the Halfkay bootloader, make sure this block is present in your `rules.mk`:
 
 ```make
 # Bootloader selection
-#   Teensy       halfkay
-#   Pro Micro    caterina
-#   Atmel DFU    atmel-dfu
-#   LUFA DFU     lufa-dfu
-#   QMK DFU      qmk-dfu
-#   ATmega32A    bootloadHID
-#   ATmega328P   USBasp
 BOOTLOADER = halfkay
 ```
 
 Compatible flashers:
 
 * [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) (recommended GUI)
+* [Teensy Loader Command Line](https://www.pjrc.com/teensy/loader_cli.html) / `:teensy` target in QMK (recommended command line)
 * [Teensy Loader](https://www.pjrc.com/teensy/loader.html)
-* [Teensy Loader Command Line](https://www.pjrc.com/teensy/loader_cli.html) (recommended command line)
 
 Flashing sequence:
 
-1. Press the `RESET` keycode, or short RST to GND quickly (you only have 7 seconds to flash once it enters)
+1. Enter the bootloader using any of the following methods (you only have 7 seconds to flash once it enters):
+    * Press the `RESET` keycode
+    * Press the `RESET` button on the Teensy or PCB if available
+    * short RST to GND quickly
 2. Wait for the OS to detect the device
 3. Flash a .hex file
 4. Reset the device into application mode (may be done automatically)
 
 ## USBasploader
 
-USBasploader is a bootloader developed by matrixstorm. It is used in some non-USB AVR chips such as the ATmega328P, which run V-USB.
+USBasploader is a bootloader originally by [Objective Development](https://www.obdev.at/products/vusb/usbasploader.html). It emulates a USBasp ISP programmer and is used in some non-USB AVR chips such as the ATmega328P, which run V-USB.
 
 To ensure compatibility with the USBasploader bootloader, make sure this block is present in your `rules.mk`:
 
 ```make
 # Bootloader selection
-#   Teensy       halfkay
-#   Pro Micro    caterina
-#   Atmel DFU    atmel-dfu
-#   LUFA DFU     lufa-dfu
-#   QMK DFU      qmk-dfu
-#   ATmega32A    bootloadHID
-#   ATmega328P   USBasp
 BOOTLOADER = USBasp
 ```
 
 Compatible flashers:
 
 * [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) (recommended GUI)
-* [avrdude](http://www.nongnu.org/avrdude/) with the `usbasp` programmer
+* [avrdude](http://www.nongnu.org/avrdude/) with the `usbasp` programmer / `:usbasp` target in QMK (recommended command line)
 * [AVRDUDESS](https://github.com/zkemble/AVRDUDESS)
 
 Flashing sequence:
 
-1. Press the `RESET` keycode, or keep the boot pin shorted to GND while quickly shorting RST to GND
+1. Enter the bootloader using any of the following methods:
+    * Press the `RESET` keycode
+    * Keep the `BOOT` button held while quickly tapping the `RESET` button on the PCB
 2. Wait for the OS to detect the device
 3. Flash a .hex file
-4. Reset the device into application mode (may be done automatically)
+4. Press the `RESET` button on the PCB or short RST to GND
 
 ## BootloadHID
 
-BootloadHID is a USB bootloader for AVR microcontrollers. The uploader tool requires no kernel level driver on Windows and can therefore be run without installing any DLLs.
+BootloadHID is a USB bootloader for AVR microcontrollers. It presents itself as an HID input device, much like HalfKay, and can therefore be run without installing any driver on Windows.
 
-To ensure compatibility with the bootloadHID bootloader, make sure this block is present your `rules.mk`:
+To ensure compatibility with the bootloadHID bootloader, make sure this block is present in your `rules.mk`:
 
 ```make
 # Bootloader selection
-#   Teensy       halfkay
-#   Pro Micro    caterina
-#   Atmel DFU    atmel-dfu
-#   LUFA DFU     lufa-dfu
-#   QMK DFU      qmk-dfu
-#   ATmega32A    bootloadHID
-#   ATmega328P   USBasp
 BOOTLOADER = bootloadHID
 ```
 
 Compatible flashers:
 
-* [HIDBootFlash](http://vusb.wikidot.com/project:hidbootflash) (recommended Windows GUI)
-* [bootloadhid Command Line](https://www.obdev.at/products/vusb/bootloadhid.html) / `:BootloadHID` in QMK (recommended command line)
+* [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) (recommended GUI)
+* [bootloadHID CLI](https://www.obdev.at/products/vusb/bootloadhid.html) / `:bootloadHID` target in QMK (recommended command line)
+* [HIDBootFlash](http://vusb.wikidot.com/project:hidbootflash)
 
 Flashing sequence:
 
 1. Enter the bootloader using any of the following methods:
-    * Tap the `RESET` keycode (may not work on all devices)
-    * Hold the salt key while plugging the keyboard in (usually documented within keyboard readme) 
+    * Tap the `RESET` keycode
+    * Hold the salt key while plugging the keyboard in - for PS2AVRGB boards, this is usually the key connected to MCU pins A0 and B0, otherwise it will be documented in your keyboard's readme
 2. Wait for the OS to detect the device
 3. Flash a .hex file
 4. Reset the device into application mode (may be done automatically)
 
-or:
+## STM32/APM32 DFU
 
-    make <keyboard>:<keymap>:bootloadHID
+All STM32 and APM32 MCUs, except for F103 (see the [STM32duino section](#stm32duino)) come preloaded with a factory bootloader that cannot be modified nor deleted.
 
-## STM32
+To ensure compatibility with the STM32-DFU bootloader, make sure this block is present in your `rules.mk` (optionally with `apm32-dfu` instead):
 
-All STM32 chips come preloaded with a factory bootloader that cannot be modified nor deleted. Some STM32 chips have bootloaders that do not come with USB programming (e.g. STM32F103) but the process is still the same.
-
-At the moment, no `BOOTLOADER` variable is needed on `rules.mk` for STM32.
+```make
+# Bootloader selection
+BOOTLOADER = stm32-dfu
+```
 
 Compatible flashers:
 
 * [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) (recommended GUI)
-* [dfu-util](https://github.com/Stefan-Schmidt/dfu-util) / `:dfu-util` (recommended command line)
+* [dfu-util](http://dfu-util.sourceforge.net/) / `:dfu-util` target in QMK (recommended command line)
 
 Flashing sequence:
 
 1. Enter the bootloader using any of the following methods:
     * Tap the `RESET` keycode (may not work on STM32F042 devices)
-    * If a reset circuit is present, tap the RESET button
-    * Otherwise, you need to bridge BOOT0 to VCC (via BOOT0 button or bridge), short RESET to GND (via RESET button or bridge), and then let go of the BOOT0 bridge
+    * If a reset circuit is present, tap the `RESET` button on the PCB; some boards may also have a toggle switch that must be flipped
+    * Otherwise, you need to bridge `BOOT0` to VCC (via `BOOT0` button or jumper), short `RESET` to GND (via `RESET` button or jumper), and then let go of the `BOOT0` bridge
 2. Wait for the OS to detect the device
 3. Flash a .bin file
-    * You will receive a warning about the DFU signature; Just ignore it
 4. Reset the device into application mode (may be done automatically)
-    * If you are building from command line (e.g. `make planck/rev6:default:dfu-util`), make sure that `:leave` is passed to the `DFU_ARGS` variable inside your `rules.mk` (e.g. `DFU_ARGS = -d 0483:df11 -a 0 -s 0x08000000:leave`) so that your device resets after flashing
 
-### STM32 Commands
+### `make` Targets
 
-There are a number of DFU commands that you can use to flash firmware to a STM32 device:
+* `:dfu-util`: Waits until an STM32 bootloader device is available, and then flashes the firmware.
+* `:dfu-util-split-left` and `:dfu-util-split-right`: Flashes the firmware as with `:avrdude`, but also sets the handedness setting in EEPROM. This is ideal for Proton-C-based split keyboards.
+* `:st-link-cli`: Allows you to flash the firmware via the ST-Link CLI utility, rather than dfu-util. Requires an ST-Link dongle.
+* `:st-flash`: Allows you to flash the firmware via the `st-flash` utility from [STLink Tools](https://github.com/stlink-org/stlink), rather than dfu-util. Requires an ST-Link dongle.
 
-* `:dfu-util` - The default command for flashing to STM32 devices, and will wait until an STM32 bootloader device is present.
-* `:dfu-util-split-left` - This flashes the normal firmware, just like the default option (`:dfu-util`). However, this also configures the "Left Side" EEPROM setting for split keyboards.
-* `:dfu-util-split-right` - This flashes the normal firmware, just like the default option (`:dfu-util`). However, this also configures the "Right Side" EEPROM setting for split keyboards.
-* `:st-link-cli` - This allows you to flash the firmware via ST-LINK's CLI utility, rather than dfu-util. 
-* `:st-flash` - This allows you to flash the firmware via the `st-flash` utility from [STLink Tools](https://github.com/stlink-org/stlink), rather than dfu-util.
+## STM32duino
+
+This bootloader is used almost exclusively for STM32F103 boards, as they do not come with a USB DFU bootloader. The source code and prebuilt binaries can be found [here](https://github.com/rogerclarkmelbourne/STM32duino-bootloader).
+
+To ensure compatibility with the STM32duino bootloader, make sure this block is present in your `rules.mk`:
+
+```make
+# Bootloader selection
+BOOTLOADER = stm32duino
+```
+
+Compatible flashers:
+
+* [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) (recommended GUI)
+* [dfu-util](http://dfu-util.sourceforge.net/) / `:dfu-util` target in QMK (recommended command line)
+
+Flashing sequence:
+
+1. Enter the bootloader using any of the following methods:
+    * Tap the `RESET` keycode
+    * If a reset circuit is present, tap the `RESET` button on the PCB
+    * Otherwise, you need to bridge `BOOT0` to VCC (via `BOOT0` button or jumper), short `RESET` to GND (via `RESET` button or jumper), and then let go of the `BOOT0` bridge
+2. Wait for the OS to detect the device
+3. Flash a .bin file
+4. Reset the device into application mode (may be done automatically)
+
+## Kiibohd DFU
+
+Keyboards produced by Input Club use NXP Kinetis microcontrollers rather than STM32, and come with their own [custom bootloader](https://github.com/kiibohd/controller/tree/master/Bootloader), however the process and protocol is largely the same.
+
+The `rules.mk` setting for this bootloader is `kiibohd`, but since this bootloader is limited to Input Club boards, it should not be necessary to set at keymap or user level.
+
+Compatible flashers:
+
+* [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) (recommended GUI)
+* [dfu-util](http://dfu-util.sourceforge.net/) / `:dfu-util` target in QMK (recommended command line)
+
+Flashing sequence:
+
+1. Enter the bootloader using any of the following methods:
+    * Tap the `RESET` keycode (this may only enter the MCU into a "secure" bootloader mode; see https://github.com/qmk/qmk_firmware/issues/6112)
+    * Press the `RESET` button on the PCB
+2. Wait for the OS to detect the device
+3. Flash a .bin file
+4. Reset the device into application mode (may be done automatically)

docs/getting_started_make_guide.md

@@ -14,16 +14,32 @@ The full syntax of the `make` command is `<keyboard_folder>:<keymap>:<target>`,
 The `<target>` means the following
 * If no target is given, then it's the same as `all` below
 * `all` compiles as many keyboard/revision/keymap combinations as specified. For example, `make planck/rev4:default` will generate a single .hex, while `make planck/rev4:all` will generate a hex for every keymap available to the planck.
-* `flash`, `dfu`, `teensy`, `avrdude`, `dfu-util`, or `bootloadHID` compile and upload the firmware to the keyboard. If the compilation fails, then nothing will be uploaded. The programmer to use depends on the keyboard. For most keyboards it's `dfu`, but for ChibiOS keyboards you should use `dfu-util`, and `teensy` for standard Teensys. To find out which command you should use for your keyboard, check the keyboard specific readme.
- * **Note**: some operating systems need root access for these commands to work, so in that case you need to run for example `sudo make planck/rev4:default:flash`.
+* `flash`, `dfu`, `teensy`, `avrdude`, `dfu-util`, or `bootloadHID` compile and upload the firmware to the keyboard. If the compilation fails, then nothing will be uploaded. The programmer to use depends on the keyboard. For most keyboards it's `dfu`, but for ChibiOS keyboards you should use `dfu-util`, and `teensy` for standard Teensys. To find out which command you should use for your keyboard, check the keyboard specific readme. 
+  Visit the [Flashing Firmware](flashing.md) guide for more details of the available bootloaders.
+  * **Note**: some operating systems need privileged access for these commands to work. This means that you may need to setup [`udev rules`](faq_build.md#linux-udev-rules) to access these without root access, or to run the command with root access (`sudo make planck/rev4:default:flash`).
 * `clean`, cleans the build output folders to make sure that everything is built from scratch. Run this before normal compilation if you have some unexplainable problems.
+* `distclean` removes .hex files and .bin files.
+
+The following targets are for developers:
+
+* `show-path` shows the path of the source and object files.
+* `dump-vars` dumps the makefile variable.
+* `objs-size` displays the size of individual object files.
+* `show_build_options` shows the options set in 'rules.mk'.
+* `check-md5` displays the md5 checksum of the generated binary file.
 
 You can also add extra options at the end of the make command line, after the target
 
 * `make COLOR=false` - turns off color output
 * `make SILENT=true` - turns off output besides errors/warnings
 * `make VERBOSE=true` - outputs all of the gcc stuff (not interesting, unless you need to debug)
-* `make EXTRAFLAGS=-E` - Preprocess the code without doing any compiling (useful if you are trying to debug #define commands)
+* `make VERBOSE_LD_CMD=yes` - execute the ld command with the -v option.
+* `make VERBOSE_AS_CMD=yes` - execute the as command with the -v option.
+* `make VERBOSE_C_CMD=<c_source_file>` - add the -v option when compiling the specified C source file.
+* `make DUMP_C_MACROS=<c_source_file>` - dump preprocessor macros when compiling the specified C source file.
+* `make DUMP_C_MACROS=<c_source_file> > <logfile>` - dump preprocessor macros to `<logfile>` when compiling the specified C source file.
+* `make VERBOSE_C_INCLUDE=<c_source_file>` - dumps the file names to be included when compiling the specified C source file.
+* `make VERBOSE_C_INCLUDE=<c_source_file> 2> <logfile>` - dumps the file names to be included to `<logfile>` when compiling the specified C source file.
 
 The make command itself also has some additional options, type `make --help` for more information. The most useful is probably `-jx`, which specifies that you want to compile using more than one CPU, the `x` represents the number of CPUs that you want to use. Setting that can greatly reduce the compile times, especially if you are compiling many keyboards/keymaps. I usually set it to one less than the number of CPUs that I have, so that I have some left for doing other things while it's compiling. Note that not all operating systems and make versions supports that option.
 

docs/hand_wire.md

@@ -121,7 +121,7 @@ Letting the diode rest, grab your solder, and touch both it and the soldering ir
 
 The smoke that the rosin releases is harmful, so be careful not to breath it or get it in your eyes/face.
 
-After soldering things in place, it may be helpful to blow on the joint to push the smoke away from your face, and cool the solder quicker. You should see the solder develop a matte (not shiny) surface as it solidifies. Keep in mind that it will still be very hot afterwards, and will take a couple minutes to be cool to touch. Blow on it will accelerate this process.
+After soldering things in place, it may be helpful to blow on the joint to push the smoke away from your face, and cool the solder quicker. You should see the solder develop a matte (not shiny) surface as it solidifies. Keep in mind that it will still be very hot afterwards, and will take a couple minutes to be cool to touch. Blowing on it will accelerate this process.
 
 When the first diode is complete, the next one will need to be soldered to both the keyswitch, and the previous diode at the new elbow. That will look something like this:
 

docs/hardware_avr.md

@@ -77,7 +77,7 @@ Do change the `MANUFACTURER` and `PRODUCT` lines to accurately reflect your keyb
 #define PRODUCT         my_awesome_keyboard
 ```
 
-?> Windows and macOS will display the `MANUFACTURER` and `PRODUCT` in the list of USB devices. `lsusb` on Linux instead takes these from the list maintained by the [USB ID Repository](http://www.linux-usb.org/usb-ids.html) by default. `lsusb -v` will show the values reported by the device, and they are also present in kernel logs after plugging it in.
+?> Windows and macOS will display the `MANUFACTURER` and `PRODUCT` in the list of USB devices. `lsusb` on Linux instead prefers the values in the list maintained by the [USB ID Repository](http://www.linux-usb.org/usb-ids.html). By default, it will only use `MANUFACTURER` and `PRODUCT` if the list does not contain that `VENDOR_ID` / `PRODUCT_ID`. `sudo lsusb -v` will show the values reported by the device, and they are also present in kernel logs after plugging it in.
 
 ### Keyboard Matrix Configuration
 

docs/ja/_summary.md

@@ -103,6 +103,7 @@
     * [DIP スイッチ](ja/feature_dip_switch.md)
     * [エンコーダ](ja/feature_encoders.md)
     * [触覚フィードバック](ja/feature_haptic_feedback.md)
+    * [LED インジケータ](ja/feature_led_indicators.md)
     * [Proton C 変換](ja/proton_c_conversion.md)
     * [PS/2 マウス](ja/feature_ps2_mouse.md)
     * [分割キーボード](ja/feature_split_keyboard.md)

docs/ja/custom_quantum_functions.md

@@ -1,8 +1,8 @@
 # キーボードの挙動をカスタマイズする方法
 
 <!---
-  original document: 0.10.33:docs/custom_quantum_functions.md
-  git diff 0.10.33 HEAD -- docs/custom_quantum_functions.md | cat
+  original document: 0.10.52:docs/custom_quantum_functions.md
+  git diff 0.10.52 HEAD -- docs/custom_quantum_functions.md | cat
 -->
 
 多くの人にとって、カスタムキーボードはボタンの押下をコンピュータに送信するだけではありません。単純なボタンの押下やマクロよりも複雑なことを実行できるようにしたいでしょう。QMK にはコードを挿入したり、機能を上書きしたり、様々な状況でキーボードの挙動をカスタマイズできるフックがあります。
@@ -93,106 +93,6 @@ keyrecord_t record {
 }
 ```
 
-# LED 制御
-
-QMK は HID 仕様で定義された5つの LED の読み取りメソッドを提供します:
-
-* Num Lock
-* Caps Lock
-* Scroll Lock
-* Compose
-* Kana
-
-ロック LED の状態を取得するには2つの方法があります:
-
-* `bool led_update_kb(led_t led_state)` あるいは `_user(led_t led_state)` を実装する、または
-* `led_t host_keyboard_led_state()` を呼び出す
-
-!> `host_keyboard_led_state()` は `led_update_user()` が呼ばれる前に新しい値を既に反映している場合があります。
-
-LED の状態を `uint8_t` として提供する2つの非推奨の関数があります:
-
-* `uint8_t led_set_kb(uint8_t usb_led)` と `_user(uint8_t usb_led)`
-* `uint8_t host_keyboard_leds()`
-
-## `led_update_user()`
-
-この関数はこれら5つの LED のいずれかの状態が変化すると呼ばれます。LED の状態を構造体のパラメータとして受け取ります。
-
-慣例により、`led_update_kb()` にそのコードを実行するようフックさせるために `led_update_user()` から `true` を返し、`led_update_kb()` でコードを実行したくない場合は `false` を返します。
-
-以下はいくつかの例です:
-
-- レイヤー表示のような何かのために LED を使うために LED を上書きする
-   - `_kb()` 関数を実行したくないので、`false`  を返します。これはレイヤーの挙動を上書きするためです。
-- LED がオンあるいはオフになった時に音楽を再生する。
-   - `_kb` 関数を実行したいので、`true` を返します。これはデフォルトの LED の挙動に追加されます。
-
-?> `led_set_*` 関数は `bool` の代わりに `void` を返すため、キーボードの LED 制御を上書きすることができません。従って、代わりに `led_update_*` を使うことをお勧めします。
-
-### `led_update_kb()` の実装例
-
-```c
-bool led_update_kb(led_t led_state) {
-    bool res = led_update_user(led_state);
-    if(res) {
-        // writePin は 1 でピンを high に、0 で low に設定します。
-        // この例では、ピンは反転していて、
-        // low/0 は LED がオンになり、high/1 は LED がオフになります。
-        // この挙動は、LED がピンと VCC の間にあるか、ピンと GND の間にあるかどうかに依存します。
-        writePin(B0, !led_state.num_lock);
-        writePin(B1, !led_state.caps_lock);
-        writePin(B2, !led_state.scroll_lock);
-        writePin(B3, !led_state.compose);
-        writePin(B4, !led_state.kana);
-    }
-    return res;
-}
-```
-
-### `led_update_user()` の実装例
-
-この不完全な例は Caps Lock がオンまたはオフになった場合に音を再生します。また LED の状態を保持する必要があるため、`true` を返します。
-
-```c
-#ifdef AUDIO_ENABLE
-  float caps_on[][2] = SONG(CAPS_LOCK_ON_SOUND);
-  float caps_off[][2] = SONG(CAPS_LOCK_OFF_SOUND);
-#endif
-
-bool led_update_user(led_t led_state) {
-    #ifdef AUDIO_ENABLE
-    static uint8_t caps_state = 0;
-    if (caps_state != led_state.caps_lock) {
-        led_state.caps_lock ? PLAY_SONG(caps_on) : PLAY_SONG(caps_off);
-        caps_state = led_state.caps_lock;
-    }
-    #endif
-    return true;
-}
-```
-
-### `led_update_*` 関数のドキュメント
-
-* キーボード/リビジョン: `bool led_update_kb(led_t led_state)`
-* キーマップ: `bool led_update_user(led_t led_state)`
-
-## `host_keyboard_led_state()`
-
-最後に受信した LED の状態を `led_t` として取得するためにこの関数を呼びます。これは、`led_update_*` の外部から、例えば [`matrix_scan_user()`](#matrix-scanning-code) の中で LED の状態を読み取るのに便利です。
-
-## 物理的な LED の状態の設定
-
-一部のキーボードの実装は、物理的な LED の状態を設定するための便利なメソッドを提供しています。
-
-### Ergodox キーボード
-
-Ergodox の実装は、個々の LED をオンあるいはオフにするために `ergodox_right_led_1`/`2`/`3_on`/`off()` と、インデックスによってそれらをオンあるいはオフにするために `ergodox_right_led_on`/`off(uint8_t led)` を提供します。
-
-さらに、LED の明度を指定することができます。全ての LED に同じ明度を指定するなら `ergodox_led_all_set(uint8_t n)` を使い、個別の LED の明度を指定するなら `ergodox_right_led_1`/`2`/`3_set(uint8_t n)` を使い、LED のインデックスを指定して明度を指定するには  `ergodox_right_led_set(uint8_t led, uint8_t n)` を使います。
-
-Ergodox キーボードは、最低の明度として `LED_BRIGHTNESS_LO` を、最高の輝度(これはデフォルトです)として `LED_BRIGHTNESS_HI` も定義しています。
-
 # キーボードの初期化コード
 
 キーボードの初期化プロセスには幾つかのステップがあります。何をしたいかによって、どの関数を使うべきかに影響します。
@@ -347,7 +247,7 @@ layer_state_t layer_state_set_user(layer_state_t state) {
 }
 ```
 
-特定のレイヤーの状態を確認するには、 `IS_LAYER_ON_STATE(state, layer)` と `IS_LAYER_OFF_STATE(state, layer)` マクロを使います。
+特定のレイヤーの状態を確認するには、`IS_LAYER_ON_STATE(state, layer)` と `IS_LAYER_OFF_STATE(state, layer)` マクロを使います。
 
 `layer_state_set_*` 関数の外では、グローバルなレイヤー状態を確認するために `IS_LAYER_ON(layer)` と `IS_LAYER_OFF(layer)` マクロを使えます。
 

docs/ja/feature_led_indicators.md

@@ -0,0 +1,119 @@
+# LED インジケータ
+
+<!---
+  original document: 0.10.52:docs/feature_led_indicators.md
+  git diff 0.10.52 HEAD -- docs/feature_led_indicators.md | cat
+-->
+
+QMK は HID 仕様で定義された5つの LED の読み取りメソッドを提供します:
+
+* Num Lock
+* Caps Lock
+* Scroll Lock
+* Compose
+* Kana
+
+ロック LED の状態を取得するには3つの方法があります:
+* `config.h` で設定オプションを指定する
+* `bool led_update_kb(led_t led_state)` あるいは `_user(led_t led_state)` を実装する、または
+* `led_t host_keyboard_led_state()` を呼び出す
+
+!> `host_keyboard_led_state()` は `led_update_user()` が呼ばれる前に新しい値を既に反映している場合があります。
+
+LED の状態を `uint8_t` として提供する2つの非推奨の関数があります:
+
+* `uint8_t led_set_kb(uint8_t usb_led)` と `_user(uint8_t usb_led)`
+* `uint8_t host_keyboard_leds()`
+
+## 設定オプション
+
+インジケータを設定するには、`config.h` で以下の `#define` をします:
+
+| 定義                  | 既定値     | 説明                             |
+|-----------------------|------------|----------------------------------|
+| `LED_NUM_LOCK_PIN`    | *定義なし* | `Num Lock` LED を制御するピン    |
+| `LED_CAPS_LOCK_PIN`   | *定義なし* | `Caps Lock` LED を制御するピン   |
+| `LED_SCROLL_LOCK_PIN` | *定義なし* | `Scroll Lock` LED を制御するピン |
+| `LED_COMPOSE_PIN`     | *定義なし* | `Compose` LED を制御するピン     |
+| `LED_KANA_PIN`        | *定義なし* | `Kana` LED を制御するピン        |
+| `LED_PIN_ON_STATE`    | `1`        | LED が "オン" の時のインジケータピンの状態 - high の場合は`1`、low の場合は`0` |
+
+独自のキーボードを設計しているわけではない限り、通常は上記の設定オプションを変更する必要はありません。
+
+## `led_update_*()`
+
+設定オプションが十分な柔軟性を提供しない場合は、提供される API フックにより LED の挙動の独自の制御ができます。これらの関数はこれら5つの LED のいずれかの状態が変化すると呼ばれます。LED の状態を構造体のパラメータとして受け取ります。
+
+慣例により、`led_update_kb()` にそのコードを実行するようフックさせるために `led_update_user()` から `true` を返し、`led_update_kb()` でコードを実行したくない場合は `false` を返します。
+
+以下はいくつかの例です:
+
+- レイヤー表示のような何かのために LED を使うために LED を上書きする
+   - `_kb()` 関数を実行したくないので、`false`  を返します。これはレイヤーの挙動を上書きするためです。
+- LED がオンあるいはオフになった時に音楽を再生する。
+   - `_kb` 関数を実行したいので、`true` を返します。これはデフォルトの LED の挙動に追加されます。
+
+?> `led_set_*` 関数は `bool` の代わりに `void` を返すため、キーボードの LED 制御を上書きすることができません。従って、代わりに `led_update_*` を使うことをお勧めします。
+
+### `led_update_kb()` の実装例
+
+```c
+bool led_update_kb(led_t led_state) {
+    bool res = led_update_user(led_state);
+    if(res) {
+        // writePin は 1 でピンを high に、0 で low に設定します。
+        // この例では、ピンは反転していて、
+        // low/0 は LED がオンになり、high/1 は LED がオフになります。
+        // この挙動は、LED がピンと VCC の間にあるか、ピンと GND の間にあるかどうかに依存します。
+        writePin(B0, !led_state.num_lock);
+        writePin(B1, !led_state.caps_lock);
+        writePin(B2, !led_state.scroll_lock);
+        writePin(B3, !led_state.compose);
+        writePin(B4, !led_state.kana);
+    }
+    return res;
+}
+```
+
+### `led_update_user()` の実装例
+
+この不完全な例は Caps Lock がオンまたはオフになった場合に音を再生します。また LED の状態を保持する必要があるため、`true` を返します。
+
+```c
+#ifdef AUDIO_ENABLE
+  float caps_on[][2] = SONG(CAPS_LOCK_ON_SOUND);
+  float caps_off[][2] = SONG(CAPS_LOCK_OFF_SOUND);
+#endif
+
+bool led_update_user(led_t led_state) {
+    #ifdef AUDIO_ENABLE
+    static uint8_t caps_state = 0;
+    if (caps_state != led_state.caps_lock) {
+        led_state.caps_lock ? PLAY_SONG(caps_on) : PLAY_SONG(caps_off);
+        caps_state = led_state.caps_lock;
+    }
+    #endif
+    return true;
+}
+```
+
+### `led_update_*` 関数のドキュメント
+
+* キーボード/リビジョン: `bool led_update_kb(led_t led_state)`
+* キーマップ: `bool led_update_user(led_t led_state)`
+
+## `host_keyboard_led_state()`
+
+最後に受信した LED の状態を `led_t` として取得するためにこの関数を呼びます。これは、`led_update_*` の外部から、例えば [`matrix_scan_user()`](#matrix-scanning-code) の中で LED の状態を読み取るのに便利です。
+
+## 物理的な LED の状態の設定
+
+一部のキーボードの実装は、物理的な LED の状態を設定するための便利なメソッドを提供しています。
+
+### Ergodox キーボード
+
+Ergodox の実装は、個々の LED をオンあるいはオフにするために `ergodox_right_led_1`/`2`/`3_on`/`off()` と、インデックスによってそれらをオンあるいはオフにするために `ergodox_right_led_on`/`off(uint8_t led)` を提供します。
+
+さらに、LED の明度を指定することができます。全ての LED に同じ明度を指定するなら `ergodox_led_all_set(uint8_t n)` を使い、個別の LED の明度を指定するなら `ergodox_right_led_1`/`2`/`3_set(uint8_t n)` を使い、LED のインデックスを指定して明度を指定するには  `ergodox_right_led_set(uint8_t led, uint8_t n)` を使います。
+
+Ergodox キーボードは、最低の明度として `LED_BRIGHTNESS_LO` を、最高の輝度(これはデフォルトです)として `LED_BRIGHTNESS_HI` も定義しています。

docs/ja/feature_rawhid.md

@@ -0,0 +1,74 @@
+# Raw HID
+
+<!---
+  original document: 0.10.47:docs/feature_rawhid.md
+  git diff 0.10.47 HEAD -- docs/feature_rawhid.md | cat
+-->
+
+Raw HID は、HID インタフェースを介して QMK とホストコンピュータ間の双方向通信を可能にします。これには、キーマップをその場で切り替えたり、RGB LED の色とモードを変更したりなど、多くの潜在的な使用方法があります。
+
+キーボードで raw HID を機能させるには、2つの主要なコンポーネントがあります。
+
+## キーボードファームウェア
+
+ファームウェアの実装はとても簡単です。
+`rules.mk` に以下を追加します:
+
+```make
+RAW_ENABLE = yes
+```
+
+`keymap.c` に `"raw_hid.h"` を include し、以下を実装します:
+
+```C
+void raw_hid_receive(uint8_t *data, uint8_t length) {
+    // ここにコードを書きます。data はホストから受信したパケットです。
+}
+```
+
+`"raw_hid.h"` ヘッダは、キーボードからホストにパケットを送信できる `void raw_hid_send(uint8_t *data, uint8_t length);` も宣言します。例として、全てのデータをホストに返すことで、ホストアプリケーションを構築する時のデバッグに使うこともできます。
+
+```C
+void raw_hid_receive(uint8_t *data, uint8_t length) {
+    raw_hid_send(data, length);
+}
+```
+
+`raw_hid_receive` はホストから最大長 `RAW_EPSIZE` の可変サイズのパケットを受信することができます。一方、`raw_hid_send` はパケットを厳密に `RAW_EPSIZE` の長さで送信するため、長さ `RAW_EPSIZE` のデータを使う必要があります。
+
+ホスト側での作業を進める前に、raw 対応のファームウェアを書き込むようにしてください。
+
+## ホスト (Windows/macOS/Linux)
+
+これは幾つかの掘り下げが必要になるため、より複雑な部分です。
+
+ホストコンピュータを raw HID を使ってキーボードに接続するには、キーボードについての4つの情報が必要です。
+
+1. Vendor ID
+2. Product ID
+3. Usage Page
+4. Usage
+
+前半の2つは、キーボードのメインディレクトリにあるキーボードの `config.h` で、`VENDOR_ID` と `PRODUCT_ID` で簡単に見つかります。
+
+後半の2つは、キーボードのメインディレクトリにあるキーボードの `config.h` で、値を再定義することで上書きすることができます: `#define RAW_USAGE_PAGE 0xFF60` と `#define RAW_USAGE_ID 0x61`。
+
+デフォルトでは、**Usage Page** は `0xFF60` で、**Usage** は `0x61` です。
+
+### ホストの構築
+
+独自に作成したくない場合は、利用可能な HID 実装ライブラリがある任意の言語を使ってホストを構築することができます。人気のある言語でよく使われるライブラリは以下の通りです:
+
+* Node: [node-hid](https://github.com/node-hid/node-hid)。
+* C: [hidapi](https://github.com/libusb/hidapi)。
+* Java: [purejavahidapi](https://github.com/nyholku/purejavahidapi) と [hid4java](https://github.com/gary-rowe/hid4java)。
+* Python: [pyhidapi](https://pypi.org/project/hid/)。
+
+これは完全なクロスプラットフォームのリストではありませんが、最初に始めるのに十分なはずです。raw HID を使うための特別な要件は無いため、どの HID ライブラリでも動作するはずです。
+
+これで、キーボードへの HID インタフェースを開くために必要な4つの情報全てが揃いました。必要なのは、ライブラリの利用可能な関数を使って ID パラメータを使ってデバイスを開くことだけです。
+
+Vendor ID と Product ID はデバイスを開くために実際には必要ないことに注意してください。それらは接続した多くの HID デバイスから特定のデバイスをフィルターするためだけに使われます。多くのライブラリでは、代わりに製品名と製造元名を使ってデバイスを開くオプションがあります。`node-hid` が代表的な例です。これは USB ハブが組み込まれているデバイスや、同じ製品名または同じ製造元の複数のインタフェースがある特別な HID インタフェースで問題になります。Product ID と Vendor ID を合わせると単一のインタフェースの固有名を作成できるため、この問題を防げます。したがって、ライブラリで必要が無い場合でも、この問題を防ぐためにそれらを使うことをお勧めします。
+ただし、Vendor ID や Product ID と異なり、Usage Page と Usage は通信を成功させるために必要です。
+
+言うまでもなく、使っているライブラリに関係なく、終了したらインタフェースを必ず閉じる必要があります。オペレーティングシステムと特定の環境によっては、明示的に接続が閉じられていない場合、後で他のクライアントまたは同じクライアントの他のインスタンスに接続しなおした時に問題が発生する可能性があります。

docs/newbs.md

@@ -6,25 +6,19 @@ QMK tries to put a lot of power into your hands by making easy things easy, and
 
 Not sure if your keyboard can run QMK? If it's a mechanical keyboard you built yourself chances are good it can. We support a [large number of hobbyist boards](http://qmk.fm/keyboards/). If your current keyboard can't run QMK there are a lot of choices out there for boards that do.
 
-## Is This Guide For Me?
-
-This guide is suitable for everyone who wants to build a keyboard firmware using the source code. If you are already a programmer you will find the process very familiar and easier to follow. If the thought of programming intimidates you please [take a look at our online GUI](newbs_building_firmware_configurator.md) instead.
+?> **Is This Guide For Me?**<br>
+If the thought of programming intimidates you, please [take a look at our online GUI](newbs_building_firmware_configurator.md) instead.</div>
 
 ## Overview
 
-There are 4 main sections to this guide:
+This guide is suitable for everyone who wants to build a keyboard firmware using the source code. If you are already a programmer you will find the process very familiar and easier to follow. There are 3 main sections to this guide:
 
 1. [Setup Your Environment](newbs_getting_started.md)
 2. [Building Your First Firmware](newbs_building_firmware.md)
 3. [Flashing Firmware](newbs_flashing.md)
-4. [Testing and Debugging](newbs_testing_debugging.md)
 
 This guide is focused on helping someone who has never compiled software before. It makes choices and recommendations based on that viewpoint. There are alternative methods for many of these procedures, and we support most of those alternatives. If you have any doubt about how to accomplish a task you can [ask us for guidance](getting_started_getting_help.md).
 
 ## Additional Resources
 
-Beyond this guide there are several resources you may find helpful while you learn QMK. We've collected them on the [Learning Resources](newbs_learn_more_resources.md) page.
-
-## Open Source
-
-QMK is Open Source Software released under the GNU General Public License.
+Beyond this guide there are several resources you may find helpful while you learn QMK. We've collected them on the [Syllabus](syllabus.md) and [Learning Resources](newbs_learn_more_resources.md) pages.

docs/newbs_building_firmware_configurator.md

@@ -2,7 +2,7 @@
 
 [![QMK Configurator Screenshot](https://i.imgur.com/anw9cOL.png)](https://config.qmk.fm/)
 
-The [QMK Configurator](https://config.qmk.fm) is an online graphical user interface that generates QMK Firmware hex files.
+The [QMK Configurator](https://config.qmk.fm) is an online graphical user interface that generates QMK Firmware `.hex` or `.bin` files.
 
 Watch the [Video Tutorial](https://www.youtube.com/watch?v=-imgglzDMdY). Many people find that is enough information to start programming their own keyboard.
 

docs/newbs_flashing.md

@@ -37,18 +37,22 @@ Begin by opening the QMK Toolbox application. You'll want to locate the firmware
 
 If you are on Windows or macOS, there are commands you can use to easily open the current folder in Explorer or Finder.
 
-#### Windows
+<!-- tabs:start -->
+
+#### ** Windows **
 
 ```
 start .
 ```
 
-#### macOS
+#### ** macOS **
 
 ```
 open .
 ```
 
+<!-- tabs:end -->
+
 The firmware file always follows this naming format:
 
 ```
@@ -106,6 +110,9 @@ In this case, you'll have to fall back on specifying the bootloader. See the [Fl
 
 ## Test It Out!
 
-Congrats! Your custom firmware has been programmed to your keyboard!
+Congrats! Your custom firmware has been programmed to your keyboard and you're ready to test it out!
 
-Give it a try and make sure everything works the way you want it to. We've written [Testing and Debugging](newbs_testing_debugging.md) to round out this guide, so head over there to learn about validating your firmware and how to troubleshoot your custom functionality.
+With a little bit of luck everything will work perfectly, but if not there are steps that will help you figure out what's wrong.
+Testing your keyboard is usually pretty straightforward. Press every single key and make sure it sends the keys you expect. You can use [QMK Configurator](https://config.qmk.fm/#/test/)'s test mode to check your keyboard, even if it doesn't run QMK.
+
+Still not working? Browse the FAQ topics for more information, or [chat with us on Discord](https://discord.gg/Uq7gcHh).

docs/newbs_getting_started.md

@@ -2,45 +2,38 @@
 
 Before you can build keymaps, you need to install some software and set up your build environment. This only has to be done once no matter how many keyboards you plan to compile firmware for.
 
-## 1. Download Software
+## 1. Prerequisites
 
 There are a few pieces of software you'll need to get started.
 
-### Text Editor
+* [Text editor](newbs_learn_more_resources.md#text-editor-resources)
+  * You’ll need a program that can edit and save plain text files. The default editor that comes with many OS's does not save plain text files, so you'll need to make sure that whatever editor you chose does.
+* [Toolbox (optional)](https://github.com/qmk/qmk_toolbox)
+  * A graphical program for Windows and macOS that allows you to both program and debug your custom keyboard
 
-You'll need a program that can edit and save **plain text** files. If you're on Windows you can make do with Notepad, and on Linux you can use gedit. Both of these are simple but functional text editors. On macOS, be careful with the default TextEdit app: it will not save plain text files unless you explicitly select _Make Plain Text_ from the _Format_ menu.
-
-You can also download and install a dedicated text editor like [Sublime Text](https://www.sublimetext.com/) or [VS Code](https://code.visualstudio.com/). This is probably the best way to go regardless of platform, as these programs are specifically made for editing code.
-
-?> Not sure which text editor to use? Laurence Bradford wrote [a great introduction](https://learntocodewith.me/programming/basics/text-editors/) to the subject.
-
-### QMK Toolbox
-
-QMK Toolbox is an optional graphical program for Windows and macOS that allows you to both program and debug your custom keyboard. You will likely find it invaluable for easily flashing your keyboard and viewing debug messages that it prints.
-
-[Download the latest release here.](https://github.com/qmk/qmk_toolbox/releases/latest)
-
-* For Windows: `qmk_toolbox.exe` (portable) or `qmk_toolbox_install.exe` (installer)
-* For macOS: `QMK.Toolbox.app.zip` (portable) or `QMK.Toolbox.pkg` (installer)
-
-### A Unix-like Environment
-
-Linux and macOS come with unix shells you can execute already. You will only need to setup your build environment.
-
-On Windows you will need to install MSYS2 or WSL and use those environments. Instructions for setting up MSYS2 are provided below.
+?> If you haven't worked with the Linux/Unix command line before, there are a few basic concepts and commands you should learn. [These resources](newbs_learn_more_resources.md#command-line-resources) will teach you enough to be able to work with QMK.
 
 ## 2. Prepare Your Build Environment :id=set-up-your-environment
 
 We've tried to make QMK as easy to set up as possible. You only have to prepare your Linux or Unix environment, then let QMK install the rest.
 
-?> If you haven't worked with the Linux/Unix command line before, there are a few basic concepts and commands you should learn. These resources will teach you enough to be able to work with 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 **
 
+QMK maintains a Bundle of MSYS2, the CLI and all necessary dependencies. It also provides a handy `QMK MSYS` terminal shortcut to boot you directly into the correct environment.
+
+#### Prerequisites
+
+You will need to install [QMK MSYS](https://msys.qmk.fm/). The latest release is available [here](https://github.com/qmk/qmk_distro_msys/releases/latest).
+
+Alternatively, if you'd like to manually install MSYS2, the following section will walk you through the process.
+
+<details>
+  <summary>Manual Install</summary>
+
+?> Ignore the following steps if you use `QMK MSYS`.
+
 #### Prerequisites
 
 You will need to install MSYS2, Git and Python. Follow the installation instructions on https://www.msys2.org.
@@ -59,6 +52,8 @@ Install the QMK CLI by running:
 
     python3 -m pip install qmk
 
+</details>
+
 ### ** macOS **
 
 QMK maintains a Homebrew tap and formula which will automatically install the CLI and all necessary dependencies.
@@ -101,9 +96,9 @@ On Arch-based distros you can install the CLI from the official repositories (NO
 
     sudo pacman -S qmk
 
-You can also try the `qmk` package from AUR:
+You can also try the `qmk-git` package from AUR:
 
-    yay -S qmk
+    yay -S qmk-git
 
 ###  ** FreeBSD **
 
@@ -173,6 +168,8 @@ Once that completes, re-run `qmk setup` to complete the setup and checks.
 
 <!-- tabs:end -->
 
+?> The qmk home folder can be specified at setup with `qmk setup -H <path>`, and modified afterwards using the [cli configuration](cli_configuration.md?id=single-key-example) and the variable `user.qmk_home`. For all available options run `qmk setup --help`.
+
 ?> If you already know [how to use GitHub](getting_started_github.md), we recommend that you create your own fork and use `qmk setup <github_username>/qmk_firmware` to clone your personal fork. If you don't know what that means you can safely ignore this message.
 
 ## 4. Test Your Build Environment

docs/newbs_learn_more_resources.md

@@ -2,15 +2,26 @@
 
 These resources are aimed at giving new members in the QMK community more understanding to the information provided in the Newbs docs.
 
-**QMK resources**:
+### QMK resources
 
 * [Thomas Baart's QMK Basics Blog](https://thomasbaart.nl/category/mechanical-keyboards/firmware/qmk/qmk-basics/) – A user-created blog covering the basics of how to use QMK Firmware, as seen from a new user's perspective.
 
-**Command Line resources**:
+### Command Line resources
 
 * [Good General Tutorial on Command Line](https://www.codecademy.com/learn/learn-the-command-line)
+* [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)
 
-**Git resources**:
+### Text Editor resources
+
+Not sure which text editor to use?
+* [a great introduction to the subject](https://learntocodewith.me/programming/basics/text-editors/)
+
+Editors specifically made for code:
+* [Sublime Text](https://www.sublimetext.com/)
+* [VS Code](https://code.visualstudio.com/)
+
+### Git resources
 
 * [Great General Tutorial](https://www.codecademy.com/learn/learn-git)
 * [Flight Rules For Git](https://github.com/k88hudson/git-flight-rules)

docs/newbs_testing_debugging.md

@@ -1,96 +1,9 @@
 # Testing and Debugging
 
-Once you've flashed your keyboard with a custom firmware you're ready to test it out. With a little bit of luck everything will work perfectly, but if not this document will help you figure out what's wrong.
-
 ## Testing
 
-Testing your keyboard is usually pretty straightforward. Press every single key and make sure it sends the keys you expect. You can use [QMK Configurator](https://config.qmk.fm/#/test/)'s test mode to check your keyboard, even if it doesn't run QMK.
+[Moved here](faq_misc.md#testing)
 
 ## Debugging :id=debugging
 
-Your keyboard will output debug information if you have `CONSOLE_ENABLE = yes` in your `rules.mk`. By default the output is very limited, but you can turn on debug mode to increase the amount of debug output. Use the `DEBUG` keycode in your keymap, use the [Command](feature_command.md) feature to enable debug mode, or add the following code to your keymap.
-
-```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;
-}
-```
-
-## Debugging Tools
-
-There are two different tools you can use to debug your keyboard.
-
-### Debugging With QMK Toolbox
-
-For compatible platforms, [QMK Toolbox](https://github.com/qmk/qmk_toolbox) can be used to display debug messages from your keyboard.
-
-### Debugging With hid_listen
-
-Prefer a terminal based solution? [hid_listen](https://www.pjrc.com/teensy/hid_listen.html), provided by PJRC, can also be used to display debug messages. Prebuilt binaries for Windows,Linux,and MacOS are available.
-
-## Sending Your Own Debug Messages
-
-Sometimes it's useful to print debug messages from within your [custom code](custom_quantum_functions.md). Doing so is pretty simple. Start by including `print.h` at the top of your file:
-
-```c
-#include "print.h"
-```
-
-After that you can use a few different print functions:
-
-* `print("string")`: Print a simple string.
-* `uprintf("%s string", var)`: Print a formatted string
-* `dprint("string")` Print a simple string, but only when debug mode is enabled
-* `dprintf("%s string", var)`: Print a formatted string, but only when debug mode is enabled
-
-## Debug Examples
-
-Below is a collection of real world debugging examples. For additional information, refer to [Debugging/Troubleshooting QMK](faq_debug.md).
-
-### Which matrix position is this keypress?
-
-When porting, or when attempting to diagnose pcb issues, it can be useful to know if a keypress is scanned correctly. To enable logging for this scenario, add the following code to your keymaps `keymap.c`
-
-```c
-bool process_record_user(uint16_t keycode, keyrecord_t *record) {
-  // If console is enabled, it will print the matrix position and status of each key pressed
-#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;
-}
-```
-
-Example output
-```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
-```
-
-### How long did it take to scan for a keypress?
-
-When testing performance issues, it can be useful to know the frequency at which the switch matrix is being scanned. To enable logging for this scenario, add the following code to your keymaps `config.h`
-
-```c
-#define DEBUG_MATRIX_SCAN_RATE
-```
-
-Example output
-```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
-```
+[Moved here](faq_debug.md#debugging)

docs/qmk_custom_dark.css

@@ -28,6 +28,9 @@
     border-bottom: 1px solid #777 !important;
 }
 
+.markdown-section p.warn > strong {
+    color: #c8c8c8;
+}
 
 :root {
     --docsifytabs-border-color: #555;
@@ -36,11 +39,3 @@
     --docsifytabs-tab-background: #444;
     --docsifytabs-tab-background-active: #3f3f3f;
 }
-
-.docsify-tabs__tab:focus {
-    outline: none !important;
-}
-
-.docsify-tabs__content .anchor {
-    transition: none;
-}

docs/qmk_custom_light.css

@@ -29,13 +29,16 @@
   padding: 0;
 }
 
-
-:root {
-  --docsifytabs-border-color: #ddd;
-  --docsifytabs-tab-highlight-color: var(--theme-color, #0074d9);
-
-  --docsifytabs-tab-background: #f8f8f8;
-  --docsifytabs-tab-background-active: transparent;
+@media only screen and (min-width: 768px) {
+  .flex-container {
+    display:flex;
+    flex-flow:row;
+  }
+  .flex-container > p {
+    flex-basis: 100%;
+    flex: 1;
+    margin: 1em 2em 1em 2em;
+  }
 }
 
 .docsify-tabs__tab:focus {
@@ -45,3 +48,11 @@
 .docsify-tabs__content .anchor {
   transition: none;
 }
+
+:root {
+  --docsifytabs-border-color: #ddd;
+  --docsifytabs-tab-highlight-color: var(--theme-color, #0074d9);
+
+  --docsifytabs-tab-background: #f8f8f8;
+  --docsifytabs-tab-background-active: transparent;
+}

docs/ws2812_driver.md

@@ -33,10 +33,11 @@ The default setting is 280 µs, which should work for most cases, but this can b
 Some variants of the WS2812 may have their color components in a different physical or logical order. For example, the WS2812B-2020 has physically swapped red and green LEDs, which causes the wrong color to be displayed, because the default order of the bytes sent over the wire is defined as GRB.
 In this case, you can change the byte order by defining `WS2812_BYTE_ORDER` as one of the following values:
 
-| Byte order                        | Known devices                 |
-|-----------------------------------|-------------------------------|
-| `WS2812_BYTE_ORDER_GRB` (default) | Most WS2812's, SK6812, SK6805 |
-| `WS2812_BYTE_ORDER_RGB`           | WS2812B-2020                  |
+|Byte order                       |Known devices                |
+|---------------------------------|-----------------------------|
+|`WS2812_BYTE_ORDER_GRB` (default)|Most WS2812's, SK6812, SK6805|
+|`WS2812_BYTE_ORDER_RGB`          |WS2812B-2020                 |
+|`WS2812_BYTE_ORDER_BGR`          |TM1812                       |
 
 
 ### Bitbang

drivers/chibios/spi_master.c

@@ -115,11 +115,17 @@ bool spi_start(pin_t slavePin, bool lsbFirst, uint8_t mode, uint16_t divisor) {
     return true;
 }
 
-spi_status_t spi_write(uint8_t data) { return spi_transmit(&data, 1); }
+spi_status_t spi_write(uint8_t data) {
+    uint8_t rxData;
+    spiExchange(&SPI_DRIVER, 1, &data, &rxData);
+
+    return rxData;
+}
 
 spi_status_t spi_read(void) {
     uint8_t data = 0;
-    spi_receive(&data, 1);
+    spiReceive(&SPI_DRIVER, 1, &data);
+
     return data;
 }
 

drivers/chibios/ws2812.c

@@ -97,6 +97,10 @@ void ws2812_setleds(LED_TYPE *ledarray, uint16_t leds) {
         sendByte(ledarray[i].r);
         sendByte(ledarray[i].g);
         sendByte(ledarray[i].b);
+#elif (WS2812_BYTE_ORDER == WS2812_BYTE_ORDER_BGR)
+        sendByte(ledarray[i].b);
+        sendByte(ledarray[i].g);
+        sendByte(ledarray[i].r);
 #endif
 
 #ifdef RGBW

drivers/chibios/ws2812_pwm.c

@@ -180,6 +180,43 @@
  * @return                          The bit index
  */
 #    define WS2812_BLUE_BIT(led, bit) WS2812_BIT((led), 2, (bit))
+
+#elif (WS2812_BYTE_ORDER == WS2812_BYTE_ORDER_BGR)
+/**
+ * @brief   Determine the index in @ref ws2812_frame_buffer "the frame buffer" of a given red bit
+ *
+ * @note    The red byte is the middle byte in the color packet
+ *
+ * @param[in] led:                  The led index [0, @ref RGBLED_NUM)
+ * @param[in] bit:                  The bit number [0, 7]
+ *
+ * @return                          The bit index
+ */
+#    define WS2812_RED_BIT(led, bit) WS2812_BIT((led), 2, (bit))
+
+/**
+ * @brief   Determine the index in @ref ws2812_frame_buffer "the frame buffer" of a given green bit
+ *
+ * @note    The red byte is the first byte in the color packet
+ *
+ * @param[in] led:                  The led index [0, @ref RGBLED_NUM)
+ * @param[in] bit:                  The bit number [0, 7]
+ *
+ * @return                          The bit index
+ */
+#    define WS2812_GREEN_BIT(led, bit) WS2812_BIT((led), 1, (bit))
+
+/**
+ * @brief   Determine the index in @ref ws2812_frame_buffer "the frame buffer" of a given blue bit
+ *
+ * @note    The red byte is the last byte in the color packet
+ *
+ * @param[in] led:                  The led index [0, @ref RGBLED_NUM)
+ * @param[in] bit:                  The bit index [0, 7]
+ *
+ * @return                          The bit index
+ */
+#    define WS2812_BLUE_BIT(led, bit) WS2812_BIT((led), 0, (bit))
 #endif
 
 /* --- PRIVATE VARIABLES ---------------------------------------------------- */

drivers/chibios/ws2812_spi.c

@@ -70,6 +70,10 @@ static void set_led_color_rgb(LED_TYPE color, int pos) {
     for (int j = 0; j < 4; j++) tx_start[BYTES_FOR_LED * pos + j] = get_protocol_eq(color.r, j);
     for (int j = 0; j < 4; j++) tx_start[BYTES_FOR_LED * pos + BYTES_FOR_LED_BYTE + j] = get_protocol_eq(color.g, j);
     for (int j = 0; j < 4; j++) tx_start[BYTES_FOR_LED * pos + BYTES_FOR_LED_BYTE * 2 + j] = get_protocol_eq(color.b, j);
+#elif (WS2812_BYTE_ORDER == WS2812_BYTE_ORDER_BGR)
+    for (int j = 0; j < 4; j++) tx_start[BYTES_FOR_LED * pos + j] = get_protocol_eq(color.b, j);
+    for (int j = 0; j < 4; j++) tx_start[BYTES_FOR_LED * pos + BYTES_FOR_LED_BYTE + j] = get_protocol_eq(color.g, j);
+    for (int j = 0; j < 4; j++) tx_start[BYTES_FOR_LED * pos + BYTES_FOR_LED_BYTE * 2 + j] = get_protocol_eq(color.r, j);
 #endif
 }
 

keyboards/0_sixty/0_sixty.c

@@ -0,0 +1,17 @@
+/* Copyright 2020 Vinam Arora <vinam@posteo.de>
+ *
+ * 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 "0_sixty.h"

keyboards/0_sixty/0_sixty.h

@@ -0,0 +1,97 @@
+/* Copyright 2020 Vinam Arora <vinam@posteo.de>
+ *
+ * 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"
+
+// This a shortcut to help you visually see your layout.
+// The first section contains all of the arguements
+// The second converts the arguments into a two-dimensional array
+#define LAYOUT_ortho_5x12( \
+    k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k0a, k0b, \
+    k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k1a, k1b, \
+    k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k2a, k2b, \
+    k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k3a, k3b, \
+    k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k4a, k4b  \
+) \
+{ \
+    { k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k0a, k0b }, \
+    { k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k1a, k1b }, \
+    { k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k2a, k2b }, \
+    { k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k3a, k3b }, \
+    { k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k4a, k4b }  \
+}
+
+#define LAYOUT_1x2uL( \
+    k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k0a, k0b, \
+    k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k1a, k1b, \
+    k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k2a, k2b, \
+    k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k3a, k3b, \
+    k40, k41, k42, k43,    k45,   k46, k47, k48, k49, k4a, k4b  \
+) \
+{ \
+    { k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k0a, k0b }, \
+    { k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k1a, k1b }, \
+    { k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k2a, k2b }, \
+    { k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k3a, k3b }, \
+    { k40, k41, k42, k43, k45, k45, k46, k47, k48, k49, k4a, k4b }  \
+}
+
+#define LAYOUT_1x2uC( \
+    k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k0a, k0b, \
+    k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k1a, k1b, \
+    k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k2a, k2b, \
+    k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k3a, k3b, \
+    k40, k41, k42, k43, k44,    k46,   k47, k48, k49, k4a, k4b \
+) \
+{ \
+    { k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k0a, k0b }, \
+    { k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k1a, k1b }, \
+    { k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k2a, k2b }, \
+    { k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k3a, k3b }, \
+    { k40, k41, k42, k43, k44, k46, k46, k47, k48, k49, k4a, k4b }  \
+}
+
+#define LAYOUT_1x2uR( \
+    k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k0a, k0b, \
+    k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k1a, k1b, \
+    k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k2a, k2b, \
+    k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k3a, k3b, \
+    k40, k41, k42, k43, k44, k45,   k46,    k48, k49, k4a, k4b  \
+) \
+{ \
+    { k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k0a, k0b }, \
+    { k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k1a, k1b }, \
+    { k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k2a, k2b }, \
+    { k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k3a, k3b }, \
+    { k40, k41, k42, k43, k44, k45, k46, k46, k48, k49, k4a, k4b }  \
+}
+
+#define LAYOUT_2x2uC( \
+    k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k0a, k0b, \
+    k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k1a, k1b, \
+    k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k2a, k2b, \
+    k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k3a, k3b, \
+    k40, k41, k42, k43,     k45,    k46,    k48, k49, k4a, k4b  \
+) \
+{ \
+    { k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k0a, k0b }, \
+    { k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k1a, k1b }, \
+    { k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k2a, k2b }, \
+    { k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k3a, k3b }, \
+    { k40, k41, k42, k43, k45, k45, k46, k46, k48, k49, k4a, k4b }  \
+}

keyboards/0_sixty/config.h

@@ -0,0 +1,68 @@
+/* Copyright 2020 Vinam Arora <vinam@posteo.de>
+ *
+ * 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 "config_common.h"
+
+/* USB Device descriptor parameter */
+
+#define VENDOR_ID       0x7654
+#define PRODUCT_ID      0x0060
+#define DEVICE_VER      0x0001
+
+#define MANUFACTURER    ven0mtr0n
+#define PRODUCT         0-Sixty
+
+/* key matrix size */
+// Rows are doubled-up
+#define MATRIX_ROWS 5
+#define MATRIX_COLS 12
+#define MATRIX_ROW_PINS { B1, F7, F6, F5, F4 }
+#define MATRIX_COL_PINS { D3, D2, D1, D0, D4, C6, D7, E6, B4, B5, B3, B2 }
+#define UNUSED_PINS
+
+/* COL2ROW or ROW2COL */
+#define DIODE_DIRECTION COL2ROW
+
+/* Set 0 if debouncing isn't needed */
+#define DEBOUNCE 5
+
+/* indicator leds */
+#define LED_CAPS_LOCK_PIN B6
+
+/* 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
+
+/*
+ * Feature disable options
+ *  These options are also useful to firmware size reduction.
+ */
+
+/* disable debug print */
+// #define NO_DEBUG
+
+/* disable print */
+// #define NO_PRINT
+
+/* disable action features */
+//#define NO_ACTION_LAYER
+//#define NO_ACTION_TAPPING
+//#define NO_ACTION_ONESHOT
+//#define NO_ACTION_MACRO
+//#define NO_ACTION_FUNCTION

keyboards/0_sixty/info.json

@@ -0,0 +1,344 @@
+{
+    "keyboard_name": "0-Sixty",
+    "url": "",
+    "maintainer": "vinamarora8",
+    "width": 12,
+    "height": 5,
+    "layouts": {
+	"LAYOUT_1x2uC": {
+            "layout": [
+                {"x": 0, "y": 0},
+                {"x": 1, "y": 0},
+                {"x": 2, "y": 0},
+                {"x": 3, "y": 0},
+                {"x": 4, "y": 0},
+                {"x": 5, "y": 0},
+                {"x": 6, "y": 0},
+                {"x": 7, "y": 0},
+                {"x": 8, "y": 0},
+                {"x": 9, "y": 0},
+                {"x": 10, "y": 0},
+                {"x": 11, "y": 0},
+
+                {"x": 0, "y": 1},
+                {"x": 1, "y": 1},
+                {"x": 2, "y": 1},
+                {"x": 3, "y": 1},
+                {"x": 4, "y": 1},
+                {"x": 5, "y": 1},
+                {"x": 6, "y": 1},
+                {"x": 7, "y": 1},
+                {"x": 8, "y": 1},
+                {"x": 9, "y": 1},
+                {"x": 10, "y": 1},
+                {"x": 11, "y": 1},
+
+                {"x": 0, "y": 2},
+                {"x": 1, "y": 2},
+                {"x": 2, "y": 2},
+                {"x": 3, "y": 2},
+                {"x": 4, "y": 2},
+                {"x": 5, "y": 2},
+                {"x": 6, "y": 2},
+                {"x": 7, "y": 2},
+                {"x": 8, "y": 2},
+                {"x": 9, "y": 2},
+                {"x": 10, "y": 2},
+                {"x": 11, "y": 2},
+
+                {"x": 0, "y": 3},
+                {"x": 1, "y": 3},
+                {"x": 2, "y": 3},
+                {"x": 3, "y": 3},
+                {"x": 4, "y": 3},
+                {"x": 5, "y": 3},
+                {"x": 6, "y": 3},
+                {"x": 7, "y": 3},
+                {"x": 8, "y": 3},
+                {"x": 9, "y": 3},
+                {"x": 10, "y": 3},
+                {"x": 11, "y": 3},
+
+                {"x": 0, "y": 4},
+                {"x": 1, "y": 4},
+                {"x": 2, "y": 4},
+                {"x": 3, "y": 4},
+                {"x": 4, "y": 4},
+                {"x": 5, "y": 4, "w": 2},
+                {"x": 7, "y": 4},
+                {"x": 8, "y": 4},
+                {"x": 9, "y": 4},
+                {"x": 10, "y": 4},
+                {"x": 11, "y": 4}
+            ]
+	},
+	"LAYOUT_2x2uC": {
+            "layout": [
+                {"x": 0, "y": 0},
+                {"x": 1, "y": 0},
+                {"x": 2, "y": 0},
+                {"x": 3, "y": 0},
+                {"x": 4, "y": 0},
+                {"x": 5, "y": 0},
+                {"x": 6, "y": 0},
+                {"x": 7, "y": 0},
+                {"x": 8, "y": 0},
+                {"x": 9, "y": 0},
+                {"x": 10, "y": 0},
+                {"x": 11, "y": 0},
+
+                {"x": 0, "y": 1},
+                {"x": 1, "y": 1},
+                {"x": 2, "y": 1},
+                {"x": 3, "y": 1},
+                {"x": 4, "y": 1},
+                {"x": 5, "y": 1},
+                {"x": 6, "y": 1},
+                {"x": 7, "y": 1},
+                {"x": 8, "y": 1},
+                {"x": 9, "y": 1},
+                {"x": 10, "y": 1},
+                {"x": 11, "y": 1},
+
+                {"x": 0, "y": 2},
+                {"x": 1, "y": 2},
+                {"x": 2, "y": 2},
+                {"x": 3, "y": 2},
+                {"x": 4, "y": 2},
+                {"x": 5, "y": 2},
+                {"x": 6, "y": 2},
+                {"x": 7, "y": 2},
+                {"x": 8, "y": 2},
+                {"x": 9, "y": 2},
+                {"x": 10, "y": 2},
+                {"x": 11, "y": 2},
+
+                {"x": 0, "y": 3},
+                {"x": 1, "y": 3},
+                {"x": 2, "y": 3},
+                {"x": 3, "y": 3},
+                {"x": 4, "y": 3},
+                {"x": 5, "y": 3},
+                {"x": 6, "y": 3},
+                {"x": 7, "y": 3},
+                {"x": 8, "y": 3},
+                {"x": 9, "y": 3},
+                {"x": 10, "y": 3},
+                {"x": 11, "y": 3},
+
+                {"x": 0, "y": 4},
+                {"x": 1, "y": 4},
+                {"x": 2, "y": 4},
+                {"x": 3, "y": 4},
+                {"x": 4, "y": 4, "w": 2},
+                {"x": 6, "y": 4, "w": 2},
+                {"x": 8, "y": 4},
+                {"x": 9, "y": 4},
+                {"x": 10, "y": 4},
+                {"x": 11, "y": 4}
+            ]
+        },
+        "LAYOUT_ortho_5x12": {
+            "layout": [
+                {"x": 0, "y": 0},
+                {"x": 1, "y": 0},
+                {"x": 2, "y": 0},
+                {"x": 3, "y": 0},
+                {"x": 4, "y": 0},
+                {"x": 5, "y": 0},
+                {"x": 6, "y": 0},
+                {"x": 7, "y": 0},
+                {"x": 8, "y": 0},
+                {"x": 9, "y": 0},
+                {"x": 10, "y": 0},
+                {"x": 11, "y": 0},
+
+                {"x": 0, "y": 1},
+                {"x": 1, "y": 1},
+                {"x": 2, "y": 1},
+                {"x": 3, "y": 1},
+                {"x": 4, "y": 1},
+                {"x": 5, "y": 1},
+                {"x": 6, "y": 1},
+                {"x": 7, "y": 1},
+                {"x": 8, "y": 1},
+                {"x": 9, "y": 1},
+                {"x": 10, "y": 1},
+                {"x": 11, "y": 1},
+
+                {"x": 0, "y": 2},
+                {"x": 1, "y": 2},
+                {"x": 2, "y": 2},
+                {"x": 3, "y": 2},
+                {"x": 4, "y": 2},
+                {"x": 5, "y": 2},
+                {"x": 6, "y": 2},
+                {"x": 7, "y": 2},
+                {"x": 8, "y": 2},
+                {"x": 9, "y": 2},
+                {"x": 10, "y": 2},
+                {"x": 11, "y": 2},
+
+                {"x": 0, "y": 3},
+                {"x": 1, "y": 3},
+                {"x": 2, "y": 3},
+                {"x": 3, "y": 3},
+                {"x": 4, "y": 3},
+                {"x": 5, "y": 3},
+                {"x": 6, "y": 3},
+                {"x": 7, "y": 3},
+                {"x": 8, "y": 3},
+                {"x": 9, "y": 3},
+                {"x": 10, "y": 3},
+                {"x": 11, "y": 3},
+
+                {"x": 0, "y": 4},
+                {"x": 1, "y": 4},
+                {"x": 2, "y": 4},
+                {"x": 3, "y": 4},
+                {"x": 4, "y": 4},
+                {"x": 5, "y": 4},
+                {"x": 6, "y": 4},
+                {"x": 7, "y": 4},
+                {"x": 8, "y": 4},
+                {"x": 9, "y": 4},
+                {"x": 10, "y": 4},
+                {"x": 11, "y": 4}
+            ]
+        },
+	"LAYOUT_1x2uR": {
+            "layout": [
+                {"x": 0, "y": 0},
+                {"x": 1, "y": 0},
+                {"x": 2, "y": 0},
+                {"x": 3, "y": 0},
+                {"x": 4, "y": 0},
+                {"x": 5, "y": 0},
+                {"x": 6, "y": 0},
+                {"x": 7, "y": 0},
+                {"x": 8, "y": 0},
+                {"x": 9, "y": 0},
+                {"x": 10, "y": 0},
+                {"x": 11, "y": 0},
+
+                {"x": 0, "y": 1},
+                {"x": 1, "y": 1},
+                {"x": 2, "y": 1},
+                {"x": 3, "y": 1},
+                {"x": 4, "y": 1},
+                {"x": 5, "y": 1},
+                {"x": 6, "y": 1},
+                {"x": 7, "y": 1},
+                {"x": 8, "y": 1},
+                {"x": 9, "y": 1},
+                {"x": 10, "y": 1},
+                {"x": 11, "y": 1},
+
+                {"x": 0, "y": 2},
+                {"x": 1, "y": 2},
+                {"x": 2, "y": 2},
+                {"x": 3, "y": 2},
+                {"x": 4, "y": 2},
+                {"x": 5, "y": 2},
+                {"x": 6, "y": 2},
+                {"x": 7, "y": 2},
+                {"x": 8, "y": 2},
+                {"x": 9, "y": 2},
+                {"x": 10, "y": 2},
+                {"x": 11, "y": 2},
+
+                {"x": 0, "y": 3},
+                {"x": 1, "y": 3},
+                {"x": 2, "y": 3},
+                {"x": 3, "y": 3},
+                {"x": 4, "y": 3},
+                {"x": 5, "y": 3},
+                {"x": 6, "y": 3},
+                {"x": 7, "y": 3},
+                {"x": 8, "y": 3},
+                {"x": 9, "y": 3},
+                {"x": 10, "y": 3},
+                {"x": 11, "y": 3},
+
+                {"x": 0, "y": 4},
+                {"x": 1, "y": 4},
+                {"x": 2, "y": 4},
+                {"x": 3, "y": 4},
+                {"x": 4, "y": 4},
+                {"x": 5, "y": 4},
+                {"x": 6, "y": 4, "w": 2},
+                {"x": 8, "y": 4},
+                {"x": 9, "y": 4},
+                {"x": 10, "y": 4},
+                {"x": 11, "y": 4}
+            ]
+        },
+        "LAYOUT_1x2uL": {
+            "layout": [
+                {"x": 0, "y": 0},
+                {"x": 1, "y": 0},
+                {"x": 2, "y": 0},
+                {"x": 3, "y": 0},
+                {"x": 4, "y": 0},
+                {"x": 5, "y": 0},
+                {"x": 6, "y": 0},
+                {"x": 7, "y": 0},
+                {"x": 8, "y": 0},
+                {"x": 9, "y": 0},
+                {"x": 10, "y": 0},
+                {"x": 11, "y": 0},
+
+                {"x": 0, "y": 1},
+                {"x": 1, "y": 1},
+                {"x": 2, "y": 1},
+                {"x": 3, "y": 1},
+                {"x": 4, "y": 1},
+                {"x": 5, "y": 1},
+                {"x": 6, "y": 1},
+                {"x": 7, "y": 1},
+                {"x": 8, "y": 1},
+                {"x": 9, "y": 1},
+                {"x": 10, "y": 1},
+                {"x": 11, "y": 1},
+
+                {"x": 0, "y": 2},
+                {"x": 1, "y": 2},
+                {"x": 2, "y": 2},
+                {"x": 3, "y": 2},
+                {"x": 4, "y": 2},
+                {"x": 5, "y": 2},
+                {"x": 6, "y": 2},
+                {"x": 7, "y": 2},
+                {"x": 8, "y": 2},
+                {"x": 9, "y": 2},
+                {"x": 10, "y": 2},
+                {"x": 11, "y": 2},
+
+                {"x": 0, "y": 3},
+                {"x": 1, "y": 3},
+                {"x": 2, "y": 3},
+                {"x": 3, "y": 3},
+                {"x": 4, "y": 3},
+                {"x": 5, "y": 3},
+                {"x": 6, "y": 3},
+                {"x": 7, "y": 3},
+                {"x": 8, "y": 3},
+                {"x": 9, "y": 3},
+                {"x": 10, "y": 3},
+                {"x": 11, "y": 3},
+
+                {"x": 0, "y": 4},
+                {"x": 1, "y": 4},
+                {"x": 2, "y": 4},
+                {"x": 3, "y": 4},
+                {"x": 4, "y": 4, "w": 2},
+                {"x": 6, "y": 4},
+                {"x": 7, "y": 4},
+                {"x": 8, "y": 4},
+                {"x": 9, "y": 4},
+                {"x": 10, "y": 4},
+                {"x": 11, "y": 4}
+            ]
+        }
+    }
+}

keyboards/0_sixty/keymaps/default/keymap.c

@@ -0,0 +1,168 @@
+/* Copyright 2020 Vinam Arora <vinam@posteo.de>
+ *
+ * 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
+
+enum zero_sixty_layers {
+  _QWERTY,
+  _COLEMAK,
+  _DVORAK,
+  _LOWER,
+  _RAISE,
+  _ADJUST
+};
+
+#define QWERTY DF(_QWERTY)
+#define COLEMAK DF(_COLEMAK)
+#define DVORAK DF(_DVORAK)
+#define LOWER MO(_LOWER)
+#define RAISE MO(_RAISE)
+#define ADJUST MO(_ADJUST)
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+/* Qwerty
+ * ,-----------------------------------------------------------------------------------.
+ * |   `  |   1  |   2  |   3  |   4  |   5  |   6  |   7  |   8  |   9  |   0  | Bksp |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * | Tab  |   Q  |   W  |   E  |   R  |   T  |   Y  |   U  |   I  |   O  |   P  | Del  |
+ * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * | Esc  |   A  |   S  |   D  |   F  |   G  |   H  |   J  |   K  |   L  |   ;  |  "   |
+ * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * | Shift|   Z  |   X  |   C  |   V  |   B  |   N  |   M  |   ,  |   .  |   /  |Enter |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * | Caps | Ctrl | Alt  | GUI  |Lower |    Space    |Raise | Left | Down |  Up  |Right |
+ * `-----------------------------------------------------------------------------------'
+ */
+[_QWERTY] = LAYOUT_ortho_5x12(
+  KC_GRV,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_BSPC,
+  KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_DEL,
+  KC_ESC,  KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT,
+  KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_ENT,
+  KC_CAPS, KC_LCTL, KC_LALT, KC_LGUI, LOWER,   KC_SPC,  KC_SPC,  RAISE,   KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT
+),
+
+/* Colemak
+ * ,-----------------------------------------------------------------------------------.
+ * |   `  |   1  |   2  |   3  |   4  |   5  |   6  |   7  |   8  |   9  |   0  | Bksp |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * | Tab  |   Q  |   W  |   F  |   P  |   G  |   J  |   L  |   U  |   Y  |   ;  | Del  |
+ * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * | Esc  |   A  |   R  |   S  |   T  |   D  |   H  |   N  |   E  |   I  |   O  |  "   |
+ * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * | Shift|   Z  |   X  |   C  |   V  |   B  |   K  |   M  |   ,  |   .  |   /  |Enter |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * | Caps | Ctrl | Alt  | GUI  |Lower |    Space    |Raise | Left | Down |  Up  |Right |
+ * `-----------------------------------------------------------------------------------'
+ */
+[_COLEMAK] = LAYOUT_ortho_5x12(
+  KC_GRV,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_BSPC,
+  KC_TAB,  KC_Q,    KC_W,    KC_F,    KC_P,    KC_G,    KC_J,    KC_L,    KC_U,    KC_Y,    KC_SCLN, KC_DEL,
+  KC_ESC,  KC_A,    KC_R,    KC_S,    KC_T,    KC_D,    KC_H,    KC_N,    KC_E,    KC_I,    KC_O,    KC_QUOT,
+  KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_K,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_ENT,
+  KC_CAPS, KC_LCTL, KC_LALT, KC_LGUI, LOWER,   KC_SPC,  KC_SPC,  RAISE,   KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT
+),
+
+/* Dvorak
+ * ,-----------------------------------------------------------------------------------.
+ * |   `  |   1  |   2  |   3  |   4  |   5  |   6  |   7  |   8  |   9  |   0  | Bksp |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * | Tab  |   "  |   ,  |   .  |   P  |   Y  |   F  |   G  |   C  |   R  |   L  | Del  |
+ * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * | Esc  |   A  |   O  |   E  |   U  |   I  |   D  |   H  |   T  |   N  |   S  |  /   |
+ * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * | Shift|   ;  |   Q  |   J  |   K  |   X  |   B  |   M  |   W  |   V  |   Z  |Enter |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * | Caps | Ctrl | Alt  | GUI  |Lower |    Space    |Raise | Left | Down |  Up  |Right |
+ * `-----------------------------------------------------------------------------------'
+ */
+[_DVORAK] = LAYOUT_ortho_5x12(
+  KC_GRV,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_BSPC,
+  KC_TAB,  KC_QUOT, KC_COMM, KC_DOT,  KC_P,    KC_Y,    KC_F,    KC_G,    KC_C,    KC_R,    KC_L,    KC_DEL,
+  KC_ESC,  KC_A,    KC_O,    KC_E,    KC_U,    KC_I,    KC_D,    KC_H,    KC_T,    KC_N,    KC_S,    KC_SLSH,
+  KC_LSFT, KC_SCLN, KC_Q,    KC_J,    KC_K,    KC_X,    KC_B,    KC_M,    KC_W,    KC_V,    KC_Z,    KC_ENT,
+  KC_CAPS, KC_LCTL, KC_LALT, KC_LGUI, LOWER,   KC_SPC,  KC_SPC,  RAISE,   KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT
+),
+
+/* Lower
+ * ,-----------------------------------------------------------------------------------.
+ * |   ~  |   !  |   @  |   #  |   $  |   %  |   ^  |   &  |   *  |   (  |   )  | Bksp |
+ * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * |   ~  |   !  |   @  |   #  |   $  |   %  |   ^  |   &  |   *  |   (  |   )  | Del  |
+ * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * | Del  |  F1  |  F2  |  F3  |  F4  |  F5  |  F6  |   _  |   +  |   {  |   }  |  |   |
+ * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * |      |  F7  |  F8  |  F9  |  F10 |  F11 |  F12 |ISO ~ |ISO | |      |      |      |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * |      |      |      |      |      |             |      | Next | Vol- | Vol+ | Play |
+ * `-----------------------------------------------------------------------------------'
+ */
+[_LOWER] = LAYOUT_ortho_5x12(
+  KC_TILD, KC_EXLM, KC_AT,   KC_HASH, KC_DLR,  KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_BSPC,
+  KC_TILD, KC_EXLM, KC_AT,   KC_HASH, KC_DLR,  KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_DEL,
+  KC_DEL,  KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_UNDS, KC_PLUS, KC_LCBR, KC_RCBR, KC_PIPE,
+  _______, KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,S(KC_NUHS),S(KC_NUBS),KC_HOME, KC_END, _______,
+  _______, _______, _______, _______, _______, _______, _______, _______,  KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY
+),
+
+/* Raise
+ * ,-----------------------------------------------------------------------------------.
+ * |   `  |   1  |   2  |   3  |   4  |   5  |   6  |   7  |   8  |   9  |   0  | Bksp |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * |   `  |   1  |   2  |   3  |   4  |   5  |   6  |   7  |   8  |   9  |   0  | Del  |
+ * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * | Del  |  F1  |  F2  |  F3  |  F4  |  F5  |  F6  |   -  |   =  |   [  |   ]  |  \   |
+ * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * |      |  F7  |  F8  |  F9  |  F10 |  F11 |  F12 |ISO # |ISO / |      |      |      |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * |      |      |      |      |      |             |      | Next | Vol- | Vol+ | Play |
+ * `-----------------------------------------------------------------------------------'
+ */
+[_RAISE] = LAYOUT_ortho_5x12(
+  KC_GRV,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_BSPC,
+  KC_GRV,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_DEL,
+  KC_DEL,  KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_MINS, KC_EQL,  KC_LBRC, KC_RBRC, KC_BSLS,
+  _______, KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,  KC_NUHS, KC_NUBS, KC_PGUP, KC_PGDN, _______,
+  _______, _______, _______, _______, _______, _______, _______, _______, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY
+),
+
+/* Adjust
+ * ,-----------------------------------------------------------------------------------.
+ * |  F1  |  F2  |  F3  |  F4  |  F5  |  F6  |  F7  |  F8  |  F9  |  F10 |  F11 |  F12 |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * |      | Reset|      |      |      |      |      |      |      |      |      |  Del |
+ * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * |      |      |      |      |      |      |      |Qwerty|Colemk|Dvorak|      |      |
+ * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * |      |      |      |      |      |      |      |      |      |      |      |      |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * |      |      |      |      |      |             |      |      |      |      |      |
+ * `-----------------------------------------------------------------------------------'
+ */
+[_ADJUST] = LAYOUT_ortho_5x12(
+  KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,
+  _______, RESET,   _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_DEL,
+  _______, _______, _______, _______, _______, _______, _______, QWERTY,  COLEMAK, DVORAK,  _______, _______,
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______
+)
+
+
+};
+
+layer_state_t layer_state_set_user(layer_state_t state) {
+  return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST);
+}

keyboards/0_sixty/keymaps/default/readme.md

@@ -0,0 +1 @@
+# The default 0-Sixty layout - largely based on the Preonic's and Planck's

keyboards/0_sixty/keymaps/ven0mtr0n/keymap.c

@@ -0,0 +1,59 @@
+/* Copyright 2020 Vinam Arora <vinam@posteo.de>
+ *
+ * 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
+
+enum zero_sixty_layers {
+  _DEFAULT,
+  _L1,
+  _L2,
+  _L3,
+};
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+[_DEFAULT] = LAYOUT_1x2uC( /* qwerty */
+  KC_ESC,   KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_BSPC ,
+  KC_TAB,   KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_ENT ,
+  KC_LCTL,  KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_RCTL ,
+  KC_LSFT,  KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_RSFT ,
+  KC_LGUI,  MO(_L3), MO(_L2), KC_LALT, MO(_L1),     KC_SPC,       MO(_L1), KC_RALT, MO(_L2), MO(_L3), KC_RGUI
+),
+
+[_L1] = LAYOUT_1x2uC(
+  _______,   _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ ,
+  _______,  KC_LBRC, KC_LT,   KC_GT,   KC_RBRC, KC_TILD, KC_PIPE, KC_GRV,  KC_QUOT, KC_DQUO, KC_PGUP, _______ ,
+  _______,  KC_LCBR, KC_LPRN, KC_RPRN, KC_RCBR, KC_DEL,  KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT, KC_PGDN, _______ ,
+  _______,  KC_APP,  _______, _______, _______, _______, KC_EQL,  KC_UNDS, KC_MINS, KC_PLUS, KC_BSLS, _______ ,
+  _______,  _______, _______, _______, _______,     KC_CAPS,      _______, _______, _______, _______, _______
+),
+
+[_L2] = LAYOUT_1x2uC(
+  _______,   KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  _______ ,
+  _______,  _______, _______, _______, _______, KC_VOLU, _______, KC_7,    KC_8,    KC_9,    KC_F11,  _______ ,
+  _______,  _______, _______, _______, KC_MPRV, KC_MPLY, KC_MNXT, KC_4,    KC_5,    KC_6,    KC_F12,  _______ ,
+  _______,  _______, _______, _______, KC_MUTE, KC_VOLD, KC_MUTE, KC_1,    KC_2,    KC_3,    KC_PSCR, _______ ,
+  _______,  _______, KC_CAPS, _______, _______,     _______,      KC_0,    _______, KC_CAPS, _______, _______
+),
+
+[_L3] = LAYOUT_1x2uC(
+  _______,  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ ,
+  _______,  _______, _______, _______, _______, _______, _______, KC_WH_U, KC_MS_U, KC_WH_D, _______, _______ ,
+  _______,  _______, KC_ACL2, KC_ACL1, KC_ACL0, _______, _______, KC_MS_L, KC_MS_D, KC_MS_R, _______, _______ ,
+  _______,  _______, _______, _______, _______, _______, _______, KC_BTN1, KC_BTN3, KC_BTN2, _______, _______ ,
+  _______,  _______, _______, _______, _______,     _______,      _______, _______, _______, _______, _______
+),
+
+};

keyboards/0_sixty/keymaps/ven0mtr0n/readme.md

@@ -0,0 +1 @@
+# Keymap used by vinam. Keeps changing ofcourse :3

keyboards/0_sixty/keymaps/ven0mtr0n/rules.mk

@@ -0,0 +1 @@
+MOUSEKEY_ENABLE = yes

keyboards/0_sixty/keymaps/via/config.h

@@ -0,0 +1,22 @@
+/* Copyright 2021 Vinam Arora <vinam@posteo.de>
+ *
+ * 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 DYNAMIC_KEYMAP_LAYER_COUNT 7
+/* This is 4 by default. ProMicro's memory doesn't seem to be able to
+ * support more than 7 dynamic keymap layers
+ */

keyboards/0_sixty/keymaps/via/keymap.c

@@ -0,0 +1,146 @@
+/* Copyright 2020 Vinam Arora <vinam@posteo.de>
+ *
+ * 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
+
+// 4 layers, because that is what VIA can support by default
+enum zero_sixty_layers {
+  _QWERTY,
+  _LOWER,
+  _RAISE,
+  _ADJUST,
+  _EMPTY1, // Just to initialize dynamic layers in VIA
+  _EMPTY2,
+  _EMPTY3,
+};
+
+#define LOWER MO(_LOWER)
+#define RAISE MO(_RAISE)
+#define ADJUST MO(_ADJUST)
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+/* Qwerty
+ * ,-----------------------------------------------------------------------------------.
+ * |   `  |   1  |   2  |   3  |   4  |   5  |   6  |   7  |   8  |   9  |   0  | Bksp |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * | Tab  |   Q  |   W  |   E  |   R  |   T  |   Y  |   U  |   I  |   O  |   P  | Del  |
+ * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * | Esc  |   A  |   S  |   D  |   F  |   G  |   H  |   J  |   K  |   L  |   ;  |  "   |
+ * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * | Shift|   Z  |   X  |   C  |   V  |   B  |   N  |   M  |   ,  |   .  |   /  |Enter |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * | Caps | Ctrl | Alt  | GUI  |Lower |    Space    |Raise | Left | Down |  Up  |Right |
+ * `-----------------------------------------------------------------------------------'
+ */
+[_QWERTY] = LAYOUT_ortho_5x12(
+  KC_GRV,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_BSPC,
+  KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_DEL,
+  KC_ESC,  KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT,
+  KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_ENT,
+  KC_CAPS, KC_LCTL, KC_LALT, KC_LGUI, LOWER,   KC_SPC,  KC_SPC,  RAISE,   KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT
+),
+
+/* Lower
+ * ,-----------------------------------------------------------------------------------.
+ * |   ~  |   !  |   @  |   #  |   $  |   %  |   ^  |   &  |   *  |   (  |   )  | Bksp |
+ * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * |   ~  |   !  |   @  |   #  |   $  |   %  |   ^  |   &  |   *  |   (  |   )  | Del  |
+ * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * | Del  |  F1  |  F2  |  F3  |  F4  |  F5  |  F6  |   _  |   +  |   {  |   }  |  |   |
+ * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * |      |  F7  |  F8  |  F9  |  F10 |  F11 |  F12 |ISO ~ |ISO | |      |      |      |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * |      |      |      |      |      |             |      | Next | Vol- | Vol+ | Play |
+ * `-----------------------------------------------------------------------------------'
+ */
+[_LOWER] = LAYOUT_ortho_5x12(
+  KC_TILD, KC_EXLM, KC_AT,   KC_HASH, KC_DLR,  KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_BSPC,
+  KC_TILD, KC_EXLM, KC_AT,   KC_HASH, KC_DLR,  KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_DEL,
+  KC_DEL,  KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_UNDS, KC_PLUS, KC_LCBR, KC_RCBR, KC_PIPE,
+  _______, KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,S(KC_NUHS),S(KC_NUBS),KC_HOME, KC_END, _______,
+  _______, _______, _______, _______, _______, _______, _______, ADJUST,  KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY
+),
+
+/* Raise
+ * ,-----------------------------------------------------------------------------------.
+ * |   `  |   1  |   2  |   3  |   4  |   5  |   6  |   7  |   8  |   9  |   0  | Bksp |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * |   `  |   1  |   2  |   3  |   4  |   5  |   6  |   7  |   8  |   9  |   0  | Del  |
+ * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * | Del  |  F1  |  F2  |  F3  |  F4  |  F5  |  F6  |   -  |   =  |   [  |   ]  |  \   |
+ * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * |      |  F7  |  F8  |  F9  |  F10 |  F11 |  F12 |ISO # |ISO / |      |      |      |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * |      |      |      |      |      |             |      | Next | Vol- | Vol+ | Play |
+ * `-----------------------------------------------------------------------------------'
+ */
+[_RAISE] = LAYOUT_ortho_5x12(
+  KC_GRV,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_BSPC,
+  KC_GRV,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_DEL,
+  KC_DEL,  KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_MINS, KC_EQL,  KC_LBRC, KC_RBRC, KC_BSLS,
+  _______, KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,  KC_NUHS, KC_NUBS, KC_PGUP, KC_PGDN, _______,
+  _______, _______, _______, _______, ADJUST,  _______, _______, _______, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY
+),
+
+/* Adjust
+ * ,-----------------------------------------------------------------------------------.
+ * |  F1  |  F2  |  F3  |  F4  |  F5  |  F6  |  F7  |  F8  |  F9  |  F10 |  F11 |  F12 |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * |      | Reset|      |      |      |      |      |      |      |      |      |  Del |
+ * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * |      |      |      |      |      |      |      |      |      |      |      |      |
+ * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * |      |      |      |      |      |      |      |      |      |      |      |      |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * |      |      |      |      |      |             |      |      |      |      |      |
+ * `-----------------------------------------------------------------------------------'
+ */
+[_ADJUST] = LAYOUT_ortho_5x12(
+  KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,
+  _______, RESET,   _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______
+),
+
+/* Transparent layers, only to initialize VIA's dynamic layers */
+
+[_EMPTY1] = LAYOUT_ortho_5x12(
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______
+),
+
+[_EMPTY2] = LAYOUT_ortho_5x12(
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______
+),
+
+[_EMPTY3] = LAYOUT_ortho_5x12(
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______
+),
+
+};

keyboards/0_sixty/keymaps/via/readme.md

@@ -0,0 +1 @@
+# The default via-supported 0-Sixty layout - largely based on the Preonic's and Planck's

keyboards/0_sixty/readme.md

@@ -0,0 +1,27 @@
+# 0-Sixty
+
+![0-Sixty](https://imgur.com/azmMb6Rl.jpg)
+
+![0-Sixty PCB](https://i.imgur.com/I0TkQ0Rl.jpg)
+
+0-Sixty (pronounced "zero to sixty") is a 60 key ortholinear keyboard inspired by the [Discipline](https://github.com/coseyfannitutti/discipline) and the [Preonic](https://drop.com/buy/preonic-mechanical-keyboard). It is designed as a DIY through-hole kit and uses the ProMicro as its controller.
+
+[More images here](https://imgur.com/a/b0JINqX)
+
+* Keyboard Maintainer: [vinamarora8](https://github.com/vinamarora8)
+* Hardware Supported: 0-Sixty PCB
+* Hardware Availability: Private Group-Buy
+
+Getting the board into bootloader mode:
+
+To be able to flash firmware onto this board, you'll need to bring the ProMicro into bootloader mode. Simply tap the small reset button twice. The button is placed to the right of the ProMicro.
+
+Make example for this keyboard (after setting up your build environment):
+
+    make 0_sixty:default
+
+Flashing example for this keyboard:
+
+    make 0_sixty:default:flash
+
+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).

keyboards/0_sixty/rules.mk

@@ -0,0 +1,21 @@
+# MCU name
+MCU = atmega32u4
+
+# Bootloader selection
+BOOTLOADER = caterina
+
+# Build Options
+#   change yes to no to disable
+#
+BOOTMAGIC_ENABLE = no       # Virtual DIP switch configuration
+EXTRAKEY_ENABLE = yes       # Audio control and System control
+CONSOLE_ENABLE = yes        # Console for debug
+COMMAND_ENABLE = yes        # Commands for debug and configuration
+# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
+SLEEP_LED_ENABLE = no       # Breathing sleep LED during USB suspend
+# if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
+NKRO_ENABLE = yes           # USB Nkey Rollover
+BACKLIGHT_ENABLE = no       # Enable keyboard backlight functionality
+RGBLIGHT_ENABLE = no        # Enable keyboard RGB underglow
+BLUETOOTH_ENABLE = no       # Enable Bluetooth
+AUDIO_ENABLE = no           # Audio output

keyboards/1upkeyboards/1up60hse/config.h

@@ -25,7 +25,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define DEVICE_VER      0x0001
 #define MANUFACTURER    1upkeyboards
 #define PRODUCT         1up60hse
-#define DESCRIPTION     A custom 60% keyboard
 
 /* key matrix size */
 #define MATRIX_ROWS 5
@@ -171,9 +170,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
  * MIDI options
  */
 
-/* Prevent use of disabled MIDI features in the keymap */
-//#define MIDI_ENABLE_STRICT 1
-
 /* enable basic MIDI features:
    - MIDI notes can be sent when in Music mode is on
 */

keyboards/1upkeyboards/1up60hte/config.h

@@ -26,7 +26,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define DEVICE_VER      0x0001
 #define MANUFACTURER    1upkeyboards
 #define PRODUCT         1up60hte
-#define DESCRIPTION     A custom 60% keyboard
 
 /* key matrix size */
 #define MATRIX_ROWS 5

keyboards/1upkeyboards/1up60rgb/config.h

@@ -8,7 +8,6 @@
 #define DEVICE_VER      0x0001
 #define MANUFACTURER    1upkeyboards
 #define PRODUCT         1UP RGB Underglow PCB
-#define DESCRIPTION     60% keyboard with RGB underglow
 
 /* key matrix size */
 #define MATRIX_ROWS 5

keyboards/1upkeyboards/super16/config.h

@@ -25,7 +25,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define DEVICE_VER      0x0001
 #define MANUFACTURER    1upkeyboards
 #define PRODUCT         super16
-#define DESCRIPTION     A 4x4 custom macropad
 
 /* key matrix size */
 #define MATRIX_ROWS 4
@@ -200,9 +199,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
  * MIDI options
  */
 
-/* Prevent use of disabled MIDI features in the keymap */
-//#define MIDI_ENABLE_STRICT 1
-
 /* enable basic MIDI features:
    - MIDI notes can be sent when in Music mode is on
 */

keyboards/1upkeyboards/sweet16/config.h

@@ -6,7 +6,6 @@
 #define VENDOR_ID       0x6F75 // OU
 #define MANUFACTURER    1up Keyboards
 #define PRODUCT         Sweet16
-#define DESCRIPTION     4x4 grid
 
 /* key matrix size */
 #define MATRIX_ROWS 4

keyboards/2key2crawl/config.h

@@ -8,7 +8,6 @@
 #define DEVICE_VER      0x0002
 #define MANUFACTURER    WoodKeys.click
 #define PRODUCT         2Key2Crawl
-#define DESCRIPTION     ATX Keycrawl 2018
 
 /* key matrix size */
 #define MATRIX_ROWS 2

keyboards/30wer/config.h

@@ -8,7 +8,6 @@
 #define DEVICE_VER      0x0000
 #define MANUFACTURER    8o7wer
 #define PRODUCT         30wer
-#define DESCRIPTION     Gherkin style construction 30% staggered pcb kit
 
 /* key matrix size */
 #define MATRIX_ROWS 3

keyboards/40percentclub/25/config.h

@@ -24,7 +24,6 @@
 #define DEVICE_VER      0x0F25
 #define MANUFACTURER    di0ib
 #define PRODUCT         The 5x5 Keyboard
-#define DESCRIPTION     A split 50 key keyboard
 
 #define USE_SERIAL
 /* serial.c configuration for split keyboard */
@@ -179,9 +178,6 @@
  * MIDI options
  */
 
-/* Prevent use of disabled MIDI features in the keymap */
-//#define MIDI_ENABLE_STRICT 1
-
 /* enable basic MIDI features:
    - MIDI notes can be sent when in Music mode is on
 */

keyboards/40percentclub/4pack/config.h

@@ -25,7 +25,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define DEVICE_VER 0x0001
 #define MANUFACTURER 40percentclub
 #define PRODUCT 4pack
-#define DESCRIPTION A 1x4 custom macropad
 
 /* key matrix size */
 #define MATRIX_ROWS 1
@@ -205,9 +204,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
  * MIDI options
  */
 
-/* Prevent use of disabled MIDI features in the keymap */
-//#define MIDI_ENABLE_STRICT 1
-
 /* enable basic MIDI features:
    - MIDI notes can be sent when in Music mode is on
 */

keyboards/40percentclub/4x4/config.h

@@ -10,7 +10,6 @@
 #define DEVICE_VER      0x4444
 #define MANUFACTURER    di0ib
 #define PRODUCT         The 4x4 Keyboard
-#define DESCRIPTION     A modular compact keyboard
 
 /* key matrix size */
 #define MATRIX_ROWS 4
@@ -146,9 +145,6 @@
  * MIDI options
  */
 
-/* Prevent use of disabled MIDI features in the keymap */
-//#define MIDI_ENABLE_STRICT 1
-
 /* enable basic MIDI features:
    - MIDI notes can be sent when in Music mode is on
 */

keyboards/40percentclub/5x5/config.h

@@ -10,7 +10,6 @@
 #define DEVICE_VER      0x05B5
 #define MANUFACTURER    di0ib
 #define PRODUCT         The 5x5 Keyboard
-#define DESCRIPTION     A 25 or 50 or 75 key keyboard
 
 /* key matrix size */
 #define MATRIX_ROWS 5
@@ -155,9 +154,6 @@
  * MIDI options
  */
 
-/* Prevent use of disabled MIDI features in the keymap */
-//#define MIDI_ENABLE_STRICT 1
-
 /* enable basic MIDI features:
    - MIDI notes can be sent when in Music mode is on
 */

keyboards/40percentclub/6lit/config.h

@@ -24,7 +24,6 @@
 #define DEVICE_VER      0x0F61
 #define MANUFACTURER    di0ib
 #define PRODUCT         The 6lit Macropad
-#define DESCRIPTION     A split 12 key Macropad
 
 #define USE_SERIAL
 
@@ -180,9 +179,6 @@
  * MIDI options
  */
 
-/* Prevent use of disabled MIDI features in the keymap */
-//#define MIDI_ENABLE_STRICT 1
-
 /* enable basic MIDI features:
    - MIDI notes can be sent when in Music mode is on
 */

keyboards/40percentclub/foobar/config.h

@@ -24,7 +24,6 @@
 #define DEVICE_VER      0x0F00
 #define MANUFACTURER    di0ib
 #define PRODUCT         The foobar Keyboard
-#define DESCRIPTION     A split 30 key keyboard
 
 #define USE_SERIAL
 
@@ -180,9 +179,6 @@
  * MIDI options
  */
 
-/* Prevent use of disabled MIDI features in the keymap */
-//#define MIDI_ENABLE_STRICT 1
-
 /* enable basic MIDI features:
    - MIDI notes can be sent when in Music mode is on
 */

keyboards/40percentclub/gherkin/config.h

@@ -8,7 +8,6 @@
 #define DEVICE_VER      0x0001
 #define MANUFACTURER    40 Percent Club
 #define PRODUCT         Gherkin
-#define DESCRIPTION     A 30 key ortholinear keyboard
 
 /* key matrix size */
 #define MATRIX_ROWS 5

keyboards/40percentclub/gherkin/keymaps/mjt/config.h

@@ -2,6 +2,4 @@
 
 /* USB Device descriptor parameter */
 #undef MANUFACTURER
-#undef DESCRIPTION
 #define MANUFACTURER    Some Guy
-#define DESCRIPTION     30 percent disaster

keyboards/40percentclub/half_n_half/config.h

@@ -25,7 +25,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define DEVICE_VER      0x4A1F
 #define MANUFACTURER    di0ib
 #define PRODUCT         half_n_half
-#define DESCRIPTION     A small split ortholinear custom keyboard with 2 thumb buttons
 
 /* key matrix size */
 #define MATRIX_ROWS 4*2
@@ -193,9 +192,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
  * MIDI options
  */
 
-/* Prevent use of disabled MIDI features in the keymap */
-//#define MIDI_ENABLE_STRICT 1
-
 /* enable basic MIDI features:
    - MIDI notes can be sent when in Music mode is on
 */

keyboards/40percentclub/i75/config.h

@@ -24,7 +24,6 @@
 #define DEVICE_VER      0x0175
 #define MANUFACTURER    di0ib
 #define PRODUCT         i75
-#define DESCRIPTION     i75 15x5 ortholinear keyboard
 
 /* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
 #define DEBOUNCE 5
@@ -135,9 +134,6 @@
  * MIDI options
  */
 
-/* Prevent use of disabled MIDI features in the keymap */
-//#define MIDI_ENABLE_STRICT 1
-
 /* enable basic MIDI features:
    - MIDI notes can be sent when in Music mode is on
 */

keyboards/40percentclub/luddite/config.h

@@ -8,7 +8,6 @@
 #define DEVICE_VER      0x1001
 #define MANUFACTURER    di0ib
 #define PRODUCT         Luddite
-#define DESCRIPTION     Luddite Keyboard
 
 /* key matrix size */
 #define MATRIX_ROWS 8

keyboards/40percentclub/mf68/config.h

@@ -25,7 +25,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define DEVICE_VER      0x0101
 #define MANUFACTURER    di0ib
 #define PRODUCT         MF68
-#define DESCRIPTION     Magicforce 68 with programmable PCB replacement
 
 /* key matrix size */
 #define MATRIX_ROWS 8

keyboards/40percentclub/mf68/keymaps/68keys/config.h

@@ -6,10 +6,8 @@
 #undef DEVICE_VER
 #undef MANUFACTURER
 #undef PRODUCT
-#undef DESCRIPTION
 #define VENDOR_ID 0xFEED
 #define PRODUCT_ID 0x0A0C
 #define DEVICE_VER 0x0068
 #define MANUFACTURER 68Keys.io
 #define PRODUCT The 68Keys.io Keyboard
-#define DESCRIPTION A 68 keys mechanical keyboard

keyboards/40percentclub/mf68/keymaps/mf68_ble/config.h

@@ -21,10 +21,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 /* Overrides for Feather 32u4 Bluefruit */
 
-/* USB Device descriptor parameter */
-#undef DESCRIPTION
-#define DESCRIPTION     Magicforce 68 BLE
-
 /*
  * Keyboard Matrix Assignments
  *

keyboards/40percentclub/nano/config.h

@@ -25,7 +25,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define DEVICE_VER      0x0001
 #define MANUFACTURER    di0ib
 #define PRODUCT         Nano
-#define DESCRIPTION     8 key microswitch board
 
 /* key matrix size */
 #define MATRIX_ROWS 2

keyboards/40percentclub/nein/config.h

@@ -24,7 +24,6 @@
 #define DEVICE_VER      0x9999
 #define MANUFACTURER    di0ib
 #define PRODUCT         The nein Keyboard
-#define DESCRIPTION     9 key macropad
 
 /* key matrix size */
 #define MATRIX_ROWS 3
@@ -189,9 +188,6 @@
  * MIDI options
  */
 
-/* Prevent use of disabled MIDI features in the keymap */
-//#define MIDI_ENABLE_STRICT 1
-
 /* enable basic MIDI features:
    - MIDI notes can be sent when in Music mode is on
 */

keyboards/40percentclub/nori/config.h

@@ -24,7 +24,6 @@
 #define DEVICE_VER      0x0444
 #define MANUFACTURER    di0ib
 #define PRODUCT         The nori Keyboard
-#define DESCRIPTION     A modular compact keyboard
 
 /* key matrix size */
 #define MATRIX_ROWS 4
@@ -168,9 +167,6 @@
  * MIDI options
  */
 
-/* Prevent use of disabled MIDI features in the keymap */
-//#define MIDI_ENABLE_STRICT 1
-
 /* enable basic MIDI features:
    - MIDI notes can be sent when in Music mode is on
 */

keyboards/40percentclub/tomato/config.h

@@ -8,7 +8,6 @@
 #define DEVICE_VER      0x0001
 #define MANUFACTURER    40 Percent Club
 #define PRODUCT         Tomato
-#define DESCRIPTION     A 30 key ortholinear keyboard with RGB backlighting
 
 /* key matrix size */
 #define MATRIX_ROWS 5

keyboards/40percentclub/ut47/config.h

@@ -25,7 +25,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define DEVICE_VER      0x0001
 #define MANUFACTURER    40percent.club
 #define PRODUCT         ut47
-#define DESCRIPTION     An awesome 40% keyboard
 
 /* key matrix size */
 #define MATRIX_ROWS 4

keyboards/4by3/config.h

@@ -8,7 +8,6 @@
 #define DEVICE_VER		0x0001
 #define MANUFACTURER    Elias Sjögreen
 #define PRODUCT         4by3
-#define DESCRIPTION     A small 12 key keypad
 
 /* key matrix size */
 #define MATRIX_ROWS 3

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

@@ -8,7 +8,6 @@
 #define DEVICE_VER      0x0001
 #define MANUFACTURER    4pplet
 #define PRODUCT         AEKISO60 Rev A
-#define DESCRIPTION     A steezy KEEB
 
 /* key matrix size */
 #define MATRIX_ROWS 5

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

@@ -8,7 +8,6 @@
 #define DEVICE_VER      0x0001
 #define MANUFACTURER    4pplet
 #define PRODUCT         Steezy60 Rev A
-#define DESCRIPTION     A steezy keeb
 
 /* key matrix size */
 #define MATRIX_ROWS 5

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

@@ -8,7 +8,6 @@
 #define DEVICE_VER      0x0001
 #define MANUFACTURER    4pplet
 #define PRODUCT         waffling60 Rev A
-#define DESCRIPTION     A steezy keeb
 
 /* key matrix size */
 #define MATRIX_ROWS 6

keyboards/6ball/config.h

@@ -26,7 +26,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define DEVICE_VER      0x0001
 #define MANUFACTURER    That-Canadian
 #define PRODUCT         6-Ball
-#define DESCRIPTION     6-Ball Macropuck
 
 /* key matrix size */
 #define MATRIX_ROWS 1

keyboards/7skb/rev1/config.h

@@ -24,7 +24,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define DEVICE_VER      0x0007
 #define MANUFACTURER    Salicylic_Acid
 #define PRODUCT         7skb
-#define DESCRIPTION     A custom keyboard
 
 /* key matrix size */
 #define MATRIX_ROWS 10

keyboards/9key/config.h

@@ -26,7 +26,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define DEVICE_VER 		0x0001
 #define MANUFACTURER    Bishop Keyboards
 #define PRODUCT         9Key
-#define DESCRIPTION     Bishop Keyboards 9Key // Charleston, SC Meetup Handout
 
 /* key matrix size */
 #define MATRIX_ROWS 3

keyboards/abacus/config.h

@@ -25,7 +25,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define DEVICE_VER 0x0001
 #define MANUFACTURER nickolaij
 #define PRODUCT abacus
-#define DESCRIPTION A first attempt at a custom keyboard
 
 /* key matrix size */
 #define MATRIX_ROWS 4
@@ -112,9 +111,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
  * MIDI options
  */
 
-/* Prevent use of disabled MIDI features in the keymap */
-//#define MIDI_ENABLE_STRICT 1
-
 /* enable basic MIDI features:
    - MIDI notes can be sent when in Music mode is on
 */

keyboards/absinthe/config.h

@@ -25,7 +25,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define DEVICE_VER 0x0001
 #define MANUFACTURER cfbender
 #define PRODUCT absinthe
-#define DESCRIPTION An F-row-less TKL
 
 /* key matrix size */
 #define MATRIX_ROWS 9

keyboards/abstract/ellipse/rev1/config.h

@@ -25,7 +25,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define DEVICE_VER      0x0001
 #define MANUFACTURER    AbstractKB
 #define PRODUCT         EllipseRev1
-#define DESCRIPTION     The Ellipse Macropad
 
 /* key matrix size */
 #define MATRIX_ROWS 2
@@ -183,9 +182,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
  * MIDI options
  */
 
-/* Prevent use of disabled MIDI features in the keymap */
-//#define MIDI_ENABLE_STRICT 1
-
 /* enable basic MIDI features:
    - MIDI notes can be sent when in Music mode is on
 */

keyboards/acheron/austin/config.h

@@ -23,7 +23,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define DEVICE_VER      0x0001
 #define MANUFACTURER    DriftMechanics
 #define PRODUCT         Austin
-#define DESCRIPTION     Austin Keyboard
 
 /* key matrix size */
 #define MATRIX_ROWS 6

keyboards/acheron/elongate/config.h

@@ -25,7 +25,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define DEVICE_VER 0x0001
 #define MANUFACTURER Acheron Project
 #define PRODUCT Elongate
-#define DESCRIPTION Acheron Project Elongate
 
 /* key matrix size */
 #define MATRIX_ROWS 5
@@ -198,9 +197,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
  * MIDI options
  */
 
-/* Prevent use of disabled MIDI features in the keymap */
-//#define MIDI_ENABLE_STRICT 1
-
 /* enable basic MIDI features:
    - MIDI notes can be sent when in Music mode is on
 */

keyboards/acheron/keebspcb/config.h

@@ -23,7 +23,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define DEVICE_VER      0x0001 // Revision pre-Alpha
 #define MANUFACTURER    AcheronProject
 #define PRODUCT         KeebsPCB
-#define DESCRIPTION     AcheronProject KeebsPCB
 
 /* key matrix size */
 #define MATRIX_ROWS 5

keyboards/acheron/lasgweloth/info.json

@@ -0,0 +1,149 @@
+{
+    "keyboard_name": "Lasgweloth",
+    "url": "",
+    "maintainer": "Gondolindrim",
+    "width": 15,
+    "height": 5,
+    "layouts": {
+        "LAYOUT_60_ansi": {
+            "layout": [
+                {"x":0, "y":0},
+                {"x":1, "y":0},
+                {"x":2, "y":0},
+                {"x":3, "y":0},
+                {"x":4, "y":0},
+                {"x":5, "y":0},
+                {"x":6, "y":0},
+                {"x":7, "y":0},
+                {"x":8, "y":0},
+                {"x":9, "y":0},
+                {"x":10, "y":0},
+                {"x":11, "y":0},
+                {"x":12, "y":0},
+                {"x":13, "y":0, "w":2},
+
+                {"x":0, "y":1, "w":1.5},
+                {"x":1.5, "y":1},
+                {"x":2.5, "y":1},
+                {"x":3.5, "y":1},
+                {"x":4.5, "y":1},
+                {"x":5.5, "y":1},
+                {"x":6.5, "y":1},
+                {"x":7.5, "y":1},
+                {"x":8.5, "y":1},
+                {"x":9.5, "y":1},
+                {"x":10.5, "y":1},
+                {"x":11.5, "y":1},
+                {"x":12.5, "y":1},
+                {"x":13.5, "y":1, "w":1.5},
+
+                {"x":0, "y":2, "w":1.75},
+                {"x":1.75, "y":2},
+                {"x":2.75, "y":2},
+                {"x":3.75, "y":2},
+                {"x":4.75, "y":2},
+                {"x":5.75, "y":2},
+                {"x":6.75, "y":2},
+                {"x":7.75, "y":2},
+                {"x":8.75, "y":2},
+                {"x":9.75, "y":2},
+                {"x":10.75, "y":2},
+                {"x":11.75, "y":2},
+                {"x":12.75, "y":2, "w":2.25},
+
+                {"x":0, "y":3, "w":2.25},
+                {"x":2.25, "y":3},
+                {"x":3.25, "y":3},
+                {"x":4.25, "y":3},
+                {"x":5.25, "y":3},
+                {"x":6.25, "y":3},
+                {"x":7.25, "y":3},
+                {"x":8.25, "y":3},
+                {"x":9.25, "y":3},
+                {"x":10.25, "y":3},
+                {"x":11.25, "y":3},
+                {"x":12.25, "y":3, "w":2.75},
+
+                {"x":0, "y":4, "w":1.25},
+                {"x":1.25, "y":4, "w":1.25},
+                {"x":2.5, "y":4, "w":1.25},
+                {"x":3.75, "y":4, "w":6.25},
+                {"x":10, "y":4, "w":1.25},
+                {"x":11.25, "y":4, "w":1.25},
+                {"x":12.5, "y":4, "w":1.25},
+                {"x":13.75, "y":4, "w":1.25}
+            ]
+        },
+        "LAYOUT_60_ansi_split_bs_rshift": {
+            "layout": [
+                {"x":0, "y":0},
+                {"x":1, "y":0},
+                {"x":2, "y":0},
+                {"x":3, "y":0},
+                {"x":4, "y":0},
+                {"x":5, "y":0},
+                {"x":6, "y":0},
+                {"x":7, "y":0},
+                {"x":8, "y":0},
+                {"x":9, "y":0},
+                {"x":10, "y":0},
+                {"x":11, "y":0},
+                {"x":12, "y":0},
+                {"x":13, "y":0},
+                {"x":14, "y":0},
+
+                {"x":0, "y":1, "w":1.5},
+                {"x":1.5, "y":1},
+                {"x":2.5, "y":1},
+                {"x":3.5, "y":1},
+                {"x":4.5, "y":1},
+                {"x":5.5, "y":1},
+                {"x":6.5, "y":1},
+                {"x":7.5, "y":1},
+                {"x":8.5, "y":1},
+                {"x":9.5, "y":1},
+                {"x":10.5, "y":1},
+                {"x":11.5, "y":1},
+                {"x":12.5, "y":1},
+                {"x":13.5, "y":1, "w":1.5},
+
+                {"x":0, "y":2, "w":1.75},
+                {"x":1.75, "y":2},
+                {"x":2.75, "y":2},
+                {"x":3.75, "y":2},
+                {"x":4.75, "y":2},
+                {"x":5.75, "y":2},
+                {"x":6.75, "y":2},
+                {"x":7.75, "y":2},
+                {"x":8.75, "y":2},
+                {"x":9.75, "y":2},
+                {"x":10.75, "y":2},
+                {"x":11.75, "y":2},
+                {"x":12.75, "y":2, "w":2.25},
+
+                {"x":0, "y":3, "w":2.25},
+                {"x":2.25, "y":3},
+                {"x":3.25, "y":3},
+                {"x":4.25, "y":3},
+                {"x":5.25, "y":3},
+                {"x":6.25, "y":3},
+                {"x":7.25, "y":3},
+                {"x":8.25, "y":3},
+                {"x":9.25, "y":3},
+                {"x":10.25, "y":3},
+                {"x":11.25, "y":3},
+                {"x":12.25, "y":3, "w":1.75},
+                {"x":14, "y":3},
+
+                {"x":0, "y":4, "w":1.25},
+                {"x":1.25, "y":4, "w":1.25},
+                {"x":2.5, "y":4, "w":1.25},
+                {"x":3.75, "y":4, "w":6.25},
+                {"x":10, "y":4, "w":1.25},
+                {"x":11.25, "y":4, "w":1.25},
+                {"x":12.5, "y":4, "w":1.25},
+                {"x":13.75, "y":4, "w":1.25}
+            ]
+        }
+    }
+}

keyboards/acheron/lasgweloth/keymaps/default/keymap.c

@@ -18,18 +18,18 @@ 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] = {
-   [0] = LAYOUT(
-   	KC_GESC, 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_BSPC,
-        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_BSLS, 
-        KC_CAPS, KC_A   , KC_S   , KC_D   , KC_F   , KC_G   , KC_H   , KC_J   , KC_K   , KC_L   , KC_SCLN, KC_QUOT, KC_ENT , KC_DEL,
-        KC_LSFT, 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_RALT, KC_RGUI, MO(1)  , KC_RCTL
- ),
-   [1] = LAYOUT(
-	_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
-	_______, _______, KC_UP  , _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
-	_______, KC_LEFT, KC_DOWN, KC_RGHT, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
-	_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
-	_______, _______, _______,                            _______,          _______, _______, _______, _______ 
-)
+    [0] = LAYOUT_60_ansi_split_bs_rshift(
+        KC_GESC, 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_BSPC, KC_DEL,
+        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_BSLS,
+        KC_CAPS, KC_A   , KC_S   , KC_D   , KC_F   , KC_G   , KC_H   , KC_J   , KC_K   , KC_L   , KC_SCLN, KC_QUOT,          KC_ENT ,
+        KC_LSFT,          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_RALT, KC_RGUI, MO(1)  , KC_RCTL
+    ),
+    [1] = LAYOUT_60_ansi_split_bs_rshift(
+        _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+        _______, _______, KC_UP  , _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+        _______, KC_LEFT, KC_DOWN, KC_RGHT, _______, _______, _______, _______, _______, _______, _______, _______,          _______,
+        _______,          _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+        _______, _______, _______,                            _______,                            _______, _______, _______, _______
+    )
 };

keyboards/acheron/lasgweloth/keymaps/xoxotus/keymap.c

@@ -18,18 +18,18 @@ 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] = {
-   [0] = LAYOUT(
-   	KC_GESC, 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_BSPC,
-        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_TILD, 
-        KC_LCTL, KC_A   , KC_S   , KC_D   , KC_F   , KC_G   , KC_H   , KC_J   , KC_K   , KC_L   , KC_SCLN, KC_QUOT, KC_ENT , KC_DEL,
-        KC_LSFT, 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_RALT, KC_RGUI, MO(1)  , KC_RCTL
- ),
-   [1] = LAYOUT(
-	_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
-	_______, _______, KC_UP  , _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
-	_______, KC_LEFT, KC_DOWN, KC_RGHT, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
-	_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
-	_______, _______, _______,                            _______,          _______, _______, _______, _______ 
-)
+    [0] = LAYOUT_60_ansi_split_bs_rshift(
+        KC_GESC, 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_BSPC, KC_DEL,
+        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_TILD,
+        KC_LCTL, KC_A   , KC_S   , KC_D   , KC_F   , KC_G   , KC_H   , KC_J   , KC_K   , KC_L   , KC_SCLN, KC_QUOT,          KC_ENT ,
+        KC_LSFT,          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_RALT, KC_RGUI, MO(1)  , KC_RCTL
+    ),
+    [1] = LAYOUT_60_ansi_split_bs_rshift(
+        _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+        _______, _______, KC_UP  , _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+        _______, KC_LEFT, KC_DOWN, KC_RGHT, _______, _______, _______, _______, _______, _______, _______, _______,          _______,
+        _______,          _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+        _______, _______, _______,                            _______,                            _______, _______, _______, _______
+    )
 };

keyboards/acheron/lasgweloth/lasgweloth.h

@@ -21,16 +21,33 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #include "quantum.h"
 
-#define LAYOUT( \
-	K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, K0D, \
-	K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, K1D, \
-	K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, K2C, K2D, \
-	K30, K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3C,      \
-	K40, K41, K42,                K46,      K48, K49, K4A, K4B           \
+// equivalent to LAYOUT_all
+#define LAYOUT_60_ansi_split_bs_rshift( \
+    K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, K0D, K2D, \
+    K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, K1D,      \
+    K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B,      K2C,      \
+    K30,      K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3C,      \
+    K40, K41, K42,                K46,                K48, K49, K4A, K4B       \
 ) { \
-	{ K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, K0D }, \
-	{ K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, K1D }, \
-	{ K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, K2C, K2D }, \
-	{ K30, K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3C, ___ }, \
-	{ K40, K41, K42, ___, ___, ___, K46, ___, K48, K49, K4A, K4B, ___, ___ }  \
+    { K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, K0D }, \
+    { K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, K1D }, \
+    { K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, K2C, K2D }, \
+    { K30, K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3C, ___ }, \
+    { K40, K41, K42, ___, ___, ___, K46, ___, K48, K49, K4A, K4B, ___, ___ }  \
 }
+
+#define LAYOUT_60_ansi( \
+    K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, K0D, \
+    K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, K1D, \
+    K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B,      K2C, \
+    K30,      K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A,      K3B, \
+    K40, K41, K42,                K46,                K48, K49, K4A, K4B  \
+) { \
+    { K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, K0D }, \
+    { K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, K1D }, \
+    { K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, K2C, ___ }, \
+    { K30, K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, ___, ___ }, \
+    { K40, K41, K42, ___, ___, ___, K46, ___, K48, K49, K4A, K4B, ___, ___ }  \
+}
+
+#define LAYOUT LAYOUT_60_ansi_split_bs_rshift

keyboards/acheron/lasgweloth/rules.mk

@@ -21,3 +21,5 @@ ENCODER_ENABLE = no
 
 # Enter lower-power sleep mode when on the ChibiOS idle thread
 OPT_DEFS += -DCORTEX_ENABLE_WFI_IDLE=TRUE
+
+LAYOUTS = 60_ansi 60_ansi_split_bs_rshift

keyboards/acheron/shark/config.h

@@ -25,7 +25,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define DEVICE_VER      0x0001
 #define MANUFACTURER    AcheronProject
 #define PRODUCT         SharkPCB
-#define DESCRIPTION     Ortho 40 PCB
 
 /* key matrix size */
 #define MATRIX_ROWS 4
@@ -209,9 +208,6 @@ B0, which is unconnected on the PCB
  * MIDI options
  */
 
-/* Prevent use of disabled MIDI features in the keymap */
-//#define MIDI_ENABLE_STRICT 1
-
 /* enable basic MIDI features:
    - MIDI notes can be sent when in Music mode is on
 */

keyboards/acr60/config.h

@@ -9,7 +9,6 @@
 #define DEVICE_VER      0x0001
 #define MANUFACTURER    MECHKEYS
 #define PRODUCT         ACR60
-#define DESCRIPTION     60% customizable keyboard
 
 /* key matrix size */
 #define MATRIX_ROWS 5

keyboards/adelheid/config.h

@@ -25,7 +25,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define DEVICE_VER      0x0002
 #define MANUFACTURER    floookay
 #define PRODUCT         adelheid
-#define DESCRIPTION     75% alice-like keyboard based on the arisu
 
 /* key matrix size */
 #define MATRIX_ROWS 7
@@ -188,9 +187,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
  * MIDI options
  */
 
-/* Prevent use of disabled MIDI features in the keymap */
-//#define MIDI_ENABLE_STRICT 1
-
 /* enable basic MIDI features:
    - MIDI notes can be sent when in Music mode is on
 */

keyboards/adkb96/rev1/config.h

@@ -22,7 +22,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define DEVICE_VER      0x0001
 #define MANUFACTURER    Bit Trade One
 #define PRODUCT         ADKB96
-#define DESCRIPTION
 
 /* key matrix size */
 // Rows are doubled-up

keyboards/aeboards/aegis/config.h

@@ -24,7 +24,6 @@
 #define DEVICE_VER      0x0001
 #define MANUFACTURER    AEboards
 #define PRODUCT         AEboards Aegis
-#define DESCRIPTION     AEboards Aegis
 
 /* key matrix size */
 #define MATRIX_ROWS 12

keyboards/aeboards/ext65/rev2/config.h

@@ -60,7 +60,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define I2C1_SCL_PAL_MODE 1
 #define I2C1_SDA_PAL_MODE 1
 
-#define I2C1_TIMINGR_PRESC 	0U
 #define I2C1_TIMINGR_SCLDEL 3U
 #define I2C1_TIMINGR_SDADEL 1U
 #define I2C1_TIMINGR_SCLH 	3U

keyboards/afternoonlabs/breeze/breeze.c

@@ -0,0 +1,17 @@
+/* Copyright 2021 eithanshavit
+ *
+ * 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 "breeze.h"