Docs: Add references to One Shot functions, and clean up formatting (#4189)

* Docs: Add references to One Shot functions, and clean up formatting

* Update PR based on @mechmerlin's recommendations

common_features.mk

@@ -219,6 +219,11 @@ ifeq ($(strip $(USB_HID_ENABLE)), yes)
     include $(TMK_DIR)/protocol/usb_hid.mk
 endif
 
+ifeq ($(strip $(ENCODER_ENABLE)), yes)
+    SRC += $(QUANTUM_DIR)/encoder.c
+    OPT_DEFS += -DENCODER_ENABLE
+endif
+
 ifeq ($(strip $(HD44780_ENABLE)), yes)
     SRC += drivers/avr/hd44780.c
     OPT_DEFS += -DHD44780_ENABLE

docs/_sidebar.md

@@ -52,6 +52,7 @@
   * [Combos](feature_combo)
   * [Command](feature_command.md)
   * [Dynamic Macros](feature_dynamic_macros.md)
+  * [Encoders](feature_encoders.md)
   * [Grave Escape](feature_grave_esc.md)
   * [Key Lock](feature_key_lock.md)
   * [Layouts](feature_layouts.md)

docs/_summary.md

@@ -52,6 +52,7 @@
   * [Combos](feature_combo)
   * [Command](feature_command.md)
   * [Dynamic Macros](feature_dynamic_macros.md)
+  * [Encoders](feature_encoders.md)
   * [Grave Escape](feature_grave_esc.md)
   * [Key Lock](feature_key_lock.md)
   * [Layouts](feature_layouts.md)

docs/feature_advanced_keycodes.md

@@ -142,6 +142,8 @@ For example, if you define a key as `OSM(MOD_LSFT)`, you can type a capital A ch
 
 One shot keys also work as normal modifiers. If you hold down a one shot key and type other keys, your one shot will be released immediately after you let go of the key.
 
+Additionally, hitting keys five times in a short period will lock that key. This applies for both One Shot Modifiers and One Shot Layers, and is controlled by the `ONESHOT_TAP_TOGGLE` define.
+
 You can control the behavior of one shot keys by defining these in `config.h`:
 
 ```c
@@ -152,15 +154,20 @@ You can control the behavior of one shot keys by defining these in `config.h`:
 * `OSM(mod)` - Momentarily hold down *mod*. You must use the `MOD_*` keycodes as shown in [Mod Tap](#mod-tap), not the `KC_*` codes.
 * `OSL(layer)` - momentary switch to *layer*.
 
-Sometimes, you want to activate a one-shot layer as part of a macro or tap dance routine. To do this, you need to call `set_oneshot_layer(LAYER, ONESHOT_START)` on key down, and `set_oneshot_layer(ONESHOT_PRESSED)` on key up. If you want to cancel the oneshot, call `reset_oneshot_layer()`. For more complicated actions, take a look at the oneshot implementation in [`process_record`](https://github.com/qmk/qmk_firmware/blob/master/tmk_core/common/action.c#L429).
+Sometimes, you want to activate a one-shot key as part of a macro or tap dance routine.  
+
+For one shot layers, you need to call `set_oneshot_layer(LAYER, ONESHOT_START)` on key down, and `set_oneshot_layer(ONESHOT_PRESSED)` on key up. If you want to cancel the oneshot, call `reset_oneshot_layer()`.
+
+For one shot mods, you need to call `set_oneshot_mods(MOD)` to set it, or `clear_oneshot_mods()` to cancel it.
+
+!> If you're having issues with OSM translating over Remote Desktop Connection, this can be fixed by opening the settings, going to the "Local Resources" tap, and in the keyboard section, change the drop down to "On this Computer".  This will fix the issue and allow OSM to function properly over Remote Desktop.
 
-If you're having issues with OSM translating over Remote Desktop Connection, this can be fixed by clicking on "Show Options", going to the "Local Resources" tab, and in the keyboard section, change the drop down to "On this Computer".  This will fix the issue and allow OSM to function properly over Remote Desktop.
 
 # Permissive Hold
 
 As of [PR#1359](https://github.com/qmk/qmk_firmware/pull/1359/), there is a new `config.h` option:
 
-```
+```c
 #define PERMISSIVE_HOLD
 ```
 
@@ -205,6 +212,6 @@ With `TAPPING_FORCE_HOLD`, the second press will be interpreted as a Shift, allo
 
 # Retro Tapping
 
-When you hold a dual function key, and haven't pressed anything when you release the key, normally nothing happens.  However, if you enable this, if you release the key without pressing another key, it will send the original key, even if it is outside of the tapping term. 
+Holding and releasing a dual function key without pressing another key will result in nothing happening. With retro tapping enabled, releasing the key without pressing another will send the original keycode even if it is outside the tapping term.
 
-For instance, if you're using `LT(2, KC_SPACE)`, if you hold the key, don't hit anything else and then release it, normally, nothing happens. But with `RETRO_TAPPING` defined in your `config.h`, it will send `KC_SPACE`. 
+For instance, holding and releasing `LT(2, KC_SPACE)` without hitting another key will result in nothing happening. With `RETRO_TAPPING` defined in your `config.h`, it will send `KC_SPACE`.

docs/feature_backlight.md

@@ -61,7 +61,7 @@ In this handler, the value of an incrementing counter is mapped onto a precomput
 |`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                   |
+|`get_backlight_level()`|Return the current backlight level           |
 
 ### Backlight Breathing Functions
 

docs/feature_combo.md

@@ -19,6 +19,7 @@ combo_t key_combos[COMBO_COUNT] = {COMBO(test_combo, KC_ESC)};
 This will send "Escape" if you hit the A and B keys.
 
 !> This method only supports [basic keycodes](keycodes_basic.md). See the examples for more control.
+!> You cannot reuse (share) keys in combos. Each key should only belong to a single combo.  
 
 ## Examples
 

docs/feature_encoders.md

@@ -0,0 +1,48 @@
+# Encoders
+
+Basic encoders are supported by adding this to your `rules.mk`:
+
+    ENCODER_ENABLE = yes
+
+and this to your `config.h`:
+
+    #define NUMBER_OF_ENCODERS 1
+    #define ENCODERS_PAD_A { B12 }
+    #define ENCODERS_PAD_B { B13 }
+
+Each PAD_A/B variable defines an array so multiple encoders can be defined, e.g.:
+
+    #define ENCODERS_PAD_A { encoder1a, encoder2a }
+    #define ENCODERS_PAD_B { encoder1a, encoder2b }
+
+If your encoder's clockwise directions are incorrect, you can swap the A & B pad definitions.
+
+Additionally, the resolution can be specified in the same file (the default & suggested is 4):
+
+    #define ENCODER_RESOLUTION 4
+
+## Callbacks
+
+The callback functions can be inserted into your `<keyboard>.c`:
+
+    void encoder_update_kb(uint8_t index, bool clockwise) {
+        encoder_update_user(index, clockwise);
+    }
+
+or `keymap.c`:
+
+    void encoder_update_user(uint8_t index, bool clockwise) {
+        if (index == 0) {
+            if (clockwise) {
+                register_code(KC_PGDN);
+                unregister_code(KC_PGDN);
+            } else {
+                register_code(KC_PGUP);
+                unregister_code(KC_PGUP);
+            }
+        }
+    }
+
+## Hardware
+
+The A an B lines of the encoders should be wired directly to the MCU, and the C/common lines should be wired to ground.

docs/feature_tap_dance.md

@@ -26,6 +26,8 @@ This array specifies what actions shall be taken when a tap-dance key is in acti
 
 The first option is enough for a lot of cases, that just want dual roles. For example, `ACTION_TAP_DANCE_DOUBLE(KC_SPC, KC_ENT)` will result in `Space` being sent on single-tap, `Enter` otherwise.
 
+!> Keep in mind that only [basic keycodes](keycodes_basic.md) are supported here. Custom keycodes are not supported.
+
 And that's the bulk of it!
 
 And now, on to the explanation of how it works!

docs/newbs_building_firmware.md

@@ -16,7 +16,7 @@ Start by navigating to the `keymaps` folder for your keyboard.
 
 ?> Windows:
 
-    start keyboards/<keyboard_folder>/keymaps
+    start .\\keyboards\\<keyboard_folder>\\keymaps
 
 ## Create a Copy Of The `default` Keymap
 

keyboards/atreus62/keymaps/194h/keymap.c

@@ -39,6 +39,7 @@
 //Norwegian layout - dependant on previous definitions
 #define  NO_UNDS  LSFT(NO_MINS)  //  _
 #define  NO_QUES  LSFT(NO_PLUS)  //  ?
+#define  NO_ACUT  RALT(NO_BSLS)  //  Acute
 #define  NO_GRAV  LSFT(NO_BSLS)  //  `
 #define  NO_GT    LSFT(NO_LT)    //  >
 #define  NO_HALF  RALT(NO_LT)    //  ½
@@ -56,6 +57,9 @@
 #define OSM_RSFT OSM(MOD_RSFT)
 #define OSM_RGUI OSM(MOD_RGUI)
 
+//CTRL on hold, ESC on tap
+#define CTL_ESC CTL_T(KC_ESC)
+
 //Layers
 #define L1 0
 #define L2 1
@@ -63,23 +67,51 @@
 #define L4 3
 #define L5 4
 
+// Momentary switch to layer 
+#define MO_L2 MO(L2)
+#define MO_L4 MO(L4)
+#define MO_L5 MO(L5)
 // Momentary switch to layer - One Shot Layer
+#define OSL_L2 OSL(L2)
 #define OSL_L3 OSL(L3)
 #define OSL_L4 OSL(L4)
 
+//Tap Dance Declarations
+enum {
+  SCLN_OE = 0,
+  QUOT_AE,
+  DQT_AO
+};
+
+//Tap Dance Definitions
+qk_tap_dance_action_t tap_dance_actions[] = {
+  //Tap once for semicolon, twice for ø
+  [SCLN_OE] = ACTION_TAP_DANCE_DOUBLE(NO_SCLN, NO_OE),
+  //Tap once for single quote, twice for æ
+  [QUOT_AE] = ACTION_TAP_DANCE_DOUBLE(NO_QUOT, NO_AE),
+  //Tap once for double quote, twice for å
+  [DQT_AO] = ACTION_TAP_DANCE_DOUBLE(NO_DQT, NO_AO),
+// Other declarations would go here, separated by commas, if you have them
+};
+
+//Tap Dance keys
+#define TD_SCLN_OE TD(SCLN_OE)
+#define TD_QUOT_AE TD(QUOT_AE)
+#define TD_DQT_AO TD(DQT_AO)
+
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
   [L1] = LAYOUT(
 	KC_LGUI,       KC_1,         KC_2,         KC_3,         KC_4,         KC_5,                                     KC_6,         KC_7,         KC_8,         KC_9,         KC_0,         KC_RGUI,
-	KC_TAB,        KC_Q,         KC_W,         KC_E,         KC_R,         KC_T,                                     KC_Y,         KC_U,         KC_I,         KC_O,         KC_P,         NO_DQT,
-	KC_BSPC,       KC_A,         KC_S,         KC_D,         KC_F,         KC_G,                                     KC_H,         KC_J,         KC_K,         KC_L,         NO_SCLN,      NO_QUOT,
+	KC_TAB,        KC_Q,         KC_W,         KC_E,         KC_R,         KC_T,                                     KC_Y,         KC_U,         KC_I,         KC_O,         KC_P,         TD_DQT_AO,
+	KC_BSPC,       KC_A,         KC_S,         KC_D,         KC_F,         KC_G,                                     KC_H,         KC_J,         KC_K,         KC_L,         TD_SCLN_OE,   TD_QUOT_AE,
 	OSM_LSFT,      KC_Z,         KC_X,         KC_C,         KC_V,         KC_B,                                     KC_N,         KC_M,         KC_COMM,      KC_DOT,       NO_MINS,      OSM_RSFT,
-	CTL_T(KC_ESC), MO(L5),       KC_LEAD,      OSM_LALT,     MO(L4),       OSL_L3,       KC_SPC,       KC_ENT,       OSL_L3,       MO(L4),       OSM_RALT,     NO_EQL,       NO_PLUS,      KC_RCTL
+	CTL_ESC,       MO_L5,        KC_TAB,       OSM_LALT,     MO_L4,        OSL_L3,       KC_SPC,       KC_ENT,       OSL_L3,       MO_L4,        OSM_LALT,     NO_EQL,       NO_PLUS,      KC_RCTL
   ),
   [L2] = LAYOUT(
 	_______,       _______,      _______,      _______,      _______,      _______,                                  _______,      _______,      _______,      _______,      _______,      _______,
-	_______,       _______,      _______,      _______,      _______,      _______,                                  _______,      _______,      _______,      _______,      _______,      NO_AO,
-	_______,       _______,      _______,      _______,      _______,      _______,                                  _______,      _______,      _______,      _______,      NO_OE,        NO_AE,
+	_______,       _______,      _______,      _______,      _______,      _______,                                  _______,      _______,      _______,      _______,      _______,      NO_DQT,
+	_______,       _______,      _______,      _______,      _______,      _______,                                  _______,      _______,      _______,      _______,      NO_SCLN,      NO_QUOT,
 	_______,       _______,      _______,      _______,      _______,      _______,                                  _______,      _______,      _______,      _______,      _______,      _______,
 	_______,       _______,      _______,      _______,      _______,      _______,      _______,      _______,      _______,      _______,      _______,      _______,      _______,      _______       
   ),
@@ -95,66 +127,23 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 	XXXXXXX,       KC_F6,        KC_F7,        KC_F8,        KC_F9,        KC_F10,                                   KC_HOME,      KC_PGDN,      KC_PGUP,      KC_END,       XXXXXXX,      XXXXXXX,
 	_______,       KC_F11,       KC_F12,       KC_F13,       KC_F14,       KC_F15,                                   KC_LEFT,      KC_DOWN,      KC_UP,        KC_RIGHT,     XXXXXXX,      KC_DEL,
 	XXXXXXX,       KC_F16,       KC_F17,       KC_F18,       KC_F19,       KC_F20,                                   XXXXXXX,      KC_APP,       XXXXXXX,      XXXXXXX,      KC_VOLD,      XXXXXXX,
-	OSM_LCTL,      _______,      XXXXXXX,      _______,      XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,      KC_MUTE,      KC_VOLU,      OSM_RCTL
+	OSM_LCTL,      _______,      XXXXXXX,      _______,      XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,      OSM_RALT,     KC_MUTE,      KC_VOLU,      OSM_RCTL
   ),
   [L5] = LAYOUT(
 	XXXXXXX,       TO(L1),       TO(L2),       TO(L3),       TO(L4),       XXXXXXX,                                  XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,
-	XXXXXXX,       XXXXXXX,      XXXXXXX,      XXXXXXX,      RESET,        XXXXXXX,                                  XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,      NO_AO,  
-	XXXXXXX,       XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,                                  XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,      NO_OE,        NO_AE,  
+	XXXXXXX,       XXXXXXX,      XXXXXXX,      XXXXXXX,      RESET,        XXXXXXX,                                  XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,
+	XXXXXXX,       XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,                                  XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,
 	XXXXXXX,       XXXXXXX,      XXXXXXX,      KC_CAPS,      XXXXXXX,      XXXXXXX,                                  XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,
 	XXXXXXX,       _______,      XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX,      XXXXXXX
   )
 };
 
-
-// Unicode Linux
-void matrix_init_user(void) {
-  set_unicode_input_mode(UC_LNX);
-};
-
-
-#define TAP_ONCE(code)  \
-  register_code (code); \
-  unregister_code (code)
-
-
-LEADER_EXTERNS();
-
-// Runs constantly in the background, in a loop. Only supports basic keycodes.
-void matrix_scan_user(void) {
-  LEADER_DICTIONARY() {
-    leading = false;
-    leader_end();
-
-    //probably useless in practice, but cool
-    SEQ_ONE_KEY (KC_P) {
-      tap_random_base64();
-      tap_random_base64();
-      tap_random_base64();
-      tap_random_base64();
-      tap_random_base64();
-      tap_random_base64();
-      tap_random_base64();
-      tap_random_base64();
-    }
-
-    SEQ_ONE_KEY (KC_G) {
-      SEND_STRING("grep something !");
-      register_code(KC_RALT);
-      TAP_ONCE(KC_4);
-      unregister_code(KC_RALT);
-    }
-    SEQ_ONE_KEY (KC_T) {
-      SEND_STRING("tail "); 
-      TAP_ONCE(KC_SLSH);
-      SEND_STRING("f !");
-      register_code(KC_RALT);
-      TAP_ONCE(KC_4);
-      unregister_code(KC_RALT);
-    }
-    SEQ_ONE_KEY (KC_S) {
-      SEND_STRING("sudo !!");
-      TAP_ONCE(KC_ENT);
-    }
-  }
-}
+//TODO: Is there productivity gain in the use of unicode?
+//	- Won't work in xterm.
+//	Create a layer for macros and/or unicode?
+//	Are macros useful?
+//	- Found no gain in having sendstring for commands.
+//	- Find repeated tasks that cannot be done easily on the OS.
+//	- Most other keymaps have macros for game/fun stuff, hard to find "serious" onces.
+//	Screw Norwegian layout, switch to US with unicode æøå or US/English International?
+//	- Will be different from laptop keyboard, requiring a switch on the OS side when only using the laptop.

keyboards/atreus62/keymaps/194h/rules.mk

@@ -1,8 +1,7 @@
-TAP_DANCE_ENABLE = no
+TAP_DANCE_ENABLE = yes
 NKRO_ENABLE = true
 MOUSEKEY_ENABLE = no
 EXTRAKEY_ENABLE = yes
 CONSOLE_ENABLE = no
 KEY_LOCK_ENABLE = no 
-AUTO_SHIFT_ENABLE = no
-LEADER_ENABLE = yes
+LEADER_ENABLE = no

keyboards/ergodox_infinity/matrix.c

