Remove PJRC USB stack

* refactor keymaps

Create one keymap for each layout macro.

* remove config.h for default keymap

There's nothing in it.

* update readme

- use the new list format
- use a smaller version of the keyboard photo (does the readme really need a 14MP image on it?)

.github/stale.yml

@@ -18,7 +18,7 @@ pulls:
     activity in the last 45 days. It will be closed in 30 days if no further activity occurs.
     Please feel free to give a status update now, or re-open when it's ready.
     
-    For maintainers: Please label with `awaiting review`, `breaking_change`, `in progress, or `on hold` to prevent 
+    For maintainers: Please label with `awaiting review`, `breaking_change`, `in progress`, or `on hold` to prevent 
     the issue from being re-flagged.
   # Comment to post when closing a stale Issue or Pull Request.
   closeComment: >
@@ -45,7 +45,7 @@ issues:
     last 90 days. It will be closed in the next 30 days unless it is tagged properly or other activity
     occurs.
     
-    For maintainers: Please label with `bug`, `in progress`, `on hold`, discussion` or `to do` to prevent 
+    For maintainers: Please label with `bug`, `in progress`, `on hold`, `discussion` or `to do` to prevent 
     the issue from being re-flagged.
   closeComment: >
     This issue has been automatically closed because it has not had activity in the last 30 days.

.github/workflows/cli.yml

@@ -0,0 +1,28 @@
+name: CLI CI
+
+on:
+  push:
+    branches:
+    - master
+    - future
+  pull_request:
+    paths:
+    - 'lib/python/**'
+    - 'bin/qmk'
+    - 'requirements.txt'
+    - '.github/workflows/cli.yml'
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    container: qmkfm/base_container
+
+    steps:
+    - uses: actions/checkout@v1
+      with:
+        submodules: recursive
+    - name: Install dependencies
+      run: pip3 install -r requirements.txt
+    - name: Run tests
+      run: bin/qmk pytest

.gitignore

@@ -63,9 +63,6 @@ util/Win_Check_Output.txt
 *.gif
 *.jpg
 
