Make the CLI Ψ capital (#6637)

This will manually wipe the EEPROM. This is a hacky solution for when new ranges are added or moved around. 

A better (more complicated) solution would be to zero out everything, not just known ranges.  But for now, this is a hacky solution that will work.

CODE_OF_CONDUCT.md

@@ -8,8 +8,17 @@ Our users, contributors, and collaborators are expected to treat each other with
 
 * The use of sexualized language or imagery
 * Unwelcome advances, sexual or otherwise
+* Deliberate intimidation, stalking, or following
 * Insults or derogatory comments, or personal or political attacks
 * Publishing others’ private information without explicit permission
+* Sustained disruption of talks or other events
 * Other conduct which could reasonably be considered inappropriate in a professional setting
+* Advocating for, or encouraging, any of the above behaviour
 
-If someone is violating this Code of Conduct you may email hello@qmk.fm to bring your concern to the Members. All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. 
+# Reporting
+
+If someone is violating this Code of Conduct, please email hello@qmk.fm or reach out to one of the Collaborators to bring it to our attention. All complaints will be reviewed and investigated.
+
+QMK will seek to use the least punitive means available to resolve an issue. If the circumstances require asking an offender to leave, we will do that.
+
+Reports will be taken and kept in strict confidence. You will not be required to confront an offender directly.

Makefile

@@ -20,7 +20,10 @@ endif
 override SILENT := false
 
 ifndef SUB_IS_SILENT
-QMK_VERSION := $(shell git describe --abbrev=0 --tags 2>/dev/null)
+ifndef SKIP_GIT
+    QMK_VERSION := $(shell git describe --abbrev=0 --tags 2>/dev/null)
+endif
+
 ifneq ($(QMK_VERSION),)
 $(info QMK Firmware $(QMK_VERSION))
 endif
@@ -94,6 +97,7 @@ $(eval $(call NEXT_PATH_ELEMENT))
 # endif
 
 define GET_KEYBOARDS
+ifndef ALT_GET_KEYBOARDS
     All_RULES_MK := $$(patsubst $(ROOT_DIR)/keyboards/%/rules.mk,%,$$(wildcard $(ROOT_DIR)/keyboards/*/rules.mk))
     All_RULES_MK += $$(patsubst $(ROOT_DIR)/keyboards/%/rules.mk,%,$$(wildcard $(ROOT_DIR)/keyboards/*/*/rules.mk))
     All_RULES_MK += $$(patsubst $(ROOT_DIR)/keyboards/%/rules.mk,%,$$(wildcard $(ROOT_DIR)/keyboards/*/*/*/rules.mk))
@@ -105,6 +109,9 @@ define GET_KEYBOARDS
     KEYMAPS_MK += $$(patsubst $(ROOT_DIR)/keyboards/%/rules.mk,%,$$(wildcard $(ROOT_DIR)/keyboards/*/*/*/*/keymaps/*/rules.mk))
 
     KEYBOARDS := $$(sort $$(filter-out $$(KEYMAPS_MK), $$(All_RULES_MK)))
+else
+    KEYBOARDS := $(shell find keyboards/ -type f -iname "rules.mk" | grep -v keymaps | sed 's!keyboards/\(.*\)/rules.mk!\1!' | sort | uniq)
+endif
 endef
 
 $(eval $(call GET_KEYBOARDS))

Vagrantfile

@@ -52,26 +52,37 @@ Vagrant.configure(2) do |config|
   end
 
   # Docker provider pulls from hub.docker.com respecting docker.image if
-  # config.vm.box is nil. Note that this bind-mounts from the current dir to
+  # config.vm.box is nil. In this case, we adhoc build util/vagrant/Dockerfile.
+  # Note that this bind-mounts from the current dir to
   # /vagrant in the guest, so unless your UID is 1000 to match vagrant in the
   # image, you'll need to: chmod -R a+rw .
   config.vm.provider "docker" do |docker, override|
     override.vm.box = nil
-    docker.image = "jesselang/debian-vagrant:stretch"
+    docker.build_dir = "util/vagrant"
     docker.has_ssh = true
   end
 
-  # This script ensures the required packages for AVR programming are installed
-  # It also ensures the system always gets the latest updates when powered on
-  # If this causes issues you can run a 'vagrant destroy' and then
-  # add a # before ,run: (or change "always" to "once") and run 'vagrant up' to get a working
-  # non-updated box and then attempt to troubleshoot or open a Github issue
-  config.vm.provision "shell", inline: "/vagrant/util/qmk_install.sh", run: "always"
+  # Unless we are running the docker container directly
+  #   1. run container detached on vm
+  #   2. attach on 'vagrant ssh'
+  ["virtualbox", "vmware_workstation", "vmware_fusion"].each do |type|
+    config.vm.provider type do |virt, override|
+      override.vm.provision "docker" do |d|
+        d.run "qmkfm/base_container",
+          cmd: "tail -f /dev/null",
+          args: "--privileged -v /dev:/dev -v '/vagrant:/vagrant'"
+      end
+
+      override.vm.provision "shell", inline: <<-SHELL
+        echo 'docker restart qmkfm-base_container && exec docker exec -it qmkfm-base_container /bin/bash -l' >> ~vagrant/.bashrc
+      SHELL
+    end
+  end
 
   config.vm.post_up_message = <<-EOT
 
-  Log into the VM using 'vagrant ssh'. QMK directory synchronized with host is
-  located at /vagrant
+  Log into the environment using 'vagrant ssh'. QMK directory synchronized with
+  host is located at /vagrant
   To compile the .hex files use make command inside this directory, e.g.
      cd /vagrant
      make <keyboard>:default

bin/qmk

@@ -38,7 +38,7 @@ with open('requirements.txt', 'r') as fd:
 
 # Figure out our version
 command = ['git', 'describe', '--abbrev=6', '--dirty', '--always', '--tags']
-result = subprocess.run(command, text=True, capture_output=True)
+result = subprocess.run(command, universal_newlines=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 
 if result.returncode == 0:
     os.environ['QMK_VERSION'] = 'QMK ' + result.stdout.strip()
@@ -47,7 +47,7 @@ else:
 
 # Setup the CLI
 import milc
-milc.EMOJI_LOGLEVELS['INFO'] = '{fg_blue}ψ{style_reset_all}'
+milc.EMOJI_LOGLEVELS['INFO'] = '{fg_blue}Ψ{style_reset_all}'
 
 # If we were invoked as `qmk <cmd>` massage sys.argv into `qmk-<cmd>`.
 # This means we can't accept arguments to the qmk script itself.

docs/_summary.md

@@ -18,6 +18,7 @@
   * [Build/Compile QMK](faq_build.md)
   * [Debugging/Troubleshooting QMK](faq_debug.md)
   * [Keymap](faq_keymap.md)
+  * [Driver Installation with Zadig](driver_installation_zadig.md)
 
 * Detailed Guides
   * [Install Build Tools](getting_started_build_tools.md)
@@ -77,6 +78,7 @@
   * [RGB Lighting](feature_rgblight.md)
   * [RGB Matrix](feature_rgb_matrix.md)
   * [Space Cadet](feature_space_cadet.md)
+  * [Split Keyboard](feature_split_keyboard.md)
   * [Stenography](feature_stenography.md)
   * [Swap Hands](feature_swap_hands.md)
   * [Tap Dance](feature_tap_dance.md)

docs/cli.md

@@ -6,7 +6,8 @@ This page describes how to setup and use the QMK CLI.
 
 The QMK CLI makes building and working with QMK keyboards easier. We have provided a number of commands to help you work with QMK:
 
-* `qmk compile-json`
+* `qmk compile`
+* `qmk doctor`
 
 # Setup
 
@@ -20,12 +21,18 @@ You may want to add this to your `.profile`, `.bash_profile`, `.zsh_profile`, or
 
 # Commands
 
-## `qmk compile-json`
+## `qmk compile`
 
-This command allows you to compile JSON files you have downloaded from <https://config.qmk.fm>.
+This command allows you to compile firmware from any directory. You can compile JSON exports from <https://config.qmk.fm> or compile keymaps in the repo.
 
-**Usage**:
+**Usage for Configurator Exports**:
 
 ```
-qmk compile-json mine.json
+qmk compile <configuratorExport.json>
+```
+
+**Usage for Keymaps**:
+
+```
+qmk compile -kb <keyboard_name> -km <keymap_name>
 ```

docs/config_options.md

@@ -76,7 +76,7 @@ This is a C header file that is one of the first things included, and will persi
 * `#define B7_AUDIO`
   * enables audio on pin B7 (duophony is enables if one of B[5-7]\_AUDIO is enabled along with one of C[4-6]\_AUDIO)
 * `#define BACKLIGHT_PIN B7`
-  * pin of the backlight - `B5`, `B6`, `B7` and `C6` (and `D4` on ATmega32A) use hardware PWM, others use software implementation
+  * pin of the backlight
 * `#define BACKLIGHT_LEVELS 3`
   * number of levels your backlight will have (maximum 15 excluding off)
 * `#define BACKLIGHT_BREATHING`
@@ -89,7 +89,7 @@ This is a C header file that is one of the first things included, and will persi
   * mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap
 * `#define LOCKING_RESYNC_ENABLE`
   * tries to keep switch state consistent with keyboard LED state
-* `#define IS_COMMAND() (get_mods() == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)))`
+* `#define IS_COMMAND() (get_mods() == MOD_MASK_SHIFT)`
   * key combination that allows the use of magic commands (useful for debugging)
 * `#define USB_MAX_POWER_CONSUMPTION`
   * sets the maximum power (in mA) over USB for the device (default: 500)
@@ -171,8 +171,8 @@ If you define these options you will enable the associated feature, which may in
   * how long for the Combo keys to be detected. Defaults to `TAPPING_TERM` if not defined.
 * `#define TAP_CODE_DELAY 100`
   * Sets the delay between `register_code` and `unregister_code`, if you're having issues with it registering properly (common on VUSB boards). The value is in milliseconds.
-* `#define TAP_HOLD_CAPS_DELAY 200`
-  * Sets the delay for Tap Hold keys (`LT`, `MT`) when using `KC_CAPSLOCK` keycode, as this has some special handling on MacOS.  The value is in milliseconds, and defaults to 200ms if not defined. 
+* `#define TAP_HOLD_CAPS_DELAY 80`
+  * Sets the delay for Tap Hold keys (`LT`, `MT`) when using `KC_CAPSLOCK` keycode, as this has some special handling on MacOS.  The value is in milliseconds, and defaults to 80 ms if not defined. For macOS, you may want to set this to 200 or higher.
 
 ## RGB Light Configuration
 
@@ -248,6 +248,9 @@ There are a few different ways to set handedness for split keyboards (listed in
 * `#define MATRIX_COL_PINS_RIGHT { <col pins> }`
   * If you want to specify a different pinout for the right half than the left half, you can define `MATRIX_ROW_PINS_RIGHT`/`MATRIX_COL_PINS_RIGHT`. Currently, the size of `MATRIX_ROW_PINS` must be the same as `MATRIX_ROW_PINS_RIGHT` and likewise for the definition of columns.
 
+* `#define DIRECT_PINS_RIGHT { { F1, F0, B0, C7 }, { F4, F5, F6, F7 } }`
+  * If you want to specify a different direct pinout for the right half than the left half, you can define `DIRECT_PINS_RIGHT`. Currently, the size of `DIRECT_PINS` must be the same as `DIRECT_PINS_RIGHT`.
+
 * `#define RGBLED_SPLIT { 6, 6 }`
   * See [RGB Light Configuration](#rgb-light-configuration)
 

docs/custom_quantum_functions.md

@@ -297,8 +297,8 @@ This runs code every time that the layers get changed.  This can be useful for l
 This example shows how to set the [RGB Underglow](feature_rgblight.md) lights based on the layer, using the Planck as an example
 
 ```c
-uint32_t layer_state_set_user(uint32_t state) {
-    switch (biton32(state)) {
+layer_state_t layer_state_set_user(layer_state_t state) {
+    switch (get_highest_layer(state)) {
     case _RAISE:
         rgblight_setrgb (0x00,  0x00, 0xFF);
         break;
@@ -320,8 +320,8 @@ uint32_t layer_state_set_user(uint32_t state) {
 ```
 ### `layer_state_set_*` Function Documentation
 
-* Keyboard/Revision: `uint32_t layer_state_set_kb(uint32_t state)`
-* Keymap: `uint32_t layer_state_set_user(uint32_t state)`
+* Keyboard/Revision: `layer_state_t layer_state_set_kb(layer_state_t state)`
+* Keymap: `layer_state_t layer_state_set_user(layer_state_t state)`
 
 
 The `state` is the bitmask of the active layers, as explained in the [Keymap Overview](keymap.md#keymap-layer-status)
@@ -377,8 +377,8 @@ void keyboard_post_init_user(void) {
 The above function will use the EEPROM config immediately after reading it, to set the default layer's RGB color. The "raw" value of it is converted in a usable structure based on the "union" that you created above. 
 
 ```c
-uint32_t layer_state_set_user(uint32_t state) {
-    switch (biton32(state)) {
+layer_state_t layer_state_set_user(layer_state_t state) {
+    switch (get_highest_layer(state)) {
     case _RAISE:
         if (user_config.rgb_layer_change) { rgblight_sethsv_noeeprom_magenta(); rgblight_mode_noeeprom(1); }
         break;

docs/driver_installation_zadig.md

@@ -0,0 +1,42 @@
+# Bootloader Driver Installation with Zadig
+
+QMK presents itself to the host as a regular HID keyboard device, and as such requires no special drivers. However, in order to flash your keyboard on Windows, the bootloader device that appears when you reset the board often *does*.
+
+There are two notable exceptions: the Caterina bootloader, usually seen on Pro Micros, and the Halfkay bootloader shipped with PJRC Teensys, appear as a serial port and a generic HID device respectively, and so do not require a driver.
+
+We recommend the use of the [Zadig](https://zadig.akeo.ie/) utility. If you have set up the development environment with Msys2 or WSL, the `qmk_install.sh` script will have asked if you want it to install the drivers for you.
+
+## Installation
+
+Place your keyboard into the bootloader mode, either by hitting the `RESET` keycode (which may be on a different layer), or by pressing the reset switch usually located on the underside of the board. If your keyboard has neither, try holding Escape, or Space+`B`, as you plug it in (see the [Bootmagic](feature_bootmagic.md) docs for more details).
+Some keyboards may have specific instructions for entering the bootloader, for example the [Bootmagic Lite](feature_bootmagic.md#bootmagic-lite) key (Escape) might be on a different key, such as Left Control. Refer to the board's README if you are unsure.
+
+Zadig will automatically detect the bootloader device. You may sometimes need to check **Options -> List All Devices**.
+ - For keyboards with Atmel AVR MCUs, the bootloader will be named something similar to `ATm32U4DFU`, and have a Vendor ID of `03EB`.
+ - USBasp bootloaders will appear as `USBasp`, with a VID/PID of `16C0:05DC`.
+ - AVR keyboards flashed with the QMK-DFU bootloader will be named `<keyboard name> Bootloader` and will also have the VID `03EB`.
+ - For most ARM keyboards, it will be called `STM32 BOOTLOADER`, and have a VID/PID of `0483:DF11`.
+
+!> If Zadig lists one or more devices with the `HidUsb` driver, your keyboard is probably not in bootloader mode. The arrow will be colored orange and you will be asked to confirm modifying a system driver. **Do not** proceed if this is the case!
+
+If the arrow appears green, select the driver, and click **Install Driver**. The `libusb-win32` driver will usually work for AVR, and `WinUSB` for ARM, but if you still cannot flash the board, try installing a different driver from the list.
+
+![Zadig with a bootloader driver correctly installed](https://i.imgur.com/b8VgXzx.png)
+
+Finally, unplug and replug the keyboard to make sure the new driver has been loaded. If you are using the QMK Toolbox to flash, exit and restart it too, as it can sometimes fail to recognize the driver change.
+
+## Recovering from Installation to Wrong Device
+
+If you find that you can no longer type with the keyboard, you may have installed the driver onto the keyboard itself instead of the bootloader. You can easily confirm this in Zadig - a healthy keyboard has the `HidUsb` driver installed on all of its interfaces:
+
+![A healthy keyboard as seen by Zadig](https://i.imgur.com/Hx0E5kC.png)
+
+Open the Device Manager and look for a device that looks like your keyboard.
+
+![The board with the wrong driver installed, in Device Manager](https://i.imgur.com/L3wvX8f.png)
+
+Right-click it and hit **Uninstall device**. Make sure to tick **Delete the driver software for this device** first.
+
+![The Device Uninstall dialog, with the "delete driver" checkbox ticked](https://i.imgur.com/aEs2RuA.png)
+
+Click **Action -> Scan for hardware changes**. At this point, you should be able to type again. Double check in Zadig that the keyboard device(s) are using the `HidUsb` driver. If so, you're all done, and your board should be functional again!

docs/faq_build.md

@@ -19,7 +19,11 @@ Note that running `make` with `sudo` is generally ***not*** a good idea, and you
 
 ### Linux `udev` Rules
 On Linux, you'll need proper privileges to access the MCU. You can either use
-`sudo` when flashing firmware, or place these files in `/etc/udev/rules.d/`.
+`sudo` when flashing firmware, or place these files in `/etc/udev/rules.d/`. Once added run the following:
+```console
+sudo udevadm control --reload-rules
+sudo udevadm trigger
+```
 
 **/etc/udev/rules.d/50-atmel-dfu.rules:**
 ```
@@ -43,22 +47,39 @@ SUBSYSTEMS=="usb", ATTRS{idVendor}=="feed", MODE:="0666"
 SUBSYSTEMS=="usb", ATTRS{idVendor}=="1c11", MODE:="0666"
 ```
 
+**/etc/udev/rules.d/55-catalina.rules:**
+```
+# ModemManager should ignore the following devices
+ATTRS{idVendor}=="2a03", ENV{ID_MM_DEVICE_IGNORE}="1"
+ATTRS{idVendor}=="2341", ENV{ID_MM_DEVICE_IGNORE}="1"
+```
+
+**Note:** ModemManager filtering only works when not in strict mode, the following commands can update that settings:
+```console
+sudo sed -i 's/--filter-policy=strict/--filter-policy=default/' /lib/systemd/system/ModemManager.service
+sudo systemctl daemon-reload
+sudo systemctl restart ModemManager
+```
+
+**/etc/udev/rules.d/56-dfu-util.rules:**
+```
+# stm32duino
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="1eaf", ATTRS{idProduct}=="0003", MODE:="0666"
+# Generic stm32
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="0483", ATTRS{idProduct}=="df11", MODE:="0666"
+```
+
 ### Serial device is not detected in bootloader mode on Linux
 Make sure your kernel has appropriate support for your device. If your device uses USB ACM, such as
 Pro Micro (Atmega32u4), make sure to include `CONFIG_USB_ACM=y`. Other devices may require `USB_SERIAL` and any of its sub options.
 
 ## Unknown Device for DFU Bootloader
 
-If you're using Windows to flash your keyboard, and you are running into issues, check the Device Manager.  If you see an "Unknown Device" when the keyboard is in "bootloader mode", then you may have a driver issue.
+Issues encountered when flashing keyboards on Windows are most often due to having the wrong drivers installed for the bootloader, or none at all.
 
-Re-running the installation script for MSYS2 may help (eg run `./util/qmk_install.sh` from MSYS2/WSL) or reinstalling the QMK Toolbox may fix the issue.
-
-If that doesn't work, then you may need to grab the [Zadig Utility](https://zadig.akeo.ie/). Download this, find the device in question, and select the `WinUSB` option, and hit "Reinstall driver". Once you've done that, try flashing your board, again.  If that doesn't work, try all of the options, until one works. 
-
-?> There isn't a best option for which driver should be used here.  Some options work better on some systems than others.  libUSB and WinUSB seem to be the best options here.
-
-If the bootloader doesn't show up in the list for devices, you may need to enable the "List all devices" option in the `Options` menu, and then find the bootloader in question. 
+Re-running the QMK installation script (`./util/qmk_install.sh` from the `qmk_firmware` directory in MSYS2 or WSL) or reinstalling the QMK Toolbox may fix the issue. Alternatively, you can download and run the [`qmk_driver_installer`](https://github.com/qmk/qmk_driver_installer) package manually.
 
+If that doesn't work, then you may need to download and run Zadig. See [Bootloader Driver Installation with Zadig](driver_installation_zadig.md) for more detailed information.
 
 ## WINAVR is Obsolete
 It is no longer recommended and may cause some problem.

docs/faq_debug.md

@@ -184,22 +184,15 @@ Pressing any key during sleep should wake host.
 
 Arduino Leonardo and micro have **ATMega32U4** and can be used for TMK, though Arduino bootloader may be a problem.
 
+## Enabling JTAG
 
-## Using PF4-7 Pins of USB AVR?
-You need to set JTD bit of MCUCR yourself to use PF4-7 as GPIO. Those pins are configured to serve JTAG function by default. MCUs like ATMega*U* or AT90USB* are affected with this.
+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 are using Teensy this isn't needed. Teensy is shipped with JTAGEN fuse bit unprogrammed to disable the function.
+If you would like to keep JTAG enabled, just add the following to your `config.h`:
 
-See this code.
+```c
+#define NO_JTAG_DISABLE
 ```
-    // JTAG disable for PORT F. write JTD bit twice within four cycles.
-    MCUCR |= (1<<JTD);
-    MCUCR |= (1<<JTD);
-```
-https://github.com/tmk/tmk_keyboard/blob/master/keyboard/hbkb/matrix.c#L67
-
-And read **26.5.1 MCU Control Register – MCUCR** of ATMega32U4 datasheet.
-
 
 ## Adding LED Indicators of Lock Keys
 You need your own LED indicators for CapsLock, ScrollLock and NumLock? See this post.

docs/feature_audio.md

@@ -21,6 +21,8 @@ STARTUP_SONG // plays when the keyboard starts up (audio.c)
 GOODBYE_SONG // plays when you press the RESET key (quantum.c)
 AG_NORM_SONG // plays when you press AG_NORM (quantum.c)
 AG_SWAP_SONG // plays when you press AG_SWAP (quantum.c)
+CG_NORM_SONG // plays when you press CG_NORM (quantum.c)
+CG_SWAP_SONG // plays when you press CG_SWAP (quantum.c)
 MUSIC_ON_SONG // plays when music mode is activated (process_music.c)
 MUSIC_OFF_SONG // plays when music mode is deactivated (process_music.c)
 CHROMATIC_SONG // plays when the chromatic music mode is selected (process_music.c)

docs/feature_backlight.md

@@ -30,32 +30,31 @@ You should then be able to use the keycodes below to change the backlight level.
 
 This feature is distinct from both the [RGB underglow](feature_rgblight.md) and [RGB matrix](feature_rgb_matrix.md) features as it usually allows for only a single colour per switch, though you can obviously use multiple different coloured LEDs on a keyboard.
 
-Hardware PWM is only supported on certain pins of the MCU, so if the backlighting is not connected to one of them, a software PWM implementation triggered by hardware timer interrupts will be used.
-
 Hardware PWM is supported according to the following table:
 
-| Backlight Pin | Hardware timer          |
-|---------------|-------------------------|
-|`B5`           | Timer 1                 |
-|`B6`           | Timer 1                 |
-|`B7`           | Timer 1                 |
-|`C6`           | Timer 3                 |
-|`D4`           | Timer 1 (ATmega32A only)|
-| other         | Software PWM            |
+|Backlight Pin|AT90USB64/128|ATmega16/32U4|ATmega16/32U2|ATmega32A|
+|-------------|-------------|-------------|-------------|---------|
+|`B5`         |Timer 1      |Timer 1      |             |         |
+|`B6`         |Timer 1      |Timer 1      |             |         |
+|`B7`         |Timer 1      |Timer 1      |Timer 1      |         |
+|`C4`         |Timer 3      |             |             |         |
+|`C5`         |Timer 3      |             |Timer 1      |         |
+|`C6`         |Timer 3      |Timer 3      |Timer 1      |         |
+|`D4`         |             |             |             |Timer 1  |
+|`D5`         |             |             |             |Timer 1  |
 
-The [audio feature](feature_audio.md) also uses hardware timers. Please refer to the following table to know what hardware timer the software PWM will use depending on the audio configuration:
+All other pins will use software PWM. If the [Audio](feature_audio.md) feature is disabled or only using one timer, the backlight PWM can be triggered by a hardware timer:
 
-| Audio Pin(s) | Audio Timer | Software PWM Timer |
-|--------------|-------------|--------------------|
-| `C4`         | Timer 3     | Timer 1            |
-| `C5`         | Timer 3     | Timer 1            |
-| `C6`         | Timer 3     | Timer 1            |
-| `B5`         | Timer 1     | Timer 3            |
-| `B6`         | Timer 1     | Timer 3            |
-| `B7`         | Timer 1     | Timer 3            |
-| `Bx` & `Cx`  | Timer 1 & 3 | None               |
+|Audio Pin|Audio Timer|Software PWM Timer|
+|---------|-----------|------------------|
+|`C4`     |Timer 3    |Timer 1           |
+|`C5`     |Timer 3    |Timer 1           |
+|`C6`     |Timer 3    |Timer 1           |
+|`B5`     |Timer 1    |Timer 3           |
+|`B6`     |Timer 1    |Timer 3           |
+|`B7`     |Timer 1    |Timer 3           |
 
-When all timers are in use for [audio](feature_audio.md), the backlight software PWM will not use a hardware timer, but instead will be triggered during the matrix scan. In this case the backlight doesn't support breathing and might show lighting artifacts (for instance flickering), because the PWM computation might not be called with enough timing precision.
+When both timers are in use for Audio, the backlight PWM will not use a hardware timer, but will instead be triggered during the matrix scan. In this case, breathing is not supported, and the backlight might flicker, because the PWM computation may not be called with enough timing precision.
 
 ## Configuration
 
@@ -65,7 +64,7 @@ To change the behaviour of the backlighting, `#define` these in your `config.h`:
 |---------------------|-------------|-------------------------------------------------------------------------------------------------------------|
 |`BACKLIGHT_PIN`      |`B7`         |The pin that controls the LEDs. Unless you are designing your own keyboard, you shouldn't need to change this|
 |`BACKLIGHT_PINS`     |*Not defined*|experimental: see below for more information                                                                 |
-|`BACKLIGHT_LEVELS`   |`3`          |The number of brightness levels (maximum 15 excluding off)                                                   |
+|`BACKLIGHT_LEVELS`   |`3`          |The number of brightness levels (maximum 31 excluding off)                                                   |
 |`BACKLIGHT_CAPS_LOCK`|*Not defined*|Enable Caps Lock indicator using backlight (for keyboards without dedicated LED)                             |
 |`BACKLIGHT_BREATHING`|*Not defined*|Enable backlight breathing, if supported                                                                     |
 |`BREATHING_PERIOD`   |`6`          |The length of one backlight "breath" in seconds                                                              |
@@ -73,8 +72,10 @@ To change the behaviour of the backlighting, `#define` these in your `config.h`:
 
 ## Backlight On State
 
-Most backlight circuits are driven by an N-channel MOSFET or NPN transistor. This means that to turn the transistor *on* and light the LEDs, you must drive the backlight pin, connected to the gate or base, *low*.
-Sometimes, however, a P-channel MOSFET, or a PNP transistor is used. In this case you must `#define BACKLIGHT_ON_STATE 1`, so that when the transistor is on, the pin is driven *high* instead.
+Most backlight circuits are driven by an N-channel MOSFET or NPN transistor. This means that to turn the transistor *on* and light the LEDs, you must drive the backlight pin, connected to the gate or base, *high*.
+Sometimes, however, a P-channel MOSFET, or a PNP transistor is used. In this case, when the transistor is on, the pin is driven *low* instead.
+
+This functionality is configured at the keyboard level with the `BACKLIGHT_ON_STATE` define.
 
 ## Multiple backlight pins
 

docs/feature_bootmagic.md

@@ -64,8 +64,11 @@ Hold down the Bootmagic key (Space by default) and the desired hotkey while plug
 |`MAGIC_NO_GUI`                    |         |Disable the GUI keys (useful when gaming) |
 |`MAGIC_UNNO_GUI`                  |         |Enable the GUI keys                       |
 |`MAGIC_SWAP_ALT_GUI`              |`AG_SWAP`|Swap Alt and GUI on both sides (for macOS)|
-|`MAGIC_UNSWAP_ALT_GUI`            |`AG_NORM`|Unswap Left Alt and Left GUI              |
-|`MAGIC_TOGGLE_ALT_GUI`            |`AG_TOGG`|Toggle Left Alt and GUI swap              |
+|`MAGIC_UNSWAP_ALT_GUI`            |`AG_NORM`|Unswap Alt and GUI                        |
+|`MAGIC_TOGGLE_ALT_GUI`            |`AG_TOGG`|Toggle Alt and GUI swap                   |
+|`MAGIC_SWAP_CTL_GUI`              |`CG_SWAP`|Swap Ctrl and GUI on both sides (for macOS)|
+|`MAGIC_UNSWAP_CTL_GUI`            |`CG_NORM`|Unswap Ctrl and GUI                       |
+|`MAGIC_TOGGLE_CTL_GUI`            |`CG_TOGG`|Toggle Ctrl and GUI swap                  |
 |`MAGIC_SWAP_BACKSLASH_BACKSPACE`  |         |Swap `\` and Backspace                    |
 |`MAGIC_UNSWAP_BACKSLASH_BACKSPACE`|         |Unswap `\` and Backspace                  |
 |`MAGIC_SWAP_CONTROL_CAPSLOCK`     |         |Swap Left Control and Caps Lock           |
@@ -76,6 +79,10 @@ Hold down the Bootmagic key (Space by default) and the desired hotkey while plug
 |`MAGIC_UNSWAP_LALT_LGUI`          |         |Unswap Left Alt and Left GUI              |
 |`MAGIC_SWAP_RALT_RGUI`            |         |Swap Right Alt and Right GUI              |
 |`MAGIC_UNSWAP_RALT_RGUI`          |         |Unswap Right Alt and Right GUI            |
+|`MAGIC_SWAP_LCTL_LGUI`            |         |Swap Left Control and Left GUI            |
+|`MAGIC_UNSWAP_LCTL_LGUI`          |         |Unswap Left Control and Left GUI          |
+|`MAGIC_SWAP_RCTL_RGUI`            |         |Swap Right Control and Right GUI          |
+|`MAGIC_UNSWAP_RCTL_RGUI`          |         |Unswap Right Control and Right GUI        |
 
 ## Configuration
 

docs/feature_combo.md

@@ -2,7 +2,7 @@
 
 The Combo feature is a chording type solution for adding custom actions.  It lets you hit multiple keys at once and produce a different effect.  For instance, hitting `A` and `S` within the tapping term would hit `ESC` instead, or have it perform even more complex tasks.
 
-To enable this feature, yu need to add `COMBO_ENABLE = yes` to your `rules.mk`.
+To enable this feature, you need to add `COMBO_ENABLE = yes` to your `rules.mk`.
 
 Additionally, in your `config.h`, you'll need to specify the number of combos that you'll be using, by adding `#define COMBO_COUNT 1` (replacing 1 with the number that you're using).
 <!-- At this time, this is necessary -->
@@ -59,19 +59,12 @@ void process_combo_event(uint8_t combo_index, bool pressed) {
   switch(combo_index) {
     case ZC_COPY:
       if (pressed) {
-        register_code(KC_LCTL);
-        register_code(KC_C);
-        unregister_code(KC_C);
-        unregister_code(KC_LCTL);
+        tap_code16(LCTL(KC_C));
       }
       break;
-
     case XV_PASTE:
       if (pressed) {
-        register_code(KC_LCTL);
-        register_code(KC_V);
-        unregister_code(KC_V);
-        unregister_code(KC_LCTL);
+        tap_code16(LCTL(KC_V));
       }
       break;
   }
@@ -87,3 +80,24 @@ If you're using long combos, or even longer combos, you may run into issues with
 In this case, you can add either `#define EXTRA_LONG_COMBOS` or `#define EXTRA_EXTRA_LONG_COMBOS` in your `config.h` file.
 
 You may also be able to enable action keys by defining `COMBO_ALLOW_ACTION_KEYS`.
+
+## Keycodes 
+
+You can enable, disable and toggle the Combo feature on the fly.  This is useful if you need to disable them temporarily, such as for a game. 
+
+|Keycode   |Description                      |
+|----------|---------------------------------|
+|`CMB_ON`  |Turns on Combo feature           |
+|`CMB_OFF` |Turns off Combo feature          |
+|`CMB_TOG` |Toggles Combo feature on and off |
+
+## User callbacks
+
+In addition to the keycodes, there are a few functions that you can use to set the status, or check it:
+
+|Function   |Description                                                         |
+|-----------|--------------------------------------------------------------------|
+| `combo_enable()`     | Enables the combo feature                               |
+| `combo_disable()`    | Disables the combo feature, and clears the combo buffer |
+| `combo_toggle()`     | Toggles the state of the combo feature                  |
+| `is_combo_enabled()` | Returns the status of the combo feature state (true or false) |

docs/feature_command.md

@@ -16,36 +16,36 @@ To use Command, hold down the key combination defined by the `IS_COMMAND()` macr
 
 If you would like to change the key assignments for Command, `#define` these in your `config.h` at either the keyboard or keymap level. All keycode assignments here must omit the `KC_` prefix.
 
-|Define                              |Default                                                                    |Description                                     |
-|------------------------------------|---------------------------------------------------------------------------|------------------------------------------------|
-|`IS_COMMAND()`                      |<code>(get_mods() == (MOD_BIT(KC_LSHIFT) &#124; MOD_BIT(KC_RSHIFT)))</code>|The key combination to activate Command         |
-|`MAGIC_KEY_SWITCH_LAYER_WITH_FKEYS` |`true`                                                                     |Set default layer with the Function row         |
-|`MAGIC_KEY_SWITCH_LAYER_WITH_NKEYS` |`true`                                                                     |Set default layer with the number keys          |
-|`MAGIC_KEY_SWITCH_LAYER_WITH_CUSTOM`|`false`                                                                    |Set default layer with `MAGIC_KEY_LAYER0..9`    |
-|`MAGIC_KEY_DEBUG`                   |`D`                                                                        |Toggle debugging over serial                    |
-|`MAGIC_KEY_DEBUG_MATRIX`            |`X`                                                                        |Toggle key matrix debugging                     |
-|`MAGIC_KEY_DEBUG_KBD`               |`K`                                                                        |Toggle keyboard debugging                       |
-|`MAGIC_KEY_DEBUG_MOUSE`             |`M`                                                                        |Toggle mouse debugging                          |
-|`MAGIC_KEY_CONSOLE`                 |`C`                                                                        |Enable the Command console                      |
-|`MAGIC_KEY_VERSION`                 |`V`                                                                        |Print the running QMK version to the console    |
-|`MAGIC_KEY_STATUS`                  |`S`                                                                        |Print the current keyboard status to the console|
-|`MAGIC_KEY_HELP`                    |`H`                                                                        |Print Command help to the console               |
-|`MAGIC_KEY_HELP_ALT`                |`SLASH`                                                                    |Print Command help to the console (alternate)   |
-|`MAGIC_KEY_LAYER0`                  |`0`                                                                        |Make layer 0 the default layer                  |
-|`MAGIC_KEY_LAYER0_ALT`              |`GRAVE`                                                                    |Make layer 0 the default layer (alternate)      |
-|`MAGIC_KEY_LAYER1`                  |`1`                                                                        |Make layer 1 the default layer                  |
-|`MAGIC_KEY_LAYER2`                  |`2`                                                                        |Make layer 2 the default layer                  |
-|`MAGIC_KEY_LAYER3`                  |`3`                                                                        |Make layer 3 the default layer                  |
-|`MAGIC_KEY_LAYER4`                  |`4`                                                                        |Make layer 4 the default layer                  |
-|`MAGIC_KEY_LAYER5`                  |`5`                                                                        |Make layer 5 the default layer                  |
-|`MAGIC_KEY_LAYER6`                  |`6`                                                                        |Make layer 6 the default layer                  |
-|`MAGIC_KEY_LAYER7`                  |`7`                                                                        |Make layer 7 the default layer                  |
-|`MAGIC_KEY_LAYER8`                  |`8`                                                                        |Make layer 8 the default layer                  |
-|`MAGIC_KEY_LAYER9`                  |`9`                                                                        |Make layer 9 the default layer                  |
-|`MAGIC_KEY_BOOTLOADER`              |`B`                                                                        |Jump to bootloader                              |
-|`MAGIC_KEY_BOOTLOADER_ALT`          |`ESC`                                                                      |Jump to bootloader (alternate)                  |
-|`MAGIC_KEY_LOCK`                    |`CAPS`                                                                     |Lock the keyboard so nothing can be typed       |
-|`MAGIC_KEY_EEPROM`                  |`E`                                                                        |Print stored EEPROM config to the console       |
-|`MAGIC_KEY_EEPROM_CLEAR`            |`BSPACE`                                                                   |Clear the EEPROM                                |
-|`MAGIC_KEY_NKRO`                    |`N`                                                                        |Toggle N-Key Rollover (NKRO)                    |
-|`MAGIC_KEY_SLEEP_LED`               |`Z`                                                                        |Toggle LED when computer is sleeping            |
+|Define                              |Default                         |Description                                     |
+|------------------------------------|--------------------------------|------------------------------------------------|
+|`IS_COMMAND()`                      |`(get_mods() == MOD_MASK_SHIFT)`|The key combination to activate Command         |
+|`MAGIC_KEY_SWITCH_LAYER_WITH_FKEYS` |`true`                          |Set default layer with the Function row         |
+|`MAGIC_KEY_SWITCH_LAYER_WITH_NKEYS` |`true`                          |Set default layer with the number keys          |
+|`MAGIC_KEY_SWITCH_LAYER_WITH_CUSTOM`|`false`                         |Set default layer with `MAGIC_KEY_LAYER0..9`    |
+|`MAGIC_KEY_DEBUG`                   |`D`                             |Toggle debugging over serial                    |
+|`MAGIC_KEY_DEBUG_MATRIX`            |`X`                             |Toggle key matrix debugging                     |
+|`MAGIC_KEY_DEBUG_KBD`               |`K`                             |Toggle keyboard debugging                       |
+|`MAGIC_KEY_DEBUG_MOUSE`             |`M`                             |Toggle mouse debugging                          |
+|`MAGIC_KEY_CONSOLE`                 |`C`                             |Enable the Command console                      |
+|`MAGIC_KEY_VERSION`                 |`V`                             |Print the running QMK version to the console    |
+|`MAGIC_KEY_STATUS`                  |`S`                             |Print the current keyboard status to the console|
+|`MAGIC_KEY_HELP`                    |`H`                             |Print Command help to the console               |
+|`MAGIC_KEY_HELP_ALT`                |`SLASH`                         |Print Command help to the console (alternate)   |
+|`MAGIC_KEY_LAYER0`                  |`0`                             |Make layer 0 the default layer                  |
+|`MAGIC_KEY_LAYER0_ALT`              |`GRAVE`                         |Make layer 0 the default layer (alternate)      |
+|`MAGIC_KEY_LAYER1`                  |`1`                             |Make layer 1 the default layer                  |
+|`MAGIC_KEY_LAYER2`                  |`2`                             |Make layer 2 the default layer                  |
+|`MAGIC_KEY_LAYER3`                  |`3`                             |Make layer 3 the default layer                  |
+|`MAGIC_KEY_LAYER4`                  |`4`                             |Make layer 4 the default layer                  |
+|`MAGIC_KEY_LAYER5`                  |`5`                             |Make layer 5 the default layer                  |
+|`MAGIC_KEY_LAYER6`                  |`6`                             |Make layer 6 the default layer                  |
+|`MAGIC_KEY_LAYER7`                  |`7`                             |Make layer 7 the default layer                  |
+|`MAGIC_KEY_LAYER8`                  |`8`                             |Make layer 8 the default layer                  |
+|`MAGIC_KEY_LAYER9`                  |`9`                             |Make layer 9 the default layer                  |
+|`MAGIC_KEY_BOOTLOADER`              |`B`                             |Jump to bootloader                              |
+|`MAGIC_KEY_BOOTLOADER_ALT`          |`ESC`                           |Jump to bootloader (alternate)                  |
+|`MAGIC_KEY_LOCK`                    |`CAPS`                          |Lock the keyboard so nothing can be typed       |
+|`MAGIC_KEY_EEPROM`                  |`E`                             |Print stored EEPROM config to the console       |
+|`MAGIC_KEY_EEPROM_CLEAR`            |`BSPACE`                        |Clear the EEPROM                                |
+|`MAGIC_KEY_NKRO`                    |`N`                             |Toggle N-Key Rollover (NKRO)                    |
+|`MAGIC_KEY_SLEEP_LED`               |`Z`                             |Toggle LED when computer is sleeping            |

docs/feature_encoders.md

@@ -6,7 +6,6 @@ Basic encoders are supported by adding this to your `rules.mk`:
 
 and this to your `config.h`:
 
-    #define NUMBER_OF_ENCODERS 1
     #define ENCODERS_PAD_A { B12 }
     #define ENCODERS_PAD_B { B13 }
 
@@ -21,6 +20,15 @@ Additionally, the resolution can be specified in the same file (the default & su
 
     #define ENCODER_RESOLUTION 4
 
+## Split Keyboards
+
+If you are using different pinouts for the encoders on each half of a split keyboard, you can define the pinout for the right half like this:
+
+```c
+#define ENCODERS_PAD_A_RIGHT { encoder1a, encoder2a }
+#define ENCODERS_PAD_B_RIGHT { encoder1b, encoder2b }
+```
+
 ## Callbacks
 
 The callback functions can be inserted into your `<keyboard>.c`:

docs/feature_oled_driver.md

@@ -31,7 +31,7 @@ This enables the feature and the `OLED_DRIVER_ENABLE` define. Then in your `keym
 void oled_task_user(void) {
   // Host Keyboard Layer Status
   oled_write_P(PSTR("Layer: "), false);
-  switch (biton32(layer_state)) {
+  switch (get_highest_layer(layer_state)) {
     case _QWERTY:
       oled_write_P(PSTR("Default\n"), false);
       break;
@@ -96,17 +96,19 @@ void oled_task_user(void) {
 
  ## Basic Configuration
 
-| Define                 | Default           | Description                                                                                                                |
-|------------------------|-------------------|----------------------------------------------------------------------------------------------------------------------------|
-| `OLED_DISPLAY_ADDRESS` | `0x3C`            | The i2c address of the OLED Display                                                                                        |
-| `OLED_FONT_H`          | `"glcdfont.c"`    | The font code file to use for custom fonts                                                                                 |
-| `OLED_FONT_START`      | `0`               | The starting characer index for custom fonts                                                                               |
-| `OLED_FONT_END`        | `224`             | The ending characer index for custom fonts                                                                                 |
-| `OLED_FONT_WIDTH`      | `6`               | The font width                                                                                                             |
-| `OLED_FONT_HEIGHT`     | `8`               | The font height (untested)                                                                                                 |
-| `OLED_DISABLE_TIMEOUT` | *Not defined*     | Disables the built in OLED timeout feature. Useful when implementing custom timeout rules.                                 |
-| `OLED_IC`              | `OLED_IC_SSD1306` | Set to `OLED_IC_SH1106` if you're using the SH1106 OLED controller.                                                        |
-| `OLED_COLUMN_OFFSET`   | `0`               | (SH1106 only.) Shift output to the right this many pixels.<br />Useful for 128x64 displays centered on a 132x64 SH1106 IC. |
+| Define                     | Default           | Description                                                                                                                |
+|----------------------------|-------------------|----------------------------------------------------------------------------------------------------------------------------|
+| `OLED_DISPLAY_ADDRESS`     | `0x3C`            | The i2c address of the OLED Display                                                                                        |
+| `OLED_FONT_H`              | `"glcdfont.c"`    | The font code file to use for custom fonts                                                                                 |
+| `OLED_FONT_START`          | `0`               | The starting characer index for custom fonts                                                                               |
+| `OLED_FONT_END`            | `224`             | The ending characer index for custom fonts                                                                                 |
+| `OLED_FONT_WIDTH`          | `6`               | The font width                                                                                                             |
+| `OLED_FONT_HEIGHT`         | `8`               | The font height (untested)                                                                                                 |
+| `OLED_TIMEOUT`             | `60000`           | Turns off the OLED screen after 60000ms of keyboard inactivity. Helps reduce OLED Burn-in. Set to 0 to disable.            |
+| `OLED_SCROLL_TIMEOUT`      | `0`               | Scrolls the OLED screen after 0ms of OLED inactivity. Helps reduce OLED Burn-in. Set to 0 to disable.                      |
+| `OLED_SCROLL_TIMEOUT_RIGHT`| *Not defined*     | Scroll timeout direction is right when defined, left when undefined.                                                       |
+| `OLED_IC`                  | `OLED_IC_SSD1306` | Set to `OLED_IC_SH1106` if you're using the SH1106 OLED controller.                                                        |
+| `OLED_COLUMN_OFFSET`       | `0`               | (SH1106 only.) Shift output to the right this many pixels.<br />Useful for 128x64 displays centered on a 132x64 SH1106 IC. |
 
  ## 128x64 & Custom sized OLED Displays
 

docs/feature_rgb_matrix.md

@@ -374,6 +374,7 @@ These are defined in [`rgblight_list.h`](https://github.com/qmk/qmk_firmware/blo
 #define RGB_MATRIX_LED_PROCESS_LIMIT (DRIVER_LED_TOTAL + 4) / 5 // limits the number of LEDs to process in an animation per task run (increases keyboard responsiveness)
 #define RGB_MATRIX_LED_FLUSH_LIMIT 16 // limits in milliseconds how frequently an animation will update the LEDs. 16 (16ms) is equivalent to limiting to 60fps (increases keyboard responsiveness)
 #define RGB_MATRIX_MAXIMUM_BRIGHTNESS 200 // limits maximum brightness of LEDs to 200 out of 255. If not defined maximum brightness is set to 255
+#define RGB_MATRIX_STARTUP_MODE RGB_MATRIX_CYCLE_LEFT_RIGHT // Sets the default mode, if none has been set
 ```
 
 ## EEPROM storage

docs/feature_split_keyboard.md

@@ -0,0 +1,197 @@
+# Split Keyboard 
+
+Many keyboards in the QMK Firmware repo are "split" keyboards. They use two controllers—one plugging into USB, and the second connected by a serial or an I<sup>2</sup>C connection over a TRRS or similar cable. 
+
+Split keyboards can have a lot of benefits, but there is some additional work needed to get them enabled.  
+
+QMK Firmware has a generic implementation that is usable by any board, as well as numerous board specific implementations. 
+
+For this, we will mostly be talking about the generic implementation used by the Let's Split and other keyboards. 
+
+!> ARM is not yet supported for Split Keyboards.  Progress is being made, but we are not quite there, yet. 
+
+
+## Hardware Configuration
+
+This assumes that you're using two Pro Micro-compatible controllers, and are using TRRS jacks to connect to two halves. 
+
+### Required Hardware
+
+Apart from diodes and key switches for the keyboard matrix in each half, you will need 2x TRRS sockets and 1x TRRS cable.
+
+Alternatively, you can use any sort of cable and socket that has at least 3 wires. 
+
+If you want to use I<sup>2</sup>C to communicate between halves, you will need a cable with at least 4 wires and 2x 4.7kΩ pull-up resistors.
+
+#### Considerations 
+
+The most commonly used connection is a TRRS cable and jacks.  These provide 4 wires, making them very useful for split keyboards, and are easy to find. 
+
+However, since one of the wires carries VCC, this means that the boards are not hot pluggable. You should always disconnect the board from USB before unplugging and plugging in TRRS cables, or you can short the controller, or worse. 
+
+Another option is to use phone cables (as in, old school RJ-11/RJ-14 cables). Make sure that you use one that actually supports 4 wires/lanes.  
+
+However, USB cables, SATA cables, and even just 4 wires have been known to be used for communication between the controllers. 
+
+!> Using USB cables for communication between the controllers works just fine, but the connector could be mistaken for a normal USB connection and potentially short out the keyboard, depending on how it's wired.  For this reason, they are not recommended for connecting split keyboards.  
+
+### Serial Wiring
+
+The 3 wires of the TRS/TRRS cable need to connect GND, VCC, and D0 (aka PDO or pin 3) between the two Pro Micros. 
+
+?> Note that the pin used here is actually set by `SOFT_SERIAL_PIN` below.
+
+![serial wiring](https://i.imgur.com/C3D1GAQ.png)
+
+### I<sup>2</sup>C Wiring
+
+The 4 wires of the TRRS cable need to connect GND, VCC, and SCL and SDA (aka PD0/pin 3 and PD1/pin 2, respectively) between the two Pro Micros. 
+
+The pull-up resistors may be placed on either half. It is also possible to use 4 resistors and have the pull-ups in both halves, but this is unnecessary in simple use cases.
+
+![I2C wiring](https://i.imgur.com/Hbzhc6E.png)
+
+## Firmware Configuration
+
+To enable the split keyboard feature, add the following to your `rules.mk`: 
+
+```make
+SPLIT_KEYBOARD = yes
+```
+
+If you're using a custom transport (communication method), then you will also need to add: 
+
+```make
+SPLIT_TRANSPORT = custom
+```
+
+### Setting Handedness
+
+By default, the firmware does not know which side is which; it needs some help to determine that. There are several ways to do this, listed in order of precedence.
+
+#### Handedness by Pin
+
+You can configure the firmware to read a pin on the controller to determine handedness.  To do this, add the following to your `config.h` file:
+
+```c
+#define SPLIT_HAND_PIN B7
+```
+
+This will read the specified pin. If it's high, then the controller assumes it is the left hand, and if it's low, it's assumed to be the right side. 
+
+#### Handedness by EEPROM
+
+This method sets the keyboard's handedness by setting a flag in the persistent storage (`EEPROM`).  This is checked when the controller first starts up, and determines what half the keyboard is, and how to orient the keyboard layout. 
+
+
+To enable this method, add the following to your `config.h` file: 
+
+```c
+#define EE_HANDS
+```
+
+However, you'll have to flash the EEPROM files for the correct hand to each controller.  You can do this manually, or there are targets for avrdude and dfu to do this, while flashing the firmware: 
+
+* `:avrdude-split-left`
+* `:avrdude-split-right`
+* `:dfu-split-left`
+* `:dfu-split-right`
+
+This setting is not changed when re-initializing the EEPROM using the `EEP_RST` key, or using the `eeconfig_init()` function.  However, if you reset the EEPROM outside of the firmware's built in options (such as flashing a file that overwrites the `EEPROM`, like how the [QMK Toolbox]()'s "Reset EEPROM" button works), you'll need to re-flash the controller with the `EEPROM` files. 
+
+You can find the `EEPROM` files in the QMK firmware repo, [here](https://github.com/qmk/qmk_firmware/tree/master/quantum/split_common). 
+
+#### Handedness by `#define`
+
+You can set the handedness at compile time.  This is done by adding the following to your `config.h` file:
+
+```c
+#define MASTER_RIGHT
+```
+
+or 
+
+```c
+#define MASTER_LEFT
+```
+
+If neither are defined, the handedness defaults to `MASTER_LEFT`.
+
+
+### Communication Options
+
+Because not every split keyboard is identical, there are a number of additional options that can be configured in your `config.h` file.
+
+```c
+#define USE_I2C
+```
+
+This enables I<sup>2</sup>C support for split keyboards. This isn't strictly for communication, but can be used for OLED or other I<sup>2</sup>C-based devices. 
+
+```c
+#define SOFT_SERIAL_PIN D0
+```
+
+This sets the pin to be used for serial communication. If you're not using serial, you shouldn't need to define this.  
+
+However, if you are using serial and I<sup>2</sup>C on the board, you will need to set this, and to something other than D0 and D1 (as these are used for I<sup>2</sup>C communication).
+
+```c
+#define SELECT_SOFT_SERIAL_SPEED {#}`
+```
+
+If you're having issues with serial communication, you can change this value, as it controls the communication speed for serial.  The default is 1, and the possible values are:
+
+* **`0`**: about 189kbps (Experimental only)
+* **`1`**: about 137kbps (default)
+* **`2`**: about 75kbps
+* **`3`**: about 39kbps
+* **`4`**: about 26kbps
+* **`5`**: about 20kbps
+
+###  Hardware Configuration Options
+
+There are some settings that you may need to configure, based on how the hardware is set up. 
+
+```c
+#define MATRIX_ROW_PINS_RIGHT { <row pins> }
+#define MATRIX_COL_PINS_RIGHT { <col pins> }
+```
+
+This allows you to specify a different set of pins for the matrix on the right side.  This is useful if you have a board with differently-shaped halves that requires a different configuration (such as Keebio's Quefrency).
+
+```c
+#define DIRECT_PINS_RIGHT { { F1, F0, B0, C7 }, { F4, F5, F6, F7 } }
+```
+
+This allows you to specify a different set of direct pins for the right side.
+
+```c
+#define ENCODERS_PAD_A_RIGHT { encoder1a, encoder2a }
+#define ENCODERS_PAD_B_RIGHT { encoder1b, encoder2b }
+```
+
+This allows you to specify a different set of encoder pins for the right side.
+
+```c
+#define RGBLIGHT_SPLIT
+```
+
+This option enables synchronization of the RGB Light modes between the controllers of the split keyboard.  This is for keyboards that have RGB LEDs that are directly wired to the controller (that is, they are not using the "extra data" option on the TRRS cable).
+
+```c
+#define RGBLED_SPLIT { 6, 6 }
+```
+
+This sets how many LEDs are directly connected to each controller.  The first number is the left side, and the second number is the right side.  
+
+?> This setting implies that `RGBLIGHT_SPLIT` is enabled, and will forcibly enable it, if it's not.
+
+
+## Additional Resources
+
+Nicinabox has a [very nice and detailed guide](https://github.com/nicinabox/lets-split-guide) for the Let's Split keyboard, that covers most everything you need to know, including troubleshooting information. 
+
+However, the RGB Light section is out of date, as it was written long before the RGB Split code was added to QMK Firmware. Instead, wire each strip up directly to the controller.
+
+<!-- I may port this information later, but for now ... it's very nice, and covers everything -->

docs/feature_tap_dance.md

@@ -1,22 +1,33 @@
 # Tap Dance: A Single Key Can Do 3, 5, or 100 Different Things
 
-<!-- FIXME: Break this up into multiple sections -->
-
+## Introduction
 Hit the semicolon key once, send a semicolon. Hit it twice, rapidly -- send a colon. Hit it three times, and your keyboard's LEDs do a wild dance. That's just one example of what Tap Dance can do. It's one of the nicest community-contributed features in the firmware, conceived and created by [algernon](https://github.com/algernon) in [#451](https://github.com/qmk/qmk_firmware/pull/451). Here's how algernon describes the feature:
 
 With this feature one can specify keys that behave differently, based on the amount of times they have been tapped, and when interrupted, they get handled before the interrupter.
 
-To make it clear how this is different from `ACTION_FUNCTION_TAP`, let's explore a certain setup! We want one key to send `Space` on single tap, but `Enter` on double-tap.
+## Explanatory Comparison with `ACTION_FUNCTION_TAP`
+`ACTION_FUNCTION_TAP` can offer similar functionality to Tap Dance, but it's worth noting some important differences. To do this, let's explore a certain setup! We want one key to send `Space` on single-tap, but `Enter` on double-tap.
 
-With `ACTION_FUNCTION_TAP`, it is quite a rain-dance to set this up, and has the problem that when the sequence is interrupted, the interrupting key will be sent first. Thus, `SPC a` will result in `a SPC` being sent, if they are typed within `TAPPING_TERM`. With the tap dance feature, that'll come out as `SPC a`, correctly.
+With `ACTION_FUNCTION_TAP`, it is quite a rain-dance to set this up, and has the problem that when the sequence is interrupted, the interrupting key will be sent first. Thus, `SPC a` will result in `a SPC` being sent, if `SPC` and `a` are both typed within `TAPPING_TERM`. With the Tap Dance feature, that'll come out correctly as `SPC a` (even if both `SPC` and `a` are typed within the `TAPPING_TERM`.
 
-The implementation hooks into two parts of the system, to achieve this: into `process_record_quantum()`, and the matrix scan. We need the latter to be able to time out a tap sequence even when a key is not being pressed, so `SPC` alone will time out and register after `TAPPING_TERM` time.
+To achieve this correct handling of interrupts, the implementation of Tap Dance hooks into two parts of the system: `process_record_quantum()`, and the matrix scan. These two parts are explained below, but for now the point to note is that we need the latter to be able to time out a tap sequence even when a key is not being pressed. That way, `SPC` alone will time out and register after `TAPPING_TERM` time.
 
-But lets start with how to use it, first!
+## How to Use Tap Dance
+But enough of the generalities; lets look at how to actually use Tap Dance!
 
-First, you will need `TAP_DANCE_ENABLE=yes` in your `rules.mk`, because the feature is disabled by default. This adds a little less than 1k to the firmware size. Next, you will want to define some tap-dance keys, which is easiest to do with the `TD()` macro, that - similar to `F()`, takes a number, which will later be used as an index into the `tap_dance_actions` array.
+First, you will need `TAP_DANCE_ENABLE=yes` in your `rules.mk`, because the feature is disabled by default. This adds a little less than 1k to the firmware size. 
 
-This array specifies what actions shall be taken when a tap-dance key is in action. Currently, there are five possible options:
+Optionally, you might want to set a custom `TAPPING_TERM` time by adding something like this in you `config.h`:
+
+```
+#define TAPPING_TERM 175
+```
+
+The `TAPPING_TERM` time is the maximum time allowed between taps of your Tap Dance key, and is measured in milliseconds. For example, if you used the above `#define` statement and set up a Tap Dance key that sends `Space` on single-tap and `Enter` on double-tap, then this key will send `ENT` only if you tap this key twice in less than 175ms. If you tap the key, wait more than 175ms, and tap the key again you'll end up sending `SPC SPC` instead. 
+
+Next, you will want to define some tap-dance keys, which is easiest to do with the `TD()` macro, that - similar to `F()` - takes a number, which will later be used as an index into the `tap_dance_actions` array. 
+
+After this, you'll want to use the `tap_dance_actions` array to specify what actions shall be taken when a tap-dance key is in action. Currently, there are five possible options:
 
 * `ACTION_TAP_DANCE_DOUBLE(kc1, kc2)`: Sends the `kc1` keycode when tapped once, `kc2` otherwise. When the key is held, the appropriate keycode is registered: `kc1` when pressed and held, `kc2` when tapped once, then pressed and held.
 * `ACTION_TAP_DANCE_DUAL_ROLE(kc, layer)`: Sends the `kc` keycode when tapped once, or moves to `layer`. (this functions like the `TO` layer keycode).
@@ -24,17 +35,22 @@ This array specifies what actions shall be taken when a tap-dance key is in acti
 * `ACTION_TAP_DANCE_FN_ADVANCED(on_each_tap_fn, on_dance_finished_fn, on_dance_reset_fn)`: Calls the first specified function - defined in the user keymap - on every tap, the second function when the dance action finishes (like the previous option), and the last function when the tap dance action resets.
 * `ACTION_TAP_DANCE_FN_ADVANCED_TIME(on_each_tap_fn, on_dance_finished_fn, on_dance_reset_fn, tap_specific_tapping_term)`: This functions identically to the `ACTION_TAP_DANCE_FN_ADVANCED` function, but uses a custom tapping term for it, instead of the predefined `TAPPING_TERM`.
 
-The first option is enough for a lot of cases, that just want dual roles. For example, `ACTION_TAP_DANCE_DOUBLE(KC_SPC, KC_ENT)` will result in `Space` being sent on single-tap, `Enter` otherwise.
+The first option is enough for a lot of cases, that just want dual roles. For example, `ACTION_TAP_DANCE_DOUBLE(KC_SPC, KC_ENT)` will result in `Space` being sent on single-tap, `Enter` otherwise. 
 
 !> Keep in mind that only [basic keycodes](keycodes_basic.md) are supported here. Custom keycodes are not supported.
 
-And that's the bulk of it!
+Similar to the first option, the second option is good for simple layer-switching cases.
 
-And now, on to the explanation of how it works!
+For more complicated cases, use the third or fourth options (examples of each are listed below). 
 
-The main entry point is `process_tap_dance()`, called from `process_record_quantum()`, which is run for every keypress, and our handler gets to run early. This function checks whether the key pressed is a tap-dance key. If it is not, and a tap-dance was in action, we handle that first, and enqueue the newly pressed key. If it is a tap-dance key, then we check if it is the same as the already active one (if there's one active, that is). If it is not, we fire off the old one first, then register the new one. If it was the same, we increment the counter and the timer.
+Finally, the fifth option is particularly useful if your non-Tap-Dance keys start behaving weirdly after adding the code for your Tap Dance keys. The likely problem is that you changed the `TAPPING_TERM` time to make your Tap Dance keys easier for you to use, and that this has changed the way your other keys handle interrupts.
 
-This means that you have `TAPPING_TERM` time to tap the key again, you do not have to input all the taps within that timeframe. This allows for longer tap counts, with minimal impact on responsiveness.
+## Implementation Details
+Well, that's the bulk of it! You should now be able to work through the examples below, and to develop your own Tap Dance functionality. But if you want a deeper understanding of what's going on behind the scenes, then read on for the explanation of how it all works!
+
+The main entry point is `process_tap_dance()`, called from `process_record_quantum()`, which is run for every keypress, and our handler gets to run early. This function checks whether the key pressed is a tap-dance key. If it is not, and a tap-dance was in action, we handle that first, and enqueue the newly pressed key. If it is a tap-dance key, then we check if it is the same as the already active one (if there's one active, that is). If it is not, we fire off the old one first, then register the new one. If it was the same, we increment the counter and reset the timer.
+
+This means that you have `TAPPING_TERM` time to tap the key again; you do not have to input all the taps within a single `TAPPING_TERM` timeframe. This allows for longer tap counts, with minimal impact on responsiveness.
 
 Our next stop is `matrix_scan_tap_dance()`. This handles the timeout of tap-dance keys.
 
@@ -397,3 +413,111 @@ qk_tap_dance_action_t tap_dance_actions[] = {
 ```
 
 Wrap each tapdance keycode in `TD()` when including it in your keymap, e.g. `TD(ALT_LP)`.
+
+### Example 6: Using tap dance for momentary-layer-switch and layer-toggle keys
+
+Tap Dance can be used to mimic MO(layer) and TG(layer) functionality. For this example, we will set up a key to function as `KC_QUOT` on single-tap, as `MO(_MY_LAYER)` on single-hold, and `TG(_MY_LAYER)` on double-tap.
+
+The first step is to include the following code towards the beginning of your `keymap.c`:
+
+```
+typedef struct {
+  bool is_press_action;
+  int state;
+} tap;
+
+//Define a type for as many tap dance states as you need
+enum {
+  SINGLE_TAP = 1,
+  SINGLE_HOLD = 2,
+  DOUBLE_TAP = 3
+};
+
+enum {
+  QUOT_LAYR = 0     //Our custom tap dance key; add any other tap dance keys to this enum 
+};
+
+//Declare the functions to be used with your tap dance key(s)
+
+//Function associated with all tap dances
+int cur_dance (qk_tap_dance_state_t *state);
+
+//Functions associated with individual tap dances
+void ql_finished (qk_tap_dance_state_t *state, void *user_data);
+void ql_reset (qk_tap_dance_state_t *state, void *user_data);
+
+//Declare variable to track which layer is active
+int active_layer;
+```
+
+The above code is similar to that used in previous examples. The one point to note is that you need to declare a variable to keep track of what layer is currently the active layer. We'll see why shortly.
+
+Towards the bottom of your `keymap.c`, include the following code:
+
+```
+//Update active_layer
+uint32_t layer_state_set_user(uint32_t state) {
+  switch (biton32(state)) {
+    case 1:
+      active_layer = 1;
+      break;
+    case 2:
+      active_layer = 2;
+      break;
+    case 3:
+      active_layer = 3;
+      break;
+    default:
+      active_layer = 0;
+      break;
+  }
+  return state;
+}
+
+//Determine the current tap dance state
+int cur_dance (qk_tap_dance_state_t *state) {
+  if (state->count == 1) {
+    if (!state->pressed) {return SINGLE_TAP;}
+    else return SINGLE_HOLD;
+  } else if (state->count == 2) {return DOUBLE_TAP;}
+  else return 8;
+}
+
+//Initialize tap structure associated with example tap dance key
+static tap ql_tap_state = {
+  .is_press_action = true,
+  .state = 0
+};
+
+//Functions that control what our tap dance key does
+void ql_finished (qk_tap_dance_state_t *state, void *user_data) {
+  ql_tap_state.state = cur_dance(state);
+  switch (ql_tap_state.state) {
+    case SINGLE_TAP: tap_code(KC_QUOT); break;
+    case SINGLE_HOLD: layer_on(_MY_LAYER); break;
+    case DOUBLE_TAP: 
+      if (active_layer==_MY_LAYER) {layer_off(_MY_LAYER);}
+      else layer_on(_MY_LAYER);
+  }
+}
+
+void ql_reset (qk_tap_dance_state_t *state, void *user_data) {
+  if (ql_tap_state.state==SINGLE_HOLD) {layer_off(_MY_LAYER);}
+  ql_tap_state.state = 0;
+}
+
+//Associate our tap dance key with its functionality
+qk_tap_dance_action_t tap_dance_actions[] = {
+  [QUOT_LAYR] = ACTION_TAP_DANCE_FN_ADVANCED_TIME(NULL, ql_finished, ql_reset, 275)
+};
+```
+
+The is where the real logic of our tap dance key gets worked out. Since `layer_state_set_user()` is called on any layer switch, we use it to update `active_layer`. Our example is assuming that your `keymap.c` includes 4 layers, so adjust the switch statement here to fit your actual number of layers.
+
+The use of `cur_dance()` and `ql_tap_state` mirrors the above examples.
+
+The `case:SINGLE_TAP` in `ql_finished` is similar to the above examples. The `case:SINGLE_HOLD` works in conjunction with `ql_reset()` to switch to `_MY_LAYER` while the tap dance key is held, and to switch away from `_MY_LAYER` when the key is released. This mirrors the use of `MO(_MY_LAYER)`. The `case:DOUBLE_TAP` works by checking whether `_MY_LAYER` is the active layer, and toggling it on or off accordingly. This mirrors the use of `TG(_MY_LAYER)`.
+
+`tap_dance_actions[]` works similar to the above examples. Note that I used `ACTION_TAP_DANCE_FN_ADVANCED_TIME()` instead of `ACTION_TAP_DANCE_FN_ADVANCED()`. This is because I like my `TAPPING_TERM` to be short (~175ms) for my non-tap-dance keys but find that this is too quick for me to reliably complete tap dance actions - thus the increased time of 275ms here.
+
+Finally, to get this tap dance key working, be sure to include `TD(QUOT_LAYR)` in your `keymaps[]`.

docs/feature_userspace.md

@@ -115,11 +115,11 @@ For instance, let's look at the `layer_state_set_user()` function.  You can enab
 In your `<name.c>` file, you'd want to add this: 
 ```c
 __attribute__ ((weak))
-uint32_t layer_state_set_keymap (uint32_t state) {
+layer_state_t layer_state_set_keymap (layer_state_t state) {
   return state;
 }
 
-uint32_t layer_state_set_user (uint32_t state) {
+layer_state_t layer_state_set_user (layer_state_t state) {
   state = update_tri_layer_state(state, 2, 3, 5);
   return layer_state_set_keymap (state);
 }

docs/features.md

@@ -30,6 +30,7 @@ QMK has a staggering number of features for building your keyboard. It can take
 * [RGB Light](feature_rgblight.md) - RGB lighting for your keyboard.
 * [RGB Matrix](feature_rgb_matrix.md) - RGB Matrix lights for per key lighting.
 * [Space Cadet](feature_space_cadet.md) - Use your left/right shift keys to type parenthesis and brackets.
+* [Split Keyboard](feature_split_keyboard.md) 
 * [Stenography](feature_stenography.md) - Put your keyboard into Plover mode for stenography use.
 * [Swap Hands](feature_swap_hands.md) - Mirror your keyboard for one handed usage.
 * [Tap Dance](feature_tap_dance.md) - Make a single key do as many things as you want.

docs/flashing.md

@@ -144,6 +144,36 @@ Flashing sequence:
 3. Flash a .hex file
 4. Reset the device into application mode (may be done automatically)
 
+## 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.
+
+To ensure compatibility with the bootloadHID bootloader, make sure this block is present your `rules.mk`:
+
+    # Bootloader
+    #     This definition is optional, and if your keyboard supports multiple bootloaders of
+    #     different sizes, comment this out, and the correct address will be loaded
+    #     automatically (+60). See bootloader.mk for all options.
+    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)
+
+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) 
+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:
+
+    make <keyboard>:<keymap>:bootloadHID
+
 ## STM32
 
 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.
@@ -171,7 +201,5 @@ Flashing sequence:
 
 There are a number of DFU commands that you can use to flash firmware to a STM32 device:
 
-* `:dfu-util` - The default command for flashing to STM32 devices. 
-* `:dfu-util-wait` - This works like the default command, but it gives you a (configurable) 10 second timeout before it attempts to flash the firmware.  You can use `TIME_DELAY=20` from the command line to change the timeout.
-   * Eg: `make <keyboard>:<keymap>:dfu-util TIME_DELAY=5`
-* `:st-link-cli` - This allows you to flash the firmware via ST-LINK's CLI utility, rather than dfu-util. 
+* `:dfu-util` - The default command for flashing to STM32 devices.
+* `:st-link-cli` - This allows you to flash the firmware via ST-LINK's CLI utility, rather than dfu-util.

docs/flashing_bootloadhid.md

@@ -0,0 +1,70 @@
+# BootloadHID Flashing Instructions and Bootloader Information
+
+ps2avr(GB) boards use an ATmega32A microcontroller and a different bootloader. It is not flashable using the regular QMK methods.
+
+General 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) 
+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)
+
+## bootloadHID Flashing Target
+
+Using the QMK installation script, detailed [here](newbs_getting_started.md), the required bootloadHID tools should be automatically installed.
+
+To flash via the command line, use the target `:bootloadHID` by executing the following command:
+
+    make <keyboard>:<keymap>:bootloadHID
+
+## GUI Flashing
+
+### Windows
+1. Download [HIDBootFlash](http://vusb.wikidot.com/project:hidbootflash).
+2. Place your keyboard into reset. 
+3. Ensure the configured VendorID is `16c0` and ProductID is `05df`
+4. Press the `Find Device` button and ensure that your keyboard is found.
+5. Press the `Open .hex File` button and locate the `.hex` file you created.
+6. Press the `Flash Device` button and wait for the process to complete.
+
+## Command Line Flashing
+
+1. Place your keyboard into reset. 
+2. Flash the board by typing `bootloadHID -r` followed by the path to your `.hex` file.
+
+### Windows Manual Installation
+For MSYS2:
+1. Download the BootloadHID firmware package from https://www.obdev.at/downloads/vusb/bootloadHID.2012-12-08.tar.gz.
+2. Extract contents using a compatible tool, for example 7-Zip.
+3. Add to the MSYS path by copying `commandline/bootloadHID.exe` from the extracted archive to your MSYS2 installation, typically `C:\msys64\usr\bin`.
+
+For native Windows flashing, the `bootloadHID.exe` can be used outside of the MSYS2 environment.
+
+### Linux Manual Installation
+1. Install libusb development dependency:
+    ```bash
+    # This depends on OS - for Debian the following works
+    sudo apt-get install libusb-dev
+    ```
+2. Download the BootloadHID firmware package:
+    ```
+    wget https://www.obdev.at/downloads/vusb/bootloadHID.2012-12-08.tar.gz -O - | tar -xz -C /tmp
+    ```
+3. Build the bootloadHID executable:
+    ```
+    cd /tmp/bootloadHID.2012-12-08/commandline/
+    make
+    sudo cp bootloadHID /usr/local/bin
+    ```
+
+### MacOS Manual Installation
+1. Install Homebrew by typing the following:
+    ```
+    /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
+    ```
+2. Install the following packages:
+    ```
+    brew install --HEAD https://raw.githubusercontent.com/robertgzr/homebrew-tap/master/bootloadhid.rb
+    ```

docs/getting_started_make_guide.md

@@ -14,7 +14,7 @@ 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.
-* `dfu`, `teensy`, `avrdude` or `dfu-util`, 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.
+* `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:dfu`.
 * `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.
 
@@ -83,7 +83,7 @@ This allows the keyboard to tell the host OS that up to 248 keys are held down a
 
 `BACKLIGHT_ENABLE`
 
-This enables your backlight on Timer1 and ports B5, B6, or B7 (for now). You can specify your port by putting this in your `config.h`:
+This enables the in-switch LED backlighting. You can specify the backlight pin by putting this in your `config.h`:
 
     #define BACKLIGHT_PIN B7
 

docs/getting_started_vagrant.md

@@ -1,16 +1,20 @@
 # Vagrant Quick Start
 
-This project includes a Vagrantfile that will allow you to build a new firmware for your keyboard very easily without major changes to your primary operating system. This also ensures that when you clone the project and perform a build, you have the exact same environment as anyone else using the Vagrantfile to build. This makes it much easier for people to help you troubleshoot any issues you encounter.
+This project includes a `Vagrantfile` that will allow you to build a new firmware for your keyboard very easily without major changes to your primary operating system. This also ensures that when you clone the project and perform a build, you have the exact same environment as anyone else using the Vagrantfile to build. This makes it much easier for people to help you troubleshoot any issues you encounter.
 
 ## Requirements
 
-Using the `/Vagrantfile` in this repository requires you have [Vagrant](http://www.vagrantup.com/) as well as [VirtualBox](https://www.virtualbox.org/) (or [VMware Workstation](https://www.vmware.com/products/workstation) and [Vagrant VMware plugin](http://www.vagrantup.com/vmware) but the (paid) VMware plugin requires a licensed copy of VMware Workstation/Fusion).
+Using the `Vagrantfile` in this repository requires you have [Vagrant](http://www.vagrantup.com/) as well as a supported provider installed:
 
-*COMPATIBILITY NOTICE* Certain versions of Virtualbox 5 appear to have an incompatibility with the Virtualbox extensions installed in the boxes in this Vagrantfile. If you encounter any issues with the /vagrant mount not succeeding, please upgrade your version of Virtualbox to at least 5.0.12. **Alternately, you can try running the following command:** `vagrant plugin install vagrant-vbguest`
+* [VirtualBox](https://www.virtualbox.org/) (Version at least 5.0.12)
+  * Sold as 'the most accessible platform to use Vagrant'
+* [VMware Workstation](https://www.vmware.com/products/workstation) and [Vagrant VMware plugin](http://www.vagrantup.com/vmware)
+  * The (paid) VMware plugin requires a licensed copy of VMware Workstation/Fusion
+* [Docker](https://www.docker.com/)
 
-Other than having Vagrant and Virtualbox installed and possibly a restart of your computer afterwards, you can simple run a 'vagrant up' anywhere inside the folder where you checked out this project and it will start a Linux virtual machine that contains all the tools required to build this project. There is a post Vagrant startup hint that will get you off on the right foot, otherwise you can also reference the build documentation below.
+Other than having Vagrant, a suitable provider installed and possibly a restart of your computer afterwards, you can simple run a 'vagrant up' anywhere inside the folder where you checked out this project and it will start an environment (either a virtual machine or container) that contains all the tools required to build this project. There is a post Vagrant startup hint that will get you off on the right foot, otherwise you can also reference the build documentation below.
 
-# Flashing the Firmware
+## Flashing the Firmware
 
 The "easy" way to flash the firmware is using a tool from your host OS:
 
@@ -19,3 +23,35 @@ The "easy" way to flash the firmware is using a tool from your host OS:
 * [Atmel FLIP](http://www.atmel.com/tools/flip.aspx)
 
 If you want to program via the command line you can uncomment the ['modifyvm'] lines in the Vagrantfile to enable the USB passthrough into Linux and then program using the command line tools like dfu-util/dfu-programmer or you can install the Teensy CLI version.
+
+## Vagrantfile Overview
+The development environment is configured to run the QMK Docker image, `qmkfm/base_container`. This not only ensures predictability between systems, it also mirrors the CI environment.
+
+## FAQ
+
+### Why am I seeing issues under Virtualbox?
+Certain versions of Virtualbox 5 appear to have an incompatibility with the Virtualbox extensions installed in the boxes in this Vagrantfile. If you encounter any issues with the /vagrant mount not succeeding, please upgrade your version of Virtualbox to at least 5.0.12. **Alternately, you can try running the following command:**
+
+```console
+vagrant plugin install vagrant-vbguest
+```
+
+### How do I remove an existing environment?
+Finished with your environment? From anywhere inside the folder where you checked out this project, Execute:
+
+```console
+vagrant destory
+```
+
+### What if I want to use Docker directly?
+Want to benefit from the Vagrant workflow without a virtual machine? The Vagrantfile is configured to bypass running a virtual machine, and run the container directly. Execute the following when bringing up the environment to force the use of Docker:
+```console
+vagrant up --provider=docker
+```
+
+### How do I access the virtual machine instead of the Docker container?
+Execute the following to bypass the `vagrant` user booting directly to the official qmk builder image:
+
+```console
+vagrant ssh -c 'sudo -i'
+```

docs/hardware_avr.md

@@ -78,7 +78,7 @@ Do change the `MANUFACTURER`, `PRODUCT`, and `DESCRIPTION` lines to accurately r
 #define DESCRIPTION     A custom keyboard
 ```
 
-?> Note: On Windows and macOS the `MANUFACTURER`, `PRODUCT`, and `DESCRIPTION` fields will be displayed in the list of USB devices. ?> On Linux these values will not be visible in lsusb by default, since Linux takes the information from the list maintained by [USB ID Repository](http://www.linux-usb.org/usb-ids.html) by default. lsusb will show the information reported by the device when executed with -v option. It is also present in kernel logs after plugging in the device.
+?> 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.
 
 ### Keyboard Matrix Configuration
 
@@ -125,7 +125,7 @@ To configure a keyboard where each switch is connected to a separate pin and gro
 
 ### Backlight Configuration
 
-By default QMK supports backlighting on pins `B5`, `B6`, and `B7`. If you are using one of those you can simply enable it here. For more details see the [Backlight Documentation](feature_backlight.md).
+QMK supports backlighting on most GPIO pins. A select few of these can be driven by the MCU in hardware. For more details see the [Backlight Documentation](feature_backlight.md).
 
 ```c
 #define BACKLIGHT_PIN B7
@@ -134,8 +134,6 @@ By default QMK supports backlighting on pins `B5`, `B6`, and `B7`. If you are us
 #define BREATHING_PERIOD 6
 ```
 
-?> You can use backlighting on any pin you like, but you will have to do more work to support that. See the [Backlight Documentation](feature_backlight.md) for more details.
-
 ### Other Configuration Options
 
 There are a lot of features that can be configured or tuned in `config.h`. You should see the [Config Options](config_options.md) page for more details.

docs/how_keyboards_work.md

@@ -33,7 +33,11 @@ The firmware does not send actual letters or characters, but only scancodes.
 Thus, by modifying the firmware, you can only modify what scancode is sent over
 USB for a given key.
 
-## 3. What the Operating System Does
+## 3. What the Event Input/Kernel Does
+
+The *scancode* is mapped to a *keycode* dependent on the keyboard [60-keyboard.hwdb at Master](https://github.com/systemd/systemd/blob/master/hwdb/60-keyboard.hwdb). Without this mapping, the operating system will not receive a valid keycode and will be unable to do anything useful with that key press.
+
+## 4. What the Operating System Does
 
 Once the keycode reaches the operating system, a piece of software has to have
 it match an actual character thanks to a keyboard layout. For example, if your

docs/i2c_driver.md

@@ -73,7 +73,22 @@ STM32 MCUs allows a variety of pins to be configured as I2C pins depending on th
 | `I2C1_SDA`               | The pin number for the SDA pin (0-9)                                                         | `7`     |
 | `I2C1_BANK` (deprecated) | The bank of pins (`GPIOA`, `GPIOB`, `GPIOC`), superceded by `I2C1_SCL_BANK`, `I2C1_SDA_BANK` | `GPIOB` |
 
-STM32 MCUs allow for different timing parameters when configuring I2C. These can be modified using the following parameters, using https://www.st.com/en/embedded-software/stsw-stm32126.html as a reference:
+The ChibiOS I2C driver configuration depends on STM32 MCU:
+
+    STM32F1xx, STM32F2xx, STM32F4xx, STM32L0xx and STM32L1xx use I2Cv1;
+    STM32F0xx, STM32F3xx, STM32F7xx and STM32L4xx use I2Cv2;
+
+#### I2Cv1
+STM32 MCUs allow for different clock and duty parameters when configuring I2Cv1. These can be modified using the following parameters, using <https://www.playembedded.org/blog/stm32-i2c-chibios/#I2Cv1_configuration_structure> as a reference:
+
+| Variable           | Default          |
+|--------------------|------------------|
+| `I2C1_OPMODE`      | `OPMODE_I2C`     |
+| `I2C1_CLOCK_SPEED` | `100000`         |
+| `I2C1_DUTY_CYCLE`  | `STD_DUTY_CYCLE` |
+
+#### I2Cv2
+STM32 MCUs allow for different timing parameters when configuring I2Cv2. These can be modified using the following parameters, using <https://www.st.com/en/embedded-software/stsw-stm32126.html> as a reference:
 
 | Variable              | Default |
 |-----------------------|---------|
@@ -83,13 +98,14 @@ STM32 MCUs allow for different timing parameters when configuring I2C. These can
 | `I2C1_TIMINGR_SCLH`   | `15U`   |
 | `I2C1_TIMINGR_SCLL`   | `21U`   |
 
-STM32 MCUs allow for different "alternate function" modes when configuring GPIO pins. These are required to switch the pins used to I2C mode. See the respective datasheet for the appropriate values for your MCU.
+STM32 MCUs allow for different "alternate function" modes when configuring GPIO pins. These are required to switch the pins used to I2Cv2 mode. See the respective datasheet for the appropriate values for your MCU.
 
 | Variable            | Default |
 |---------------------|---------|
 | `I2C1_SCL_PAL_MODE` | `4`     |
 | `I2C1_SDA_PAL_MODE` | `4`     |
 
+#### Other
 You can also overload the `void i2c_init(void)` function, which has a weak attribute. If you do this the configuration variables above will not be used. Please consult the datasheet of your MCU for the available GPIO configurations. The following is an example initialization function:
 
 ```C

docs/keycodes.md

@@ -261,6 +261,8 @@ This is a reference only. Each group of keys links to the page documenting their
 |----------------------------------|---------|------------------------------------|
 |`MAGIC_SWAP_CONTROL_CAPSLOCK`     |         |Swap Caps Lock and Left Control     |
 |`MAGIC_CAPSLOCK_TO_CONTROL`       |         |Treat Caps Lock as Control          |
+|`MAGIC_SWAP_LCTL_LGUI`            |         |Swap Left Control and GUI           |
+|`MAGIC_SWAP_RCTL_RGUI`            |         |Swap Right Control and GUI          |
 |`MAGIC_SWAP_LALT_LGUI`            |         |Swap Left Alt and GUI               |
 |`MAGIC_SWAP_RALT_RGUI`            |         |Swap Right Alt and GUI              |
 |`MAGIC_NO_GUI`                    |         |Disable the GUI key                 |
@@ -268,8 +270,11 @@ This is a reference only. Each group of keys links to the page documenting their
 |`MAGIC_SWAP_BACKSLASH_BACKSPACE`  |         |Swap `\` and Backspace              |
 |`MAGIC_HOST_NKRO`                 |         |Force NKRO on                       |
 |`MAGIC_SWAP_ALT_GUI`              |`AG_SWAP`|Swap Alt and GUI on both sides      |
+|`MAGIC_SWAP_CTL_GUI`              |`CG_SWAP`|Swap Ctrl and GUI on both sides (for macOS)|
 |`MAGIC_UNSWAP_CONTROL_CAPSLOCK`   |         |Unswap Caps Lock and Left Control   |
 |`MAGIC_UNCAPSLOCK_TO_CONTROL`     |         |Stop treating Caps Lock as Control  |
+|`MAGIC_UNSWAP_LCTL_LGUI`          |         |Unswap Left Control and GUI         |
+|`MAGIC_UNSWAP_RCTL_RGUI`          |         |Unswap Right Control and GUI        |
 |`MAGIC_UNSWAP_LALT_LGUI`          |         |Unswap Left Alt and GUI             |
 |`MAGIC_UNSWAP_RALT_RGUI`          |         |Unswap Right Alt and GUI            |
 |`MAGIC_UNNO_GUI`                  |         |Enable the GUI key                  |
@@ -277,8 +282,10 @@ This is a reference only. Each group of keys links to the page documenting their
 |`MAGIC_UNSWAP_BACKSLASH_BACKSPACE`|         |Unswap `\` and Backspace            |
 |`MAGIC_UNHOST_NKRO`               |         |Force NKRO off                      |
 |`MAGIC_UNSWAP_ALT_GUI`            |`AG_NORM`|Unswap Alt and GUI on both sides    |
-|`MAGIC_TOGGLE_ALT_GUI`            |`AG_TOGG`|Toggle Alt and GUI swap on both sides|
-|`MAGIC_TOGGLE_NKRO`               |         |Turn NKRO on or off                 |
+|`MAGIC_UNSWAP_CTL_GUI`            |`CG_NORM`|Unswap Ctrl and GUI on both sides      |
+|`MAGIC_TOGGLE_ALT_GUI`            |`AG_TOGG`|Toggle Alt and GUI swap on both sides  |
+|`MAGIC_TOGGLE_CTL_GUI`            |`CG_TOGG`|Toggle Ctrl and GUI swap on both sides |
+|`MAGIC_TOGGLE_NKRO`               |         |Turn NKRO on or off                    |
 
 ## [Bluetooth](feature_bluetooth.md)
 

docs/newbs_building_firmware_configurator.md

@@ -4,7 +4,7 @@ The [QMK Configurator](https://config.qmk.fm) is an online graphical user interf
 
 ?> **Please follow these steps in order.**
 
-Watch the [Video Tutorial](https://youtu.be/7RH-1pAbjvw)
+Watch the [Video Tutorial](https://youtu.be/tx54jkRC9ZY)
 
 The QMK Configurator works best with Chrome/Firefox. 
 

docs/newbs_flashing.md

@@ -223,7 +223,7 @@ For the PJRC devices (Teensy's), when you're ready to compile and flash your fir
 
 For example, if your keymap is named "xyverz" and you're building a keymap for an Ergodox or Ergodox EZ, you'll use this command:
 
-    make erdogox_ez:xyverz:teensy
+    make ergodox_ez:xyverz:teensy
 
 Once the firmware finishes compiling, it will output something like this: 
 
@@ -248,6 +248,42 @@ Programming.....................................................................
 Booting
 ```
 
+## BootloadHID
+
+For Bootmapper Client(BMC)/bootloadHID/ATmega32A based boards, when you're ready to compile and flash your firmware, open up your terminal window and run the build command: 
+
+    make <my_keyboard>:<my_keymap>:bootloaderHID
+
+For example, if your keymap is named "xyverz" and you're building a keymap for a jj40, you'll use this command:
+
+    make jj40:xyverz:bootloaderHID
+
+Once the firmware finishes compiling, it will output something like this: 
+
+```
+Linking: .build/jj40_default.elf                                                                   [OK]
+Creating load file for flashing: .build/jj40_default.hex                                           [OK]
+Copying jj40_default.hex to qmk_firmware folder                                                    [OK]
+Checking file size of jj40_default.hex                                                             [OK]
+ * The firmware size is fine - 21920/28672 (6752 bytes free)
+```
+
+After it gets to this point, the build script will look for the DFU bootloader every 5 seconds.  It will repeat the following until the device is found or you cancel it. 
+
+```
+Error opening HIDBoot device: The specified device was not found
+Trying again in 5s.
+```
+
+Once it does this, you'll want to reset the controller.  It should then show output similar to this: 
+
+```
+Page size   = 128 (0x80)
+Device size = 32768 (0x8000); 30720 bytes remaining
+Uploading 22016 (0x5600) bytes starting at 0 (0x0)
+0x05580 ... 0x05600
+```
+
 ## STM32 (ARM)
 
 For a majority of ARM boards (including the Proton C, Planck Rev 6, and Preonic Rev 3), when you're ready to compile and flash your firmware, open up your terminal window and run the build command: 

docs/porting_your_keyboard_to_qmk_(arm_and_other_chibios_cpus).md

@@ -34,7 +34,7 @@ For the `DIODE_DIRECTION`, most hand-wiring guides will instruct you to wire the
 
 To configure a keyboard where each switch is connected to a separate pin and ground instead of sharing row and column pins, use `DIRECT_PINS`. The mapping defines the pins of each switch in rows and columns, from left to right. Must conform to the sizes within `MATRIX_ROWS` and `MATRIX_COLS`, use `NO_PIN` to fill in blank spaces. Overrides the behaviour of `DIODE_DIRECTION`, `MATRIX_ROW_PINS` and `MATRIX_COL_PINS`.
 
-`BACKLIGHT_PIN` is the pin that your PWM-controlled backlight (if one exists) is hooked-up to. Currently only B5, B6, and B7 are supported.
+`BACKLIGHT_PIN` is the pin that your PWM-controlled backlight (if one exists) is hooked-up to.
 
 `BACKLIGHT_BREATHING` is a fancier backlight feature that adds breathing/pulsing/fading effects to the backlight. It uses the same timer as the normal backlight. These breathing effects must be called by code in your keymap.
 

docs/ref_functions.md

@@ -50,7 +50,7 @@ The caveat to this method is that you cannot access the `z` layer without having
 #### Example
 
 ```c
-uint32_t layer_state_set_user(uint32_t state) {
+layer_state_t layer_state_set_user(layer_state_t state) {
   return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST);
 }
 ```
@@ -58,7 +58,7 @@ uint32_t layer_state_set_user(uint32_t state) {
 Alternatively, you don't have to immediately "return" the value.  This is useful if you want to add multiple tri layers, or if you want to add additional effects.
 
 ```c
-uint32_t layer_state_set_user(uint32_t state) {
+layer_state_t layer_state_set_user(layer_state_t state) {
   state = update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST);
   state = update_tri_layer_state(state, _RAISE, _SYMB, _SPECIAL);
   return state;

docs/zh-cn/faq_debug.md

@@ -173,23 +173,6 @@ EXTRAKEY_ENABLE = yes          # 音频控制和系统控制
 
 Arduino Leonardo和micro使用**ATMega32U4**，该芯片TMK可用，但Arduino的bootloader会导致问题。
 
-
-## 在USB AVR使用PF4-7针脚?
-你要置位MCUCR寄存器JTD位来将PF4-7设置为GPIO。这些针脚默认是JTAG功能。 像ATMega*U* or AT90USB*这样的MCU会受影响。
-
-如果是用Teensy的话就不需要了。Tennsy自带JTAGEN位未编程来失能该功能。
-<!--翻译问题：上句可能有错，原文为：Teensy is shipped with JTAGEN fuse bit unprogrammed to disable the function. -->
-代码如下。
-```
-    // F接口JTAG失能。在四个周期内写入两次JTD位。
-    MCUCR |= (1<<JTD);
-    MCUCR |= (1<<JTD);
-```
-https://github.com/tmk/tmk_keyboard/blob/master/keyboard/hbkb/matrix.c#L67
-
-阅读ATMega32U4的datasheet中的**26.5.1 MCU Control Register – MCUCR**。
-
-
 ## 为锁定键添加指示灯
 你要自制CapsLock, ScrollLock 和 NumLock指示灯？见下文。
 

drivers/arm/i2c_master.c

@@ -33,11 +33,17 @@
 static uint8_t i2c_address;
 
 static const I2CConfig i2cconfig = {
+#ifdef USE_I2CV1
+  I2C1_OPMODE,
+  I2C1_CLOCK_SPEED,
+  I2C1_DUTY_CYCLE,
+#else
   STM32_TIMINGR_PRESC(I2C1_TIMINGR_PRESC) |
   STM32_TIMINGR_SCLDEL(I2C1_TIMINGR_SCLDEL) | STM32_TIMINGR_SDADEL(I2C1_TIMINGR_SDADEL) |
   STM32_TIMINGR_SCLH(I2C1_TIMINGR_SCLH)  | STM32_TIMINGR_SCLL(I2C1_TIMINGR_SCLL),
   0,
   0
+#endif
 };
 
 static i2c_status_t chibios_to_qmk(const msg_t* status) {
@@ -61,8 +67,13 @@ void i2c_init(void)
 
   chThdSleepMilliseconds(10);
 
+#ifdef USE_I2CV1
+  palSetPadMode(I2C1_SCL_BANK, I2C1_SCL, PAL_MODE_STM32_ALTERNATE_OPENDRAIN);
+  palSetPadMode(I2C1_SDA_BANK, I2C1_SDA, PAL_MODE_STM32_ALTERNATE_OPENDRAIN);
+#else
   palSetPadMode(I2C1_SCL_BANK, I2C1_SCL, PAL_MODE_ALTERNATE(I2C1_SCL_PAL_MODE) | PAL_STM32_OTYPE_OPENDRAIN);
   palSetPadMode(I2C1_SDA_BANK, I2C1_SDA, PAL_MODE_ALTERNATE(I2C1_SDA_PAL_MODE) | PAL_STM32_OTYPE_OPENDRAIN);
+#endif
 
   //i2cInit(); //This is invoked by halInit() so no need to redo it.
 }
@@ -106,11 +117,11 @@ i2c_status_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, const uint8_t* data,
   return chibios_to_qmk(&status);
 }
 
-i2c_status_t i2c_readReg(uint8_t devaddr, uint8_t* regaddr, uint8_t* data, uint16_t length, uint16_t timeout)
+i2c_status_t i2c_readReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout)
 {
   i2c_address = devaddr;
   i2cStart(&I2C_DRIVER, &i2cconfig);
-  msg_t status = i2cMasterTransmitTimeout(&I2C_DRIVER, (i2c_address >> 1), regaddr, 1, data, length, MS2ST(timeout));
+  msg_t status = i2cMasterTransmitTimeout(&I2C_DRIVER, (i2c_address >> 1), &regaddr, 1, data, length, MS2ST(timeout));
   return chibios_to_qmk(&status);
 }
 

drivers/arm/i2c_master.h

@@ -22,10 +22,16 @@
  * Please ensure that HAL_USE_I2C is TRUE in the halconf.h file and that
  * STM32_I2C_USE_I2C1 is TRUE in the mcuconf.h file.
  */
+#pragma once
 
 #include "ch.h"
 #include <hal.h>
 
+
+#if defined(STM32F1XX) || defined(STM32F1xx) || defined(STM32F2xx) || defined(STM32F4xx) || defined(STM32L0xx) || defined(STM32L1xx)
+    #define USE_I2CV1
+#endif
+
 #ifdef I2C1_BANK
     #define I2C1_SCL_BANK I2C1_BANK
     #define I2C1_SDA_BANK I2C1_BANK
@@ -46,30 +52,42 @@
     #define I2C1_SDA 7
 #endif
 
-// The default PAL alternate modes are used to signal that the pins are used for I2C
-#ifndef I2C1_SCL_PAL_MODE
-    #define I2C1_SCL_PAL_MODE 4
-#endif
-#ifndef I2C1_SDA_PAL_MODE
-    #define I2C1_SDA_PAL_MODE 4
-#endif
+#ifdef USE_I2CV1
+    #ifndef I2C1_OPMODE
+        #define I2C1_OPMODE OPMODE_I2C
+    #endif
+    #ifndef I2C1_CLOCK_SPEED
+        #define I2C1_CLOCK_SPEED 100000 /* 400000 */
+    #endif
+    #ifndef I2C1_DUTY_CYCLE
+        #define I2C1_DUTY_CYCLE STD_DUTY_CYCLE /* FAST_DUTY_CYCLE_2 */
+    #endif
+#else
+    // The default PAL alternate modes are used to signal that the pins are used for I2C
+    #ifndef I2C1_SCL_PAL_MODE
+        #define I2C1_SCL_PAL_MODE 4
+    #endif
+    #ifndef I2C1_SDA_PAL_MODE
+        #define I2C1_SDA_PAL_MODE 4
+    #endif
 
-// The default timing values below configures the I2C clock to 400khz assuming a 72Mhz clock
-// For more info : https://www.st.com/en/embedded-software/stsw-stm32126.html
-#ifndef I2C1_TIMINGR_PRESC
-    #define I2C1_TIMINGR_PRESC 15U
-#endif
-#ifndef I2C1_TIMINGR_SCLDEL
-    #define I2C1_TIMINGR_SCLDEL 4U
-#endif
-#ifndef I2C1_TIMINGR_SDADEL
-    #define I2C1_TIMINGR_SDADEL 2U
-#endif
-#ifndef I2C1_TIMINGR_SCLH
-    #define I2C1_TIMINGR_SCLH 15U
-#endif
-#ifndef I2C1_TIMINGR_SCLL
-    #define I2C1_TIMINGR_SCLL 21U
+    // The default timing values below configures the I2C clock to 400khz assuming a 72Mhz clock
+    // For more info : https://www.st.com/en/embedded-software/stsw-stm32126.html
+    #ifndef I2C1_TIMINGR_PRESC
+        #define I2C1_TIMINGR_PRESC 15U
+    #endif
+    #ifndef I2C1_TIMINGR_SCLDEL
+        #define I2C1_TIMINGR_SCLDEL 4U
+    #endif
+    #ifndef I2C1_TIMINGR_SDADEL
+        #define I2C1_TIMINGR_SDADEL 2U
+    #endif
+    #ifndef I2C1_TIMINGR_SCLH
+        #define I2C1_TIMINGR_SCLH 15U
+    #endif
+    #ifndef I2C1_TIMINGR_SCLL
+        #define I2C1_TIMINGR_SCLL 21U
+    #endif
 #endif
 
 #ifndef I2C_DRIVER
@@ -88,5 +106,5 @@ i2c_status_t i2c_transmit(uint8_t address, const uint8_t* data, uint16_t length,
 i2c_status_t i2c_receive(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout);
 i2c_status_t i2c_transmit_receive(uint8_t address, uint8_t * tx_body, uint16_t tx_length, uint8_t * rx_body, uint16_t rx_length);
 i2c_status_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, const uint8_t* data, uint16_t length, uint16_t timeout);
-i2c_status_t i2c_readReg(uint8_t devaddr, uint8_t* regaddr, uint8_t* data, uint16_t length, uint16_t timeout);
+i2c_status_t i2c_readReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout);
 void i2c_stop(void);

drivers/issi/is31fl3731.c

@@ -71,10 +71,10 @@ uint8_t g_twi_transfer_buffer[20];
 // buffers and the transfers in IS31FL3731_write_pwm_buffer() but it's
 // probably not worth the extra complexity.
 uint8_t g_pwm_buffer[DRIVER_COUNT][144];
-bool g_pwm_buffer_update_required = false;
+bool g_pwm_buffer_update_required[DRIVER_COUNT] = { false };
 
 uint8_t g_led_control_registers[DRIVER_COUNT][18] = { { 0 }, { 0 } };
-bool g_led_control_registers_update_required = false;
+bool g_led_control_registers_update_required[DRIVER_COUNT] = { false };
 
 // This is the bit pattern in the LED control registers
 // (for matrix A, add one to register for matrix B)
@@ -204,7 +204,7 @@ void IS31FL3731_set_color( int index, uint8_t red, uint8_t green, uint8_t blue )
         g_pwm_buffer[led.driver][led.r - 0x24] = red;
         g_pwm_buffer[led.driver][led.g - 0x24] = green;
         g_pwm_buffer[led.driver][led.b - 0x24] = blue;
-        g_pwm_buffer_update_required = true;
+        g_pwm_buffer_update_required[led.driver] = true;
     }
 }
 
@@ -220,12 +220,12 @@ void IS31FL3731_set_led_control_register( uint8_t index, bool red, bool green, b
 {
     is31_led led = g_is31_leds[index];
 
-  uint8_t control_register_r = (led.r - 0x24) / 8;
-  uint8_t control_register_g = (led.g - 0x24) / 8;
-  uint8_t control_register_b = (led.b - 0x24) / 8;
-  uint8_t bit_r = (led.r - 0x24) % 8;
-  uint8_t bit_g = (led.g - 0x24) % 8;
-  uint8_t bit_b = (led.b - 0x24) % 8;
+    uint8_t control_register_r = (led.r - 0x24) / 8;
+    uint8_t control_register_g = (led.g - 0x24) / 8;
+    uint8_t control_register_b = (led.b - 0x24) / 8;
+    uint8_t bit_r = (led.r - 0x24) % 8;
+    uint8_t bit_g = (led.g - 0x24) % 8;
+    uint8_t bit_b = (led.b - 0x24) % 8;
 
     if ( red ) {
         g_led_control_registers[led.driver][control_register_r] |= (1 << bit_r);
@@ -243,28 +243,26 @@ void IS31FL3731_set_led_control_register( uint8_t index, bool red, bool green, b
         g_led_control_registers[led.driver][control_register_b] &= ~(1 << bit_b);
     }
 
-    g_led_control_registers_update_required = true;
+    g_led_control_registers_update_required[led.driver] = true;
 
 }
 
-void IS31FL3731_update_pwm_buffers( uint8_t addr1, uint8_t addr2 )
+void IS31FL3731_update_pwm_buffers( uint8_t addr, uint8_t index )
 {
-    if ( g_pwm_buffer_update_required )
+    if ( g_pwm_buffer_update_required[index] )
     {
-        IS31FL3731_write_pwm_buffer( addr1, g_pwm_buffer[0] );
-        IS31FL3731_write_pwm_buffer( addr2, g_pwm_buffer[1] );
+        IS31FL3731_write_pwm_buffer( addr, g_pwm_buffer[index] );
     }
-    g_pwm_buffer_update_required = false;
+    g_pwm_buffer_update_required[index] = false;
 }
 
-void IS31FL3731_update_led_control_registers( uint8_t addr1, uint8_t addr2 )
+void IS31FL3731_update_led_control_registers( uint8_t addr, uint8_t index )
 {
-    if ( g_led_control_registers_update_required )
+    if ( g_led_control_registers_update_required[index] )
     {
         for ( int i=0; i<18; i++ )
         {
-            IS31FL3731_write_register(addr1, i, g_led_control_registers[0][i] );
-            IS31FL3731_write_register(addr2, i, g_led_control_registers[1][i] );
+            IS31FL3731_write_register( addr, i, g_led_control_registers[index][i] );
         }
     }
 }

drivers/issi/is31fl3731.h

@@ -44,8 +44,8 @@ void IS31FL3731_set_led_control_register( uint8_t index, bool red, bool green, b
 // (eg. from a timer interrupt).
 // Call this while idle (in between matrix scans).
 // If the buffer is dirty, it will update the driver with the buffer.
-void IS31FL3731_update_pwm_buffers( uint8_t addr1, uint8_t addr2 );
-void IS31FL3731_update_led_control_registers( uint8_t addr1, uint8_t addr2 );
+void IS31FL3731_update_pwm_buffers( uint8_t addr, uint8_t index  );
+void IS31FL3731_update_led_control_registers( uint8_t addr, uint8_t index );
 
 #define C1_1  0x24
 #define C1_2  0x25

drivers/oled/oled_driver.c

@@ -114,8 +114,11 @@ bool             oled_active = false;
 bool             oled_scrolling = false;
 uint8_t          oled_rotation = 0;
 uint8_t          oled_rotation_width = 0;
-#if !defined(OLED_DISABLE_TIMEOUT)
-  uint16_t         oled_last_activity;
+#if OLED_TIMEOUT > 0
+  uint32_t         oled_timeout;
+#endif
+#if OLED_SCROLL_TIMEOUT > 0
+  uint32_t         oled_scroll_timeout;
 #endif
 
 // Internal variables to reduce math instructions
@@ -209,6 +212,13 @@ bool oled_init(uint8_t rotation) {
     return false;
   }
 
+#if OLED_TIMEOUT > 0
+  oled_timeout = timer_read32() + OLED_TIMEOUT;
+#endif
+#if OLED_SCROLL_TIMEOUT > 0
+  oled_scroll_timeout = timer_read32() + OLED_SCROLL_TIMEOUT;
+#endif
+
   oled_clear();
   oled_initialized = true;
   oled_active = true;
@@ -321,7 +331,7 @@ void oled_render(void) {
 
     // Send render data chunk after rotating
     if (I2C_WRITE_REG(I2C_DATA, &temp_buffer[0], OLED_BLOCK_SIZE) != I2C_STATUS_SUCCESS) {
-      print("oled_render data failed\n");
+      print("oled_render90 data failed\n");
       return;
     }
   }
@@ -393,6 +403,11 @@ void oled_write_char(const char data, bool invert) {
     return;
   }
 
+  if (data == '\r') {
+    oled_advance_page(false);
+    return;
+  }
+
   // copy the current render buffer to check for dirty after
   static uint8_t oled_temp_buffer[OLED_FONT_WIDTH];
   memcpy(&oled_temp_buffer, oled_cursor, OLED_FONT_WIDTH);
@@ -452,8 +467,8 @@ void oled_write_ln_P(const char *data, bool invert) {
 #endif // defined(__AVR__)
 
 bool oled_on(void) {
-#if !defined(OLED_DISABLE_TIMEOUT)
-  oled_last_activity = timer_read();
+#if OLED_TIMEOUT > 0
+  oled_timeout = timer_read32() + OLED_TIMEOUT;
 #endif
 
   static const uint8_t PROGMEM display_on[] = { I2C_CMD, DISPLAY_ON };
@@ -517,6 +532,7 @@ bool oled_scroll_off(void) {
       return oled_scrolling;
     }
     oled_scrolling = false;
+    oled_dirty = -1;
   }
   return !oled_scrolling;
 }
@@ -544,15 +560,32 @@ void oled_task(void) {
 
   oled_task_user();
 
+#if OLED_SCROLL_TIMEOUT > 0
+  if (oled_dirty && oled_scrolling) {
+    oled_scroll_timeout = timer_read32() + OLED_SCROLL_TIMEOUT;
+    oled_scroll_off();
+  }
+#endif
+
   // Smart render system, no need to check for dirty
   oled_render();
 
   // Display timeout check
-#if !defined(OLED_DISABLE_TIMEOUT)
-  if (oled_active && timer_elapsed(oled_last_activity) > OLED_TIMEOUT) {
+#if OLED_TIMEOUT > 0
+  if (oled_active && timer_expired32(timer_read32(), oled_timeout)) {
     oled_off();
   }
 #endif
+
+#if OLED_SCROLL_TIMEOUT > 0
+  if (!oled_scrolling && timer_expired32(timer_read32(), oled_scroll_timeout)) {
+#ifdef OLED_SCROLL_TIMEOUT_RIGHT
+    oled_scroll_right();
+#else
+    oled_scroll_left();
+#endif
+  }
+#endif
 }
 
 __attribute__((weak))

drivers/oled/oled_driver.h

@@ -138,6 +138,14 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
   #define OLED_FONT_HEIGHT 8
 #endif
 
+#if !defined(OLED_TIMEOUT)
+  #if defined(OLED_DISABLE_TIMEOUT)
+    #define OLED_TIMEOUT 0
+  #else
+    #define OLED_TIMEOUT 60000
+  #endif
+#endif
+
 // OLED Rotation enum values are flags
 typedef enum {
     OLED_ROTATION_0   = 0,

keyboards/1upkeyboards/1up60hse/keymaps/default/keymap.c

@@ -17,6 +17,19 @@
 #include QMK_KEYBOARD_H
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+  /* Qwerty
+   * ,-----------------------------------------------------------------------------------------.
+   * | Esc |  1  |  2  |  3  |  4  |  5  |  6  |  7  |  8  |  9  |  0  |  -  |  =  | Backspace |
+   * |-----------------------------------------------------------------------------------------+
+   * |  Tab   |  Q  |  W  |  E  |  R  |  T  |  Y  |  U  |  I  |  O  |  P  |  [  |  ]  |    \   |
+   * |-----------------------------------------------------------------------------------------+
+   * |  Caps   |  A  |  S  |  D  |  F  |  G  |  H  |  J  |  K  |  L  |  ;  |  '  |    Enter    |
+   * |-----------------------------------------------------------------------------------------+
+   * |   Shift   |  Z  |  X  |  C  |  V  |  B  |  N  |  M  |  ,  |  .  |  /  |      Shift      |
+   * |-----------------------------------------------------------------------------------------+
+   * | Ctrl  |  GUI  |  Alt  |              Space              |  Alt  |  GUI  |  L1   | Ctrl  |
+   * `-----------------------------------------------------------------------------------------'
+   */
   [0] = LAYOUT_60_ansi(
     KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_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,
@@ -25,6 +38,19 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     KC_LCTL, KC_LGUI, KC_LALT, KC_SPC, KC_RALT, KC_RGUI, MO(1), KC_RCTL
   ),
 
+  /* Function
+   * ,-----------------------------------------------------------------------------------------.
+   * |  `  | F1  | F2  | F3  | F4  | F5  | F6  | F7  | F8  | F9  | F10 | F11 | F12 |    Del    |
+   * |-----------------------------------------------------------------------------------------+
+   * |        |     | Up  |     |     |     |     |     |     |     |PrtSc|ScrLk|Pause|        |
+   * |-----------------------------------------------------------------------------------------+
+   * |         |Left |Down |Right|     |     |     |     |     | Ins |Home |PgUp |             |
+   * |-----------------------------------------------------------------------------------------+
+   * |           |VolUp|VolDn|VolMu|     |     |     |     |     | End |PgDn |                 |
+   * |-----------------------------------------------------------------------------------------+
+   * |       |       |       |                                 |       |  L2   |       |       |
+   * `-----------------------------------------------------------------------------------------'
+   */
   [1] = LAYOUT_60_ansi(
     KC_GRV, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_DEL,
     KC_TRNS, KC_TRNS, KC_UP, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_PSCR, KC_SLCK, KC_PAUS, KC_TRNS,
@@ -33,6 +59,19 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, MO(2), KC_TRNS, KC_TRNS
   ),
 
+  /* RGB
+   * ,-----------------------------------------------------------------------------------------.
+   * |     |     |     |     |     |     |     |     |     |     |     |     |     |   Reset   |
+   * |-----------------------------------------------------------------------------------------+
+   * | BL Tog |BLInc|BLDec|BLStp|     |     |     |     |     |     |     |     |     |        |
+   * |-----------------------------------------------------------------------------------------+
+   * | RGB Tog |Mode |Hue I|Sat I|Val I|Spd I|Plain|Breat|Rnbow|Swirl|     |     |             |
+   * |-----------------------------------------------------------------------------------------+
+   * |           |RMode|Hue D|Sat D|Val D|Spd D|Snake|Knigh|Xmas |Gradi|     |                 |
+   * |-----------------------------------------------------------------------------------------+
+   * |       |       |       |                                 |       |       |       |       |
+   * `-----------------------------------------------------------------------------------------'
+   */
   [2] = LAYOUT_60_ansi(
     KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, RESET,
     BL_TOGG, BL_INC, BL_DEC, BL_STEP, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,

keyboards/1upkeyboards/1up60hse/keymaps/vosechu/config.h

@@ -1,4 +1,4 @@
-/* Copyright 2018 Jack Humbert
+/* Copyright 2018 Chuck "@vosechu" Lauer Vose
  *
  * 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
@@ -14,8 +14,6 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include QMK_KEYBOARD_H
+#pragma once
 
-const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-  [0] = {{ KC_A }}
-};
+// place overrides here

keyboards/1upkeyboards/1up60hse/keymaps/vosechu/keymap.c

@@ -0,0 +1,46 @@
+/* Copyright 2018 Chuck "@vosechu" Lauer Vose
+ *
+ * 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
+
+#define SPACEFN LT(1, KC_SPC)
+#define CTL_GRV CTL_T(KC_GRV)
+#define ALT_TAB ALT_T(KC_TAB)
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+  [0] = LAYOUT_60_ansi(
+    KC_ESC  , KC_1     , KC_2    , KC_3    , KC_4    , KC_5    , KC_6     , KC_7    , KC_8    , KC_9     , KC_0    , KC_MINS , KC_EQL  , KC_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_LSFT , KC_Z     , KC_X    , KC_C    , KC_V    , KC_B    , KC_N     , KC_M    , KC_COMM , KC_DOT   , KC_SLSH , KC_RSFT ,
+    CTL_GRV , ALT_TAB  , KC_LGUI ,           SPACEFN           , KC_RALT  , KC_RGUI , MO(1)   , KC_RCTL
+  ),
+
+  [1] = LAYOUT_60_ansi(
+    KC_GRV  , KC_F1    , KC_F2   , KC_F3   , KC_F4   , KC_F5   , KC_F6    , KC_F7   , KC_F8   , KC_F9    , KC_F10  , KC_F11  , KC_F12  , KC_DEL  ,
+    KC_TRNS , KC_TRNS  , KC_UP   , KC_TRNS , KC_TRNS , KC_TRNS , KC_TRNS  , KC_TRNS , KC_TRNS , KC_TRNS  , KC_PSCR , KC_SLCK , KC_PAUS , KC_TRNS ,
+    KC_TRNS , KC_LEFT  , KC_DOWN , KC_RGHT , KC_TRNS , KC_TRNS , KC_TRNS  , KC_TRNS , KC_TRNS , KC_INS   , KC_HOME , KC_PGUP , KC_TRNS ,
+    KC_TRNS , KC_VOLU  , KC_VOLD , KC_MUTE , KC_TRNS , KC_TRNS , KC_TRNS  , KC_TRNS , KC_TRNS , KC_END   , KC_PGDN , KC_TRNS ,
+    KC_TRNS , KC_TRNS  , KC_TRNS ,           KC_TRNS           , KC_TRNS  , MO(2)   , KC_TRNS , KC_TRNS
+  ),
+
+  [2] = LAYOUT_60_ansi(
+    KC_TRNS , KC_TRNS  , KC_TRNS , KC_TRNS , KC_TRNS , KC_TRNS , KC_TRNS  , KC_TRNS , KC_TRNS , KC_TRNS  , KC_TRNS , KC_TRNS , KC_TRNS , RESET   ,
+    BL_TOGG , BL_INC   , BL_DEC  , BL_STEP , KC_TRNS , KC_TRNS , KC_TRNS  , KC_TRNS , KC_TRNS , KC_TRNS  , KC_TRNS , KC_TRNS , KC_TRNS , KC_TRNS ,
+    RGB_TOG , RGB_MOD  , RGB_HUI , RGB_SAI , RGB_VAI , RGB_SPI , RGB_M_P  , RGB_M_B , RGB_M_R , RGB_M_SW , KC_TRNS , KC_TRNS , KC_TRNS ,
+    KC_TRNS , RGB_RMOD , RGB_HUD , RGB_SAD , RGB_VAD , RGB_SPD , RGB_M_SN , RGB_M_K , RGB_M_X , RGB_M_G  , KC_TRNS , KC_TRNS ,
+    KC_TRNS , KC_TRNS  , KC_TRNS ,           KC_TRNS           , KC_TRNS  , KC_TRNS , KC_TRNS , KC_TRNS
+  )
+};

keyboards/1upkeyboards/1up60hse/keymaps/vosechu/readme.md

@@ -0,0 +1,6 @@
+# 1up60hse keymap made by vosechu
+
+Tweaks from default
+
+* Add in SpaceFN so arrows are reachable with just left hand (leaving right free for mousing).
+* Also add tab/grv under the alt/ctrl keys to make those easier to reach.

keyboards/1upkeyboards/1up60hse/rules.mk

@@ -1,5 +1,4 @@
 # MCU name
-#MCU = at90usb1286
 MCU = atmega32u4
 
 # Processor frequency.

keyboards/1upkeyboards/1up60rgb/keymaps/default/keymap.c

@@ -18,15 +18,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
 };
 
-const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
-	;
-
-	switch (id) {
-
-	}
-	return MACRO_NONE;
-}
-
 void matrix_init_user(void) {
 }
 

keyboards/1upkeyboards/1up60rgb/keymaps/iso/keymap.c

@@ -18,15 +18,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
 };
 
-const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
-	;
-
-	switch (id) {
-
-	}
-	return MACRO_NONE;
-}
-
 void matrix_init_user(void) {
 }
 

keyboards/1upkeyboards/1up60rgb/keymaps/tsangan/keymap.c

@@ -18,15 +18,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
 };
 
-const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
-	;
-
-	switch (id) {
-
-	}
-	return MACRO_NONE;
-}
-
 void matrix_init_user(void) {
 }
 

keyboards/2_milk/2_milk.c

@@ -0,0 +1,16 @@
+/* Copyright 2019 Sebastian Williams
+ *
+ * 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 "2_milk.h"

keyboards/2_milk/2_milk.h

@@ -0,0 +1,26 @@
+/* Copyright 2019 Sebastian Williams
+ *
+ * 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"
+
+#define LAYOUT( \
+  K00,  \
+  K01  \
+) { \
+  { K00 }, \
+  { K01 } \
+}

keyboards/2_milk/config.h

@@ -0,0 +1,41 @@
+/* Copyright 2019 Sebastian Williams
+ *
+ * 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       0xFEED
+#define PRODUCT_ID      0xB195
+#define DEVICE_VER      0x0001
+#define MANUFACTURER    rionlion100
+#define PRODUCT         2% Milk
+#define DESCRIPTION     A milk themed 2% Keyboard
+
+/* key matrix size */
+#define MATRIX_ROWS 2
+#define MATRIX_COLS 1
+
+/* Milk default pinout */
+#define DIRECT_PINS { \
+    {D4}, \
+    {C6}  \
+}
+#define UNUSED_PINS
+
+#ifdef RGBLIGHT_ENABLE
+#define RGB_DI_PIN B6
+#define RGBLED_NUM 1
+#endif

keyboards/2_milk/info.json

@@ -0,0 +1,15 @@
+{
+  "keyboard_name": "2% Milk",
+  "keyboard_folder": "2_milk",
+  "url": "",
+  "maintainer": "rionlion100",
+  "width": 1,
+  "height": 2,
+  "layouts": {
+    "LAYOUT": {
+      "key_count": 2,
+      "layout": [ {"x": 0, "y": 0 }, {"x": 0, "y": 1 }]
+    }
+  }
+}
+

keyboards/2_milk/keymaps/binary/keymap.c

@@ -0,0 +1,8 @@
+#include QMK_KEYBOARD_H
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+      [0] = LAYOUT(
+          KC_P0, 
+          KC_P1
+          )
+};

keyboards/2_milk/keymaps/binary/readme.md

@@ -0,0 +1,2 @@
+# Binary keymap 
+0 and 1 that's it 

keyboards/2_milk/keymaps/copypasta/keymap.c

@@ -0,0 +1,9 @@
+    
+#include QMK_KEYBOARD_H
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+      [0] = LAYOUT(
+          RCTL(KC_C), 
+          RCTL(KC_V)
+          )
+};

keyboards/2_milk/keymaps/copypasta/readme.md

@@ -0,0 +1,2 @@
+# Copy/Paste Keymap
+![Picture](https://i.imgur.com/7LMZZrL.png)

keyboards/2_milk/keymaps/default/keymap.c

@@ -0,0 +1,8 @@
+#include QMK_KEYBOARD_H
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+      [0] = LAYOUT(
+          KC_Z,
+          KC_X
+          )
+};

keyboards/2_milk/keymaps/default/readme.md

@@ -0,0 +1,2 @@
+# Default keymap for 2% Milk
+![Picture](https://i.imgur.com/9PsZ6wa.png)

keyboards/2_milk/keymaps/emoji/keymap.c

@@ -0,0 +1,31 @@
+#include QMK_KEYBOARD_H
+
+enum custom_keycodes {
+  DISSA,
+  SHRUG
+};
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+      [0] = LAYOUT(
+          SHRUG,
+          DISSA
+          )
+};
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+    case SHRUG:
+      if (record->event.pressed) {
+        send_unicode_hex_string("00AF 005C 005F 0028 30C4 0029 005F 002F 00AF");
+      } else {
+      }
+      break;
+    case DISSA:
+      if (record->event.pressed) {
+          send_unicode_hex_string("0CA0 005F 0CA0");
+      } else {
+      }
+      break;
+  }
+  return true;
+};

keyboards/2_milk/keymaps/emoji/readme.md

@@ -0,0 +1,2 @@
+# Emoji Keymap
+![Picture](https://i.imgur.com/1zEZ9Lq.png)

keyboards/2_milk/keymaps/excessbread/keymap.c

@@ -0,0 +1,8 @@
+#include QMK_KEYBOARD_H
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+      [0] = LAYOUT(
+          KC_LGUI,
+          KC_F11	
+          )
+};

keyboards/2_milk/keymaps/excessbread/readme.md

@@ -0,0 +1,2 @@
+# ExcessBread's keymap
+requested by excessbread

keyboards/2_milk/keymaps/mouse/keymap.c

@@ -0,0 +1,8 @@
+#include QMK_KEYBOARD_H
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+      [0] = LAYOUT(
+          KC_BTN1,
+          KC_BTN2	
+          )
+};

keyboards/2_milk/keymaps/mouse/readme.md

@@ -0,0 +1,2 @@
+# left and right mouse buttons
+requested by WanderingVagrant

keyboards/2_milk/readme.md

@@ -0,0 +1,19 @@
+# 2% Milk
+
+![2%Milk](https://i.imgur.com/Ud96uXn.png)
+
+A 2% Meme board themed around a milk carton
+
+Keyboard Maintainer: [Rionlion100](https://github.com/rionlion100)  
+Hardware Availability: [Open Source](https://github.com/Rionlion100/Spaceboards/tree/master/Keyboards/2%25%20Milk)
+
+Make example for this keyboard (after setting up your build environment):
+
+    make 2_milk:default
+
+See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs).
+
+### Credits
++ Case design by Soft
++ PCB by PyroL
++ Name by jetpacktuxedo

keyboards/2_milk/rules.mk

@@ -0,0 +1,34 @@
+# MCU name
+MCU = atmega32u4
+
+# Processor frequency.
+F_CPU = 16000000
+
+#
+# LUFA specific
+#
+# Target architecture (see library "Board Types" documentation).
+ARCH = AVR8
+
+# Input clock frequency.
+F_USB = $(F_CPU)
+
+# Bootloader
+BOOTLOADER = caterina
+
+# Interrupt driven control endpoint task(+60)
+OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
+
+# Build Options
+#   comment out to disable the options.
+#
+BOOTMAGIC_ENABLE  = no	# Virtual DIP switch configuration(+1000)
+MOUSEKEY_ENABLE  = no	# Mouse keys(+4700)
+EXTRAKEY_ENABLE  = no	# Audio control and System control(+450)
+CONSOLE_ENABLE  = yes	# Console for debug(+400)
+COMMAND_ENABLE  = yes    # Commands for debug and configuration
+SLEEP_LED_ENABLE  = no  # Breathing sleep LED during USB suspend
+NKRO_ENABLE  = yes		# USB Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
+BACKLIGHT_ENABLE  = no  # Custom backlighting code is used, so this should not be enabled
+AUDIO_ENABLE  = no # This can be enabled if a speaker is connected to the expansion port. Not compatible with RGBLIGHT below
+RGBLIGHT_ENABLE  = yes # This can be enabled if a ws2812 strip is connected to the expansion port.

keyboards/40percentclub/gherkin/keymaps/default/keymap.c

@@ -18,46 +18,24 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
 };
 
-void matrix_init_user(void) {
-}
+void keyboard_pre_init_user(void) {
+  // Call the keyboard pre init code.
 
-void matrix_scan_user(void) {
-}
-
-bool process_record_user(uint16_t keycode, keyrecord_t *record) {
-  return true;
+  // Set our LED pins as output
+  setPinOutput(D5);
+  setPinOutput(B0);
 }
 
 void led_set_user(uint8_t usb_led) {
-
-  if (usb_led & (1 << USB_LED_NUM_LOCK)) {
-    DDRD |= (1 << 5); PORTD &= ~(1 << 5);
+  if (IS_LED_ON(usb_led, USB_LED_NUM_LOCK)) {
+    writePinLow(D5);
   } else {
-    DDRD &= ~(1 << 5); PORTD &= ~(1 << 5);
+    writePinHigh(D5);
   }
 
-  if (usb_led & (1 << USB_LED_CAPS_LOCK)) {
-    DDRB |= (1 << 0); PORTB &= ~(1 << 0);
+  if (IS_LED_ON(usb_led, USB_LED_CAPS_LOCK)) {
+    writePinLow(B0);
   } else {
-    DDRB &= ~(1 << 0); PORTB &= ~(1 << 0);
+    writePinHigh(B0);
   }
-
-  if (usb_led & (1 << USB_LED_SCROLL_LOCK)) {
-
-  } else {
-
-  }
-
-  if (usb_led & (1 << USB_LED_COMPOSE)) {
-
-  } else {
-
-  }
-
-  if (usb_led & (1 << USB_LED_KANA)) {
-
-  } else {
-
-  }
-
 }

keyboards/40percentclub/half_n_half/rules.mk

@@ -1,5 +1,4 @@
 # MCU name
-#MCU = at90usb1286
 MCU = atmega32u4
 
 # Processor frequency.

keyboards/40percentclub/luddite/keymaps/default/keymap.c

@@ -1,7 +1,5 @@
 #include QMK_KEYBOARD_H
 
-extern keymap_config_t keymap_config;
-
 // Each layer gets a name for readability, which is then used in the keymap matrix below.
 // The underscores don't mean anything - you can have a layer called STUFF or any other name.
 // Layer names don't all need to be of the same length, obviously, and you can also skip them
@@ -15,18 +13,18 @@ enum custom_keycodes {
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   [_BASE] = LAYOUT_60_ansi(
-    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_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_RSFT, \
-    KC_LCTL , KC_LGUI , KC_LALT ,                      KC_SPC                    , KC_RALT , KC_RGUI , MO(_FN1)  , KC_RCTL
+    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_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH,                    KC_RSFT,
+    KC_LCTL, KC_LGUI, KC_LALT ,                           KC_SPC,                             KC_RALT, KC_RGUI, MO(_FN1), KC_RCTL
   ),
 
   [_FN1] = LAYOUT_60_ansi(
-    KC_GESC, KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,  KC_BSPC, \
-    RGB_TOG, RGB_MOD, KC_UP,   _______,   _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
-    _______, KC_LEFT, KC_DOWN, KC_RGHT, _______, _______, _______, _______, _______, _______, _______, _______, _______,\
-    BL_INC, BL_DEC, BL_TOGG, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
-    KC_GRV, _______, _______, _______, _______,          _______, _______, _______
+    KC_GESC, KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,   KC_BSPC,
+    RGB_TOG, RGB_MOD, KC_UP,   _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,  _______,
+    _______, KC_LEFT, KC_DOWN, KC_RGHT, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+    BL_INC,  BL_DEC,  BL_TOGG, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+    KC_GRV,  _______, _______,                            _______,                            _______, _______, _______,  _______
   )
 };

keyboards/40percentclub/luddite/keymaps/tzarc/config.h

@@ -0,0 +1,6 @@
+#undef RGBLED_NUM
+#define RGBLED_NUM 16
+
+#define QMK_ESC_OUTPUT F4
+#define QMK_ESC_INPUT D3
+#define QMK_LED B0

keyboards/40percentclub/luddite/keymaps/tzarc/keymap.c

@@ -0,0 +1,30 @@
+#include QMK_KEYBOARD_H
+
+// Each layer gets a name for readability, which is then used in the keymap matrix below.
+// The underscores don't mean anything - you can have a layer called STUFF or any other name.
+// Layer names don't all need to be of the same length, obviously, and you can also skip them
+// entirely and just use numbers.
+#define _BASE 0
+#define _FN1 1
+
+enum custom_keycodes {
+  QWERTY = SAFE_RANGE,
+};
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+  [_BASE] = LAYOUT_60_ansi(
+    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_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH,                    KC_RSFT,
+    KC_LCTL, KC_LGUI, KC_LALT ,                           KC_SPC,                             KC_RALT, KC_APP,  MO(_FN1), KC_RCTL
+  ),
+
+  [_FN1] = LAYOUT_60_ansi(
+    KC_GESC, KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,   _______,
+    RGB_TOG, RGB_MOD, KC_UP,   _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,  _______,
+    _______, KC_LEFT, KC_DOWN, KC_RGHT, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+    BL_INC,  BL_DEC,  BL_TOGG, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+    KC_GRV,  _______, _______,                            _______,                            _______, KC_RGUI, _______,  _______
+  )
+};

keyboards/40percentclub/luddite/keymaps/tzarc/rules.mk

@@ -0,0 +1 @@
+BOOTLOADER = qmk-dfu

keyboards/40percentclub/luddite/luddite.h

@@ -3,7 +3,7 @@
 #include "quantum.h"
 
 #define LAYOUT_60_ansi( \
-	 K00, K01, K02, K03, K04, K05, K06, K07, K10, K11, K12, K13, K14, K15, \
+    K00, K01, K02, K03, K04, K05, K06, K07, K10, K11, K12, K13, K14, K15, \
     K16, K17, K20, K21, K22, K23, K24, K25, K26, K27, K30, K31, K32, K33, \
     K34, K35, K36, K37, K40, K41, K42, K43, K44, K45, K46, K47, K50, \
     K51, K52, K53, K54, K55, K56, K57, K60, K61, K62, K63, K64, \
@@ -18,4 +18,3 @@
 	{ K60,   K61,   K62,   K63,   K64,   K65,   K66,   K67 }, \
 	{ K70,   K71,   K72,   K73,   K74 }, \
 }
-

keyboards/4by3/4by3.c

@@ -0,0 +1 @@
+#include "4by3.h"

keyboards/4by3/4by3.h

@@ -0,0 +1,70 @@
+#pragma once
+
+#include "quantum.h"
+
+/* LAYOUT_horizontal
+ * ┌───┐
+ * │USB│
+ * ├───┼───┬───┬───┐
+ * │K00│K01│K02│K03│
+ * ├───┼───┼───┼───┤
+ * │K10│K11│K12│K13│
+ * ├───┼───┼───┼───┤
+ * │K20│K21│K22│K23│
+ * └───┴───┴───┴───┘
+ */
+#define LAYOUT_horizontal( \
+	K00, K01, K02, K03, \
+	K10, K11, K12, K13, \
+	K20, K21, K22, K23  \
+) { \
+	{ K00, K01, K02, K03 }, \
+	{ K10, K11, K12, K13 }, \
+	{ K20, K21, K22, K23 }  \
+}
+
+/* LAYOUT_vertical_right
+ * ┌───┬───┬───┬───┐
+ * │K00│K01│K03│USB│
+ * ├───┼───┼───┬───┘
+ * │K04│K05│K06│
+ * ├───┼───┼───┤
+ * │K07│K08│K09│
+ * ├───┼───┼───┤
+ * │K10│K11│K12│
+ * └───┴───┴───┘
+ */
+#define LAYOUT_vertical_right( \
+	K20, K10, K00, \
+    K21, K11, K01, \
+    K22, K12, K02, \
+    K23, K13, K03  \
+) { \
+	{ K00, K01, K02, K03 }, \
+	{ K10, K11, K12, K13 }, \
+	{ K20, K21, K22, K23 }  \
+}
+
+/* LAYOUT_vertical_left
+ *     ┌───┬───┬───┐
+ *     │K00│K01│K03│
+ *     ├───┼───┼───┤
+ *     │K04│K05│K06│
+ *     ├───┼───┼───┤
+ *     │K07│K08│K09│
+ * ┌───┼───┼───┼───┤
+ * │USB│K10│K11│K12│
+ * └───┴───┴───┴───┘
+ */
+#define LAYOUT_vertical_left( \
+	K03, K13, K23, \
+    K02, K12, K22, \
+    K01, K11, K21, \
+    K00, K10, K20  \
+) { \
+	{ K00, K01, K02, K03 }, \
+	{ K10, K11, K12, K13 }, \
+	{ K20, K21, K22, K23 }  \
+}
+
+#define LAYOUT LAYOUT_horizontal

keyboards/4by3/config.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "config_common.h"
+
+/* USB Device descriptor parameter */
+#define VENDOR_ID       0xEEEE
+#define PRODUCT_ID      0x2019
+#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
+#define MATRIX_COLS 4
+
+/* key matrix pins */
+#define MATRIX_ROW_PINS { D1, D0, D4 }
+#define MATRIX_COL_PINS { C6, D7, E6, B4 }
+#define UNUSED_PINS
+
+/* COL2ROW or ROW2COL */
+#define DIODE_DIRECTION COL2ROW
+
+/* Set 0 if debouncing isn't needed */
+#define DEBOUNCE 5

keyboards/4by3/info.json

@@ -0,0 +1,41 @@
+{
+    "keyboard_name": "4by3",
+    "url": "https://github.com/eliassjogreen/4by3",
+    "maintainer": "eliassjogreen",
+    "width": 4,
+    "height": 3,
+    "layouts": {
+        "LAYOUT_horizontal": {
+            "key_count": 12,
+            "width": 4,
+            "height": 3,
+            "layout": [
+                { "x": 0, "y": 0 }, { "x": 1, "y": 0 }, { "x": 2, "y": 0 }, { "x": 3, "y": 0 },
+                { "x": 0, "y": 1 }, { "x": 1, "y": 1 }, { "x": 2, "y": 1 }, { "x": 3, "y": 1 },
+                { "x": 0, "y": 2 }, { "x": 1, "y": 2 }, { "x": 2, "y": 2 }, { "x": 3, "y": 2 }
+            ]
+        },
+        "LAYOUT_vertical_right": {
+            "key_count": 12,
+            "width": 3,
+            "height": 4,
+            "layout": [
+                { "x": 0, "y": 0 }, { "x": 1, "y": 0 }, { "x": 2, "y": 0 },
+                { "x": 0, "y": 1 }, { "x": 1, "y": 1 }, { "x": 2, "y": 1 },
+                { "x": 0, "y": 2 }, { "x": 1, "y": 2 }, { "x": 2, "y": 2 },
+                { "x": 0, "y": 3 }, { "x": 1, "y": 3 }, { "x": 2, "y": 3 }
+            ]
+        },
+        "LAYOUT_vertical_left": {
+            "key_count": 12,
+            "width": 3,
+            "height": 4,
+            "layout": [
+                { "x": 0, "y": 0 }, { "x": 1, "y": 0 }, { "x": 2, "y": 0 },
+                { "x": 0, "y": 1 }, { "x": 1, "y": 1 }, { "x": 2, "y": 1 },
+                { "x": 0, "y": 2 }, { "x": 1, "y": 2 }, { "x": 2, "y": 2 },
+                { "x": 0, "y": 3 }, { "x": 1, "y": 3 }, { "x": 2, "y": 3 }
+            ]
+        }
+    }
+}

keyboards/4by3/keymaps/arrowpad/keymap.c

@@ -0,0 +1,12 @@
+#include QMK_KEYBOARD_H
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+    /* Change 'LAYOUT_vertical_right' to 'LAYOUT_vertical_left'
+       to change the side where the pro micro usb port is. */
+    [0] = LAYOUT_vertical_right(
+		KC_INS  , KC_HOME , KC_PGUP ,
+        KC_DEL  , KC_END  , KC_PGDN ,
+        KC_PSCR , KC_UP   , KC_PAUS ,
+        KC_LEFT , KC_DOWN , KC_RGHT
+    )
+};

keyboards/4by3/keymaps/default/keymap.c

@@ -0,0 +1,9 @@
+#include QMK_KEYBOARD_H
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+	[0] = LAYOUT_horizontal(
+		KC_VOLU , _______ , _______ , _______ ,
+        KC_MUTE , KC_MPRV , KC_MPLY , KC_MNXT ,
+        KC_VOLD , _______ , _______ , _______
+    )
+};

keyboards/4by3/keymaps/default/readme.md

@@ -0,0 +1,3 @@
+# The default 4by3 keymap
+
+![The default 4by3 keymap](https://i.imgur.com/E4OlQAs.png)

keyboards/4by3/keymaps/funcpad_horizontal/keymap.c

@@ -0,0 +1,9 @@
+#include QMK_KEYBOARD_H
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+	[0] = LAYOUT_horizontal(
+		KC_F1   , KC_F2   , KC_F3   , KC_F4   ,
+		KC_F5   , KC_F6   , KC_F7   , KC_F8   ,
+		KC_F9   , KC_F10  , KC_F11  , KC_F12
+    )
+};

keyboards/4by3/keymaps/funcpad_vertical/keymap.c

@@ -0,0 +1,12 @@
+#include QMK_KEYBOARD_H
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+    /* Change 'LAYOUT_vertical_right' to 'LAYOUT_vertical_left'
+       to change the side where the pro micro usb port is. */
+	[0] = LAYOUT_vertical_right(
+		KC_F1   , KC_F2   , KC_F3   ,
+        KC_F4   , KC_F5   , KC_F6   ,
+        KC_F7   , KC_F8   , KC_F9   ,
+        KC_F10  , KC_F11  , KC_F12
+    )
+};

keyboards/4by3/keymaps/numpad_horizontal/keymap.c

@@ -0,0 +1,9 @@
+#include QMK_KEYBOARD_H
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+	[0] = LAYOUT_horizontal(
+		KC_P1   , KC_P2   , KC_P3   , KC_P4   ,
+		KC_P5   , KC_P6   , KC_P7   , KC_P8   ,
+		KC_P9   , KC_P0   , KC_BSPC , KC_ENT
+    ),
+};

keyboards/4by3/keymaps/numpad_vertical/keymap.c

@@ -0,0 +1,12 @@
+#include QMK_KEYBOARD_H
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+    /* Change 'LAYOUT_vertical_right' to 'LAYOUT_vertical_left'
+       to change the side where the pro micro usb port is. */
+	[0] = LAYOUT_vertical_right(
+		KC_P1   , KC_P2   , KC_P3   ,
+        KC_P4   , KC_P5   , KC_P6   ,
+        KC_P7   , KC_P8   , KC_P9   ,
+        KC_BSPC , KC_P0   , KC_ENT
+    ),
+};

keyboards/4by3/readme.md

@@ -1,16 +1,15 @@
-Proton C
-===
+# 4by3
 
-![Proton C](https://i.imgur.com/xZrjIqa.jpg)
+![4by3](https://i.imgur.com/Ykb7evL.jpg)
 
-A Pro Micro drop-in replacement.
+A 12 key mechanical keypad.
 
-Keyboard Maintainer: [Jack Humbert](https://github.com/jackhumbert)  
-Hardware Supported: QMK Proton C  
-Hardware Availability: [List of vendors](https://qmk.fm/proton-c)
+Keyboard Maintainer: [eliassjogreen](https://github.com/eliassjogreen)  
+Hardware Supported: 4by3  
+Hardware Availability: [eliassjogreen/4by3](https://github.com/eliassjogreen/4by3)
 
 Make example for this keyboard (after setting up your build environment):
 
-    make proton_c:default
+    make 4by3:default
 
 See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs).

keyboards/4by3/rules.mk

@@ -0,0 +1,8 @@
+MCU 				= atmega32u4
+BOOTLOADER 			= caterina
+
+EXTRAKEY_ENABLE 	= yes
+NKRO_ENABLE 		= yes
+CONSOLE_ENABLE		= yes
+COMMAND_ENABLE		= yes
+

keyboards/6ball/rules.mk

@@ -1,5 +1,4 @@
 # MCU name
-#MCU = at90usb1287
 MCU = atmega32u4
 
 # Processor frequency.

keyboards/9key/rules.mk

@@ -1,5 +1,4 @@
 # MCU name
-#MCU = at90usb1287
 MCU = atmega32u4
 
 # Processor frequency.

keyboards/abstract/ellipse/rev1/config.h

@@ -125,11 +125,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
-/* key combination for magic key command */
-/*#define IS_COMMAND() ( \
-    keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
-)*/
-
 /* control how magic key switches layers */
 //#define MAGIC_KEY_SWITCH_LAYER_WITH_FKEYS  true
 //#define MAGIC_KEY_SWITCH_LAYER_WITH_NKEYS  true
@@ -239,7 +234,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // #define BOOTMAGIC_LITE_ROW 0
 // #define BOOTMAGIC_LITE_COLUMN 0
 
-#define NUMBER_OF_ENCODERS 3
 #define ENCODERS_PAD_A { B2, B3, D5 }
 #define ENCODERS_PAD_B { B1, B7, B4 }
 #define ENCODER_RESOLUTION 2

keyboards/adkb96/rev1/rev1.h

@@ -2,8 +2,6 @@
 
 #include "adkb96.h"
 
-//void promicro_bootloader_jmp(bool program);
-
 #ifdef USE_I2C
 #include <stddef.h>
 #ifdef __AVR__
@@ -12,9 +10,6 @@
 #endif
 #endif
 
-//void promicro_bootloader_jmp(bool program);
-
-
 // Keymap with right side flipped
 // (TRRS jack on both halves are to the right)
 #define LAYOUT_ortho_6x16( \

keyboards/adkb96/rules.mk

@@ -1,5 +1,4 @@
 # MCU name
-#MCU = at90usb1287
 MCU = atmega32u4
 
 # Processor frequency.

keyboards/ai03/lunar/keymaps/muzfuz/keymap.c

@@ -0,0 +1,52 @@
+#include QMK_KEYBOARD_H
+
+// Helpful defines
+#define ESC_CTL     CTL_T(KC_ESCAPE)            // Tap for Esc, hold for Ctrl
+#define FL_KCF LT(1,KC_F)
+#define FL_KCJ LT(1,KC_J)
+#define CMD_ENT LGUI(LSFT(KC_ENT))
+
+enum custom_keycodes {
+  HASHRKT = SAFE_RANGE,
+  CLNEQLS,
+};
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+	[0] = LAYOUT( /* Base */
+		KC_GRV,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_BSLS, KC_BSLS, LGUI(KC_C),
+		KC_TAB,           KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_LBRC, KC_RBRC, KC_BSPC, LGUI(KC_V),
+		ESC_CTL,          KC_A,    KC_S,    KC_D,    FL_KCF,  KC_G,    KC_H,    FL_KCJ,  KC_K,    KC_L,    KC_SCLN, KC_QUOT,          KC_ENT,  KC_PGUP,
+		KC_LSFT,          KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_LSFT,          KC_UP,   KC_PGDN,
+		CMD_ENT, KC_LALT, KC_LGUI,          KC_SPC,           KC_SPC,           KC_SPC,                    MO(2),   KC_GRV,  KC_LEFT, KC_DOWN, KC_RGHT
+	),
+	[1] = LAYOUT( /* FL */
+		KC_ESC,   KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,  KC_DEL,  KC_DEL,  KC_VOLU,
+		_______,          HASHRKT, _______, KC_LCBR, KC_RCBR, _______, _______, KC_UNDS, KC_PLUS, KC_PIPE,  _______, _______, _______, _______, KC_VOLD,
+		_______,          CLNEQLS, _______, KC_LBRC, KC_RBRC, _______, _______, KC_MINS, KC_EQL,  KC_BSLS,  KC_TILD, KC_GRV,           _______, KC_HOME,
+		_______,          _______, _______, _______, _______, _______, _______, _______,  _______, _______, _______, _______,          _______, KC_END,
+		_______, _______, _______,          _______,          _______,          _______,                    _______, _______, _______, _______, _______
+	),
+	[2] = LAYOUT( /* FN */
+		RESET,   KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,  KC_DEL,  KC_DEL,  _______,
+		KC_CAPS,          _______, KC_UP,   _______, _______, _______, KC_NLCK, KC_P7,   KC_P8,   KC_P9,   KC_MPRV, KC_MPLY, KC_MNXT, _______, _______,
+		_______,          KC_LEFT, KC_DOWN, KC_RGHT, _______, KC_VOLD, KC_VOLU, KC_P4,   KC_P5,   KC_P6,   _______, _______,          _______, _______,
+		_______,          KC_RCTL, KC_RGUI, KC_RALT, _______, _______, KC_P0,   KC_P1,   KC_P2,   KC_P3,   _______, _______,          KC_PGUP, _______,
+		_______, _______, _______,          _______,          _______,          _______,                   _______, _______, KC_HOME, KC_PGDN, KC_END
+	)
+};
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch(keycode) {
+    case HASHRKT:
+      if (record->event.pressed) {
+        SEND_STRING("=>");
+      }
+      break;
+    case CLNEQLS:
+      if (record->event.pressed) {
+        SEND_STRING(":=");
+      }
+      break;
+  }
+  return true;
+}

keyboards/ai03/lunar/keymaps/muzfuz/readme.md

@@ -0,0 +1,5 @@
+# muzfuz's keymap for Lunar
+
+```shell
+make ai03/lunar:muzfuz:dfu
+```

keyboards/ai03/lunar/keymaps/via/rules.mk

@@ -1,5 +1,4 @@
 # MCU name
-#MCU = at90usb1286
 MCU = atmega32u4
 
 # Processor frequency.
@@ -83,4 +82,4 @@ HD44780_ENABLE = no 		# Enable support for HD44780 based LCDs (+400)
 SRC += keyboards/wilba_tech/wt_main.c
 
 RAW_ENABLE = yes
-DYNAMIC_KEYMAP_ENABLE = yes
+DYNAMIC_KEYMAP_ENABLE = yes

keyboards/ai03/lunar/rules.mk

@@ -1,5 +1,4 @@
 # MCU name
-#MCU = at90usb1286
 MCU = atmega32u4
 
 # Processor frequency.

keyboards/ai03/orbit/rules.mk

@@ -5,7 +5,6 @@ SRC += split_util.c \
 	   matrix.c
 
 # MCU name
-#MCU = at90usb1286
 MCU = atmega32u4
 
 # Processor frequency.