@@ -44,14 +44,14 @@ static uint16_t debouncing_time = 0;
 
 void matrix_init(void)
 {
-    /* Column(sense) */
+    /* Row(sense) */
     palSetPadMode(GPIOD, 1,  PAL_MODE_INPUT_PULLDOWN);
     palSetPadMode(GPIOD, 4,  PAL_MODE_INPUT_PULLDOWN);
     palSetPadMode(GPIOD, 5,  PAL_MODE_INPUT_PULLDOWN);
     palSetPadMode(GPIOD, 6,  PAL_MODE_INPUT_PULLDOWN);
     palSetPadMode(GPIOD, 7,  PAL_MODE_INPUT_PULLDOWN);
 
-    /* Row(strobe) */
+    /* Column(strobe) */
     palSetPadMode(GPIOB, 2,  PAL_MODE_OUTPUT_PUSHPULL);
     palSetPadMode(GPIOB, 3,  PAL_MODE_OUTPUT_PUSHPULL);
     palSetPadMode(GPIOB, 18, PAL_MODE_OUTPUT_PUSHPULL);

keyboards/hs60/v1/config.h

@@ -15,8 +15,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 CONFIG_H
-#define CONFIG_H
+#pragma once
 
 #include "config_common.h"
 
@@ -142,5 +141,3 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #endif
 
 #define DRIVER_LED_TOTAL DRIVER_1_LED_TOTAL + DRIVER_2_LED_TOTAL
-
-#endif

keyboards/hs60/v1/keymaps/ansi/config.h

@@ -14,13 +14,8 @@ 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 CONFIG_USER_H
-#define CONFIG_USER_H
-
-#include "../../config.h"
+#pragma once
 
 /* Include overwrites for specific keymap */
 
 #define HS60_ANSI
-
-#endif

keyboards/hs60/v1/readme.md

@@ -13,6 +13,6 @@ Due to the RGB implementation, the HS60 is currently not compatible with communi
 
 Make example for this keyboard (after setting up your build environment):
 
-    make hs60:default
+    make hs60/v1: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/hs60/v1/v1.c

@@ -13,8 +13,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/>.
  */
-#include "hs60.h"
-#include "config.h"
+#include "v1.h"
 
 // Please ignore this is for upcoming features
 /*#ifdef RAW_ENABLE

keyboards/hs60/v2/boards/GENERIC_STM32_F303XC/board.c

@@ -0,0 +1,126 @@
+/*
+    ChibiOS - Copyright (C) 2006..2016 Giovanni Di Sirio
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#include "hal.h"
+
+#if HAL_USE_PAL || defined(__DOXYGEN__)
+/**
+ * @brief   PAL setup.
+ * @details Digital I/O ports static configuration as defined in @p board.h.
+ *          This variable is used by the HAL when initializing the PAL driver.
+ */
+const PALConfig pal_default_config = {
+#if STM32_HAS_GPIOA
+  {VAL_GPIOA_MODER, VAL_GPIOA_OTYPER, VAL_GPIOA_OSPEEDR, VAL_GPIOA_PUPDR,
+   VAL_GPIOA_ODR,   VAL_GPIOA_AFRL,   VAL_GPIOA_AFRH},
+#endif
+#if STM32_HAS_GPIOB
+  {VAL_GPIOB_MODER, VAL_GPIOB_OTYPER, VAL_GPIOB_OSPEEDR, VAL_GPIOB_PUPDR,
+   VAL_GPIOB_ODR,   VAL_GPIOB_AFRL,   VAL_GPIOB_AFRH},
+#endif
+#if STM32_HAS_GPIOC
+  {VAL_GPIOC_MODER, VAL_GPIOC_OTYPER, VAL_GPIOC_OSPEEDR, VAL_GPIOC_PUPDR,
+   VAL_GPIOC_ODR,   VAL_GPIOC_AFRL,   VAL_GPIOC_AFRH},
+#endif
+#if STM32_HAS_GPIOD
+  {VAL_GPIOD_MODER, VAL_GPIOD_OTYPER, VAL_GPIOD_OSPEEDR, VAL_GPIOD_PUPDR,
+   VAL_GPIOD_ODR,   VAL_GPIOD_AFRL,   VAL_GPIOD_AFRH},
+#endif
+#if STM32_HAS_GPIOE
+  {VAL_GPIOE_MODER, VAL_GPIOE_OTYPER, VAL_GPIOE_OSPEEDR, VAL_GPIOE_PUPDR,
+   VAL_GPIOE_ODR,   VAL_GPIOE_AFRL,   VAL_GPIOE_AFRH},
+#endif
+#if STM32_HAS_GPIOF
+  {VAL_GPIOF_MODER, VAL_GPIOF_OTYPER, VAL_GPIOF_OSPEEDR, VAL_GPIOF_PUPDR,
+   VAL_GPIOF_ODR,   VAL_GPIOF_AFRL,   VAL_GPIOF_AFRH},
+#endif
+#if STM32_HAS_GPIOG
+  {VAL_GPIOG_MODER, VAL_GPIOG_OTYPER, VAL_GPIOG_OSPEEDR, VAL_GPIOG_PUPDR,
+   VAL_GPIOG_ODR,   VAL_GPIOG_AFRL,   VAL_GPIOG_AFRH},
+#endif
+#if STM32_HAS_GPIOH
+  {VAL_GPIOH_MODER, VAL_GPIOH_OTYPER, VAL_GPIOH_OSPEEDR, VAL_GPIOH_PUPDR,
+   VAL_GPIOH_ODR,   VAL_GPIOH_AFRL,   VAL_GPIOH_AFRH},
+#endif
+#if STM32_HAS_GPIOI
+  {VAL_GPIOI_MODER, VAL_GPIOI_OTYPER, VAL_GPIOI_OSPEEDR, VAL_GPIOI_PUPDR,
+   VAL_GPIOI_ODR,   VAL_GPIOI_AFRL,   VAL_GPIOI_AFRH}
+#endif
+};
+#endif
+
+void enter_bootloader_mode_if_requested(void);
+
+/**
+ * @brief   Early initialization code.
+ * @details This initialization must be performed just after stack setup
+ *          and before any other initialization.
+ */
+void __early_init(void) {
+  enter_bootloader_mode_if_requested();
+  stm32_clock_init();
+}
+
+#if HAL_USE_SDC || defined(__DOXYGEN__)
+/**
+ * @brief   SDC card detection.
+ */
+bool sdc_lld_is_card_inserted(SDCDriver *sdcp) {
+
+  (void)sdcp;
+  /* TODO: Fill the implementation.*/
+  return true;
+}
+
+/**
+ * @brief   SDC card write protection detection.
+ */
+bool sdc_lld_is_write_protected(SDCDriver *sdcp) {
+
+  (void)sdcp;
+  /* TODO: Fill the implementation.*/
+  return false;
+}
+#endif /* HAL_USE_SDC */
+
+#if HAL_USE_MMC_SPI || defined(__DOXYGEN__)
+/**
+ * @brief   MMC_SPI card detection.
+ */
+bool mmc_lld_is_card_inserted(MMCDriver *mmcp) {
+
+  (void)mmcp;
+  /* TODO: Fill the implementation.*/
+  return true;
+}
+
+/**
+ * @brief   MMC_SPI card write protection detection.
+ */
+bool mmc_lld_is_write_protected(MMCDriver *mmcp) {
+
+  (void)mmcp;
+  /* TODO: Fill the implementation.*/
+  return false;
+}
+#endif
+
+/**
+ * @brief   Board-specific initialization code.
+ * @todo    Add your board-specific code, if any.
+ */
+void boardInit(void) {
+}

keyboards/hs60/v2/boards/GENERIC_STM32_F303XC/board.mk

@@ -0,0 +1,5 @@
+# List of all the board related files.
+BOARDSRC = $(BOARD_PATH)/boards/GENERIC_STM32_F303XC/board.c
+
+# Required include directories
+BOARDINC = $(BOARD_PATH)/boards/GENERIC_STM32_F303XC

keyboards/hs60/v2/bootloader_defs.h

@@ -0,0 +1,7 @@
+/* Address for jumping to bootloader on STM32 chips. */
+/* It is chip dependent, the correct number can be looked up here:
+ * http://www.st.com/web/en/resource/technical/document/application_note/CD00167594.pdf
+ * This also requires a patch to chibios:
+ *  <tmk_dir>/tmk_core/tool/chibios/ch-bootloader-jump.patch
+ */
+#define STM32_BOOTLOADER_ADDRESS 0x1FFFD800

keyboards/hs60/v2/chconf.h

@@ -0,0 +1,520 @@
+/*
+    ChibiOS - Copyright (C) 2006..2016 Giovanni Di Sirio
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+/**
+ * @file    templates/chconf.h
+ * @brief   Configuration file template.
+ * @details A copy of this file must be placed in each project directory, it
+ *          contains the application specific kernel settings.
+ *
+ * @addtogroup config
+ * @details Kernel related settings and hooks.
+ * @{
+ */
+
+#ifndef CHCONF_H
+#define CHCONF_H
+
+#define _CHIBIOS_RT_CONF_
+
+/*===========================================================================*/
+/**
+ * @name System timers settings
+ * @{
+ */
+/*===========================================================================*/
+
+/**
+ * @brief   System time counter resolution.
+ * @note    Allowed values are 16 or 32 bits.
+ */
+#define CH_CFG_ST_RESOLUTION                32
+
+/**
+ * @brief   System tick frequency.
+ * @details Frequency of the system timer that drives the system ticks. This
+ *          setting also defines the system tick time unit.
+ */
+#define CH_CFG_ST_FREQUENCY                 100000
+
+/**
+ * @brief   Time delta constant for the tick-less mode.
+ * @note    If this value is zero then the system uses the classic
+ *          periodic tick. This value represents the minimum number
+ *          of ticks that is safe to specify in a timeout directive.
+ *          The value one is not valid, timeouts are rounded up to
+ *          this value.
+ */
+#define CH_CFG_ST_TIMEDELTA                 2
+
+/** @} */
+
+/*===========================================================================*/
+/**
+ * @name Kernel parameters and options
+ * @{
+ */
+/*===========================================================================*/
+
+/**
+ * @brief   Round robin interval.
+ * @details This constant is the number of system ticks allowed for the
+ *          threads before preemption occurs. Setting this value to zero
+ *          disables the preemption for threads with equal priority and the
+ *          round robin becomes cooperative. Note that higher priority
+ *          threads can still preempt, the kernel is always preemptive.
+ * @note    Disabling the round robin preemption makes the kernel more compact
+ *          and generally faster.
+ * @note    The round robin preemption is not supported in tickless mode and
+ *          must be set to zero in that case.
+ */
+#define CH_CFG_TIME_QUANTUM                 0
+
+/**
+ * @brief   Managed RAM size.
+ * @details Size of the RAM area to be managed by the OS. If set to zero
+ *          then the whole available RAM is used. The core memory is made
+ *          available to the heap allocator and/or can be used directly through
+ *          the simplified core memory allocator.
+ *
+ * @note    In order to let the OS manage the whole RAM the linker script must
+ *          provide the @p __heap_base__ and @p __heap_end__ symbols.
+ * @note    Requires @p CH_CFG_USE_MEMCORE.
+ */
+#define CH_CFG_MEMCORE_SIZE                 0
+
+/**
+ * @brief   Idle thread automatic spawn suppression.
+ * @details When this option is activated the function @p chSysInit()
+ *          does not spawn the idle thread. The application @p main()
+ *          function becomes the idle thread and must implement an
+ *          infinite loop.
+ */
+#define CH_CFG_NO_IDLE_THREAD               FALSE
+
+/** @} */
+
+/*===========================================================================*/
+/**
+ * @name Performance options
+ * @{
+ */
+/*===========================================================================*/
+
+/**
+ * @brief   OS optimization.
+ * @details If enabled then time efficient rather than space efficient code
+ *          is used when two possible implementations exist.
+ *
+ * @note    This is not related to the compiler optimization options.
+ * @note    The default is @p TRUE.
+ */
+#define CH_CFG_OPTIMIZE_SPEED               TRUE
+
+/** @} */
+
+/*===========================================================================*/
+/**
+ * @name Subsystem options
+ * @{
+ */
+/*===========================================================================*/
+
+/**
+ * @brief   Time Measurement APIs.
+ * @details If enabled then the time measurement APIs are included in
+ *          the kernel.
+ *
+ * @note    The default is @p TRUE.
+ */
+#define CH_CFG_USE_TM                       TRUE
+
+/**
+ * @brief   Threads registry APIs.
+ * @details If enabled then the registry APIs are included in the kernel.
+ *
+ * @note    The default is @p TRUE.
+ */
+#define CH_CFG_USE_REGISTRY                 TRUE
+
+/**
+ * @brief   Threads synchronization APIs.
+ * @details If enabled then the @p chThdWait() function is included in
+ *          the kernel.
+ *
+ * @note    The default is @p TRUE.
+ */
+#define CH_CFG_USE_WAITEXIT                 TRUE
+
+/**
+ * @brief   Semaphores APIs.
+ * @details If enabled then the Semaphores APIs are included in the kernel.
+ *
+ * @note    The default is @p TRUE.
+ */
+#define CH_CFG_USE_SEMAPHORES               TRUE
+
+/**
+ * @brief   Semaphores queuing mode.
+ * @details If enabled then the threads are enqueued on semaphores by
+ *          priority rather than in FIFO order.
+ *
+ * @note    The default is @p FALSE. Enable this if you have special
+ *          requirements.
+ * @note    Requires @p CH_CFG_USE_SEMAPHORES.
+ */
+#define CH_CFG_USE_SEMAPHORES_PRIORITY      FALSE
+
+/**
+ * @brief   Mutexes APIs.
+ * @details If enabled then the mutexes APIs are included in the kernel.
+ *
+ * @note    The default is @p TRUE.
+ */
+#define CH_CFG_USE_MUTEXES                  TRUE
+
+/**
+ * @brief   Enables recursive behavior on mutexes.
+ * @note    Recursive mutexes are heavier and have an increased
+ *          memory footprint.
+ *
+ * @note    The default is @p FALSE.
+ * @note    Requires @p CH_CFG_USE_MUTEXES.
+ */
+#define CH_CFG_USE_MUTEXES_RECURSIVE        FALSE
+
+/**
+ * @brief   Conditional Variables APIs.
+ * @details If enabled then the conditional variables APIs are included
+ *          in the kernel.
+ *
+ * @note    The default is @p TRUE.
+ * @note    Requires @p CH_CFG_USE_MUTEXES.
+ */
+#define CH_CFG_USE_CONDVARS                 TRUE
+
+/**
+ * @brief   Conditional Variables APIs with timeout.
+ * @details If enabled then the conditional variables APIs with timeout
+ *          specification are included in the kernel.
+ *
+ * @note    The default is @p TRUE.
+ * @note    Requires @p CH_CFG_USE_CONDVARS.
+ */
+#define CH_CFG_USE_CONDVARS_TIMEOUT         TRUE
+
+/**
+ * @brief   Events Flags APIs.
+ * @details If enabled then the event flags APIs are included in the kernel.
+ *
+ * @note    The default is @p TRUE.
+ */
+#define CH_CFG_USE_EVENTS                   TRUE
+
+/**
+ * @brief   Events Flags APIs with timeout.
+ * @details If enabled then the events APIs with timeout specification
+ *          are included in the kernel.
+ *
+ * @note    The default is @p TRUE.
+ * @note    Requires @p CH_CFG_USE_EVENTS.
+ */
+#define CH_CFG_USE_EVENTS_TIMEOUT           TRUE
+
+/**
+ * @brief   Synchronous Messages APIs.
+ * @details If enabled then the synchronous messages APIs are included
+ *          in the kernel.
+ *
+ * @note    The default is @p TRUE.
+ */
+#define CH_CFG_USE_MESSAGES                 TRUE
+
+/**
+ * @brief   Synchronous Messages queuing mode.
+ * @details If enabled then messages are served by priority rather than in
+ *          FIFO order.
+ *
+ * @note    The default is @p FALSE. Enable this if you have special
+ *          requirements.
+ * @note    Requires @p CH_CFG_USE_MESSAGES.
+ */
+#define CH_CFG_USE_MESSAGES_PRIORITY        TRUE
+
+/**
+ * @brief   Mailboxes APIs.
+ * @details If enabled then the asynchronous messages (mailboxes) APIs are
+ *          included in the kernel.
+ *
+ * @note    The default is @p TRUE.
+ * @note    Requires @p CH_CFG_USE_SEMAPHORES.
+ */
+#define CH_CFG_USE_MAILBOXES                TRUE
+
+/**
+ * @brief   Core Memory Manager APIs.
+ * @details If enabled then the core memory manager APIs are included
+ *          in the kernel.
+ *
+ * @note    The default is @p TRUE.
+ */
+#define CH_CFG_USE_MEMCORE                  TRUE
+
+/**
+ * @brief   Heap Allocator APIs.
+ * @details If enabled then the memory heap allocator APIs are included
+ *          in the kernel.
+ *
+ * @note    The default is @p TRUE.
+ * @note    Requires @p CH_CFG_USE_MEMCORE and either @p CH_CFG_USE_MUTEXES or
+ *          @p CH_CFG_USE_SEMAPHORES.
+ * @note    Mutexes are recommended.
+ */
+#define CH_CFG_USE_HEAP                     TRUE
+
+/**
+ * @brief   Memory Pools Allocator APIs.
+ * @details If enabled then the memory pools allocator APIs are included
+ *          in the kernel.
+ *
+ * @note    The default is @p TRUE.
+ */
+#define CH_CFG_USE_MEMPOOLS                 TRUE
+
+/**
+ * @brief   Dynamic Threads APIs.
+ * @details If enabled then the dynamic threads creation APIs are included
+ *          in the kernel.
+ *
+ * @note    The default is @p TRUE.
+ * @note    Requires @p CH_CFG_USE_WAITEXIT.
+ * @note    Requires @p CH_CFG_USE_HEAP and/or @p CH_CFG_USE_MEMPOOLS.
+ */
+#define CH_CFG_USE_DYNAMIC                  TRUE
+
+/** @} */
+
+/*===========================================================================*/
+/**
+ * @name Debug options
+ * @{
+ */
+/*===========================================================================*/
+
+/**
+ * @brief   Debug option, kernel statistics.
+ *
+ * @note    The default is @p FALSE.
+ */
+#define CH_DBG_STATISTICS                   FALSE
+
+/**
+ * @brief   Debug option, system state check.
+ * @details If enabled the correct call protocol for system APIs is checked
+ *          at runtime.
+ *
+ * @note    The default is @p FALSE.
+ */
+#define CH_DBG_SYSTEM_STATE_CHECK           FALSE
+
+/**
+ * @brief   Debug option, parameters checks.
+ * @details If enabled then the checks on the API functions input
+ *          parameters are activated.
+ *
+ * @note    The default is @p FALSE.
+ */
+#define CH_DBG_ENABLE_CHECKS                FALSE
+
+/**
+ * @brief   Debug option, consistency checks.
+ * @details If enabled then all the assertions in the kernel code are
+ *          activated. This includes consistency checks inside the kernel,
+ *          runtime anomalies and port-defined checks.
+ *
+ * @note    The default is @p FALSE.
+ */
+#define CH_DBG_ENABLE_ASSERTS               FALSE
+
+/**
+ * @brief   Debug option, trace buffer.
+ * @details If enabled then the trace buffer is activated.
+ *
+ * @note    The default is @p CH_DBG_TRACE_MASK_DISABLED.
+ */
+#define CH_DBG_TRACE_MASK                   CH_DBG_TRACE_MASK_DISABLED
+
+/**
+ * @brief   Trace buffer entries.
+ * @note    The trace buffer is only allocated if @p CH_DBG_TRACE_MASK is
+ *          different from @p CH_DBG_TRACE_MASK_DISABLED.
+ */
+#define CH_DBG_TRACE_BUFFER_SIZE            128
+
+/**
+ * @brief   Debug option, stack checks.
+ * @details If enabled then a runtime stack check is performed.
+ *
+ * @note    The default is @p FALSE.
+ * @note    The stack check is performed in a architecture/port dependent way.
+ *          It may not be implemented or some ports.
+ * @note    The default failure mode is to halt the system with the global
+ *          @p panic_msg variable set to @p NULL.
+ */
+#define CH_DBG_ENABLE_STACK_CHECK           TRUE
+
+/**
+ * @brief   Debug option, stacks initialization.
+ * @details If enabled then the threads working area is filled with a byte
+ *          value when a thread is created. This can be useful for the
+ *          runtime measurement of the used stack.
+ *
+ * @note    The default is @p FALSE.
+ */
+#define CH_DBG_FILL_THREADS                 FALSE
+
+/**
+ * @brief   Debug option, threads profiling.
+ * @details If enabled then a field is added to the @p thread_t structure that
+ *          counts the system ticks occurred while executing the thread.
+ *
+ * @note    The default is @p FALSE.
+ * @note    This debug option is not currently compatible with the
+ *          tickless mode.
+ */
+#define CH_DBG_THREADS_PROFILING            FALSE
+
+/** @} */
+
+/*===========================================================================*/
+/**
+ * @name Kernel hooks
+ * @{
+ */
+/*===========================================================================*/
+
+/**
+ * @brief   Threads descriptor structure extension.
+ * @details User fields added to the end of the @p thread_t structure.
+ */
+#define CH_CFG_THREAD_EXTRA_FIELDS                                          \
+  /* Add threads custom fields here.*/
+
+/**
+ * @brief   Threads initialization hook.
+ * @details User initialization code added to the @p chThdInit() API.
+ *
+ * @note    It is invoked from within @p chThdInit() and implicitly from all
+ *          the threads creation APIs.
+ */
+#define CH_CFG_THREAD_INIT_HOOK(tp) {                                       \
+  /* Add threads initialization code here.*/                                \
+}
+
+/**
+ * @brief   Threads finalization hook.
+ * @details User finalization code added to the @p chThdExit() API.
+ */
+#define CH_CFG_THREAD_EXIT_HOOK(tp) {                                       \
+  /* Add threads finalization code here.*/                                  \
+}
+
+/**
+ * @brief   Context switch hook.
+ * @details This hook is invoked just before switching between threads.
+ */
+#define CH_CFG_CONTEXT_SWITCH_HOOK(ntp, otp) {                              \
+  /* Context switch code here.*/                                            \
+}
+
+/**
+ * @brief   ISR enter hook.
+ */
+#define CH_CFG_IRQ_PROLOGUE_HOOK() {                                        \
+  /* IRQ prologue code here.*/                                              \
+}
+
+/**
+ * @brief   ISR exit hook.
+ */
+#define CH_CFG_IRQ_EPILOGUE_HOOK() {                                        \
+  /* IRQ epilogue code here.*/                                              \
+}
+
+/**
+ * @brief   Idle thread enter hook.
+ * @note    This hook is invoked within a critical zone, no OS functions
+ *          should be invoked from here.
+ * @note    This macro can be used to activate a power saving mode.
+ */
+#define CH_CFG_IDLE_ENTER_HOOK() {                                          \
+  /* Idle-enter code here.*/                                                \
+}
+
+/**
+ * @brief   Idle thread leave hook.
+ * @note    This hook is invoked within a critical zone, no OS functions
+ *          should be invoked from here.
+ * @note    This macro can be used to deactivate a power saving mode.
+ */
+#define CH_CFG_IDLE_LEAVE_HOOK() {                                          \
+  /* Idle-leave code here.*/                                                \
+}
+
+/**
+ * @brief   Idle Loop hook.
+ * @details This hook is continuously invoked by the idle thread loop.
+ */
+#define CH_CFG_IDLE_LOOP_HOOK() {                                           \
+  /* Idle loop code here.*/                                                 \
+}
+
+/**
+ * @brief   System tick event hook.
+ * @details This hook is invoked in the system tick handler immediately
+ *          after processing the virtual timers queue.
+ */
+#define CH_CFG_SYSTEM_TICK_HOOK() {                                         \
+  /* System tick event code here.*/                                         \
+}
+
+/**
+ * @brief   System halt hook.
+ * @details This hook is invoked in case to a system halting error before
+ *          the system is halted.
+ */
+#define CH_CFG_SYSTEM_HALT_HOOK(reason) {                                   \
+  /* System halt code here.*/                                               \
+}
+
+/**
+ * @brief   Trace hook.
+ * @details This hook is invoked each time a new record is written in the
+ *          trace buffer.
+ */
+#define CH_CFG_TRACE_HOOK(tep) {                                            \
+  /* Trace code here.*/                                                     \
+}
+
+/** @} */
+
+/*===========================================================================*/
+/* Port-specific settings (override port settings defaulted in chcore.h).    */
+/*===========================================================================*/
+
+#endif  /* CHCONF_H */
+
+/** @} */

keyboards/hs60/v2/config.h

@@ -0,0 +1,117 @@
+/*
+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/>.
+*/
+
+#pragma once
+
+#include "config_common.h"
+
+/* USB Device descriptor parameter */
+#define VENDOR_ID       0xFEED
+#define PRODUCT_ID      0x0258
+#define DEVICE_VER      0x0001
+#define MANUFACTURER    Yiancar-Designs
+#define PRODUCT         HS60 V2
+#define DESCRIPTION     GH60 compatible, tool free RGB keyboard
+
+/* key matrix size */
+#define MATRIX_ROWS 5
+#define MATRIX_COLS 14
+
+#define MATRIX_ROW_PINS { B3, B4, B5, A8, A4 }
+#define MATRIX_COL_PINS { A13, A10, A9, A14, A15, B8, B9, C13, C14, C15, A0, A1, A2, A3 }
+// To enable debugger set A13 A14 -> A5 A6
+
+/* COL2ROW, ROW2COL, or CUSTOM_MATRIX */
+#define DIODE_DIRECTION COL2ROW
+
+/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
+#define DEBOUNCE 0
+
+/* define if matrix has ghost (lacks anti-ghosting diodes) */
+//#define MATRIX_HAS_GHOST
+
+/* If defined, GRAVE_ESC will always act as ESC when CTRL is held.
+ * This is userful for the Windows task manager shortcut (ctrl+shift+esc).
+ */
+// #define GRAVE_ESC_CTRL_OVERRIDE
+
+/*
+ * Force NKRO
+ *
+ * Force NKRO (nKey Rollover) to be enabled by default, regardless of the saved
+ * state in the bootmagic EEPROM settings. (Note that NKRO must be enabled in the
+ * makefile for this to work.)
+ *
+ * If forced on, NKRO can be disabled via magic key (default = LShift+RShift+N)
+ * until the next keyboard reset.
+ *
+ * NKRO may prevent your keystrokes from being detected in the BIOS, but it is
+ * fully operational during normal computer usage.
+ *
+ * For a less heavy-handed approach, enable NKRO via magic key (LShift+RShift+N)
+ * or via bootmagic (hold SPACE+N while plugging in the keyboard). Once set by
+ * bootmagic, NKRO mode will always be enabled until it is toggled again during a
+ * power-up.
+ *
+ */
+//#define FORCE_NKRO
+
+/*
+ * 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)) \
+)
+
+/*
+ * Feature disable options
+ *  These options are also useful to firmware size reduction.
+ */
+
+/* disable debug print */
+//#define NO_DEBUG
+
+/* disable print */
+//#define NO_PRINT
+
+/* Backlight options */
+
+#define RGB_DISABLE_AFTER_TIMEOUT 0 // number of ticks to wait until disabling effects
+#define RGB_DISABLE_WHEN_USB_SUSPENDED false // turn off effects when suspended
+#define RGB_MATRIX_SKIP_FRAMES 3
+
+#define DRIVER_ADDR_1 0b1010000
+#define DRIVER_ADDR_2 0b1010000 // this is here for compliancy reasons.
+
+#define DRIVER_COUNT 2
+#ifdef HS60_ANSI
+#define DRIVER_1_LED_TOTAL 61
+#else
+#define DRIVER_1_LED_TOTAL 62
+#endif
+
+#define DRIVER_LED_TOTAL DRIVER_1_LED_TOTAL