-# Do not ignore MiniDox left/right hand eeprom files
-!keyboards/minidox/*.eep
-
 # things travis sees
 secrets.tar
 id_rsa_*

.travis.yml

@@ -12,6 +12,18 @@ env:
   - MAKEFLAGS="-j3 --output-sync"
 services:
   - docker
+addons:
+  apt:
+    sources:
+      - ubuntu-toolchain-r-test
+      - llvm-toolchain-trusty-7
+    packages:
+    - pandoc
+    - diffutils
+    - dos2unix
+    - doxygen
+    - clang-format-7
+    - libstdc++-7-dev
 install:
   - npm install -g moxygen
 script:
@@ -20,13 +32,6 @@ script:
   - bash util/travis_test.sh
   - bash util/travis_build.sh
   - bash util/travis_docs.sh
-addons:
-  apt:
-    packages:
-    - pandoc
-    - diffutils
-    - dos2unix
-    - doxygen
 after_script:
   bash util/travis_compiled_push.sh
 notifications:

bin/qmk

@@ -25,6 +25,11 @@ with open(os.path.join(qmk_dir, 'requirements.txt'), 'r') as fd:
             line = line.split('#')[0]
 
         module = line.split('=')[0] if '=' in line else line
+
+        if module in ['pep8-naming']:
+            # Not every module is importable by its own name.
+            continue
+
         if not find_spec(module):
             print('Could not find module %s!' % module)
             print('Please run `pip3 install -r requirements.txt` to install the python dependencies.')

bootloader.mk

@@ -82,6 +82,13 @@ ifeq ($(strip $(BOOTLOADER)), USBasp)
     OPT_DEFS += -DBOOTLOADER_USBASP
     BOOTLOADER_SIZE = 4096
 endif
+ifeq ($(strip $(BOOTLOADER)), lufa-ms)
+    # DO NOT USE THIS BOOTLOADER IN NEW PROJECTS!
+    # It is extremely prone to bricking, and is only included to support existing boards.
+    OPT_DEFS += -DBOOTLOADER_MS
+    BOOTLOADER_SIZE = 6144
+    FIRMWARE_FORMAT = bin
+endif
 
 ifdef BOOTLOADER_SIZE
     OPT_DEFS += -DBOOTLOADER_SIZE=$(strip $(BOOTLOADER_SIZE))

build_json.mk

@@ -22,5 +22,5 @@ else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_1)/keymap.json)","")
 endif
 
 # Generate the keymap.c
-$(KEYBOARD_OUTPUT)/src/keymap.c:
+$(KEYBOARD_OUTPUT)/src/keymap.c: $(KEYMAP_JSON)
 	bin/qmk json-keymap --quiet --output $(KEYMAP_C) $(KEYMAP_JSON)

docs/_langs.md

@@ -4,5 +4,6 @@
   - [:es: Español](/es/)
   - [:fr: Français](/fr-fr/)
   - [:he: עברית](/he-il/)
+  - [:brazil: Português](/pt-br/)
   - [:ru: Русский](/ru-ru/)
   - [:jp: 日本語](/ja/)

docs/_summary.md

@@ -3,7 +3,10 @@
   * [Building Your First Firmware](newbs_building_firmware.md)
   * [Flashing Firmware](newbs_flashing.md)
   * [Testing and Debugging](newbs_testing_debugging.md)
-  * [Git Best Practices](newbs_best_practices.md)
+  * [Best Git Practices](newbs_git_best_practices.md)
+    * [Using Your Fork's Master](newbs_git_using_your_master_branch.md)
+    * [Resolving Merge Conflicts](newbs_git_resolving_merge_conflicts.md)
+    * [Resynchronizing a Branch](newbs_git_resynchronize_a_branch.md)
   * [Learning Resources](newbs_learn_more_resources.md)
 
 * [QMK Basics](README.md)
@@ -15,6 +18,7 @@
   * [Getting Help](getting_started_getting_help.md)
 
 * [Breaking Changes](breaking_changes.md)
+  * [My Pull Request Was Flagged](breaking_changes_instructions.md)
   * [2019 Aug 30](ChangeLog/20190830.md)
 
 * [FAQ](faq.md)
@@ -98,9 +102,12 @@
   * [Hand Wiring Guide](hand_wire.md)
   * [ISP Flashing Guide](isp_flashing_guide.md)
   * [ARM Debugging Guide](arm_debugging.md)
+  * [ADC Driver](adc_driver.md)
   * [I2C Driver](i2c_driver.md)
   * [WS2812 Driver](ws2812_driver.md)
+  * [EEPROM Driver](eeprom_driver.md)
   * [GPIO Controls](internals_gpio_control.md)
+  * [Custom Matrix](custom_matrix.md)
   * [Proton C Conversion](proton_c_conversion.md)
 
 * For a Deeper Understanding
@@ -111,7 +118,7 @@
   * [Using Eclipse with QMK](other_eclipse.md)
   * [Using VSCode with QMK](other_vscode.md)
   * [Support](support.md)
-  * [How to add translations](translating.md)
+  * [Translating the QMK Docs](translating.md)
 
 * QMK Internals (In Progress)
   * [Defines](internals_defines.md)

docs/adc_driver.md

@@ -0,0 +1,50 @@
+# ADC Driver
+
+QMK can leverage the Analog-to-Digital Converter (ADC) on supported MCUs to measure voltages on certain pins. This can be useful for implementing things such as battery level indicators for Bluetooth keyboards, or volume controls using a potentiometer, as opposed to a [rotary encoder](feature_encoders.md).
+
+This driver is currently AVR-only. The values returned are 10-bit integers (0-1023) mapped between 0V and VCC (usually 5V or 3.3V).
+
+## Usage
+
+To use this driver, add the following to your `rules.mk`:
+
+```make
+SRC += analog.c
+```
+
+Then place this include at the top of your code:
+
+```c
+#include "analog.h"
+```
+
+## Channels
+
+|Channel|AT90USB64/128|ATmega16/32U4|ATmega32A|ATmega328P|
+|-------|-------------|-------------|---------|----------|
+|0      |`F0`         |`F0`         |`A0`     |`C0`      |
+|1      |`F1`         |`F1`         |`A1`     |`C1`      |
+|2      |`F2`         |             |`A2`     |`C2`      |
+|3      |`F3`         |             |`A3`     |`C3`      |
+|4      |`F4`         |`F4`         |`A4`     |`C4`      |
+|5      |`F5`         |`F5`         |`A5`     |`C5`      |
+|6      |`F6`         |`F6`         |`A6`     |*         |
+|7      |`F7`         |`F7`         |`A7`     |*         |
+|8      |             |`D4`         |         |          |
+|9      |             |`D6`         |         |          |
+|10     |             |`D7`         |         |          |
+|11     |             |`B4`         |         |          |
+|12     |             |`B5`         |         |          |
+|13     |             |`B6`         |         |          |
+
+<sup>\* The ATmega328P possesses two extra ADC channels; however, they are not present on the DIP pinout, and are not shared with GPIO pins. You can use `adc_read()` directly to gain access to these.</sup>
+
+## Functions
+
+|Function                    |Description                                                                                                        |
+|----------------------------|-------------------------------------------------------------------------------------------------------------------|
+|`analogReference(mode)`     |Sets the analog voltage reference source. Must be one of `ADC_REF_EXTERNAL`, `ADC_REF_POWER` or `ADC_REF_INTERNAL`.|
+|`analogRead(pin)`           |Reads the value from the specified Arduino pin, eg. `4` for ADC6 on the ATmega32U4.                                |
+|`analogReadPin(pin)`        |Reads the value from the specified QMK pin, eg. `F6` for ADC6 on the ATmega32U4.                                   |
+|`pinToMux(pin)`             |Translates a given QMK pin to a mux value. If an unsupported pin is given, returns the mux value for "0V (GND)".   |
+|`adc_read(mux)`             |Reads the value from the ADC according to the specified mux. See your MCU's datasheet for more information.        |

docs/arm_debugging.md

@@ -1,4 +1,4 @@
-# ARM Debugging usign Eclipse
+# ARM Debugging using Eclipse
 
 This page describes how to setup debugging for ARM MCUs using an SWD adapter and open-source/free tools. In this guide we will install GNU MCU Eclipse IDE for C/C++ Developers and OpenOCD together with all the necessary dependencies.
 
@@ -18,7 +18,7 @@ XPM installation instructions can be found [here](https://www.npmjs.com/package/
 
 ### The ARM Toolchain
 
-Using XPM it is very easy to install the ARM toolchain. Enter the command `xpm install --global @gnu-mcu-eclipse/arm-none-eabi-gcc`.
+Using XPM it is very easy to install the ARM toolchain. Enter the command `xpm install --global @xpack-dev-tools/arm-none-eabi-gcc`.
 
 ### Windows build tools
 
@@ -33,7 +33,7 @@ If you have an ST-Link the drivers can be found [here](https://www.st.com/en/dev
 
 ### OpenOCD
 
-This dependency allows SWD access from GDB and it is essential for debugging. Run `xpm install --global @gnu-mcu-eclipse/openocd`.
+This dependency allows SWD access from GDB and it is essential for debugging. Run `xpm install --global @xpack-dev-tools/openocd`.
 
 ### Java
 
@@ -45,17 +45,17 @@ Now its finally time to install the IDE. Use the Release page [here](https://git
 
 ## Configuring Eclipse
 
-Open up the Eclipse IDE we just downloaded. To import our QMK directory select File -> Import -> C/C++ -> Existing code as Makefile Project. Select next and use Browse to select your QMK folder. In the tool-chain list select ARM Cross GCC and select Finish.
+Open up the Eclipse IDE we just downloaded. To import our QMK directory select File -> Import -> C/C++ -> Existing Code as Makefile Project. Select Next and use Browse to select your QMK folder. In the tool-chain list select ARM Cross GCC and select Finish.
 
-Now you can see the QMK folder on the left hand side. Right click it and select Properties. On the left hand side, expand MCU and select ARM Toolchain Paths. Press xPack and OK. Repeat for OpenOCD Path  and if you are on windows for Build Tool Path. Select Apply and Close.
+Now you can see the QMK folder on the left hand side. Right click it and select Properties. On the left hand side, expand MCU and select ARM Toolchains Paths. Press xPack and OK. Repeat for OpenOCD Path and if you are on Windows for Build Tools Path. Select Apply and Close.
 
-Now its time to install the necessary MCU packages. Go to Packs perspective by selecting Window -> Open Perspective -> Others -> Packs. Now select the yellow refresh symbol next to the Packs tab. This will take a long time as it is requesting the MCU definitions from various places. If some of the links fail you can probably select Ignore.
+Now its time to install the necessary MCU packages. Go to Packs perspective by selecting Window -> Perspective -> Open Perspective -> Other... -> Packs. Now select the yellow refresh symbol next to the Packs tab. This will take a long time as it is requesting the MCU definitions from various places. If some of the links fail you can probably select Ignore.
 
-When this finishes you must find the MCU which we will be building/debugging for. In this example I will be using the STM32F3 series MCUs. On the left, select STMicroelectonics -> STM32F3 Series. On the middle window we can see the pack. Right click and select Install. Once that is done we can go back to the default perspective, Window -> Open Perspective -> Others -> C/C++.
+When this finishes you must find the MCU which we will be building/debugging for. In this example I will be using the STM32F3 series MCUs. On the left, select STMicroelectronics -> STM32F3 Series. On the middle window we can see the pack. Right click and select Install. Once that is done we can go back to the default perspective, Window -> Perspective -> Open Perspective -> Other... -> C/C++.
 
-We need to let eclipse know the device we intent to build QMK on. Right click on the QMK folder -> Properties -> C/C++ Build -> Settings. Select the Devices tab and under devices select the appropriate variant of your MCU. For my example it is STM32F303CC
+We need to let eclipse know the device we intent to build QMK on. Right click on the QMK folder -> Properties -> C/C++ Build -> Settings. Select the Devices tab and under Devices select the appropriate variant of your MCU. For my example it is STM32F303CC
 
-While we are here let's setup the build command as well. Select C/C++ Build and then the Behavior tab. On the build command, replace `all` with your necessary make command. For example for a rev6 Planck with the default keymap this would be `planck/rev6:default`. Select Apply and Close.
+While we are here let's setup the build command as well. Select C/C++ Build and then the Behavior tab. On the Build command, replace `all` with your necessary make command. For example for a rev6 Planck with the default keymap this would be `planck/rev6:default`. Select Apply and Close.
 
 ## Building
 
@@ -71,7 +71,7 @@ NOTE: Make sure the SWCLK and SWDIO pins are not used in the matrix of your keyb
 
 ### Configuring the Debugger
 
-Right click on your QMK folder, select Debug As -> Debug Configuration. Here double click on GDB OpenOCD Debugging. Select the debugger tab and enter the configuration necessary for your MCU. This might take some fiddling and googleing to find out. The default script for the STM32F3 is called stm32f3discovery.cfg. To let OpenOCD know, in the Config options enter `-f board/stm32f3discovery.cfg`.
+Right click on your QMK folder, select Debug As -> Debug Configurations... . Here double click on GDB OpenOCD Debugging. Select the Debugger tab and enter the configuration necessary for your MCU. This might take some fiddling and Googling to find out. The default script for the STM32F3 is called `stm32f3discovery.cfg`. To let OpenOCD know, in the Config options enter `-f board/stm32f3discovery.cfg`.
 
 NOTE: In my case this configuration script requires editing to disable the reset assertion. The locations of the scripts can be found in the actual executable field usually under the path `openocd/version/.content/scripts/board`. Here I edited `reset_config srst_only` to `reset_config none`.
 
@@ -81,7 +81,7 @@ Select Apply and Close.
 
 Reset your keyboard.
 
-Press the bug icon and if all goes well you should soon find yourself in the debug perspective. Here the program counter will pause at the beginning of the main function and way for you to press Play. Most of the features of all debuggers work on ARM MCUs but for exact details google is your friend!
+Press the bug icon and if all goes well you should soon find yourself in the Debug perspective. Here the program counter will pause at the beginning of the main function and wait for you to press Play. Most of the features of all debuggers work on Arm MCUs but for exact details Google is your friend!
 
 
 Happy debugging!

docs/breaking_changes.md

@@ -10,16 +10,16 @@ The breaking change period is when we will merge PR's that change QMK in dangero
 
 ## When is the next Breaking Change?
 
-The next Breaking Change is scheduled for Nov 29.
+The next Breaking Change is scheduled for February 29, 2020.
 
 ### Important Dates
 
 * [x] 2019 Sep 21 - `future` is created. It will be rebased weekly.
-* [ ] 2019 Nov 01 - `future` closed to new PR's.
-* [ ] 2019 Nov 01 - Call for testers.
-* [ ] 2019 Nov 27 - `master` is locked, no PR's merged.
-* [ ] 2019 Nov 29 - Merge `future` to `master`.
-* [ ] 2019 Nov 30 - `master` is unlocked. PR's can be merged again.
+* [x] 2020 Feb 1 - `future` closed to new PR's.
+* [x] 2020 Feb 1 - Call for testers.
+* [ ] 2020 Feb 26 - `master` is locked, no PR's merged.
+* [ ] 2020 Feb 28 - Merge `future` to `master`.
+* [ ] 2020 Feb 29 - `master` is unlocked. PR's can be merged again.
 
 ## What changes will be included?
 

docs/breaking_changes_instructions.md

@@ -0,0 +1,42 @@
+# Breaking Changes: My Pull Request Was Flagged
+
+A QMK member may have replied to your pull request stating that your submission is a breaking change. In their judgment, the changes you have proposed have greater implications for either QMK, or its users.
+
+Some things that may cause a pull request to be flagged are:
+
+- **Edits to User Keymaps**
+  A user may submit their keymap to QMK, then some time later open a pull request with further updates, only to find it can't be merged because it was edited in the `qmk/qmk_firmware` repository. As not all users are proficient at using Git or GitHub, the user may find themself unable to fix the issue on their own.
+- **Changes to Expected Behavior**
+  Changes to QMK behavior may cause users to believe their hardware or QMK is broken if they flash new firmware that incorporates changes to existing QMK features, and find themselves without a means to restore the desired behavior.
+- **Changes Requiring User Action**
+  Changes may also require action to be taken by users, such as updating a toolchain or taking some action in Git.
+- **Changes Necessitating Increased Scrutiny**
+  On occasion, a submission may have implications for QMK as a project. This could be copyright/licensing issues, coding conventions, large feature overhauls, "high-risk" changes that need wider testing by our community, or something else entirely.
+- **Changes Requiring Communication to End Users**
+  This includes warnings about future deprecations, outdated practices, and anything else that needs to be communicated but doesn't fit into one of the above categories.
+
+## What Do I Do?
+
+If it is determined that your submission is a breaking change, there are a few things you can do to smooth the process:
+
+### Consider Splitting Up Your PR
+
+If you are contributing core code, and the only reason it needs to go through breaking changes is that you are updating keymaps to match your change, consider whether you can submit your feature in a way that the old keymaps continue to work. Then submit a separate PR that goes through the breaking changes process to remove the old code.
+
+### Contribute a ChangeLog Entry
+
+We require submissions that go through the Breaking Change process to include a changelog entry. The entry should be a short summary of the changes your pull request makes – [each section here started as a changelog](ChangeLog/20190830.md "n.b. This should link to the 2019 Aug 30 Breaking Changes doc  - @noroadsleft").
+
+Your changelog should be located at `docs/ChangeLog/YYYYMMDD/PR####.md`, where `YYYYMMDD` is the date on which QMK's breaking change branch – usually named `future` – will be merged into the `master` branch, and `####` is the number of your pull request.
+
+If your submission requires action on the part of users, your changelog should instruct users what action(s) must be taken, or link to a location that does so.
+
+### Document Your Changes
+
+Understanding the purpose for your submission, and possible implications or actions it will require can make the review process more straightforward. A changelog may suffice for this purpose, but more extensive changes may require a level of detail that is ill-suited for a changelog.
+
+Commenting on your pull request and being responsive to questions, comments, and change requests is much appreciated.
+
+### Ask for Help
+
+Having your submission flagged may have caught you off guard. If you find yourself intimidated or overwhelmed, let us know. Comment on your pull request, or [reach out to the QMK team on Discord](https://discord.gg/Uq7gcHh).

docs/cli.md

@@ -81,7 +81,7 @@ qmk cformat [file1] [file2] [...] [fileN]
 
 ## `qmk compile`
 
-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.
+This command allows you to compile firmware from any directory. You can compile JSON exports from <https://config.qmk.fm>, compile keymaps in the repo, or compile the keyboard in the current working directory.
 
 **Usage for Configurator Exports**:
 
@@ -95,6 +95,53 @@ qmk compile <configuratorExport.json>
 qmk compile -kb <keyboard_name> -km <keymap_name>
 ```
 
+**Usage in Keyboard Directory**:  
+
+Must be in keyboard directory with a default keymap, or in keymap directory for keyboard, or supply one with `--keymap <keymap_name>`
+```
+qmk compile
+```
+
+**Example**:
+```
+$ qmk config compile.keymap=default
+$ cd ~/qmk_firmware/keyboards/planck/rev6
+$ qmk compile
+Ψ Compiling keymap with make planck/rev6:default
+...
+```
+or with optional keymap argument
+
+```
+$ cd ~/qmk_firmware/keyboards/clueboard/66/rev4 
+$ qmk compile -km 66_iso
+Ψ Compiling keymap with make clueboard/66/rev4:66_iso
+...
+```
+or in keymap directory
+
+```
+$ cd ~/qmk_firmware/keyboards/gh60/satan/keymaps/colemak
+$ qmk compile
+Ψ Compiling keymap with make make gh60/satan:colemak
+...
+```
+
+**Usage in Layout Directory**:  
+
+Must be under `qmk_firmware/layouts/`, and in a keymap folder.
+```
+qmk compile -kb <keyboard_name>
+```
+
+**Example**:
+```
+$ cd ~/qmk_firmware/layouts/community/60_ansi/mechmerlin-ansi
+$ qmk compile -kb dz60
+Ψ Compiling keymap with make dz60:mechmerlin-ansi
+...
+```
+
 ## `qmk flash`
 
 This command is similar to `qmk compile`, but can also target a bootloader. The bootloader is optional, and is set to `:flash` by default.
@@ -141,14 +188,28 @@ qmk docs [-p PORT]
 
 ## `qmk doctor`
 
-This command examines your environment and alerts you to potential build or flash problems.
+This command examines your environment and alerts you to potential build or flash problems. It can fix many of them if you want it to.
 
 **Usage**:
 
 ```
-qmk doctor
+qmk doctor [-y] [-n]
 ```
 
+**Examples**:
+
+Check your environment for problems and prompt to fix them:
+
+    qmk doctor
+
+Check your environment and automatically fix any problems found:
+
+    qmk doctor -y
+
+Check your environment and report problems only:
+
+    qmk doctor -n
+
 ## `qmk json-keymap`
 
 Creates a keymap.c from a QMK Configurator export.

docs/coding_conventions_c.md

@@ -14,7 +14,7 @@ Most of our style is pretty easy to pick up on, but right now it's not entirely
   * Think of them as a story describing the feature
   * Use them liberally to explain why particular decisions were made.
   * Do not write obvious comments
-  * If you not sure if a comment is obvious, go ahead and include it.
+  * If you're not sure if a comment is obvious, go ahead and include it.
 * In general we don't wrap lines, they can be as long as needed. If you do choose to wrap lines please do not wrap any wider than 76 columns.
 * We use `#pragma once` at the start of header files rather than old-style include guards (`#ifndef THIS_FILE_H`, `#define THIS_FILE_H`, ..., `#endif`)
 * We accept both forms of preprocessor if's: `#ifdef DEFINED` and `#if defined(DEFINED)`

docs/coding_conventions_python.md

@@ -8,7 +8,7 @@ Most of our style follows PEP8 with some local modifications to make things less
   * Think of them as a story describing the feature
   * Use them liberally to explain why particular decisions were made.
   * Do not write obvious comments
-  * If you not sure if a comment is obvious, go ahead and include it.
+  * If you're not sure if a comment is obvious, go ahead and include it.
 * We require useful docstrings for all functions.
 * In general we don't wrap lines, they can be as long as needed. If you do choose to wrap lines please do not wrap any wider than 76 columns.
 * Some of our practices conflict with the wider python community to make our codebase more approachable to non-pythonistas.
@@ -309,6 +309,18 @@ FIXME(username): Revisit this code when the frob feature is done.
 
 ...where username is your GitHub username.
 
-# Unit Tests
+# Testing
 
-These are good. We should have some one day.
+We use a combination of Integration and Unit testing to ensure that the our code is as bug-free as possible. All the tests can be found in `lib/python/qmk/tests/`. You can run all the tests with `qmk pytest`.
+
+At the time of this writing our tests are not very comprehensive. Looking at the current tests and writing new test cases for untested situations is a great way to both familiarize yourself with the codebase and contribute to QMK.
+
+## Integration Tests
+
+Integration tests can be found in `lib/python/qmk/tests/test_cli_commands.py`. This is where CLI commands are actually run and their overall behavior is verified. We use [`subprocess`](https://docs.python.org/3.5/library/subprocess.html#module-subprocess) to launch each CLI command and a combination of checking output and returncode to determine if the right thing happened.
+
+## Unit Tests
+
+The other `test_*.py` files in `lib/python/qmk/tests/` contain unit tests. You can write tests for individual functions inside `lib/python/qmk/` here. Generally these files are named after the module, with dots replaced by underscores.
+
+At the time of this writing we do not do any mocking for our tests. If you would like to help us change this please [open an issue](https://github.com/qmk/qmk_firmware/issues/new?assignees=&labels=cli%2C+python&template=other_issues.md&title=) or [join #cli on Discord](https://discord.gg/heQPAgy) and start a conversation there.

docs/config_options.md

@@ -143,10 +143,14 @@ If you define these options you will enable the associated feature, which may in
 * `#define IGNORE_MOD_TAP_INTERRUPT`
   * makes it possible to do rolling combos (zx) with keys that convert to other keys on hold, by enforcing the `TAPPING_TERM` for both keys.
   * See [Mod tap interrupt](feature_advanced_keycodes.md#ignore-mod-tap-interrupt) for details
+* `#define IGNORE_MOD_TAP_INTERRUPT_PER_KEY`
+  * enables handling for per key `IGNORE_MOD_TAP_INTERRUPT` settings
 * `#define TAPPING_FORCE_HOLD`
   * makes it possible to use a dual role key as modifier shortly after having been tapped
   * See [Hold after tap](feature_advanced_keycodes.md#tapping-force-hold)
   * Breaks any Tap Toggle functionality (`TT` or the One Shot Tap Toggle)
+* `#define TAPPING_FORCE_HOLD_PER_KEY`
+  * enables handling for per key `TAPPING_FORCE_HOLD` settings
 * `#define LEADER_TIMEOUT 300`
   * how long before the leader key times out
     * If you're having issues finishing the sequence before it times out, you may need to increase the timeout setting. Or you may want to enable the `LEADER_PER_KEY_TIMING` option, which resets the timeout after each key is tapped.
@@ -272,9 +276,12 @@ There are a few different ways to set handedness for split keyboards (listed in
   * Default behavior for ARM
   * Required for AVR Teensy
 
-* `#define SPLIT_USB_TIMEOUT 2500`
+* `#define SPLIT_USB_TIMEOUT 2000`
   * Maximum timeout when detecting master/slave when using `SPLIT_USB_DETECT`
 
+* `#define SPLIT_USB_TIMEOUT_POLL 10`
+  * Poll frequency when detecting master/slave when using `SPLIT_USB_DETECT`
+
 # The `rules.mk` File
 
 This is a [make](https://www.gnu.org/software/make/manual/make.html) file that is included by the top-level `Makefile`. It is used to set some information about the MCU that we will be compiling for as well as enabling and disabling certain features.
@@ -287,8 +294,27 @@ This is a [make](https://www.gnu.org/software/make/manual/make.html) file that i
   * Defines which format (bin, hex) is copied to the root `qmk_firmware` folder after building.
 * `SRC`
   * Used to add files to the compilation/linking list.
+* `LIB_SRC`
+  * Used to add files as a library to the compilation/linking list.  
+    The files specified by `LIB_SRC` is linked after the files specified by `SRC`.  
+    For example, if you specify:
+    ```
+    SRC += a.c
+    LIB_SRC += lib_b.c
+    SRC += c.c
+    LIB_SRC += lib_d.c
+    ```
+    The link order is as follows.
+    ```
+     ...  a.o c.o  ...  lib_b.a lib_d.a  ...
+    ```
 * `LAYOUTS`
   * A list of [layouts](feature_layouts.md) this keyboard supports.
+* `LINK_TIME_OPTIMIZATION_ENABLE`
+  * Enables Link Time Optimization (`LTO`) when compiling the keyboard.  This makes the process take longer, but can significantly reduce the compiled size (and since the firmware is small, the added time is not noticeable).  However, this will automatically disable the old Macros and Functions features automatically, as these break when `LTO` is enabled.
+  It does this by automatically defining `NO_ACTION_MACRO` and `NO_ACTION_FUNCTION`
+* `LTO_ENABLE`
+  * It has the same meaning as LINK_TIME_OPTIMIZATION_ENABLE.  You can use `LTO_ENABLE` instead of `LINK_TIME_OPTIMIZATION_ENABLE`.
 
 ## AVR MCU Options
 * `MCU = atmega32u4`
@@ -347,9 +373,6 @@ Use these to enable or disable building certain features. The more you have enab
   * Forces the keyboard to wait for a USB connection to be established before it starts up
 * `NO_USB_STARTUP_CHECK`
   * Disables usb suspend check after keyboard startup. Usually the keyboard waits for the host to wake it up before any tasks are performed. This is useful for split keyboards as one half will not get a wakeup call but must send commands to the master.
-* `LINK_TIME_OPTIMIZATION_ENABLE`
-  * Enables Link Time Optimization (`LTO`) when compiling the keyboard.  This makes the process take longer, but can significantly reduce the compiled size (and since the firmware is small, the added time is not noticeable).  However, this will automatically disable the old Macros and Functions features automatically, as these break when `LTO` is enabled.  It does this by automatically defining `NO_ACTION_MACRO` and `NO_ACTION_FUNCTION`
-  * Alternatively, you can use `LTO_ENABLE` instead of `LINK_TIME_OPTIMIZATION_ENABLE`. 
 
 ## USB Endpoint Limitations
 

docs/contributing.md

@@ -85,7 +85,7 @@ Limited experimentation on the devices I have available shows that 7 is high eno
 
 Documentation is one of the easiest ways to get started contributing to QMK. Finding places where the documentation is wrong or incomplete and fixing those is easy! We also very badly need someone to edit our documentation, so if you have editing skills but aren't sure where or how to jump in please [reach out for help](#where-can-i-go-for-help)!
 
-You'll find all our documentation in the `qmk_firmware/docs` directory, or if you'd rather use a web based workflow you can click "Suggest An Edit" at the top of each page on http://docs.qmk.fm/.
+You'll find all our documentation in the `qmk_firmware/docs` directory, or if you'd rather use a web based workflow you can click the "Edit this page" link at the bottom of each page on https://docs.qmk.fm/.
 
 When providing code examples in your documentation, try to observe naming conventions used elsewhere in the docs. For example, standardizing enums as `my_layers` or `my_keycodes` for consistency:
 
@@ -101,6 +101,18 @@ enum my_keycodes {
 };
 ```
 
+### Previewing the Documentation
+
+Before opening a pull request, you can preview your changes if you have set up the development environment by running this command from the `qmk_firmware/` folder:
+
+    ./bin/qmk docs
+
+or if you only have Python 3 installed:
+
+    python3 -m http.server 8936
+
+and navigating to `http://localhost:8936/`.
+
 ## Keymaps
 
 Most first-time QMK contributors start with their personal keymaps. We try to keep keymap standards pretty casual (keymaps, after all, reflect the personality of their creators) but we do ask that you follow these guidelines to make it easier for others to discover and learn from your keymap.

docs/custom_matrix.md

@@ -0,0 +1,108 @@
+# Custom Matrix
+
+QMK provides a mechanism to supplement or replace the default matrix scanning routine with your own code.
+
+The reasons to use this feature include:
+
+* Extra hardware between the keyboard's switches and MCU pins
+  * I/O multiplexer
+  * Line decoder
+* Irregular switch matrix
+  * Simultaneous use of `COL2ROW` and `ROW2COL`
+
+## Prerequisites
+
+Implementing custom matrix usually involves compilation of an additional source file. It is recommended that for consistency, this file is called `matrix.c`.
+
+Add a new file to your keyboard directory:
+```text
+keyboards/<keyboard>/matrix.c
+```
+
+And to configure compilation for the new file, add this to your `rules.mk`:
+```make
+SRC += matrix.c
+```
+
+## 'lite'
+
+Provides a default implementation for various scanning functions, reducing the boilerplate code when implementing custom matrix.
+To configure it, add this to your `rules.mk`:
+
+```make
+CUSTOM_MATRIX = lite
+```
+
+And implement the following functions in a `matrix.c` file in your keyboard folder:
+
+```c
+void matrix_init_custom(void) {
+    // TODO: initialize hardware here
+}
+
+bool matrix_scan_custom(matrix_row_t current_matrix[]) {
+    bool matrix_has_changed = false;
+
+    // TODO: add matrix scanning routine here
+
+    return matrix_has_changed;
+}
+```
+
+
+## Full Replacement
+
+When more control over the scanning routine is required, you can choose to implement the full scanning routine.
+To configure it, add this to your rules.mk:
+
+```make
+CUSTOM_MATRIX = yes
+```
+
+And implement the following functions in a `matrix.c` file in your keyboard folder:
+
+```c
+matrix_row_t matrix_get_row(uint8_t row) {
+    // TODO: return the requested row data
+}
+
+void matrix_print(void) {
+    // TODO: use print() to dump the current matrix state to console
+}
+
+void matrix_init(void) {
+    // TODO: initialize hardware and global matrix state here
+
+    // Unless hardware debouncing - Init the configured debounce routine
+    debounce_init(MATRIX_ROWS);
+
+    // This *must* be called for correct keyboard behavior
+    matrix_init_quantum();
+}
+
+uint8_t matrix_scan(void) {
+    bool matrix_has_changed = false;
+
+    // TODO: add matrix scanning routine here
+
+    // Unless hardware debouncing - use the configured debounce routine
+    debounce(raw_matrix, matrix, MATRIX_ROWS, changed);
+
+    // This *must* be called for correct keyboard behavior
+    matrix_scan_quantum();
+
+    return matrix_has_changed;
+}
+```
+
+And also provide defaults for the following callbacks:
+
+```c
+__attribute__((weak)) void matrix_init_kb(void) { matrix_init_user(); }
+
+__attribute__((weak)) void matrix_scan_kb(void) { matrix_scan_user(); }
+
+__attribute__((weak)) void matrix_init_user(void) {}
+
+__attribute__((weak)) void matrix_scan_user(void) {}
+```

docs/custom_quantum_functions.md

@@ -114,7 +114,15 @@ Two more deprecated functions exist that provide the LED state as a `uint8_t`:
 
 This function will be called when the state of one of those 5 LEDs changes. It receives the LED state as a struct parameter.
 
-You must return either `true` or `false` from this function, depending on whether you want to override the keyboard-level implementation.
+By convention, return `true` from `led_update_user()` to get the `led_update_kb()` hook to run its code, and
+return `false` when you would prefer not to run the code in `led_update_kb()`.
+
+Some examples include:
+
+  - overriding the LEDs to use them for something else like layer indication
+    - return `false` because you do not want the `_kb()` function to run, as it would override your layer behavior.
+  - play a sound when an LED turns on or off.
+    - return `true` because you want the `_kb` function to run, and this is in addition to the default LED behavior.
 
 ?> Because the `led_set_*` functions return `void` instead of `bool`, they do not allow for overriding the keyboard LED control, and thus it's recommended to use `led_update_*` instead.
 
@@ -122,66 +130,41 @@ You must return either `true` or `false` from this function, depending on whethe
 
 ```c
 bool led_update_kb(led_t led_state) {
-    if(led_update_user(led_state)) {
-        if (led_state.num_lock) {
-            writePinLow(B0);
-        } else {
-            writePinHigh(B0);
-        }
-        if (led_state.caps_lock) {
-            writePinLow(B1);
-        } else {
-            writePinHigh(B1);
-        }
-        if (led_state.scroll_lock) {
-            writePinLow(B2);
-        } else {
-            writePinHigh(B2);
-        }
-        if (led_state.compose) {
-            writePinLow(B3);
-        } else {
-            writePinHigh(B3);
-        }
-        if (led_state.kana) {
-            writePinLow(B4);
-        } else {
-            writePinHigh(B4);
-        }
-        return true;
+    bool res = led_update_user(led_state);
+    if(res) {
+        // writePin sets the pin high for 1 and low for 0.
+        // In this example the pins are inverted, setting
+        // it low/0 turns it on, and high/1 turns the LED off.
+        // This behavior depends on whether the LED is between the pin
+        // and VCC or the pin and GND.
+        writePin(B0, !led_state.num_lock);
+        writePin(B1, !led_state.caps_lock);
+        writePin(B2, !led_state.scroll_lock);
+        writePin(B3, !led_state.compose);
+        writePin(B4, !led_state.kana);
     }
+    return res;
 }
 ```
 
 ### Example `led_update_user()` Implementation
 
+This incomplete example would play a sound if Caps Lock is turned on or off. It returns `true`, because you also want the LEDs to maintain their state.
+
 ```c
+#ifdef AUDIO_ENABLE
+  float caps_on[][2] = SONG(CAPS_LOCK_ON_SOUND);
+  float caps_off[][2] = SONG(CAPS_LOCK_OFF_SOUND);
+#endif
+
 bool led_update_user(led_t led_state) {
-    if (led_state.num_lock) {
-        writePinLow(B0);
-    } else {
-        writePinHigh(B0);
-    }
-    if (led_state.caps_lock) {
-        writePinLow(B1);
-    } else {
-        writePinHigh(B1);
-    }
-    if (led_state.scroll_lock) {
-        writePinLow(B2);
-    } else {
-        writePinHigh(B2);
-    }
-    if (led_state.compose) {
-        writePinLow(B3);
-    } else {
-        writePinHigh(B3);
-    }
-    if (led_state.kana) {
-        writePinLow(B4);
-    } else {
-        writePinHigh(B4);
+    #ifdef AUDIO_ENABLE
+    static uint8_t caps_state = 0;
+    if (caps_state != led_state.caps_lock) {
+        led_state.caps_lock ? PLAY_SONG(caps_on) : PLAY_SONG(caps_off);
+        caps_state = led_state.caps_lock;
     }
+    #endif
     return true;
 }
 ```
@@ -411,7 +394,7 @@ void keyboard_post_init_user(void) {
   // Set default layer, if enabled
   if (user_config.rgb_layer_change) {
     rgblight_enable_noeeprom();
-    rgblight_sethsv_noeeprom_cyan(); 
+    rgblight_sethsv_noeeprom_cyan();
     rgblight_mode_noeeprom(1);
   }
 }
@@ -459,18 +442,18 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
         }
         return true; // Let QMK send the enter press/release events
     case RGB_LYR:  // This allows me to use underglow as layer indication, or as normal
-        if (record->event.pressed) { 
+        if (record->event.pressed) {
             user_config.rgb_layer_change ^= 1; // Toggles the status
             eeconfig_update_user(user_config.raw); // Writes the new status to EEPROM
-            if (user_config.rgb_layer_change) { // if layer state indication is enabled, 
+            if (user_config.rgb_layer_change) { // if layer state indication is enabled,
                 layer_state_set(layer_state);   // then immediately update the layer color
             }
         }
         return false; break;
     case RGB_MODE_FORWARD ... RGB_MODE_GRADIENT: // For any of the RGB codes (see quantum_keycodes.h, L400 for reference)
         if (record->event.pressed) { //This disables layer indication, as it's assumed that if you're changing this ... you want that disabled
-            if (user_config.rgb_layer_change) {        // only if this is enabled 
-                user_config.rgb_layer_change = false;  // disable it, and 
+            if (user_config.rgb_layer_change) {        // only if this is enabled
+                user_config.rgb_layer_change = false;  // disable it, and
                 eeconfig_update_user(user_config.raw); // write the setings to EEPROM
             }
         }
@@ -483,7 +466,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
 And lastly, you want to add the `eeconfig_init_user` function, so that when the EEPROM is reset, you can specify default values, and even custom actions. To force an EEPROM reset, use the `EEP_RST` keycode or [Bootmagic](feature_bootmagic.md) functionallity. For example, if you want to set rgb layer indication by default, and save the default valued. 
 
 ```c
-void eeconfig_init_user(void) {  // EEPROM is getting reset! 
+void eeconfig_init_user(void) {  // EEPROM is getting reset!
   user_config.raw = 0;
   user_config.rgb_layer_change = true; // We want this enabled by default
   eeconfig_update_user(user_config.raw); // Write default value to EEPROM now
@@ -506,14 +489,24 @@ The `val` is the value of the data that you want to write to EEPROM.  And the `e
 
 # Custom Tapping Term
 
-By default, the tapping term is defined globally, and is not configurable by key.  For most users, this is perfectly fine.  But in come cases, dual function keys would be greatly improved by different timeouts than `LT` keys, or because some keys may be easier to hold than others.  Instead of using custom key codes for each, this allows for per key configurable `TAPPING_TERM`.
+By default, the tapping term and related options (such as `IGNORE_MOD_TAP_INTERRUPT`) are defined globally, and are not configurable by key.  For most users, this is perfectly fine.  But in some cases, dual function keys would be greatly improved by different timeout behaviors than `LT` keys, or because some keys may be easier to hold than others.  Instead of using custom key codes for each, this allows for per key configurable timeout behaviors.
 
-To enable this functionality, you need to add `#define TAPPING_TERM_PER_KEY` to your `config.h`, first.  
+There are two configurable options to control per-key timeout behaviors:
+
+- `TAPPING_TERM_PER_KEY`
+- `IGNORE_MOD_TAP_INTERRUPT_PER_KEY`
+
+You need to add `#define` lines to your `config.h` for each feature you want.
+
+```
+#define TAPPING_TERM_PER_KEY
+#define IGNORE_MOD_TAP_INTERRUPT_PER_KEY
+```
 
 
 ## Example `get_tapping_term` Implementation
 
-To change the `TAPPING TERM` based on the keycode, you'd want to add something like the following to your `keymap.c` file: 
+To change the `TAPPING_TERM` based on the keycode, you'd want to add something like the following to your `keymap.c` file:
 
 ```c
 uint16_t get_tapping_term(uint16_t keycode) {
@@ -528,6 +521,21 @@ uint16_t get_tapping_term(uint16_t keycode) {
 }
 ```
 
-### `get_tapping_term` Function Documentation
+## Example `get_ignore_mod_tap_interrupt` Implementation
 
-Unlike many of the other functions here, there isn't a need (or even reason) to have a quantum or keyboard level function. Only a user level function is useful here, so no need to mark it as such.
+To change the `IGNORE_MOD_TAP_INTERRUPT` value based on the keycode, you'd want to add something like the following to your `keymap.c` file:
+
+```c
+bool get_ignore_mod_tap_interrupt(uint16_t keycode) {
+  switch (keycode) {
+    case SFT_T(KC_SPC):
+      return true;
+    default:
+      return false;
+  }
+}
+```
+
+## `get_tapping_term` / `get_ignore_mod_tap_interrupt` Function Documentation
+
+Unlike many of the other functions here, there isn't a need (or even reason) to have a quantum or keyboard level function. Only user level functions are useful here, so no need to mark them as such.

docs/de/_summary.md

@@ -111,7 +111,7 @@
   * [Support](de/support.md)
   * [Übersetzungen](de/translating.md)
 
-* QMK Internals (de/In Progress)
+* QMK Internals (In Progress)
   * [Defines](de/internals_defines.md)
   * [Input Callback Reg](de/internals_input_callback_reg.md)
   * [Midi Device](de/internals_midi_device.md)

docs/eeprom_driver.md

@@ -0,0 +1,50 @@
+# EEPROM Driver Configuration
+
+The EEPROM driver can be swapped out depending on the needs of the keyboard, or whether extra hardware is present.
+
+Driver                      | Description
+--------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+`EEPROM_DRIVER = vendor`    | Uses the on-chip driver provided by the chip manufacturer. For AVR, this is provided by avr-libc. This is supported on ARM for a subset of chips -- STM32F3xx, STM32F1xx, and STM32F072xB will be emulated by writing to flash. Other chips will generally act as "transient" below.
+`EEPROM_DRIVER = i2c`       | Supports writing to I2C-based 24xx EEPROM chips. See the driver section below.
+`EEPROM_DRIVER = transient` | Fake EEPROM driver -- supports reading/writing to RAM, and will be discarded when power is lost.
+
+## Vendor Driver Configuration
+
+No configurable options are available.
+
+## I2C Driver Configuration
+
+Currently QMK supports 24xx-series chips over I2C. As such, requires a working i2c_master driver configuration. You can override the driver configuration via your config.h:
+
+`config.h` override                         | Description                                                                         | Default Value
+------------------------------------------- | ----------------------------------------------------------------------------------- | ------------------------------------
+`#define EXTERNAL_EEPROM_I2C_BASE_ADDRESS`  | Base I2C address for the EEPROM -- shifted left by 1 as per i2c_master requirements | 0b10100000
+`#define EXTERNAL_EEPROM_I2C_ADDRESS(addr)` | Calculated I2C address for the EEPROM                                               | `(EXTERNAL_EEPROM_I2C_BASE_ADDRESS)`
+`#define EXTERNAL_EEPROM_BYTE_COUNT`        | Total size of the EEPROM in bytes                                                   | 8192
+`#define EXTERNAL_EEPROM_PAGE_SIZE`         | Page size of the EEPROM in bytes, as specified in the datasheet                     | 32
+`#define EXTERNAL_EEPROM_ADDRESS_SIZE`      | The number of bytes to transmit for the memory location within the EEPROM           | 2
+`#define EXTERNAL_EEPROM_WRITE_TIME`        | Write cycle time of the EEPROM, as specified in the datasheet                       | 5
+
+Default values and extended descriptions can be found in `drivers/eeprom/eeprom_i2c.h`.
+
+Alternatively, there are pre-defined hardware configurations for available chips/modules:
+
+Module           | Equivalent `#define`            | Source
+-----------------|---------------------------------|------------------------------------------
+CAT24C512 EEPROM | `#define EEPROM_I2C_CAT24C512`  | <https://www.sparkfun.com/products/14764>
+RM24C512C EEPROM | `#define EEPROM_I2C_RM24C512C`  | <https://www.sparkfun.com/products/14764>
+24LC128 EEPROM   | `#define EEPROM_I2C_24LC128`    | <https://www.microchip.com/wwwproducts/en/24LC128>
+24LC256 EEPROM   | `#define EEPROM_I2C_24LC256`    | <https://www.sparkfun.com/products/525>
+MB85RC256V FRAM  | `#define EEPROM_I2C_MB85RC256V` | <https://www.adafruit.com/product/1895>
+
+?> If you find that the EEPROM is not cooperating, ensure you've correctly shifted up your EEPROM address by 1. For example, the datasheet might state the address as `0b01010000` -- the correct value of `EXTERNAL_EEPROM_I2C_BASE_ADDRESS` needs to be `0b10100000`.
+
+## Transient Driver configuration
+
+The only configurable item for the transient EEPROM driver is its size:
+
+`config.h` override             | Description                               | Default Value
+------------------------------- | ----------------------------------------- | -------------
+`#define TRANSIENT_EEPROM_SIZE` | Total size of the EEPROM storage in bytes | 64
+
+Default values and extended descriptions can be found in `drivers/eeprom/eeprom_transient.h`.

docs/es/README.md

@@ -19,7 +19,7 @@ De cualquier manera, también puedes descargarlo directamente en formatos ([zip]
 
 ## Cómo compilar
 
-Antes de poder compilar, necesitarás [instalar un entorno](getting_started_build_tools.md) para el desarrollo de AVR y/o ARM. Una vez hayas completado este paso, usarás el comando `make` para compilar un teclado y keymap con la siguiente notación:
+Antes de poder compilar, necesitarás [instalar un entorno](es/getting_started_build_tools.md) para el desarrollo de AVR y/o ARM. Una vez hayas completado este paso, usarás el comando `make` para compilar un teclado y keymap con la siguiente notación:
 
     make planck/rev4:default
 
@@ -29,4 +29,4 @@ Este ejemplo compilaría la revisión `rev4` del teclado `planck` con el keymap
 
 ## Cómo personalizar
 
-QMK tiene montones de [características](features.md) para explorar, y una buena cantidad de [documentación de referencia](http://docs.qmk.fm) en la que sumergirse. Se pueden sacar provecho de la mayoría de las características modificando tu [keymap](keymap.md), y cambiando los [keycodes](keycodes.md).
+QMK tiene montones de [características](es/features.md) para explorar, y una buena cantidad de [documentación de referencia](http://docs.qmk.fm) en la que sumergirse. Se pueden sacar provecho de la mayoría de las características modificando tu [keymap](es/keymap.md), y cambiando los [keycodes](es/keycodes.md).

docs/es/_summary.md

@@ -1,121 +1,121 @@
-* [Guía completa para novatos](newbs.md)
-  * [Empezando](newbs_getting_started.md)
-  * [Construyendo tu primer firmare](newbs_building_firmware.md)
-  * [Flasheando el firmware](newbs_flashing.md)
-  * [Testeando y depurando ](newbs_testing_debugging.md)
-  * [Mejores práticas](newbs_best_practices.md)
-  * [Recursos de aprendizaje](newbs_learn_more_resources.md)
+* [Guía completa para novatos](es/newbs.md)
+  * [Empezando](es/newbs_getting_started.md)
+  * [Construyendo tu primer firmare](es/newbs_building_firmware.md)
+  * [Flasheando el firmware](es/newbs_flashing.md)
+  * [Testeando y depurando ](es/newbs_testing_debugging.md)
+  * [Mejores práticas](es/newbs_best_practices.md)
+  * [Recursos de aprendizaje](es/newbs_learn_more_resources.md)
 
-* [QMK Basics](README.md)
-  * [Introducción a QMK](getting_started_introduction.md)
-  * [QMK CLI](cli.md)
-  * [Configuración de QMK CLI](cli_configuration.md)
-  * [Contribuyendo a QMK](contributing.md)
-  * [Cómo usar Github](getting_started_github.md)
-  * [Obtener ayuda](getting_started_getting_help.md)
+* [QMK Basics](es/README.md)
+  * [Introducción a QMK](es/getting_started_introduction.md)
+  * [QMK CLI](es/cli.md)
+  * [Configuración de QMK CLI](es/cli_configuration.md)
+  * [Contribuyendo a QMK](es/contributing.md)
+  * [Cómo usar Github](es/getting_started_github.md)
+  * [Obtener ayuda](es/getting_started_getting_help.md)
 
-* [Cambios incompatibles](breaking_changes.md)
-  * [30 Ago 2019](ChangeLog/20190830.md)
+* [Cambios incompatibles](es/breaking_changes.md)
+  * [30 Ago 2019](es/ChangeLog/20190830.md)
 
-* [Preguntas frecuentes](faq.md)
-  * [General](faq_general.md)
-  * [Construir/Compilar QMK](faq_build.md)
-  * [Depurando/Encontrando problemas en QMK](faq_debug.md)
-  * [Keymap](faq_keymap.md)
-  * [Instalación de drivers con Zadig](driver_installation_zadig.md)
+* [Preguntas frecuentes](es/faq.md)
+  * [General](es/faq_general.md)
+  * [Construir/Compilar QMK](es/faq_build.md)
+  * [Depurando/Encontrando problemas en QMK](es/faq_debug.md)
+  * [Keymap](es/faq_keymap.md)
+  * [Instalación de drivers con Zadig](es/driver_installation_zadig.md)
 
 * Guías detalladas
-  * [Instalar herramientas construcción](getting_started_build_tools.md)
-  * [Guía Vagrant](getting_started_vagrant.md)
-  * [Instrucciones de Construcción/Compilado](getting_started_make_guide.md)
-  * [Flasheando Firmware](flashing.md)
-  * [Personalizando funcionalidad](custom_quantum_functions.md)
-  * [Visión general del Keymap](keymap.md)
+  * [Instalar herramientas construcción](es/getting_started_build_tools.md)
+  * [Guía Vagrant](es/getting_started_vagrant.md)
+  * [Instrucciones de Construcción/Compilado](es/getting_started_make_guide.md)
+  * [Flasheando Firmware](es/flashing.md)
+  * [Personalizando funcionalidad](es/custom_quantum_functions.md)
+  * [Visión general del Keymap](es/keymap.md)
 
-* [Hardware](hardware.md)
-  * [Procesadores AVR](hardware_avr.md)
-  * [Drivers](hardware_drivers.md)
+* [Hardware](es/hardware.md)
+  * [Procesadores AVR](es/hardware_avr.md)
+  * [Drivers](es/hardware_drivers.md)
 
 * Referencia
-  * [Pautas de teclados](hardware_keyboard_guidelines.md)
-  * [Opciones de configuración](config_options.md)
-  * [Keycodes](keycodes.md)
-  * [Convenciones de código - C](coding_conventions_c.md)
-  * [Convenciones de código - Python](coding_conventions_python.md)
-  * [Mejores prácticas de documentación](documentation_best_practices.md)
-  * [Plantillas de documentación](documentation_templates.md)
-  * [Glosario](reference_glossary.md)
-  * [Tests unitarios](unit_testing.md)
-  * [Funciones útiles](ref_functions.md)
-  * [Sporte configurador](reference_configurator_support.md)
-  * [Formato info.json](reference_info_json.md)
-  * [Desarrollo Python CLI](cli_development.md)
+  * [Pautas de teclados](es/hardware_keyboard_guidelines.md)
+  * [Opciones de configuración](es/config_options.md)
+  * [Keycodes](es/keycodes.md)
+  * [Convenciones de código - C](es/coding_conventions_c.md)
+  * [Convenciones de código - Python](es/coding_conventions_python.md)
+  * [Mejores prácticas de documentación](es/documentation_best_practices.md)
+  * [Plantillas de documentación](es/documentation_templates.md)
+  * [Glosario](es/reference_glossary.md)
+  * [Tests unitarios](es/unit_testing.md)
+  * [Funciones útiles](es/ref_functions.md)
+  * [Sporte configurador](es/reference_configurator_support.md)
+  * [Formato info.json](es/reference_info_json.md)
+  * [Desarrollo Python CLI](es/cli_development.md)
 
-* [Características](features.md)
-  * [Keycodes Básicos](keycodes_basic.md)
-  * [Teclas US ANSI Shifted](keycodes_us_ansi_shifted.md)
-  * [Keycodes Quantum](quantum_keycodes.md)
-  * [Keycodes Avanzados](feature_advanced_keycodes.md)
-  * [Audio](feature_audio.md)
-  * [Auto Shift](feature_auto_shift.md)
-  * [Retroiluminación](feature_backlight.md)
-  * [Bluetooth](feature_bluetooth.md)
-  * [Bootmagic](feature_bootmagic.md)
-  * [Combos](feature_combo.md)
-  * [Comando](feature_command.md)
-  * [API Debounce](feature_debounce_type.md)
-  * [Switch DIP](feature_dip_switch.md)
-  * [Macros Dinámicas](feature_dynamic_macros.md)
-  * [Encoders](feature_encoders.md)
-  * [Grave Escape](feature_grave_esc.md)
-  * [Feedback Háptico](feature_haptic_feedback.md)
-  * [Controlador LCD HD44780](feature_hd44780.md)
-  * [Key Lock](feature_key_lock.md)
-  * [Layouts](feature_layouts.md)
-  * [Tecla Leader](feature_leader_key.md)
-  * [Matriz LED](feature_led_matrix.md)
-  * [Macros](feature_macros.md)
-  * [Teclas del ratón](feature_mouse_keys.md)
-  * [Driver OLED](feature_oled_driver.md)
-  * [Teclas One Shot](feature_advanced_keycodes.md#one-shot-keys)
-  * [Dispositivo de apuntado](feature_pointing_device.md)
-  * [Ratón PS/2](feature_ps2_mouse.md)
-  * [Iluminación RGB](feature_rgblight.md)
-  * [Matriz RGB](feature_rgb_matrix.md)
-  * [Cadete espacial](feature_space_cadet.md)
-  * [Teclado dividido](feature_split_keyboard.md)
-  * [Stenografía](feature_stenography.md)
-  * [Swap Hands](feature_swap_hands.md)
-  * [Tap Dance](feature_tap_dance.md)
-  * [Terminal](feature_terminal.md)
-  * [Impresora Térmica](feature_thermal_printer.md)
-  * [Unicode](feature_unicode.md)
-  * [Userspace](feature_userspace.md)
-  * [Velocikey](feature_velocikey.md)
+* [Características](es/features.md)
+  * [Keycodes Básicos](es/keycodes_basic.md)
+  * [Teclas US ANSI Shifted](es/keycodes_us_ansi_shifted.md)
+  * [Keycodes Quantum](es/quantum_keycodes.md)
+  * [Keycodes Avanzados](es/feature_advanced_keycodes.md)
+  * [Audio](es/feature_audio.md)
+  * [Auto Shift](es/feature_auto_shift.md)
+  * [Retroiluminación](es/feature_backlight.md)
+  * [Bluetooth](es/feature_bluetooth.md)
+  * [Bootmagic](es/feature_bootmagic.md)
+  * [Combos](es/feature_combo.md)
+  * [Comando](es/feature_command.md)
+  * [API Debounce](es/feature_debounce_type.md)
+  * [Switch DIP](es/feature_dip_switch.md)
+  * [Macros Dinámicas](es/feature_dynamic_macros.md)
+  * [Encoders](es/feature_encoders.md)
+  * [Grave Escape](es/feature_grave_esc.md)
+  * [Feedback Háptico](es/feature_haptic_feedback.md)
+  * [Controlador LCD HD44780](es/feature_hd44780.md)
+  * [Key Lock](es/feature_key_lock.md)
+  * [Layouts](es/feature_layouts.md)
+  * [Tecla Leader](es/feature_leader_key.md)
+  * [Matriz LED](es/feature_led_matrix.md)
+  * [Macros](es/feature_macros.md)
+  * [Teclas del ratón](es/feature_mouse_keys.md)
+  * [Driver OLED](es/feature_oled_driver.md)
+  * [Teclas One Shot](es/feature_advanced_keycodes.md#one-shot-keys)
+  * [Dispositivo de apuntado](es/feature_pointing_device.md)
+  * [Ratón PS/2](es/feature_ps2_mouse.md)
+  * [Iluminación RGB](es/feature_rgblight.md)
+  * [Matriz RGB](es/feature_rgb_matrix.md)
+  * [Cadete espacial](es/feature_space_cadet.md)
+  * [Teclado dividido](es/feature_split_keyboard.md)
+  * [Stenografía](es/feature_stenography.md)
+  * [Swap Hands](es/feature_swap_hands.md)
+  * [Tap Dance](es/feature_tap_dance.md)
+  * [Terminal](es/feature_terminal.md)
+  * [Impresora Térmica](es/feature_thermal_printer.md)
+  * [Unicode](es/feature_unicode.md)
+  * [Userspace](es/feature_userspace.md)
+  * [Velocikey](es/feature_velocikey.md)
 
 * Para Makers y Modders
-  * [Guía de cableado a mano](hand_wire.md)
-  * [Guía de flasheado de ISP](isp_flashing_guide.md)
-  * [Guía de depuración de ARM](arm_debugging.md)
-  * [Driver I2C](i2c_driver.md)
-  * [Controles GPIO](internals_gpio_control.md)
-  * [Conversión Proton C](proton_c_conversion.md)
+  * [Guía de cableado a mano](es/hand_wire.md)
+  * [Guía de flasheado de ISP](es/isp_flashing_guide.md)
+  * [Guía de depuración de ARM](es/arm_debugging.md)
+  * [Driver I2C](es/i2c_driver.md)
+  * [Controles GPIO](es/internals_gpio_control.md)
+  * [Conversión Proton C](es/proton_c_conversion.md)
 
 * Para entender en profundidad
-  * [Cómo funcionan los teclados](how_keyboards_work.md)
-  * [Entendiendo QMK](understanding_qmk.md)
+  * [Cómo funcionan los teclados](es/how_keyboards_work.md)
+  * [Entendiendo QMK](es/understanding_qmk.md)
 
 * Otros temas
-  * [Usando Eclipse con QMK](other_eclipse.md)
-  * [Usando VSCode con QMK](other_vscode.md)
-  * [Soporte](support.md)
-  * [Cómo añadir traducciones](translating.md)
+  * [Usando Eclipse con QMK](es/other_eclipse.md)
+  * [Usando VSCode con QMK](es/other_vscode.md)
+  * [Soporte](es/support.md)
+  * [Cómo añadir traducciones](es/translating.md)
 
 * QMK Internals (En progreso)
-  * [Defines](internals_defines.md)
-  * [Input Callback Reg](internals_input_callback_reg.md)
-  * [Dispositivo Midi](internals_midi_device.md)
-  * [Proceso de configuración de un dispositivo Midi](internals_midi_device_setup_process.md)
-  * [Utilidad Midi](internals_midi_util.md)
-  * [Funciones Send](internals_send_functions.md)
-  * [Herramientas Sysex](internals_sysex_tools.md)
+  * [Defines](es/internals_defines.md)
+  * [Input Callback Reg](es/internals_input_callback_reg.md)
+  * [Dispositivo Midi](es/internals_midi_device.md)
+  * [Proceso de configuración de un dispositivo Midi](es/internals_midi_device_setup_process.md)
+  * [Utilidad Midi](es/internals_midi_util.md)
+  * [Funciones Send](es/internals_send_functions.md)
+  * [Herramientas Sysex](es/internals_sysex_tools.md)

docs/faq_build.md

@@ -47,7 +47,7 @@ SUBSYSTEMS=="usb", ATTRS{idVendor}=="feed", MODE:="0666"
 SUBSYSTEMS=="usb", ATTRS{idVendor}=="1c11", MODE:="0666"
 ```
 
-**/etc/udev/rules.d/55-catalina.rules:**
+**/etc/udev/rules.d/55-caterina.rules:**
 ```
 # ModemManager should ignore the following devices
 ATTRS{idVendor}=="2a03", ENV{ID_MM_DEVICE_IGNORE}="1"
@@ -69,6 +69,12 @@ SUBSYSTEMS=="usb", ATTRS{idVendor}=="1eaf", ATTRS{idProduct}=="0003", MODE:="066
 SUBSYSTEMS=="usb", ATTRS{idVendor}=="0483", ATTRS{idProduct}=="df11", MODE:="0666"
 ```
 
