Fix installation for linux finding ID:fedora in os_release

* Add my own keymap to the list of available Redox keymaps.

This keymap is a Colemak keymap, and is meant to be used on Mac OS.
More information can be found in the readme.

* Fix "macOS" typo and remove mention of the license.

This directory inherits the project's license.

* Add missing custom keycode.

* Address feedback from PR review

- Remove deprecated code
- Remove RGB logic since it is overwritten by code running later.

Makefile

@@ -578,7 +578,7 @@ lib/%:
 
 git-submodule:
 	git submodule sync --recursive
-	git submodule update --init --recursive
+	git submodule update --init --recursive --progress
 
 ifdef SKIP_VERSION
 SKIP_GIT := yes

build_keyboard.mk

@@ -144,6 +144,9 @@ endif
 ifdef MCU_FAMILY
     FIRMWARE_FORMAT?=bin
     PLATFORM=CHIBIOS
+else ifdef ARM_ATSAM
+    PLATFORM=ARM_ATSAM
+    FIRMWARE_FORMAT=bin
 else
     PLATFORM=AVR
     FIRMWARE_FORMAT?=hex
@@ -286,6 +289,11 @@ endif
     include $(TMK_PATH)/avr.mk
 endif
 
+ifeq ($(PLATFORM),ARM_ATSAM)
+    include $(TMK_PATH)/arm_atsam.mk
+    include $(TMK_PATH)/protocol/arm_atsam.mk
+endif
+
 ifeq ($(PLATFORM),CHIBIOS)
     include $(TMK_PATH)/protocol/chibios.mk
 endif

common_features.mk

@@ -61,8 +61,8 @@ endif
 
 ifeq ($(strip $(STENO_ENABLE)), yes)
     OPT_DEFS += -DSTENO_ENABLE
-	VIRTSER_ENABLE := yes
-	SRC += $(QUANTUM_DIR)/process_keycode/process_steno.c
+    VIRTSER_ENABLE := yes
+    SRC += $(QUANTUM_DIR)/process_keycode/process_steno.c
 endif
 
 ifeq ($(strip $(VIRTSER_ENABLE)), yes)
@@ -75,9 +75,9 @@ ifeq ($(strip $(FAUXCLICKY_ENABLE)), yes)
 endif
 
 ifeq ($(strip $(POINTING_DEVICE_ENABLE)), yes)
-	OPT_DEFS += -DPOINTING_DEVICE_ENABLE
-	OPT_DEFS += -DMOUSE_ENABLE
-	SRC += $(QUANTUM_DIR)/pointing_device.c
+    OPT_DEFS += -DPOINTING_DEVICE_ENABLE
+    OPT_DEFS += -DMOUSE_ENABLE
+    SRC += $(QUANTUM_DIR)/pointing_device.c
 endif
 
 ifeq ($(strip $(UCIS_ENABLE)), yes)
@@ -110,12 +110,14 @@ ifeq ($(strip $(RGBLIGHT_ENABLE)), yes)
     ifeq ($(strip $(RGBLIGHT_CUSTOM_DRIVER)), yes)
         OPT_DEFS += -DRGBLIGHT_CUSTOM_DRIVER
     else
-	    SRC += ws2812.c
+        SRC += ws2812.c
     endif
 endif
 
 ifeq ($(strip $(RGB_MATRIX_ENABLE)), yes)
     OPT_DEFS += -DRGB_MATRIX_ENABLE
+    OPT_DEFS += -DIS31FL3731
+    COMMON_VPATH += $(DRIVER_PATH)/issi
     SRC += is31fl3731.c
     SRC += i2c_master.c
     SRC += $(QUANTUM_DIR)/color.c
@@ -123,6 +125,28 @@ ifeq ($(strip $(RGB_MATRIX_ENABLE)), yes)
     CIE1931_CURVE = yes
 endif
 
+ifeq ($(strip $(RGB_MATRIX_ENABLE)), IS31FL3731)
+    OPT_DEFS += -DRGB_MATRIX_ENABLE
+    OPT_DEFS += -DIS31FL3731
+    COMMON_VPATH += $(DRIVER_PATH)/issi
+    SRC += is31fl3731.c
+    SRC += i2c_master.c
+    SRC += $(QUANTUM_DIR)/color.c
+    SRC += $(QUANTUM_DIR)/rgb_matrix.c
+    CIE1931_CURVE = yes
+endif
+
+ifeq ($(strip $(RGB_MATRIX_ENABLE)), IS31FL3733)
+    OPT_DEFS += -DRGB_MATRIX_ENABLE
+    OPT_DEFS += -DIS31FL3733
+    COMMON_VPATH += $(DRIVER_PATH)/issi
+    SRC += is31fl3733.c
+    SRC += i2c_master.c
+    SRC += $(QUANTUM_DIR)/color.c
+    SRC += $(QUANTUM_DIR)/rgb_matrix.c
+    CIE1931_CURVE = yes
+endif
+
 ifeq ($(strip $(TAP_DANCE_ENABLE)), yes)
     OPT_DEFS += -DTAP_DANCE_ENABLE
     SRC += $(QUANTUM_DIR)/process_keycode/process_tap_dance.c
@@ -169,7 +193,7 @@ ifeq ($(strip $(BACKLIGHT_ENABLE)), yes)
     ifeq ($(strip $(VISUALIZER_ENABLE)), yes)
         CIE1931_CURVE = yes
     endif
-		ifeq ($(strip $(BACKLIGHT_CUSTOM_DRIVER)), yes)
+        ifeq ($(strip $(BACKLIGHT_CUSTOM_DRIVER)), yes)
         OPT_DEFS += -DBACKLIGHT_CUSTOM_DRIVER
     endif
 endif
@@ -200,7 +224,7 @@ endif
 
 ifeq ($(strip $(HD44780_ENABLE)), yes)
     SRC += drivers/avr/hd44780.c
-	OPT_DEFS += -DHD44780_ENABLE
+    OPT_DEFS += -DHD44780_ENABLE
 endif
 
 QUANTUM_SRC:= \

docs/_sidebar.md

@@ -36,6 +36,7 @@
   * [Documentation Templates](documentation_templates.md)
   * [Glossary](reference_glossary.md)
   * [Unit Testing](unit_testing.md)
+  * [Useful Functions](ref_functions.md)
 
 * [Features](features.md)
   * [Basic Keycodes](keycodes_basic.md)

docs/_summary.md

@@ -36,6 +36,7 @@
   * [Documentation Templates](documentation_templates.md)
   * [Glossary](reference_glossary.md)
   * [Unit Testing](unit_testing.md)
+  * [Useful Functions](ref_functions.md)
 
 * [Features](features.md)
   * [Basic Keycodes](keycodes_basic.md)

docs/becoming_a_qmk_collaborator.md

@@ -1,7 +1,9 @@
-A QMK collaborator is a keyboard maker/designer that is interested in helping QMK grow and fully support their keyboard(s), and encouraging their users/customers to submit features, ideas, and keymaps. We're always looking to add more keyboards and collaborators, but we ask that they fulfill these requirements:
+# Becoming a QMK Collaborator
 
-* **Have a PCB available for sale** - unfortunately there's just too much variation and complications with handwired keyboards.
-* **Maintain the your keyboard's directory** - this may just require an initial setup to get your keyboard working, but it could also include accommodating changes made to QMK's core.
-* **Approve and merge your keyboard's keymap pull requests** - we like to encourage users to contribute their keymaps for others to see and work from when creating their own.
+A QMK collaborator is a keyboard maker or designer that is interested in helping QMK grow and fully support their keyboard(s), and encouraging their users and customers to submit features, ideas, and keymaps. We're always looking to add more keyboards and collaborators, but we ask that they fulfill these requirements:
+
+* **Have a PCB available for sale.** Unfortunately there's just too much variation and complications with handwired keyboards.
+* **Maintain your keyboard in QMK.** This may just require an initial setup to get your keyboard working, but it could also include accommodating changes made to QMK's core that might break or render any custom code redundant.
+* **Approve and merge keymap pull requests for your keyboard.** We like to encourage users to contribute their keymaps for others to see and work from when creating their own.
 
 If you feel you meet these requirements, shoot us an email at hello@qmk.fm with an introduction and some links to your keyboard!

docs/config_options.md

@@ -248,3 +248,7 @@ Use these to enable or disable building certain features. The more you have enab
   * Enable Bluetooth with the Adafruit EZ-Key HID
 * `SPLIT_KEYBOARD`
   * Enables split keyboard support (dual MCU like the let's split and bakingpy's boards) and includes all necessary files located at quantum/split_common
+* `WAIT_FOR_USB`
+  * 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.

docs/feature_advanced_keycodes.md

@@ -13,9 +13,11 @@ People often define custom names using `#define`. For example:
 
 This will allow you to use `FN_CAPS` and `ALT_TAB` in your `KEYMAP()`, keeping it more readable.
 
-### Limits of These Aliases
+### Caveats
 
-Currently, the keycodes able to used with these functions are limited to the [Basic Keycodes](keycodes_basic.md), meaning you can't use keycodes like `KC_TILD`, or anything greater than 0xFF. For a full list of the keycodes able to be used see [Basic Keycodes](keycodes_basic.md).
+Currently, `LT()` and `MT()` are limited to the [Basic Keycode set](keycodes_basic.md), meaning you can't use keycodes like `LCTL()`, `KC_TILD`, or anything greater than `0xFF`. Modifiers specified as part of a Layer Tap or Mod Tap's keycode will be ignored.
+
+Additionally, if at least one right-handed modifier is specified in a Mod Tap or Layer Tap, it will cause all modifiers specified to become right-handed, so it is not possible to mix and match the two.
 
 # Switching and Toggling Layers
 
@@ -55,57 +57,73 @@ Sometimes, you might want to switch between layers in a macro or as part of a ta
 
 # Modifier Keys
 
-These functions allow you to combine a mod with a keycode. When pressed the keydown for the mod will be sent first, and then *kc* will be sent. When released the keyup for *kc* will be sent and then the mod will be sent.
+These allow you to combine a modifier with a keycode. When pressed, the keydown event for the modifier, then `kc` will be sent. On release, the keyup event for `kc`, then the modifier will be sent.
 
-* `LSFT(kc)` or `S(kc)` - applies left Shift to *kc* (keycode)
-* `RSFT(kc)` - applies right Shift to *kc*
-* `LCTL(kc)` - applies left Control to *kc*
-* `RCTL(kc)` - applies right Control to *kc*
-* `LALT(kc)` - applies left Alt to *kc*
-* `RALT(kc)` - applies right Alt to *kc*
-* `LGUI(kc)` - applies left GUI (command/win) to *kc*
-* `RGUI(kc)` - applies right GUI (command/win) to *kc*
-* `HYPR(kc)` - applies Hyper (all modifiers) to *kc*
-* `MEH(kc)`  - applies Meh (all modifiers except Win/Cmd) to *kc*
-* `LCAG(kc)` - applies CtrlAltGui to *kc*
+|Key       |Aliases               |Description                                         |
+|----------|----------------------|----------------------------------------------------|
+|`LCTL(kc)`|                      |Hold Left Control and press `kc`                    |
+|`LSFT(kc)`|`S(kc)`               |Hold Left Shift and press `kc`                      |
+|`LALT(kc)`|                      |Hold Left Alt and press `kc`                        |
+|`LGUI(kc)`|`LCMD(kc)`, `LWIN(kc)`|Hold Left GUI and press `kc`                        |
+|`RCTL(kc)`|                      |Hold Right Control and press `kc`                   |
+|`RSFT(kc)`|                      |Hold Right Shift and press `kc`                     |
+|`RALT(kc)`|                      |Hold Right Alt and press `kc`                       |
+|`RGUI(kc)`|`RCMD(kc)`, `LWIN(kc)`|Hold Right GUI and press `kc`                       |
+|`HYPR(kc)`|                      |Hold Left Control, Shift, Alt and GUI and press `kc`|
+|`MEH(kc)` |                      |Hold Left Control, Shift and Alt and press `kc`     |
+|`LCAG(kc)`|                      |Hold Left Control, Alt and GUI and press `kc`       |
+|`ALTG(kc)`|                      |Hold Right Control and Alt and press `kc`           |
+|`SGUI(kc)`|`SCMD(kc)`, `SWIN(kc)`|Hold Left Shift and GUI and press `kc`              |
+|`LCA(kc)` |                      |Hold Left Control and Alt and press `kc`            |
 
-You can also chain these, like this:
+You can also chain them, for example `LCTL(LALT(KC_DEL))` makes a key that sends Control+Alt+Delete with a single keypress.
 
-    LALT(LCTL(KC_DEL)) -- this makes a key that sends Alt, Control, and Delete in a single keypress.
+# Mod-Tap
 
-# Mod Tap
+The Mod-Tap key `MT(mod, kc)` acts like a modifier when held, and a regular keycode when tapped. In other words, you can have a key that sends Escape when you tap it, but functions as a Control or Shift key when you hold it down.
 
-`MT(mod, kc)` - is *mod* (modifier key - MOD_LCTL, MOD_LSFT) when held, and *kc* when tapped. In other words, you can have a key that sends Esc (or the letter O or whatever) when you tap it, but works as a Control key or a Shift key when you hold it down.
+The modifiers this keycode and `OSM()` accept are prefixed with `MOD_`, not `KC_`:
 
-These are the values you can use for the `mod` in `MT()` and `OSM()`:
+|Modifier  |Description                             |
+|----------|----------------------------------------|
+|`MOD_LCTL`|Left Control                            |
+|`MOD_LSFT`|Left Shift                              |
+|`MOD_LALT`|Left Alt                                |
+|`MOD_LGUI`|Left GUI (Windows/Command/Meta key)     |
+|`MOD_RCTL`|Right Control                           |
+|`MOD_RSFT`|Right Shift                             |
+|`MOD_RALT`|Right Alt                               |
+|`MOD_RGUI`|Right GUI (Windows/Command/Meta key)    |
+|`MOD_HYPR`|Hyper (Left Control, Shift, Alt and GUI)|
+|`MOD_MEH` |Meh (Left Control, Shift, and Alt)      |
 
-  * MOD_LCTL
-  * MOD_LSFT
-  * MOD_LALT
-  * MOD_LGUI
-  * MOD_RCTL
-  * MOD_RSFT
-  * MOD_RALT
-  * MOD_RGUI
-  * MOD_HYPR
-  * MOD_MEH
+You can combine these by ORing them together like so:
 
-These can also be combined like `MOD_LCTL | MOD_LSFT` e.g. `MT(MOD_LCTL | MOD_LSFT, KC_ESC)` which would activate Control and Shift when held, and send Escape when tapped.
+```c
+MT(MOD_LCTL | MOD_LSFT, KC_ESC)
+```
 
-We've added shortcuts to make common modifier/tap (mod-tap) mappings more compact:
+This key would activate Left Control and Left Shift when held, and send Escape when tapped.
 