keyboards/hs60/v2/halconf.h

@@ -0,0 +1,388 @@
+/*
+    ChibiOS - Copyright (C) 2006..2016 Giovanni Di Sirio
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+/**
+ * @file    templates/halconf.h
+ * @brief   HAL configuration header.
+ * @details HAL configuration file, this file allows to enable or disable the
+ *          various device drivers from your application. You may also use
+ *          this file in order to override the device drivers default settings.
+ *
+ * @addtogroup HAL_CONF
+ * @{
+ */
+
+#ifndef HALCONF_H
+#define HALCONF_H
+
+#include "mcuconf.h"
+
+/**
+ * @brief   Enables the PAL subsystem.
+ */
+#if !defined(HAL_USE_PAL) || defined(__DOXYGEN__)
+#define HAL_USE_PAL                 TRUE
+#endif
+
+/**
+ * @brief   Enables the ADC subsystem.
+ */
+#if !defined(HAL_USE_ADC) || defined(__DOXYGEN__)
+#define HAL_USE_ADC                 FALSE
+#endif
+
+/**
+ * @brief   Enables the CAN subsystem.
+ */
+#if !defined(HAL_USE_CAN) || defined(__DOXYGEN__)
+#define HAL_USE_CAN                 FALSE
+#endif
+
+/**
+ * @brief   Enables the DAC subsystem.
+ */
+#if !defined(HAL_USE_DAC) || defined(__DOXYGEN__)
+#define HAL_USE_DAC                 TRUE
+#endif
+
+/**
+ * @brief   Enables the EXT subsystem.
+ */
+#if !defined(HAL_USE_EXT) || defined(__DOXYGEN__)
+#define HAL_USE_EXT                 FALSE
+#endif
+
+/**
+ * @brief   Enables the GPT subsystem.
+ */
+#if !defined(HAL_USE_GPT) || defined(__DOXYGEN__)
+#define HAL_USE_GPT                 TRUE
+#endif
+
+/**
+ * @brief   Enables the I2C subsystem.
+ */
+#if !defined(HAL_USE_I2C) || defined(__DOXYGEN__)
+#define HAL_USE_I2C                 TRUE
+#endif
+
+/**
+ * @brief   Enables the I2S subsystem.
+ */
+#if !defined(HAL_USE_I2S) || defined(__DOXYGEN__)
+#define HAL_USE_I2S                 FALSE
+#endif
+
+/**
+ * @brief   Enables the ICU subsystem.
+ */
+#if !defined(HAL_USE_ICU) || defined(__DOXYGEN__)
+#define HAL_USE_ICU                 FALSE
+#endif
+
+/**
+ * @brief   Enables the MAC subsystem.
+ */
+#if !defined(HAL_USE_MAC) || defined(__DOXYGEN__)
+#define HAL_USE_MAC                 FALSE
+#endif
+
+/**
+ * @brief   Enables the MMC_SPI subsystem.
+ */
+#if !defined(HAL_USE_MMC_SPI) || defined(__DOXYGEN__)
+#define HAL_USE_MMC_SPI             FALSE
+#endif
+
+/**
+ * @brief   Enables the PWM subsystem.
+ */
+#if !defined(HAL_USE_PWM) || defined(__DOXYGEN__)
+#define HAL_USE_PWM                 FALSE
+#endif
+
+/**
+ * @brief   Enables the QSPI subsystem.
+ */
+#if !defined(HAL_USE_QSPI) || defined(__DOXYGEN__)
+#define HAL_USE_QSPI                FALSE
+#endif
+
+/**
+ * @brief   Enables the RTC subsystem.
+ */
+#if !defined(HAL_USE_RTC) || defined(__DOXYGEN__)
+#define HAL_USE_RTC                 FALSE
+#endif
+
+/**
+ * @brief   Enables the SDC subsystem.
+ */
+#if !defined(HAL_USE_SDC) || defined(__DOXYGEN__)
+#define HAL_USE_SDC                 FALSE
+#endif
+
+/**
+ * @brief   Enables the SERIAL subsystem.
+ */
+#if !defined(HAL_USE_SERIAL) || defined(__DOXYGEN__)
+#define HAL_USE_SERIAL              FALSE
+#endif
+
+/**
+ * @brief   Enables the SERIAL over USB subsystem.
+ */
+#if !defined(HAL_USE_SERIAL_USB) || defined(__DOXYGEN__)
+#define HAL_USE_SERIAL_USB          FALSE
+#endif
+
+/**
+ * @brief   Enables the SPI subsystem.
+ */
+#if !defined(HAL_USE_SPI) || defined(__DOXYGEN__)
+#define HAL_USE_SPI                 FALSE
+#endif
+
+/**
+ * @brief   Enables the UART subsystem.
+ */
+#if !defined(HAL_USE_UART) || defined(__DOXYGEN__)
+#define HAL_USE_UART                FALSE
+#endif
+
+/**
+ * @brief   Enables the USB subsystem.
+ */
+#if !defined(HAL_USE_USB) || defined(__DOXYGEN__)
+#define HAL_USE_USB                 TRUE
+#endif
+
+/**
+ * @brief   Enables the WDG subsystem.
+ */
+#if !defined(HAL_USE_WDG) || defined(__DOXYGEN__)
+#define HAL_USE_WDG                 FALSE
+#endif
+
+/*===========================================================================*/
+/* ADC driver related settings.                                              */
+/*===========================================================================*/
+
+/**
+ * @brief   Enables synchronous APIs.
+ * @note    Disabling this option saves both code and data space.
+ */
+#if !defined(ADC_USE_WAIT) || defined(__DOXYGEN__)
+#define ADC_USE_WAIT                TRUE
+#endif
+
+/**
+ * @brief   Enables the @p adcAcquireBus() and @p adcReleaseBus() APIs.
+ * @note    Disabling this option saves both code and data space.
+ */
+#if !defined(ADC_USE_MUTUAL_EXCLUSION) || defined(__DOXYGEN__)
+#define ADC_USE_MUTUAL_EXCLUSION    TRUE
+#endif
+
+/*===========================================================================*/
+/* CAN driver related settings.                                              */
+/*===========================================================================*/
+
+/**
+ * @brief   Sleep mode related APIs inclusion switch.
+ */
+#if !defined(CAN_USE_SLEEP_MODE) || defined(__DOXYGEN__)
+#define CAN_USE_SLEEP_MODE          TRUE
+#endif
+
+/*===========================================================================*/
+/* I2C driver related settings.                                              */
+/*===========================================================================*/
+
+/**
+ * @brief   Enables the mutual exclusion APIs on the I2C bus.
+ */
+#if !defined(I2C_USE_MUTUAL_EXCLUSION) || defined(__DOXYGEN__)
+#define I2C_USE_MUTUAL_EXCLUSION    TRUE
+#endif
+
+/*===========================================================================*/
+/* MAC driver related settings.                                              */
+/*===========================================================================*/
+
+/**
+ * @brief   Enables an event sources for incoming packets.
+ */
+#if !defined(MAC_USE_ZERO_COPY) || defined(__DOXYGEN__)
+#define MAC_USE_ZERO_COPY           FALSE
+#endif
+
+/**
+ * @brief   Enables an event sources for incoming packets.
+ */
+#if !defined(MAC_USE_EVENTS) || defined(__DOXYGEN__)
+#define MAC_USE_EVENTS              TRUE
+#endif
+
+/*===========================================================================*/
+/* MMC_SPI driver related settings.                                          */
+/*===========================================================================*/
+
+/**
+ * @brief   Delays insertions.
+ * @details If enabled this options inserts delays into the MMC waiting
+ *          routines releasing some extra CPU time for the threads with
+ *          lower priority, this may slow down the driver a bit however.
+ *          This option is recommended also if the SPI driver does not
+ *          use a DMA channel and heavily loads the CPU.
+ */
+#if !defined(MMC_NICE_WAITING) || defined(__DOXYGEN__)
+#define MMC_NICE_WAITING            TRUE
+#endif
+
+/*===========================================================================*/
+/* SDC driver related settings.                                              */
+/*===========================================================================*/
+
+/**
+ * @brief   Number of initialization attempts before rejecting the card.
+ * @note    Attempts are performed at 10mS intervals.
+ */
+#if !defined(SDC_INIT_RETRY) || defined(__DOXYGEN__)
+#define SDC_INIT_RETRY              100
+#endif
+
+/**
+ * @brief   Include support for MMC cards.
+ * @note    MMC support is not yet implemented so this option must be kept
+ *          at @p FALSE.
+ */
+#if !defined(SDC_MMC_SUPPORT) || defined(__DOXYGEN__)
+#define SDC_MMC_SUPPORT             FALSE
+#endif
+
+/**
+ * @brief   Delays insertions.
+ * @details If enabled this options inserts delays into the MMC waiting
+ *          routines releasing some extra CPU time for the threads with
+ *          lower priority, this may slow down the driver a bit however.
+ */
+#if !defined(SDC_NICE_WAITING) || defined(__DOXYGEN__)
+#define SDC_NICE_WAITING            TRUE
+#endif
+
+/*===========================================================================*/
+/* SERIAL driver related settings.                                           */
+/*===========================================================================*/
+
+/**
+ * @brief   Default bit rate.
+ * @details Configuration parameter, this is the baud rate selected for the
+ *          default configuration.
+ */
+#if !defined(SERIAL_DEFAULT_BITRATE) || defined(__DOXYGEN__)
+#define SERIAL_DEFAULT_BITRATE      38400
+#endif
+
+/**
+ * @brief   Serial buffers size.
+ * @details Configuration parameter, you can change the depth of the queue
+ *          buffers depending on the requirements of your application.
+ * @note    The default is 16 bytes for both the transmission and receive
+ *          buffers.
+ */
+#if !defined(SERIAL_BUFFERS_SIZE) || defined(__DOXYGEN__)
+#define SERIAL_BUFFERS_SIZE         16
+#endif
+
+/*===========================================================================*/
+/* SERIAL_USB driver related setting.                                        */
+/*===========================================================================*/
+
+/**
+ * @brief   Serial over USB buffers size.
+ * @details Configuration parameter, the buffer size must be a multiple of
+ *          the USB data endpoint maximum packet size.
+ * @note    The default is 256 bytes for both the transmission and receive
+ *          buffers.
+ */
+#if !defined(SERIAL_USB_BUFFERS_SIZE) || defined(__DOXYGEN__)
+#define SERIAL_USB_BUFFERS_SIZE     1
+#endif
+
+/**
+ * @brief   Serial over USB number of buffers.
+ * @note    The default is 2 buffers.
+ */
+#if !defined(SERIAL_USB_BUFFERS_NUMBER) || defined(__DOXYGEN__)
+#define SERIAL_USB_BUFFERS_NUMBER   2
+#endif
+
+/*===========================================================================*/
+/* SPI driver related settings.                                              */
+/*===========================================================================*/
+
+/**
+ * @brief   Enables synchronous APIs.
+ * @note    Disabling this option saves both code and data space.
+ */
+#if !defined(SPI_USE_WAIT) || defined(__DOXYGEN__)
+#define SPI_USE_WAIT                TRUE
+#endif
+
+/**
+ * @brief   Enables the @p spiAcquireBus() and @p spiReleaseBus() APIs.
+ * @note    Disabling this option saves both code and data space.
+ */
+#if !defined(SPI_USE_MUTUAL_EXCLUSION) || defined(__DOXYGEN__)
+#define SPI_USE_MUTUAL_EXCLUSION    TRUE
+#endif
+
+/*===========================================================================*/
+/* UART driver related settings.                                             */
+/*===========================================================================*/
+
+/**
+ * @brief   Enables synchronous APIs.
+ * @note    Disabling this option saves both code and data space.
+ */
+#if !defined(UART_USE_WAIT) || defined(__DOXYGEN__)
+#define UART_USE_WAIT               FALSE
+#endif
+
+/**
+ * @brief   Enables the @p uartAcquireBus() and @p uartReleaseBus() APIs.
+ * @note    Disabling this option saves both code and data space.
+ */
+#if !defined(UART_USE_MUTUAL_EXCLUSION) || defined(__DOXYGEN__)
+#define UART_USE_MUTUAL_EXCLUSION   FALSE
+#endif
+
+/*===========================================================================*/
+/* USB driver related settings.                                              */
+/*===========================================================================*/
+
+/**
+ * @brief   Enables synchronous APIs.
+ * @note    Disabling this option saves both code and data space.
+ */
+#if !defined(USB_USE_WAIT) || defined(__DOXYGEN__)
+#define USB_USE_WAIT                TRUE
+#endif
+
+#endif /* HALCONF_H */
+
+/** @} */

keyboards/hs60/v2/keymaps/ansi/config.h

@@ -0,0 +1,21 @@
+/*
+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/>.
+*/
+#pragma once
+
+/* Include overwrites for specific keymap */
+
+#define HS60_ANSI

keyboards/hs60/v2/keymaps/ansi/keymap.c

@@ -0,0 +1,46 @@
+/* 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/>.
+ */
+#include QMK_KEYBOARD_H
+
+//This is the ANSI version of the PCB
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+[0] = LAYOUT_60_ansi( /* Base */
+    KC_GESC,  KC_1,     KC_2,     KC_3,  KC_4,  KC_5,  KC_6,    KC_7,  KC_8,  KC_9,     KC_0,     KC_MINS,  KC_EQL,  KC_BSPC,\
+    KC_TAB,   KC_Q,     KC_W,     KC_E,  KC_R,  KC_T,  KC_Y,    KC_U,  KC_I,  KC_O,     KC_P,     KC_LBRC,  KC_RBRC, KC_BSLS,\
+    KC_CAPS,  KC_A,     KC_S,     KC_D,  KC_F,  KC_G,  KC_H,    KC_J,  KC_K,  KC_L,     KC_SCLN,  KC_QUOT,           KC_ENT, \
+    KC_LSFT,            KC_Z,     KC_X,  KC_C,  KC_V,  KC_B,    KC_N,  KC_M,  KC_COMM,  KC_DOT,   KC_SLSH,           KC_RSFT,\
+    KC_LCTL,  KC_LGUI,  KC_LALT,                       KC_SPC,                          KC_RALT,  MO(1)  ,  KC_APP,  KC_RCTL),
+
+[1] = LAYOUT_60_ansi( /* FN */
+    KC_TRNS,  KC_F1,    KC_F2,    KC_F3,    KC_F4,    KC_F5,    KC_F6,    KC_F7,    KC_F8,    KC_F9,    KC_F10,   KC_F11,   KC_F12,   KC_DEL ,\
+    KC_TRNS,  KC_TRNS,  KC_UP,    KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  RESET  ,  KC_TRNS,\
+    KC_TRNS,  KC_LEFT,  KC_DOWN,  KC_RGHT,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,\
+    KC_TRNS,            RGB_TOG,  RGB_MOD,  RGB_HUI,  RGB_HUD,  RGB_SAI,  RGB_SAD,  RGB_VAI,  RGB_VAD,  RGB_SPI,  RGB_SPD,            KC_TRNS,\
+    KC_VOLU,  KC_VOLD,  KC_MUTE,                                KC_TRNS,                                KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS),
+};
+
+void matrix_init_user(void) {
+  //user initialization
+}
+
+void matrix_scan_user(void) {
+  //user matrix
+}
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  return true;
+}

keyboards/hs60/v2/keymaps/ansi/readme.md

@@ -0,0 +1,6 @@
+The default keymap for ANSI HS60
+================================
+
+![Layout image](https://imgur.com/CSyPw0J.png)
+
+Default layer is normal ANSI and Fn layer is used for RGB functions, Volume control and arrow cluster

keyboards/hs60/v2/keymaps/default/keymap.c

@@ -0,0 +1,46 @@
+/* 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/>.
+ */
+#include QMK_KEYBOARD_H
+
+//This is the ISO version of the PCB
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+[0] = LAYOUT_60_iso( /* Base */
+    KC_GESC,  KC_1,     KC_2,     KC_3,  KC_4,  KC_5,  KC_6,    KC_7,  KC_8,  KC_9,     KC_0,     KC_MINS,  KC_EQL,  KC_BSPC,\
+    KC_TAB,   KC_Q,     KC_W,     KC_E,  KC_R,  KC_T,  KC_Y,    KC_U,  KC_I,  KC_O,     KC_P,     KC_LBRC,  KC_RBRC,         \
+    KC_CAPS,  KC_A,     KC_S,     KC_D,  KC_F,  KC_G,  KC_H,    KC_J,  KC_K,  KC_L,     KC_SCLN,  KC_QUOT,  KC_NUHS, KC_ENT, \
+    KC_LSFT,  KC_NUBS,  KC_Z,     KC_X,  KC_C,  KC_V,  KC_B,    KC_N,  KC_M,  KC_COMM,  KC_DOT,   KC_SLSH,           KC_RSFT,\
+    KC_LCTL,  KC_LGUI,  KC_LALT,                       KC_SPC,                          KC_RALT,  MO(1)  ,  KC_APP,  KC_RCTL),
+
+[1] = LAYOUT_60_iso( /* FN */
+    KC_TRNS,  KC_F1,    KC_F2,    KC_F3,    KC_F4,    KC_F5,    KC_F6,    KC_F7,    KC_F8,    KC_F9,    KC_F10,   KC_F11,   KC_F12,   KC_DEL ,\
+    KC_TRNS,  KC_TRNS,  KC_UP,    KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  RESET  ,          \
+    KC_TRNS,  KC_LEFT,  KC_DOWN,  KC_RGHT,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,\
+    KC_TRNS,  RGB_TOG,  RGB_MOD,  RGB_HUI,  RGB_HUD,  RGB_SAI,  RGB_SAD,  RGB_VAI,  RGB_VAD,  RGB_SPI,  RGB_SPD,  KC_TRNS,            KC_TRNS,\
+    KC_VOLU,  KC_VOLD,  KC_MUTE,                                KC_TRNS,                                KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS),
+};
+
+void matrix_init_user(void) {
+  //user initialization
+}
+
+void matrix_scan_user(void) {
+  //user matrix
+}
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  return true;
+}

keyboards/hs60/v2/keymaps/default/readme.md

@@ -0,0 +1,6 @@
+The default keymap for ISO HS60
+===============================
+
+![Layout image](https://imgur.com/HXj4tYL.png)
+
+Default layer is normal ISO and Fn layer is used for RGB functions, Volume control and arrow cluster

keyboards/hs60/v2/keymaps/hhkb/config.h

@@ -0,0 +1,21 @@
+/*
+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/>.
+*/
+#pragma once
+
+/* Include overwrites for specific keymap */
+
+#define HS60_HHKB

keyboards/hs60/v2/keymaps/hhkb/keymap.c

@@ -0,0 +1,46 @@
+/* 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/>.
+ */
+#include QMK_KEYBOARD_H
+
+//This is the HHKB version of the PCB
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+[0] = LAYOUT_60_hhkb( /* Base */
+    KC_ESC,   KC_1,  KC_2,  KC_3,  KC_4,  KC_5,  KC_6,  KC_7,  KC_8,     KC_9,    KC_0,     KC_MINS,  KC_EQL,  KC_GRV,  KC_BSLS, \
+    KC_TAB,   KC_Q,  KC_W,  KC_E,  KC_R,  KC_T,  KC_Y,  KC_U,  KC_I,     KC_O,    KC_P,     KC_LBRC,  KC_RBRC,       KC_BSPC,    \
+    KC_LCTL,  KC_A,  KC_S,  KC_D,  KC_F,  KC_G,  KC_H,  KC_J,  KC_K,     KC_L,    KC_SCLN,  KC_QUOT,            KC_ENT,          \
+    KC_LSFT,  KC_Z,  KC_X,  KC_C,  KC_V,  KC_B,  KC_N,  KC_M,  KC_COMM,  KC_DOT,  KC_SLSH,  KC_RSFT,            MO(1),           \
+    KC_LCTL, KC_LGUI,KC_LALT,                 KC_SPC,                             KC_RALT,  KC_RGUI,          KC_RCTL          ),
+
+[1] = LAYOUT_60_hhkb( /* FN */
+    RESET, KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,    KC_F9,    KC_F10,   KC_F11,   KC_F12,  KC_TRNS,  KC_TRNS,\
+    KC_TRNS, RGB_TOG, RGB_MOD, RGB_HUI, RGB_HUD, RGB_SAI, RGB_SAD, RGB_VAI, RGB_VAD,  RGB_SPI,  RGB_SPD,    KC_UP,  KC_TRNS,       KC_DEL,      \
+    KC_TRNS, KC_VOLD, KC_VOLU, KC_MUTE, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_HOME,  KC_PGUP,  KC_LEFT, KC_RGHT,          KC_TRNS,            \
+    KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,  KC_END,  KC_PGDN,  KC_DOWN, KC_TRNS,          KC_TRNS,            \
+    KC_TRNS, KC_TRNS, KC_TRNS,                 KC_TRNS,                             KC_TRNS,  KC_TRNS,            KC_TRNS                       )
+};
+
+void matrix_init_user(void) {
+  //user initialization
+}
+
+void matrix_scan_user(void) {
+  //user matrix
+}
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  return true;
+}

keyboards/hs60/v2/mcuconf.h