+**/etc/udev/rules.d/57-bootloadhid.rules:**
+```
+# bootloadHID
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="16c0", ATTRS{idProduct}=="05df", 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.
@@ -81,10 +87,6 @@ Re-running the QMK installation script (`./util/qmk_install.sh` from the `qmk_fi
 
 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.
-See [TMK Issue #99](https://github.com/tmk/tmk_keyboard/issues/99).
-
 ## USB VID and PID
 You can use any ID you want with editing `config.h`. Using any presumably unused ID will be no problem in fact except for very low chance of collision with other product.
 
@@ -97,29 +99,6 @@ You can buy a really unique VID:PID here. I don't think you need this for person
 - http://www.obdev.at/products/vusb/license.html
 - http://www.mcselec.com/index.php?page=shop.product_details&flypage=shop.flypage&product_id=92&option=com_phpshop&Itemid=1
 
-## Cortex: `cstddef: No such file or directory`
-GCC 4.8 of Ubuntu 14.04 had this problem and had to update to 4.9 with this PPA.
-https://launchpad.net/~terry.guo/+archive/ubuntu/gcc-arm-embedded
-
-https://github.com/tmk/tmk_keyboard/issues/212
-https://github.com/tmk/tmk_keyboard/wiki/mbed-cortex-porting#compile-error-cstddef
-https://developer.mbed.org/forum/mbed/topic/5205/
-
-## `clock_prescale_set` and `clock_div_1` Not Available
-Your toolchain is too old to support the MCU. For example WinAVR 20100110 doesn't support ATMega32u2.
-
-```
-Compiling C: ../../tmk_core/protocol/lufa/lufa.c
-avr-gcc -c -mmcu=atmega32u2 -gdwarf-2 -DF_CPU=16000000UL -DINTERRUPT_CONTROL_ENDPOINT -DBOOTLOADER_SIZE=4096 -DF_USB=16000000UL -DARCH=ARCH_AVR8 -DUSB_DEVICE_ONLY -DUSE_FLASH_DESCRIPTORS -DUSE_STATIC_OPTIONS="(USB_DEVICE_OPT_FULLSPEED | USB_OPT_REG_ENABLED | USB_OPT_AUTO_PLL)" -DFIXED_CONTROL_ENDPOINT_SIZE=8  -DFIXED_NUM_CONFIGURATIONS=1 -DPROTOCOL_LUFA -DEXTRAKEY_ENABLE -DCONSOLE_ENABLE -DCOMMAND_ENABLE -DVERSION=unknown -Os -funsigned-char -funsigned-bitfields -ffunction-sections -fdata-sections -fno-inline-small-functions -fpack-struct -fshort-enums -fno-strict-aliasing -Wall -Wstrict-prototypes -Wa,-adhlns=obj_alps64/protocol/lufa/lufa.lst -I. -I../../tmk_core -I../../tmk_core/protocol/lufa -I../../tmk_core/protocol/lufa/LUFA-git -I../../tmk_core/common -std=gnu99 -include config.h -MMD -MP -MF .dep/obj_alps64_protocol_lufa_lufa.o.d  ../../tmk_core/protocol/lufa/lufa.c -o obj_alps64/protocol/lufa/lufa.o
-../../tmk_core/protocol/lufa/lufa.c: In function 'setup_mcu':
-../../tmk_core/protocol/lufa/lufa.c:575: warning: implicit declaration of function 'clock_prescale_set'
-../../tmk_core/protocol/lufa/lufa.c:575: error: 'clock_div_1' undeclared (first use in this function)
-../../tmk_core/protocol/lufa/lufa.c:575: error: (Each undeclared identifier is reported only once
-../../tmk_core/protocol/lufa/lufa.c:575: error: for each function it appears in.)
-make: *** [obj_alps64/protocol/lufa/lufa.o] Error 1
-```
-
-
 ## BOOTLOADER_SIZE for AVR
 Note that Teensy2.0++ bootloader size is 2048byte. Some Makefiles may have wrong comment.
 
@@ -140,24 +119,29 @@ The solution is to remove and reinstall all affected modules.
 
 ```
 brew rm avr-gcc
+brew rm avr-gcc@8
 brew rm dfu-programmer
 brew rm dfu-util
 brew rm gcc-arm-none-eabi
+brew rm arm-gcc-bin@8
 brew rm avrdude
-brew install avr-gcc
+brew install avr-gcc@8
 brew install dfu-programmer
 brew install dfu-util
-brew install gcc-arm-none-eabi
+brew install arm-gcc-bin@8
 brew install avrdude
+brew link --force avr-gcc@8
+brew link --force arm-gcc-bin@8
+
 ```
 
-### avr-gcc 8.1 and LUFA
+### `avr-gcc` and LUFA
 
-If you updated your avr-gcc to above 7 you may see errors involving LUFA. For example:
+If you updated your `avr-gcc` and you see errors involving LUFA, for example:
 
 `lib/lufa/LUFA/Drivers/USB/Class/Device/AudioClassDevice.h:380:5: error: 'const' attribute on function returning 'void'`
 
-For now, you need to rollback avr-gcc to 7 in brew.
+For now, you need to rollback `avr-gcc` to 8 in Homebrew.
 
 ```
 brew uninstall --force avr-gcc

docs/faq_debug.md

@@ -112,56 +112,6 @@ In C `1` means one of [int] type which is [16 bit] in case of AVR so you can't s
 
 http://deskthority.net/workshop-f7/rebuilding-and-redesigning-a-classic-thinkpad-keyboard-t6181-60.html#p146279
 
-
-## Bootloader Jump Doesn't Work
-Properly configure bootloader size in **Makefile**. With wrong section size bootloader won't probably start with **Magic command** and **Boot Magic**.
-```
-# Size of Bootloaders in bytes:
-#   Atmel DFU loader(ATmega32U4)   4096
-#   Atmel DFU loader(AT90USB128)   8192
-#   LUFA bootloader(ATmega32U4)    4096
-#   Arduino Caterina(ATmega32U4)   4096
-#   USBaspLoader(ATmega***)        2048
-#   Teensy   halfKay(ATmega32U4)   512
-#   Teensy++ halfKay(AT90USB128)   2048
-OPT_DEFS += -DBOOTLOADER_SIZE=4096
-```
-AVR Boot section size are defined by setting **BOOTSZ** fuse in fact. Consult with your MCU datasheet.
-Note that **Word**(2 bytes) size and address are used in datasheet while TMK uses **Byte**.
-
-AVR Boot section is located at end of Flash memory like the followings.
-```
-byte     Atmel/LUFA(ATMega32u4)          byte     Atmel(AT90SUB1286)
-0x0000   +---------------+               0x00000  +---------------+
-         |               |                        |               |
-         |               |                        |               |
-         |  Application  |                        |  Application  |
-         |               |                        |               |
-         =               =                        =               =
-         |               | 32KB-4KB               |               | 128KB-8KB
-0x6000   +---------------+               0x1E000  +---------------+
-         |  Bootloader   | 4KB                    |  Bootloader   | 8KB
-0x7FFF   +---------------+               0x1FFFF  +---------------+
-
-
-byte     Teensy(ATMega32u4)              byte     Teensy++(AT90SUB1286)
-0x0000   +---------------+               0x00000  +---------------+
-         |               |                        |               |
-         |               |                        |               |
-         |  Application  |                        |  Application  |
-         |               |                        |               |
-         =               =                        =               =
-         |               | 32KB-512B              |               | 128KB-2KB
-0x7E00   +---------------+               0x1FC00  +---------------+
-         |  Bootloader   | 512B                   |  Bootloader   | 2KB
-0x7FFF   +---------------+               0x1FFFF  +---------------+
-```
-
-And see this discussion for further reference.
-https://github.com/tmk/tmk_keyboard/issues/179
-
-If you are using a TeensyUSB, there is a [known bug](https://github.com/qmk/qmk_firmware/issues/164) in which the hardware reset button prevents the RESET key from working. Unplugging the keyboard and plugging it back in should resolve the problem.
-
 ## Special Extra Key Doesn't Work (System, Audio Control Keys)
 You need to define `EXTRAKEY_ENABLE` in `rules.mk` to use them in QMK.
 
@@ -194,24 +144,6 @@ If you would like to keep JTAG enabled, just add the following to your `config.h
 #define NO_JTAG_DISABLE
 ```
 
-## Adding LED Indicators of Lock Keys
-You need your own LED indicators for CapsLock, ScrollLock and NumLock? See this post.
-
-http://deskthority.net/workshop-f7/tmk-keyboard-firmware-collection-t4478-120.html#p191560
-
-## Program Arduino Micro/Leonardo
-Push reset button and then run command like this within 8 seconds.
-
-```
-avrdude -patmega32u4 -cavr109 -b57600 -Uflash:w:adb_usb.hex -P/dev/ttyACM0
-```
-
-Device name will vary depending on your system.
-
-http://arduino.cc/en/Main/ArduinoBoardMicro
-https://geekhack.org/index.php?topic=14290.msg1563867#msg1563867
-
-
 ## USB 3 Compatibility
 I heard some people have a problem with USB 3 port, try USB 2 port.
 

docs/faq_keymap.md

@@ -67,24 +67,8 @@ After enabling this feature use keycodes `KC_LCAP`, `KC_LNUM` and `KC_LSCR` in y
 Old vintage mechanical keyboards occasionally have lock switches but modern ones don't have. ***You don't need this feature in most case and just use keycodes `KC_CAPS`, `KC_NLCK` and `KC_SLCK`.***
 
 ## Input Special Characters Other Than ASCII like Cédille 'Ç'
-NO UNIVERSAL METHOD TO INPUT THOSE WORKS OVER ALL SYSTEMS. You have to define **MACRO** in way specific to your OS or layout.
 
-See this post for example **MACRO** code.
-
-http://deskthority.net/workshop-f7/tmk-keyboard-firmware-collection-t4478-120.html#p195620
-
-On **Windows** you can use `AltGr` key or **Alt code**.
-* http://en.wikipedia.org/wiki/AltGr_key
-* http://en.wikipedia.org/wiki/Alt_code
-
-On **Mac** OS defines `Option` key combinations.
-* http://en.wikipedia.org/wiki/Option_key#Alternative_keyboard_input
-
-On **Xorg** you can use `compose` key, instead.
-* http://en.wikipedia.org/wiki/Compose_key
-
-And see this for **Unicode** input.
-* http://en.wikipedia.org/wiki/Unicode_input
+See the [Unicode](feature_unicode.md) feature.
 
 ## `Fn` Key on macOS
 
@@ -130,51 +114,6 @@ https://github.com/tekezo/Karabiner/issues/403
 
 See the [Grave Escape](feature_grave_esc.md) feature.
 
-## Arrow on Right Modifier Keys with Dual-Role
-This turns right modifier keys into arrow keys when the keys are tapped while still modifiers when the keys are hold. In TMK the dual-role function is dubbed **TAP**.
-```
-
-#include "keymap_common.h"
-
-
-/* Arrow keys on right modifier keys with TMK dual role feature
- *
- *  https://github.com/tmk/tmk_core/blob/master/doc/keymap.md#213-modifier-with-tap-keydual-role
- *  https://en.wikipedia.org/wiki/Modifier_key#Dual-role_keys
- */
-const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-    /* 0: qwerty */
-    [0] = LAYOUT( \
-        ESC, 1,   2,   3,   4,   5,   6,   7,   8,   9,   0,   MINS,EQL, NUHS,BSPC, \
-        TAB, Q,   W,   E,   R,   T,   Y,   U,   I,   O,   P,   LBRC,RBRC,BSLS, \
-        LCTL,A,   S,   D,   F,   G,   H,   J,   K,   L,   SCLN,QUOT,ENT,  \
-        LSFT,NUBS,Z,   X,   C,   V,   B,   N,   M,   COMM,DOT, SLSH,FN0, ESC, \
-        FN4, LGUI,LALT,          SPC,                     APP, FN2, FN1, FN3),
-    [1] = LAYOUT( \
-        GRV, F1,  F2,  F3,  F4,  F5,  F6,  F7,  F8,  F9,  F10, F11, F12, TRNS,TRNS, \
-        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,\
-        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \
-        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,FN5, TRNS, \
-        TRNS,TRNS,TRNS,          TRNS,                    TRNS,FN7, FN6, FN8),
-};
-
-const uint16_t PROGMEM fn_actions[] = {
-    [0] = ACTION_MODS_TAP_KEY(MOD_RSFT, KC_UP),
-    [1] = ACTION_MODS_TAP_KEY(MOD_RGUI, KC_DOWN),
-    [2] = ACTION_MODS_TAP_KEY(MOD_RALT, KC_LEFT),
-    [3] = ACTION_MODS_TAP_KEY(MOD_RCTL, KC_RIGHT),
-    [4] = ACTION_LAYER_MOMENTARY(1),
-    [5] = ACTION_MODS_TAP_KEY(MOD_RSFT, KC_PGUP),
-    [6] = ACTION_MODS_TAP_KEY(MOD_RGUI, KC_PGDN),
-    [7] = ACTION_MODS_TAP_KEY(MOD_RALT, KC_HOME),
-    [8] = ACTION_MODS_TAP_KEY(MOD_RCTL, KC_END),
-};
-
-```
-
-Dual-role key: https://en.wikipedia.org/wiki/Modifier_key#Dual-role_keys
-
-
 ## Eject on Mac OSX
 `KC_EJCT` keycode works on OSX. https://github.com/tmk/tmk_keyboard/issues/250
 It seems Windows 10 ignores the code and Linux/Xorg recognizes but has no mapping by default.

docs/feature_advanced_keycodes.md

@@ -155,7 +155,7 @@ You can control the behavior of one shot keys by defining these in `config.h`:
 
 Sometimes, you want to activate a one-shot key as part of a macro or tap dance routine.  
 
-For one shot layers, you need to call `set_oneshot_layer(LAYER, ONESHOT_START)` on key down, and `set_oneshot_layer(ONESHOT_PRESSED)` on key up. If you want to cancel the oneshot, call `reset_oneshot_layer()`.
+For one shot layers, you need to call `set_oneshot_layer(LAYER, ONESHOT_START)` on key down, and `clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED)` on key up. If you want to cancel the oneshot, call `reset_oneshot_layer()`.
 
 For one shot mods, you need to call `set_oneshot_mods(MOD)` to set it, or `clear_oneshot_mods()` to cancel it.
 
@@ -291,6 +291,25 @@ Normally, this would send `X` (`SHIFT`+`x`). With `Ignore Mod Tap Interrupt` ena
 
 ?> If you have `Permissive Hold` enabled, as well, this will modify how both work. The regular key has the modifier added if the first key is released first or if both keys are held longer than the `TAPPING_TERM`.
 
+For more granular control of this feature, you can add the following to your `config.h`:
+
+```c
+#define IGNORE_MOD_TAP_INTERRUPT_PER_KEY
+```
+
+You can then add the following function to your keymap:
+
+```c
+bool get_ignore_mod_tap_interrupt(uint16_t keycode) {
+  switch (keycode) {
+    case SFT_T(KC_SPC):
+      return true;
+    default:
+      return false;
+  }
+}
+```
+
 ## Tapping Force Hold
 
 To enable `tapping force hold`, add the following to your `config.h`: 
@@ -315,6 +334,25 @@ With `TAPPING_FORCE_HOLD`, the second press will be interpreted as a Shift, allo
 
 !> `TAPPING_FORCE_HOLD` will break anything that uses tapping toggles (Such as the `TT` layer keycode, and the One Shot Tapping Toggle).
 
+For more granular control of this feature, you can add the following to your `config.h`:
+
+```c
+#define TAPPING_FORCE_HOLD_PER_KEY
+```
+
+You can then add the following function to your keymap:
+
+```c
+bool get_tapping_force_hold(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+    case LT(1, KC_BSPC):
+      return true;
+    default:
+      return false;
+  }
+}
+```
+
 ## Retro Tapping
 
 To enable `retro tapping`, add the following to your `config.h`: 

docs/feature_backlight.md

@@ -6,16 +6,14 @@ QMK is able to control the brightness of these LEDs by switching them on and off
 
 The MCU can only supply so much current to its GPIO pins. Instead of powering the backlight directly from the MCU, the backlight pin is connected to a transistor or MOSFET that switches the power to the LEDs.
 
-## Driver configuration
+## Feature Configuration
 
 Most keyboards have backlighting enabled by default if they support it, but if it is not working for you, check that your `rules.mk` includes the following:
 
 ```makefile