-  * `CTL_T(kc)` - is LCTL when held and *kc* when tapped
-  * `SFT_T(kc)` - is LSFT when held and *kc* when tapped
-  * `ALT_T(kc)` - is LALT when held and *kc* when tapped
-  * `ALGR_T(kc)` - is AltGr when held and *kc* when tapped
-  * `GUI_T(kc)` - is LGUI when held and *kc* when tapped
-  * `ALL_T(kc)` - is Hyper (all mods) when held and *kc* when tapped. To read more about what you can do with a Hyper key, see [this blog post by Brett Terpstra](http://brettterpstra.com/2012/12/08/a-useful-caps-lock-key/)
-  * `LCAG_T(kc)` - is CtrlAltGui when held and *kc* when tapped
-  * `MEH_T(kc)` - is like Hyper, but not as cool -- does not include the Cmd/Win key, so just sends Alt+Ctrl+Shift.
+For convenience, QMK includes some Mod-Tap shortcuts to make common combinations more compact in your keymap:
 
-?> Due to the way that keycodes are structured, any modifiers specified as part of `kc`, such as `LCTL()` or `KC_LPRN`, will only activate when held instead of tapped.
-
-?> Additionally, if there is at least one right-handed modifier, any other modifiers in a chain of functions will turn into their right-handed equivalents, so it is not possible to "mix and match" the two.
+|Key         |Aliases                                |Description                                            |
+|------------|---------------------------------------|-------------------------------------------------------|
+|`LCTL_T(kc)`|`CTL_T(kc)`                            |Left Control when held, `kc` when tapped               |
+|`RCTL_T(kc)`|                                       |Right Control when held, `kc` when tapped              |
+|`LSFT_T(kc)`|`SFT_T(kc)`                            |Left Shift when held, `kc` when tapped                 |
+|`RSFT_T(kc)`|                                       |Right Shift when held, `kc` when tapped                |
+|`LALT_T(kc)`|`ALT_T(kc)`                            |Left Alt when held, `kc` when tapped                   |
+|`RALT_T(kc)`|`ALGR_T(kc)`                           |Right Alt when held, `kc` when tapped                  |
+|`LGUI_T(kc)`|`LCMD_T(kc)`, `RWIN_T(kc)`, `GUI_T(kc)`|Left GUI when held, `kc` when tapped                   |
+|`RGUI_T(kc)`|`RCMD_T(kc)`, `RWIN_T(kc)`             |Right GUI when held, `kc` when tapped                  |
+|`C_S_T(kc)` |                                       |Left Control and Shift when held, `kc` when tapped     |
+|`MEH_T(kc)` |                                       |Left Control, Shift and Alt when held, `kc` when tapped|
+|`LCAG_T(kc)`|                                       |Left Control, Alt and GUI when held, `kc` when tapped  |
+|`RCAG_T(kc)`|                                       |Right Control, Alt and GUI when held, `kc` when tapped |
+|`ALL_T(kc)` |                                       |Left Control, Shift, Alt and GUI when held, `kc` when tapped - more info [here](http://brettterpstra.com/2012/12/08/a-useful-caps-lock-key/)|
+|`SGUI_T(kc)`|`SCMD_T(kc)`, `SWIN_T(kc)`             |Left Shift and GUI when held, `kc` when tapped         |
+|`LCA_T(kc)` |                                       |Left Control and Alt when held, `kc` when tapped       |
 
 # One Shot Keys
 

docs/feature_backlight.md

@@ -51,3 +51,22 @@ In this way `OCRxx` essentially controls the duty cycle of the LEDs, and thus th
 
 The breathing effect is achieved by registering an interrupt handler for `TIMER1_OVF_vect` that is called whenever the counter resets, roughly 244 times per second.
 In this handler, the value of an incrementing counter is mapped onto a precomputed brightness curve. To turn off breathing, the interrupt handler is simply disabled, and the brightness reset to the level stored in EEPROM.
+
+## Backlight Functions
+
+|Function  |Description                                               |
+|----------|----------------------------------------------------------|
+|`backlight_toggle()`   |Turn the backlight on or off                 |
+|`backlight_step()`     |Cycle through backlight levels               |
+|`backlight_increase()` |Increase the backlight level                 |
+|`backlight_decrease()` |Decrease the backlight level                 |
+|`backlight_level(x)`   |Sets the backlight level to specified level  |
+|`get_backlight_level()`|Toggle backlight breathing                   |
+
+### Backlight Breathing Functions
+
+|Function  |Description                                               |
+|----------|----------------------------------------------------------|
+|`breathing_toggle()`  |Turn the backlight breathing on or off        |
+|`breathing_enable()`  |Turns on backlight breathing                  |
+|`breathing_disable()` |Turns off backlight breathing                 |

docs/feature_layouts.md

@@ -53,6 +53,8 @@ but the `LAYOUT_<layout>` variable must be defined in `<folder>.h` as well.
 
 ## Tips for Making Layouts Keyboard-Agnostic
 
+### Includes
+
 Instead of using `#include "planck.h"`, you can use this line to include whatever `<keyboard>.h` (`<folder>.h` should not be included here) file that is being compiled:
 
     #include QMK_KEYBOARD_H
@@ -72,3 +74,7 @@ For example:
 ```
 
 Note that the names are lowercase and match the folder/file names for the keyboard/revision exactly.
+
+### Keymaps
+
+In order to support both split and non-split keyboards with the same layout, you need to use the keyboard agnostic `LAYOUT_<layout name>` macro in your keymap. For instance, in order for a Let's Split and Planck to share the same layout file, you need to use `LAYOUT_ortho_4x12` instead of `LAYOUT_planck_grid` or just `{}` for a C array.

docs/feature_rgb_matrix.md

@@ -1,8 +1,12 @@
 # RGB Matrix Lighting
 
+## Driver configuration
+
+### IS31FL3731
+
 There is basic support for addressable RGB matrix lighting with the I2C IS31FL3731 RGB controller. To enable it, add this to your `rules.mk`:
 
-    RGB_MATRIX_ENABLE = yes
+    RGB_MATRIX_ENABLE = IS31FL3731
 
 Configure the hardware via your `config.h`:
 
@@ -36,7 +40,51 @@ Define these arrays listing all the LEDs in your `<keyboard>.c`:
 	    ....
 	}
 
-Where `Cx_y` is the location of the LED in the matrix defined by [the datasheet](http://www.issi.com/WW/pdf/31FL3731.pdf). The `driver` is the index of the driver you defined in your `config.h` (`0` or `1` right now).
+Where `Cx_y` is the location of the LED in the matrix defined by [the datasheet](http://www.issi.com/WW/pdf/31FL3731.pdf) and the header file `drivers/issi/is31fl3731.h`. The `driver` is the index of the driver you defined in your `config.h` (`0` or `1` right now).
+
+###  IS31FL3733
+
+There is basic support for addressable RGB matrix lighting with the I2C IS31FL3733 RGB controller. To enable it, add this to your `rules.mk`:
+
+    RGB_MATRIX_ENABLE = IS31FL3733
+
+Configure the hardware via your `config.h`:
+
+	// This is a 7-bit address, that gets left-shifted and bit 0
+	// set to 0 for write, 1 for read (as per I2C protocol)
+	// The address will vary depending on your wiring:
+	// 00 <-> GND
+	// 01 <-> SCL
+	// 10 <-> SDA
+	// 11 <-> VCC
+	// ADDR1 represents A1:A0 of the 7-bit address.
+	// ADDR2 represents A3:A2 of the 7-bit address.
+	// The result is: 0b101(ADDR2)(ADDR1)
+	#define DRIVER_ADDR_1 0b1010000
+	#define DRIVER_ADDR_2 0b1010000 // this is here for compliancy reasons.
+
+	#define DRIVER_COUNT 1
+	#define DRIVER_1_LED_TOTAL 64
+	#define DRIVER_LED_TOTAL DRIVER_1_LED_TOTAL
+
+Currently only a single drivers is supported, but it would be trivial to support all 4 combinations. For now define `DRIVER_ADDR_2` as `DRIVER_ADDR_1`
+
+Define these arrays listing all the LEDs in your `<keyboard>.c`:
+
+	const is31_led g_is31_leds[DRIVER_LED_TOTAL] = {
+	/* Refer to IS31 manual for these locations
+	 *   driver
+	 *   |  R location
+	 *   |  |       G location
+	 *   |  |       |       B location
+	 *   |  |       |       | */
+	    {0, B_1,    A_1,    C_1},
+	    ....
+	}
+
+Where `X_Y` is the location of the LED in the matrix defined by [the datasheet](http://www.issi.com/WW/pdf/31FL3733.pdf) and the header file `drivers/issi/is31fl3733.h`. The `driver` is the index of the driver you defined in your `config.h` (Only `0` right now).
+
+From this point forward the configuration is the same for all the drivers. 
 
 	const rgb_led g_rgb_leds[DRIVER_LED_TOTAL] = {
 	/* {row | col << 4}

docs/hardware_drivers.md

@@ -26,6 +26,10 @@ You can make use of uGFX within QMK to drive character and graphic LCD's, LED ar
 
 Support for WS2811/WS2812{a,b,c} LED's. For more information see the [RGB Light](feature_rgblight.md) page.
 
-## IS31FL3731 (AVR Only)
+## IS31FL3731
 
 Support for up to 2 drivers. Each driver impliments 2 charlieplex matrices to individually address LEDs using I2C. This allows up to 144 same color LEDs or 32 RGB LEDs. For more information on how to setup the driver see the [RGB Matrix](feature_rgb_matrix.md) page.
+
+## IS31FL3733
+
+Support for up to a single driver with room for expansion. Each driver can control 192 individual LEDs or 64 RGB LEDs. For more information on how to setup the driver see the [RGB Matrix](feature_rgb_matrix.md) page.

docs/keycodes.md

@@ -318,7 +318,7 @@ This is a reference only. Each group of keys links to the page documenting their
 ## [Modifiers](feature_advanced_keycodes.md#modifier-keys)
 
 |Key       |Aliases               |Description                                         |
-|----------|----------            |----------------------------------------------------|
+|----------|----------------------|----------------------------------------------------|
 |`KC_HYPR` |                      |Hold Left Control, Shift, Alt and GUI               |
 |`KC_MEH`  |                      |Hold Left Control, Shift and Alt                    |
 |`LCTL(kc)`|                      |Hold Left Control and press `kc`                    |
@@ -353,7 +353,7 @@ This is a reference only. Each group of keys links to the page documenting their
 |`LCAG_T(kc)`|                                       |Left Control, Alt and GUI when held, `kc` when tapped  |
 |`RCAG_T(kc)`|                                       |Right Control, Alt and GUI when held, `kc` when tapped |
 |`ALL_T(kc)` |                                       |Left Control, Shift, Alt and GUI when held, `kc` when tapped - more info [here](http://brettterpstra.com/2012/12/08/a-useful-caps-lock-key/)|
-|`SCMD_T(kc)`|`SWIN_T(kc)`                           |Left Shift and GUI when held, `kc` when tapped         |
+|`SGUI_T(kc)`|`SCMD_T(kc)`, `SWIN_T(kc)`             |Left Shift and GUI when held, `kc` when tapped         |
 |`LCA_T(kc)` |                                       |Left Control and Alt when held, `kc` when tapped       |
 
 ## [RGB Lighting](feature_rgblight.md)

docs/ref_functions.md

@@ -0,0 +1,48 @@
+# List of Useful Core Functions To Make Your Keyboard Better
+
+There are a lot of hidden functions in QMK that are incredible useful, or may add a bit of functionality that you've been wanting.  Functions that are specific to certain features are not included here, as those will be on their respective feature page. 
+
+## (OLKB) Tri Layers
+
+There are actually separate functions that you can use there, depending on what you're after. 
+
+The first is the `update_tri_layer(x, y, z)` function.   This function check to see if layers `x` and `y` are both on. If they are both on, then it runs on layer `z`.  Otherwise, if both `x` and `y` are not both on (either only one is, or neither is), then it runs off layer `z`. 
+
+This function is useful if you want to create specific keys that have this functionality, but other layer keycodes won't do this. 
+
+The other function is `update_tri_layer_state(state, x, y, z)`.  This function is meant to be called from they [`layer_state_set_*` functions](custom_quantum_functions.md#layer-change-code).  This means that any time that you use a keycode to change the layer, this will be checked.  So you could use `LT(layer, kc)` to change the layer and it will trigger the same layer check. 
+
+The caveat to this method is that you cannot access the `z` layer without having `x` and `y` layers on, since if you try to activate just layer `z`, it will run this code and turn off layer `z` before you could use it. 
+
+## Setting the Persistent Default Layer
+
+Do you want to set the default layer, so that it's retained even after you unplug the board?  If so, this is the function for you. 
+
+To use this, you would use `set_single_persistent_default_layer(layer)`.  If you have a name defined for your layer, you can use that instead (such as _QWERTY, _DVORAK or _COLEMAK). 
+
+This will set the default layer, update the persistent settings, and play a tune if you have [Audio](feature_audio.md) enabled on your board, and the default layer sounds set. 
+
+To configure the default layer sounds, you would want to define this in your `config.h` file, like this: 
+
+```c
+#define DEFAULT_LAYER_SONGS { SONG(QWERTY_SOUND), \
+                              SONG(COLEMAK_SOUND), \
+                              SONG(DVORAK_SOUND) \
+                            }
+```
+
+
+?> There are a large number of predefined songs in [quantum/audio/song_list.h](https://github.com/qmk/qmk_firmware/blob/master/quantum/audio/song_list.h) that you can use.
+
+## Reseting the keyboard
+
+There is the `RESET` quantum keycode that you can use. But if you want to reset the board as part of a macro, rather than hitting a key separately, you can do that. 
+
+And to do so, add `reset_keyboard()` to your function or macro, and this will reset to bootloader.
+
+## Wiping the EEPROM (Persistent Storage)
+
+If you're having issues with Audio, RGB Underglow, backlighting or keys acting weird, then you can reset the EEPROM (persistent setting storage).  Bootmagic is one way to do this, but if that isn't enabled, then you can use a custom macro to do so. 
+
+To wipe the EEPROM, run `eeconfig_init()` from your function or macro to reset most of the settings to default. 
+

docs/understanding_qmk.md

@@ -12,7 +12,7 @@ You can think of QMK as no different from any other computer program. It is star
 
 The reason for this is the different platforms that QMK supports. The most common platform is `lufa`, which runs on AVR processors such at the atmega32u4. We also support `chibios` and `vusb`.
 
-We'll focus on AVR processors for the moment, which use the `lufa` platform. You can find the `main()` function in [tmk_core/protocol/lufa/lufa.c](https://github.com/qmk/qmk_firmware/blob/master/tmk_core/protocol/lufa/lufa.c#L1129). If you browse through that function you'll find that it initializes any hardware that has been configured (including USB to the host) and then it starts the core part of the program with a [`while(1)`](https://github.com/qmk/qmk_firmware/blob/master/tmk_core/protocol/lufa/lufa.c#L1182). This is [The Main Loop](#the_main_loop).
+We'll focus on AVR processors for the moment, which use the `lufa` platform. You can find the `main()` function in [tmk_core/protocol/lufa/lufa.c](https://github.com/qmk/qmk_firmware/blob/661ca4440cc42f3b60697e98985c44b0571ccfc1/tmk_core/protocol/lufa/lufa.c#L1019). If you browse through that function you'll find that it initializes any hardware that has been configured (including USB to the host) and then it starts the core part of the program with a [`while(1)`](https://github.com/qmk/qmk_firmware/blob/661ca4440cc42f3b60697e98985c44b0571ccfc1/tmk_core/protocol/lufa/lufa.c#L1060). This is [The Main Loop](#the-main-loop).
 
 ## The Main Loop
 
@@ -22,7 +22,7 @@ This section of code is called "The Main Loop" because it's responsible for loop
     keyboard_task();
 ```
 
-This is where all the keyboard specific functionality is dispatched. The source code for `keyboard_task()` can be found in [tmk_core/common/keyboard.c](https://github.com/qmk/qmk_firmware/blob/master/tmk_core/common/keyboard.c#L154), and it is responsible for detecting changes in the matrix and turning status LED's on and off.
+This is where all the keyboard specific functionality is dispatched. The source code for `keyboard_task()` can be found in [tmk_core/common/keyboard.c](https://github.com/qmk/qmk_firmware/blob/661ca4440cc42f3b60697e98985c44b0571ccfc1/tmk_core/common/keyboard.c#L206), and it is responsible for detecting changes in the matrix and turning status LED's on and off.
 
 Within `keyboard_task()` you'll find code to handle:
 
@@ -77,7 +77,7 @@ At the keyboard level we define a C macro (typically named `KEYMAP()`) which map
 
 Notice how the second block of our `KEYMAP()` macro matches the Matrix Scanning array above? This macro is what will map the matrix scanning array to keycodes. However, if you look at a 17 key numpad you'll notice that it has 3 places where the matrix could have a switch but doesn't, due to larger keys. We have populated those spaces with `KC_NO` so that our keymap definition doesn't have to.
 
-You can also use this macro to handle unusual matrix layouts, for example the [Clueboard rev 2](https://github.com/qmk/qmk_firmware/blob/master/keyboards/clueboard/66/rev2/rev2.h). Explaining that is outside the scope of this document.
+You can also use this macro to handle unusual matrix layouts, for example the [Clueboard rev 2](https://github.com/qmk/qmk_firmware/blob/661ca4440cc42f3b60697e98985c44b0571ccfc1/keyboards/clueboard/66/rev2/rev2.h). Explaining that is outside the scope of this document.
 
 ##### Keycode Assignment
 
@@ -129,27 +129,32 @@ Comparing against our keymap we can see that the pressed key is KC_NLCK. From he
 <!-- FIXME: Magic happens between here and process_record -->
 
 ##### Process Record
+The `process_record()` function itself is deceptively simple, but hidden within is a gateway to overriding functionality at various levels of QMK. The chain of events is listed below, using cluecard whenever we need to look at the keyboard/keymap level functions.  Depending on options set in rule.mk or elsewhere, only a subset of the functions below will be included in final firmware.
 
-The `process_record()` function itself is deceptively simple, but hidden within is a gateway to overriding functionality at various levels of QMK. The chain of events is described below, using cluecard whenever we need to look at the keyboard/keymap level functions.
-
-* [`void process_record(keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/tmk_core/common/action.c#L128)
-  * [`bool process_record_quantum(keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/quantum.c#L140)
-    * [Map this record to a keycode](https://github.com/qmk/qmk_firmware/blob/master/quantum/quantum.c#L143)
-    * [`bool process_record_kb(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/keyboards/clueboard/card/card.c#L20)
-      * [`bool process_record_user(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/keyboards/clueboard/card/keymaps/default/keymap.c#L58)
-    * [`bool process_midi(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_midi.c#L102)
-    * [`bool process_audio(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_audio.c#L10)
-    * [`bool process_music(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_music.c#L69)
-    * [`bool process_tap_dance(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_tap_dance.c#L75)
-    * [`bool process_leader(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_leader.c#L32)
-    * [`bool process_chording(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_chording.c#L41)
-    * [`bool process_combo(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_combo.c#L115)
-    * [`bool process_unicode(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_unicode.c#L22)
-    * [`bool process_ucis(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_ucis.c#L91)
-    * [`bool process_printer(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_printer.c#L77)
-    * [`bool process_auto_shift(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_auto_shift.c#L47)
-    * [`bool process_unicode_map(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_unicodemap.c#L47)
-    * [Identify and process quantum specific keycodes](https://github.com/qmk/qmk_firmware/blob/master/quantum/quantum.c#L211)
+* [`void process_record(keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/08c682c193f43e5d54df990680ae93fc2e06150a/tmk_core/common/action.c#L172)
+  * [`bool process_record_quantum(keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/08c682c193f43e5d54df990680ae93fc2e06150a/quantum/quantum.c#L193)
+    * [Map this record to a keycode](https://github.com/qmk/qmk_firmware/blob/08c682c193f43e5d54df990680ae93fc2e06150a/quantum/quantum.c#L213)
+    * [`void preprocess_tap_dance(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/08c682c193f43e5d54df990680ae93fc2e06150a/quantum/process_keycode/process_tap_dance.c#L115)
+    * [`bool process_key_lock(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/08c682c193f43e5d54df990680ae93fc2e06150a/quantum/process_keycode/process_key_lock.c#L62)
+    * [`bool process_clicky(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/08c682c193f43e5d54df990680ae93fc2e06150a/quantum/process_keycode/process_clicky.c#L44)
+    * [`bool process_record_kb(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/08c682c193f43e5d54df990680ae93fc2e06150a/keyboards/clueboard/card/card.c#L20)
+      * [`bool process_record_user(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/08c682c193f43e5d54df990680ae93fc2e06150a/keyboards/clueboard/card/keymaps/default/keymap.c#L58)
+    * [`bool process_rgb_matrix(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/fdd0f915271f79b104aa5d216566bcc3fd134e85/quantum/rgb_matrix.c#L139)
+    * [`bool process_midi(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/661ca4440cc42f3b60697e98985c44b0571ccfc1/quantum/process_keycode/process_midi.c#L81)
+    * [`bool process_audio(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/661ca4440cc42f3b60697e98985c44b0571ccfc1/quantum/process_keycode/process_audio.c#L19)
+    * [`bool process_steno(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/661ca4440cc42f3b60697e98985c44b0571ccfc1/quantum/process_keycode/process_steno.c#L160)
+    * [`bool process_music(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/661ca4440cc42f3b60697e98985c44b0571ccfc1/quantum/process_keycode/process_music.c#L114)
+    * [`bool process_tap_dance(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/661ca4440cc42f3b60697e98985c44b0571ccfc1/quantum/process_keycode/process_tap_dance.c#L136)
+    * [`bool process_leader(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/661ca4440cc42f3b60697e98985c44b0571ccfc1/quantum/process_keycode/process_leader.c#L38)
+    * [`bool process_chording(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/661ca4440cc42f3b60697e98985c44b0571ccfc1/quantum/process_keycode/process_chording.c#L41)
+    * [`bool process_combo(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/661ca4440cc42f3b60697e98985c44b0571ccfc1/quantum/process_keycode/process_combo.c#L115)
+    * [`bool process_unicode(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/661ca4440cc42f3b60697e98985c44b0571ccfc1/quantum/process_keycode/process_unicode.c#L22)
+    * [`bool process_ucis(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/661ca4440cc42f3b60697e98985c44b0571ccfc1/quantum/process_keycode/process_ucis.c#L91)
+    * [`bool process_printer(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/661ca4440cc42f3b60697e98985c44b0571ccfc1/quantum/process_keycode/process_printer.c#L77)
+    * [`bool process_auto_shift(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/661ca4440cc42f3b60697e98985c44b0571ccfc1/quantum/process_keycode/process_auto_shift.c#L94)
+    * [`bool process_unicode_map(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/661ca4440cc42f3b60697e98985c44b0571ccfc1/quantum/process_keycode/process_unicodemap.c#L47)
+    * [`bool process_terminal(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/661ca4440cc42f3b60697e98985c44b0571ccfc1/quantum/process_keycode/process_terminal.c#L264)
+    * [Identify and process quantum specific keycodes](https://github.com/qmk/qmk_firmware/blob/661ca4440cc42f3b60697e98985c44b0571ccfc1/quantum/quantum.c#L287)
 
 At any step during this chain of events a function (such as `process_record_kb()`) can `return false` to halt all further processing.
 

drivers/arm/i2c_master.c

@@ -15,12 +15,14 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-/* This library follows the convention of the AVR i2c_master library.
+/* This library is only valid for STM32 processors.
+ * This library follows the convention of the AVR i2c_master library.
  * As a result addresses are expected to be already shifted (addr << 1).
  * I2CD1 is the default driver which corresponds to pins B6 and B7. This
  * can be changed.
  * 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.
+ * STM32_I2C_USE_I2C1 is TRUE in the mcuconf.h file. Pins B6 and B7 are used
+ * but using any other I2C pins should be trivial.
  */
 
 #include "i2c_master.h"
@@ -41,7 +43,7 @@ static const I2CConfig i2cconfig = {
 
 void i2c_init(void)
 {
-  palSetGroupMode(GPIOB,6,7, PAL_MODE_INPUT);       // Try releasing special pins for a short time
+  palSetGroupMode(GPIOB, GPIOB_PIN6 | GPIOB_PIN7, 0, PAL_MODE_INPUT); // Try releasing special pins for a short time
   chThdSleepMilliseconds(10);
 
   palSetPadMode(GPIOB, 6, PAL_MODE_ALTERNATE(4) | PAL_STM32_OTYPE_OPENDRAIN | PAL_STM32_PUPDR_PULLUP);
@@ -82,12 +84,12 @@ uint8_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t l
   {
     complete_packet[i+1] = data[i];
   }
-  complete_packet[0] = regaddr
+  complete_packet[0] = regaddr;
 
   return i2cMasterTransmitTimeout(&I2C_DRIVER, (i2c_address >> 1), complete_packet, length + 1, 0, 0, MS2ST(timeout));
 }
 
-uint8_t i2c_readReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout)
+uint8_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);
@@ -97,7 +99,6 @@ uint8_t i2c_readReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t le
 // This is usually not needed. It releases the driver to allow pins to become GPIO again.
 uint8_t i2c_stop(uint16_t timeout)
 {
-  i2c_address = address;
   i2cStop(&I2C_DRIVER);
   return 0;
 }

drivers/arm/i2c_master.h

@@ -35,5 +35,5 @@ uint8_t i2c_start(uint8_t address);
 uint8_t i2c_transmit(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout);
 uint8_t i2c_receive(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout);
 uint8_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout);
-uint8_t i2c_readReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout);
-void i2c_stop(void);
+uint8_t i2c_readReg(uint8_t devaddr, uint8_t* regaddr, uint8_t* data, uint16_t length, uint16_t timeout);
+uint8_t i2c_stop(uint16_t timeout);

drivers/issi/is31fl3731.c

@@ -91,7 +91,7 @@ bool g_led_control_registers_update_required = false;
 // 0x10 - R16,R15,R14,R13,R12,R11,R10,R09
 
 
-void IS31_write_register( uint8_t addr, uint8_t reg, uint8_t data )
+void IS31FL3731_write_register( uint8_t addr, uint8_t reg, uint8_t data )
 {
     g_twi_transfer_buffer[0] = reg;
     g_twi_transfer_buffer[1] = data;
@@ -106,7 +106,7 @@ void IS31_write_register( uint8_t addr, uint8_t reg, uint8_t data )
   #endif
 }
 
-void IS31_write_pwm_buffer( uint8_t addr, uint8_t *pwm_buffer )
+void IS31FL3731_write_pwm_buffer( uint8_t addr, uint8_t *pwm_buffer )
 {
     // assumes bank is already selected
 
@@ -135,7 +135,7 @@ void IS31_write_pwm_buffer( uint8_t addr, uint8_t *pwm_buffer )
     }
 }
 
-void IS31_init( uint8_t addr )
+void IS31FL3731_init( uint8_t addr )
 {
     // In order to avoid the LEDs being driven with garbage data
     // in the LED driver's PWM registers, first enable software shutdown,
@@ -143,10 +143,10 @@ void IS31_init( uint8_t addr )
     // then disable software shutdown.
 
     // select "function register" bank
-    IS31_write_register( addr, ISSI_COMMANDREGISTER, ISSI_BANK_FUNCTIONREG );
+    IS31FL3731_write_register( addr, ISSI_COMMANDREGISTER, ISSI_BANK_FUNCTIONREG );
 
     // enable software shutdown
-    IS31_write_register( addr, ISSI_REG_SHUTDOWN, 0x00 );
+    IS31FL3731_write_register( addr, ISSI_REG_SHUTDOWN, 0x00 );
     // this delay was copied from other drivers, might not be needed
     #ifdef __AVR__
     _delay_ms( 10 );
@@ -155,47 +155,47 @@ void IS31_init( uint8_t addr )
     #endif
 
     // picture mode
-    IS31_write_register( addr, ISSI_REG_CONFIG, ISSI_REG_CONFIG_PICTUREMODE );
+    IS31FL3731_write_register( addr, ISSI_REG_CONFIG, ISSI_REG_CONFIG_PICTUREMODE );
     // display frame 0
-    IS31_write_register( addr, ISSI_REG_PICTUREFRAME, 0x00 );
+    IS31FL3731_write_register( addr, ISSI_REG_PICTUREFRAME, 0x00 );
     // audio sync off
-    IS31_write_register( addr, ISSI_REG_AUDIOSYNC, 0x00 );
+    IS31FL3731_write_register( addr, ISSI_REG_AUDIOSYNC, 0x00 );
 
     // select bank 0
-    IS31_write_register( addr, ISSI_COMMANDREGISTER, 0 );
+    IS31FL3731_write_register( addr, ISSI_COMMANDREGISTER, 0 );
 
     // turn off all LEDs in the LED control register
     for ( int i = 0x00; i <= 0x11; i++ )
     {
-        IS31_write_register( addr, i, 0x00 );
+        IS31FL3731_write_register( addr, i, 0x00 );
     }
 
     // turn off all LEDs in the blink control register (not really needed)
     for ( int i = 0x12; i <= 0x23; i++ )
     {
-        IS31_write_register( addr, i, 0x00 );
+        IS31FL3731_write_register( addr, i, 0x00 );
     }
 
     // set PWM on all LEDs to 0
     for ( int i = 0x24; i <= 0xB3; i++ )
     {
-        IS31_write_register( addr, i, 0x00 );
+        IS31FL3731_write_register( addr, i, 0x00 );
     }
 
     // select "function register" bank
-    IS31_write_register( addr, ISSI_COMMANDREGISTER, ISSI_BANK_FUNCTIONREG );
+    IS31FL3731_write_register( addr, ISSI_COMMANDREGISTER, ISSI_BANK_FUNCTIONREG );
 
     // disable software shutdown
-    IS31_write_register( addr, ISSI_REG_SHUTDOWN, 0x01 );
+    IS31FL3731_write_register( addr, ISSI_REG_SHUTDOWN, 0x01 );
 
     // select bank 0 and leave it selected.
     // most usage after initialization is just writing PWM buffers in bank 0
     // as there's not much point in double-buffering
-    IS31_write_register( addr, ISSI_COMMANDREGISTER, 0 );
+    IS31FL3731_write_register( addr, ISSI_COMMANDREGISTER, 0 );
 
 }
 
-void IS31_set_color( int index, uint8_t red, uint8_t green, uint8_t blue )
+void IS31FL3731_set_color( int index, uint8_t red, uint8_t green, uint8_t blue )
 {
     if ( index >= 0 && index < DRIVER_LED_TOTAL ) {
         is31_led led = g_is31_leds[index];
@@ -208,15 +208,15 @@ void IS31_set_color( int index, uint8_t red, uint8_t green, uint8_t blue )
     }
 }
 
-void IS31_set_color_all( uint8_t red, uint8_t green, uint8_t blue )
+void IS31FL3731_set_color_all( uint8_t red, uint8_t green, uint8_t blue )
 {
     for ( int i = 0; i < DRIVER_LED_TOTAL; i++ )
     {
-        IS31_set_color( i, red, green, blue );
+        IS31FL3731_set_color( i, red, green, blue );
     }
 }
 
-void IS31_set_led_control_register( uint8_t index, bool red, bool green, bool blue )
+void IS31FL3731_set_led_control_register( uint8_t index, bool red, bool green, bool blue )
 {
     is31_led led = g_is31_leds[index];
 
@@ -247,24 +247,24 @@ void IS31_set_led_control_register( uint8_t index, bool red, bool green, bool bl
 
 }
 
-void IS31_update_pwm_buffers( uint8_t addr1, uint8_t addr2 )
+void IS31FL3731_update_pwm_buffers( uint8_t addr1, uint8_t addr2 )
 {
     if ( g_pwm_buffer_update_required )
     {
-        IS31_write_pwm_buffer( addr1, g_pwm_buffer[0] );
-        IS31_write_pwm_buffer( addr2, g_pwm_buffer[1] );
+        IS31FL3731_write_pwm_buffer( addr1, g_pwm_buffer[0] );
+        IS31FL3731_write_pwm_buffer( addr2, g_pwm_buffer[1] );
     }
     g_pwm_buffer_update_required = false;
 }
 
-void IS31_update_led_control_registers( uint8_t addr1, uint8_t addr2 )
+void IS31FL3731_update_led_control_registers( uint8_t addr1, uint8_t addr2 )
 {
     if ( g_led_control_registers_update_required )
     {
         for ( int i=0; i<18; i++ )
         {
-            IS31_write_register(addr1, i, g_led_control_registers[0][i] );
-            IS31_write_register(addr2, i, g_led_control_registers[1][i] );
+            IS31FL3731_write_register(addr1, i, g_led_control_registers[0][i] );
+            IS31FL3731_write_register(addr2, i, g_led_control_registers[1][i] );
         }
     }
 }

drivers/issi/is31fl3731.h

@@ -31,21 +31,21 @@ typedef struct is31_led {
 
 extern const is31_led g_is31_leds[DRIVER_LED_TOTAL];
 
-void IS31_init( uint8_t addr );
-void IS31_write_register( uint8_t addr, uint8_t reg, uint8_t data );
-void IS31_write_pwm_buffer( uint8_t addr, uint8_t *pwm_buffer );
+void IS31FL3731_init( uint8_t addr );
+void IS31FL3731_write_register( uint8_t addr, uint8_t reg, uint8_t data );
+void IS31FL3731_write_pwm_buffer( uint8_t addr, uint8_t *pwm_buffer );
 
-void IS31_set_color( int index, uint8_t red, uint8_t green, uint8_t blue );
-void IS31_set_color_all( uint8_t red, uint8_t green, uint8_t blue );
+void IS31FL3731_set_color( int index, uint8_t red, uint8_t green, uint8_t blue );
+void IS31FL3731_set_color_all( uint8_t red, uint8_t green, uint8_t blue );
 
-void IS31_set_led_control_register( uint8_t index, bool red, bool green, bool blue );
+void IS31FL3731_set_led_control_register( uint8_t index, bool red, bool green, bool blue );
 
 // This should not be called from an interrupt
 // (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 IS31_update_pwm_buffers( uint8_t addr1, uint8_t addr2 );
-void IS31_update_led_control_registers( uint8_t addr1, uint8_t addr2 );
+void IS31FL3731_update_pwm_buffers( uint8_t addr1, uint8_t addr2 );
+void IS31FL3731_update_led_control_registers( uint8_t addr1, uint8_t addr2 );
 
 #define C1_1  0x24
 #define C1_2  0x25

drivers/issi/is31fl3733.c

@@ -0,0 +1,253 @@
+/* Copyright 2017 Jason Williams
+ * Copyright 2018 Jack Humbert
+ * Copyright 2018 Yiancar
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifdef __AVR__
+#include <avr/interrupt.h>
+#include <avr/io.h>
+#include <util/delay.h>
+#else
+#include "wait.h"
+#endif
+
+#include "is31fl3733.h"
+#include <string.h>
+#include "i2c_master.h"
+#include "progmem.h"
+
+// This is a 7-bit address, that gets left-shifted and bit 0
+// set to 0 for write, 1 for read (as per I2C protocol)
+// The address will vary depending on your wiring:
+// 00 <-> GND
+// 01 <-> SCL
+// 10 <-> SDA
+// 11 <-> VCC
+// ADDR1 represents A1:A0 of the 7-bit address.
+// ADDR2 represents A3:A2 of the 7-bit address.
+// The result is: 0b101(ADDR2)(ADDR1)
+#define ISSI_ADDR_DEFAULT 0x50
+
+#define ISSI_COMMANDREGISTER 0xFD
+#define ISSI_COMMANDREGISTER_WRITELOCK 0xFE
+#define ISSI_INTERRUPTMASKREGISTER 0xF0
+#define ISSI_INTERRUPTSTATUSREGISTER 0xF1
+
+#define ISSI_PAGE_LEDCONTROL 0x00 //PG0
+#define ISSI_PAGE_PWM 0x01        //PG1
+#define ISSI_PAGE_AUTOBREATH 0x02 //PG2
+#define ISSI_PAGE_FUNCTION 0x03   //PG3
+
+#define ISSI_REG_CONFIGURATION 0x00 //PG3
+#define ISSI_REG_GLOBALCURRENT 0x01 //PG3
+#define ISSI_REG_RESET 0x11// PG3
+#define ISSI_REG_SWPULLUP 0x0F //PG3
+#define ISSI_REG_CSPULLUP 0x10 //PG3
+
+#ifndef ISSI_TIMEOUT
+  #define ISSI_TIMEOUT 100
+#endif
+
+#ifndef ISSI_PERSISTENCE
+  #define ISSI_PERSISTENCE 0
+#endif
+
+// Transfer buffer for TWITransmitData()
+uint8_t g_twi_transfer_buffer[20];
+
+// These buffers match the IS31FL3733 PWM registers.
+// The control buffers match the PG0 LED On/Off registers.
+// Storing them like this is optimal for I2C transfers to the registers.
+// We could optimize this and take out the unused registers from these
+// buffers and the transfers in IS31FL3733_write_pwm_buffer() but it's
+// probably not worth the extra complexity.
+uint8_t g_pwm_buffer[DRIVER_COUNT][192];
+bool g_pwm_buffer_update_required = false;
+
+uint8_t g_led_control_registers[DRIVER_COUNT][24] = { { 0 }, { 0 } };
+bool g_led_control_registers_update_required = false;
+
+void IS31FL3733_write_register( uint8_t addr, uint8_t reg, uint8_t data )
+{
+    g_twi_transfer_buffer[0] = reg;
+    g_twi_transfer_buffer[1] = data;
+
+  #if ISSI_PERSISTENCE > 0
+    for (uint8_t i = 0; i < ISSI_PERSISTENCE; i++) {
+      if (i2c_transmit(addr << 1, g_twi_transfer_buffer, 2, ISSI_TIMEOUT) == 0)
+        break;
+    }
+  #else
+    i2c_transmit(addr << 1, g_twi_transfer_buffer, 2, ISSI_TIMEOUT);
+  #endif
+}
+
+void IS31FL3733_write_pwm_buffer( uint8_t addr, uint8_t *pwm_buffer )
+{
+    // assumes PG1 is already selected
+
+    // transmit PWM registers in 12 transfers of 16 bytes
+    // g_twi_transfer_buffer[] is 20 bytes
+
+    // iterate over the pwm_buffer contents at 16 byte intervals
+    for ( int i = 0; i < 192; i += 16 ) {
+        g_twi_transfer_buffer[0] = i;
+        // copy the data from i to i+15
+        // device will auto-increment register for data after the first byte
+        // thus this sets registers 0x00-0x0F, 0x10-0x1F, etc. in one transfer
+        for ( int j = 0; j < 16; j++ ) {
+            g_twi_transfer_buffer[1 + j] = pwm_buffer[i + j];
+        }
+
+    #if ISSI_PERSISTENCE > 0
+      for (uint8_t i = 0; i < ISSI_PERSISTENCE; i++) {
+        if (i2c_transmit(addr << 1, g_twi_transfer_buffer, 17, ISSI_TIMEOUT) == 0)
+          break;
+      }
+    #else
+      i2c_transmit(addr << 1, g_twi_transfer_buffer, 17, ISSI_TIMEOUT);
+    #endif
+    }
+}
+
+void IS31FL3733_init( uint8_t addr )
+{
+    // In order to avoid the LEDs being driven with garbage data
+    // in the LED driver's PWM registers, shutdown is enabled last.
+    // Set up the mode and other settings, clear the PWM registers,
+    // then disable software shutdown.
+
+    // Unlock the command register.
+    IS31FL3733_write_register( addr, ISSI_COMMANDREGISTER_WRITELOCK, 0xC5 );
+
+    // Select PG0
+    IS31FL3733_write_register( addr, ISSI_COMMANDREGISTER, ISSI_PAGE_LEDCONTROL );
+    // Turn off all LEDs.
+    for ( int i = 0x00; i <= 0x17; i++ )
+    {
+        IS31FL3733_write_register( addr, i, 0x00 );
+    }
+
+    // Unlock the command register.
+    IS31FL3733_write_register( addr, ISSI_COMMANDREGISTER_WRITELOCK, 0xC5 );
+
+    // Select PG1
+    IS31FL3733_write_register( addr, ISSI_COMMANDREGISTER, ISSI_PAGE_PWM );
+    // Set PWM on all LEDs to 0
+    // No need to setup Breath registers to PWM as that is the default.
+    for ( int i = 0x00; i <= 0xBF; i++ )
+    {
+        IS31FL3733_write_register( addr, i, 0x00 );
+    }
+
+    // Unlock the command register.
+    IS31FL3733_write_register( addr, ISSI_COMMANDREGISTER_WRITELOCK, 0xC5 );
+
+    // Select PG3
+    IS31FL3733_write_register( addr, ISSI_COMMANDREGISTER, ISSI_PAGE_FUNCTION );
+    // Set global current to maximum.
+    IS31FL3733_write_register( addr, ISSI_REG_GLOBALCURRENT, 0xFF );
+    // Disable software shutdown.
+    IS31FL3733_write_register( addr, ISSI_REG_CONFIGURATION, 0x01 );
+
+    // Wait 10ms to ensure the device has woken up.
+    #ifdef __AVR__
+    _delay_ms( 10 );
+    #else
+    wait_ms(10);
+    #endif
+}
+
+void IS31FL3733_set_color( int index, uint8_t red, uint8_t green, uint8_t blue )
+{
+    if ( index >= 0 && index < DRIVER_LED_TOTAL ) {
+        is31_led led = g_is31_leds[index];
+
+        g_pwm_buffer[led.driver][led.r] = red;
+        g_pwm_buffer[led.driver][led.g] = green;
+        g_pwm_buffer[led.driver][led.b] = blue;
+        g_pwm_buffer_update_required = true;
+    }
+}
+
+void IS31FL3733_set_color_all( uint8_t red, uint8_t green, uint8_t blue )
+{
+    for ( int i = 0; i < DRIVER_LED_TOTAL; i++ )
+    {
+        IS31FL3733_set_color( i, red, green, blue );
+    }
+}
+
+void IS31FL3733_set_led_control_register( uint8_t index, bool red, bool green, bool blue )
+{
+    is31_led led = g_is31_leds[index];
+
+  uint8_t control_register_r = led.r / 8;
+  uint8_t control_register_g = led.g / 8;
+  uint8_t control_register_b = led.b / 8;
+  uint8_t bit_r = led.r % 8;
+  uint8_t bit_g = led.g % 8;
+  uint8_t bit_b = led.b % 8;
+
+    if ( red ) {
+        g_led_control_registers[led.driver][control_register_r] |= (1 << bit_r);
+    } else {
+        g_led_control_registers[led.driver][control_register_r] &= ~(1 << bit_r);
+    }
+    if ( green ) {
+        g_led_control_registers[led.driver][control_register_g] |= (1 << bit_g);
+    } else {
+        g_led_control_registers[led.driver][control_register_g] &= ~(1 << bit_g);
+    }
+    if ( blue ) {
+        g_led_control_registers[led.driver][control_register_b] |= (1 << bit_b);
+    } else {
+        g_led_control_registers[led.driver][control_register_b] &= ~(1 << bit_b);
+    }
+
+    g_led_control_registers_update_required = true;
+
+}
+
+void IS31FL3733_update_pwm_buffers( uint8_t addr1, uint8_t addr2 )
+{
+    if ( g_pwm_buffer_update_required )
+    {
+        // Firstly we need to unlock the command register and select PG1
+        IS31FL3733_write_register( addr1, ISSI_COMMANDREGISTER_WRITELOCK, 0xC5 );
+        IS31FL3733_write_register( addr1, ISSI_COMMANDREGISTER, ISSI_PAGE_PWM );
+
+        IS31FL3733_write_pwm_buffer( addr1, g_pwm_buffer[0] );
+        //IS31FL3733_write_pwm_buffer( addr2, g_pwm_buffer[1] );
+    }
+    g_pwm_buffer_update_required = false;
+}
+
+void IS31FL3733_update_led_control_registers( uint8_t addr1, uint8_t addr2 )
+{
+    if ( g_led_control_registers_update_required )
+    {
+        // Firstly we need to unlock the command register and select PG0
+        IS31FL3733_write_register( addr1, ISSI_COMMANDREGISTER_WRITELOCK, 0xC5 );
+        IS31FL3733_write_register( addr1, ISSI_COMMANDREGISTER, ISSI_PAGE_LEDCONTROL );
+        for ( int i=0; i<24; i++ )
+        {
+            IS31FL3733_write_register(addr1, i, g_led_control_registers[0][i] );
+            //IS31FL3733_write_register(addr2, i, g_led_control_registers[1][i] );
+        }
+    }
+}
+

drivers/issi/is31fl3733.h

@@ -0,0 +1,255 @@
+/* Copyright 2017 Jason Williams
+ * Copyright 2018 Jack Humbert
+ * Copyright 2018 Yiancar
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef IS31FL3733_DRIVER_H
+#define IS31FL3733_DRIVER_H
+
+#include <stdint.h>
+#include <stdbool.h>
+
+typedef struct is31_led {
+  uint8_t driver:2;
+  uint8_t r;
+  uint8_t g;
+  uint8_t b;
+} __attribute__((packed)) is31_led;
+
+extern const is31_led g_is31_leds[DRIVER_LED_TOTAL];
+
+void IS31FL3733_init( uint8_t addr );
+void IS31FL3733_write_register( uint8_t addr, uint8_t reg, uint8_t data );
+void IS31FL3733_write_pwm_buffer( uint8_t addr, uint8_t *pwm_buffer );
+
+void IS31FL3733_set_color( int index, uint8_t red, uint8_t green, uint8_t blue );
+void IS31FL3733_set_color_all( uint8_t red, uint8_t green, uint8_t blue );
+
+void IS31FL3733_set_led_control_register( uint8_t index, bool red, bool green, bool blue );
+
+// This should not be called from an interrupt
+// (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 IS31FL3733_update_pwm_buffers( uint8_t addr1, uint8_t addr2 );
+void IS31FL3733_update_led_control_registers( uint8_t addr1, uint8_t addr2 );
+
+#define A_1  0x00
+#define A_2  0x01
+#define A_3  0x02
+#define A_4  0x03
+#define A_5  0x04
+#define A_6  0x05
+#define A_7  0x06
+#define A_8  0x07
+#define A_9  0x08
+#define A_10  0x09
+#define A_11  0x0A
+#define A_12  0x0B
+#define A_13  0x0C
+#define A_14  0x0D
+#define A_15  0x0E
+#define A_16  0x0F
+
+#define B_1  0x10
+#define B_2  0x11
+#define B_3  0x12
+#define B_4  0x13
+#define B_5  0x14
+#define B_6  0x15
+#define B_7  0x16
+#define B_8  0x17
+#define B_9  0x18
+#define B_10  0x19
+#define B_11  0x1A
+#define B_12  0x1B
+#define B_13  0x1C
+#define B_14  0x1D
+#define B_15  0x1E
+#define B_16  0x1F
+
+#define C_1  0x20
+#define C_2  0x21
+#define C_3  0x22
+#define C_4  0x23
+#define C_5  0x24
+#define C_6  0x25
+#define C_7  0x26
+#define C_8  0x27
+#define C_9  0x28
+#define C_10  0x29
+#define C_11  0x2A
+#define C_12  0x2B
+#define C_13  0x2C
+#define C_14  0x2D
+#define C_15  0x2E
+#define C_16  0x2F
+
+#define D_1  0x30
+#define D_2  0x31
+#define D_3  0x32
+#define D_4  0x33
+#define D_5  0x34
+#define D_6  0x35
+#define D_7  0x36
+#define D_8  0x37
+#define D_9  0x38
+#define D_10  0x39
+#define D_11  0x3A
+#define D_12  0x3B
+#define D_13  0x3C
+#define D_14  0x3D
+#define D_15  0x3E
+#define D_16  0x3F
+
+#define E_1  0x40
+#define E_2  0x41
+#define E_3  0x42
+#define E_4  0x43
+#define E_5  0x44
+#define E_6  0x45
+#define E_7  0x46
+#define E_8  0x47
+#define E_9  0x48
+#define E_10  0x49
+#define E_11  0x4A
+#define E_12  0x4B
+#define E_13  0x4C
+#define E_14  0x4D
+#define E_15  0x4E
+#define E_16  0x4F
+
+#define F_1  0x50
+#define F_2  0x51
+#define F_3  0x52
+#define F_4  0x53
+#define F_5  0x54
+#define F_6  0x55
+#define F_7  0x56
+#define F_8  0x57
+#define F_9  0x58
+#define F_10  0x59
+#define F_11  0x5A
+#define F_12  0x5B
+#define F_13  0x5C
+#define F_14  0x5D
+#define F_15  0x5E
+#define F_16  0x5F
+
+#define G_1  0x60
+#define G_2  0x61
+#define G_3  0x62
+#define G_4  0x63
+#define G_5  0x64
+#define G_6  0x65
+#define G_7  0x66
+#define G_8  0x67
+#define G_9  0x68
+#define G_10  0x69
+#define G_11  0x6A
+#define G_12  0x6B
+#define G_13  0x6C
+#define G_14  0x6D
+#define G_15  0x6E
+#define G_16  0x6F
+
+#define H_1  0x70
+#define H_2  0x71
+#define H_3  0x72
+#define H_4  0x73
+#define H_5  0x74
+#define H_6  0x75
+#define H_7  0x76
+#define H_8  0x77
+#define H_9  0x78
+#define H_10  0x79
+#define H_11  0x7A
+#define H_12  0x7B
+#define H_13  0x7C
+#define H_14  0x7D
+#define H_15  0x7E
+#define H_16  0x7F
+
+#define I_1  0x80
+#define I_2  0x81
+#define I_3  0x82
+#define I_4  0x83
+#define I_5  0x84
+#define I_6  0x85
+#define I_7  0x86
+#define I_8  0x87
+#define I_9  0x88
+#define I_10  0x89
+#define I_11  0x8A
+#define I_12  0x8B
+#define I_13  0x8C
+#define I_14  0x8D
+#define I_15  0x8E
+#define I_16  0x8F
+
+#define J_1  0x90
+#define J_2  0x91
+#define J_3  0x92
+#define J_4  0x93
+#define J_5  0x94
+#define J_6  0x95
+#define J_7  0x96
+#define J_8  0x97
+#define J_9  0x98
+#define J_10  0x99
+#define J_11  0x9A
+#define J_12  0x9B
+#define J_13  0x9C
+#define J_14  0x9D
+#define J_15  0x9E
+#define J_16  0x9F
+
+#define K_1  0xA0
+#define K_2  0xA1
+#define K_3  0xA2
+#define K_4  0xA3
+#define K_5  0xA4
+#define K_6  0xA5
+#define K_7  0xA6
+#define K_8  0xA7
+#define K_9  0xA8
+#define K_10  0xA9
+#define K_11  0xAA
+#define K_12  0xAB
+#define K_13  0xAC
+#define K_14  0xAD
+#define K_15  0xAE
+#define K_16  0xAF
+
+#define L_1  0xB0
+#define L_2  0xB1
+#define L_3  0xB2
+#define L_4  0xB3
+#define L_5  0xB4
+#define L_6  0xB5
+#define L_7  0xB6
+#define L_8  0xB7
+#define L_9  0xB8
+#define L_10  0xB9
+#define L_11  0xBA
+#define L_12  0xBB
+#define L_13  0xBC
+#define L_14  0xBD
+#define L_15  0xBE
+#define L_16  0xBF
+
+#endif // IS31FL3733_DRIVER_H

keyboards/1upkeyboards/1up60hse/readme.md

@@ -10,6 +10,6 @@ Hardware Availability: [1upkeyboards.com](https://www.1upkeyboards.com/shop/cont
 
 Make example for this keyboard (after setting up your build environment):
 
-    make 1up60hse:default
+    make 1upkeyboards/1up60hse:default
 
-See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.
+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/1upkeyboards/1up60rgb/keymaps/raffle/keymap.c

@@ -0,0 +1,130 @@
+//****************************************************************************//
+// raffle's keymap for the 1up60rgb.                                          //
+//   emulates my pok3r layout and adds RGB control + firmware reset/debug     //
+//   layers                                                                   //
+//****************************************************************************//
+
+//************************ dependencies + definitions ************************//
+#include QMK_KEYBOARD_H
+
+// create names for layers
+enum layers {
+  _typing,
+  _raise,
+  _rgb,
+  _adjust
+};
+
+// define layer mods
+#define RAISE MO(_raise)
+#define RGB MO(_rgb)
+
+// define mod masks for making multi-key macros
+#define MODS_SHIFT_MASK  (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))
+#define MODS_CTRL_MASK  (MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTRL))
+#define MODS_ALT_MASK  (MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT))
+
+//********************************** Layers **********************************//
+// define layers
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+  // typing layer to handle basic typing
+  [_typing] = LAYOUT_all
+  (
+   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_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_LCTL, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT, KC_ENT,
+   KC_LSFT, 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_RSFT,
+   RAISE, KC_LGUI, KC_LALT, KC_SPC, KC_RALT, KC_RGUI, RGB, KC_RCTL
+   ),
+  // raise layer to handle function & nav keys
+  [_raise] = LAYOUT_all
+  (
+   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_DEL,
+   KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_CALC, KC_PGUP, KC_UP, KC_PGDN, KC_PSCR, KC_LSCR, KC_PAUSE, KC_TRNS,
+   KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_HOME, KC_LEFT, KC_DOWN, KC_RIGHT, KC_INS, KC_DEL, KC_TRNS, KC_TRNS,
+   KC_TRNS, KC_TRNS, KC_APP, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_END, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
+   KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS
+   ),
+  // rgb layer for pretty backlight colors
+  [_rgb] = LAYOUT_all
+  (
+   RGB_TOG, RGB_M_P, RGB_M_B, RGB_M_R, RGB_M_SW, RGB_M_SN, RGB_M_K, RGB_M_X, RGB_M_G, RGB_M_T, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
+   KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, RGB_HUI, RGB_VAI, RGB_HUD, KC_NO, KC_NO, KC_NO, KC_NO,
+   KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, RGB_MOD, RGB_SAI, RGB_VAD,RGB_SAD, KC_NO, KC_NO, KC_NO, KC_NO,
+   KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, RGB_RMOD, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
+   KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO
+   ),
+  // adjust to handle firmware debug + reset mode
+  [_adjust] = LAYOUT_all
+  (
+   RESET, DEBUG, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
+   KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
+   KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
+   KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
+   KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO
+   )
+};
+
+//***************************** Function bodies  *****************************//
+// enable tri-layer state for _raise + _rgb = _adjust
+uint32_t layer_state_set_user(uint32_t state) {
+  return update_tri_layer_state(state, _raise, _rgb, _adjust);
+}
+
+
+// scan matrix
+void matrix_scan_user(void) {
+}
+
+// support for standard mod state keys (caps lock, scroll lock, etc.)
+void led_set_user(uint8_t usb_led) {
+
+  if (usb_led & (1 << USB_LED_NUM_LOCK)) {
+
+  } else {
+
+  }
+
+  if (usb_led & (1 << USB_LED_CAPS_LOCK)) {
+    DDRB |= (1 << 2); PORTB &= ~(1 << 2);
+  } else {
+    DDRB &= ~(1 << 2); PORTB &= ~(1 << 2);
+  }
+
+  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 {
+
+  }
+
+}
+
+//*********** Empty fxns from default map that I'm not modifying ***********//
+// onboard macro support
+const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
+  ;
+
+  switch (id) {
+
+  }
+  return MACRO_NONE;
+}
+
+// initialize matrix 
+void matrix_init_user(void) {
+}
+
+
+

keyboards/1upkeyboards/1up60rgb/keymaps/raffle/readme.md

@@ -0,0 +1,43 @@
+## raffle's keymap
+The default keymap is just enough to get started. This keymap adds a pok3r-like
+raise layer, backlight RGB control layer, and firmware reset/debug adjust layer
+for ANSI layouts.
+
+In the default layer, the following modifications are made (using standard ANSI
+keys for LHS):
+
+- `CAPS` = `LCTRL`
+- `LCTRL` = `RAISE`
+- `APP` = `RGB`
+- `LCTRL` + `APP` (`RAISE` + `RGB`) = `ADJUST`
+- `GRV` = `ESC`
+
+Additionally, the pok3r's `SHIFT` + `ESC` for `~` is maintained (with either `SHIFT`).
+
+### Raise Layer
+Emulates standard pok3r layout (without the onboard macro keys)
+
+Highlights:
+
+- `IJKL` for arrow keys
+- `H`/`N` for `HOME`/`END`
+- `U`/`P` for `PGUP`/`PGDN`
+- `1` - `=` for `F1` - `F12`
+- `Y` for calculator
+
+Other standard keys from the pok3r layout are carried over. See the keymap or
+the pok3r documentation for details.
+
+### RGB Layer
+Uses navigation keys from `RAISE` layer for RGB adjustment
+
+- `I`/`K` for Value (brightness) Increase/Decrease
+- `U`/`P` for Hue (color) Increase/Decrease
+- `H`/`N` for Saturation Incrase/Decrease
+- `GRV` to toggle RGB on/off
+- `1`-`9` to activate QMK's predefined RGB animations
+
+### Adjust Layer
+
+- `GRV` activates firmware reset for flashing
+- `1` enters debug mode

keyboards/1upkeyboards/1up60rgb/readme.md

@@ -8,6 +8,6 @@ Hardware Availability: [1upkeyboards](https://www.1upkeyboards.com/shop/controll
 
 Make example for this keyboard (after setting up your build environment):
 
-    make 1up60rgb:default
+    make 1upkeyboards/1up60rgb:default
 
-See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.
+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/1upkeyboards/readme.md

@@ -0,0 +1,5 @@
+# 1UP Keyboards
+
+Website: [1UP Keyboards](https://www.1upkeyboards.com/)  
+Discord: [Server Invite](https://discordapp.com/invite/c6SYn8)  
+YouTube: [skiwithpete](https://www.youtube.com/user/skiwithpete)  

keyboards/1upkeyboards/sweet16/readme.md

@@ -9,6 +9,6 @@ Hardware Availability: [1up Keyboards](https://1upkeyboards.com/)
 
 Make example for this keyboard (after setting up your build environment):
 
-    make sweet16:default
+    make 1upkeyboards/sweet16:default
 
-See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.
+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/4x4/rules.mk

@@ -71,4 +71,4 @@ AUDIO_ENABLE = no           # Audio output on port C6
 FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
 HD44780_ENABLE = no 		# Enable support for HD44780 based LCDs (+400)
 
-LAYOUT = ortho_4x4  ortho_4x8  ortho_4x12  ortho_4x16 
+LAYOUTS = ortho_4x4  ortho_4x8  ortho_4x12  ortho_4x16 

keyboards/5x5/rules.mk

@@ -71,4 +71,4 @@ AUDIO_ENABLE = no           # Audio output on port C6
 FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
 HD44780_ENABLE = no 		# Enable support for HD44780 based LCDs (+400)
 
-LAYOUT = ortho_5x5  ortho_5x10  ortho_5x15
+LAYOUTS = ortho_5x5  ortho_5x10  ortho_5x15

keyboards/alpha/keymaps/default/keymap.c

@@ -1,32 +1,18 @@
 #include QMK_KEYBOARD_H
-const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
-	LAYOUT(
-		KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, 
-		KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, TO(1), 
-		KC_Z, KC_X, KC_C, KC_V, MT(MOD_LSFT, KC_SPC), KC_B, KC_N, KC_M),
-
-	LAYOUT(
-		KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, 
-		KC_BSPC, KC_ESC, KC_TAB, KC_SCLN, KC_QUOT, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT, TO(2), 
-		KC_LCTL, KC_LGUI, KC_LALT, TO(0), MT(MOD_LSFT, KC_ENT), KC_COMM, KC_DOT, KC_SLSH),
-
-	LAYOUT(
-		KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, 
-		KC_LSFT, KC_F11, KC_F12, KC_MINS, KC_EQL, KC_LBRC, KC_RBRC, KC_BSLS, KC_GRV, TO(3), 
-		RGB_VAI, RGB_VAD, RGB_HUI, TO(0), RGB_MOD, KC_MPLY, KC_VOLD, KC_VOLU),
-
-	LAYOUT(
-		RESET, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, 
-		KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, 
-		KC_NO, KC_NO, KC_NO, KC_NO, M(0), KC_NO, KC_NO, KC_NO),
+#define HOME 0
+#define MODS 1
+#define MODS2 2
+#define OTHER 3
 
+enum custom_keycodes {
+	MACRO1
 };
 
-bool process_record_user(uint16_t keycode, keyrecord_t *record) {	
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
 	if (record->event.pressed) {
 		switch (keycode) {
-			case 0:
+			case MACRO1:
 				SEND_STRING("I'm so sorry... -PyroL");
 				return false;
 		}
@@ -34,43 +20,30 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
 	return true;
 };
 
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+	[HOME] = LAYOUT(
+		KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P,
+		KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, TO(1),
+		KC_Z, KC_X, KC_C, KC_V, MT(MOD_LSFT, KC_SPC), KC_B, KC_N, KC_M),
+
+	[MODS] = LAYOUT(
+		KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0,
+		KC_BSPC, KC_ESC, KC_TAB, KC_SCLN, KC_QUOT, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT, TO(2),
+		KC_LCTL, KC_LGUI, KC_LALT, TO(0), MT(MOD_LSFT, KC_ENT), KC_COMM, KC_DOT, KC_SLSH),
+
+	[MODS2] = LAYOUT(
+		KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10,
+		KC_LSFT, KC_F11, KC_F12, KC_MINS, KC_EQL, KC_LBRC, KC_RBRC, KC_BSLS, KC_GRV, TO(3),
+		RGB_VAI, RGB_VAD, RGB_HUI, TO(0), RGB_MOD, KC_MPLY, KC_VOLD, KC_VOLU),
+
+	[OTHER] = LAYOUT(
+		RESET, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
+		KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
+		KC_NO, KC_NO, KC_NO, TO(0), MACRO1, KC_NO, KC_NO, KC_NO),
+};
+
 void matrix_init_user(void) {
 }
 
 void matrix_scan_user(void) {
 }
-
-
-void led_set_user(uint8_t usb_led) {
-
-	if (usb_led & (1 << USB_LED_NUM_LOCK)) {
-		
-	} else {
-		
-	}
-
-	if (usb_led & (1 << USB_LED_CAPS_LOCK)) {
-		
-	} else {
-		
-	}
-
-	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/alpha/readme.md

@@ -14,4 +14,6 @@ Make example for Alpha (after setting up your build environment):
 
     make alpha:default
 
-See [build environment setup](https://docs.qmk.fm/install-build-tools) then the [make instructions](https://docs.qmk.fm/faq/build-compile-qmk) for more information.
+See [build environment setup](https://docs.qmk.fm/install-build-tools) then the [make instructions](https://docs.qmk.fm/faq/build-compile-qmk) for more information.
+
+Please see [PyrooL/Alpha](https://www.github.com/PyrooL/Alpha) for **build instructions**, parts lists, Gerbers, and case files.

keyboards/at101_blackheart/at101_blackheart.c

@@ -0,0 +1 @@
+#include "at101_blackheart.h"

keyboards/at101_blackheart/at101_blackheart.h

@@ -0,0 +1,28 @@
+#ifndef at101_blackheart_H
+#define at101_blackheart_H
+
+#include "quantum.h"
+
+#define LAYOUT( \
+	K0000, K0100, K0001, K0101, K0002, K0102, K0003, K0103, K0004, K0104, K0005, K0105, K0006, 			K0106, K0007, K0107, \
+	K0200, K0300, K0201, K0301, K0202, K0302, K0203, K0303, K0204, K0304, K0205, K0305, K0206, K0306, 	K0207, K0307, K0208, 	K0308, K0209, K0309, K0009, \
+	K0400, K0500, K0401, K0501, K0402, K0502, K0403, K0503, K0404, K0504, K0405, K0505, K0406, K0506, 	K0407, K0507, K0408, 	K0508, K0409, K0509, K0109, \
+	K0600, K0700, K0601, K0701, K0602, K0702, K0603, K0703, K0604, K0704, K0605, K0705, K0606,        							K0608, K0708, K0609, K0709, \
+	K0800, K1101, K0900, K0801, K0901, K0802, K0902, K0803, K0903, K0804, K0904, K0805, K0905, K0806, 		   K0807, 			K0808, K0908, K0809, K0909, \
+	K1000, K1100, K1001,  			   K1102,                     		  K1005, K1105, K1006, K1106, 	K1007, K1107, K1008, 		K1108, 	  K1009 \
+) { \
+	{ K0000, K0001, K0002, K0003, K0004, K0005, K0006, K0007, KC_NO, K0009 }, \
+	{ K0100, K0101, K0102, K0103, K0104, K0105, K0106, K0107, KC_NO, K0109 }, \
+	{ K0200, K0201, K0202, K0203, K0204, K0205, K0206, K0207, K0208, K0209 }, \
+	{ K0300, K0301, K0302, K0303, K0304, K0305, K0306, K0307, K0308, K0309 }, \
+	{ K0400, K0401, K0402, K0403, K0404, K0405, K0406, K0407, K0408, K0409 }, \
+	{ K0500, K0501, K0502, K0503, K0504, K0505, K0506, K0507, K0508, K0509 }, \
+	{ K0600, K0601, K0602, K0603, K0604, K0605, K0606, KC_NO, K0608, K0609 }, \
+	{ K0700, K0701, K0702, K0703, K0704, K0705, KC_NO, KC_NO, K0708, K0709 }, \
+	{ K0800, K0801, K0802, K0803, K0804, K0805, K0806, K0807, K0808, K0809 }, \
+	{ K0900, K0901, K0902, K0903, K0904, K0905, KC_NO, KC_NO, K0908, K0909 }, \
+	{ K1000, K1001, KC_NO, KC_NO, KC_NO, K1005, K1006, K1007, K1008, K1009 }, \
+	{ K1100, K1101, K1102, KC_NO, KC_NO, K1105, K1106, K1107, K1108, KC_NO }  \
+}
+
+#endif

keyboards/at101_blackheart/config.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "config_common.h"
+
+/* USB Device descriptor parameter */
+#define VENDOR_ID       0xFEED
+#define PRODUCT_ID      0x6060
+#define DEVICE_VER      0x0001
+#define MANUFACTURER    blindassassin111
+#define PRODUCT         AT101_Blackheart PCB
+#define DESCRIPTION     Replacement AT101 PCB
+
+/* key matrix size */
+#define MATRIX_ROWS 12
+#define MATRIX_COLS 10
+
+/* key matrix pins */
+#define MATRIX_ROW_PINS { F0, F1, F4, D4, F6, F5, F7, B6, B5, D5, C7, C6 }
+#define MATRIX_COL_PINS { D1, D0, B7, B3, B2, B1, B0, E6, D2, D3 }
+#define UNUSED_PINS
+
+/* COL2ROW or ROW2COL */
+#define DIODE_DIRECTION COL2ROW
+
+/* Set 0 if debouncing isn't needed */
+#define DEBOUNCING_DELAY 5
+
+/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
+#define LOCKING_SUPPORT_ENABLE
+
+/* Locking resynchronize hack */
+#define LOCKING_RESYNC_ENABLE
+
+/* force n-key rollover*/
+#define FORCE_NKRO
+
+/* key combination for command */
+#define IS_COMMAND() ( \
+    keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
+)
+
+/* prevent stuck modifiers */
+#define PREVENT_STUCK_MODIFIERS

keyboards/at101_blackheart/keymaps/default/keymap.c

@@ -0,0 +1,53 @@
+#include QMK_KEYBOARD_H
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+	LAYOUT(
+		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_PSCR,KC_SLCK, KC_PAUS,
+		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_BSPC,		KC_INS, KC_HOME, KC_PGUP, 		KC_NLCK, KC_PSLS, KC_PAST, KC_PMNS,
+		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_DEL, KC_END,  KC_PGDN, 		KC_P7,   KC_P8,   KC_P9,   KC_PPLS,
+		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_P4, 	 KC_P5,   KC_P6,   KC_PEQL,
+		KC_LSFT,KC_BSLS,KC_Z, KC_X,  KC_C,  KC_V,  KC_B,  KC_N,  KC_M, KC_COMM,KC_DOT, KC_SLSH,KC_LSFT,MO(1), 				KC_UP, 					KC_P1,   KC_P2,   KC_P3,   KC_PENT,
+		KC_LCTL,KC_LGUI,KC_LALT, 			KC_SPC,				 		KC_RALT, KC_RGUI,KC_MENU, KC_RCTL,			KC_LEFT,KC_DOWN, KC_RGHT,			KC_P0,		  KC_PDOT),
+
+	LAYOUT(
+		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, 			KC_TRNS, KC_TRNS, KC_TRNS, 			  
+		RESET,   KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, 	KC_TRNS, KC_TRNS, KC_TRNS, 		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
+		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, 	KC_TRNS, KC_TRNS, KC_TRNS, 		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
+		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, 					 						KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, 
+		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, 			 KC_TRNS, 				KC_TRNS, KC_TRNS, KC_TRNS, 
+		KC_TRNS, KC_TRNS, KC_TRNS, 					 KC_TRNS, 							 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, 	KC_TRNS, KC_TRNS, KC_TRNS,			KC_TRNS, 	  KC_TRNS),
+};
+
+void matrix_init_user(void) {
+}
+
+void matrix_scan_user(void) {
+}
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+	return true;
+}
+
+void led_set_user(uint8_t usb_led) {
+  DDRB |= (1 << 4);
+  DDRD |= (1 << 6) | (1 << 7);
+
+  if (usb_led & (1 << USB_LED_NUM_LOCK)) {
+    PORTD |= (1 << 7);
+  } else {
+    PORTD &= ~(1 << 7);
+  }
+
+  if (usb_led & (1 << USB_LED_CAPS_LOCK)) {
+    PORTB |= (1 << 4);
+  } else {
+    PORTB &= ~(1 << 4);
+  }
+
+  if (usb_led & (1 << USB_LED_SCROLL_LOCK)) {
+    PORTD |= (1 << 6);
+  } else {
+    PORTD &= ~(1 << 6);
+  }
+}

keyboards/at101_blackheart/readme.md

@@ -0,0 +1,14 @@
+AT101 Blackheart PCB
+===
+
+A replacement PCB for AT101 keyboards.
+
+Keyboard Maintainer: QMK Community and blindassassin111  
+Hardware Supported: AT101 blackheart PCB  
+Hardware Availability: https://deskthority.net/group-buys-f50/programmable-vintage-board-pcbs-omnikey-at101-and-z-150-t19325.html
+
+Make example for this keyboard (after setting up your build environment):
+
+    make at101_blackheart:default
+
+See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.

keyboards/at101_blackheart/rules.mk

@@ -0,0 +1,59 @@
+# MCU name
+MCU = atmega32u4
+
+# Processor frequency.
+#     This will define a symbol, F_CPU, in all source code files equal to the
+#     processor frequency in Hz. You can then use this symbol in your source code to
+#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#     automatically to create a 32-bit value in your source code.
+#
+#     This will be an integer division of F_USB below, as it is sourced by
+#     F_USB after it has run through any CPU prescalers. Note that this value
+#     does not *change* the processor frequency - it should merely be updated to
+#     reflect the processor speed set externally so that the code can use accurate
+#     software delays.
+F_CPU = 16000000
+
+#
+# LUFA specific
+#
+# Target architecture (see library "Board Types" documentation).
+ARCH = AVR8
+
+# Input clock frequency.
+#     This will define a symbol, F_USB, in all source code files equal to the
+#     input clock frequency (before any prescaling is performed) in Hz. This value may
+#     differ from F_CPU if prescaling is used on the latter, and is required as the
+#     raw input clock is fed directly to the PLL sections of the AVR for high speed
+#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
+#     at the end, this will be done automatically to create a 32-bit value in your
+#     source code.
+#
+#     If no clock division is performed on the input clock inside the AVR (via the
+#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
+F_USB = $(F_CPU)
+
+# Interrupt driven control endpoint task(+60)
+OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
+
+
+# Bootloader selection
+BOOTLOADER = halfkay
+
+# Boot Section Size in *bytes*
+# OPT_DEFS += -DBOOTLOADER_SIZE=4096
+
+
+# Build Options
+#   comment out to disable the options.
+#
+BOOTMAGIC_ENABLE = yes	# Virtual DIP switch configuration(+1000)
+MOUSEKEY_ENABLE = yes	# Mouse keys(+4700)
+EXTRAKEY_ENABLE = yes	# Audio control and System control(+450)
+CONSOLE_ENABLE = no	# Console for debug(+400)
+COMMAND_ENABLE = no    # Commands for debug and configuration
+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  # Enable keyboard backlight functionality
+AUDIO_ENABLE = no
+RGBLIGHT_ENABLE = no

keyboards/atreus/keymaps/nojjan/config.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#undef MATRIX_ROW_PINS
+#undef MATRIX_COL_PINS
+#undef UNUSED_PINS
+
+// Pin configuration for falbatech atreus
+#define MATRIX_ROW_PINS { D0, D1, D3, D2 }
+#define MATRIX_COL_PINS { D7, C6, B5, B4, E6, D4, B6, F6, F7, D6, B7 }
+#define UNUSED_PINS

keyboards/atreus/keymaps/nojjan/keymap.c

@@ -0,0 +1,61 @@
+// this is the style you want to emulate.
+// This is the canonical layout file for the Quantum project. If you want to add another keyboard,
+
+#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 _QW 0
+#define _RS 1
+#define _LW 2
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+[_QW] = LAYOUT( /* Qwerty */
+  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,                      KC_Y,    KC_U,    KC_I,    KC_O,    KC_P    ,
+  KC_A,    KC_S,    KC_D,    KC_F,    KC_G,                      KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN ,
+  KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,                      KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH ,
+  KC_ESC, KC_TAB, KC_LGUI,  KC_LSFT, KC_BSPC,  KC_LCTL, KC_LALT, KC_SPC,  MO(_RS), KC_MINS, KC_QUOT, KC_ENT  ),
+/*
+ *  !       @     up     {    }        ||     pgup    7     8     9    *
+ *  #     left   down  right  $        ||     pgdn    4     5     6    +
+ *  [       ]      (     )    &        ||       `     1     2     3    \
+ * lower  insert super shift bksp ctrl || alt space   fn    .     0    =
+ */
+[_RS] = LAYOUT( /* [> RAISE <] */
+  KC_EXLM, KC_AT,   KC_UP,   KC_LCBR, KC_RCBR,                   KC_PGUP, KC_7,    KC_8,   KC_9, KC_ASTR ,
+  KC_HASH, KC_LEFT, KC_DOWN, KC_RGHT, KC_DLR,                    KC_PGDN, KC_4,    KC_5,   KC_6, KC_PLUS ,
+  KC_LBRC, KC_RBRC, KC_LPRN, KC_RPRN, KC_AMPR,                   KC_GRV,  KC_1,    KC_2,   KC_3, KC_BSLS ,
+  TG(_LW), KC_INS,  KC_LGUI, KC_LSFT, KC_BSPC, KC_LCTL, KC_LALT, KC_SPC,  KC_TRNS, KC_DOT, KC_0, KC_EQL  ),
+/*
+ * insert home   up  end   pgup       ||      up     F7    F8    F9   F10
+ *  del   left  down right pgdn       ||     down    F4    F5    F6   F11
+ *       volup             reset      ||             F1    F2    F3   F12
+ *       voldn  super shift bksp ctrl || alt space   L0  prtsc scroll pause
+ */
+[_LW] = LAYOUT( /* [> LOWER <] */
+  KC_INS,  KC_HOME, KC_UP,   KC_END,  KC_PGUP,                   KC_UP,   KC_F7,   KC_F8,   KC_F9,   KC_F10  ,
+  KC_DELT, KC_LEFT, KC_DOWN, KC_RGHT, KC_DOWN,                   KC_DOWN, KC_F4,   KC_F5,   KC_F6,   KC_F11  ,
+  KC_NO,   KC_VOLU, KC_NO,   KC_NO,   RESET,                     KC_NO,   KC_F1,   KC_F2,   KC_F3,   KC_F12  ,
+  KC_NO,   KC_VOLD, KC_LGUI, KC_LSFT, KC_BSPC, KC_LCTL, KC_LALT, KC_SPC,  TO(_QW), KC_PSCR, KC_SLCK, KC_PAUS )
+};
+
+const uint16_t PROGMEM fn_actions[] = {
+
+};
+
+const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
+{
+  // MACRODOWN only works in this function
+      switch(id) {
+        case 0:
+          if (record->event.pressed) {
+            register_code(KC_RSFT);
+          } else {
+            unregister_code(KC_RSFT);
+          }
+        break;
+      }
+    return MACRO_NONE;
+};

keyboards/atreus62/keymaps/xyverz/keymap.c

@@ -127,8 +127,17 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
 };
 
-const uint16_t PROGMEM fn_actions[] = {
+void matrix_init_user(void) {
+#ifdef BOOTLOADER_CATERINA
+   // This will disable the red LEDs on the ProMicros
+   DDRD &= ~(1<<5);
+   PORTD &= ~(1<<5);
+   DDRB &= ~(1<<0);
+   PORTB &= ~(1<<0);
+#endif
+};
 
+const uint16_t PROGMEM fn_actions[] = {
 };
 
 void persistent_default_layer_set(uint16_t default_layer) {

keyboards/converter/usb_usb/README.md

@@ -3,8 +3,8 @@ USB to USB keyboard protocol converter
 A small device to connect between your USB keyboard and your PC that makes (almost) every keyboard fully programmable.
 Original code from the [TMK firmware](https://github.com/tmk/tmk_keyboard/tree/master/converter/usb_usb). Ported to QMK by [Balz Guenat](https://github.com/BalzGuenat).
 
-Keyboard Maintainer: [Balz Guenat](https://github.com/BalzGuenat)
-Hardware Supported: [Hasu's USB-USB converter](https://geekhack.org/index.php?topic=69169.0), [Pro Micro + USB Host Shield](https://geekhack.org/index.php?topic=80421.0), maybe more
+Keyboard Maintainer: [Balz Guenat](https://github.com/BalzGuenat)  
+Hardware Supported: [Hasu's USB-USB converter](https://geekhack.org/index.php?topic=69169.0), [Pro Micro + USB Host Shield](https://geekhack.org/index.php?topic=80421.0), maybe more  
 Hardware Availability: [GH thread](https://geekhack.org/index.php?topic=72052.0), self-built
 
 Make example for this keyboard (after setting up your build environment):

keyboards/cospad/cospad.h

@@ -22,6 +22,21 @@
    * `-------------------'
  */
 
+/* COSPAD gamepad matrix layout
+   * ,-------------------.
+   * | 00 | 01 | 02 | 03 |
+   * |----|----|----|----|
+   * | 10 | 11 | 12 | 13 |
+   * |----|----|----|----|
+   * | 20 | 21 | 22 |    |
+   * |----|----|----| 23 |
+   * | 30 | 31 | 32 |    |
+   * |----|----|----|----|
+   * | 40 | 41 | 42 | 43 |
+   * |----|----|----|----|
+   * | 50 | 51 | 52 | 53 |
+   * `-------------------'
+ */
 
 /* COSPAD numpad matrix layout
    * ,-------------------.
@@ -41,7 +56,7 @@
 // The first section contains all of the arguments
 // The second converts the arguments into a two-dimensional array
 #define LAYOUT_ortho_6x4( \
-  k00, k01, k02, k03, \
+	k00, k01, k02, k03, \
 	k10, k11, k12, k13, \
 	k20, k21, k22, k23, \
 	k30, k31, k32, k33, \
@@ -57,8 +72,25 @@
 	{k50, k51, k52, k53}  \
 }
 
+#define LAYOUT_gamepad_6x4( \
+	k00, k01, k02, k03, \
+	k10, k11, k12, k13, \
+	k20, k21, k22,      \
+	k30, k31, k32, k23, \
+	k40, k41, k42, k43, \
+	k50, k51, k52, k53  \
+) \
+{ \
+	{k00, k01, k02, k03},   \
+	{k10, k11, k12, k13},   \
+	{k20, k21, k22, k23},   \
+	{k30, k31, k32, KC_NO}, \
+	{k40, k41, k42, k43},   \
+	{k50, k51, k52, k53}    \
+}
+
 #define LAYOUT_numpad_6x4( \
-  k00, k01, k02, k03,  \
+	k00, k01, k02, k03,  \
 	k10, k11, k12, k13,  \
 	k20, k21, k22,       \
 	k30, k31, k32, k23,  \

keyboards/cospad/keymaps/detrus/keymap.c

@@ -0,0 +1,369 @@
+#include QMK_KEYBOARD_H
+#include "led.h"
+#include <print.h>
+
+#ifdef RGBLIGHT_ENABLE
+#include "rgblight.h"
+#endif
+
+#define _______ KC_TRNS
+
+// Each layer gets a name for readability, which is then used in the keymap matrix below.
+enum cospad_layers {
+	_QWERTY_LAYER,
+	_QWERTZ_LAYER,
+	_COLEMA_LAYER,
+	_DVORAK_LAYER,
+	_QWERTY_LOWER_LAYER,
+	_QWERTZ_LOWER_LAYER,
+	_COLEMA_LOWER_LAYER,
+	_DVORAK_LOWER_LAYER,
+	_RAISE_LAYER,
+	_ALTER_LAYER,
+};
+
+// To switch the default layer used for the layout, there are special keycodes.
+// Which onces detected below serve to switch it.
+enum cospad_keycodes {
+	QWERTY = SAFE_RANGE,
+	QWERTZ,
+	COLEMAK,
+	DVORAK
+};
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+	/* Keymap _QWERTY_LAYER: Default layer
+	 * ,-----------------------.
+	 * |  T  |  G  |  B  | Alt |
+	 * |-----|-----|-----|-----|
+	 * |  R  |  F  |  V  | LOW |
+	 * |-----|-----|-----|-----|
+	 * |  E  |  D  |  C  |     |
+	 * |-----|-----|-----| Spc |
+	 * |  W  |  S  |  X  |     |
+	 * |-----|-----|-----|-----|
+	 * |  Q  |  A  |  Z  | RAI |
+	 * |-----|-----|-----|-----|
+	 * | Esc | Tab | Sft | Ctl |
+	 * `-----------------------'
+	 *
+	 *   And it's LOWER layer
+	 * ,-----------------------.
+	 * |  P  |  ;  |  /  | Alt |
+	 * |-----|-----|-----|-----|
+	 * |  O  |  L  |  .  | LOW |
+	 * |-----|-----|-----|-----|
+	 * |  I  |  K  |  ,  |     |
+	 * |-----|-----|-----| Ent |
+	 * |  U  |  J  |  M  |     |
+	 * |-----|-----|-----|-----|
+	 * |  Y  |  H  |  N  | RAI |
+	 * |-----|-----|-----|-----|
+	 * | Esc | Tab | Sft | Ctl |
+	 * `-----------------------'
+	 */
+	[_QWERTY_LAYER] = LAYOUT_gamepad_6x4(
+			KC_T,    KC_G,    KC_B,    KC_LALT,  \
+			KC_R,    KC_F,    KC_V,    MO(_QWERTY_LOWER_LAYER),\
+			KC_E,    KC_D,    KC_C,              \
+			KC_W,    KC_S,    KC_X,    KC_SPACE, \
+			KC_Q,    KC_A,    KC_Z,    MO(_RAISE_LAYER),\
+			KC_GESC, KC_TAB,  KC_LSFT, KC_LCTRL),
+	[_QWERTY_LOWER_LAYER] = LAYOUT_gamepad_6x4(
+			KC_P,    KC_SCLN, KC_SLSH, KC_LALT,  \
+			KC_O,    KC_L,    KC_DOT,  _______,  \
+			KC_I,    KC_K,    KC_COMM,           \
+			KC_U,    KC_J,    KC_M,    KC_ENTER, \
+			KC_Y,    KC_H,    KC_N,    _______,  \
+			_______, _______,  _______, _______),
+
+
+
+	/* Keymap _QWERTZ_LAYER: Alternate default layer
+	 * ,-----------------------.
+	 * |  T  |  G  |  B  | Alt |
+	 * |-----|-----|-----|-----|
+	 * |  R  |  F  |  V  | LOW |
+	 * |-----|-----|-----|-----|
+	 * |  E  |  D  |  C  |     |
+	 * |-----|-----|-----| Spc |
+	 * |  W  |  S  |  X  |     |
+	 * |-----|-----|-----|-----|
+	 * |  Q  |  A  |  Y  | RAI |
+	 * |-----|-----|-----|-----|
+	 * | Esc | Tab | Sft | Ctl |
+	 * `-----------------------'
+	 *
+	 *   And it's LOWER layer
+	 * ,-----------------------.
+	 * |  P  |  ;  |  /  | Alt |
+	 * |-----|-----|-----|-----|
+	 * |  O  |  L  |  >  | LOW |
+	 * |-----|-----|-----|-----|
+	 * |  I  |  K  |  <  |     |
+	 * |-----|-----|-----| Ent |
+	 * |  U  |  J  |  M  |     |
+	 * |-----|-----|-----|-----|
+	 * |  Z  |  H  |  N  | RAI |
+	 * |-----|-----|-----|-----|
+	 * | Esc | Tab | Sft | Ctl |
+	 * `-----------------------'
+	 */
+	[_QWERTZ_LAYER] = LAYOUT_gamepad_6x4(
+			KC_T,    KC_G,    KC_B,    KC_LALT,  \
+			KC_R,    KC_F,    KC_V,    MO(_QWERTZ_LOWER_LAYER),\
+			KC_E,    KC_D,    KC_C,              \
+			KC_W,    KC_S,    KC_X,    KC_SPACE, \
+			KC_Q,    KC_A,    KC_Y,    MO(_RAISE_LAYER),\
+			KC_GESC, KC_TAB,  KC_LSFT, KC_LCTRL),
+	[_QWERTZ_LOWER_LAYER] = LAYOUT_gamepad_6x4(
+			KC_P,    KC_SCLN, KC_SLSH, KC_LALT,  \
+			KC_O,    KC_L,    KC_DOT,  _______,  \
+			KC_I,    KC_K,    KC_COMM,           \
+			KC_U,    KC_J,    KC_M,    KC_ENTER, \
+			KC_Z,    KC_H,    KC_N,    _______,  \
+			_______, _______, _______, _______),
+
+
+
+	/* Keymap _COLEMA_LAYER: Alternate default layer
+	 * ,-----------------------.
+	 * |  G  |  D  |  B  | Alt |
+	 * |-----|-----|-----|-----|
+	 * |  P  |  T  |  V  | LOW |
+	 * |-----|-----|-----|-----|
+	 * |  F  |  S  |  C  |     |
+	 * |-----|-----|-----| Spc |
+	 * |  W  |  R  |  X  |     |
+	 * |-----|-----|-----|-----|
+	 * |  Q  |  A  |  Z  | RAI |
+	 * |-----|-----|-----|-----|
+	 * | Esc | Tab | Sft | Ctl |
+	 * `-----------------------'
+	 *
+	 *   And it's LOWER layer
+	 * ,-----------------------.
+	 * |  ;  |  O  |  /  | Alt |
+	 * |-----|-----|-----|-----|
+	 * |  Y  |  I  |  .  | LOW |
+	 * |-----|-----|-----|-----|
+	 * |  U  |  E  |  ,  |     |
+	 * |-----|-----|-----| Ent |
+	 * |  L  |  N  |  M  |     |
+	 * |-----|-----|-----|-----|
+	 * |  J  |  H  |  K  | RAI |
+	 * |-----|-----|-----|-----|
+	 * | Esc | Tab | Sft | Ctl |
+	 * `-----------------------'
+	 */
+	[_COLEMA_LAYER] = LAYOUT_gamepad_6x4(
+			KC_T,    KC_D,     KC_B,    KC_LALT,  \
+			KC_R,    KC_T,     KC_V,    MO(_COLEMA_LOWER_LAYER),\
+			KC_E,    KC_S,     KC_C,              \
+			KC_W,    KC_R,     KC_X,    KC_SPACE, \
+			KC_Q,    KC_A,     KC_Z,    MO(_RAISE_LAYER),\
+			KC_GESC, KC_TAB,   KC_LSFT, KC_LCTRL),
+	[_COLEMA_LOWER_LAYER] = LAYOUT_gamepad_6x4(
+			KC_SCLN, KC_O,     KC_SLSH, _______,  \
+			KC_Y,    KC_I,     KC_DOT,  _______,  \
+			KC_U,    KC_E,     KC_COMM,           \
+			KC_L,    KC_N,     KC_M,    KC_ENTER, \
+			KC_J,    KC_H,     KC_K,    _______,  \
+			KC_F,    KC_G,     _______, _______),
+
+
+
+	/* Keymap _DVORAK_LAYER: Alternate default layer
+	 * ,-----------------------.
+	 * |  Y  |  I  |  X  | Alt |
+	 * |-----|-----|-----|-----|
+	 * |  P  |  U  |  K  | LOW |
+	 * |-----|-----|-----|-----|
+	 * |  .  |  E  |  J  |     |
+	 * |-----|-----|-----| Spc |
+	 * |  ,  |  O  |  Q  |     |
+	 * |-----|-----|-----|-----|
+	 * |  '  |  A  |  ;  | RAI |
+	 * |-----|-----|-----|-----|
+	 * | Esc | Tab | Sft | Ctl |
+	 * `-----------------------'
+	 *
+	 *   And it's LOWER layer
+	 * ,-----------------------.
+	 * |  L  |  S  |  Z  | Alt |
+	 * |-----|-----|-----|-----|
+	 * |  R  |  N  |  V  | LOW |
+	 * |-----|-----|-----|-----|
+	 * |  C  |  T  |  W  |     |
+	 * |-----|-----|-----| Ent |
+	 * |  G  |  H  |  M  |     |
+	 * |-----|-----|-----|-----|
+	 * |  F  |  D  |  B  | RAI |
+	 * |-----|-----|-----|-----|
+	 * | Esc | Tab | Sft | Ctl |
+	 * `-----------------------'
+	 */
+	[_DVORAK_LAYER] = LAYOUT_gamepad_6x4(
+			KC_Y,    KC_I,    KC_X,    KC_LALT,   \
+			KC_P,    KC_U,    KC_K,    MO(_DVORAK_LOWER_LAYER),\
+			KC_DOT,  KC_E,    KC_J,               \
+			KC_COMM, KC_O,    KC_A,    KC_SPACE,  \
+			KC_QUOT, KC_A,    KC_SCLN, MO(_RAISE_LAYER),\
+			KC_GESC, KC_TAB,  KC_LSFT, KC_LCTRL),
+	[_DVORAK_LOWER_LAYER] = LAYOUT_gamepad_6x4(
+			KC_L,    KC_S,    KC_Z,    KC_LALT, \
+			KC_R,    KC_N,    KC_V,    _______, \
+			KC_C,    KC_T,    KC_W,             \
+			KC_G,    KC_H,    KC_M,    KC_ENTER,\
+			KC_F,    KC_D,    KC_B,    _______, \
+			_______, _______, _______, _______),
+
+
+
+	/* Keymap _RAISE_LAYER: Additional layer to access more
+	 * ,-----------------------.
+	 * |  5  |  0  | del | Alt |
+	 * |-----|-----|-----|-----|
+	 * |  4  |  9  | ->  | LOW |
+	 * |-----|-----|-----|-----|
+	 * |  3  |  8  |  <- |     |
+	 * |-----|-----|-----| Spc |
+	 * |  2  |  7  | ->  |     |
+	 * |-----|-----|-----|-----|
+	 * |  1  |  6  |  <- | RAI |
+	 * |-----|-----|-----|-----|
+	 * | Esc | Tab | Sft | Ctl |
+	 * `-----------------------'
+	 */
+	[_RAISE_LAYER] = LAYOUT_gamepad_6x4(
+			KC_5,    KC_0,   KC_BSPC,  _______, \
+			KC_4,    KC_9,   KC_RIGHT, _______, \
+			KC_3,    KC_8,   KC_UP,             \
+			KC_2,    KC_7,   KC_DOWN,  _______, \
+			KC_1,    KC_6,   KC_LEFT,  _______, \
+			_______, _______, _______, _______),
+
+
+
+	/* Keymap _ALTER_LAYER: Function layer used to control the Leds
+	 *                     and use media buttons
+	 * ,----------------------------------------.
+	 * | Val Dec | Bl Toggle  | Qwertz  | Super |
+	 * |---------|------------|---------|-------|
+	 * | Val Inc |   Bl Off   | Qwerty  |       |
+	 * |---------|------------|---------|-------|
+	 * | Sat Dec |   Bl On    | Colemak |       |
+	 * |---------|------------|---------|       |
+	 * | Sat Inc | RGB Toggle | Dvorak  |       |
+	 * |---------|------------|---------|-------|
+	 * | Hue Dec |  RGB Next  | Vol Dwn |       |
+	 * |---------|------------|---------|-------|
+	 * | Hue Inc |  RGB Prev  | Vol Up  | Reset |
+	 * `----------------------------------------'
+	 */
+	[_ALTER_LAYER] = LAYOUT_gamepad_6x4(
+			RGB_VAD, BL_TOGG,  QWERTZ,  KC_LGUI, \
+			RGB_VAI, BL_OFF,   QWERTY,  _______, \
+			RGB_SAD, BL_ON,    COLEMAK,          \
+			RGB_SAI, RGB_TOG,  DVORAK,  _______, \
+			RGB_HUD, RGB_MOD,  KC_VOLD, _______, \
+			RGB_HUI, RGB_RMOD, KC_VOLU, RESET),
+};
+
+// Makes sure to update the good tri-layer if a layer changes
+uint32_t layer_state_set_user(uint32_t state) {
+	switch (biton32(default_layer_state)) {
+		case _QWERTY_LAYER:
+			state = update_tri_layer_state(state, _RAISE_LAYER, _QWERTY_LOWER_LAYER, _ALTER_LAYER);
+			break;
+		case _QWERTZ_LAYER:
+			state = update_tri_layer_state(state, _RAISE_LAYER, _QWERTZ_LOWER_LAYER, _ALTER_LAYER);
+			break;
+		case _COLEMA_LAYER:
+			state = update_tri_layer_state(state, _RAISE_LAYER, _COLEMA_LOWER_LAYER, _ALTER_LAYER);
+			break;
+		case _DVORAK_LAYER:
+			state = update_tri_layer_state(state, _RAISE_LAYER, _DVORAK_LOWER_LAYER, _ALTER_LAYER);
+			break;
+	}
+	return state;
+}
+
+// Makes the tri-layer
+uint32_t default_layer_state_set_kb(uint32_t state) {
+	switch (biton32(state)) {
+		case _QWERTY_LAYER:
+			state = update_tri_layer_state(state, _RAISE_LAYER, _QWERTZ_LOWER_LAYER, _ALTER_LAYER);
+			state = update_tri_layer_state(state, _RAISE_LAYER, _COLEMA_LOWER_LAYER, _ALTER_LAYER);
+			state = update_tri_layer_state(state, _RAISE_LAYER, _DVORAK_LOWER_LAYER, _ALTER_LAYER);
+			layer_move(_QWERTY_LAYER);
+			break;
+		case _QWERTZ_LAYER:
+			state = update_tri_layer_state(state, _RAISE_LAYER, _QWERTY_LOWER_LAYER, _ALTER_LAYER);
+			state = update_tri_layer_state(state, _RAISE_LAYER, _COLEMA_LOWER_LAYER, _ALTER_LAYER);
+			state = update_tri_layer_state(state, _RAISE_LAYER, _DVORAK_LOWER_LAYER, _ALTER_LAYER);
+			layer_move(_QWERTZ_LAYER);
+			break;
+		case _COLEMA_LAYER:
+			state = update_tri_layer_state(state, _RAISE_LAYER, _QWERTY_LOWER_LAYER, _ALTER_LAYER);
+			state = update_tri_layer_state(state, _RAISE_LAYER, _QWERTZ_LOWER_LAYER, _ALTER_LAYER);
+			state = update_tri_layer_state(state, _RAISE_LAYER, _DVORAK_LOWER_LAYER, _ALTER_LAYER);
+			layer_move(_COLEMA_LAYER);
+			break;
+		case _DVORAK_LAYER:
+			state = update_tri_layer_state(state, _RAISE_LAYER, _QWERTY_LOWER_LAYER, _ALTER_LAYER);
+			state = update_tri_layer_state(state, _RAISE_LAYER, _QWERTZ_LOWER_LAYER, _ALTER_LAYER);
+			state = update_tri_layer_state(state, _RAISE_LAYER, _COLEMA_LOWER_LAYER, _ALTER_LAYER);
+			layer_move(_DVORAK_LAYER);
+			break;
+	}
+	return state;
+}
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+	switch (keycode) {
+		case BL_TOGG:
+			if (record->event.pressed) {
+				cospad_bl_led_togg();
+			}
+			return false;
+		case BL_ON:
+			if (record->event.pressed) {
+				cospad_bl_led_on();
+			}
+			return false;
+		case BL_OFF:
+			if (record->event.pressed) {
+				cospad_bl_led_off();
+			}
+			return false;
+		case QWERTY:
+			if (record->event.pressed) {
+				set_single_persistent_default_layer(_QWERTY_LAYER);
+				print("switched to QWERTY layout\n");
+			}
+			return false;
+			break;
+		case QWERTZ:
+			if (record->event.pressed) {
+				set_single_persistent_default_layer(_QWERTZ_LAYER);
+			}
+			return false;
+			break;
+		case COLEMAK:
+			if (record->event.pressed) {
+				set_single_persistent_default_layer(_COLEMA_LAYER);
+			}
+			return false;
+			break;
+		case DVORAK:
+			if (record->event.pressed) {
+				set_single_persistent_default_layer(_DVORAK_LAYER);
+			}
+			return false;
+			break;
+		default:
+			return true;
+	}
+}

keyboards/crkbd/config.h

@@ -16,9 +16,16 @@ You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef CONFIG_H
-#define CONFIG_H
+#pragma once
 
 #include "config_common.h"
+#include <serial_config.h>
 
-#endif
+#ifdef USE_Link_Time_Optimization
+  // LTO has issues with macros (action_get_macro) and "functions" (fn_actions),
+  //  so just disable them
+  #define NO_ACTION_MACRO
+  #define NO_ACTION_FUNCTION
+
+  #define DISABLE_LEADER
+#endif // USE_Link_Time_Optimization

keyboards/crkbd/crkbd.h

@@ -1,8 +1,5 @@
-#ifndef CRKBD_H
-#define CRKBD_H
+#pragma once
 
 #ifdef KEYBOARD_crkbd_rev1
   #include "rev1.h"
 #endif
-
-#endif

keyboards/crkbd/i2c.c

@@ -34,7 +34,7 @@ void i2c_delay(void) {
   // _delay_us(100);
 }
 
-// Setup twi to run at 100kHz
+// Setup twi to run at 100kHz or 400kHz (see ./i2c.h SCL_CLOCK)
 void i2c_master_init(void) {
   // no prescaler
   TWSR = 0;

keyboards/crkbd/i2c.h

@@ -1,5 +1,4 @@
-#ifndef I2C_H
-#define I2C_H
+#pragma once
 
 #include <stdint.h>
 
@@ -15,7 +14,7 @@
 
 #define SLAVE_BUFFER_SIZE 0x10
 
-// i2c SCL clock frequency
+// i2c SCL clock frequency 400kHz
 #define SCL_CLOCK  400000L
 
 extern volatile uint8_t i2c_slave_buffer[SLAVE_BUFFER_SIZE];
@@ -45,5 +44,3 @@ extern unsigned char i2c_readNak(void);
 extern unsigned char i2c_read(unsigned char ack);
 
 #define i2c_read(ack)  (ack) ? i2c_readAck() : i2c_readNak();
-
-#endif

keyboards/crkbd/keymaps/default/keymap.c

@@ -5,7 +5,6 @@
   #include "split_util.h"
 #endif
 #ifdef SSD1306OLED
-  #include "LUFA/Drivers/Peripheral/TWI.h"
   #include "ssd1306.h"
 #endif
 
@@ -130,7 +129,6 @@ void matrix_init_user(void) {
     #endif
     //SSD1306 OLED init, make sure to add #define SSD1306OLED in config.h
     #ifdef SSD1306OLED
-        TWI_Init(TWI_BIT_PRESCALE_1, TWI_BITLENGTH_FROM_FREQ(1, 800000));
         iota_gfx_init(!has_usb());   // turns on the display
     #endif
 }

keyboards/crkbd/keymaps/default/rules.mk

@@ -21,10 +21,10 @@ SWAP_HANDS_ENABLE = no        # Enable one-hand typing
 SLEEP_LED_ENABLE = no    # Breathing sleep LED during USB suspend
 
 # If you want to change the display of OLED, you need to change here
-SRC +=  ../lib/rgb_state_reader.c \
-        ../lib/layer_state_reader.c \
-        ../lib/logo_reader.c \
-        ../lib/keylogger.c \
-        # ../lib/mode_icon_reader.c \
-        # ../lib/host_led_state_reader.c \
-        # ../lib/timelogger.c \
+SRC +=  ./lib/rgb_state_reader.c \
+        ./lib/layer_state_reader.c \
+        ./lib/logo_reader.c \
+        ./lib/keylogger.c \
+        # ./lib/mode_icon_reader.c \
+        # ./lib/host_led_state_reader.c \
+        # ./lib/timelogger.c \

keyboards/crkbd/keymaps/like_jis/keymap.c

@@ -5,7 +5,6 @@
   #include "split_util.h"
 #endif
 #ifdef SSD1306OLED
-  #include "LUFA/Drivers/Peripheral/TWI.h"
   #include "ssd1306.h"
 #endif
 
@@ -124,7 +123,6 @@ void matrix_init_user(void) {
     #endif
     //SSD1306 OLED init, make sure to add #define SSD1306OLED in config.h
     #ifdef SSD1306OLED
-        TWI_Init(TWI_BIT_PRESCALE_1, TWI_BITLENGTH_FROM_FREQ(1, 800000));
         iota_gfx_init(!has_usb());   // turns on the display
     #endif
 }

keyboards/crkbd/keymaps/like_jis/rules.mk

@@ -21,10 +21,10 @@ SWAP_HANDS_ENABLE = no        # Enable one-hand typing
 SLEEP_LED_ENABLE = no    # Breathing sleep LED during USB suspend
 
 # If you want to change the display of OLED, you need to change here
-SRC +=  ../lib/rgb_state_reader.c \
-        ../lib/layer_state_reader.c \
-        ../lib/logo_reader.c \
-        ../lib/keylogger.c \
-        # ../lib/mode_icon_reader.c \
-        # ../lib/host_led_state_reader.c \
-        # ../lib/timelogger.c \
+SRC +=  ./lib/rgb_state_reader.c \
+        ./lib/layer_state_reader.c \
+        ./lib/logo_reader.c \
+        ./lib/keylogger.c \
+        # ./lib/mode_icon_reader.c \
+        # ./lib/host_led_state_reader.c \
+        # ./lib/timelogger.c \

keyboards/crkbd/pro_micro.h

@@ -21,9 +21,7 @@
 
   $Id: wiring.h 249 2007-02-03 16:52:51Z mellis $
 */
-
-#ifndef Pins_Arduino_h
-#define Pins_Arduino_h
+#pragma once
 
 #include <avr/pgmspace.h>
 
@@ -358,5 +356,3 @@ const uint8_t PROGMEM analog_pin_to_channel_PGM[] = {
 #define SERIAL_PORT_USBVIRTUAL     Serial
 #define SERIAL_PORT_HARDWARE       Serial1
 #define SERIAL_PORT_HARDWARE_OPEN  Serial1
-
-#endif /* Pins_Arduino_h */

keyboards/crkbd/rev1/config.h

@@ -16,10 +16,7 @@ You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef REV1_CONFIG_H
-#define REV1_CONFIG_H
-
-#include "../config.h"
+#pragma once
 
 /* USB Device descriptor parameter */
 #define VENDOR_ID       0xFEED
@@ -82,6 +79,3 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //#define NO_ACTION_ONESHOT
 //#define NO_ACTION_MACRO
 //#define NO_ACTION_FUNCTION
-
-
-#endif

keyboards/crkbd/rev1/matrix.c

@@ -20,6 +20,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 #include <stdint.h>
 #include <stdbool.h>
+#include <string.h>
 #include <avr/io.h>
 #include <avr/wdt.h>
 #include <avr/interrupt.h>
@@ -30,12 +31,11 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "matrix.h"
 #include "split_util.h"
 #include "pro_micro.h"
-#include "config.h"
 
 #ifdef USE_MATRIX_I2C
 #  include "i2c.h"
 #else // USE_SERIAL
-#  include "serial.h"
+#  include "split_scomm.h"
 #endif
 
 #ifndef DEBOUNCE
@@ -103,6 +103,8 @@ void matrix_init(void)
     init_cols();
 
     TX_RX_LED_INIT;
+    TXLED0;
+    RXLED0;
 
     // initialize matrix state: all keys off
     for (uint8_t i=0; i < MATRIX_ROWS; i++) {
@@ -179,17 +181,20 @@ i2c_error: // the cable is disconnceted, or something else went wrong
 
 #else // USE_SERIAL
 
-int serial_transaction(void) {
+int serial_transaction(int master_changed) {
     int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
+#ifdef SERIAL_USE_MULTI_TRANSACTION
+    int ret=serial_update_buffers(master_changed);
+#else
     int ret=serial_update_buffers();
+#endif
     if (ret ) {
-        if(ret==2)RXLED1;
+        if(ret==2) RXLED1;
         return 1;
     }
-RXLED0;
-    for (int i = 0; i < ROWS_PER_HAND; ++i) {
-        matrix[slaveOffset+i] = serial_slave_buffer[i];
-    }
+    RXLED0;
+    memcpy(&matrix[slaveOffset],
+        (void *)serial_slave_buffer, SERIAL_SLAVE_BUFFER_LENGTH);
     return 0;
 }
 #endif
@@ -200,19 +205,9 @@ uint8_t matrix_scan(void)
         matrix_master_scan();
     }else{
         matrix_slave_scan();
-
-//        if(serial_slave_DATA_CORRUPT()){
-//          TXLED0;
-          int offset = (isLeftHand) ? ROWS_PER_HAND : 0;
-
-          for (int i = 0; i < ROWS_PER_HAND; ++i) {
-              matrix[offset+i] = serial_master_buffer[i];
-          }
-
-//        }else{
-//          TXLED1;
-//        }
-
+        int offset = (isLeftHand) ? ROWS_PER_HAND : 0;
+        memcpy(&matrix[offset],
+               (void *)serial_master_buffer, SERIAL_MASTER_BUFFER_LENGTH);
         matrix_scan_quantum();
     }
     return 1;
@@ -222,6 +217,7 @@ uint8_t matrix_scan(void)
 uint8_t matrix_master_scan(void) {
 
     int ret = _matrix_scan();
+    int mchanged = 1;
 
     int offset = (isLeftHand) ? 0 : ROWS_PER_HAND;
 
@@ -231,15 +227,18 @@ uint8_t matrix_master_scan(void) {
 //        i2c_slave_buffer[i] = matrix[offset+i];
 //    }
 #else // USE_SERIAL
-    for (int i = 0; i < ROWS_PER_HAND; ++i) {
-        serial_master_buffer[i] = matrix[offset+i];
-    }
+  #ifdef SERIAL_USE_MULTI_TRANSACTION
+    mchanged = memcmp((void *)serial_master_buffer,
+		      &matrix[offset], SERIAL_MASTER_BUFFER_LENGTH);
+  #endif
+    memcpy((void *)serial_master_buffer,
+	   &matrix[offset], SERIAL_MASTER_BUFFER_LENGTH);
 #endif
 
 #ifdef USE_MATRIX_I2C
     if( i2c_transaction() ) {
 #else // USE_SERIAL
-    if( serial_transaction() ) {
+    if( serial_transaction(mchanged) ) {
 #endif
         // turn on the indicator led when halves are disconnected
         TXLED1;
@@ -273,9 +272,19 @@ void matrix_slave_scan(void) {
         i2c_slave_buffer[i] = matrix[offset+i];
     }
 #else // USE_SERIAL
+  #ifdef SERIAL_USE_MULTI_TRANSACTION
+    int change = 0;
+  #endif
     for (int i = 0; i < ROWS_PER_HAND; ++i) {
+  #ifdef SERIAL_USE_MULTI_TRANSACTION
+        if( serial_slave_buffer[i] != matrix[offset+i] )
+	    change = 1;
+  #endif
         serial_slave_buffer[i] = matrix[offset+i];
     }
+  #ifdef SERIAL_USE_MULTI_TRANSACTION
+    slave_buffer_change_count += change;
+  #endif
 #endif
 }
 

keyboards/crkbd/rev1/rev1.h

@@ -1,5 +1,4 @@
-#ifndef REV1_H
-#define REV1_CONFIG_H
+#pragma once
 
 #include "../crkbd.h"
 
@@ -49,5 +48,3 @@
     KC_##L20, KC_##L21, KC_##L22, KC_##L23, KC_##L24, KC_##L25,                     KC_##R20, KC_##R21, KC_##R22, KC_##R23, KC_##R24, KC_##R25, \
                                             KC_##L30, KC_##L31, KC_##L32, KC_##R30, KC_##R31, KC_##R32 \
   )
-
-#endif

keyboards/crkbd/rev1/rules.mk

@@ -1,2 +1,3 @@
-SRC += rev1/matrix.c \
-	   ws2812.c
+SRC += rev1/matrix.c
+SRC += rev1/split_util.c
+SRC += rev1/split_scomm.c

keyboards/crkbd/rev1/serial_config.h

@@ -0,0 +1,10 @@
+#pragma once
+
+/* Soft Serial defines */
+#define SERIAL_PIN_DDR DDRD
+#define SERIAL_PIN_PORT PORTD
+#define SERIAL_PIN_INPUT PIND
+#define SERIAL_PIN_MASK _BV(PD2)
+#define SERIAL_PIN_INTERRUPT INT2_vect
+
+#define SERIAL_USE_MULTI_TRANSACTION

keyboards/crkbd/rev1/serial_config_simpleapi.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#undef SERIAL_USE_MULTI_TRANSACTION
+#define SERIAL_SLAVE_BUFFER_LENGTH MATRIX_ROWS/2
+#define SERIAL_MASTER_BUFFER_LENGTH MATRIX_ROWS/2

keyboards/crkbd/rev1/split_scomm.c

@@ -0,0 +1,73 @@
+#ifdef USE_SERIAL
+#ifdef SERIAL_USE_MULTI_TRANSACTION
+/* --- USE flexible API (using multi-type transaction function) --- */
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stddef.h>
+#include <split_scomm.h>
+#include "serial.h"
+#ifdef SERIAL_DEBUG_MODE
+#include <avr/io.h>
+#endif
+
+uint8_t volatile serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH] = {0};
+uint8_t volatile serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH] = {0};
+uint8_t volatile status_com = 0;
+uint8_t volatile status1 = 0;
+uint8_t slave_buffer_change_count = 0;
+uint8_t s_change_old = 0xff;
+
+SSTD_t transactions[] = {
+#define GET_SLAVE_STATUS 0
+    /* master buffer not changed, only recive slave_buffer_change_count */
+    { (uint8_t *)&status_com,
+      0, NULL,
+      sizeof(slave_buffer_change_count), &slave_buffer_change_count,
+    },
+#define PUT_MASTER_GET_SLAVE_STATUS 1
+    /* master buffer changed need send, and recive slave_buffer_change_count  */
+    { (uint8_t *)&status_com,
+      sizeof(serial_master_buffer), (uint8_t *)serial_master_buffer,
+      sizeof(slave_buffer_change_count), &slave_buffer_change_count,
+    },
+#define GET_SLAVE_BUFFER 2
+    /* recive serial_slave_buffer */
+    { (uint8_t *)&status1,
+      0, NULL,
+      sizeof(serial_slave_buffer), (uint8_t *)serial_slave_buffer
+    }
+};
+
+void serial_master_init(void)
+{
+    soft_serial_initiator_init(transactions);
+}
+
+void serial_slave_init(void)
+{
+    soft_serial_target_init(transactions);
+}
+
+// 0 => no error
+// 1 => slave did not respond
+// 2 => checksum error
+int serial_update_buffers(int master_update)
+{
+    int status;
+    static int need_retry = 0;
+    if( s_change_old != slave_buffer_change_count ) {
+	status = soft_serial_transaction(GET_SLAVE_BUFFER);
+	if( status == TRANSACTION_END )
+	    s_change_old = slave_buffer_change_count;
+    }
+    if( !master_update && !need_retry)
+	status = soft_serial_transaction(GET_SLAVE_STATUS);
+    else
+	status = soft_serial_transaction(PUT_MASTER_GET_SLAVE_STATUS);
+    need_retry = ( status == TRANSACTION_END ) ? 0 : 1;
+    return status;
+}
+
+#endif // SERIAL_USE_MULTI_TRANSACTION
+#endif /* USE_SERIAL */

keyboards/crkbd/rev1/split_scomm.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#ifndef SERIAL_USE_MULTI_TRANSACTION
+/* --- USE Simple API (OLD API, compatible with let's split serial.c) --- */
+#include "serial.h"
+
+#else
+/* --- USE flexible API (using multi-type transaction function) --- */
+// Buffers for master - slave communication
+#define SERIAL_SLAVE_BUFFER_LENGTH MATRIX_ROWS/2
+#define SERIAL_MASTER_BUFFER_LENGTH MATRIX_ROWS/2
+
+extern volatile uint8_t serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH];
+extern volatile uint8_t serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH];
+extern uint8_t slave_buffer_change_count;
+
+void serial_master_init(void);
+void serial_slave_init(void);
+int serial_update_buffers(int master_changed);
+
+#endif

keyboards/crkbd/rev1/split_util.c

@@ -7,12 +7,11 @@
 #include "split_util.h"
 #include "matrix.h"
 #include "keyboard.h"
-#include "config.h"
 
 #ifdef USE_MATRIX_I2C
 #  include "i2c.h"
 #else
-#  include "serial.h"
+#  include "split_scomm.h"
 #endif
 
 volatile bool isLeftHand = true;

keyboards/crkbd/rev1/split_util.h

@@ -1,5 +1,4 @@
-#ifndef SPLIT_KEYBOARD_UTIL_H
-#define SPLIT_KEYBOARD_UTIL_H
+#pragma once
 
 #include <stdbool.h>
 #include "eeconfig.h"
@@ -15,5 +14,3 @@ void split_keyboard_setup(void);
 bool has_usb(void);
 
 void matrix_master_OLED_init (void);
-
-#endif

keyboards/crkbd/rules.mk

@@ -1,7 +1,9 @@
-SRC += i2c.c \
-	   serial.c \
-	   split_util.c \
-	   ssd1306.c
+SRC += i2c.c
+SRC += serial.c
+SRC += ssd1306.c
+
+# if firmware size over limit, try this option
+# CFLAGS += -flto
 
 # MCU name
 #MCU = at90usb1287

keyboards/crkbd/serial.c

@@ -9,36 +9,128 @@
 #include <avr/io.h>
 #include <avr/interrupt.h>
 #include <util/delay.h>
+#include <stddef.h>
 #include <stdbool.h>
 #include "serial.h"
+//#include <pro_micro.h>
 
 #ifdef USE_SERIAL
 
-// Serial pulse period in microseconds. Its probably a bad idea to lower this
-// value.
-#define SERIAL_DELAY 24
+#ifndef SERIAL_USE_MULTI_TRANSACTION
+/* --- USE Simple API (OLD API, compatible with let's split serial.c) */
+  #if SERIAL_SLAVE_BUFFER_LENGTH > 0
+  uint8_t volatile serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH] = {0};
+  #endif
+  #if SERIAL_MASTER_BUFFER_LENGTH > 0
+  uint8_t volatile serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH] = {0};
+  #endif
+  uint8_t volatile status0 = 0;
 
-uint8_t volatile serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH] = {0};
-uint8_t volatile serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH] = {0};
+SSTD_t transactions[] = {
+    { (uint8_t *)&status0,
+  #if SERIAL_MASTER_BUFFER_LENGTH > 0
+      sizeof(serial_master_buffer), (uint8_t *)serial_master_buffer,
+  #else
+      0, (uint8_t *)NULL,
+  #endif
+  #if SERIAL_SLAVE_BUFFER_LENGTH > 0
+      sizeof(serial_slave_buffer), (uint8_t *)serial_slave_buffer
+  #else
+      0, (uint8_t *)NULL,
+  #endif
+  }
+};
 
-#define SLAVE_DATA_CORRUPT (1<<0)
-volatile uint8_t status = 0;
+void serial_master_init(void)
+{ soft_serial_initiator_init(transactions); }
+
+void serial_slave_init(void)
+{ soft_serial_target_init(transactions); }
+
+// 0 => no error
+// 1 => slave did not respond
+// 2 => checksum error
+int serial_update_buffers()
+{ return soft_serial_transaction(); }
+
+#endif // Simple API (OLD API, compatible with let's split serial.c)
+
+#define ALWAYS_INLINE __attribute__((always_inline))
+#define NO_INLINE __attribute__((noinline))
+#define _delay_sub_us(x)    __builtin_avr_delay_cycles(x)
+
+// Serial pulse period in microseconds.
+#define TID_SEND_ADJUST 14
+
+#define SELECT_SERIAL_SPEED 1
+#if SELECT_SERIAL_SPEED == 0
+  // Very High speed
+  #define SERIAL_DELAY 4             // micro sec
+  #define READ_WRITE_START_ADJUST 33 // cycles
+  #define READ_WRITE_WIDTH_ADJUST 3 // cycles
+#elif SELECT_SERIAL_SPEED == 1
+  // High speed
+  #define SERIAL_DELAY 6             // micro sec
+  #define READ_WRITE_START_ADJUST 30 // cycles
+  #define READ_WRITE_WIDTH_ADJUST 3 // cycles
+#elif SELECT_SERIAL_SPEED == 2
+  // Middle speed
+  #define SERIAL_DELAY 12            // micro sec
+  #define READ_WRITE_START_ADJUST 30 // cycles
+  #define READ_WRITE_WIDTH_ADJUST 3 // cycles
+#elif SELECT_SERIAL_SPEED == 3
+  // Low speed
+  #define SERIAL_DELAY 24            // micro sec
+  #define READ_WRITE_START_ADJUST 30 // cycles
+  #define READ_WRITE_WIDTH_ADJUST 3 // cycles
+#elif SELECT_SERIAL_SPEED == 4
+  // Very Low speed
+  #define SERIAL_DELAY 50            // micro sec
+  #define READ_WRITE_START_ADJUST 30 // cycles
+  #define READ_WRITE_WIDTH_ADJUST 3 // cycles
+#else
+#error Illegal Serial Speed
+#endif
+
+
+#define SERIAL_DELAY_HALF1 (SERIAL_DELAY/2)
+#define SERIAL_DELAY_HALF2 (SERIAL_DELAY - SERIAL_DELAY/2)
+
+#define SLAVE_INT_WIDTH_US 1
+#ifndef SERIAL_USE_MULTI_TRANSACTION
+  #define SLAVE_INT_RESPONSE_TIME SERIAL_DELAY
+#else
+  #define SLAVE_INT_ACK_WIDTH_UNIT 2
+  #define SLAVE_INT_ACK_WIDTH 4
+#endif
+
+static SSTD_t *Transaction_table = NULL;
 
 inline static
 void serial_delay(void) {
   _delay_us(SERIAL_DELAY);
 }
-void serial_delay_short(void) {
-  _delay_us(SERIAL_DELAY-1);
+
+inline static
+void serial_delay_half1(void) {
+  _delay_us(SERIAL_DELAY_HALF1);
 }
+
+inline static
+void serial_delay_half2(void) {
+  _delay_us(SERIAL_DELAY_HALF2);
+}
+
+inline static void serial_output(void) ALWAYS_INLINE;
 inline static
 void serial_output(void) {
   SERIAL_PIN_DDR |= SERIAL_PIN_MASK;
 }
 
 // make the serial pin an input with pull-up resistor
+inline static void serial_input_with_pullup(void) ALWAYS_INLINE;
 inline static
-void serial_input(void) {
+void serial_input_with_pullup(void) {
   SERIAL_PIN_DDR  &= ~SERIAL_PIN_MASK;
   SERIAL_PIN_PORT |= SERIAL_PIN_MASK;
 }
@@ -48,191 +140,305 @@ uint8_t serial_read_pin(void) {
   return !!(SERIAL_PIN_INPUT & SERIAL_PIN_MASK);
 }
 
+inline static void serial_low(void) ALWAYS_INLINE;
 inline static
 void serial_low(void) {
   SERIAL_PIN_PORT &= ~SERIAL_PIN_MASK;
 }
 
+inline static void serial_high(void) ALWAYS_INLINE;
 inline static
 void serial_high(void) {
   SERIAL_PIN_PORT |= SERIAL_PIN_MASK;
 }
 
-void serial_master_init(void) {
-  serial_output();
-  serial_high();
+void soft_serial_initiator_init(SSTD_t *sstd_table)
+{
+    Transaction_table = sstd_table;
+    serial_output();
+    serial_high();
 }
 
-void serial_slave_init(void) {
-  serial_input();
+void soft_serial_target_init(SSTD_t *sstd_table)
+{
+    Transaction_table = sstd_table;
+    serial_input_with_pullup();
 
-#ifndef USE_SERIAL_PD2
-  // Enable INT0
-  EIMSK |= _BV(INT0);
-  // Trigger on falling edge of INT0
-  EICRA &= ~(_BV(ISC00) | _BV(ISC01));
+#if SERIAL_PIN_MASK == _BV(PD0)
+    // Enable INT0
+    EIMSK |= _BV(INT0);
+    // Trigger on falling edge of INT0
+    EICRA &= ~(_BV(ISC00) | _BV(ISC01));
+#elif SERIAL_PIN_MASK == _BV(PD2)
+    // Enable INT2
+    EIMSK |= _BV(INT2);
+    // Trigger on falling edge of INT2
+    EICRA &= ~(_BV(ISC20) | _BV(ISC21));
 #else
-  // Enable INT2
-  EIMSK |= _BV(INT2);
-  // Trigger on falling edge of INT2
-  EICRA &= ~(_BV(ISC20) | _BV(ISC21));
+ #error unknown SERIAL_PIN_MASK value
 #endif
 }
 
-// Used by the master to synchronize timing with the slave.
+// Used by the sender to synchronize timing with the reciver.
+static void sync_recv(void) NO_INLINE;
 static
 void sync_recv(void) {
-  serial_input();
-  // This shouldn't hang if the slave disconnects because the
-  // serial line will float to high if the slave does disconnect.
+  for (uint8_t i = 0; i < SERIAL_DELAY*5 && serial_read_pin(); i++ ) {
+  }
+  // This shouldn't hang if the target disconnects because the
+  // serial line will float to high if the target does disconnect.
   while (!serial_read_pin());
-  //serial_delay();
-  _delay_us(SERIAL_DELAY-5);
 }
 
-// Used by the slave to send a synchronization signal to the master.
+// Used by the reciver to send a synchronization signal to the sender.
+static void sync_send(void)NO_INLINE;
 static
 void sync_send(void) {
-  serial_output();
-
   serial_low();
   serial_delay();
-
   serial_high();
 }
 
 // Reads a byte from the serial line
-static
-uint8_t serial_read_byte(void) {
-  uint8_t byte = 0;
-  serial_input();
-  for ( uint8_t i = 0; i < 8; ++i) {
-    byte = (byte << 1) | serial_read_pin();
-    serial_delay();
-    _delay_us(1);
+static uint8_t serial_read_chunk(uint8_t *pterrcount, uint8_t bit) NO_INLINE;
+static uint8_t serial_read_chunk(uint8_t *pterrcount, uint8_t bit) {
+    uint8_t byte, i, p, pb;
+
+  _delay_sub_us(READ_WRITE_START_ADJUST);
+  for( i = 0, byte = 0, p = 0; i < bit; i++ ) {
+      serial_delay_half1();   // read the middle of pulses
+      if( serial_read_pin() ) {
+	  byte = (byte << 1) | 1; p ^= 1;
+      } else {
+	  byte = (byte << 1) | 0; p ^= 0;
+      }
+      _delay_sub_us(READ_WRITE_WIDTH_ADJUST);
+      serial_delay_half2();
   }
+  /* recive parity bit */
+  serial_delay_half1();   // read the middle of pulses
+  pb = serial_read_pin();
+  _delay_sub_us(READ_WRITE_WIDTH_ADJUST);
+  serial_delay_half2();
+
+  *pterrcount += (p != pb)? 1 : 0;
 
   return byte;
 }
 
 // Sends a byte with MSB ordering
-static
-void serial_write_byte(uint8_t data) {
-  uint8_t b = 8;
-  serial_output();
-  while( b-- ) {
-    if(data & (1 << b)) {
-      serial_high();
-    } else {
-      serial_low();
+void serial_write_chunk(uint8_t data, uint8_t bit) NO_INLINE;
+void serial_write_chunk(uint8_t data, uint8_t bit) {
+    uint8_t b, p;
+    for( p = 0, b = 1<<(bit-1); b ; b >>= 1) {
+	if(data & b) {
+	    serial_high(); p ^= 1;
+	} else {
+	    serial_low();  p ^= 0;
+	}
+	serial_delay();
     }
+    /* send parity bit */
+    if(p & 1) { serial_high(); }
+    else      { serial_low(); }
     serial_delay();
+
+    serial_low(); // sync_send() / senc_recv() need raise edge
+}
+
+static void serial_send_packet(uint8_t *buffer, uint8_t size) NO_INLINE;
+static
+void serial_send_packet(uint8_t *buffer, uint8_t size) {
+  for (uint8_t i = 0; i < size; ++i) {
+    uint8_t data;
+    data = buffer[i];
+    sync_send();
+    serial_write_chunk(data,8);
   }
 }
 
-// interrupt handle to be used by the slave device
+static uint8_t serial_recive_packet(uint8_t *buffer, uint8_t size) NO_INLINE;
+static
+uint8_t serial_recive_packet(uint8_t *buffer, uint8_t size) {
+  uint8_t pecount = 0;
+  for (uint8_t i = 0; i < size; ++i) {
+    uint8_t data;
+    sync_recv();
+    data = serial_read_chunk(&pecount, 8);
+    buffer[i] = data;
+  }
+  return pecount == 0;
+}
+
+inline static
+void change_sender2reciver(void) {
+    sync_send();          //0
+    serial_delay_half1(); //1
+    serial_low();         //2
+    serial_input_with_pullup(); //2
+    serial_delay_half1(); //3
+}
+
+inline static
+void change_reciver2sender(void) {
+    sync_recv();     //0
+    serial_delay();  //1
+    serial_low();    //3
+    serial_output(); //3
+    serial_delay_half1(); //4
+}
+
+// interrupt handle to be used by the target device
 ISR(SERIAL_PIN_INTERRUPT) {
-  sync_send();
 
-  uint8_t checksum = 0;
-  for (int i = 0; i < SERIAL_SLAVE_BUFFER_LENGTH; ++i) {
-    serial_write_byte(serial_slave_buffer[i]);
-    sync_send();
-    checksum += serial_slave_buffer[i];
-  }
-  serial_write_byte(checksum);
-  sync_send();
+#ifndef SERIAL_USE_MULTI_TRANSACTION
+  serial_low();
+  serial_output();
+  SSTD_t *trans = Transaction_table;
+#else
+  // recive transaction table index
+  uint8_t tid;
+  uint8_t pecount = 0;
+  sync_recv();
+  tid = serial_read_chunk(&pecount,4);
+  if(pecount> 0)
+      return;
+  serial_delay_half1();
 
-  // wait for the sync to finish sending
-  serial_delay();
+  serial_high(); // response step1 low->high
+  serial_output();
+  _delay_sub_us(SLAVE_INT_ACK_WIDTH_UNIT*SLAVE_INT_ACK_WIDTH);
+  SSTD_t *trans = &Transaction_table[tid];
+  serial_low(); // response step2 ack high->low
+#endif
 
-  // read the middle of pulses
-  _delay_us(SERIAL_DELAY/2);
+  // target send phase
+  if( trans->target2initiator_buffer_size > 0 )
+      serial_send_packet((uint8_t *)trans->target2initiator_buffer,
+			 trans->target2initiator_buffer_size);
+  // target switch to input
+  change_sender2reciver();
 
-  uint8_t checksum_computed = 0;
-  for (int i = 0; i < SERIAL_MASTER_BUFFER_LENGTH; ++i) {
-    serial_master_buffer[i] = serial_read_byte();
-    sync_send();
-    checksum_computed += serial_master_buffer[i];
-  }
-  uint8_t checksum_received = serial_read_byte();
-  sync_send();
-
-  serial_input(); // end transaction
-
-  if ( checksum_computed != checksum_received ) {
-    status |= SLAVE_DATA_CORRUPT;
+  // target recive phase
+  if( trans->initiator2target_buffer_size > 0 ) {
+      if (serial_recive_packet((uint8_t *)trans->initiator2target_buffer,
+			       trans->initiator2target_buffer_size) ) {
+	  *trans->status = TRANSACTION_ACCEPTED;
+      } else {
+	  *trans->status = TRANSACTION_DATA_ERROR;
+      }
   } else {
-    status &= ~SLAVE_DATA_CORRUPT;
+      *trans->status = TRANSACTION_ACCEPTED;
   }
+
+  sync_recv(); //weit initiator output to high
 }
 
-inline
-bool serial_slave_DATA_CORRUPT(void) {
-  return status & SLAVE_DATA_CORRUPT;
-}
-
-// Copies the serial_slave_buffer to the master and sends the
-// serial_master_buffer to the slave.
+/////////
+//  start transaction by initiator
+//
+// int  soft_serial_transaction(int sstd_index)
 //
 // Returns:
-// 0 => no error
-// 1 => slave did not respond
-int serial_update_buffers(void) {
-  // this code is very time dependent, so we need to disable interrupts
+//    TRANSACTION_END
+//    TRANSACTION_NO_RESPONSE
+//    TRANSACTION_DATA_ERROR
+// this code is very time dependent, so we need to disable interrupts
+#ifndef SERIAL_USE_MULTI_TRANSACTION
+int  soft_serial_transaction(void) {
+  SSTD_t *trans = Transaction_table;
+#else
+int  soft_serial_transaction(int sstd_index) {
+  SSTD_t *trans = &Transaction_table[sstd_index];
+#endif
   cli();
 
-  // signal to the slave that we want to start a transaction
+  // signal to the target that we want to start a transaction
   serial_output();
   serial_low();
-  _delay_us(1);
+  _delay_us(SLAVE_INT_WIDTH_US);
 
-  // wait for the slaves response
-  serial_input();
-  serial_high();
-  _delay_us(SERIAL_DELAY);
+#ifndef SERIAL_USE_MULTI_TRANSACTION
+  // wait for the target response
+  serial_input_with_pullup();
+  _delay_us(SLAVE_INT_RESPONSE_TIME);
 
-  // check if the slave is present
+  // check if the target is present
   if (serial_read_pin()) {
-    // slave failed to pull the line low, assume not present
+    // target failed to pull the line low, assume not present
+    serial_output();
+    serial_high();
+    *trans->status = TRANSACTION_NO_RESPONSE;
     sei();
-    return 1;
+    return TRANSACTION_NO_RESPONSE;
   }
 
-  // if the slave is present syncronize with it
-  sync_recv();
+#else
+  // send transaction table index
+  sync_send();
+  _delay_sub_us(TID_SEND_ADJUST);
+  serial_write_chunk(sstd_index, 4);
+  serial_delay_half1();
 
-  uint8_t checksum_computed = 0;
-  // receive data from the slave
-  for (int i = 0; i < SERIAL_SLAVE_BUFFER_LENGTH; ++i) {
-    serial_slave_buffer[i] = serial_read_byte();
-    sync_recv();
-    checksum_computed += serial_slave_buffer[i];
-  }
-  uint8_t checksum_received = serial_read_byte();
-  sync_recv();
-
-  if (checksum_computed != checksum_received) {
-    sei();
-    return 2;
+  // wait for the target response (step1 low->high)
+  serial_input_with_pullup();
+  while( !serial_read_pin() ) {
+      _delay_sub_us(2);
   }
 
-  uint8_t checksum = 0;
-  // send data to the slave
-  for (int i = 0; i < SERIAL_MASTER_BUFFER_LENGTH; ++i) {
-    serial_write_byte(serial_master_buffer[i]);
-    sync_recv();
-    checksum += serial_master_buffer[i];
+  // check if the target is present (step2 high->low)
+  for( int i = 0; serial_read_pin(); i++ ) {
+      if (i > SLAVE_INT_ACK_WIDTH + 1) {
+	  // slave failed to pull the line low, assume not present
+	  serial_output();
+	  serial_high();
+	  *trans->status = TRANSACTION_NO_RESPONSE;
+	  sei();
+	  return TRANSACTION_NO_RESPONSE;
+      }
+      _delay_sub_us(SLAVE_INT_ACK_WIDTH_UNIT);
+  }
+#endif
+
+  // initiator recive phase
+  // if the target is present syncronize with it
+  if( trans->target2initiator_buffer_size > 0 ) {
+      if (!serial_recive_packet((uint8_t *)trans->target2initiator_buffer,
+				trans->target2initiator_buffer_size) ) {
+	  serial_output();
+	  serial_high();
+	  *trans->status = TRANSACTION_DATA_ERROR;
+	  sei();
+	  return TRANSACTION_DATA_ERROR;
+      }
+   }
+
+  // initiator switch to output
+  change_reciver2sender();
+
+  // initiator send phase
+  if( trans->initiator2target_buffer_size > 0 ) {
+      serial_send_packet((uint8_t *)trans->initiator2target_buffer,
+			 trans->initiator2target_buffer_size);
   }
-  serial_write_byte(checksum);
-  sync_recv();
 
   // always, release the line when not in use
-  serial_output();
-  serial_high();
+  sync_send();
 
+  *trans->status = TRANSACTION_END;
   sei();
-  return 0;
+  return TRANSACTION_END;
 }
 
+#ifdef SERIAL_USE_MULTI_TRANSACTION
+int soft_serial_get_and_clean_status(int sstd_index) {
+    SSTD_t *trans = &Transaction_table[sstd_index];
+    cli();
+    int retval = *trans->status;
+    *trans->status = 0;;
+    sei();
+    return retval;
+}
+#endif
+
 #endif

keyboards/crkbd/serial.h

@@ -1,32 +1,77 @@
-#ifndef MY_SERIAL_H
-#define MY_SERIAL_H
+#pragma once
 
-#include "config.h"
 #include <stdbool.h>
 
-/* TODO:  some defines for interrupt setup */
-#define SERIAL_PIN_DDR DDRD
-#define SERIAL_PIN_PORT PORTD
-#define SERIAL_PIN_INPUT PIND
+// /////////////////////////////////////////////////////////////////
+// Need Soft Serial defines in serial_config.h
+// /////////////////////////////////////////////////////////////////
+// ex.
+//  #define SERIAL_PIN_DDR DDRD
+//  #define SERIAL_PIN_PORT PORTD
+//  #define SERIAL_PIN_INPUT PIND
+//  #define SERIAL_PIN_MASK _BV(PD?)   ?=0,2
+//  #define SERIAL_PIN_INTERRUPT INT?_vect  ?=0,2
+//
+// //// USE Simple API (OLD API, compatible with let's split serial.c)
+// ex.
+//  #define SERIAL_SLAVE_BUFFER_LENGTH MATRIX_ROWS/2
+//  #define SERIAL_MASTER_BUFFER_LENGTH 1
+//
+// //// USE flexible API (using multi-type transaction function)
+//  #define SERIAL_USE_MULTI_TRANSACTION
+//
+// /////////////////////////////////////////////////////////////////
 
-#ifndef USE_SERIAL_PD2
-#define SERIAL_PIN_MASK _BV(PD0)
-#define SERIAL_PIN_INTERRUPT INT0_vect
-#else
-#define SERIAL_PIN_MASK _BV(PD2)
-#define SERIAL_PIN_INTERRUPT INT2_vect
-#endif
 
-#define SERIAL_SLAVE_BUFFER_LENGTH MATRIX_ROWS/2
-#define SERIAL_MASTER_BUFFER_LENGTH MATRIX_ROWS/2
-
-// Buffers for master - slave communication
+#ifndef SERIAL_USE_MULTI_TRANSACTION
+/* --- USE Simple API (OLD API, compatible with let's split serial.c) */
+#if SERIAL_SLAVE_BUFFER_LENGTH > 0
 extern volatile uint8_t serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH];
+#endif
+#if SERIAL_MASTER_BUFFER_LENGTH > 0
 extern volatile uint8_t serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH];
+#endif
 
 void serial_master_init(void);
 void serial_slave_init(void);
 int serial_update_buffers(void);
-bool serial_slave_data_corrupt(void);
 
+#endif // USE Simple API
+
+// Soft Serial Transaction Descriptor
+typedef struct _SSTD_t  {
+    uint8_t *status;
+    uint8_t initiator2target_buffer_size;
+    uint8_t *initiator2target_buffer;
+    uint8_t target2initiator_buffer_size;
+    uint8_t *target2initiator_buffer;
+} SSTD_t;
+
+// initiator is transaction start side
+void soft_serial_initiator_init(SSTD_t *sstd_table);
+// target is interrupt accept side
+void soft_serial_target_init(SSTD_t *sstd_table);
+
+// initiator resullt
+#define TRANSACTION_END 0
+#define TRANSACTION_NO_RESPONSE 0x1
+#define TRANSACTION_DATA_ERROR  0x2
+#ifndef SERIAL_USE_MULTI_TRANSACTION
+int  soft_serial_transaction(void);
+#else
+int  soft_serial_transaction(int sstd_index);
+#endif
+
+// target status
+// *SSTD_t.status has
+//   initiator:
+//       TRANSACTION_END
+//    or TRANSACTION_NO_RESPONSE
+//    or TRANSACTION_DATA_ERROR
+//   target:
+//       TRANSACTION_DATA_ERROR
+//    or TRANSACTION_ACCEPTED
+#define TRANSACTION_ACCEPTED 0x4
+#ifdef SERIAL_USE_MULTI_TRANSACTION
+int  soft_serial_get_and_clean_status(int sstd_index);
 #endif

keyboards/crkbd/ssd1306.c

@@ -123,6 +123,7 @@ static int8_t capture_sendchar(uint8_t c) {
 bool iota_gfx_init(bool rotate) {
   bool success = false;
 
+  i2c_master_init();
   send_cmd1(DisplayOff);
   send_cmd2(SetDisplayClockDiv, 0x80);
   send_cmd2(SetMultiPlex, DisplayHeight - 1);

keyboards/crkbd/ssd1306.h

@@ -1,10 +1,8 @@
-#ifndef SSD1306_H
-#define SSD1306_H
+#pragma once
 
 #include <stdbool.h>
 #include <stdio.h>
 #include "pincontrol.h"
-#include "config.h"
 
 enum ssd1306_cmds {
   DisplayOff = 0xAE,
@@ -88,7 +86,3 @@ void matrix_write(struct CharacterMatrix *matrix, const char *data);
 void matrix_write_ln(struct CharacterMatrix *matrix, const char *data);
 void matrix_write_P(struct CharacterMatrix *matrix, const char *data);
 void matrix_render(struct CharacterMatrix *matrix);
-
-
-
-#endif

keyboards/divergetm2/config.h

@@ -0,0 +1,79 @@
+/* Copyright 2018 Christon DeWan (xton)
+ * Copyright 2017 IslandMan93
+ *
+ * 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      0x1256
+#define DEVICE_VER      0x0001
+#define MANUFACTURER    UniKeyboard
+#define PRODUCT         diverge tm2
+#define DESCRIPTION     Split 46 key keyboard
+
+/* key matrix size */
+#define MATRIX_ROWS 8
+#define MATRIX_COLS 6
+
+/*
+ * Keyboard Matrix Assignments
+ *
+ * Change this to how you wired your keyboard
+ * COLS: AVR pins used for columns, left to right
+ * ROWS: AVR pins used for rows, top to bottom
+ * DIODE_DIRECTION: COL2ROW = COL = Anode (+), ROW = Cathode (-, marked on diode)
+ *                  ROW2COL = ROW = Anode (+), COL = Cathode (-, marked on diode)
+ *
+*/
+#define MATRIX_ROW_PINS { D7, E6, B4, B5 }
+#define MATRIX_COL_PINS { F6, F7, B1, B3, B2, B6 }
+#define UNUSED_PINS
+
+/* COL2ROW, ROW2COL, or CUSTOM_MATRIX */
+#define DIODE_DIRECTION ROW2COL
+
+
+/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
+#define DEBOUNCING_DELAY 5
+
+/* number of backlight levels */
+
+/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
+#define LOCKING_SUPPORT_ENABLE
+/* Locking resynchronize hack */
+#define LOCKING_RESYNC_ENABLE
+
+/*
+ * Magic Key Options
+ *
+ * Magic keys are hotkey commands that allow control over firmware functions of
+ * the keyboard. They are best used in combination with the HID Listen program,
+ * found here: https://www.pjrc.com/teensy/hid_listen.html
+ *
+ * The options below allow the magic key functionality to be changed. This is
+ * useful if your keyboard/keypad is missing keys and you want magic key support.
+ *
+ */
+
+/* key combination for magic key command */
+#define IS_COMMAND() ( \
+    keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
+)
+
+

keyboards/divergetm2/divergetm2.c

@@ -0,0 +1,17 @@
+/* Copyright 2018 Christon DeWan (xton)
+ * Copyright 2017 IslandMan93
+ *
+ * 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 "divergetm2.h"