@@ -0,0 +1,257 @@
+/*
+    ChibiOS - Copyright (C) 2006..2016 Giovanni Di Sirio
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#ifndef MCUCONF_H
+#define MCUCONF_H
+
+/*
+ * STM32F3xx drivers configuration.
+ * The following settings override the default settings present in
+ * the various device driver implementation headers.
+ * Note that the settings for each driver only have effect if the whole
+ * driver is enabled in halconf.h.
+ *
+ * IRQ priorities:
+ * 15...0       Lowest...Highest.
+ *
+ * DMA priorities:
+ * 0...3        Lowest...Highest.
+ */
+
+#define STM32F3xx_MCUCONF
+
+/*
+ * HAL driver system settings.
+ */
+#define STM32_NO_INIT                       FALSE
+#define STM32_PVD_ENABLE                    FALSE
+#define STM32_PLS                           STM32_PLS_LEV0
+#define STM32_HSI_ENABLED                   TRUE
+#define STM32_LSI_ENABLED                   TRUE
+#define STM32_HSE_ENABLED                   TRUE
+#define STM32_LSE_ENABLED                   FALSE
+#define STM32_SW                            STM32_SW_PLL
+#define STM32_PLLSRC                        STM32_PLLSRC_HSE
+#define STM32_PREDIV_VALUE                  1
+#define STM32_PLLMUL_VALUE                  9
+#define STM32_HPRE                          STM32_HPRE_DIV1
+#define STM32_PPRE1                         STM32_PPRE1_DIV2
+#define STM32_PPRE2                         STM32_PPRE2_DIV2
+#define STM32_MCOSEL                        STM32_MCOSEL_NOCLOCK
+#define STM32_ADC12PRES                     STM32_ADC12PRES_DIV1
+#define STM32_ADC34PRES                     STM32_ADC34PRES_DIV1
+#define STM32_USART1SW                      STM32_USART1SW_PCLK
+#define STM32_USART2SW                      STM32_USART2SW_PCLK
+#define STM32_USART3SW                      STM32_USART3SW_PCLK
+#define STM32_UART4SW                       STM32_UART4SW_PCLK
+#define STM32_UART5SW                       STM32_UART5SW_PCLK
+#define STM32_I2C1SW                        STM32_I2C1SW_SYSCLK
+#define STM32_I2C2SW                        STM32_I2C2SW_SYSCLK
+#define STM32_TIM1SW                        STM32_TIM1SW_PCLK2
+#define STM32_TIM8SW                        STM32_TIM8SW_PCLK2
+#define STM32_RTCSEL                        STM32_RTCSEL_LSI
+#define STM32_USB_CLOCK_REQUIRED            TRUE
+#define STM32_USBPRE                        STM32_USBPRE_DIV1P5
+
+#undef STM32_HSE_BYPASS
+// #error "oh no"
+// #endif
+
+/*
+ * ADC driver system settings.
+ */
+#define STM32_ADC_DUAL_MODE                 FALSE
+#define STM32_ADC_COMPACT_SAMPLES           FALSE
+#define STM32_ADC_USE_ADC1                  FALSE
+#define STM32_ADC_USE_ADC2                  FALSE
+#define STM32_ADC_USE_ADC3                  FALSE
+#define STM32_ADC_USE_ADC4                  FALSE
+#define STM32_ADC_ADC1_DMA_STREAM           STM32_DMA_STREAM_ID(1, 1)
+#define STM32_ADC_ADC2_DMA_STREAM           STM32_DMA_STREAM_ID(2, 1)
+#define STM32_ADC_ADC3_DMA_STREAM           STM32_DMA_STREAM_ID(2, 5)
+#define STM32_ADC_ADC4_DMA_STREAM           STM32_DMA_STREAM_ID(2, 2)
+#define STM32_ADC_ADC1_DMA_PRIORITY         2
+#define STM32_ADC_ADC2_DMA_PRIORITY         2
+#define STM32_ADC_ADC3_DMA_PRIORITY         2
+#define STM32_ADC_ADC4_DMA_PRIORITY         2
+#define STM32_ADC_ADC12_IRQ_PRIORITY        5
+#define STM32_ADC_ADC3_IRQ_PRIORITY         5
+#define STM32_ADC_ADC4_IRQ_PRIORITY         5
+#define STM32_ADC_ADC1_DMA_IRQ_PRIORITY     5
+#define STM32_ADC_ADC2_DMA_IRQ_PRIORITY     5
+#define STM32_ADC_ADC3_DMA_IRQ_PRIORITY     5
+#define STM32_ADC_ADC4_DMA_IRQ_PRIORITY     5
+#define STM32_ADC_ADC12_CLOCK_MODE          ADC_CCR_CKMODE_AHB_DIV1
+#define STM32_ADC_ADC34_CLOCK_MODE          ADC_CCR_CKMODE_AHB_DIV1
+
+/*
+ * CAN driver system settings.
+ */
+#define STM32_CAN_USE_CAN1                  FALSE
+#define STM32_CAN_CAN1_IRQ_PRIORITY         11
+
+/*
+ * DAC driver system settings.
+ */
+#define STM32_DAC_DUAL_MODE                 FALSE
+#define STM32_DAC_USE_DAC1_CH1              TRUE
+#define STM32_DAC_USE_DAC1_CH2              TRUE
+#define STM32_DAC_DAC1_CH1_IRQ_PRIORITY     10
+#define STM32_DAC_DAC1_CH2_IRQ_PRIORITY     10
+#define STM32_DAC_DAC1_CH1_DMA_PRIORITY     2
+#define STM32_DAC_DAC1_CH2_DMA_PRIORITY     2
+
+/*
+ * EXT driver system settings.
+ */
+#define STM32_EXT_EXTI0_IRQ_PRIORITY        6
+#define STM32_EXT_EXTI1_IRQ_PRIORITY        6
+#define STM32_EXT_EXTI2_IRQ_PRIORITY        6
+#define STM32_EXT_EXTI3_IRQ_PRIORITY        6
+#define STM32_EXT_EXTI4_IRQ_PRIORITY        6
+#define STM32_EXT_EXTI5_9_IRQ_PRIORITY      6
+#define STM32_EXT_EXTI10_15_IRQ_PRIORITY    6
+#define STM32_EXT_EXTI16_IRQ_PRIORITY       6
+#define STM32_EXT_EXTI17_IRQ_PRIORITY       6
+#define STM32_EXT_EXTI18_IRQ_PRIORITY       6
+#define STM32_EXT_EXTI19_IRQ_PRIORITY       6
+#define STM32_EXT_EXTI20_IRQ_PRIORITY       6
+#define STM32_EXT_EXTI21_22_29_IRQ_PRIORITY 6
+#define STM32_EXT_EXTI30_32_IRQ_PRIORITY    6
+#define STM32_EXT_EXTI33_IRQ_PRIORITY       6
+
+/*
+ * GPT driver system settings.
+ */
+#define STM32_GPT_USE_TIM1                  FALSE
+#define STM32_GPT_USE_TIM2                  FALSE
+#define STM32_GPT_USE_TIM3                  FALSE
+#define STM32_GPT_USE_TIM4                  FALSE
+#define STM32_GPT_USE_TIM6                  TRUE
+#define STM32_GPT_USE_TIM7                  TRUE
+#define STM32_GPT_USE_TIM8                  TRUE
+#define STM32_GPT_TIM1_IRQ_PRIORITY         7
+#define STM32_GPT_TIM2_IRQ_PRIORITY         7
+#define STM32_GPT_TIM3_IRQ_PRIORITY         7
+#define STM32_GPT_TIM4_IRQ_PRIORITY         7
+#define STM32_GPT_TIM6_IRQ_PRIORITY         7
+#define STM32_GPT_TIM7_IRQ_PRIORITY         7
+#define STM32_GPT_TIM8_IRQ_PRIORITY         7
+
+/*
+ * I2C driver system settings.
+ */
+#define STM32_I2C_USE_I2C1                  TRUE
+#define STM32_I2C_USE_I2C2                  FALSE
+#define STM32_I2C_BUSY_TIMEOUT              50
+#define STM32_I2C_I2C1_IRQ_PRIORITY         10
+#define STM32_I2C_I2C2_IRQ_PRIORITY         10
+#define STM32_I2C_USE_DMA                   TRUE
+#define STM32_I2C_I2C1_DMA_PRIORITY         1
+#define STM32_I2C_I2C2_DMA_PRIORITY         1
+#define STM32_I2C_DMA_ERROR_HOOK(i2cp)      osalSysHalt("DMA failure")
+
+/*
+ * ICU driver system settings.
+ */
+#define STM32_ICU_USE_TIM1                  FALSE
+#define STM32_ICU_USE_TIM2                  FALSE
+#define STM32_ICU_USE_TIM3                  FALSE
+#define STM32_ICU_USE_TIM4                  FALSE
+#define STM32_ICU_USE_TIM8                  FALSE
+#define STM32_ICU_TIM1_IRQ_PRIORITY         7
+#define STM32_ICU_TIM2_IRQ_PRIORITY         7
+#define STM32_ICU_TIM3_IRQ_PRIORITY         7
+#define STM32_ICU_TIM4_IRQ_PRIORITY         7
+#define STM32_ICU_TIM8_IRQ_PRIORITY         7
+
+/*
+ * PWM driver system settings.
+ */
+#define STM32_PWM_USE_ADVANCED              FALSE
+#define STM32_PWM_USE_TIM1                  FALSE
+#define STM32_PWM_USE_TIM2                  FALSE
+#define STM32_PWM_USE_TIM3                  FALSE
+#define STM32_PWM_USE_TIM4                  FALSE
+#define STM32_PWM_USE_TIM8                  FALSE
+#define STM32_PWM_TIM1_IRQ_PRIORITY         7
+#define STM32_PWM_TIM2_IRQ_PRIORITY         7
+#define STM32_PWM_TIM3_IRQ_PRIORITY         7
+#define STM32_PWM_TIM4_IRQ_PRIORITY         7
+#define STM32_PWM_TIM8_IRQ_PRIORITY         7
+
+/*
+ * SERIAL driver system settings.
+ */
+#define STM32_SERIAL_USE_USART1             FALSE
+#define STM32_SERIAL_USE_USART2             FALSE
+#define STM32_SERIAL_USE_USART3             FALSE
+#define STM32_SERIAL_USE_UART4              FALSE
+#define STM32_SERIAL_USE_UART5              FALSE
+#define STM32_SERIAL_USART1_PRIORITY        12
+#define STM32_SERIAL_USART2_PRIORITY        12
+#define STM32_SERIAL_USART3_PRIORITY        12
+#define STM32_SERIAL_UART4_PRIORITY         12
+#define STM32_SERIAL_UART5_PRIORITY         12
+
+/*
+ * SPI driver system settings.
+ */
+#define STM32_SPI_USE_SPI1                  FALSE
+#define STM32_SPI_USE_SPI2                  FALSE
+#define STM32_SPI_USE_SPI3                  FALSE
+#define STM32_SPI_SPI1_DMA_PRIORITY         1
+#define STM32_SPI_SPI2_DMA_PRIORITY         1
+#define STM32_SPI_SPI3_DMA_PRIORITY         1
+#define STM32_SPI_SPI1_IRQ_PRIORITY         10
+#define STM32_SPI_SPI2_IRQ_PRIORITY         10
+#define STM32_SPI_SPI3_IRQ_PRIORITY         10
+#define STM32_SPI_DMA_ERROR_HOOK(spip)      osalSysHalt("DMA failure")
+
+/*
+ * ST driver system settings.
+ */
+#define STM32_ST_IRQ_PRIORITY               8
+#define STM32_ST_USE_TIMER                  2
+
+/*
+ * UART driver system settings.
+ */
+#define STM32_UART_USE_USART1               FALSE
+#define STM32_UART_USE_USART2               FALSE
+#define STM32_UART_USE_USART3               FALSE
+#define STM32_UART_USART1_IRQ_PRIORITY      12
+#define STM32_UART_USART2_IRQ_PRIORITY      12
+#define STM32_UART_USART3_IRQ_PRIORITY      12
+#define STM32_UART_USART1_DMA_PRIORITY      0
+#define STM32_UART_USART2_DMA_PRIORITY      0
+#define STM32_UART_USART3_DMA_PRIORITY      0
+#define STM32_UART_DMA_ERROR_HOOK(uartp)    osalSysHalt("DMA failure")
+
+/*
+ * USB driver system settings.
+ */
+#define STM32_USB_USE_USB1                  TRUE
+#define STM32_USB_LOW_POWER_ON_SUSPEND      FALSE
+#define STM32_USB_USB1_HP_IRQ_PRIORITY      13
+#define STM32_USB_USB1_LP_IRQ_PRIORITY      14
+
+/*
+ * WDG driver system settings.
+ */
+#define STM32_WDG_USE_IWDG                  FALSE
+
+#endif /* MCUCONF_H */

keyboards/hs60/v2/readme.md