-BACKLIGHT_ENABLE = software # Valid driver values are 'yes,software,no'
+BACKLIGHT_ENABLE = yes
 ```
 
-See below for help on individual drivers.
-
 ## Keycodes
 Once enabled the following keycodes below can be used to change the backlight level.
 
@@ -51,6 +49,16 @@ Once enabled the following keycodes below can be used to change the backlight le
 |`breathing_enable()`  |Turns on backlight breathing           |
 |`breathing_disable()` |Turns off backlight breathing          |
 
+## Driver Configuration
+
+To select which driver to use, configure your `rules.mk` with the following:
+
+```makefile
+BACKLIGHT_DRIVER = software # Valid driver values are 'pwm,software,no'
+```
+
+See below for help on individual drivers.
+
 ## Common Driver Configuration
 
 To change the behavior of the backlighting, `#define` these in your `config.h`:
@@ -72,9 +80,9 @@ This functionality is configured at the keyboard level with the `BACKLIGHT_ON_ST
 
 ## AVR driver
 
-On AVR boards, the default driver currently sniffs the configuration to pick the best scenario. To enable it, add this to your rules.mk:
+On AVR boards, the default driver currently sniffs the configuration to pick the best scenario. The driver is configured by default, however the equivalent setting within rules.mk would be:
 ```makefile