@@ -0,0 +1,18 @@
+HS60 V2.0
+=========
+
+[HS60](https://mechboards.co.uk/wp-content/uploads/2018/04/IMG_20180420_140353.jpg)
+
+This is a standard fixed layout 60% PCB. It comes in three variants; ISO, ANSI and HHKB and support full per-key RGB.
+
+Keyboard Maintainer: [Yiancar](http://yiancar-designs.com/) and on [github](https://github.com/yiancar)  
+Hardware Supported: HS60 ISO, ANSI and HHKB PCBs with STM32F303CC   
+Hardware Availability: http://groupbuys.mechboards.co.uk/shop/hs60-hotswap-60-pcb/   
+
+Due to the RGB implementation, the HS60 is currently not compatible with community layouts.
+
+Make example for this keyboard (after setting up your build environment):
+
+    make hs60/v2: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/hs60/v2/rules.mk

@@ -0,0 +1,58 @@
+# project specific files
+
+## chip/board settings
+#   the next two should match the directories in
+#   <chibios>/os/hal/ports/$(MCU_FAMILY)/$(MCU_SERIES)
+MCU_FAMILY = STM32
+MCU_SERIES = STM32F3xx
+
+# Linker script to use
+#   it should exist either in <chibios>/os/common/ports/ARMCMx/compilers/GCC/ld/
+#   or <this_dir>/ld/
+MCU_LDSCRIPT = STM32F303xC
+
+# Startup code to use
+#  - it should exist in <chibios>/os/common/startup/ARMCMx/compilers/GCC/mk/
+MCU_STARTUP = stm32f3xx
+
+# Board: it should exist either in <chibios>/os/hal/boards/
+#  or <this_dir>/boards
+BOARD = GENERIC_STM32_F303XC
+
+# Cortex version
+MCU  = cortex-m4
+
+# ARM version, CORTEX-M0/M1 are 6, CORTEX-M3/M4/M7 are 7
+ARMV = 7
+
+USE_FPU = yes
+
+# Vector table for application
+# 0x00000000-0x00001000 area is occupied by bootlaoder.*/
+# The CORTEX_VTOR... is needed only for MCHCK/Infinity KB
+# OPT_DEFS = -DCORTEX_VTOR_INIT=0x08005000
+OPT_DEFS =
+
+# Do not put the microcontroller into power saving mode
+# when we get USB suspend event. We want it to keep updating
+# backlight effects.
+OPT_DEFS += -DNO_SUSPEND_POWER_DOWN
+
+# Options to pass to dfu-util when flashing
+DFU_ARGS = -d 0483:df11 -a 0 -s 0x08000000:leave
+
+# Build Options
+#   comment out to disable the options.
+#
+BACKLIGHT_ENABLE = no
+BOOTMAGIC_ENABLE = yes             # Virtual DIP switch configuration
+MOUSEKEY_ENABLE = yes              # Mouse keys
+EXTRAKEY_ENABLE = yes              # Audio control and System control
+CONSOLE_ENABLE = no                # Console for debug
+COMMAND_ENABLE = no                # Commands for debug and configuration
+#SLEEP_LED_ENABLE = yes            # Breathing sleep LED during USB suspend
+NKRO_ENABLE = yes                  # USB Nkey Rollover
+AUDIO_ENABLE = no
+RGB_MATRIX_ENABLE = IS31FL3733     # Use RGB matrix
+NO_USB_STARTUP_CHECK = no          # Disable initialization only when usb is plugged in
+#SERIAL_LINK_ENABLE = yes

keyboards/hs60/v2/v2.c

@@ -0,0 +1,635 @@
+/* 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/>.
+ */
+#include "v2.h"
+
+//#include "is31fl3733.h"
+
+// Please ignore this is for upcoming features
+/*#ifdef RAW_ENABLE
+
+void raw_hid_receive( uint8_t *data, uint8_t length )
+{
+    uint8_t command = data[0];
+    switch ( command )
+    {
+        case id_protocol_version:
+        {
+            msg_protocol_version *msg = (msg_protocol_version*)&data[1];
+            msg->version = PROTOCOL_VERSION;
+            break;
+        }
+#if USE_KEYMAPS_IN_EEPROM
+        case id_keymap_keycode_load:
+        {
+            msg_keymap_keycode_load *msg = (msg_keymap_keycode_load*)&data[1];
+            msg->keycode = keymap_keycode_load( msg->layer, msg->row, msg->column );
+            break;
+        }
+        case id_keymap_keycode_save:
+        {
+            msg_keymap_keycode_save *msg = (msg_keymap_keycode_save*)&data[1];
+            keymap_keycode_save( msg->layer, msg->row, msg->column, msg->keycode);
+            break;
+        }
+        case id_keymap_default_save:
+        {
+            keymap_default_save();
+            break;
+        }
+#endif // USE_KEYMAPS_IN_EEPROM
+        case id_backlight_config_set_values:
+        {
+            msg_backlight_config_set_values *msg = (msg_backlight_config_set_values*)&data[1];
+            backlight_config_set_values(msg);
+            backlight_config_save();
+            break;
+        }
+        case id_backlight_config_set_alphas_mods:
+        {
+            msg_backlight_config_set_alphas_mods *msg = (msg_backlight_config_set_alphas_mods*)&data[1];
+            backlight_config_set_alphas_mods( msg->alphas_mods );
+            backlight_config_save();
+            break;
+        }
+        case id_backlight_set_key_color:
+        {
+            msg_backlight_set_key_color *msg = (msg_backlight_set_key_color*)&data[1];
+            backlight_set_key_color(msg->row, msg->column, msg->hsv);
+            break;
+        }
+        case id_system_get_state:
+        {
+            msg_system_state *msg = (msg_system_state*)&data[1];
+            msg->value = backlight_get_tick();
+            break;
+        }
+        default:
+        {
+            // Unhandled message.
+            data[0] = id_unhandled;
+            break;
+        }
+    }
+
+    // Return same buffer with values changed
+    raw_hid_send( data, length );
+
+}
+
+#endif*/
+
+#ifdef HS60_ANSI
+
+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}, //MX1
+    {0, E_1,    D_1,    F_1}, //MX2
+    {0, H_1,    G_1,    I_1}, //MX3
+    {0, K_1,    J_1,    L_1}, //MX4
+    {0, B_2,    A_2,    C_2}, //MX6
+    {0, E_2,    D_2,    F_2}, //MX7
+    {0, H_2,    G_2,    I_2}, //MX8
+    {0, K_2,    J_2,    L_2}, //MX14
+    {0, B_3,    A_3,    C_3}, //MX11
+    {0, E_3,    D_3,    F_3}, //MX12
+    {0, H_3,    G_3,    I_3}, //MX13
+    {0, K_3,    J_3,    L_3}, //MX19
+    {0, B_4,    A_4,    C_4}, //MX16
+    {0, E_4,    D_4,    F_4}, //MX17
+    {0, H_4,    G_4,    I_4}, //MX18
+    {0, K_4,    J_4,    L_4}, //MX23
+    {0, B_5,    A_5,    C_5}, //MX20
+    {0, E_5,    D_5,    F_5}, //MX21
+    {0, H_5,    G_5,    I_5}, //MX22
+    {0, K_5,    J_5,    L_5}, //MX27
+    {0, B_6,    A_6,    C_6}, //MX24
+    {0, E_6,    D_6,    F_6}, //MX25
+    {0, H_6,    G_6,    I_6}, //MX26
+    {0, K_6,    J_6,    L_6}, //MX31
+    {0, B_7,    A_7,    C_7}, //MX28
+    {0, E_7,    D_7,    F_7}, //MX29
+    {0, H_7,    G_7,    I_7}, //MX30
+    {0, K_7,    J_7,    L_7}, //MX36
+    {0, B_8,    A_8,    C_8}, //MX33
+    {0, E_8,    D_8,    F_8}, //MX34
+    {0, H_8,    G_8,    I_8}, //MX35
+    {0, K_8,    J_8,    L_8}, //MX40
+    {0, B_9,    A_9,    C_9}, //MX37
+    {0, E_9,    D_9,    F_9}, //MX38
+    {0, H_9,    G_9,    I_9}, //MX39
+    {0, K_9,    J_9,    L_9}, //MX44
+    {0, B_10,   A_10,   C_10}, //MX41
+    {0, E_10,   D_10,   F_10}, //MX42
+    {0, H_10,   G_10,   I_10}, //MX43
+    {0, K_10,   J_10,   L_10}, //MX48
+    {0, B_11,   A_11,   C_11}, //MX45
+    {0, E_11,   D_11,   F_11}, //MX46
+    {0, H_11,   G_11,   I_11}, //MX47
+    {0, K_11,   J_11,   L_11}, //MX53
+    {0, B_12,   A_12,   C_12}, //MX50
+    {0, E_12,   D_12,   F_12}, //MX51
+    {0, H_12,   G_12,   I_12}, //MX52
+
+    {0, B_13,   A_13,   C_13}, //MX55
+    {0, E_13,   D_13,   F_13}, //MX56
+
+    {0, K_13,   J_13,   L_13}, //MX61
+    {0, B_14,   A_14,   C_14}, //MX59
+    {0, E_14,   D_14,   F_14}, //MX57
+    {0, H_14,   G_14,   I_14}, //MX60
+    {0, K_14,   J_14,   L_14}, //MX62
+    {0, B_15,   A_15,   C_15}, //MX5
+    {0, E_15,   D_15,   F_15}, //MX10
+    {0, H_15,   G_15,   I_15}, //MX15
+    {0, K_15,   J_15,   L_15}, //MX32
+
+    {0, E_16,   D_16,   F_16}, //MX49
+    {0, H_16,   G_16,   I_16}, //MX54
+    {0, K_16,   J_16,   L_16}, //MX58
+};
+
+const rgb_led g_rgb_leds[DRIVER_LED_TOTAL] = {
+//
+//  MX1,  MX6, MX11, MX16, MX20, MX24, MX28, MX33, MX37, MX41, MX45, MX50, MX55, MX59,
+//  MX2,  MX7, MX12, MX17, MX21, MX25, MX29, MX34, MX38, MX42, MX46, MX51, MX56,  ---,
+//  MX3,  MX8, MX13, MX18, MX22, MX26, MX30, MX35, MX39, MX43, MX47, MX52, MX57, MX60,
+//  MX4,  ---, MX14, MX19, MX23, MX27, MX31, MX36, MX40, MX44, MX48, MX53,  ---, MX61,
+//  MX5, MX10, MX15,  ---,  ---,  ---, MX32,  ---,  ---,  ---, MX49, MX54, MX58, MX62
+/* {row | col << 4}
+ *    |           {x=0..224, y=0..64}
+ *    |              |            modifier
+ *    |              |         | */
+    {{0|(0<<4)},    {  0,  0}, 1}, //MX1
+    {{1|(0<<4)},    {  0, 16}, 1}, //MX2
+    {{2|(0<<4)},    {  0, 32}, 1}, //MX3
+    {{3|(0<<4)},    {  0, 48}, 1}, //MX4
+    {{0|(1<<4)},    { 17,  0}, 0}, //MX6
+    {{1|(1<<4)},    { 17, 16}, 0}, //MX7
+    {{2|(1<<4)},    { 17, 32}, 0}, //MX8
+    {{3|(2<<4)},    { 34, 48}, 0}, //MX14
+    {{0|(2<<4)},    { 34,  0}, 0}, //MX11
+    {{1|(2<<4)},    { 34, 16}, 0}, //MX12
+    {{2|(2<<4)},    { 34, 32}, 0}, //MX13
+    {{3|(3<<4)},    { 51, 48}, 0}, //MX19
+    {{0|(3<<4)},    { 51,  0}, 0}, //MX16
+    {{1|(3<<4)},    { 51, 16}, 0}, //MX17
+    {{2|(3<<4)},    { 51, 32}, 0}, //MX18
+    {{3|(4<<4)},    { 68, 48}, 0}, //MX23
+    {{0|(4<<4)},    { 68,  0}, 0}, //MX20
+    {{1|(4<<4)},    { 68, 16}, 0}, //MX21
+    {{2|(4<<4)},    { 68, 32}, 0}, //MX22
+    {{3|(5<<4)},    { 85, 48}, 0}, //MX27
+    {{0|(5<<4)},    { 85,  0}, 0}, //MX24
+    {{1|(5<<4)},    { 85, 16}, 0}, //MX25
+    {{2|(5<<4)},    { 85, 32}, 0}, //MX26
+    {{3|(6<<4)},    {102, 48}, 0}, //MX31
+    {{0|(6<<4)},    {102,  0}, 0}, //MX28
+    {{1|(6<<4)},    {102, 16}, 0}, //MX29
+    {{2|(6<<4)},    {102, 32}, 0}, //MX30
+    {{3|(7<<4)},    {119, 48}, 0}, //MX36
+    {{0|(7<<4)},    {119,  0}, 0}, //MX33
+    {{1|(7<<4)},    {119, 16}, 0}, //MX34
+    {{2|(7<<4)},    {119, 32}, 0}, //MX35
+    {{3|(8<<4)},    {136, 48}, 0}, //MX40
+    {{0|(8<<4)},    {136,  0}, 0}, //MX37
+    {{1|(8<<4)},    {136, 16}, 0}, //MX38
+    {{2|(8<<4)},    {136, 32}, 0}, //MX39
+    {{3|(9<<4)},    {153, 48}, 0}, //MX44
+    {{0|(9<<4)},    {153,  0}, 0}, //MX41
+    {{1|(9<<4)},    {153, 16}, 0}, //MX42
+    {{2|(9<<4)},    {153, 32}, 0}, //MX43
+    {{3|(10<<4)},   {170, 48}, 0}, //MX48
+    {{0|(10<<4)},   {170,  0}, 0}, //MX45
+    {{1|(10<<4)},   {170, 16}, 0}, //MX46
+    {{2|(10<<4)},   {170, 32}, 0}, //MX47
+    {{3|(11<<4)},   {187, 48}, 0}, //MX53
+    {{0|(11<<4)},   {187,  0}, 0}, //MX50
+    {{1|(11<<4)},   {187, 16}, 0}, //MX51
+    {{2|(11<<4)},   {187, 32}, 0}, //MX52
+
+    {{0|(12<<4)},   {204,  0}, 0}, //MX55
+    {{1|(12<<4)},   {204, 16}, 0}, //MX56
+
+    {{3|(13<<4)},   {221, 48}, 1}, //MX61
+    {{0|(13<<4)},   {221,  0}, 1}, //MX59
+    {{2|(12<<4)},   {221, 16}, 0}, //MX57
+    {{2|(13<<4)},   {221, 32}, 1}, //MX60
+    {{4|(13<<4)},   {221, 64}, 1}, //MX62
+    {{4|(0<<4)},    {  0, 64}, 1}, //MX5
+    {{4|(1<<4)},    { 17, 64}, 1}, //MX10
+    {{4|(2<<4)},    { 34, 64}, 1}, //MX15
+    {{4|(5<<4)},    {102, 64}, 0}, //MX32
+
+    {{4|(10<<4)},   {170, 64}, 1}, //MX49
+    {{4|(11<<4)},   {187, 64}, 1}, //MX54
+    {{4|(12<<4)},    {204, 64}, 1}  //MX58
+};
+
+#elif defined(HS60_HHKB)
+
+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}, //MX1
+    {0, E_1,    D_1,    F_1}, //MX2
+    {0, H_1,    G_1,    I_1}, //MX3
+    {0, K_1,    J_1,    L_1}, //MX4
+    {0, B_2,    A_2,    C_2}, //MX6
+    {0, E_2,    D_2,    F_2}, //MX7
+    {0, H_2,    G_2,    I_2}, //MX8
+    {0, K_2,    J_2,    L_2}, //MX14
+    {0, B_3,    A_3,    C_3}, //MX11
+    {0, E_3,    D_3,    F_3}, //MX12
+    {0, H_3,    G_3,    I_3}, //MX13
+    {0, K_3,    J_3,    L_3}, //MX19
+    {0, B_4,    A_4,    C_4}, //MX16
+    {0, E_4,    D_4,    F_4}, //MX17
+    {0, H_4,    G_4,    I_4}, //MX18
+    {0, K_4,    J_4,    L_4}, //MX23
+    {0, B_5,    A_5,    C_5}, //MX20
+    {0, E_5,    D_5,    F_5}, //MX21
+    {0, H_5,    G_5,    I_5}, //MX22
+    {0, K_5,    J_5,    L_5}, //MX27
+    {0, B_6,    A_6,    C_6}, //MX24
+    {0, E_6,    D_6,    F_6}, //MX25
+    {0, H_6,    G_6,    I_6}, //MX26
+    {0, K_6,    J_6,    L_6}, //MX31
+    {0, B_7,    A_7,    C_7}, //MX28
+    {0, E_7,    D_7,    F_7}, //MX29
+    {0, H_7,    G_7,    I_7}, //MX30
+    {0, K_7,    J_7,    L_7}, //MX36
+    {0, B_8,    A_8,    C_8}, //MX33
+    {0, E_8,    D_8,    F_8}, //MX34
+    {0, H_8,    G_8,    I_8}, //MX35
+    {0, K_8,    J_8,    L_8}, //MX40
+    {0, B_9,    A_9,    C_9}, //MX37
+    {0, E_9,    D_9,    F_9}, //MX38
+    {0, H_9,    G_9,    I_9}, //MX39
+    {0, K_9,    J_9,    L_9}, //MX44
+    {0, B_10,   A_10,   C_10}, //MX41
+    {0, E_10,   D_10,   F_10}, //MX42
+    {0, H_10,   G_10,   I_10}, //MX43
+    {0, K_10,   J_10,   L_10}, //MX48
+    {0, B_11,   A_11,   C_11}, //MX45
+    {0, E_11,   D_11,   F_11}, //MX46
+    {0, H_11,   G_11,   I_11}, //MX47
+    {0, K_11,   J_11,   L_11}, //MX53
+    {0, B_12,   A_12,   C_12}, //MX50
+    {0, E_12,   D_12,   F_12}, //MX51
+    {0, H_12,   G_12,   I_12}, //MX52
+    {0, K_12,   J_12,   L_12}, //MX64
+    {0, B_13,   A_13,   C_13}, //MX55
+    {0, E_13,   D_13,   F_13}, //MX56
+    {0, H_13,   G_13,   I_13}, //MX63
+    {0, K_13,   J_13,   L_13}, //MX61
+    {0, B_14,   A_14,   C_14}, //MX59
+    {0, E_14,   D_14,   F_14}, //MX57
+    {0, H_14,   G_14,   I_14}, //MX60
+    {0, K_14,   J_14,   L_14}, //MX62
+    {0, B_15,   A_15,   C_15}, //MX5
+    {0, E_15,   D_15,   F_15}, //MX10
+    {0, H_15,   G_15,   I_15}, //MX15
+    {0, K_15,   J_15,   L_15}, //MX32
+
+
+    {0, H_16,   G_16,   I_16}, //MX54
+    {0, K_16,   J_16,   L_16}, //MX58
+};
+
+const rgb_led g_rgb_leds[DRIVER_LED_TOTAL] = {
+//
+//  MX1,  MX6, MX11, MX16, MX20, MX24, MX28, MX33, MX37, MX41, MX45, MX50, MX55, MX59,
+//  MX2,  MX7, MX12, MX17, MX21, MX25, MX29, MX34, MX38, MX42, MX46, MX51, MX56, MX64,
+//  MX3,  MX8, MX13, MX18, MX22, MX26, MX30, MX35, MX39, MX43, MX47, MX52, MX57, MX60,
+//  MX4, ----, MX14, MX19, MX23, MX27, MX31, MX36, MX40, MX44, MX48, MX53, MX63, MX61,
+//  MX5, MX10, MX15, ----, ----, ----, MX32, ----,  ---, ----, ----, MX54, MX58, MX62
+/* {row | col << 4}
+ *    |           {x=0..224, y=0..64}
+ *    |              |            modifier
+ *    |              |         | */
+    {{0|(0<<4)},    {  0,  0}, 1}, //MX1
+    {{1|(0<<4)},    {  0, 16}, 1}, //MX2
+    {{2|(0<<4)},    {  0, 32}, 1}, //MX3
+    {{3|(0<<4)},    {  0, 48}, 1}, //MX4
+    {{0|(1<<4)},    { 17,  0}, 0}, //MX6
+    {{1|(1<<4)},    { 17, 16}, 0}, //MX7
+    {{2|(1<<4)},    { 17, 32}, 0}, //MX8
+    {{3|(2<<4)},    { 34, 48}, 0}, //MX14
+    {{0|(2<<4)},    { 34,  0}, 0}, //MX11
+    {{1|(2<<4)},    { 34, 16}, 0}, //MX12
+    {{2|(2<<4)},    { 34, 32}, 0}, //MX13
+    {{3|(3<<4)},    { 51, 48}, 0}, //MX19
+    {{0|(3<<4)},    { 51,  0}, 0}, //MX16
+    {{1|(3<<4)},    { 51, 16}, 0}, //MX17
+    {{2|(3<<4)},    { 51, 32}, 0}, //MX18
+    {{3|(4<<4)},    { 68, 48}, 0}, //MX23
+    {{0|(4<<4)},    { 68,  0}, 0}, //MX20
+    {{1|(4<<4)},    { 68, 16}, 0}, //MX21
+    {{2|(4<<4)},    { 68, 32}, 0}, //MX22
+    {{3|(5<<4)},    { 85, 48}, 0}, //MX27
+    {{0|(5<<4)},    { 85,  0}, 0}, //MX24
+    {{1|(5<<4)},    { 85, 16}, 0}, //MX25
+    {{2|(5<<4)},    { 85, 32}, 0}, //MX26
+    {{3|(6<<4)},    {102, 48}, 0}, //MX31
+    {{0|(6<<4)},    {102,  0}, 0}, //MX28
+    {{1|(6<<4)},    {102, 16}, 0}, //MX29
+    {{2|(6<<4)},    {102, 32}, 0}, //MX30
+    {{3|(7<<4)},    {119, 48}, 0}, //MX36
+    {{0|(7<<4)},    {119,  0}, 0}, //MX33
+    {{1|(7<<4)},    {119, 16}, 0}, //MX34
+    {{2|(7<<4)},    {119, 32}, 0}, //MX35
+    {{3|(8<<4)},    {136, 48}, 0}, //MX40
+    {{0|(8<<4)},    {136,  0}, 0}, //MX37
+    {{1|(8<<4)},    {136, 16}, 0}, //MX38
+    {{2|(8<<4)},    {136, 32}, 0}, //MX39
+    {{3|(9<<4)},    {153, 48}, 0}, //MX44
+    {{0|(9<<4)},    {153,  0}, 0}, //MX41
+    {{1|(9<<4)},    {153, 16}, 0}, //MX42
+    {{2|(9<<4)},    {153, 32}, 0}, //MX43
+    {{3|(10<<4)},   {170, 48}, 0}, //MX48
+    {{0|(10<<4)},   {170,  0}, 0}, //MX45
+    {{1|(10<<4)},   {170, 16}, 0}, //MX46
+    {{2|(10<<4)},   {170, 32}, 0}, //MX47
+    {{3|(11<<4)},   {187, 48}, 0}, //MX53
+    {{0|(11<<4)},   {187,  0}, 0}, //MX50
+    {{1|(11<<4)},   {187, 16}, 0}, //MX51
+    {{2|(11<<4)},   {187, 32}, 0}, //MX52
+    {{1|(13<<4)},   {221,  0}, 1}, //MX64
+    {{0|(12<<4)},   {204,  0}, 0}, //MX55
+    {{1|(12<<4)},   {204, 16}, 0}, //MX56
+    {{3|(12<<4)},   {204, 48}, 0}, //MX63
+    {{3|(13<<4)},   {212, 48}, 1}, //MX61
+    {{0|(13<<4)},   {221,  0}, 0}, //MX59
+    {{2|(12<<4)},   {221, 16}, 0}, //MX57
+    {{2|(13<<4)},   {221, 32}, 1}, //MX60
+    {{4|(13<<4)},   {221, 64}, 1}, //MX62
+    {{4|(0<<4)},    {  0, 64}, 1}, //MX5
+    {{4|(1<<4)},    { 17, 64}, 1}, //MX10
+    {{4|(2<<4)},    { 34, 64}, 1}, //MX15
+    {{4|(5<<4)},    {102, 64}, 0}, //MX32
+
+
+    {{4|(11<<4)},   {187, 64}, 1}, //MX54
+    {{4|(12<<4)},    {204, 64}, 1}  //MX58
+};
+
+#else //ISO layout
+
+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}, //MX1
+    {0, E_1,    D_1,    F_1}, //MX2
+    {0, H_1,    G_1,    I_1}, //MX3
+    {0, K_1,    J_1,    L_1}, //MX4
+    {0, B_2,    A_2,    C_2}, //MX6
+    {0, E_2,    D_2,    F_2}, //MX7
+    {0, H_2,    G_2,    I_2}, //MX8
+    {0, K_2,    J_2,    L_2}, //MX14
+    {0, B_3,    A_3,    C_3}, //MX11
+    {0, E_3,    D_3,    F_3}, //MX12
+    {0, H_3,    G_3,    I_3}, //MX13
+    {0, K_3,    J_3,    L_3}, //MX19
+    {0, B_4,    A_4,    C_4}, //MX16
+    {0, E_4,    D_4,    F_4}, //MX17
+    {0, H_4,    G_4,    I_4}, //MX18
+    {0, K_4,    J_4,    L_4}, //MX23
+    {0, B_5,    A_5,    C_5}, //MX20
+    {0, E_5,    D_5,    F_5}, //MX21
+    {0, H_5,    G_5,    I_5}, //MX22
+    {0, K_5,    J_5,    L_5}, //MX27
+    {0, B_6,    A_6,    C_6}, //MX24
+    {0, E_6,    D_6,    F_6}, //MX25
+    {0, H_6,    G_6,    I_6}, //MX26
+    {0, K_6,    J_6,    L_6}, //MX31
+    {0, B_7,    A_7,    C_7}, //MX28
+    {0, E_7,    D_7,    F_7}, //MX29
+    {0, H_7,    G_7,    I_7}, //MX30
+    {0, K_7,    J_7,    L_7}, //MX36
+    {0, B_8,    A_8,    C_8}, //MX33
+    {0, E_8,    D_8,    F_8}, //MX34
+    {0, H_8,    G_8,    I_8}, //MX35
+    {0, K_8,    J_8,    L_8}, //MX40
+    {0, B_9,    A_9,    C_9}, //MX37
+    {0, E_9,    D_9,    F_9}, //MX38
+    {0, H_9,    G_9,    I_9}, //MX39
+    {0, K_9,    J_9,    L_9}, //MX44
+    {0, B_10,   A_10,   C_10}, //MX41
+    {0, E_10,   D_10,   F_10}, //MX42
+    {0, H_10,   G_10,   I_10}, //MX43
+    {0, K_10,   J_10,   L_10}, //MX48
+    {0, B_11,   A_11,   C_11}, //MX45
+    {0, E_11,   D_11,   F_11}, //MX46
+    {0, H_11,   G_11,   I_11}, //MX47
+    {0, K_11,   J_11,   L_11}, //MX53
+    {0, B_12,   A_12,   C_12}, //MX50
+    {0, E_12,   D_12,   F_12}, //MX51
+    {0, H_12,   G_12,   I_12}, //MX52
+    {0, K_12,   J_12,   L_12}, //MX9
+    {0, B_13,   A_13,   C_13}, //MX55
+    {0, E_13,   D_13,   F_13}, //MX56
+
+    {0, K_13,   J_13,   L_13}, //MX61
+    {0, B_14,   A_14,   C_14}, //MX59
+    {0, E_14,   D_14,   F_14}, //MX57
+    {0, H_14,   G_14,   I_14}, //MX60
+    {0, K_14,   J_14,   L_14}, //MX62
+    {0, B_15,   A_15,   C_15}, //MX5
+    {0, E_15,   D_15,   F_15}, //MX10
+    {0, H_15,   G_15,   I_15}, //MX15
+    {0, K_15,   J_15,   L_15}, //MX32
+
+    {0, E_16,   D_16,   F_16}, //MX49
+    {0, H_16,   G_16,   I_16}, //MX54
+    {0, K_16,   J_16,   L_16}, //MX58
+};
+
+const rgb_led g_rgb_leds[DRIVER_LED_TOTAL] = {
+//
+//  MX1,  MX6, MX11, MX16, MX20, MX24, MX28, MX33, MX37, MX41, MX45, MX50, MX55, MX59,
+//  MX2,  MX7, MX12, MX17, MX21, MX25, MX29, MX34, MX38, MX42, MX46, MX51, MX56,  ---,
+//  MX3,  MX8, MX13, MX18, MX22, MX26, MX30, MX35, MX39, MX43, MX47, MX52, MX57, MX60,
+//  MX4,  ---, MX14, MX19, MX23, MX27, MX31, MX36, MX40, MX44, MX48, MX53,  ---, MX61,
+//  MX5, MX10, MX15,  ---,  ---,  ---, MX32,  ---,  ---,  ---, MX49, MX54, MX58, MX62
+/* {row | col << 4}
+ *    |           {x=0..224, y=0..64}
+ *    |              |            modifier
+ *    |              |         | */
+    {{0|(0<<4)},    {  0,  0}, 1}, //MX1
+    {{1|(0<<4)},    {  0, 16}, 1}, //MX2
+    {{2|(0<<4)},    {  0, 32}, 1}, //MX3
+    {{3|(0<<4)},    {  0, 48}, 1}, //MX4
+    {{0|(1<<4)},    { 17,  0}, 0}, //MX6
+    {{1|(1<<4)},    { 17, 16}, 0}, //MX7
+    {{2|(1<<4)},    { 17, 32}, 0}, //MX8
+    {{3|(2<<4)},    { 34, 48}, 0}, //MX14
+    {{0|(2<<4)},    { 34,  0}, 0}, //MX11
+    {{1|(2<<4)},    { 34, 16}, 0}, //MX12
+    {{2|(2<<4)},    { 34, 32}, 0}, //MX13
+    {{3|(3<<4)},    { 51, 48}, 0}, //MX19
+    {{0|(3<<4)},    { 51,  0}, 0}, //MX16
+    {{1|(3<<4)},    { 51, 16}, 0}, //MX17
+    {{2|(3<<4)},    { 51, 32}, 0}, //MX18
+    {{3|(4<<4)},    { 68, 48}, 0}, //MX23
+    {{0|(4<<4)},    { 68,  0}, 0}, //MX20
+    {{1|(4<<4)},    { 68, 16}, 0}, //MX21
+    {{2|(4<<4)},    { 68, 32}, 0}, //MX22
+    {{3|(5<<4)},    { 85, 48}, 0}, //MX27
+    {{0|(5<<4)},    { 85,  0}, 0}, //MX24
+    {{1|(5<<4)},    { 85, 16}, 0}, //MX25
+    {{2|(5<<4)},    { 85, 32}, 0}, //MX26
+    {{3|(6<<4)},    {102, 48}, 0}, //MX31
+    {{0|(6<<4)},    {102,  0}, 0}, //MX28
+    {{1|(6<<4)},    {102, 16}, 0}, //MX29
+    {{2|(6<<4)},    {102, 32}, 0}, //MX30
+    {{3|(7<<4)},    {119, 48}, 0}, //MX36
+    {{0|(7<<4)},    {119,  0}, 0}, //MX33
+    {{1|(7<<4)},    {119, 16}, 0}, //MX34
+    {{2|(7<<4)},    {119, 32}, 0}, //MX35
+    {{3|(8<<4)},    {136, 48}, 0}, //MX40
+    {{0|(8<<4)},    {136,  0}, 0}, //MX37
+    {{1|(8<<4)},    {136, 16}, 0}, //MX38
+    {{2|(8<<4)},    {136, 32}, 0}, //MX39
+    {{3|(9<<4)},    {153, 48}, 0}, //MX44
+    {{0|(9<<4)},    {153,  0}, 0}, //MX41
+    {{1|(9<<4)},    {153, 16}, 0}, //MX42
+    {{2|(9<<4)},    {153, 32}, 0}, //MX43
+    {{3|(10<<4)},   {170, 48}, 0}, //MX48
+    {{0|(10<<4)},   {170,  0}, 0}, //MX45
+    {{1|(10<<4)},   {170, 16}, 0}, //MX46
+    {{2|(10<<4)},   {170, 32}, 0}, //MX47
+    {{3|(11<<4)},   {187, 48}, 0}, //MX53
+    {{0|(11<<4)},   {187,  0}, 0}, //MX50
+    {{1|(11<<4)},   {187, 16}, 0}, //MX51
+    {{2|(11<<4)},   {187, 32}, 0}, //MX52
+    {{3|(2<<4)},    { 17, 32}, 1}, //MX9
+    {{0|(12<<4)},   {204,  0}, 0}, //MX55
+    {{1|(12<<4)},   {204, 16}, 0}, //MX56
+
+    {{3|(13<<4)},   {221, 48}, 1}, //MX61
+    {{0|(13<<4)},   {221,  0}, 1}, //MX59
+    {{2|(12<<4)},   {204, 32}, 0}, //MX57
+    {{2|(13<<4)},   {221, 24}, 1}, //MX60
+    {{4|(13<<4)},   {221, 64}, 1}, //MX62
+    {{4|(0<<4)},    {  0, 64}, 1}, //MX5
+    {{4|(1<<4)},    { 17, 64}, 1}, //MX10
+    {{4|(2<<4)},    { 34, 64}, 1}, //MX15
+    {{4|(5<<4)},    {102, 64}, 0}, //MX32
+
+    {{4|(10<<4)},   {170, 64}, 1}, //MX49
+    {{4|(11<<4)},   {187, 64}, 1}, //MX54
+    {{4|(12<<4)},    {204, 64}, 1}  //MX58
+};
+
+#endif
+
+void bootmagic_lite(void)
+{
+    // The lite version of TMK's bootmagic made by Wilba.
+    // 100% less potential for accidentally making the
+    // keyboard do stupid things.
+
+    // We need multiple scans because debouncing can't be turned off.
+    matrix_scan();
+    wait_ms(10);
+    matrix_scan();
+
+    // If the Esc and space bar are held down on power up,
+    // reset the EEPROM valid state and jump to bootloader.
+    // Assumes Esc is at [0,0] and spacebar is at [4,6].
+    // This isn't very generalized, but we need something that doesn't
+    // rely on user's keymaps in firmware or EEPROM.
+    if ( ( matrix_get_row(0) & (1<<0) ) &&
+        ( matrix_get_row(4) & (1<<6) ) )
+    {
+        // Set the TMK/QMK EEPROM state as invalid.
+        eeconfig_disable();
+        //eeprom_set_valid(false);
+        // Jump to bootloader.
+        bootloader_jump();
+    }
+}
+
+void matrix_init_kb(void) {
+    // put your keyboard start-up code here
+    // runs once when the firmware starts up
+
+    bootmagic_lite();
+
+    // Please ignore this is for upcoming features
+    // If the EEPROM has the magic, the data is good.
+    // OK to load from EEPROM.
+    /*if (eeprom_is_valid())
+    {
+        backlight_config_load();
+
+        // TODO: do something to "turn on" keymaps in EEPROM?
+    }
+    else
+    {
+        // If the EEPROM has not been saved before, or is out of date,
+        // save the default values to the EEPROM. Default values
+        // come from construction of the zeal_backlight_config instance.
+        backlight_config_save();
+
+        // Clear the LED colors stored in EEPROM
+        for ( int row=0; row < MATRIX_ROWS; row++ )
+        {
+            HSV hsv;
+            for ( int column=0; column < MATRIX_COLS; column++ )
+            {
+                hsv.h = rand() & 0xFF;
+                hsv.s = rand() & 0x7F;
+                hsv.v = 255;
+                backlight_set_key_color( row, column, hsv );
+            }
+        }
+        #ifdef USE_KEYMAPS_IN_EEPROM
+        keymap_default_save();
+        #endif
+        // Save the magic number last, in case saving was interrupted
+        eeprom_set_valid(true);
+    }*/
+
+    matrix_init_user();
+}
+
+void matrix_scan_kb(void) {
+
+    matrix_scan_user();
+}
+
+bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
+
+    return process_record_user(keycode, record);
+}
+
+void led_set_kb(uint8_t usb_led) {
+    //backlight_set_indicator_state(usb_led);
+}

keyboards/hs60/v2/v2.h

@@ -0,0 +1,67 @@
+/* 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 HS60_H
+#define HS60_H
+
+#define XXX KC_NO
+
+#include "quantum.h"
+
+// This a shortcut to help you visually see your layout.
+
+#define LAYOUT_60_iso( \
+    K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, K0D, \
+    K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C,      \
+    K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, K2C, K2D, \
+    K30, K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B,      K3D, \
+    K40, K41, K42,                K46,                K4A, K4B, K4C, K4D  \
+) { \
+    { K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, K0D }, \
+    { K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, XXX }, \
+    { K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, K2C, K2D }, \
+    { K30, K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, XXX, K3D }, \
+    { K40, K41, K42, XXX, XXX, XXX, K46, XXX, XXX, XXX, K4A, K4B, K4C, K4D }  \
+}
+
+#define LAYOUT_60_ansi( \
+    K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, K0D, \
+    K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, K2C, \
+    K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B,      K2D, \
+    K30,      K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B,      K3D, \
+    K40, K41, K42,                K46,                K4A, K4B, K4C, K4D  \
+) { \
+    { K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, K0D }, \
+    { K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, XXX }, \
+    { K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, K2C, K2D }, \
+    { K30, XXX, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, XXX, K3D }, \
+    { K40, K41, K42, XXX, XXX, XXX, K46, XXX, XXX, XXX, K4A, K4B, K4C, K4D }  \
+}
+
+#define LAYOUT_60_hhkb( \
+    K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, K0D, K1D, \
+    K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, K2C,      \
+    K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B,      K2D,      \
+    K30, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3C,      K3D,      \
+    K40, K41, K42,                K46,                     K4B, K4C, K4D       \
+) { \
+    { K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, K0D }, \
+    { K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, K1D }, \
+    { K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, K2C, K2D }, \
+    { K30, XXX, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3C, K3D }, \
+    { K40, K41, K42, XXX, XXX, XXX, K46, XXX, XXX, XXX, XXX, K4B, K4C, K4D }  \
+}
+
+#endif

keyboards/jd45/jd45.h

@@ -6,15 +6,27 @@
 /* JD45 keymap definition macro
  */
 #define LAYOUT( \