-BACKLIGHT_ENABLE = yes
+BACKLIGHT_DRIVER = pwm
 ```
 
 ### Caveats
@@ -150,9 +158,9 @@ The breathing effect is the same as in the hardware PWM implementation.
 
 ## ARM Driver
 
-While still in its early stages, ARM backlight support aims to eventually have feature parity with AVR. To enable it, add this to your rules.mk:
+While still in its early stages, ARM backlight support aims to eventually have feature parity with AVR. The driver is configured by default, however the equivalent setting within rules.mk would be:
 ```makefile
-BACKLIGHT_ENABLE = yes
+BACKLIGHT_DRIVER = pwm
 ```
 
 ### Caveats
@@ -176,7 +184,7 @@ To change the behavior of the backlighting, `#define` these in your `config.h`:
 
 Emulation of PWM while running other keyboard tasks, it offers maximum hardware compatibility without extra platform configuration. The tradeoff is the backlight might jitter when the keyboard is busy. To enable, add this to your rules.mk:
 ```makefile
-BACKLIGHT_ENABLE = software
+BACKLIGHT_DRIVER = software
 ```
 
 ### Software PWM Configuration
@@ -200,3 +208,29 @@ To activate multiple backlight pins, you need to add something like this to your
 #undef BACKLIGHT_PIN
 #define BACKLIGHT_PINS { F5, B2 }
 ```
+
+## Custom Driver
+
+To enable, add this to your rules.mk:
+
+```makefile
+BACKLIGHT_DRIVER = custom
+```
+
+When implementing the custom driver API, the provided keyboard hooks are as follows:
+
+```c
+void backlight_init_ports(void) {
+    // Optional - Run on startup
+    //          - usually you want to configure pins here
+}
+void backlight_set(uint8_t level) {
+    // Optional - Run on level change
+    //          - usually you want to respond to the new value
+}
+
+void backlight_task(void) {
+    // Optional - Run periodically
+    //          - long running actions here can cause performance issues
+}
+```