-    K01, K02, K03, K04, K05, K06, K07, K08, K09, K10, K11, K12, K13, \
-	K14, K15, K16, K17, K18, K19, K20, K21, K22, K23, K24, K25, \
-	K26, K27, K28, K29, K30, K31, K32, K33, K34, K35, K36, K37, \
-	K38, K39, K40, K41, K42, K43, K44, K45, K46, K47 \
+    k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k0a, k0b, k0c, \
+    k10,  k11, k12, k13, k14, k15, k16, k17, k18, k19, k1a,     k1b, \
+    k20,    k21, k22, k23, k24, k25, k26, k27, k28, k29, k2a,   k2b, \
+    k30, k31, k32, k33,      k34,     k36,       k38, k39, k3a, k3b  \
 ) { \
-    { KC_##K01, KC_##K02, KC_##K03, KC_##K04, KC_##K05, KC_##K06, KC_##K07, KC_##K08, KC_##K09, KC_##K10, KC_##K11, KC_##K12, KC_##K13 }, \
-    { KC_##K14, KC_##K15, KC_##K16, KC_##K17, KC_##K18, KC_##K19, KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_NO    }, \
-    { KC_##K26, KC_##K27, KC_##K28, KC_##K29, KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_##K37, KC_NO    }, \
-    { KC_##K38, KC_##K39, KC_##K40, KC_##K41, KC_##K42, KC_NO,    KC_##K43, KC_NO,    KC_##K44, KC_##K45, KC_##K46, KC_##K47, KC_NO    }  \
+    { k00,   k01,   k02,   k03,   k04,   k05,   k06,   k07,   k08,   k09,   k0a,   k0b,   k0c   }, \
+    { k10,   k11,   k12,   k13,   k14,   k15,   k16,   k17,   k18,   k19,   k1a,   k1b,   KC_NO }, \
+    { k20,   k21,   k22,   k23,   k24,   k25,   k26,   k27,   k28,   k29,   k2a,   k2b,   KC_NO }, \
+    { k30,   k31,   k32,   k33,   k34,   KC_NO, k36,   KC_NO, k38,   k39,   k3a,   k3b,   KC_NO }  \
+}
+
+#define LAYOUT_kc( \
+    k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k0a, k0b, k0c, \
+    k10,  k11, k12, k13, k14, k15, k16, k17, k18, k19, k1a,     k1b, \
+    k20,    k21, k22, k23, k24, k25, k26, k27, k28, k29, k2a,   k2b, \
+    k30, k31, k32, k33,      k34,     k36,       k38, k39, k3a, k3b  \
+) { \
+    { KC_##k00,   KC_##k01,   KC_##k02,   KC_##k03,   KC_##k04,   KC_##k05,   KC_##k06,   KC_##k07,   KC_##k08,   KC_##k09,   KC_##k0a,   KC_##k0b,   KC_##k0c }, \
+    { KC_##k10,   KC_##k11,   KC_##k12,   KC_##k13,   KC_##k14,   KC_##k15,   KC_##k16,   KC_##k17,   KC_##k18,   KC_##k19,   KC_##k1a,   KC_##k1b,   KC_NO    }, \
+    { KC_##k20,   KC_##k21,   KC_##k22,   KC_##k23,   KC_##k24,   KC_##k25,   KC_##k26,   KC_##k27,   KC_##k28,   KC_##k29,   KC_##k2a,   KC_##k2b,   KC_NO    }, \
+    { KC_##k30,   KC_##k31,   KC_##k32,   KC_##k33,   KC_##k34,   KC_NO,      KC_##k36,   KC_NO,      KC_##k38,   KC_##k39,   KC_##k3a,   KC_##k3b,   KC_NO    }  \
 }
 
 #endif

keyboards/jd45/keymaps/blakedietz/config.h

@@ -1,19 +1,4 @@
-#include "../../config.h"
-
-/**
- *JD45 keymap definition macro
- */
-#define LAYOUT_JD45( \
-    K01, K02, K03, K04, K05, K06, K07, K08, K09, K10, K11, K12, K13, \
-    K14, K15, K16, K17, K18, K19, K20, K21, K22, K23, K24, K25, \
-    K26, K27, K28, K29, K30, K31, K32, K33, K34, K35, K36, K37, \
-    K38, K39, K40, K41, K42, K43, K44, K45, K46, K47 \
-) { \
-    { K01,   K02,   K03,   K04,   K05,   K06,   K07,   K08,   K09,   K10,   K11,   K12,   K13   }, \
-    { K14,   K15,   K16,   K17,   K18,   K19,   K20,   K21,   K22,   K23,   K24,   K25,   KC_NO }, \
-    { K26,   K27,   K28,   K29,   K30,   K31,   K32,   K33,   K34,   K35,   K36,   K37,   KC_NO }, \
-    { K38,   K39,   K40,   K41,   K42, KC_NO,   K43, KC_NO,   K44,   K45,   K46,   K47,   KC_NO }  \
-}
+#pragma once
 
 /**
  * This makes it possible to do rolling combos (zx) with keys that convert to other keys on hold (z becomes ctrl when
@@ -28,4 +13,4 @@
 #define MOUSEKEY_DELAY          0
 #define MOUSEKEY_TIME_TO_MAX    5
 #define MOUSEKEY_MAX_SPEED      2
-#define MOUSEKEY_WHEEL_DELAY    0
+#define MOUSEKEY_WHEEL_DELAY    0

keyboards/jd45/keymaps/blakedietz/keymap.c

@@ -45,10 +45,6 @@ enum macro_keycodes
     KC_AG_TAB_R,
 };
 
-// Fillers to make layering more clear
-#define _______ KC_TRNS
-#define XXXXXXX KC_NO
-
 /**
  * This section of macros is for tap or hold functionality. Keys will fire off the second symbol in the name if tapped
  * or fire the first symbol in the name if held. For example
@@ -101,7 +97,7 @@ enum macro_keycodes
  *  `-------+-------+-------+-------+---^^^----+---^^^----+---------+--------+--------+----------'
  */
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-    [_QWERTY] = LAYOUT_JD45(
+    [_QWERTY] = LAYOUT(
         /*,--------+-------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------.*/
         KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC, ALL_T(KC_NO),
         /*|--------`-------`--------`--------`--------`--------`--------`--------`--------`--------`--------`--------`--------|*/
@@ -124,7 +120,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  * |        |       |       |       |          |          |         |  Prev  |  Next  |   Mute   |
  *  `-------+-------+-------+-------+---^^^----+---^^^----+---------+--------+--------+----------'
  */
-    [_LOWER] = LAYOUT_JD45(
+    [_LOWER] = LAYOUT(
         /*,--------+-------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------.*/
         KC_GRV, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_BSPC, KC_BSPC,
         /*|--------`-------`--------`--------`--------`--------`--------`--------`--------`--------`--------`--------`--------|*/
@@ -146,7 +142,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  * |        |       |       |       |          |          |         |  Prev  |  Next  |   Mute   |
  *  `-------+-------+-------+-------+---^^^----+---^^^----+---------+--------+--------+----------'
  */
-    [_RAISE] = LAYOUT_JD45(
+    [_RAISE] = LAYOUT(
         /*,--------+-------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------.*/
         KC_TILD, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_BSPC, KC_BSPC,
         /*|--------`-------`--------`--------`--------`--------`--------`--------`--------`--------`--------`--------`--------|*/
@@ -169,7 +165,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  *  `-------+-------+-------+-------+---^^^----+---^^^----+---------+--------+--------+----------'
  */
 
-    [_MOUSECURSOR] = LAYOUT_JD45(
+    [_MOUSECURSOR] = LAYOUT(
         /*,--------+-------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------.*/
         _______, _______, _______, KC_MS_U, _______, _______, _______, KC_ACL2, KC_ACL1, KC_ACL0, _______, _______, _______,
         /*|--------`-------`--------`--------`--------`--------`--------`--------`--------`--------`--------`--------`--------|*/
@@ -191,7 +187,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  * |        |       |       |       |          |          |         |        |        |  Reset   |
  *  `-------+-------+-------+-------+---^^^----+---^^^----+---------+--------+--------+----------'
  */
-    [_ADJUST] = LAYOUT_JD45(
+    [_ADJUST] = LAYOUT(
 
         /*,--------+-------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------.*/
         _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_DEL,
@@ -214,7 +210,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  * |        |       |       |       |          |          |         |        |        |          |
  *  `-------+-------+-------+-------+---^^^----+---^^^----+---------+--------+--------+----------'
  */
-    [_VIM] = LAYOUT_JD45(
+    [_VIM] = LAYOUT(
         /*,--------+-------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------.*/
         _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
         /*|--------`-------`--------`--------`--------`--------`--------`--------`--------`--------`--------`--------`--------|*/
@@ -236,7 +232,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  * |        |       |       |       |          |          |         |        |        |          |
  *  `-------+-------+-------+-------+---^^^----+---^^^----+---------+--------+--------+----------'
  */
-    [_MEDIA] = LAYOUT_JD45(
+    [_MEDIA] = LAYOUT(
         /*,--------+-------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------.*/
         _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
         /*|--------`-------`--------`--------`--------`--------`--------`--------`--------`--------`--------`--------`--------|*/

keyboards/jd45/keymaps/default/keymap.c

@@ -5,13 +5,10 @@
  */
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-    [0] = LAYOUT(
-        ESC, Q, W, E, R, T, Y, U, I, O, P, QUOT, BSPC,
-        TAB, A, S, D, F, G, H, J, K, L, SCLN, ENT,
-        LSFT, Z, X, C, V, B, N, M, COMM, DOT, SLSH, RSFT,
-        PAUSE, LCTL, LALT, DEL, SPC, DEL, LEFT, UP, DOWN, RIGHT),
-};
-
-const uint16_t PROGMEM fn_actions[] = {
-
+  [0] = LAYOUT(
+    KC_ESC,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_QUOT, KC_BSPC,
+    KC_TAB,  KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN,          KC_ENT,
+    KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH,          KC_RSFT,
+    KC_PAUS, KC_LCTL, KC_LALT, KC_DEL,           KC_SPC,           KC_DEL,           KC_LEFT, KC_UP,   KC_DOWN, KC_RGHT
+  ),
 };

keyboards/jd45/keymaps/jeebak/config.h

@@ -1,16 +0,0 @@
-#include "../../config.h"
-
-/**
- *JD45 keymap definition macro
- */
-#define LAYOUT_JD45( \
-    K01, K02, K03, K04, K05, K06, K07, K08, K09, K10, K11, K12, K13, \
-    K14, K15, K16, K17, K18, K19, K20, K21, K22, K23, K24, K25, \
-    K26, K27, K28, K29, K30, K31, K32, K33, K34, K35, K36, K37, \
-    K38, K39, K40, K41, K42, K43, K44, K45, K46, K47 \
-) { \
-    { K01,   K02,   K03,   K04,   K05,   K06,   K07,   K08,   K09,   K10,   K11,   K12,   K13   }, \
-    { K14,   K15,   K16,   K17,   K18,   K19,   K20,   K21,   K22,   K23,   K24,   K25,   KC_NO }, \
-    { K26,   K27,   K28,   K29,   K30,   K31,   K32,   K33,   K34,   K35,   K36,   K37,   KC_NO }, \
-    { K38,   K39,   K40,   K41,   K42, KC_NO,   K43, KC_NO,   K44,   K45,   K46,   K47,   KC_NO }  \
-}

keyboards/jd45/keymaps/jeebak/keymap.c

@@ -48,10 +48,6 @@ enum macro_keycodes
     KC_AG_TAB_R,
 };
 
-// Fillers to make layering more clear
-#define _______ KC_TRNS
-#define XXXXXXX KC_NO
-
 // Custom macros
 #define CTL_ESC CTL_T(KC_ESC)  // Tap for Esc, hold for Ctrl
 #define SFT_ENT SFT_T(KC_ENT)  // Tap for Enter, hold for Shift
@@ -91,7 +87,7 @@ enum macro_keycodes
  */
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-    [_QWERTY] = LAYOUT_JD45(
+    [_QWERTY] = LAYOUT(
         /*,--------+-------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------.*/
         HPR_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC, KC_BSPC,
         /*|--------`-------`--------`--------`--------`--------`--------`--------`--------`--------`--------`--------`--------|*/
@@ -113,7 +109,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  * |   RGUI |  Alt  |  GUI  | Lower | TC/Space | TC/Space |  Raise  |  Vol-  |  Vol+  |   Play   |
  *  `-------+-------+-------+-------+---^^^----+---^^^----+---------+--------+--------+----------'
  */
-    [_COLEMAK] = LAYOUT_JD45(
+    [_COLEMAK] = LAYOUT(
         /*,--------+-------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------.*/
         HPR_TAB, KC_Q, KC_W, KC_F, KC_P, KC_G, KC_J, KC_L, KC_U, KC_Y, KC_SCLN, KC_BSPC, KC_BSPC,
         /*|--------`-------`--------`--------`--------`--------`--------`--------`--------`--------`--------`--------`--------|*/
@@ -135,7 +131,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  * |   RGUI |  Alt  |  GUI  | Lower | TC/Space | TC/Space |  Raise  |  Vol-  |  Vol+  |   Play   |
  *  `-------+-------+-------+-------+---^^^----+---^^^----+---------+--------+--------+----------'
  */
-    [_DVORAK] = LAYOUT_JD45(
+    [_DVORAK] = LAYOUT(
         /*,--------+-------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------.*/
         HPR_TAB, KC_QUOT, KC_COMM, KC_DOT, KC_P, KC_Y, KC_F, KC_G, KC_C, KC_R, KC_L, KC_BSPC, KC_BSPC,
         /*|--------`-------`--------`--------`--------`--------`--------`--------`--------`--------`--------`--------`--------|*/
@@ -157,7 +153,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  * | Brite  |       |       |       |          |          |         |  Prev  |  Next  |   Mute   |
  *  `-------+-------+-------+-------+---^^^----+---^^^----+---------+--------+--------+----------'
  */
-    [_LOWER] = LAYOUT_JD45(
+    [_LOWER] = LAYOUT(
         /*,--------+-------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------.*/
         KC_TILD, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_BSPC, KC_BSPC,
         /*|--------`-------`--------`--------`--------`--------`--------`--------`--------`--------`--------`--------`--------|*/
@@ -179,7 +175,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  * | Brite  |       |       |       |          |          |         |  Prev  |  Next  |   Mute   |
  *  `-------+-------+-------+-------+---^^^----+---^^^----+---------+--------+--------+----------'
  */
-    [_RAISE] = LAYOUT_JD45(
+    [_RAISE] = LAYOUT(
         /*,--------+-------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------.*/
         KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_BSPC, KC_BSPC,
         /*|--------`-------`--------`--------`--------`--------`--------`--------`--------`--------`--------`--------`--------|*/
@@ -205,7 +201,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  * seem to work on Mac. Presumably they'll work under Windows.
  */
 
-    [_TOUCHCURSOR] = LAYOUT_JD45(
+    [_TOUCHCURSOR] = LAYOUT(
         /*,--------+-------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------.*/
         ALT_TAB, CMD_TAB, CTL_TAB, KC_LGUI, KC_LSFT, KC_TILD, KC_INS, KC_HOME, KC_UP, KC_END, KC_BSPC, _______, _______,
         /*|--------`-------`--------`--------`--------`--------`--------`--------`--------`--------`--------`--------`--------|*/
@@ -228,7 +224,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  *  `-------+-------+-------+-------+---^^^----+---^^^----+---------+--------+--------+----------'
  */
 
-    [_MOUSECURSOR] = LAYOUT_JD45(
+    [_MOUSECURSOR] = LAYOUT(
         /*,--------+-------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------.*/
         _______, _______, KC_ACL0, _______, _______, _______, _______, KC_WH_L, KC_MS_U, KC_WH_R, KC_BTN2, _______, _______,
         /*|--------`-------`--------`--------`--------`--------`--------`--------`--------`--------`--------`--------`--------|*/
@@ -251,7 +247,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  *  `-------+-------+-------+-------+---^^^----+---^^^----+---------+--------+--------+----------'
  */
 
-    [_PLOVER] = LAYOUT_JD45(
+    [_PLOVER] = LAYOUT(
         /*,--------+-------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------.*/
         KC_1, KC_1, KC_1, KC_1, KC_1, KC_1, KC_1, KC_1, KC_1, KC_1, KC_1, KC_1, KC_1,
         /*|--------`-------`--------`--------`--------`--------`--------`--------`--------`--------`--------`--------`--------|*/
@@ -273,7 +269,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  * |        |       |       |       |          |          |         |        |        |  Reset   |
  *  `-------+-------+-------+-------+---^^^----+---^^^----+---------+--------+--------+----------'
  */
-    [_ADJUST] = LAYOUT_JD45(
+    [_ADJUST] = LAYOUT(
         /*,--------+-------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------.*/
         _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_DEL,
         /*|--------`-------`--------`--------`--------`--------`--------`--------`--------`--------`--------`--------`--------|*/

keyboards/jd45/keymaps/justin/keymap.c

@@ -1,27 +1,27 @@
 #include QMK_KEYBOARD_H
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-    [0] = LAYOUT(
+    [0] = LAYOUT_kc(
         ESC, Q, W, F, P, G, J, L, U, Y, SCLN, QUOT, BSPC,
         FN8, A, R, S, T, D, H, N, E, I, O, ENT,
         LSFT, Z, X, C, V, B, K, M, COMM, DOT, SLSH, FN6,
         FN4, LGUI, FN7, FN2, FN1, SPC, FN5, RALT, FN3, FN0),
-    [1] = LAYOUT(
+    [1] = LAYOUT_kc(
         TRNS, FN10, FN11, FN12, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, UP, DEL,
         TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, HOME, PGUP, LEFT, RGHT,
         TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, END, PGDN, DOWN, TRNS,
         TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS),
-    [2] = LAYOUT(
+    [2] = LAYOUT_kc(
         TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, 7, 8, 9, 0, TRNS, TRNS,
         TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, LBRC, 4, 5, 6, DOT, TRNS,
         TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, RBRC, 1, 2, 3, BSLS, TRNS,
         TRNS, FN29, TRNS, TRNS, TRNS, PAUSE, EQL, MINS, TRNS, TRNS),
-    [3] = LAYOUT(
+    [3] = LAYOUT_kc(
         TRNS, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12,
         TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS,
         TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS,
         TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS),
-    [4] = LAYOUT(
+    [4] = LAYOUT_kc(
         TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, 7, 8, 9, 0, TRNS, TRNS,
         TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, LBRC, 4, 5, 6, DOT, TRNS,
         TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, RBRC, 1, 2, 3, BSLS, TRNS,

keyboards/jd45/keymaps/mjt/keymap.c

@@ -4,23 +4,23 @@
  */
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-    [0] = LAYOUT(
+    [0] = LAYOUT_kc(
         TAB, Q, W, E, R, T, Y, U, I, O, P, MINS, BSLS,
         FN1, A, S, D, F, G, H, J, K, L, QUOT, ENT,
         FN0, Z, X, C, V, B, N, M, COMM, DOT, SLSH, RSFT,
         NO, LCTL, LALT, LGUI, SPC, BSPC, APP, FN2, ESC, NO),
-    [1] = LAYOUT(
+    [1] = LAYOUT_kc(
         GRV, TRNS, UP, TRNS, 7, 8, 9, 0, MINS, EQL, PSCR, LBRC, RBRC,
         TRNS, LEFT, DOWN, RGHT, 4, 5, 6, INS, HOME, PGUP, SCLN, TRNS,
         TRNS, TRNS, TRNS, TRNS, 1, 2, 3, DEL, END, PGDN, TRNS, TRNS,
         TRNS, TRNS, TRNS, SPC, TRNS, DEL, TRNS, FN3, TRNS, TRNS),
-    [2] = LAYOUT(
+    [2] = LAYOUT_kc(
         TRNS, TRNS, VOLU, TRNS, F7, F8, F9, F10, F11, F12, PSCR, FN3, FN4,
         TRNS, MPRV, VOLD, MNXT, F4, F5, F6, J, K, L, SCLN, TRNS,
         TRNS, TRNS, TRNS, TRNS, F1, F2, F3, MUTE, MPRV, MNXT, MSTP, TRNS,
         TRNS, TRNS, TRNS, LGUI, TRNS, TRNS, TRNS, TRNS, PAUS, TRNS)
     /*  ,
-[3] = LAYOUT(
+[3] = LAYOUT_kc(
 TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS,
 TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS,
 TRNS, TRNS, TRNS, TRNS, TRNS, BTLD, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS,

keyboards/jd45/keymaps/mjt6u/config.h

@@ -1,84 +1,3 @@
-/*
-Copyright 2012 Jun Wako <wakojun@gmail.com>
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "config_common.h"
-
-/* USB Device descriptor parameter */
-#define VENDOR_ID       0xFEED
-#define PRODUCT_ID      0x6060
-#define DEVICE_VER      0x0001
-#define MANUFACTURER    geekhack
-#define PRODUCT         JD45
-#define DESCRIPTION     q.m.k. keyboard firmware for JD45
-
-/* key matrix size */
-#define MATRIX_ROWS 4
-#define MATRIX_COLS 13
-
-/* Planck PCB default pin-out */
-#define MATRIX_ROW_PINS { F0, F1, F5, B4 }
-#define MATRIX_COL_PINS { F4, D7, B5, B6, C6, C7, D4, D6, D5, D0, D1, D2, B0 }
-#define UNUSED_PINS
-
-#define BACKLIGHT_PIN B7
+#pragma once
 
 #define USB_MAX_POWER_CONSUMPTION 50
-
-/* COL2ROW or ROW2COL */
-#define DIODE_DIRECTION COL2ROW
-
-/* define if matrix has ghost */
-//#define MATRIX_HAS_GHOST
-
-/* number of backlight levels */
-#define BACKLIGHT_LEVELS 3
-
-/* 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
-
-/* key combination for command */
-#define IS_COMMAND() ( \
-    keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
-)
-
-/*
- * Feature disable options
- *  These options are also useful to firmware size reduction.
- */
-
-/* disable debug print */
-//#define NO_DEBUG
-
-/* disable print */
-//#define NO_PRINT
-
-/* disable action features */
-//#define NO_ACTION_LAYER
-//#define NO_ACTION_TAPPING
-//#define NO_ACTION_ONESHOT
-//#define NO_ACTION_MACRO
-//#define NO_ACTION_FUNCTION
-
-#endif

keyboards/jd45/keymaps/mjt6u/keymap.c

@@ -25,25 +25,61 @@ enum jd45_keycodes
 #define LONGPRESS_DELAY 150
 #define LAYER_TOGGLE_DELAY 900
 
-#define _______ KC_TRNS
 #define __MOD__ KC_TRNS
-#define XXXXXXX KC_NO
 #define F_FNSPC F(0)
 #define F_NUMSPC F(1)
 #define F_FNTAB F(2)
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-    [_QWERTY] = {
-        {F_FNTAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_MINS, KC_BSPC},
-        {CTL_T(KC_ESC), KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, LT(_ADJUST, KC_QUOT)},
-        {KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, SFT_T(KC_ENT)},
-        {XXXXXXX, KC_LALT, KC_LGUI, XXXXXXX, XXXXXXX, XXXXXXX, F_FNSPC, XXXXXXX, XXXXXXX, MO(_FUNCTION), MO(_ADJUST)}},
-    [_QWERTYNUMMODS] = {{F_FNTAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_MINS, KC_BSPC}, {CTL_T(KC_ESC), KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, LT(_ADJUST, KC_QUOT)}, {KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, SFT_T(KC_ENT)}, {XXXXXXX, KC_LALT, KC_LGUI, XXXXXXX, XXXXXXX, XXXXXXX, F_NUMSPC, XXXXXXX, XXXXXXX, MO(_FKEYNUMPAD), MO(_ADJUST)}},
-    [_NUMSYM] = {{KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, _______, KC_DEL}, {__MOD__, _______, _______, _______, _______, _______, KC_LEFT, KC_DOWN, KC_UP, KC_RIGHT, _______, _______}, {_______, _______, _______, _______, _______, KC_SPC, KC_MINS, KC_EQL, KC_LBRC, KC_RBRC, KC_BSLS, _______}, {XXXXXXX, __MOD__, __MOD__, XXXXXXX, XXXXXXX, XXXXXXX, _______, XXXXXXX, XXXXXXX, __MOD__, __MOD__}},
-    [_FUNCTION] = {{__MOD__, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12}, {__MOD__, _______, _______, _______, _______, _______, KC_MPRV, KC_VOLD, KC_VOLU, KC_MNXT, _______, _______}, {_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______}, {XXXXXXX, __MOD__, __MOD__, XXXXXXX, XXXXXXX, XXXXXXX, _______, XXXXXXX, XXXXXXX, __MOD__, __MOD__}},
-    [_NUMPAD] = {{KC_GRV, _______, KC_UP, _______, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_PSCR, KC_LBRC, KC_RBRC}, {_______, KC_LEFT, KC_DOWN, KC_RGHT, KC_4, KC_5, KC_6, KC_INS, KC_HOME, KC_PGUP, _______, _______}, {_______, _______, _______, _______, KC_1, KC_2, KC_3, KC_DEL, KC_END, KC_PGDN, _______, _______}, {XXXXXXX, _______, _______, XXXXXXX, XXXXXXX, XXXXXXX, _______, XXXXXXX, XXXXXXX, __MOD__, __MOD__}},
-    [_FKEYNUMPAD] = {{_______, _______, KC_VOLU, _______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_PSCR, _______, _______}, {_______, KC_MPRV, KC_VOLD, KC_MNXT, KC_F4, KC_F5, KC_F6, KC_J, KC_K, KC_L, KC_SCLN, _______}, {_______, _______, _______, _______, KC_F1, KC_F2, KC_F3, KC_MUTE, KC_MPRV, KC_MNXT, KC_MSTP, _______}, {XXXXXXX, _______, _______, XXXXXXX, XXXXXXX, XXXXXXX, _______, XXXXXXX, XXXXXXX, __MOD__, __MOD__}},
-    [_ADJUST] = {{_______, RESET, _______, _______, _______, _______, _______, DYN_REC_START1, DYN_REC_START2, _______, KC_PSCR, _______, _______}, {_______, _______, _______, _______, USEFNMODS, _______, _______, DYN_MACRO_PLAY1, DYN_MACRO_PLAY2, MACSLEEP, _______, _______}, {_______, _______, _______, _______, _______, _______, USENUMMODS, _______, _______, _______, _______, _______}, {XXXXXXX, _______, _______, XXXXXXX, XXXXXXX, XXXXXXX, _______, XXXXXXX, XXXXXXX, __MOD__, __MOD__}}};
+  [_QWERTY] = LAYOUT( \
+    F_FNTAB,       KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,          KC_MINS,     KC_BSPC,              \
+    CTL_T(KC_ESC), KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN,                    LT(_ADJUST, KC_QUOT), \
+    KC_LSFT,       KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH,                    SFT_T(KC_ENT),        \
+    XXXXXXX,       KC_LALT, KC_LGUI, XXXXXXX,          XXXXXXX,          F_FNSPC,          XXXXXXX, MO(_FUNCTION), MO(_ADJUST), XXXXXXX               \
+  ),
+
+  [_QWERTYNUMMODS] = LAYOUT( \
+    F_FNTAB,       KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,     KC_I,    KC_O,    KC_P,            KC_MINS,     KC_BSPC,              \
+    CTL_T(KC_ESC), KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,     KC_K,    KC_L,    KC_SCLN,                      LT(_ADJUST, KC_QUOT), \
+    KC_LSFT,       KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,     KC_COMM, KC_DOT,  KC_SLSH,                      SFT_T(KC_ENT),        \
+    XXXXXXX,       KC_LALT, KC_LGUI, XXXXXXX,          XXXXXXX,          F_NUMSPC,          XXXXXXX, MO(_FKEYNUMPAD), MO(_ADJUST), XXXXXXX               \
+  ),
+
+  [_NUMSYM] = LAYOUT( \
+    KC_GRV,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    _______, KC_DEL,  \
+    __MOD__, _______, _______, _______, _______, _______, KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT, _______,          _______, \
+    _______, _______, _______, _______, _______, KC_SPC,  KC_MINS, KC_EQL,  KC_LBRC, KC_RBRC, KC_BSLS,          _______, \
+    XXXXXXX, __MOD__, __MOD__, XXXXXXX,          XXXXXXX,          _______,          XXXXXXX, __MOD__, __MOD__, XXXXXXX  \
+  ),
+
+  [_FUNCTION] = LAYOUT( \
+    __MOD__, KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,  \
+    __MOD__, _______, _______, _______, _______, _______, KC_MPRV, KC_VOLD, KC_VOLU, KC_MNXT, _______,          _______, \
+    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,          _______, \
+    XXXXXXX, __MOD__, __MOD__, XXXXXXX,          XXXXXXX,          _______,          XXXXXXX, __MOD__, __MOD__, XXXXXXX  \
+  ),
+
+  [_NUMPAD] = LAYOUT( \
+    KC_GRV,  _______, KC_UP,   _______, KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_PSCR, KC_LBRC, KC_RBRC, \
+    _______, KC_LEFT, KC_DOWN, KC_RGHT, KC_4,    KC_5,    KC_6,    KC_INS,  KC_HOME, KC_PGUP, _______,          _______, \
+    _______, _______, _______, _______, KC_1,    KC_2,    KC_3,    KC_DEL,  KC_END,  KC_PGDN, _______,          _______, \
+    XXXXXXX, _______, _______, XXXXXXX,          XXXXXXX,          _______,          XXXXXXX, __MOD__, __MOD__, XXXXXXX  \
+  ),
+
+  [_FKEYNUMPAD] = LAYOUT( \
+    _______, _______, KC_VOLU, _______, KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,  KC_PSCR, _______, _______, \
+    _______, KC_MPRV, KC_VOLD, KC_MNXT, KC_F4,   KC_F5,   KC_F6,   KC_J,    KC_K,    KC_L,    KC_SCLN,          _______, \
+    _______, _______, _______, _______, KC_F1,   KC_F2,   KC_F3,   KC_MUTE, KC_MPRV, KC_MNXT, KC_MSTP,          _______, \
+    XXXXXXX, _______, _______, XXXXXXX,          XXXXXXX,          _______,          XXXXXXX, __MOD__, __MOD__, XXXXXXX  \
+  ),
+
+  [_ADJUST] = LAYOUT( \
+    _______, RESET,   _______, _______, _______,   _______, _______,    DYN_REC_START1,  DYN_REC_START2,  _______,  KC_PSCR, _______, _______, \
+    _______, _______, _______, _______, USEFNMODS, _______, _______,    DYN_MACRO_PLAY1, DYN_MACRO_PLAY2, MACSLEEP, _______,          _______, \
+    _______, _______, _______, _______, _______,   _______, USENUMMODS, _______,         _______,         _______,  _______,          _______, \
+    XXXXXXX, _______, _______, XXXXXXX,            XXXXXXX,             _______,                          XXXXXXX, __MOD__,  __MOD__, XXXXXXX  \
+  )
+};
 
 const uint16_t PROGMEM fn_actions[] = {
     [0] = ACTION_LAYER_TAP_KEY(_NUMSYM, KC_SPC),

keyboards/jd45/readme.md

@@ -11,4 +11,4 @@ Make example for this keyboard (after setting up your build environment):
 
     make jd45: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/mechmini/v2/keymaps/lbibass_625_space/config.h

@@ -0,0 +1,4 @@
+#pragma once
+
+#define ONESHOT_TAP_TOGGLE  3
+#define TAPPING_TERM 200

keyboards/mechmini/v2/keymaps/lbibass_625_space/keymap.c

@@ -0,0 +1,48 @@
+#include QMK_KEYBOARD_H
+
+#define _BL 0
+#define _FN1 2
+#define _FN2 3
+#define _WIN 1
+//Tap Dance Declarations
+enum
+{
+  TD_DOTCOM = 0
+};
+//Tap Dance Definitions
+qk_tap_dance_action_t tap_dance_actions[] = {
+    //Tap once for Esc, twice for Caps Lock
+    [TD_DOTCOM] = ACTION_TAP_DANCE_DOUBLE(KC_COMMA, KC_DOT)
+    // Other declarations would go here, separated by commas, if you have them
+};
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+    [_BL] = LAYOUT_625_space(
+        LT(OSL(2), KC_TAB), KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC,
+        GUI_T(KC_ESC), KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, LT(3, KC_ENT),
+        KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, TD(TD_DOTCOM), OSL(2), OSM(MOD_RSFT),
+        KC_ESC, KC_LALT, KC_LCTL, KC_SPC, KC_RGUI, RGB_TOG),
+    [_WIN] = LAYOUT_625_space(
+        LT(OSL(2), KC_TAB), KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC,
+        CTL_T(KC_ESC), KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, LT(3, KC_ENT),
+        KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, TD(TD_DOTCOM), OSL(2), OSM(MOD_RSFT),
+        KC_ESC, KC_LGUI, KC_LALT, KC_SPC, KC_RALT, RGB_TOG),
+    [_FN1] = LAYOUT_625_space(
+        KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_BSPC,
+        GUI_T(KC_ESC), KC_PGUP, KC_VOLU, KC_DEL, KC_TRNS, KC_BSLS, KC_LBRC, KC_RBRC, KC_MINS, KC_EQL, KC_TRNS,
+        KC_LSFT, KC_PGDN, KC_VOLD, BL_STEP, BL_TOGG, KC_SCLN, KC_QUOT, KC_SLSH, KC_DOT, KC_TRNS, KC_TRNS,
+        KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
+
+    [_FN2] = LAYOUT_625_space(
+        KC_PWR, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, RESET,
+        MT(KC_LGUI, KC_ESC), KC_LEFT, KC_DOWN, KC_UP, KC_RIGHT, TG(1), KC_TRNS, KC_TRNS, KC_F11, KC_F12, KC_TRNS,
+        KC_TRNS, RGB_TOG, RGB_MOD, RGB_VAI, RGB_VAD, RGB_HUI, RGB_HUD, RGB_SAI, RGB_SAD, KC_TRNS, KC_TRNS,
+        KC_CAPS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
+
+};
+
+
+
+
+

keyboards/mechmini/v2/keymaps/lbibass_625_space/readme.md

@@ -0,0 +1,2 @@
+# /u/Lbibass's 6.25u spacebar Mechmini 2.0 Layout. 
+

keyboards/mechmini/v2/keymaps/lbibass_625_space/rules.mk

@@ -0,0 +1,11 @@
+BOOTMAGIC_ENABLE = yes	# Virtual DIP switch configuration(+1000)
+MOUSEKEY_ENABLE = no	# Mouse keys(+4700)
+EXTRAKEY_ENABLE = yes	# Audio control and System control(+450)
+CONSOLE_ENABLE = yes	# Console for debug(+400)
+COMMAND_ENABLE = no    # Commands for debug and configuration
+SLEEP_LED_ENABLE = yes  # 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 = yes  # Enable keyboard backlight functionality
+AUDIO_ENABLE = no
+RGBLIGHT_ENABLE = yes
+TAP_DANCE_ENABLE = yes

keyboards/mechmini/v2/keymaps/lbibass_split_space/config.h

@@ -0,0 +1,4 @@
+#pragma once
+
+#define ONESHOT_TAP_TOGGLE 3
+#define TAPPING_TERM 200

keyboards/mechmini/v2/keymaps/lbibass_split_space/keymap.c

@@ -0,0 +1,33 @@
+#include QMK_KEYBOARD_H
+
+#define _BL 0
+#define _FN1 2
+#define _FN2 3
+#define _WIN 1
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+    [_BL] = LAYOUT_split_space(
+        LT(2, KC_TAB), KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC,
+        GUI_T(KC_ESC), KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, LT(3, KC_ENT),
+        KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, MO(2), KC_RSHIFT,
+        KC_ESC, KC_LALT, KC_LCTL, KC_SPC, KC_SPC, KC_RGUI, KC_RALT, RGB_TOG),
+    [_WIN] = LAYOUT_split_space(
+        LT(2, KC_TAB), KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC,
+        CTL_T(KC_ESC), KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, LT(3, KC_ENT),
+        KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, MO(2), KC_RSHIFT,
+        KC_ESC, KC_LGUI, KC_LALT, KC_SPC, KC_SPC, KC_RALT, KC_LCTL, RGB_TOG),
+    [_FN1] = LAYOUT_split_space(
+        KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_DEL,
+        KC_TRNS, KC_PGUP, KC_VOLU, KC_TRNS, KC_TRNS, KC_BSLS, KC_LBRC, KC_RBRC, KC_MINS, KC_EQL, KC_TRNS,
+        KC_LSFT, KC_PGDN, KC_VOLD, KC_TRNS, KC_TRNS, KC_SCLN, KC_QUOT, KC_SLSH, KC_DOT, KC_RSHIFT, KC_HOME,
+        KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
+
+    [_FN2] = LAYOUT_split_space(
+        KC_PWR, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, RESET,
+        MT(KC_LGUI, KC_ESC), KC_LEFT, KC_DOWN, KC_UP, KC_RIGHT, TG(1), KC_TRNS, KC_TRNS, KC_F11, KC_F12, KC_TRNS,
+        KC_TRNS, RGB_TOG, RGB_MOD, RGB_VAI, RGB_VAD, RGB_HUI, RGB_HUD, RGB_SAI, RGB_SAD, KC_TRNS, KC_END,
+        KC_CAPS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
+
+};
+

keyboards/mechmini/v2/keymaps/lbibass_split_space/readme.md

@@ -0,0 +1,2 @@
+# /u/Lbibass's Split Space Mechmini 2.0 Layout
+

keyboards/mechmini/v2/keymaps/lbibass_split_space/rules.mk

@@ -0,0 +1,11 @@
+BOOTMAGIC_ENABLE = yes	# Virtual DIP switch configuration(+1000)
+MOUSEKEY_ENABLE = no	# Mouse keys(+4700)
+EXTRAKEY_ENABLE = yes	# Audio control and System control(+450)
+CONSOLE_ENABLE = yes	# Console for debug(+400)
+COMMAND_ENABLE = no    # Commands for debug and configuration
+SLEEP_LED_ENABLE = yes  # 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 = yes  # Enable keyboard backlight functionality
+AUDIO_ENABLE = no
+RGBLIGHT_ENABLE = yes
+TAP_DANCE_ENABLE = no

keyboards/panc60/panc60.c

@@ -14,8 +14,15 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 #include "panc60.h"
+#ifdef BACKLIGHT_ENABLE
+#include "backlight.h"
+#endif
+#ifdef RGBLIGHT_ENABLE
+#include "rgblight.h"
+#endif
 
 #include <avr/pgmspace.h>
+
 #include "action_layer.h"
 #include "i2c.h"
 #include "quantum.h"
@@ -23,3 +30,35 @@
 __attribute__ ((weak))
 void matrix_scan_user(void) {
 }
+
+#ifdef RGBLIGHT_ENABLE
+extern rgblight_config_t rgblight_config;
+
+void rgblight_set(void) {
+    if (!rgblight_config.enable) {
+        for (uint8_t i = 0; i < RGBLED_NUM; i++) {
+            led[i].r = 0;
+            led[i].g = 0;
+            led[i].b = 0;
+        }
+    }
+
+    i2c_init();
+    i2c_send(0xb0, (uint8_t*)led, 3 * RGBLED_NUM);
+}
+#endif
+
+void backlight_init_ports(void) {
+	DDRD |= (1<<0 | 1<<1 | 1<<4 | 1<<6);
+	PORTD &= ~(1<<0 | 1<<1 | 1<<4 | 1<<6);
+}
+
+void backlight_set(uint8_t level) {
+	if (level == 0) {
+		// Turn out the lights
+		PORTD &= ~(1<<0 | 1<<1 | 1<<4 | 1<<6);
+	} else {
+		// Turn on the lights
+		PORTD |= (1<<0 | 1<<1 | 1<<4 | 1<<6);
+	}
+}

keyboards/panc60/rules.mk

@@ -36,8 +36,8 @@ MOUSEKEY_ENABLE = yes
 EXTRAKEY_ENABLE = yes
 CONSOLE_ENABLE = yes
 COMMAND_ENABLE = yes
-BACKLIGHT_ENABLE = no
-RGBLIGHT_ENABLE = no
+BACKLIGHT_ENABLE = yes
+RGBLIGHT_ENABLE = yes
 RGBLIGHT_CUSTOM_DRIVER = yes
 
 OPT_DEFS = -DDEBUG_LEVEL=0

keyboards/planck/planck.h

@@ -3,6 +3,8 @@
 
 #include "quantum.h"
 
+#define encoder_update(clockwise) encoder_update_user(uint8_t index, clockwise)
+
 #ifdef __AVR__
 #define LAYOUT_planck_mit( \
 	k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k0a, k0b, \

keyboards/planck/rev6/config.h

@@ -43,6 +43,10 @@
  * #define UNUSED_PINS
  */
 
+#define NUMBER_OF_ENCODERS 1
+#define ENCODERS_PAD_A { B12 }
+#define ENCODERS_PAD_B { B13 }
+
 #define MUSIC_MAP
 #undef AUDIO_VOICES
 #undef C6_AUDIO

keyboards/planck/rev6/matrix.c

@@ -21,10 +21,6 @@ static matrix_row_t matrix_debouncing[MATRIX_COLS];
 static bool debouncing = false;
 static uint16_t debouncing_time = 0;
 
-static uint8_t encoder_state = 0;
-static int8_t encoder_value = 0;
-static int8_t encoder_LUT[] = { 0, -1, 1, 0, 1, 0, 0, -1, -1, 0, 0, 1, 0, 1, -1, 0 };
-
 static bool dip_switch[4] = {0, 0, 0, 0};
 
 __attribute__ ((weak))
@@ -53,12 +49,6 @@ void matrix_init(void) {
     palSetPadMode(GPIOA, 10, PAL_MODE_INPUT_PULLUP);
     palSetPadMode(GPIOB, 9,  PAL_MODE_INPUT_PULLUP);
 
-    // encoder setup
-    palSetPadMode(GPIOB, 12, PAL_MODE_INPUT_PULLUP);
-    palSetPadMode(GPIOB, 13, PAL_MODE_INPUT_PULLUP);
-
-    encoder_state = (palReadPad(GPIOB, 12) << 0) | (palReadPad(GPIOB, 13) << 1);
-
     // actual matrix setup
     palSetPadMode(GPIOB, 11, PAL_MODE_OUTPUT_PUSHPULL);
     palSetPadMode(GPIOB, 10, PAL_MODE_OUTPUT_PUSHPULL);
@@ -87,15 +77,8 @@ void matrix_init(void) {
 __attribute__ ((weak))
 void dip_update(uint8_t index, bool active) { }
 
-__attribute__ ((weak))
-void encoder_update(bool clockwise) { }
-
 bool last_dip_switch[4] = {0};
 
-#ifndef ENCODER_RESOLUTION
-  #define ENCODER_RESOLUTION 4
-#endif
-
 uint8_t matrix_scan(void) {
     // dip switch
     dip_switch[0] = !palReadPad(GPIOB, 14);
@@ -108,18 +91,6 @@ uint8_t matrix_scan(void) {
     }
     memcpy(last_dip_switch, dip_switch, sizeof(&dip_switch));
 
-    // encoder on B12 and B13
-    encoder_state <<= 2;
-    encoder_state |= (palReadPad(GPIOB, 12) << 0) | (palReadPad(GPIOB, 13) << 1);
-    encoder_value += encoder_LUT[encoder_state & 0xF];
-    if (encoder_value >= ENCODER_RESOLUTION) {
-        encoder_update(0);
-    }
-    if (encoder_value <= -ENCODER_RESOLUTION) { // direction is arbitrary here, but this clockwise
-        encoder_update(1);
-    }
-    encoder_value %= ENCODER_RESOLUTION;
-
     // actual matrix
     for (int col = 0; col < MATRIX_COLS; col++) {
         matrix_row_t data = 0;

keyboards/planck/rev6/rules.mk

@@ -54,3 +54,4 @@ CUSTOM_MATRIX = yes # Custom matrix file
 AUDIO_ENABLE = yes
 RGBLIGHT_ENABLE = no
 # SERIAL_LINK_ENABLE = yes
+ENCODER_ENABLE = yes

layouts/community/60_ansi/mechmerlin-ansi/keymap.c

@@ -20,7 +20,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, \
 	KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,  \
     KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,  \
-    KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_UP, \
+    KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, RSFT_T(KC_UP), \
     KC_TRNS, KC_TRNS, KC_TRNS,       KC_TRNS,                               KC_TRNS, KC_LEFT, KC_DOWN, KC_RIGHT)
 
  };

layouts/community/60_ansi_split_bs_rshift/mechmerlin-split/keymap.c

@@ -20,7 +20,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_NO, KC_TRNS, \
 	KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,  \
     KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,  \
-    KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_UP,   KC_TRNS, \
+    KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, RSFT_T(KC_UP),   KC_TRNS, \
     KC_TRNS, KC_TRNS, KC_TRNS,       KC_TRNS,                               KC_TRNS, KC_LEFT, KC_DOWN, KC_RIGHT)
 
  };

quantum/encoder.c

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2018 Jack Humbert <jack.humb@gmail.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "encoder.h"
+
+#ifndef ENCODER_RESOLUTION
+  #define ENCODER_RESOLUTION 4
+#endif
+
+#ifndef NUMBER_OF_ENCODERS
+  #error "Number of encoders not defined by NUMBER_OF_ENCODERS"
+#endif
+
+#if !defined(ENCODERS_PAD_A) || !defined(ENCODERS_PAD_B)
+  #error "No encoder pads defined by ENCODERS_PAD_A and ENCODERS_PAD_B"
+#endif
+
+static pin_t encoders_pad_a[NUMBER_OF_ENCODERS] = ENCODERS_PAD_A;
+static pin_t encoders_pad_b[NUMBER_OF_ENCODERS] = ENCODERS_PAD_B;
+
+static int8_t encoder_LUT[] = { 0, -1, 1, 0, 1, 0, 0, -1, -1, 0, 0, 1, 0, 1, -1, 0 };
+
+static uint8_t encoder_state[NUMBER_OF_ENCODERS] = {0};
+static int8_t encoder_value[NUMBER_OF_ENCODERS] = {0};
+
+__attribute__ ((weak))
+void encoder_update_user(int8_t index, bool clockwise) { }
+
+__attribute__ ((weak))
+void encoder_update_kb(int8_t index, bool clockwise) {
+  encoder_update_user(index, clockwise);
+}
+
+void encoder_init(void) {
+  for (int i = 0; i < NUMBER_OF_ENCODERS; i++) {
+    setPinInputHigh(encoders_pad_a[i]);
+    setPinInputHigh(encoders_pad_b[i]);
+
+    encoder_state[i] = (readPin(encoders_pad_a[i]) << 0) | (readPin(encoders_pad_b[i]) << 1);
+  }
+}
+
+void encoder_read(void) {
+  for (int i = 0; i < NUMBER_OF_ENCODERS; i++) {
+    encoder_state[i] <<= 2;
+    encoder_state[i] |= (readPin(encoders_pad_a[i]) << 0) | (readPin(encoders_pad_b[i]) << 1);
+    encoder_value[i] += encoder_LUT[encoder_state[i] & 0xF];
+    if (encoder_value[i] >= ENCODER_RESOLUTION) {
+        encoder_update_kb(i, COUNTRECLOCKWISE);
+    }
+    if (encoder_value[i] <= -ENCODER_RESOLUTION) { // direction is arbitrary here, but this clockwise
+        encoder_update_kb(i, CLOCKWISE);
+    }
+    encoder_value[i] %= ENCODER_RESOLUTION;
+  }
+}

quantum/encoder.h

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2018 Jack Humbert <jack.humb@gmail.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "quantum.h"
+
+#define COUNTRECLOCKWISE 0
+#define CLOCKWISE 1
+
+void encoder_init(void);
+void encoder_read(void);
+
+void encoder_update_kb(int8_t index, bool clockwise);
+void encoder_update_user(int8_t index, bool clockwise);

quantum/quantum.c

@@ -42,6 +42,11 @@ extern backlight_config_t backlight_config;
 #include "process_midi.h"
 #endif
 
+
+#ifdef ENCODER_ENABLE
+#include "encoder.h"
+#endif
+
 #ifdef AUDIO_ENABLE
   #ifndef GOODBYE_SONG
     #define GOODBYE_SONG SONG(GOODBYE_SOUND)
@@ -957,6 +962,9 @@ void matrix_init_quantum() {
   #ifdef RGB_MATRIX_ENABLE
     rgb_matrix_init();
   #endif
+  #ifdef ENCODER_ENABLE
+    encoder_init();
+  #endif
   matrix_init_kb();
 }
 
@@ -991,6 +999,10 @@ void matrix_scan_quantum() {
     rgb_matrix_task_counter = ((rgb_matrix_task_counter + 1) % (RGB_MATRIX_SKIP_FRAMES + 1));
   #endif
 
+  #ifdef ENCODER_ENABLE
+    encoder_read();
+  #endif
+
   matrix_scan_kb();
 }
 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)

tmk_core/chibios.mk

@@ -233,6 +233,24 @@ qmk: $(BUILD_DIR)/$(TARGET).bin
 dfu-util: $(BUILD_DIR)/$(TARGET).bin cpfirmware sizeafter
 	$(DFU_UTIL) $(DFU_ARGS) -D $(BUILD_DIR)/$(TARGET).bin
 
+
+ifneq ($(strip $(TIME_DELAY)),)
+  TIME_DELAY = $(strip $(TIME_DELAY))
+else
+  TIME_DELAY = 10
+endif
+dfu-util-wait: $(BUILD_DIR)/$(TARGET).bin cpfirmware sizeafter
+	echo "Preparing to flash firmware. Please enter bootloader now..." ;\
+  COUNTDOWN=$(TIME_DELAY) ;\
+  while [[ $$COUNTDOWN -ge 1 ]] ; do \
+        echo "Flashing in $$COUNTDOWN ..."; \
+        sleep 1 ;\
+        ((COUNTDOWN = COUNTDOWN - 1)) ; \
+  done; \
+  echo "Flashing $(TARGET).bin" ;\
+  sleep 1 ;\
+  $(DFU_UTIL) $(DFU_ARGS) -D $(BUILD_DIR)/$(TARGET).bin
+
 st-link-cli: $(BUILD_DIR)/$(TARGET).hex sizeafter
 	$(ST_LINK_CLI) $(ST_LINK_ARGS) -q -c SWD -p $(BUILD_DIR)/$(TARGET).hex -Rst
 

tmk_core/protocol/chibios/usb_main.c

@@ -715,15 +715,16 @@ void send_mouse(report_mouse_t *report) {
     osalSysUnlock();
     return;
   }
-  osalSysUnlock();
 
-  osalSysLock();
   if(usbGetTransmitStatusI(&USB_DRIVER, MOUSE_IN_EPNUM)) {
     /* Need to either suspend, or loop and call unlock/lock during
      * every iteration - otherwise the system will remain locked,
      * no interrupts served, so USB not going through as well.
      * Note: for suspend, need USB_USE_WAIT == TRUE in halconf.h */
-    osalThreadSuspendS(&(&USB_DRIVER)->epc[MOUSE_IN_EPNUM]->in_state->thread);
+    if (osalThreadSuspendTimeoutS(&(&USB_DRIVER)->epc[MOUSE_IN_EPNUM]->in_state->thread, MS2ST(10)==MSG_TIMEOUT)) {
+      osalSysUnlock();
+      return;
+    }
   }
   usbStartTransmitI(&USB_DRIVER, MOUSE_IN_EPNUM, (uint8_t *)report, sizeof(report_mouse_t));
   osalSysUnlock();

users/mechmerlin/changelog.md

@@ -0,0 +1,14 @@
+# Changelog
+All notable changes to my userspace will be documented in this file.
+
+## [0.1.1] - 2018-10-26
+### Added
+- Added a changelog, aka THIS VERY FILE! 
+- Added `config.h` to userspace for `RGBLIGHT_SLEEP` feature. 
+
+### Changed
+- Spruced up the readme file to better explain the things I use in my keymap for would be keymap snoopers. Also useful as an example when people ask. 
+- Use `CTL_T` instead of `MT` for my custom `KC_CTCP` keycode as it was causing issues on some boards. 
+
+## [0.1.0] - 2018-08-31
+Initial usage of userspaces!

users/mechmerlin/config.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#ifdef RGBLIGHT_ENABLE
+#define RGBLIGHT_SLEEP
+#endif // RGBLIGHT_ENABLE

users/mechmerlin/mechmerlin.h

@@ -10,8 +10,8 @@ enum userspace_layers {
 
 // Enum of custom keycodes defined in process_record_user
 enum keycodes {
-    KC_FNX, // Hold for FN layer, tap to toggle ARROWS layer. 
+    KC_FNX, // Hold for FN layer, tap to toggle ARROWS layer.
 };
 
 // Custom #defined keycodes
-#define KC_CTCP MT(KC_LCTL, KC_CAPS)
+#define KC_CTCP CTL_T(KC_CAPS)

users/mechmerlin/readme.md

@@ -1,3 +1,40 @@
-# MechMerlin's Userspace
+# MechMerlin's Userspace v0.1.1
 
-This is a collection of my most commonly used QMK functions
+This is a collection of my most commonly used QMK features. 
+
+A majority of my keyboards are smaller than 75%, ANSI, and staggered. 
+
+## Layers
+----
+
+### _BL (Base Layer)
+Typical standard QWERTY keymap.
+
+### _FL (Function Layer)
+This layer is commonly accessed via `MO(_FL)` on the base layer. It consists of your typical function key F1 through F12 and some RGB and Backlight controls. 
+
+### _AL (Arrow Layer)
+This layer is only present on my 60% boards. I habitually use the bottom right modifiers as arrows. 
+
+### _CL (Control Layer)
+This is not defined in here as it's present only on `LAYOUT_66` boards, or to be specific, my clueboard. It currently uses the default clueboard controls.
+
+## Custom Keycodes
+----
+
+### KC_FNX (Fn Extended)
+
+`KC_FNX` functions as a hold for `MO(X)` and tap for `TG(Y)`. Layer X and Y are different layers. 
+
+It is used primarily on my `LAYOUT_60_ansi` boards as my regular toggle (the 1u key to the right of right shift), is not present there. 
+
+### KC_CTCP (Control Caps)
+
+This is just a wrapper for `CTL_T(KC_CAPS)`. This is a hold for control and tap for caps lock. 
+
+## QMK Features
+----
+
+### RGBLIGHT_SLEEP
+
+Ensures that when my computer is in sleep mode, the keyboard underglow lights will also be off. 

users/spacebarracecar/readme.md

@@ -0,0 +1,111 @@
+# SpacebarRacecar Userspace
+
+The main purpose of this userspace is to keep my personal keymaps clean by moving shared code in here and also allowing me to easily change all my keymaps at once. However it also contains code that might be interesting to QMK Users living in Germany. Most of this code will be explained here.
+
+
+## US Layout Keys for German PCs
+
+I'm using the US Ansi layout however I'm living in Germany which means that every PC here has its input language set to German. My goal was to create custom keycodes that emulate the US Keys so that I can plug my keyboards into any German PC and have them working without changing any settings.
+
+### How to use
+
+- To activate the custom keycodes set GERMAN_ENABLE = yes in the keyboards rules.mk file.
+- The keycodes are listed and explained in [spacebarracecar.h](spacebarracecar.h) under `enum userspace_custom_keycodes`.
+- The keycodes are handled by the `process_record_user` function which is now located in [spacebarracecar.c](spacebarracecar.c). To change keyboard specific configuration `process_record_keymap` is used (see [drashna userspace readme](../drashna/readme.md) for better explanation).
+- There is a predefined `_DEADKEY` layer in [spacebarracecar.h](spacebarracecar.h) under `enum userspace_layers`. Shifted CU_QUOT enables the dead key layer, just like KC_QUOT would when using the US International layout. (See `enum userspace_custom_keycodes` for more explanation).
+- On Windows grave and circonflexe are defined as dead keys when using the standard german layout. Those are automatically escaped when using the custom keycodes. `CU_ESCT` can be used to enable/disable this behavior.
+- For a complete example see my [fc660c](../../keyboards/fc660c/keymaps/spacebarracecar/keymap.c) or [planck](../../keyboards/planck/keymaps/spacebarracecar/keymap.c) keymaps.
+
+### How it works
+
+Creating the custom keycodes was not a trivial task because it is necessary that they are able to send different keycodes depending on the physical shift state. Also the shift state of the actual send keycodes has to be completely independent of the physical shift state. At the same time it has to be ensured that shift never gets stuck or disabled accidentaly.
+
+(Shift state: If shift keycode is registered; Physical shift state: If shift key is actually pressed)
+
+Here is an example for a custom *US Equal* keycode that illustrates the problem:
+
+| Physical Shift State | Custom keycode | Actual send keycodes |
+|----------------------|----------------|----------------------|
+| Unshifted            | =              | Shifted DE_0         |
+| Shifted              | +              | Unshifted DE_PLUS    |
+
+#### Tracking the physical shift state
+
+To track the physical shift state there are two custom left and right shift keycodes `CU_LSFT` and `CU_RSFT`. These track the current physical shift state using two booleans `lshift` and `rshift`. To make things easier both custom shifts use KC_LSFT. A space cadet shift functionality is also included. The preexisting space cadet shift implementation could not be used because it doesn't reset when custom keycodes are pressed and therefore produces unwated parenthesis. 
+
+#### Custom keycode templates
+
+To ease the creation of custom keycodes there are a few templates defined in [spacebarracecar.h](spacebarracecar.h).
+
+- `SHIFT_NORM(kc1, kc2)` Sends independent keycodes kc1 and kc2 depending on physical shift state without changing shift state.
+- `SHIFT_SWITCH(kc1, kc2)` Sends independent keycodes kc1 and kc2 depending on physical shift state while flipping shift state.
+- `SHIFT_ALL(kc1, kc2)` Sends independent keycodes kc1 and kc2 depending on physical shift state while always sending shift.
+- `SHIFT_NO(kc1, kc2)` Sends independent keycodes kc1 and kc2 depending on physical shift state while never sending shift.
+- `SHIFT_ALGR(kc1, kc2)` Sends independent keycodes kc1 and kc2 depending on physical shift state while never sending shift and always sending ralt.
+- `UML(kc)` Sends keycode kc without changing shift state and then escapes the `_DEADKEY` layer.
+
+Here is `SHIFT_NORM` as an example:
+```c
+#define SHIFT_NORM(kc1, kc2) \
+if (record->event.pressed) { \
+  timer_timeout(); \
+  if (lshift || rshift) { \
+    register_code(KC_LSFT); \
+    unregister_code(kc2); \
+    register_code(kc2); \
+    add_to_prev(kc2); \
+  } else { \
+    unregister_code(KC_LSFT); \
+    unregister_code(kc1); \
+    register_code(kc1); \
+  } \
+} else { \
+  unregister_code(kc1); \
+  unregister_code(kc2); \
+} \
+return false;
+```
+
+It is noticeable that before registering a keycode the same keycode gets unregistered first. The reason for this is that there can now be two physical keys that use the same keycode only with different shift states. When rolling those two keys the keycode has to be unregistered first, otherwise the second key doesn't register. Also noticable is that sometimes the `add_to_prev` function is called. This will be explained later. The `timer_timeout` function is necessary to reset the timers of the custom space cadet shift functionality.
+
+It's worth mentioning that `SHIFT_ALGR` unlike the other templates doesn't allow repetition of characters when held. This is because it would otherwise require extensive checking of physical ralt status similar to shift to prevent ralt from getting stuck.
+
+#### Ensuring that shift state is always correct when pressing normal keycodes
+
+To ensure that non custom keycodes always get send with the correct shift state the default case in `process_record_user` includes a physical shift check that sets shift accordingly before registering the keycode. Also `timer_timeout` is always called to reset the space cadet shift timers to prevent unwanted parenthesis.
+
+```c
+default:
+    if(record->event.pressed) {
+      timer_timeout();
+
+      #ifdef GERMAN_ENABLE
+      if (lshift || rshift)
+        register_code(KC_LSFT);
+      else
+        unregister_code(KC_LSFT);
+      #endif
+
+    }
+    return process_record_keymap(keycode, record);
+```
+
+#### Ensuring that custom keycodes always produce the correct character
+
+When very specific key combinations that include custom keycodes and/or shift are pressed it can happen that wrong characters are produced due to changing shift states. The previously mentioned `add_to_prev` function is there to prevent that. It can be used to add a keycode to the `prev_kcs` array that can hold up to 6 keycodes. On various occasions, but mainly when shift is released `unreg_prev` is called, which then unregisters all saved keycodes.
+
+For real use this is probably not needed, but it doesn't hurt either.
+
+#### Adapting the templates for other languages
+
+In theory the templates can be used to create custom keycodes that map any layout to any other layout.
+
+## Other stuff
+
+### Custom Nav/Esc Key
+
+Since I'm always using a navigation layer with all my keyboards there is a `_NAV` layer predefined in [spacebarracecar.h](spacebarracecar.h) under `enum userspace_layers`. In addition to that I wanted to have a keycode that activates the navigation layer when held, but acts as Escape when pressed. In QMK there already exists `LT(layer, kc)`, however I found that there is some amount of lag before the layer is actived. Therefore I created a custom keycode CU_NAV that does the same without lag using a custom timer. Since I already need timers for the custom space cadet shift implementing this was very easy by adding the timer to the `timer_timeout` function.
+
+### Gamemode
+
+The userspace includes the custom keycode `CU_GAME` that is used to flip a boolean variable called `game`. That variable is used to enable/disable windows keys and space cadet shift. In my [planck keymap](../../keyboards/planck/keymaps/spacebarracecar/keymap.c) it also makes Lower act like Space which is more comfortable when resting on wasd and it could also be used to change various other things when gaming.