Conflicts: common/action_util.c

9 years ago · 3ea4495bf5
--- a/README.md
+++ b/README.md
@@ -151,6 +151,7 @@ To avoid configuring accidentally additive salt key `KC_SPACE` also needs to be
 - Disable Gui(`Left Gui`)
 - Swap Grave and Escape(`Grave`)
 - Swap BackSlash and BackSpace(`Back Slash`)
 - Enable NKRO on boot(`N`)

 #### Default Layer
 - Set Default Layer to 0(`0`)
--- a/common/bootmagic.c
+++ b/common/bootmagic.c
@@ -5,6 +5,7 @@
 #include "bootloader.h"
 #include "debug.h"
 #include "keymap.h"
 #include "host.h"
 #include "action_layer.h"
 #include "eeconfig.h"
 #include "keymap_in_eeprom.h"
@@ -81,8 +82,15 @@ void bootmagic(void)
 if (bootmagic_scan_keycode(BOOTMAGIC_KEY_SWAP_BACKSLASH_BACKSPACE)) {
 keymap_config.swap_backslash_backspace = !keymap_config.swap_backslash_backspace;
 }
 if (bootmagic_scan_keycode(BOOTMAGIC_HOST_NKRO)) {
 keymap_config.nkro = !keymap_config.nkro;
 }
 eeconfig_write_keymap(keymap_config.raw);

 #ifdef NKRO_ENABLE
 keyboard_nkro = keymap_config.nkro;
 #endif

 /* default layer */
 uint8_t default_layer = 0;
 if (bootmagic_scan_keycode(BOOTMAGIC_KEY_DEFAULT_LAYER_0)) { default_layer |= (1<<0); }
--- a/common/bootmagic.h
+++ b/common/bootmagic.h
@@ -60,6 +60,9 @@
 #ifndef BOOTMAGIC_KEY_SWAP_BACKSLASH_BACKSPACE
 #define BOOTMAGIC_KEY_SWAP_BACKSLASH_BACKSPACE KC_BSLASH
 #endif
 #ifndef BOOTMAGIC_HOST_NKRO
 #define BOOTMAGIC_HOST_NKRO KC_N
 #endif


 /*
--- a/common/command.c
+++ b/common/command.c
@@ -151,6 +151,7 @@ static void print_eeconfig(void)
 print(".no_gui: "); print_dec(kc.no_gui); print("\n");
 print(".swap_grave_esc: "); print_dec(kc.swap_grave_esc); print("\n");
 print(".swap_backslash_backspace: "); print_dec(kc.swap_backslash_backspace); print("\n");
 print(".nkro: "); print_dec(kc.nkro); print("\n");

 #ifdef BACKLIGHT_ENABLE
 backlight_config_t bc;
--- a/common/eeconfig.h
+++ b/common/eeconfig.h
@@ -47,6 +47,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
 #define EECONFIG_KEYMAP_NO_GUI (1<<4)
 #define EECONFIG_KEYMAP_SWAP_GRAVE_ESC (1<<5)
 #define EECONFIG_KEYMAP_SWAP_BACKSLASH_BACKSPACE (1<<6)
 #define EECONFIG_KEYMAP_NKRO (1<<7)


 bool eeconfig_is_enabled(void);
--- a/common/keymap.h
+++ b/common/keymap.h
@@ -35,7 +35,7 @@ typedef union {
 bool no_gui:1;
 bool swap_grave_esc:1;
 bool swap_backslash_backspace:1;
 bool reserved:1;
 bool nkro:1;
 };
 } keymap_config_t;
 keymap_config_t keymap_config;
--- a/converter/adb_usb/Makefile
+++ b/converter/adb_usb/Makefile
@@ -48,11 +48,17 @@ TOP_DIR = ../..
 TARGET_DIR = .

 # project specific files
 SRC = keymap.c \
 SRC = keymap_common.c \
 matrix.c \
 led.c \
 adb.c

 ifdef KEYMAP
 SRC := keymap_$(KEYMAP).c $(SRC)
 else
 SRC := keymap_ansi.c $(SRC)
 endif

 CONFIG_H = config.h


--- a/converter/adb_usb/Makefile.pjrc
+++ b/converter/adb_usb/Makefile.pjrc
@@ -8,11 +8,17 @@ TOP_DIR = ../..
 TARGET_DIR = .

 # keyboard dependent files
 SRC = keymap.c \
 SRC = keymap_common.c \
 matrix.c \
 led.c \
 adb.c

 ifdef KEYMAP
 SRC := keymap_$(KEYMAP).c $(SRC)
 else
 SRC := keymap_ansi.c $(SRC)
 endif

 CONFIG_H = config.h


--- a/converter/adb_usb/README.md
+++ b/converter/adb_usb/README.md
@@ -7,17 +7,29 @@ But binary size is about 10KB or more it doesn't fit into 8K flash like ATMega8U
 Discuss: http://geekhack.org/showwiki.php?title=Island:14290


 Build
 -----
 0. Connect ADB keyboard to Teensy by 3 lines(Vcc, GND, Data). By default Data line uses port D0.
 Wiring
 ------
 0. Connect ADB keyboard to Teensy by 3 lines(Vcc, GND, Data). By default Data line uses port PD0.
 This converter uses AVR's internal pull-up, but it seems to be too weak, in particular when you want to use a long or coiled cable.
 The external pull-up resistor(1K-10K Ohm) on Data is strongly recommended.
 1. Define following macros for ADB connection in config.h if you use other than port D0.
 1. Define following macros for ADB connection in config.h if you use other than port PD0.
 ADB_PORT, ADB_PIN, ADB_DDR, ADB_DATA_BIT
 2. make
 3. program Teensy


 Build
 -----
 Just make

 $ make clean
 $ make

 If your keyboard is ISO layout

 $ make KEYMAP=iso


 LOCKING CAPSLOCK
 ----------------
 Many of old ADB keyboards have mechanical push-lock switch for Capslock key and this converter supports the locking Capslock key by default. See README in top directory for more detail about this feature.
@@ -48,7 +60,7 @@ effort at this time.
 * |-----------------------------------------------------------| ,---. |---------------|
 * |Shift | Z| X| C| V| B| N| M| ,| ,| /|Shift | |Up | | 1| 2| 3| |
 * |-----------------------------------------------------------| ,-----------. |-----------|Ent|
 * |Ctrl |Gui |Alt | Space | | |  | |Lef|Dow|Rig| | 0| .| |
 * |Ctrl |Alt |Gui | Space |Gui |Alt |Ctrl | |Lef|Dow|Rig| | 0| .| |
 * `-----------------------------------------------------------' `-----------' `---------------'
 */
 KEYMAP(
@@ -68,11 +80,17 @@ To get help press `h` holding Magic key. Magic key is `Power key`.

 Notes
 -----
 Many ADB keyboards has no discrimination between right modifier and left one,
 Not-extended ADB keyboards have no discrimination between right modifier and left one,
 you will always see left control even if you press right control key.
 Apple Extended Keyboard and Apple Extended Keyboard II are the examples.
 Though ADB protocol itself has the ability of distinction between right and left.
 And most ADB keyboard has no NKRO functionality, though ADB protocol itself has that. 
 See protocol/adb.c for more info.
 Apple Extended Keyboard and Apple Extended Keyboard II can discriminate both side
 modifiers except for GUI key(Windows/Command).

 And most ADB keyboard has no diodes in its matrix so they are not NKRO,
 though ADB protocol itself supports it. See protocol/adb.c for more info.

 If keyobard has ISO layout you need to use ISO keymap with `make KEYMAP=iso`. With ANSI
 keymap you will suffer from swapped keys problem.

 https://github.com/tmk/tmk_keyboard/issues/35

 EOF
--- a/converter/adb_usb/keymap_ansi.c
+++ b/converter/adb_usb/keymap_ansi.c
@@ -0,0 +1,16 @@
 #include "keymap_common.h"


 const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 KEYMAP_EXT_ANSI(
 ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, PSCR,SLCK,PAUS, PWR,
 GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, INS, HOME,PGUP, NLCK,PEQL,PSLS,PAST,
 TAB, Q, W, E, R, T, Y, U, I, O, P, LBRC,RBRC,BSLS, DEL, END, PGDN, P7, P8, P9, PMNS,
 LCAP,A, S, D, F, G, H, J, K, L, SCLN,QUOT, ENT, P4, P5, P6, PPLS,
 LSFT,Z, X, C, V, B, N, M, COMM,DOT, SLSH, RSFT, UP, P1, P2, P3,
 LCTL,LALT,LGUI, SPC, RALT,RCTL, LEFT,DOWN,RGHT, P0, PDOT,PENT
 ),
 };

 const uint16_t PROGMEM fn_actions[] = {
 };
--- a/converter/adb_usb/keymap_common.c
+++ b/converter/adb_usb/keymap_common.c
@@ -0,0 +1,30 @@
 /*
 Copyright 2011,2012,2013 Jun Wako <[email protected]>

 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 "keymap_common.h"


 /* translates key to keycode */
 uint8_t keymap_key_to_keycode(uint8_t layer, key_t key)
 {
 return pgm_read_byte(&keymaps[(layer)][(key.row)][(key.col)]);
 }

 /* translates Fn keycode to action */
 action_t keymap_fn_to_action(uint8_t keycode)
 {
 return (action_t){ .code = pgm_read_word(&fn_actions[FN_INDEX(keycode)]) };
 }
--- a/converter/adb_usb/keymap_common.h
+++ b/converter/adb_usb/keymap_common.h
@@ -1,5 +1,5 @@
 /*
 Copyright 2011 Jun Wako <[email protected]>
 Copyright 2011,2012,2013 Jun Wako <[email protected]>

 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -14,111 +14,113 @@ 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 KEYMAP_COMMON_H
 #define KEYMAP_COMMON_H

 /*
 * Keymap for ADB keyboard
 */
 #include <stdint.h>
 #include <stdbool.h>
 #include <avr/pgmspace.h>
 #include "keycode.h"
 #include "action.h"
 #include "action_macro.h"
 #include "report.h"
 #include "print.h"
 #include "debug.h"
 #include "util.h"
 #include "keymap.h"


 #define KEYCODE(layer, row, col) (pgm_read_byte(&keymaps[(layer)][(row)][(col)]))
 extern const uint8_t keymaps[][MATRIX_ROWS][MATRIX_COLS];
 extern const uint16_t fn_actions[];

 #define KEYMAP_ALL( \

 /* M0115 Apple Extended Keyboard ANSI
 * ,---. ,---------------. ,---------------. ,---------------. ,-----------. ,---.
 * |Esc| |F1 |F2 |F3 |F4 | |F5 |F6 |F7 |F8 | |F9 |F10|F11|F12| |PrS|ScL|Pau| |Pwr|
 * `---' `---------------' `---------------' `---------------' `-----------' `---'
 * ,-----------------------------------------------------------. ,-----------. ,---------------.
 * | `| 1| 2| 3| 4| 5| 6| 7| 8| 9| 0| -| =|Backspa| |Ins|Hom|PgU| |NmL| =| /| *|
 * |-----------------------------------------------------------| |-----------| |---------------|
 * |Tab | Q| W| E| R| T| Y| U| I| O| P| [| ]| \| |Del|End|PgD| | 7| 8| 9| -|
 * |-----------------------------------------------------------| `-----------' |---------------|
 * |CapsLo| A| S| D| F| G| H| J| K| L| ;| '|Return | | 4| 5| 6| +|
 * |-----------------------------------------------------------| ,---. |---------------|
 * |Shift | Z| X| C| V| B| N| M| ,| ,| /|Shift | |Up | | 1| 2| 3| |
 * |-----------------------------------------------------------| ,-----------. |-----------|Ent|
 * |Ctrl |Opt |Cmd | Space | |Opt |Ctrl | |Lef|Dow|Rig| | 0| .| |
 * `-----------------------------------------------------------' `-----------' `---------------'
 */
 #define KEYMAP_EXT_ANSI( \
 K35, K7A,K78,K63,K76, K60,K61,K62,K64, K65,K6D,K67,K6F, K69,K6B,K71, K7F, \
 K32,K12,K13,K14,K15,K17,K16,K1A,K1C,K19,K1D,K1B,K18,K33, K72,K73,K74, K47,K51,K4B,K43, \
 K30,K0C,K0D,K0E,K0F,K11,K10,K20,K22,K1F,K23,K21,K1E,K2A, K75,K77,K79, K59,K5B,K5C,K4E, \
 K39,K00,K01,K02,K03,K05,K04,K26,K28,K25,K29,K27, K24, K56,K57,K58,K45, \
 K38,K06,K07,K08,K09,K0B,K2D,K2E,K2B,K2F,K2C, K7B, K3E, K53,K54,K55, \
 K36,K3A,K37, K31, K7C,K7D, K3B,K3D,K3C, K52, K41,K4C, \
 /* for ISO/JIS keyboard */ \
 K0A, /* NON-US \ and | 0x64 */ \
 K34, /* Keypad ENTER 0x58 */ \
 K40, /* F17 0x6C */ \
 K44, /* F18? 0x6d */ \
 K4F, /* F18 0x6d */ \
 K50, /* F19 0x6e */ \
 K5A, /* F20 0x6f */ \
 K5D, /* INTL3(Yen) 0x89 */ \
 K5E, /* INTL1(Ro) 0x87 */ \
 K5F, /* Keypad Comma 0x85 */ \
 K66, /* LANG2(Eisu) 0x91 */ \
 K68, /* LANG1(Kana) 0x90 */ \
 K6A, /* F16 0x6B */ \
 K6E /* Application 0x65 */ \
 K36,K3A,K37, K31, K7C,K7D, K3B,K3D,K3C, K52, K41,K4C \
 ) { \
 { 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_##K0D, KC_##K0E, KC_##K0F }, \
 { KC_##K08, KC_##K09, KC_NUBS, KC_##K0B, KC_##K0C, KC_##K0D, KC_##K0E, KC_##K0F }, \
 { 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_##K1C, KC_##K1D, KC_##K1E, KC_##K1F }, \
 { 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_##K2C, KC_##K2D, KC_##K2E, KC_##K2F }, \
 { KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_##K37 }, \
 { KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_PENT, KC_##K35, KC_##K36, KC_##K37 }, \
 { KC_##K38, KC_##K39, KC_##K3A, KC_##K3B, KC_##K3C, KC_##K3D, KC_##K3E, KC_NO }, \
 { KC_##K40, KC_##K41, KC_NO, KC_##K43, KC_##K44, KC_##K45, KC_NO, KC_##K47 }, \
 { KC_NO, KC_NO, KC_NO, KC_##K4B, KC_##K4C, KC_NO, KC_##K4E, KC_##K4F }, \
 { KC_##K50, KC_##K51, KC_##K52, KC_##K53, KC_##K54, KC_##K55, KC_##K56, KC_##K57 }, \
 { KC_##K58, KC_##K59, KC_##K5A, KC_##K5B, KC_##K5C, KC_##K5D, KC_##K5E, KC_##K5F }, \
 { KC_##K60, KC_##K61, KC_##K62, KC_##K63, KC_##K64, KC_##K65, KC_##K66, KC_##K67 }, \
 { KC_##K68, KC_##K69, KC_##K6A, KC_##K6B, KC_NO, KC_##K6D, KC_##K6E, KC_##K6F }, \
 { KC_F17, KC_##K41, KC_NO, KC_##K43, KC_F18, KC_##K45, KC_NO, KC_##K47 }, \
 { KC_NO, KC_NO, KC_NO, KC_##K4B, KC_##K4C, KC_NO, KC_##K4E, KC_F18 }, \
 { KC_F19, KC_##K51, KC_##K52, KC_##K53, KC_##K54, KC_##K55, KC_##K56, KC_##K57 }, \
 { KC_##K58, KC_##K59, KC_F20, KC_##K5B, KC_##K5C, KC_INT3, KC_INT1, KC_PCMM }, \
 { KC_##K60, KC_##K61, KC_##K62, KC_##K63, KC_##K64, KC_##K65, KC_LANG2, KC_##K67 }, \
 { KC_LANG1, KC_##K69, KC_F16, KC_##K6B, KC_NO, KC_##K6D, KC_APP, KC_##K6F }, \
 { KC_NO, KC_##K71, KC_##K72, KC_##K73, KC_##K74, KC_##K75, KC_##K76, KC_##K77 }, \
 { KC_##K78, KC_##K79, KC_##K7A, KC_##K7B, KC_##K7C, KC_##K7D, KC_NO, KC_##K7F } \
 }

 /* Apple Extended Keyboard US
 /* M0115 Apple Extended Keyboard ISO
 * ,---. ,---------------. ,---------------. ,---------------. ,-----------. ,---.
 * |Esc| |F1 |F2 |F3 |F4 | |F5 |F6 |F7 |F8 | |F9 |F10|F11|F12| |PrS|ScL|Pau| |Pwr|
 * `---' `---------------' `---------------' `---------------' `-----------' `---'
 * ,-----------------------------------------------------------. ,-----------. ,---------------.
 * | `| 1| 2| 3| 4| 5| 6| 7| 8| 9| 0| -| =|Backspa| |Ins|Hom|PgU| |NmL| =| /| *|
 * |-----------------------------------------------------------| |-----------| |---------------|
 * |Tab | Q| W| E| R| T| Y| U| I| O| P| [| ]| \| |Del|End|PgD| | 7| 8| 9| -|
 * |-----------------------------------------------------------| `-----------' |---------------|
 * |CapsLo| A| S| D| F| G| H| J| K| L| ;| '|Return | | 4| 5| 6| +|
 * |Tab | Q| W| E| R| T| Y| U| I| O| P| [| ]|Retur| |Del|End|PgD| | 7| 8| 9| -|
 * |------------------------------------------------------` | `-----------' |---------------|
 * |CapsLo| A| S| D| F| G| H| J| K| L| ;| '| #|  | | 4| 5| 6| +|
 * |-----------------------------------------------------------| ,---. |---------------|
 * |Shift | Z| X| C| V| B| N| M| ,| ,| /|Shift | |Up | | 1| 2| 3| |
 * |Shif| \| Z| X| C| V| B| N| M| ,| ,| /|Shift | |Up | | 1| 2| 3| |
 * |-----------------------------------------------------------| ,-----------. |-----------|Ent|
 * |Ctrl |Opt |Cmd | Space | |Opt |Ctrl | |Lef|Dow|Rig| | 0| .| |
 * `-----------------------------------------------------------' `-----------' `---------------'
 */
 #define KEYMAP_EXTENDED_US( \
 #define KEYMAP_EXT_ISO( \
 K35, K7A,K78,K63,K76, K60,K61,K62,K64, K65,K6D,K67,K6F, K69,K6B,K71, K7F, \
 K32,K12,K13,K14,K15,K17,K16,K1A,K1C,K19,K1D,K1B,K18,K33, K72,K73,K74, K47,K51,K4B,K43, \
 K30,K0C,K0D,K0E,K0F,K11,K10,K20,K22,K1F,K23,K21,K1E,K2A, K75,K77,K79, K59,K5B,K5C,K4E, \
 K39,K00,K01,K02,K03,K05,K04,K26,K28,K25,K29,K27, K24, K56,K57,K58,K45, \
 K38,K06,K07,K08,K09,K0B,K2D,K2E,K2B,K2F,K2C,  K7B, K3E, K53,K54,K55, \
 K30,K0C,K0D,K0E,K0F,K11,K10,K20,K22,K1F,K23,K21,K1E,K24, K75,K77,K79, K59,K5B,K5C,K4E, \
 K39,K00,K01,K02,K03,K05,K04,K26,K28,K25,K29,K27,K2A, K56,K57,K58,K45, \
 K38,K0A,K06,K07,K08,K09,K0B,K2D,K2E,K2B,K2F,K2C, K7B, K3E, K53,K54,K55, \
 K36,K3A,K37, K31, K7C,K7D, K3B,K3D,K3C, K52, K41,K4C \
 ) KEYMAP_ALL( \
 K35, K7A,K78,K63,K76, K60,K61,K62,K64, K65,K6D,K67,K6F, K69,K6B,K71, K7F, \
 K32,K12,K13,K14,K15,K17,K16,K1A,K1C,K19,K1D,K1B,K18,K33, K72,K73,K74, K47,K51,K4B,K43, \
 K30,K0C,K0D,K0E,K0F,K11,K10,K20,K22,K1F,K23,K21,K1E,K2A, K75,K77,K79, K59,K5B,K5C,K4E, \
 K39,K00,K01,K02,K03,K05,K04,K26,K28,K25,K29,K27, K24, K56,K57,K58,K45, \
 K38,K06,K07,K08,K09,K0B,K2D,K2E,K2B,K2F,K2C, K7B, K3E, K53,K54,K55, \
 K36,K3A,K37, K31, K7C,K7D, K3B,K3D,K3C, K52, K41,K4C, \
 /* for ISO/JIS keyboard */ \
 NONUS_BSLASH, /* NON-US \ and | 0x64 */ \
 KP_ENTER, /* Keypad ENTER 0x58 */ \
 F17, /* F17 0x6C */ \
 F18, /* F18? 0x6d */ \
 F18, /* F18 0x6d */ \
 F19, /* F19 0x6e */ \
 F20, /* F20 0x6f */ \
 INT3, /* INTL3(Yen) 0x89 */ \
 INT1, /* INTL1(Ro) 0x87 */ \
 KP_COMMA, /* Keypad Comma 0x85 */ \
 LANG2, /* LANG2(Eisu) 0x91 */ \
 LANG1, /* LANG1(Kana) 0x90 */ \
 F16, /* F16 0x6B */ \
 APPLICATION /* Application 0x65 */ \
 )

 /* M0116
 ) { \
 { 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_##K0D, KC_##K0E, KC_##K0F }, \
 { 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_##K1C, KC_##K1D, KC_##K1E, KC_##K1F }, \
 { 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_##K2C, KC_##K2D, KC_##K2E, KC_##K2F }, \
 { KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_PENT, KC_##K35, KC_##K36, KC_##K37 }, \
 { KC_##K38, KC_##K39, KC_##K3A, KC_##K3B, KC_##K3C, KC_##K3D, KC_##K3E, KC_NO }, \
 { KC_F17, KC_##K41, KC_NO, KC_##K43, KC_F18, KC_##K45, KC_NO, KC_##K47 }, \
 { KC_NO, KC_NO, KC_NO, KC_##K4B, KC_##K4C, KC_NO, KC_##K4E, KC_F18 }, \
 { KC_F19, KC_##K51, KC_##K52, KC_##K53, KC_##K54, KC_##K55, KC_##K56, KC_##K57 }, \
 { KC_##K58, KC_##K59, KC_F20, KC_##K5B, KC_##K5C, KC_INT3, KC_INT1, KC_PCMM }, \
 { KC_##K60, KC_##K61, KC_##K62, KC_##K63, KC_##K64, KC_##K65, KC_LANG2, KC_##K67 }, \
 { KC_LANG1, KC_##K69, KC_F16, KC_##K6B, KC_NO, KC_##K6D, KC_APP, KC_##K6F }, \
 { KC_NO, KC_##K71, KC_##K72, KC_##K73, KC_##K74, KC_##K75, KC_##K76, KC_##K77 }, \
 { KC_##K78, KC_##K79, KC_##K7A, KC_##K7B, KC_##K7C, KC_##K7D, KC_NO, KC_##K7F } \
 }




 /* M0116 Apple Standard Keyboard ANSI
 * +-------+
 * | power |
 * +-------+
@@ -134,7 +136,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
 * |cap|opt|comnd| ` | | \ |lef|rig|dwn|up | | 0 | . | |
 * +---------------------------------------------------------+ +-------+---+---+
 */
 #define KEYMAP_M0116( \
 #define KEYMAP_M0116_ANSI( \
 K7F, \
 K35,K12,K13,K14,K15,K17,K16,K1A,K1C,K19,K1D,K1B,K18,K33, K47,K51,K4B,K43, \
 K30,K0C,K0D,K0E,K0F,K11,K10,K20,K22,K1F,K23,K21,K1E, K59,K5B,K5C,K45, \
@@ -160,55 +162,51 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
 { KC_NO , KC_NO, KC_NO , KC_##K7B, KC_NO, KC_NO, KC_NO, KC_##K7F } \
 }

 #endif

 // Assign Fn key(0-7) to a layer to which switch with the Fn key pressed.
 static const uint8_t PROGMEM fn_layer[] = {
 0, // Fn0
 0, // Fn1
 0, // Fn2
 0, // Fn3
 0, // Fn4
 0, // Fn5
 0, // Fn6
 0 // Fn7
 };

 // Assign Fn key(0-7) to a keycode sent when release Fn key without use of the layer.
 // See layer.c for details.
 static const uint8_t PROGMEM fn_keycode[] = {
 KC_NO, // Fn0
 KC_NO, // Fn1
 KC_NO, // Fn2
 KC_NO, // Fn3
 KC_NO, // Fn4
 KC_NO, // Fn5
 KC_NO, // Fn6
 KC_NO // Fn7
 };

 static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 KEYMAP_EXTENDED_US(
 ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, PSCR,SLCK,PAUS, PWR,
 GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, INS, HOME,PGUP, NLCK,PEQL,PSLS,PAST,
 TAB, Q, W, E, R, T, Y, U, I, O, P, LBRC,RBRC,BSLS, DEL, END, PGDN, P7, P8, P9, PMNS,
 LCAP,A, S, D, F, G, H, J, K, L, SCLN,QUOT, ENT, P4, P5, P6, PPLS,
 LSFT,Z, X, C, V, B, N, M, COMM,DOT, SLSH, RSFT, UP, P1, P2, P3,
 LCTL,LGUI,LALT, SPC, RGUI,RCTL, LEFT,DOWN,RGHT, P0, PDOT,PENT
 ),
 };


 uint8_t keymap_get_keycode(uint8_t layer, uint8_t row, uint8_t col)
 {
 return KEYCODE(layer, row, col);
 }

 uint8_t keymap_fn_layer(uint8_t index)
 {
 return pgm_read_byte(&fn_layer[index]);
 }

 uint8_t keymap_fn_keycode(uint8_t index)
 {
 return pgm_read_byte(&fn_keycode[index]);
 }
 /*
 ADB ANSI/ISO Keymapping Note
 ============================
 ANSI
 ,----------- ----------.
 | *a| 1| 2 =|Backspa|
 |----------- ----------|
 |Tab | Q| | ]| *c|
 |----------- ----------|
 |CapsLo| A| '|Return |
 |----------- ----------|
 |Shift | Shift |
 `----------- ----------'

 ISO
 ,----------- ----------.
 | *a| 1| 2 =|Backspa|
 |----------- ----------|
 |Tab | Q| | ]|Retur|
 |----------- -----` |
 |CapsLo| A| '| *c| |
 |----------- ----------|
 |Shif| *b| Shift |
 `----------- ----------'

 ADB Keyboard scan code:
 ADB scan code USB usage
 ------------- ---------
 Key ANSI ISO ANSI ISO
 ---------------------------------------------
 *a 0x32 0x0A 0x35 0x35
 *b ---- 0x32 ---- 0x64
 *c 0x2A 0x2A 0x31 0x31(or 0x32)


 TMK ADB-USB mapping:
 ADB USB(ANSI) USB(ISO)
 ---------------------------------
 0x32 0x35 0x64
 0x0A ---- 0x35
 0x2A 0x31 0x31(or 0x32)

 Note that mappings of ADB code 0x32 are diffrent between ANSI and ISO keyboard.
 https://github.com/tmk/tmk_keyboard/issues/35
 */
--- a/converter/adb_usb/keymap_hasu.c
+++ b/converter/adb_usb/keymap_hasu.c
@@ -0,0 +1,58 @@
 #include "keymap_common.h"


 const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 /* Default Layer: plain keymap
 * ,---. ,---------------. ,---------------. ,---------------. ,-----------. ,---.
 * |Esc| |F1 |F2 |F3 |F4 | |F5 |F6 |F7 |F8 | |F9 |F10|F11|F12| |PrS|ScL|Pau| | |
 * `---' `---------------' `---------------' `---------------' `-----------' `---'
 * ,-----------------------------------------------------------. ,-----------. ,---------------.
 * | `| 1| 2| 3| 4| 5| 6| 7| 8| 9| 0| -| =|Backspa| |Ins|Hom|PgU| |NmL| =| /| *|
 * |-----------------------------------------------------------| |-----------| |---------------|
 * |Tab | Q| W| E| R| T| Y| U| I| O| P| [| ]| Fn0| |Del|End|PgD| | 7| 8| 9| -|
 * |-----------------------------------------------------------| `-----------' |---------------|
 * |CapsLo| A| S| D| F| G| H| J| K| L| ;| '|Return | | 4| 5| 6| +|
 * |-----------------------------------------------------------| ,---. |---------------|
 * |Shift | Z| X| C| V| B| N| M| ,| ,| /|Shift | |Up | | 1| 2| 3| |
 * |-----------------------------------------------------------| ,-----------. |-----------|Ent|
 * |Ctrl |Gui |Alt | Space |Alt |Gui |Ctrl | |Lef|Dow|Rig| | 0| .| |
 * `-----------------------------------------------------------' `-----------' `---------------'
 */
 KEYMAP_EXT_ANSI(
 ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, PSCR,SLCK,BRK, NO,
 GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, INS, HOME,PGUP, NLCK,EQL, PSLS,PAST,
 TAB, Q, W, E, R, T, Y, U, I, O, P, LBRC,RBRC,FN0, DEL, END, PGDN, P7, P8, P9, PMNS,
 CAPS,A, S, D, F, G, H, J, K, L, SCLN,QUOT, ENT, P4, P5, P6, PPLS,
 LSFT,Z, X, C, V, B, N, M, COMM,DOT, SLSH, RSFT, UP, P1, P2, P3,
 LCTL,LGUI,LALT, SPC, RGUI,RCTL, LEFT,DOWN,RGHT, P0, PDOT,PENT
 ),

 /* Default Layer: plain keymap
 * ,---. ,---------------. ,---------------. ,---------------. ,-----------. ,---.
 * |` | |F1 |F2 |F3 |F4 | |F5 |F6 |F7 |F8 | |F9 |F10|F11|F12| |PrS|ScL|Pau| | |
 * `---' `---------------' `---------------' `---------------' `-----------' `---'
 * ,-----------------------------------------------------------. ,-----------. ,---------------.
 * |Esc|F1 |F2 |F3 |F4 |F5 |F6 |F7 |F8 |F9 |F10|F11|F12|Delete | |Ins|Hom|PgU| |NmL|Mb1|Mb2|Mb3|
 * |-----------------------------------------------------------| |-----------| |---------------|
 * |Tab | Q| W| E| R| T| Y| U|PrS|ScL|Pau|Up |Ins| Fn0| |Del|End|PgD| |MwD|McU|MwU|MwD|
 * |-----------------------------------------------------------| `-----------' |---------------|
 * |CapsLo|VoD|VoU|Mut| F| G| H| J|Hom|PgU|Lef|Rig|Return | |McL|McD|McR|MwU|
 * |-----------------------------------------------------------| ,---. |---------------|
 * |Shift | Z| X| C| V| B| N| M|End|PgD|Dow|Shift | |PgU| |MwL|McD|MwR| |
 * |-----------------------------------------------------------| ,-----------. |-----------|Mb3|
 * |Ctrl |Gui |Alt | Space |Alt |Gui |Ctrl | |Hom|PgD|End| | Mb1|Mb2| |
 * `-----------------------------------------------------------' `-----------' `---------------'
 */
 KEYMAP_EXT_ANSI(
 GRV, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, PSCR,SLCK,BRK, NO, 
 ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, DEL, INS, HOME,PGUP, NLCK,BTN1,BTN2,BTN3,
 TAB, Q, W, E, R, T, Y, U, PSCR,SLCK,PAUS,UP, INS, FN0, DEL, END, PGDN, WH_D,MS_U,WH_U,WH_D,
 CAPS,VOLD,VOLU,MUTE,F, G, H, J, HOME,PGUP,LEFT,RGHT, ENT, MS_L,MS_D,MS_R,WH_U,
 LSFT,Z, X, C, V, B, N, M, END, PGDN,DOWN, RSFT, PGUP, WH_L,MS_D,WH_R,
 LCTL,LGUI,LALT, SPC, RGUI,RCTL, HOME,PGDN,END, BTN1, BTN2,BTN3
 ),
 };

 const uint16_t PROGMEM fn_actions[] = {
 [0] = ACTION_LAYER_TAP_KEY(1, KC_BSLS),
 };
--- a/converter/adb_usb/keymap_iso.c
+++ b/converter/adb_usb/keymap_iso.c
@@ -0,0 +1,16 @@
 #include "keymap_common.h"


 const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 KEYMAP_EXT_ISO(
 ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, PSCR,SLCK,PAUS, PWR,
 GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, INS, HOME,PGUP, NLCK,PEQL,PSLS,PAST,
 TAB, Q, W, E, R, T, Y, U, I, O, P, LBRC,RBRC,ENT, DEL, END, PGDN, P7, P8, P9, PMNS,
 LCAP,A, S, D, F, G, H, J, K, L, SCLN,QUOT,NUHS, P4, P5, P6, PPLS,
 LSFT,NUBS,Z, X, C, V, B, N, M, COMM,DOT, SLSH, RSFT, UP, P1, P2, P3,
 LCTL,LALT,LGUI, SPC, RALT,RCTL, LEFT,DOWN,RGHT, P0, PDOT,PENT
 ),
 };

 const uint16_t PROGMEM fn_actions[] = {
 };
--- a/converter/m0110_usb/Makefile
+++ b/converter/m0110_usb/Makefile
@@ -10,13 +10,14 @@ TARGET_DIR = .
 # keyboard dependent files
 SRC = matrix.c \
 led.c \
 keymap_common.c \
 m0110.c

 # To use own keymap file run make like: make keymap=hasu
 ifdef keymap
 SRC += keymap_$(keymap).c
 ifdef KEYMAP
 SRC += keymap_$(KEYMAP).c
 else
 SRC += keymap.c
 SRC += keymap_plain.c
 endif

 CONFIG_H = config.h
@@ -71,14 +72,14 @@ OPT_DEFS += -DBOOTLOADER_SIZE=4096
 # Build Options
 # *Comment out* to disable the options.
 #
 BOOTMAGIC_ENABLE = yes # Virtual DIP switch configuration(+1000)
 #BOOTMAGIC_ENABLE = yes # Virtual DIP switch configuration(+1000)
 MOUSEKEY_ENABLE = yes # Mouse keys(+4700)
 EXTRAKEY_ENABLE = yes # Audio control and System control(+450)
 CONSOLE_ENABLE = yes # Console for debug(+400)
 COMMAND_ENABLE = yes # Commands for debug and configuration
 #SLEEP_LED_ENABLE = yes # Breathing sleep LED during USB suspend
 #NKRO_ENABLE = yes # USB Nkey Rollover - not yet supported in LUFA
 KEYMAP_SECTION_ENABLE = yes # fixed address keymap for keymap editor
 #KEYMAP_SECTION_ENABLE = yes # fixed address keymap for keymap editor



--- a/converter/m0110_usb/README.md
+++ b/converter/m0110_usb/README.md
@@ -2,6 +2,8 @@ M0110/M0110A to USB keyboard converter
 ======================================
 This firmware converts the protocol of Apple Macintosh keyboard **M0110**, **M0110A** and **M0120** into USB. Target of this project is USB AVR controller **ATmega32U4**. Using this converter you can revive these retro keyboards with modern computer.

 Read README of top directory too.

 Pictures of **M0110 + M0120** and **M0110A**.

 ![M0110+M0120](http://i.imgur.com/dyvXb2Tm.jpg)
@@ -17,6 +19,7 @@ Update
 ------
 - 2013/08: Change port for signals `PF` to `PD`
 - 2013/09: Change port again, it uses inversely `PD0` for data and `PD1` for clock line now.
 - 2014/06: Change keymaps



@@ -54,76 +57,22 @@ To compile firmware you need AVR GCC. You can edit *Makefile* and *config.h* to

 $ git clone git://github.com/tmk/tmk_keyboard.git (or download source)
 $ cd m0110_usb
 $ make -f Makefile clean
 $ make -f Makefile
 $ make clean
 $ make

 To select keymap use `KEYMAP` option.

 and program your Teensy with [PJRC Teensy loader](http://www.pjrc.com/teensy/loader.html).
 $ make clean
 $ make KEYMAP={plain|spacefn|hasu}



 Keymap
 ------
 You can change keymaps by editing *keymap.c*.

 ### M0110 & M0120
 #### *Default Layer*
 ,---------------------------------------------------------. ,---------------.
 | `| 1| 2| 3| 4| 5| 6| 7| 8| 9| 0| -| =|Backs| |Clr| -|Lft|Rgt|
 |---------------------------------------------------------| |---------------|
 |Tab | Q| W| E| R| T| Y| U| I| O| P| [| ]| \| | 7| 8| 9| Up|
 |---------------------------------------------------------| |---------------|
 |Caps | A| S| D| F| G| H| J| K| L| ;| '|Enter | | 4| 5| 6| Dn|
 |---------------------------------------------------------| |---------------|
 |Shift | Z| X| C| V| B| N| M| ,| ,| /|Shift | | 1| 2| 3| |
 `---------------------------------------------------------' |-----------|Ent|
 |Ctl|Gui | Space |Alt |Ctl| | 0| .| |
 `-----------------------------------------------' `---------------'

 - `Space` and `Enter` also work as `Fn` layer switch key when holding down.

 #### *Function Layer(WASD/HHKB)*
 ,---------------------------------------------------------. ,---------------.
 |Esc| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12|Delet| |Nlk| -|Lft|Rgt|
 |---------------------------------------------------------| |---------------|
 |Caps |Hom| Up|PgU| | | | |Psc|Slk|Pau|Up |Ins| \| | 7| 8| 9| Up|
 |---------------------------------------------------------| |---------------|
 |Caps |Lef|Dow|Rig| | | | |Hom|PgU|Lef|Rig|Enter | | 4| 5| 6| Dn|
 |---------------------------------------------------------| |---------------|
 |Shift |End| |PgD| | | | |End|PgD|Dow|Shift | | 1| 2| 3| |
 `---------------------------------------------------------' |-----------|Ent|
 |Ctl|Gui | Space |Alt |Ctl| | 0| .| |
 `-----------------------------------------------' `---------------'


 ### M0110A
 #### *Default Layer*
 ,---------------------------------------------------------. ,---------------.
 | `| 1| 2| 3| 4| 5| 6| 7| 8| 9| 0| -| =|Backs| |Clr| =| /| *|
 |---------------------------------------------------------| |---------------|
 |Tab | Q| W| E| R| T| Y| U| I| O| P| [| ]| | | 7| 8| 9| -|
 |-----------------------------------------------------' | |---------------|
 |Caps | A| S| D| F| G| H| J| K| L| ;| '|Enter | | 4| 5| 6| +|
 |---------------------------------------------------------| |---------------|
 |Shift | Z| X| C| V| B| N| M| ,| ,| /|Shft| Up| | 1| 2| 3| |
 |---------------------------------------------------------| |-----------|Ent|
 |Ctrl |Gui | Space | \|Lft|Rgt|Dwn| | 0| .| |
 `---------------------------------------------------------' `---------------'

 - `Space` and `Enter` also work as `Fn` layer switch key when holding down.
 - `Backslash(\)` also works as `Alt` when holding down.

 #### *Function Layer(WASD/HHKB)*
 ,---------------------------------------------------------. ,---------------.
 |Esc| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12|Delet| |Nlk| =| /| *|
 |---------------------------------------------------------| |---------------|
 |Caps |Hom| Up|PgU| | | | |Psc|Slk|Pau|Up |Ins| | | 7| 8| 9| -|
 |-----------------------------------------------------' | |---------------|
 |Caps |Lef|Dow|Rig| | | | |Hom|PgU|Lef|Rig|Enter | | 4| 5| 6| +|
 |---------------------------------------------------------| |---------------|
 |Shift |End| |PgD| | | | |End|PgD|Dow|Shif|PgU| | 1| 2| 3| |
 |---------------------------------------------------------| |-----------|Ent|
 |Ctrl |Gui | Space | \|Hom|End|PgD| | 0| .| |
 `---------------------------------------------------------' `---------------'
 To create your own keymap copy existent keymap file to `keymap_name.c` and edit it. You can build it like this.

 $ make clean
 $ make KEYMAP=name



--- a/converter/m0110_usb/keymap_common.c
+++ b/converter/m0110_usb/keymap_common.c
@@ -0,0 +1,37 @@
 /*
 Copyright 2011,2012,2014 Jun Wako <[email protected]>

 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 <stdint.h>
 #include <avr/pgmspace.h>
 #include "action.h"
 #include "keycode.h"
 #include "keymap.h"
 #include "keymap_common.h"


 /* translates key to keycode */
 uint8_t keymap_key_to_keycode(uint8_t layer, key_t key)
 {
 return pgm_read_byte(&keymaps[(layer)][(key.row)][(key.col)]);
 }

 /* translates Fn index to action */
 action_t keymap_fn_to_action(uint8_t keycode)
 {
 action_t action;
 action.code = pgm_read_word(&fn_actions[FN_INDEX(keycode)]);
 return action;
 }
--- a/converter/m0110_usb/keymap_common.h
+++ b/converter/m0110_usb/keymap_common.h
@@ -0,0 +1,107 @@
 /*
 Copyright 2011,2012,2014 Jun Wako <[email protected]>

 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 <stdint.h>
 #include <avr/pgmspace.h>
 #include "keycode.h"
 #include "keymap.h"


 extern const uint8_t keymaps[][MATRIX_ROWS][MATRIX_COLS];
 extern const uint16_t fn_actions[];


 /* 
 * The keymap works with both M0110 and M0110A keyboards. As you can see, the M0110A is a superset
 * of the M0110 keyboard, with only one exception: 'Enter' in M0110 does not exist
 * on the M0110A, but since it generates a unique scan code which is not used for some other key in
 * the M0110A, they are totally interchangeable. In fact, the M0110A is functionally (almost)
 * identical to the combination of the M0110 along with the M0120 keypad. The only difference
 * (which is causing some problems as you will read below) is that the M0110+M0120 don't have
 * dedicated arrow keys, while the M0110A does. However, the M0120 did have arrow keys, which
 * doubled as the [comma], [/], [*] and [+] keys, when used with the [Shift] key. The M0110A has
 * substituted the [comma] key with the [=] key, however its scancode is the same.
 *
 * Physical layout:
 * M0110A
 * ,---------------------------------------------------------. ,---------------.
 * | `| 1| 2| 3| 4| 5| 6| 7| 8| 9| 0| -| =|Bcksp| |Clr| =| /| *|
 * |---------------------------------------------------------| |---------------|
 * |Tab | Q| W| E| R| T| Y| U| I| O| P| [| ]| | | 7| 8| 9| -|
 * |-----------------------------------------------------' | |---------------|
 * |Caps | A| S| D| F| G| H| J| K| L| ;| '|Return| | 4| 5| 6| +|
 * |---------------------------------------------------------| |---------------|
 * |Shift | Z| X| C| V| B| N| M| ,| ,| /|Shft|Up | | 1| 2| 3| |
 * |---------------------------------------------------------' |-----------|Ent|
 * |Opt |Mac | Space | \|Lft|Rgt|Dn | | 0| .| |
 * `---------------------------------------------------------' `---------------'
 *
 * M0110 M0120
 * ,---------------------------------------------------------. ,---------------.
 * | `| 1| 2| 3| 4| 5| 6| 7| 8| 9| 0| -| =|Backs| |Clr| -| +| *|
 * |---------------------------------------------------------| |---------------|
 * |Tab | Q| W| E| R| T| Y| U| I| O| P| [| ]| \| | 7| 8| 9| /|
 * |---------------------------------------------------------| |---------------|
 * |Caps | A| S| D| F| G| H| J| K| L| ;| '|Return| | 4| 5| 6| ,|
 * |---------------------------------------------------------| |---------------|
 * |Shift | Z| X| C| V| B| N| M| ,| ,| /|Shift | | 1| 2| 3| |
 * `---------------------------------------------------------' |-----------|Ent|
 * |Opt|Mac | Space |Ent |Opt| | 0| .| |
 * `-----------------------------------------------' `---------------'
 * With Shift keys on M0120 work as curosor.(-:Left *:Right /:Up ,:Down)
 *
 * NOTE: \ is located differently.
 * NOTE: Enter on M0110 is different from Enter on keypad(M0120 and M0110A).
 * NOTE: Left Shift and right Shift are logically same key.
 * NOTE: Left Option and right Option are logically same key.
 */

 /* Keymap definition Macro
 * ,---------------------------------------------------------. ,---------------.
 * | `| 1| 2| 3| 4| 5| 6| 7| 8| 9| 0| -| =|Backs| |Clr| =| /| *|
 * |---------------------------------------------------------| |---------------|
 * |Tab | Q| W| E| R| T| Y| U| I| O| P| [| ]| | | 7| 8| 9| -|
 * |-----------------------------------------------------' | |---------------|
 * |Caps | A| S| D| F| G| H| J| K| L| ;| '|Return| | 4| 5| 6| +|
 * |---------------------------------------------------------| |---------------|
 * |Shift | Z| X| C| V| B| N| M| ,| ,| /|Shft|Up | | 1| 2| 3| |
 * |---------------------------------------------------------| |-----------|Ent|
 * |Opt |Mac | Space |Ent| \|Lft|Rgt|Dn | | 0| .| |
 * `---------------------------------------------------------' `---------------'
 * NOTE: Ent between Space and \ means Enter on M0110.
 */
 #define KEYMAP( \
 K32,K12,K13,K14,K15,K17,K16,K1A,K1C,K19,K1D,K1B,K18,K33, K47,K68,K6D,K62, \
 K30,K0C,K0D,K0E,K0F,K11,K10,K20,K22,K1F,K23,K21,K1E, K59,K5B,K5C,K4E, \
 K39,K00,K01,K02,K03,K05,K04,K26,K28,K25,K29,K27, K24, K56,K57,K58,K66, \
 K38,K06,K07,K08,K09,K0B,K2D,K2E,K2B,K2F,K2C, K4D, K53,K54,K55,K4C, \
 K3A,K37, K31, K34,K2A,K46,K42,K48, K52, K41 \
 ) { \
 { KC_##K00, KC_##K01, KC_##K02, KC_##K03, KC_##K04, KC_##K05, KC_##K06, KC_##K07 }, \
 { KC_##K08, KC_##K09, KC_NO, KC_##K0B, KC_##K0C, KC_##K0D, KC_##K0E, KC_##K0F }, \
 { 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_##K1C, KC_##K1D, KC_##K1E, KC_##K1F }, \
 { 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_##K2C, KC_##K2D, KC_##K2E, KC_##K2F }, \
 { KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_##K34, KC_NO, KC_NO, KC_##K37 }, \
 { KC_##K38, KC_##K39, KC_##K3A, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \
 { KC_NO, KC_##K41, KC_##K42, KC_NO, KC_NO, KC_NO, KC_##K46, KC_##K47 }, \
 { KC_##K48, KC_NO, KC_NO, KC_NO, KC_##K4C, KC_##K4D, KC_##K4E, KC_NO }, \
 { KC_NO, KC_NO, KC_##K52, KC_##K53, KC_##K54, KC_##K55, KC_##K56, KC_##K57 }, \
 { KC_##K58, KC_##K59, KC_NO, KC_##K5B, KC_##K5C, KC_NO, KC_NO, KC_NO }, \
 { KC_NO, KC_NO, KC_##K62, KC_NO, KC_NO, KC_NO, KC_##K66, KC_NO }, \
 { KC_##K68, KC_NO, KC_NO, KC_NO, KC_NO, KC_##K6D, KC_NO, KC_NO }, \
 }
--- a/converter/m0110_usb/keymap_for_editor.c
+++ b/converter/m0110_usb/keymap_for_editor.c
@@ -0,0 +1,118 @@
 /*
 Copyright 2014 Jun Wako <[email protected]>

 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 <stdint.h>
 #include "keycode.h"
 #include "keymap_common.h"


 #ifdef KEYMAP_SECTION_ENABLE
 const uint8_t keymaps[][MATRIX_ROWS][MATRIX_COLS] __attribute__ ((section (".keymap.keymaps"))) = {
 #else
 const uint8_t keymaps[][MATRIX_ROWS][MATRIX_COLS] PROGMEM = {
 #endif
 /* Default:
 * ,---------------------------------------------------------. ,---------------.
 * | `| 1| 2| 3| 4| 5| 6| 7| 8| 9| 0| -| =|Backs| |Clr| =| /| *|
 * |---------------------------------------------------------| |---------------|
 * |Tab | Q| W| E| R| T| Y| U| I| O| P| [| ]| | | 7| 8| 9| -|
 * |-----------------------------------------------------' | |---------------|
 * |Caps | A| S| D| F| G| H| J| K| L| ;| '|Enter | | 4| 5| 6| +|
 * |---------------------------------------------------------| |---------------|
 * |Shift | Z| X| C| V| B| N| M| ,| ,| /|Shft|Up | | 1| 2| 3| |
 * |---------------------------------------------------------| |-----------|Ent|
 * |Ctl |Gui | Space |Alt| \|Lft|Rgt|Dn | | 0| .| |
 * `---------------------------------------------------------' `---------------'
 */
 [0] = KEYMAP(
 GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, CLR, EQL, PSLS,PAST,
 TAB, Q, W, E, R, T, Y, U, I, O, P, LBRC,RBRC, P7, P8, P9, PMNS,
 LCAP,A, S, D, F, G, H, J, K, L, SCLN,QUOT, FN15, P4, P5, P6, PPLS,
 LSFT,Z, X, C, V, B, N, M, COMM,DOT, SLSH, UP, P1, P2, P3, PENT,
 LCTL,LGUI, FN16, LALT,FN31,LEFT,RGHT,DOWN, P0, PDOT
 ),
 /* Cursor Layer(WASD, IJKL)
 * ,---------------------------------------------------------. ,---------------.
 * |Esc| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12|Delet| |Nlk| =| /| *|
 * |---------------------------------------------------------| |---------------|
 * |Caps |Hom| Up|PgU| | | | |Psc|Slk|Pau|Up |Ins| | | 7| 8| 9| -|
 * |-----------------------------------------------------' | |---------------|
 * |Caps |Lef|Dow|Rig| | | | |Hom|PgU|Lef|Rig|Enter | | 4| 5| 6| +|
 * |---------------------------------------------------------| |---------------|
 * |Shift |End| |PgD| | | | |End|PgD|Dow|Shif|PgU| | 1| 2| 3| |
 * |---------------------------------------------------------| |-----------|Ent|
 * |Ctl |Gui | Space |Alt | \|Hom|End|PgD| | 0| .| |
 * `---------------------------------------------------------' `---------------'
 */
 [3] = KEYMAP(
 ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, DEL, NLCK,EQL, PSLS,PAST,
 CAPS,HOME,UP, PGUP,NO, NO, NO, NO, PSCR,SLCK,PAUS,UP, INS, P7, P8, P9, PMNS,
 LCAP,LEFT,DOWN,RGHT,NO, NO, NO, NO, HOME,PGUP,LEFT,RGHT, FN15, P4, P5, P6, PPLS,
 LSFT,END, NO, PGDN,NO, NO, NO, NO, END, PGDN,DOWN, PGUP, P1, P2, P3, PENT,
 LCTL,LGUI, FN16, LALT,FN31,HOME,END, PGDN, P0, PDOT
 ),
 [4] = KEYMAP(
 ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, DEL, NLCK,EQL, PSLS,PAST,
 CAPS,HOME,UP, PGUP,NO, NO, NO, NO, PSCR,SLCK,PAUS,UP, INS, P7, P8, P9, PMNS,
 LCAP,LEFT,DOWN,RGHT,NO, NO, NO, NO, HOME,PGUP,LEFT,RGHT, FN15, P4, P5, P6, PPLS,
 LSFT,END, NO, PGDN,NO, NO, NO, NO, END, PGDN,DOWN, PGUP, P1, P2, P3, PENT,
 LCTL,LGUI, FN16, LALT,FN31,HOME,END, PGDN, P0, PDOT
 ),
 [7] = {},
 };


 /*
 * Fn action definition
 */
 #ifdef KEYMAP_SECTION_ENABLE
 const uint16_t fn_actions[] __attribute__ ((section (".keymap.fn_actions"))) = {
 #else
 const uint16_t fn_actions[] PROGMEM = {
 #endif
 [0] = ACTION_LAYER_MOMENTARY(1),
 [1] = ACTION_LAYER_MOMENTARY(2),
 [2] = ACTION_LAYER_MOMENTARY(3),
 [3] = ACTION_LAYER_MOMENTARY(4),
 [4] = ACTION_LAYER_MOMENTARY(5),
 [5] = ACTION_LAYER_MOMENTARY(6),
 [6] = ACTION_LAYER_MOMENTARY(7),
 [7] = ACTION_LAYER_TOGGLE(1),
 [8] = ACTION_LAYER_TOGGLE(2),
 [9] = ACTION_LAYER_TOGGLE(3),
 [10] = ACTION_LAYER_TAP_TOGGLE(1),
 [11] = ACTION_LAYER_TAP_TOGGLE(2),
 [12] = ACTION_LAYER_TAP_TOGGLE(3),
 [13] = ACTION_LAYER_TAP_KEY(1, KC_F),
 [14] = ACTION_LAYER_TAP_KEY(2, KC_J),
 [15] = ACTION_LAYER_TAP_KEY(3, KC_ENTER),
 [16] = ACTION_LAYER_TAP_KEY(4, KC_SPACE),
 [17] = ACTION_LAYER_TAP_KEY(5, KC_SCOLON),
 [18] = ACTION_LAYER_TAP_KEY(6, KC_QUOTE),
 [19] = ACTION_LAYER_TAP_KEY(7, KC_SLASH),
 [20] = ACTION_MODS_TAP_KEY(MOD_LSFT, KC_SPACE),
 [21] = ACTION_MODS_TAP_KEY(MOD_LCTL, KC_SPACE),
 [22] = ACTION_MODS_TAP_KEY(MOD_RCTL, KC_QUOTE),
 [23] = ACTION_MODS_TAP_KEY(MOD_RCTL, KC_ENTER),
 [24] = ACTION_MODS_TAP_KEY(MOD_LCTL, KC_ESC),
 [25] = ACTION_MODS_TAP_KEY(MOD_LCTL, KC_BSPACE),
 [26] = ACTION_MODS_ONESHOT(MOD_LCTL),
 [27] = ACTION_MODS_TAP_KEY(MOD_LSFT, KC_ESC),
 [28] = ACTION_MODS_TAP_KEY(MOD_LSFT, KC_BSPACE),
 [29] = ACTION_MODS_ONESHOT(MOD_LSFT),
 [30] = ACTION_MODS_TAP_KEY(MOD_RSFT, KC_GRAVE),
 [31] = ACTION_MODS_TAP_KEY(MOD_RALT, KC_BSLASH),
 };
--- a/converter/m0110_usb/keymap_hasu.c
+++ b/converter/m0110_usb/keymap_hasu.c
@@ -1,5 +1,5 @@
 /*
 Copyright 2011,2012 Jun Wako <[email protected]>
 Copyright 2014 Jun Wako <[email protected]>

 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -14,188 +14,74 @@ 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/>.
 */
 /* M0110A Support was contributed by skagon@github */

 #include <stdint.h>
 #include <stdbool.h>
 #include <avr/pgmspace.h>
 #include "keycode.h"
 #include "print.h"
 #include "debug.h"
 #include "util.h"
 #include "keymap.h"


 /* 
 * The keymap works with both M0110 and M0110A keyboards. As you can see, the M0110A is a superset
 * of the M0110 keyboard, with only one exception: 'Enter' in M0110 does not exist
 * on the M0110A, but since it generates a unique scan code which is not used for some other key in
 * the M0110A, they are totally interchangeable. In fact, the M0110A is functionally (almost)
 * identical to the combination of the M0110 along with the M0120 keypad. The only difference
 * (which is causing some problems as you will read below) is that the M0110+M0120 don't have
 * dedicated arrow keys, while the M0110A does. However, the M0120 did have arrow keys, which
 * doubled as the [comma], [/], [*] and [+] keys, when used with the [Shift] key. The M0110A has
 * substituted the [comma] key with the [=] key, however its scancode is the same.
 *
 * Physical layout:
 * M0110A
 * ,---------------------------------------------------------. ,---------------.
 * | `| 1| 2| 3| 4| 5| 6| 7| 8| 9| 0| -| =|Bcksp| |Clr| =| /| *|
 * |---------------------------------------------------------| |---------------|
 * |Tab | Q| W| E| R| T| Y| U| I| O| P| [| ]| | | 7| 8| 9| -|
 * |-----------------------------------------------------' | |---------------|
 * |Caps | A| S| D| F| G| H| J| K| L| ;| '|Return| | 4| 5| 6| +|
 * |---------------------------------------------------------| |---------------|
 * |Shift | Z| X| C| V| B| N| M| ,| ,| /|Shft|Up | | 1| 2| 3| |
 * |---------------------------------------------------------' |-----------|Ent|
 * |Opt |Mac | Space | \|Lft|Rgt|Dn | | 0| .| |
 * `---------------------------------------------------------' `---------------'
 *
 * M0110 M0120
 * ,---------------------------------------------------------. ,---------------.
 * | `| 1| 2| 3| 4| 5| 6| 7| 8| 9| 0| -| =|Backs| |Clr| -| +| *|
 * |---------------------------------------------------------| |---------------|
 * |Tab | Q| W| E| R| T| Y| U| I| O| P| [| ]| \| | 7| 8| 9| /|
 * |---------------------------------------------------------| |---------------|
 * |Caps | A| S| D| F| G| H| J| K| L| ;| '|Return| | 4| 5| 6| ,|
 * |---------------------------------------------------------| |---------------|
 * |Shift | Z| X| C| V| B| N| M| ,| ,| /|Shift | | 1| 2| 3| |
 * `---------------------------------------------------------' |-----------|Ent|
 * |Opt|Mac | Space |Ent |Opt| | 0| .| |
 * `-----------------------------------------------' `---------------'
 * With Shift keys on M0120 work as curosor.(-:Left *:Right /:Up ,:Down)
 *
 * NOTE: \ is located differently.
 * NOTE: Enter on M0110 is different from Enter on keypad(M0120 and M0110A).
 * NOTE: Left Shift and right Shift are logically same key.
 * NOTE: Left Option and right Option are logically same key.
 */

 /* Keymap definition Macro
 * ,---------------------------------------------------------. ,---------------.
 * | `| 1| 2| 3| 4| 5| 6| 7| 8| 9| 0| -| =|Backs| |Clr| =| /| *|
 * |---------------------------------------------------------| |---------------|
 * |Tab | Q| W| E| R| T| Y| U| I| O| P| [| ]| | | 7| 8| 9| -|
 * |-----------------------------------------------------' | |---------------|
 * |Caps | A| S| D| F| G| H| J| K| L| ;| '|Return| | 4| 5| 6| +|
 * |---------------------------------------------------------| |---------------|
 * |Shift | Z| X| C| V| B| N| M| ,| ,| /|Shft|Up | | 1| 2| 3| |
 * |---------------------------------------------------------| |-----------|Ent|
 * |Opt |Mac | Space |Ent| \|Lft|Rgt|Dn | | 0| .| |
 * `---------------------------------------------------------' `---------------'
 * NOTE: Ent between Space and \ means Enter on M0110.
 */
 #define KEYMAP( \
 K32,K12,K13,K14,K15,K17,K16,K1A,K1C,K19,K1D,K1B,K18,K33, K47,K68,K6D,K62, \
 K30,K0C,K0D,K0E,K0F,K11,K10,K20,K22,K1F,K23,K21,K1E, K59,K5B,K5C,K4E, \
 K39,K00,K01,K02,K03,K05,K04,K26,K28,K25,K29,K27, K24, K56,K57,K58,K66, \
 K38,K06,K07,K08,K09,K0B,K2D,K2E,K2B,K2F,K2C, K4D, K53,K54,K55,K4C, \
 K3A,K37, K31, K34,K2A,K46,K42,K48, K52, K41 \
 ) { \
 { KC_##K00, KC_##K01, KC_##K02, KC_##K03, KC_##K04, KC_##K05, KC_##K06, KC_##K07 }, \
 { KC_##K08, KC_##K09, KC_NO, KC_##K0B, KC_##K0C, KC_##K0D, KC_##K0E, KC_##K0F }, \
 { 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_##K1C, KC_##K1D, KC_##K1E, KC_##K1F }, \
 { 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_##K2C, KC_##K2D, KC_##K2E, KC_##K2F }, \
 { KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_##K34, KC_NO, KC_NO, KC_##K37 }, \
 { KC_##K38, KC_##K39, KC_##K3A, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \
 { KC_NO, KC_##K41, KC_##K42, KC_NO, KC_NO, KC_NO, KC_##K46, KC_##K47 }, \
 { KC_##K48, KC_NO, KC_NO, KC_NO, KC_##K4C, KC_##K4D, KC_##K4E, KC_NO }, \
 { KC_NO, KC_NO, KC_##K52, KC_##K53, KC_##K54, KC_##K55, KC_##K56, KC_##K57 }, \
 { KC_##K58, KC_##K59, KC_NO, KC_##K5B, KC_##K5C, KC_NO, KC_NO, KC_NO }, \
 { KC_NO, KC_NO, KC_##K62, KC_NO, KC_NO, KC_NO, KC_##K66, KC_NO }, \
 { KC_##K68, KC_NO, KC_NO, KC_NO, KC_NO, KC_##K6D, KC_NO, KC_NO }, \
 }

 #define KEYCODE(layer, row, col) (pgm_read_byte(&keymaps[(layer)][(row)][(col)]))


 // Assign Fn key(0-7) to a layer to which switch with the Fn key pressed.
 static const uint8_t PROGMEM fn_layer[] = {
 1, // Fn0
 2, // Fn1
 3, // Fn2
 1, // Fn3
 2, // Fn4
 0, // Fn5
 0, // Fn6
 0 // Fn7
 };
 #include "keymap_common.h"

 // Assign Fn key(0-7) to a keycode sent when release Fn key without use of the layer.
 // See layer.c for details.
 static const uint8_t PROGMEM fn_keycode[] = {
 KC_ENTER, // Fn0
 KC_SCOLON, // Fn1
 KC_SLASH, // Fn2
 KC_UP, // Fn3
 KC_NO, // Fn4
 KC_NO, // Fn5
 KC_NO, // Fn6
 KC_NO // Fn7
 };

 static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 /* Default:
 * M0110 M0120
 * ,---------------------------------------------------------. ,---------------.
 * | `| 1| 2| 3| 4| 5| 6| 7| 8| 9| 0| -| =|Backs| |Gui| -| +| *|
 * |---------------------------------------------------------| |---------------|
 * |Tab | Q| W| E| R| T| Y| U| I| O| P| [| ]| \| | 7| 8| 9| /|
 * |---------------------------------------------------------| |---------------|
 * |Ctrl | A| S| D| F| G| H| J| K| L| Fn| '|Return| | 4| 5| 6| ,|
 * |---------------------------------------------------------| |---------------|
 * |Shift | Z| X| C| V| B| N| M| ,| ,| Fn|Shift | | 1| 2| 3| |
 * `---------------------------------------------------------' |-----------|Ent|
 * |Fn |alt | Space |Gui |Fn | | 0| .|  |
 * `-----------------------------------------------' `---------------'
 * M0110
 * ,---------------------------------------------------------.
 * | `| 1| 2| 3| 4| 5| 6| 7| 8| 9| 0| -| =|Backs|
 * |---------------------------------------------------------|
 * |Tab | Q| W| E| R| T| Y| U| I| O| P| [| ]| \|
 * |---------------------------------------------------------|
 * |Ctrl | A| S| D| F| G| H| J| K| L| Fn| '|Return|
 * |---------------------------------------------------------|
 * |Shift | Z| X| C| V| B| N| M| ,| ,| Fn|Shift |
 * `---------------------------------------------------------'
 * |Fn |alt | Fn |Gui |Fn |
 * `-----------------------------------------------'
 */
 KEYMAP(
 [0] = KEYMAP(
 ESC, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, NLCK,EQL, PSLS,PAST,
 TAB, Q, W, E, R, T, Y, U, I, O, P, LBRC,RBRC, P7, P8, P9, PMNS,
 LCTL,A, S, D, F, G, H, J, K, L, FN1, QUOT, FN0, P4, P5, P6, PPLS,
 LSFT,Z, X, C, V, B, N, M, COMM,DOT, FN2, FN3, P1, P2, P3, PENT,
 FN4, LALT, SPC, LGUI,BSLS,LGUI,RCTL,RCTL, LGUI, PDOT
 LCTL,A, S, D, F, G, H, J, K, L, FN3, QUOT, ENT, P4, P5, P6, PPLS,
 LSFT,Z, X, C, V, B, N, M, COMM,DOT, FN1, UP, P1, P2, P3, PENT,
 FN0, LALT, FN2, LGUI,BSLS,LEFT,RGHT,DOWN, P0, PDOT
 ),
 // HHKB & WASD
 KEYMAP(
 // IJKL cursor
 [1] = KEYMAP(
 GRV, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, DEL, NLCK,EQL, PSLS,PAST,
 CAPS,NO, NO, NO, NO, NO, NO, NO, PSCR,SLCK,PAUS,UP, NO, P7, P8, P9, PMNS,
 LCTL,VOLD,VOLU,MUTE,NO, NO, NO, NO, HOME,PGUP,LEFT,RGHT, FN0, P4, P5, P6, PPLS,
 LSFT,NO, NO, NO, NO, NO, NO, NO, END, PGDN,DOWN, FN3,  P1, P2, P3, PENT,
 LCTL,LALT, SPC, LGUI,INS, LGUI,RCTL,RCTL, P0, PDOT
 CAPS,NO, NO, NO, NO, NO, HOME,PGDN,UP, PGUP,END, NO, NO, P7, P8, P9, PMNS,
 LCTL,VOLD,VOLU,MUTE,NO, NO, HOME,LEFT,DOWN,RGHT,END, NO, ENT, P4, P5, P6, PPLS,
 LSFT,NO, NO, NO, NO, NO, HOME,PGDN,PGUP,END, NO, PGUP, P1, P2, P3, PENT,
 TRNS,LALT, SPC, LGUI,BSLS,HOME,END, PGDN, P0, PDOT
 ),
 // vi mousekeys
 KEYMAP(
 // HJKL cursor
 [2] = KEYMAP(
 GRV, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, DEL, NLCK,EQL, PSLS,PAST,
 CAPS,NO, NO, NO, NO, NO, WH_L,WH_D,WH_U,WH_R,PSCR,SLCK,PAUS, P7, P8, P9, PMNS,
 LCTL,VOLD,VOLU,MUTE,NO, NO, MS_L,MS_D,MS_U,MS_R,FN1, NO, ENT, P4, P5, P6, PPLS,
 LSFT,NO, NO, NO, NO, BTN3,BTN2,BTN1,NO, NO, NO, NO,  P1, P2, P3, PENT,
 FN4, LALT, BTN1, LGUI,NO, LGUI,RCTL,RCTL, P0, PDOT
 CAPS,NO, NO, NO, NO, NO, HOME,PGDN,UP, PGUP,END, NO, NO, P7, P8, P9, PMNS,
 LCTL,VOLD,VOLU,MUTE,NO, NO, LEFT,DOWN,UP, RGHT,NO, NO, ENT, P4, P5, P6, PPLS,
 LSFT,NO, NO, NO, NO, NO, HOME,PGDN,PGUP,END, TRNS, PGUP, P1, P2, P3, PENT,
 TRNS,LALT, SPC, LGUI,BSLS,HOME,END, PGDN, P0, PDOT
 ),
 // vi cusorkeys
 KEYMAP(
 // Mousekey
 [3] = KEYMAP(
 GRV, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, DEL, NLCK,EQL, PSLS,PAST,
 CAPS,NO, NO, NO, NO, NO, HOME,PGDN,PGUP,END, PSCR,SLCK,PAUS, P7, P8, P9, PMNS,
 LCTL,NO, NO, NO, NO, NO, LEFT,DOWN,UP, RGHT,NO, NO, ENT, P4, P5, P6, PPLS,
 LSFT,NO, NO, NO, NO, NO, HOME,PGDN,PGUP,END, FN2, NO, P1, P2, P3, PENT,
 LCTL,LALT, SPC, LGUI,INS, LGUI,RCTL,RCTL, P0, PDOT
 CAPS,Q, W, E, R, T, WH_L,WH_D,MS_U,WH_U,WH_R,WBAK,WFWD, P7, P8, P9, PMNS,
 LCTL,VOLD,VOLU,MUTE,NO, NO, BTN2,MS_L,MS_D,MS_R,BTN1,NO, ENT, P4, P5, P6, PPLS,
 LSFT,Z, X, C, V, B, BTN2,BTN1,BTN4,BTN5,NO, PGUP, P1, P2, P3, PENT,
 NO, LALT, TRNS, LGUI,BSLS,HOME,END, PGDN, P0, PDOT
 ),
 // Mousekey
 [4] = KEYMAP(
 GRV, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, DEL, NLCK,EQL, PSLS,PAST,
 CAPS,Q, W, E, R, T, WH_L,WH_D,MS_U,WH_U,WH_R,WBAK,WFWD, P7, P8, P9, PMNS,
 LCTL,VOLD,VOLU,MUTE,NO, NO, BTN2,MS_L,MS_D,MS_R,TRNS,NO, ENT, P4, P5, P6, PPLS,
 LSFT,Z, X, C, V, B, BTN2,BTN1,BTN4,BTN5,NO, PGUP, P1, P2, P3, PENT,
 NO, LALT, BTN1, LGUI,BSLS,HOME,END, PGDN, P0, PDOT
 ),
 };


 uint8_t keymap_get_keycode(uint8_t layer, uint8_t row, uint8_t col)
 {
 return KEYCODE(layer, row, col);
 }

 uint8_t keymap_fn_layer(uint8_t index)
 {
 return pgm_read_byte(&fn_layer[index]);
 }

 uint8_t keymap_fn_keycode(uint8_t index)
 {
 return pgm_read_byte(&fn_keycode[index]);
 }
 /*
 * Fn action definition
 */
 const uint16_t fn_actions[] PROGMEM = {
 [0] = ACTION_LAYER_MOMENTARY(1),
 [1] = ACTION_LAYER_TAP_KEY(2, KC_SLASH),
 [2] = ACTION_LAYER_TAP_KEY(3, KC_SPACE),
 [3] = ACTION_LAYER_TAP_KEY(4, KC_SCOLON),
 };
--- a/converter/m0110_usb/keymap_plain.c
+++ b/converter/m0110_usb/keymap_plain.c
@@ -0,0 +1,64 @@
 /*
 Copyright 2014 Jun Wako <[email protected]>

 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 <stdint.h>
 #include "keycode.h"
 #include "keymap_common.h"


 const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 /* Default:
 * M0110 M0120
 * ,---------------------------------------------------------. ,---------------.
 * | `| 1| 2| 3| 4| 5| 6| 7| 8| 9| 0| -| =|Backs| |Nlk| -| +| *|
 * |---------------------------------------------------------| |---------------|
 * |Tab | Q| W| E| R| T| Y| U| I| O| P| [| ]| \| | 7| 8| 9| /|
 * |---------------------------------------------------------| |---------------|
 * |Ctrl | A| S| D| F| G| H| J| K| L| ;| '|Return| | 4| 5| 6| ,|
 * |---------------------------------------------------------| |---------------|
 * |Shift | Z| X| C| V| B| N| M| ,| ,| /|Shift | | 1| 2| 3| |
 * `---------------------------------------------------------' |-----------|Ent|
 * |Opt|Mac | Space |Mac |Opt| | 0| .| |
 * `-----------------------------------------------' `---------------'
 * M0110A
 * ,---------------------------------------------------------. ,---------------.
 * | `| 1| 2| 3| 4| 5| 6| 7| 8| 9| 0| -| =|Bcksp| |Nlk| =| /| *|
 * |---------------------------------------------------------| |---------------|
 * |Tab | Q| W| E| R| T| Y| U| I| O| P| [| ]| | | 7| 8| 9| -|
 * |-----------------------------------------------------' | |---------------|
 * |Caps | A| S| D| F| G| H| J| K| L| ;| '|Return| | 4| 5| 6| +|
 * |---------------------------------------------------------| |---------------|
 * |Shift | Z| X| C| V| B| N| M| ,| ,| /|Shft|Up | | 1| 2| 3| |
 * |---------------------------------------------------------' |-----------|Ent|
 * |Opt |Mac | Space | \|Lft|Rgt|Dn | | 0| .| |
 * `---------------------------------------------------------' `---------------'
 */
 [0] = KEYMAP(
 GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, NLCK,PEQL,PSLS,PAST,
 TAB, Q, W, E, R, T, Y, U, I, O, P, LBRC,RBRC, P7, P8, P9, PMNS,
 LCAP,A, S, D, F, G, H, J, K, L, SCLN,QUOT, ENT, P4, P5, P6, PPLS,
 LSFT,Z, X, C, V, B, N, M, COMM,DOT, SLSH, UP, P1, P2, P3, PENT,
 LALT,LGUI, SPC, RGUI,BSLS,LEFT,RGHT,DOWN, P0, PDOT
 ),
 };

 /*
 * Fn action definition
 */
 const uint16_t fn_actions[] PROGMEM = {
 };


--- a/converter/m0110_usb/keymap_spacefn.c
+++ b/converter/m0110_usb/keymap_spacefn.c
@@ -0,0 +1,71 @@
 /*
 Copyright 2014 Jun Wako <[email protected]>

 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 <stdint.h>
 #include "keycode.h"
 #include "keymap_common.h"


 const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 /* Default:
 * M0110 M0120
 * ,---------------------------------------------------------. ,---------------.
 * | `| 1| 2| 3| 4| 5| 6| 7| 8| 9| 0| -| =|Backs| |Nlk| -| +| *|
 * |---------------------------------------------------------| |---------------|
 * |Tab | Q| W| E| R| T| Y| U| I| O| P| [| ]| \| | 7| 8| 9| /|
 * |---------------------------------------------------------| |---------------|
 * |Ctrl | A| S| D| F| G| H| J| K| L| ;| '|Return| | 4| 5| 6| ,|
 * |---------------------------------------------------------| |---------------|
 * |Shift | Z| X| C| V| B| N| M| ,| ,| /|Shift | | 1| 2| 3| |
 * `---------------------------------------------------------' |-----------|Ent|
 * |Opt|Mac | Space |Mac |Opt| | 0| .| |
 * `-----------------------------------------------' `---------------'
 * M0110A
 * ,---------------------------------------------------------. ,---------------.
 * | `| 1| 2| 3| 4| 5| 6| 7| 8| 9| 0| -| =|Bcksp| |Nlk| =| /| *|
 * |---------------------------------------------------------| |---------------|
 * |Tab | Q| W| E| R| T| Y| U| I| O| P| [| ]| | | 7| 8| 9| -|
 * |-----------------------------------------------------' | |---------------|
 * |Caps | A| S| D| F| G| H| J| K| L| ;| '|Return| | 4| 5| 6| +|
 * |---------------------------------------------------------| |---------------|
 * |Shift | Z| X| C| V| B| N| M| ,| ,| /|Shft|Up | | 1| 2| 3| |
 * |---------------------------------------------------------' |-----------|Ent|
 * |Opt |Mac | Space | \|Lft|Rgt|Dn | | 0| .| |
 * `---------------------------------------------------------' `---------------'
 */
 [0] = KEYMAP(
 GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, NLCK,PEQL,PSLS,PAST,
 TAB, Q, W, E, R, T, Y, U, I, O, P, LBRC,RBRC, P7, P8, P9, PMNS,
 LCTL,A, S, D, F, G, H, J, K, L, SCLN,QUOT, ENT, P4, P5, P6, PPLS,
 LSFT,Z, X, C, V, B, N, M, COMM,DOT, SLSH, UP, P1, P2, P3, PENT,
 LALT,LGUI, FN0, RGUI,BSLS,LEFT,RGHT,DOWN, P0, PDOT
 ),
 [1] = KEYMAP(
 ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, DEL, NLCK,EQL, PSLS,PAST,
 TRNS,TRNS,TRNS,ESC, TRNS,TRNS,TRNS,HOME,UP, END, PSCR,SLCK,PAUS, P7, P8, P9, PMNS,
 LCTL,TRNS,TRNS,TRNS,TRNS,TRNS,PGUP,LEFT,DOWN,RGHT,TRNS,TRNS, TRNS, P4, P5, P6, PPLS,
 TRNS,TRNS,TRNS,TRNS,TRNS,SPC, PGDN,GRV, FN1, TRNS,APP, PGUP, P1, P2, P3, PENT,
 TRNS,TRNS, TRNS, TRNS,INS, HOME,END, PGDN, P0, PDOT
 ),
 };

 /*
 * Fn action definition
 */
 const uint16_t fn_actions[] PROGMEM = {
 [0] = ACTION_LAYER_TAP_KEY(1, KC_SPACE),
 [1] = ACTION_MODS_KEY(MOD_LSFT, KC_GRV), // tilde
 };
--- a/converter/ps2_usb/README.md
+++ b/converter/ps2_usb/README.md
@@ -12,7 +12,7 @@ In case of Teensy2.0(ATMega32U4):
 - **Interrupt**: **Clock** is on `PD1` and **Data** on `PD0`.(Recommended. Soarer's converter compatible)
 - **Busywait**: **Clock** is on `PD1` and **Data** on `PD0`.
 - **USART**: **Clock** is on `PD5` and **Data** on `PD2`.
 3. Optionally you need pull-up register. 1K-10K Ohm is OK.
 3. Optionally you need pull-up resistor. 1K-10K Ohm is OK.

 To change pin configuration edit config.h.

--- a/converter/ps2_usb/config_tmk_rev2.h
+++ b/converter/ps2_usb/config_tmk_rev2.h
@@ -35,8 +35,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.

 /* key combination for command */
 #define IS_COMMAND() ( \
 keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) || \
 keyboard_report->mods == (MOD_BIT(KC_LCTRL) | MOD_BIT(KC_RSHIFT)) \
 keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
 )


--- a/converter/ps2_usb/keymap_spacefn.c
+++ b/converter/ps2_usb/keymap_spacefn.c
@@ -35,11 +35,11 @@ const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 * ,-----------------------------------------------------------.
 * |` | F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12|Delete |
 * |-----------------------------------------------------------|
 * | | | | | | | |Hom|Up |End|Psc|Slk|Pau|Ins |
 * | | | |Esc| | | |Hom|Up |End|Psc|Slk|Pau|Ins |
 * |-----------------------------------------------------------|
 * | | | | | | |PgU|Lef|Dow|Rig| | | |
 * |-----------------------------------------------------------|
 * | | | | | |Spc|PgD|` |~ | | | |
 * | | | | | |Spc|PgD|` |~ | |Men| |
 * |-----------------------------------------------------------|
 * | | | | | | | | |
 * `-----------------------------------------------------------'
@@ -49,7 +49,7 @@ const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 GRV, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, DEL, INS, HOME,PGUP, NLCK,PSLS,PAST,PMNS,
 TRNS,TRNS,TRNS,ESC, TRNS,TRNS,TRNS,HOME,UP, END, PSCR,SLCK,PAUS,INS, DEL, END, PGDN, P7, P8, P9,
 TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,PGUP,LEFT,DOWN,RGHT,TRNS,TRNS, TRNS, P4, P5, P6, PPLS,
 TRNS,TRNS,TRNS,TRNS,TRNS,SPC, PGDN,GRV, FN1, TRNS,TRNS, TRNS, UP, P1, P2, P3,
 TRNS,TRNS,TRNS,TRNS,TRNS,SPC, PGDN,GRV, FN1, TRNS,APP,  TRNS, UP, P1, P2, P3,
 TRNS,TRNS,TRNS, TRNS, TRNS,TRNS,TRNS,TRNS, LEFT,DOWN,RGHT, P0, PDOT,PENT
 ),
 };
--- a/doc/build.md
+++ b/doc/build.md
@@ -5,23 +5,22 @@ Build Firmware and Program Controller
 Download and Install
 --------------------
 ### 1. Install Tools
 First, you need tools to build firmware and program your controller. I assume you are on Windows here.

 1. **Toolchain** Install [WinAVR][winavr]. This is old but works well for this purpose. `WinAVR` is a tool set to build firmware including C compiler(gcc) and make commands. You can use [CrossPack][crosspack] instead if you are on Mac.
 1. **Toolchain** On Windows install [MHV AVR Tools][mhv] for AVR GCC compiler and [Cygwin][cygwin](or [MinGW][mingw]) for shell terminal. On Mac you can use [CrossPack][crosspack]. On Linux you can install AVR GCC with your favorite package manager.

 2. **Programmer** Install [Atmel FLIP][flip]. `FLIP` is a tool to program(load) firmware into AVR controller via DFU bootloader. AVR USB chips including ATmega32U4 has DFU bootloader by factory default. You can also use [dfu-programmer][dfu-prog] instead if you are on Mac or Linux.
 2. **Programmer** On Windows install [Atmel FLIP][flip]. On Mac and Linux install [dfu-programmer][dfu-prog].

 3. **Driver** At first time you start DFU bootloader on Chip 'Found New Hardware Wizard' will come up on Windows. If you install device driver properly you can find chip name like 'ATmega32U4' under 'LibUSB-Win32 Devices' tree on 'Device Manager'. If not you shall need to update its driver on 'Device Manager'. You will find the driver in `FLIP` install directory like: C:\Program Files (x86)\Atmel\Flip 3.4.5\usb\. If you use `dfu-programmer` install its driver.
 3. **Driver** On Windows you start DFU bootloader on the chip first time you will see 'Found New Hardware Wizard' to install driver. If you install device driver properly you can find chip name like 'ATmega32U4' under 'LibUSB-Win32 Devices' tree on 'Device Manager'. If not you shall need to update its driver on 'Device Manager'. You will find the driver in `FLIP` install directory like: C:\Program Files (x86)\Atmel\Flip 3.4.5\usb\. In case of `dfu-programmer` use its driver.

 If you use PJRC Teensy you don't need step 2 and 3 above, just get [Teensy loader][teensy-loader].


 ### 2. Download source
 You can find firmware source at github: 
 You can find firmware source at github:

 - <https://github.com/tmk/tmk_keyboard>

 If you are familiar with `Git` tools you are recommended to use it but you can also download zip archive from: 
 If you are familiar with `Git` tools you are recommended to use it but you can also download zip archive from:

 - <https://github.com/tmk/tmk_keyboard/archive/master.zip>

@@ -29,7 +28,7 @@ If you are familiar with `Git` tools you are recommended to use it but you can a
 Build firmware
 --------------
 ### 1. Open terminal
 Open terminal window to get access to commands. You can use `cmd` in Windows or `Terminal.app` on Mac OSX. In Windows press `Windows` key and `R` then enter `cmd` in 'Run command' dialog showing up.
 Open terminal window to get access to commands. Use Cygwin(or MingGW) `shell terminal` in Windows or `Terminal.app` on Mac OSX. In Windows press `Windows` key and `R` then enter `cmd` in 'Run command' dialog showing up.

 ### 2. Change directory
 Move to project directory in the firmware source.
@@ -100,6 +99,9 @@ You may want to use other programmer like `avrdude` with AVRISPmkII, Arduino or
 $ make -f Makefile.<variant> program


 [cygwin]: https://www.cygwin.com/
 [mingw]: http://www.mingw.org/
 [mhv]: https://infernoembedded.com/products/avr-tools
 [winavr]: http://winavr.sourceforge.net/
 [crosspack]: http://www.obdev.at/products/crosspack/index.html
 [flip]: http://www.atmel.com/tools/FLIP.aspx
@@ -116,14 +118,18 @@ Makefile Options
 #MCU = at90usb1286 # Teensy++ 2.0
 F_CPU = 16000000

 Set your MCU and its clock in Hz.

 # Boot Section Size in *bytes*
 # Teensy halfKay 512
 # Atmel DFU loader 4096
 # LUFA bootloader 4096
 OPT_DEFS += -DBOOTLOADER_SIZE=4096

 If you are using PJRC Teensy use `512` for `BOOTLOADER_SIZE`, otherwise use `4096` unless you are sure.

 ### 2. Features
 Optional. Note that ***comment out*** to disable them.
 Optional. Note that ***comment out*** with `#` to disable them.

 BOOTMAGIC_ENABLE = yes # Virtual DIP switch configuration(+1000)
 MOUSEKEY_ENABLE = yes # Mouse keys(+4700)
@@ -153,7 +159,7 @@ Config.h Options
 ----------------
 ### 1. Magic command key combination

 #define IS_COMMAND() (keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_RSHIFT))) 
 #define IS_COMMAND() (keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_RSHIFT)))

 ### 2. Mechanical Locking Support for CapsLock

--- a/keyboard/hhkb/Makefile
+++ b/keyboard/hhkb/Makefile
@@ -53,12 +53,6 @@ SRC += keymap_common.c \
 matrix.c \
 led.c

 ifdef KEYMAP
 SRC := keymap_$(KEYMAP).c $(SRC)
 else
 SRC := keymap_hasu.c $(SRC)
 endif

 CONFIG_H = config.h


@@ -123,7 +117,27 @@ EXTRAKEY_ENABLE = yes # Audio control and System control
 CONSOLE_ENABLE = yes # Console for debug
 COMMAND_ENABLE = yes # Commands for debug and configuration
 NKRO_ENABLE = yes # USB Nkey Rollover
 KEYMAP_SECTION_ENABLE = yes # fixed address keymap for keymap editor
 #KEYMAP_SECTION_ENABLE = yes # fixed address keymap for keymap editor
 #HHKB_JP = yes # HHKB JP support


 ifdef HHKB_JP
 OPT_DEFS += -DHHKB_JP
 endif


 #
 # Keymap file
 #
 ifdef KEYMAP
 SRC := keymap_$(KEYMAP).c $(SRC)
 else
 ifdef HHKB_JP
 SRC := keymap_jp.c $(SRC)
 else 
 SRC := keymap_hhkb.c $(SRC)
 endif
 endif


 # Search Path
@@ -138,4 +152,5 @@ debug-on: EXTRAFLAGS += -DDEBUG -DDEBUG_ACTION
 debug-on: all

 debug-off: EXTRAFLAGS += -DNO_DEBUG -DNO_PRINT
 debug-off: OPT_DEFS := $(filter-out -DCONSOLE_ENABLE,$(OPT_DEFS))
 debug-off: all
--- a/keyboard/hhkb/Makefile.nodebug
+++ b/keyboard/hhkb/Makefile.nodebug
@@ -102,7 +102,7 @@ ARCH = AVR8
 F_USB = $(F_CPU)

 # Interrupt driven control endpoint task
 OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
 #OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT


 # Boot Section Size in *bytes*
@@ -122,8 +122,8 @@ MOUSEKEY_ENABLE = yes # Mouse keys
 EXTRAKEY_ENABLE = yes # Audio control and System control
 #CONSOLE_ENABLE = yes # Console for debug
 COMMAND_ENABLE = yes # Commands for debug and configuration
 #NKRO_ENABLE = yes # USB Nkey Rollover
 #KEYMAP_SECTION_ENABLE = yes # fixed address keymap for keymap editor
 NKRO_ENABLE = yes # USB Nkey Rollover
 KEYMAP_SECTION_ENABLE = yes # fixed address keymap for keymap editor


 # Search Path
--- a/keyboard/hhkb/README.md
+++ b/keyboard/hhkb/README.md
@@ -2,7 +2,7 @@ Alternative Controller for HHKB Pro
 ===================================
 I wanted to add some features like vi cursor and mouse keys to my [HHKB][HHKB] but its controller is not programmable and firmware source code is not open, of course. This means customizing this keyboard needs to replace original controller with programmable one.

 This controller can work with HHKB **Professional**, **Professional** 2 and **Type-S**.
 This controller can work with HHKB **Professional**, **Professional** 2, **JP** and **Type-S**.

 See [this thread][AltController] in geekhack.org.

@@ -43,7 +43,7 @@ See [doc/HHKB.txt](doc/HHKB.txt) and files under [doc/](doc/) for internal of HH
 See [this document](../../doc/build.md) first.

 ### Configuration
 Set `MCU`, `BOOTLOADER_SIZE` and other build options in `Makefile` and `config.h`.
 Set `MCU`, `BOOTLOADER_SIZE` and other build options in `Makefile` and `config.h`. If your target is **HHKB JP** you need to set `HHKB_JP` build option in `Makefile`.

 ### Build 
 Several version of keymap are available in advance but you are recommended to define your favorite layout yourself. Just `make` with `KEYMAP` option like:
@@ -66,37 +66,22 @@ Use [Teensy Loader] if your controller is Teensy/Teensy++.


 ##Keymap
 To define your own keymap create file named `keymap_<name>.c` and see keymap document(you can find in top README.md) and existent keymap files.
 To define your own keymap create file named `keymap_<name>.c` and see [keymap document](../../doc/keymap.md) and existent keymap files.


 ##Hardware
 You have some options for hardware. Development boards with USB AVR family(ATMega32U4, AT90USB1286) like Teensy will work while MegaAVR with [V-USB] library is also cheaper option for DIY.

 ###1. TMK Alt Controller Board
 TMK designed [Keyboard Controller Board for HHKB Pro2(KiCad project)](https://github.com/tmk/HHKB_controller).
 See [this post](http://geekhack.org/index.php?topic=12047.msg948923#msg948923).


 ###2. PJRC Teensy++ 2.0 version
 +---------------+
 | Teensy++ |
 | |
 | | HHKB pro HHKB pro2
 | | ~~~~~~~~ ~~~~~~~~~
 | PB0-2|------->ROW (6-8) (5-7)
 | PB3-5|------->COL (9-11) (8-10)
 | PB6|------->ENABLE (12) (11)
 | PE6|<-------KEY (4) (3)
 | PE7|------->PREV (5) (4)
 | |
 | | 5V--- (1-3) (1-2)
 | | GND--- (13-14) (12-13)
 +---------------+

 - NOTE: PJRC [Teensy](http://www.pjrc.com/teensy/)
 Design files are available at [Keyboard Controller Board for HHKB(KiCad project)](https://github.com/tmk/HHKB_controller) and see [Controller Distribution thread](http://geekhack.org/index.php?topic=56494.0) if you get an assembled one.


 ###2. PJRC Teensy
 See [this thread](http://geekhack.org/index.php?topic=57008.0).


 ###3. V-USB version
 See [V-USB controller for HHKB](doc/V-USB.md)
 See [V-USB controller for HHKB](doc/V-USB.md).


 [LUFA]: http://www.fourwalledcubicle.com/LUFA.php
--- a/keyboard/hhkb/config.h
+++ b/keyboard/hhkb/config.h
@@ -28,7 +28,11 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.


 /* matrix size */
 #define MATRIX_ROWS 8
 #ifdef HHKB_JP
 # define MATRIX_ROWS 16
 #else
 # define MATRIX_ROWS 8
 #endif
 #define MATRIX_COLS 8


--- a/keyboard/hhkb/doc/HHKB.txt
+++ b/keyboard/hhkb/doc/HHKB.txt
@@ -12,11 +12,11 @@ Controller PCB
 Keyswitch PCB
 -------------
 HC4051 Analog Multiplexer: select a row line.
 http://www.alldatasheet.com/datasheet-pdf/pdf/203989/KODENSHI/KK74HC4051A.html
 http://www.ti.com/lit/ds/schs122j/schs122j.pdf
 LS145 BCD Decoder: select a column line.
 http://www.alldatasheet.com/datasheet-pdf/pdf/27373/TI/SN74LS145D.html
 http://www.ti.com/lit/ds/symlink/sn74ls145.pdf
 BU9831 Non-volatile electronic potentiometer: for calibration?
 http://www.alldatasheet.com/datasheet-pdf/pdf/36387/ROHM/BU9831.html
 https://www.spezial.com/doc/rohm-a/bu9831.pdf
 TP1683/4 Capacitive Sensing controller: no datasheet available.

 (HHKB_keyswitch.jpg)
@@ -28,37 +28,41 @@ Keyswitch PCB
 Connector Cable
 ---------------
 Two PCBs are connected by 15 lines(13 in case of Pro2).
 Vcc and GND use 3(2) lines each, other 9 lines are for keyboard signaling.
 Vcc and GND use 3(2) lines each, other lines are for keyboard signaling.

 Keyswitch connector
 pro pro2  Description Teensy++ pins
 HHKB connector lines:
 JP Pro2 Pro Function Description Teensy++ pins
 --------------------------------------------------------------------------------------------
 1 Vcc(5V) Not exist on Pro2 5V
 2 1 Vcc(5V) 5V
 3 2 Vcc(5V) 5V
 4 3 TP1684 KEY: Low(0) when key pressed PE6 input(with pullup)
 5 4 TP1684 KEY_PREV: make threshold PE7 output
 6 5 HC4051 A(bit0)\ PB0 output
 7 6 HC4051 B(bit1) > select row(0 to 7) PB1 output
 8 7 HC4051 C(bit2)/ PB2 output
 9 8 LS145 A(bit0)\ PB3 output
 10 9 LS145 B(bit1) > select column(0 to 7) PB4 output
 11 10 LS145 C(bit2)/ PB5 output
 12 11 LS145 D(enable) Low(0) enables selected column PB6 output
 13 12 GND GND
 14 13 GND GND
 15 GND Not exist on Pro2 GND
 1 Vcc(5V) 5V
 1 1 2 Vcc(5V) 5V
 2 2 3 Vcc(5V) 5V
 3 3 4 TP1684 KEY: Low(0) when key pressed PE6 input(with pullup)
 4 4 5 TP1684 KEY_PREV: make threshold PE7 output
 5 5 6 HC4051 A(bit0)\ PB0 output
 6 6 7 HC4051 B(bit1) > select row 0-7 PB1 output
 7 7 8 HC4051 C(bit2)/ PB2 output
 8 8 9 LS145 A(bit0)\ PB3 output
 9 9 10 LS145 B(bit1) > select column 0-7 PB4 output
 10 10 11 LS145 C(bit2)/ PB5 output
 11 11 12 LS145 D(enable) Low(0) enables selected column PB6 output
 12 12 13 GND GND
 13 13 14 GND GND
 15 GND
 14 HC4051(Z2) ~Enable of Z2 row0-7
 15 HC4051(Z3) ~Enable of Z3 row8-15

 NOTE: guessing pin5(KEY_PREV) may work for hysteresis of capacitive sensing.
 NOTE: 1KOhm didn't work as pullup resistor on KEY. AVR internal pullup or 10KOhm resistor was OK.
 NOTE: JP has two HC4051(Z2,Z3) and line 5, 6 and 7 are connected to both of them.

 (HHKB_connector.jpg)


 Keyswitch matrix
 ----------------
 60 keyswitches in 8*8 matrix. It is ghost-free and bounce-free.
 HHKB switch matrix is ghost-free and bounce-free.

 Pro/Pro2(8x8):
 COL 0 1 2 3 4 5 6 7
 ROW ---------------------------------------------------------------
 0| 2 q w s a z x c
@@ -71,8 +75,30 @@ Keyswitch matrix
 7| - + ] [ ' / . _NONE_


 JP(16x8):
 COL 0 1 2 3 4 5 6 7
 ROW ---------------------------------------------------------------
 0| ESC TAB LFn LShift LCtrl
 1| 4 E MuHKN C D
 2| 3 W LAlt X S
 3| 1 HHK
 4| 
 5| 5 R V F
 6| 2 Q LGui Z A
 7| 6 T Space B G
 8| 9 I Kana , K
 9| 8 U Henkan M J
 A| 7 Y N H
 B| 0 O RAlt . L
 C| BS Right RShift Enter
 D| \ [ Down Up ]
 E| - P RFn / ;
 F| ~ @ Left Ro :


 Matrix diagram:

 Pro/Pro2:
 +-------------------------+-+-+-+-+-+-+-+ Vcc
 |bias control? - - - - - - - - ---
 | 3.9K*8 R R R R R R R R |
@@ -89,18 +115,54 @@ Matrix diagram:
 KEY PREV | A B C +-----------------+
 | | +-^----+ | | | | LS145 |
 Vcc | | |BU9831| | | | +-^--^--^--^------+
 --- | | +------+ | | | A B C D +------+
 | | | | | | | | | | | |
 1-3 4 5 6 7 8 9 10 11 12 13-15 |
 +--------------------------------------------------+ |
 | connector | ---
 +--------------------------------------------------+ GND
 to controller
 --- | | +------+ | | | A B C D +-------+
 | | | | | | | | | | | |
 1-3 4 5 6 7 8 9 10 11 12 13-15 Pro |
 1-2 3 4 5 6 7 8 9 10 11 12-13 Pro2|
 +--------------------------------------------------+ |
 | connector | ---
 +--------------------------------------------------+ GND


 JP:
 +-----------------------------+-+-+-+-+ Vcc
 |bias control? - - - - - ---
 | 3.9K*5 R R R R R |
 +--------^+ +--------+ - - - - - | 
 | | | HC4051 <0-----------|-|-|-|-|----|R|-+
 | |capa. | Z2 <1-----------|-|-|-|-|----|R|-+
 | TP1684 |sense | <2-----------|-|-|-|-|----|R|-+
 | <---+--| <3-----------|-|-|-|-|----|R|-+
 | | | | <4-----------|-|-|-|-|----|R|-+
 | | ~En| <5-----------|-|-|-|-|----|R|-+
 | | +----> <6-----------|-|-|-|-|----|R|-+
 | | | | | A B C <7-----------|-|-|-|-|----|R|-+
 +---V---^-+ | | +-^-^-^--+ | | | | | |
 KEY PREV | | | | | | | | | | |
 | | | | +--------+ | | | | | |
 | | | | | HC4051 <8-----------|-|-|-|-|----|R|-+
 | | | | | Z3 <9-----------|-|-|-|-|----|R|-+
 | | | +--| <A-----------|-|-|-|-|----|R|-+
 | | | | <B-----------|-|-|-|-|----|R|-+
 | | | | <C-----------|-|-|-|-|----|R|-+
 | | | ~En| <D-----------|-|-|-|-|----|R|-+
 | | | +-> <E-----------|-|-|-|-|----|R|-+
 | | | | | A B C <F-----------|-|-|-|-|----|R|-+
 | | | | +-^-^-^--+ 0 1 2 3 4 5 6 7 33K*8
 | | | | | | | +-----------------+
 | | | | | | | | LS145 |
 Vcc | | | | | | | +-^--^--^--^------+
 --- | | | | | | | A B C D +-------+
 | | | | | | | | | | | | | |
 1-2 3 4 14 15 5 6 7 8 9 10 11 12-13 |
 +--------------------------------------------------+ |
 | connector | ---
 +--------------------------------------------------+ GND
 

 Signals charts
 --------------
 While pressing space bar, watched HHKB original controller signals by logic analyzer.
 While pressing space bar, watched HHKB Pro original controller signals by logic analyzer.
 Row and column is looping between 0-7 each for selecting a key.
 A key is scaned every about 15ms, so scan rate is 66Hz.

@@ -109,44 +171,32 @@ Signals charts
 Space bar locate at ROW:3 COL:7. A key is selected by HC4051(C,B,A) and LS145(C,B,A).
 Key state can be read on TP1684(4/KEY) while asserting low on LS145(D). 

 Usage of TP1684(5) is not clear. Controller seemed to output previous key state on this line.
 However key state can be read without using this signal.

 (HHKB_chart2.jpg)


 Matrix scan pseudo code
 -----------------------
 for (row: 0-7) {
 SELECT_ROW(row); // set HC4051(A,B,C)

 for (col: 0-7) {
 SELECT_COL(col); // set LS145(A,B,C)

 _delay_us(40);

 if (prev_key_state(row, col)) {
 KEY_PREV_ON;
 }

 _delay_us(7);

 ENALBLE_COL(); // set LS145(D) to low
 Signal of JP:

 _delay_us(10);
 1) Select row
 rowC ____~~~~____~~~~ 3.8/3.8ms(JP) 7.7/7.7ms(Pro) S2 of HC4051
 rowB __~~__~~__~~__~~ 1.9/1.9ms(JP) 3.8/3.8ms(Pro) S1 of HC4051
 rowA _~_~_~_~_~_~_~_~ 1.0/1.0ms(JP) 1.9/1.9ms(Pro) S0 of HC4051
 0123456701234567 selected row(Pro)
 0123456789ABCDEF selected row(JP)
 rowEn0 ________~~~~~~~~ 7.7/7.7ms(JP only) ~Enable of Z2 HC4051(JP only)
 rowEn1 ~~~~~~~~________ 7.7/7.7ms(JP only) ~Enable of Z3 HC4051(JP only)

 if (KEY == 0) { // read TP1684(KEY)
 // key pressed
 } else {
 // not pressed
 }
 2) Select column
 colC ____~~~~____~~~~ 550/410us(JP) / us(Pro)
 colB __~~__~~__~~__~~ 200/210us(JP) 450/460us(Pro)
 colA _~_~_~_~_~_~_~_~ 100/110us(JP) 220/230us(Pro)
 0123456701234567 selected column

 KEY_PREV_OFF;
 UNALBLE_COL(); // set LS145(D) to high
 3) Wait 5us after column select, then set prev, strobe colD to spit out key status and read it.
 prev _~~~~_____ 20us if previous key state is low
 colD ~~~__~~~~~ 10us strobe
 key ~~~____~~~ 22us indicates current state of the key

 _delay_us(150);
 }
 }
 NOTE: JP scans twice fast as Pro/Pro2 does. So Pro/Pro2 scans 8x8 matrix in 15.4ms while JP scans 16x8 in that time.



--- a/keyboard/hhkb/hhkb_avr.h
+++ b/keyboard/hhkb/hhkb_avr.h
@@ -0,0 +1,149 @@
 #ifndef HHKB_AVR_H
 #define HHKB_AVR_H

 #include <stdint.h>
 #include <stdbool.h>
 #include <avr/io.h>
 #include <avr/interrupt.h>
 #include <util/delay.h>


 // Timer resolution check
 #if (1000000/TIMER_RAW_FREQ > 20)
 # error "Timer resolution(>20us) is not enough for HHKB matrix scan tweak on V-USB."
 #endif


 /*
 * HHKB Matrix I/O
 *
 * row: HC4051[A,B,C] selects scan row0-7
 * row-ext: [En0,En1] row extention for JP
 * col: LS145[A,B,C,D] selects scan col0-7 and enable(D)
 * key: on: 0/off: 1
 * prev: hysteresis control: assert(1) when previous key state is on
 */


 #if defined(__AVR_ATmega32U4__)
 /*
 * For TMK HHKB alt controller(ATMega32U4)
 *
 * row: PB0-2
 * col: PB3-5,6
 * key: PD7(pull-uped)
 * prev: PB7
 * power: PD4(L:off/H:on)
 * row-ext: PC6,7 for HHKB JP(active low)
 */
 static inline void KEY_ENABLE(void) { (PORTB &= ~(1<<6)); }
 static inline void KEY_UNABLE(void) { (PORTB |= (1<<6)); }
 static inline bool KEY_STATE(void) { return (PIND & (1<<7)); }
 static inline void KEY_PREV_ON(void) { (PORTB |= (1<<7)); }
 static inline void KEY_PREV_OFF(void) { (PORTB &= ~(1<<7)); }
 static inline void KEY_POWER_ON(void) {}
 static inline void KEY_POWER_OFF(void) {}
 static inline void KEY_INIT(void)
 {
 DDRB = 0xFF;
 PORTB = 0x00;
 DDRD &= ~0x80;
 PORTD |= 0x80;
 /* keyswitch board power on */
 DDRD |= (1<<4);
 PORTD |= (1<<4);
 #ifdef HHKB_JP
 /* row extention for HHKB JP */
 DDRC |= (1<<6|1<<7);
 PORTC |= (1<<6|1<<7);
 #endif
 KEY_UNABLE();
 KEY_PREV_OFF();
 }
 static inline void KEY_SELECT(uint8_t ROW, uint8_t COL)
 {
 PORTB = (PORTB & 0xC0) | (((COL) & 0x07)<<3) | ((ROW) & 0x07);
 #ifdef HHKB_JP
 if ((ROW) & 0x08) PORTC = (PORTC & ~(1<<6|1<<7)) | (1<<6);
 else PORTC = (PORTC & ~(1<<6|1<<7)) | (1<<7);
 #endif
 }


 #elif defined(__AVR_AT90USB1286__)
 /*
 * For Teensy++(AT90USB1286)
 *
 * HHKB pro HHKB pro2
 * row: PB0-2 (6-8) (5-7)
 * col: PB3-5,6 (9-12) (8-11)
 * key: PE6(pull-uped) (4) (3)
 * prev: PE7 (5) (4)
 *
 * TODO: convert into 'staitc inline' function
 */
 #define KEY_INIT() do { \
 DDRB |= 0x7F; \
 DDRE |= (1<<7); \
 DDRE &= ~(1<<6); \
 PORTE |= (1<<6); \
 } while (0)
 #define KEY_SELECT(ROW, COL) (PORTB = (PORTB & 0xC0) | \
 (((COL) & 0x07)<<3) | \
 ((ROW) & 0x07))
 #define KEY_ENABLE() (PORTB &= ~(1<<6))
 #define KEY_UNABLE() (PORTB |= (1<<6))
 #define KEY_STATE() (PINE & (1<<6))
 #define KEY_PREV_ON() (PORTE |= (1<<7))
 #define KEY_PREV_OFF() (PORTE &= ~(1<<7))
 #define KEY_POWER_ON()
 #define KEY_POWER_OFF()


 #else
 # error "define code for matrix scan"
 #endif


 #if 0
 // For ATMega328P with V-USB
 //
 // #elif defined(__AVR_ATmega328P__)
 // Ports for V-USB
 // key: PB0(pull-uped)
 // prev: PB1
 // row: PB2-4
 // col: PC0-2,3
 // power: PB5(Low:on/Hi-z:off)
 #define KEY_INIT() do { \
 DDRB |= 0x3E; \
 DDRB &= ~(1<<0); \
 PORTB |= 1<<0; \
 DDRC |= 0x0F; \
 KEY_UNABLE(); \
 KEY_PREV_OFF(); \
 } while (0)
 #define KEY_SELECT(ROW, COL) do { \
 PORTB = (PORTB & 0xE3) | ((ROW) & 0x07)<<2; \
 PORTC = (PORTC & 0xF8) | ((COL) & 0x07); \
 } while (0)
 #define KEY_ENABLE() (PORTC &= ~(1<<3))
 #define KEY_UNABLE() (PORTC |= (1<<3))
 #define KEY_STATE() (PINB & (1<<0))
 #define KEY_PREV_ON() (PORTB |= (1<<1))
 #define KEY_PREV_OFF() (PORTB &= ~(1<<1))
 // Power supply switching
 #define KEY_POWER_ON() do { \
 KEY_INIT(); \
 PORTB &= ~(1<<5); \
 _delay_ms(1); \
 } while (0)
 #define KEY_POWER_OFF() do { \
 DDRB &= ~0x3F; \
 PORTB &= ~0x3F; \
 DDRC &= ~0x0F; \
 PORTC &= ~0x0F; \
 } while (0)
 #endif

 #endif
--- a/keyboard/hhkb/keymap_common.h
+++ b/keyboard/hhkb/keymap_common.h
@@ -54,4 +54,31 @@ extern const uint16_t fn_actions[];
 { KC_##K70, KC_##K71, KC_##K72, KC_##K73, KC_##K74, KC_##K75, KC_##K76, KC_NO } \
 }


 #define KEYMAP_JP( \
 K02, K32, K62, K22, K12, K52, K72, KA2, K92, K82, KB2, KE2, KF2, KD2, KC2, \
 K03, K63, K23, K13, K53, K73, KA3, K93, K83, KB3, KE3, KF3, KD3, \
 K06, K66, K26, K16, K56, K76, KA6, K96, K86, KB6, KE6, KF6, KD6, KC6, \
 K05, K65, K25, K15, K55, K75, KA5, K95, K85, KB5, KE5, KF5, KD5, KC5, \
 K04, K34, K64, K24, K14, K74, K94, K84, KB4, KE4, KF4, KD4, KC4 \
 ) \
 { \
 { KC_NO, KC_NO, KC_##K02, KC_##K03, KC_##K04, KC_##K05, KC_##K06, KC_NO }, \
 { KC_NO, KC_NO, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_NO }, \
 { KC_NO, KC_NO, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_NO }, \
 { KC_NO, KC_NO, KC_##K32, KC_NO, KC_##K34, KC_NO, KC_NO, KC_NO }, \
 { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \
 { KC_NO, KC_NO, KC_##K52, KC_##K53, KC_NO, KC_##K55, KC_##K56, KC_NO }, \
 { KC_NO, KC_NO, KC_##K62, KC_##K63, KC_##K64, KC_##K65, KC_##K66, KC_NO }, \
 { KC_NO, KC_NO, KC_##K72, KC_##K73, KC_##K74, KC_##K75, KC_##K76, KC_NO }, \
 { KC_NO, KC_NO, KC_##K82, KC_##K83, KC_##K84, KC_##K85, KC_##K86, KC_NO }, \
 { KC_NO, KC_NO, KC_##K92, KC_##K93, KC_##K94, KC_##K95, KC_##K96, KC_NO }, \
 { KC_NO, KC_NO, KC_##KA2, KC_##KA3, KC_NO, KC_##KA5, KC_##KA6, KC_NO }, \
 { KC_NO, KC_NO, KC_##KB2, KC_##KB3, KC_##KB4, KC_##KB5, KC_##KB6, KC_NO }, \
 { KC_NO, KC_NO, KC_##KC2, KC_NO, KC_##KC4, KC_##KC5, KC_##KC6, KC_NO }, \
 { KC_NO, KC_NO, KC_##KD2, KC_##KD3, KC_##KD4, KC_##KD5, KC_##KD6, KC_NO }, \
 { KC_NO, KC_NO, KC_##KE2, KC_##KE3, KC_##KE4, KC_##KE5, KC_##KE6, KC_NO }, \
 { KC_NO, KC_NO, KC_##KF2, KC_##KF3, KC_##KF4, KC_##KF5, KC_##KF6, KC_NO } \
 }

 #endif
--- a/keyboard/hhkb/keymap_hasu.c
+++ b/keyboard/hhkb/keymap_hasu.c
@@ -15,20 +15,21 @@ const uint8_t keymaps[][MATRIX_ROWS][MATRIX_COLS] PROGMEM = {
 * |-----------------------------------------------------------|
 * |Tab | Q| W| E| R| T| Y| U| I| O| P| [| ]|Backs|
 * |-----------------------------------------------------------|
 * |Contro| A| S| D| F| G| H| J| K| L|Fn3| '|Fn4 |
 * |Contro| A| S| D| F| G| H| J| K| L|Fn3| '|Fn6 |
 * |-----------------------------------------------------------|
 * |Fn5 | Z| X| C| V| B| N| M| ,| .|Fn2|Shift |Fn1|
 * |Fn7 | Z| X| C| V| B| N| M| ,| .|Fn2|Shift |Fn1|
 * `-----------------------------------------------------------'
 * |Gui|Alt | Fn6 |Alt |Fn7|
 * |Gui|Alt | Fn4 |Fn5 |Gui|
 * `-------------------------------------------'
 */
 [0] = \
 KEYMAP(ESC, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSLS,GRV, \
 TAB, Q, W, E, R, T, Y, U, I, O, P, LBRC,RBRC,BSPC, \
 LCTL,A, S, D, F, G, H, J, K, L, FN3, QUOT,FN4, \
 FN11,Z, X, C, V, B, N, M, COMM,DOT, FN2, RSFT,FN1, \
 LGUI,LALT, FN6, RALT,RGUI),
 LCTL,A, S, D, F, G, H, J, K, L, FN3, QUOT,FN6, \
 FN7, Z, X, C, V, B, N, M, COMM,DOT, FN2, RSFT,FN1, \
 LGUI,LALT, FN4, FN5, RGUI),

 /* Layer 1: HHKB mode (HHKB Fn)
 /* Layer 1: HHKB mode[HHKB Fn]
 * ,-----------------------------------------------------------.
 * |Esc| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12|Ins|Del|
 * |-----------------------------------------------------------|
@@ -41,13 +42,14 @@ const uint8_t keymaps[][MATRIX_ROWS][MATRIX_COLS] PROGMEM = {
 * |Gui|Alt | Space |Alt |Gui|
 * `-------------------------------------------'
 */ 
 [1] = \
 KEYMAP(GRV, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, INS, DEL, \
 CAPS,NO, NO, NO, NO, NO, NO, NO, PSCR,SLCK,PAUS, UP, NO, BSPC, \
 LCTL,VOLD,VOLU,MUTE,NO, FN9, PAST,PSLS,HOME,PGUP,LEFT,RGHT,ENT, \
 LCTL,VOLD,VOLU,MUTE,NO, NO,  PAST,PSLS,HOME,PGUP,LEFT,RGHT,ENT, \
 LSFT,NO, NO, NO, NO, NO, PPLS,PMNS,END, PGDN,DOWN,RSFT,TRNS, \
 LGUI,LALT, SPC, RALT,RGUI),

 /* Layer 2: Vi mode (Slash)
 /* Layer 2: Vi mode[Slash]
 * ,-----------------------------------------------------------.
 * |Esc| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12|Ins|Del|
 * |-----------------------------------------------------------|
@@ -60,13 +62,57 @@ const uint8_t keymaps[][MATRIX_ROWS][MATRIX_COLS] PROGMEM = {
 * |Gui|Alt | Space |Alt |Gui|
 * `-------------------------------------------'
 */
 [2] = \
 KEYMAP(GRV, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, INS, DEL, \
 TAB, HOME,PGDN,UP, PGUP,END, HOME,PGDN,PGUP,END, NO, NO, NO, BSPC, \
 LCTL,NO, LEFT,DOWN,RGHT,NO, LEFT,DOWN,UP, RGHT,NO, NO, ENT, \
 LSFT,NO, NO, NO, NO, NO, HOME,PGDN,PGUP,END, TRNS,RSFT,NO, \
 LGUI,LALT, SPC, RALT,RGUI),

 /* Layer 3: Mouse mode (Semicolon)
 /* Layer 3: Mouse mode(IJKL)[Semicolon]
 * ,-----------------------------------------------------------.
 * |Esc| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12|Ins|Del|
 * |-----------------------------------------------------------|
 * |Tab | | | | | |MwL|MwD|McU|MwU|MwR|Wbk|Wfr|Alt-T|
 * |-----------------------------------------------------------|
 * |Contro| | | | | |Mb2|McL|McD|McR|Fn | |Return |
 * |-----------------------------------------------------------|
 * |Shift | | | | |Mb3|Mb2|Mb1|Mb4|Mb5| |Shift | |
 * `-----------------------------------------------------------'
 * |Gui |Alt | Mb1 |Fn |Fn |
 * `--------------------------------------------'
 * Mc: Mouse Cursor / Mb: Mouse Button / Mw: Mouse Wheel8
 */
 [3] = \
 KEYMAP(GRV, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, INS, DEL, \
 FN8, NO, NO, NO, NO, NO, WH_L,WH_D,MS_U,WH_U,WH_R,WBAK,WFWD,FN8, \
 LCTL,ACL0,ACL1,ACL2,ACL2,NO, NO, MS_L,MS_D,MS_R,TRNS,NO, ENT, \
 LSFT,NO, NO, NO, NO, BTN3,BTN2,BTN1,BTN4,BTN5,NO, RSFT,NO, \
 LGUI,LALT, BTN1, TRNS,TRNS),

 /* Layer 5: Mouse mode(IJKL)[Space]
 * ,-----------------------------------------------------------.
 * |Esc| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12|Ins|Del|
 * |-----------------------------------------------------------|
 * |Tab | | | | | |MwL|MwD|McU|MwU|MwR|Wbk|Wfr|Alt-T|
 * |-----------------------------------------------------------|
 * |Contro| | | | | |Mb2|McL|McD|McR|Mb1| |Return |
 * |-----------------------------------------------------------|
 * |Shift | | | | |Mb3|Mb2|Mb1|Mb4|Mb5| |Shift | |
 * `-----------------------------------------------------------'
 * |Gui |Alt | Mb1 |Fn |Fn |
 * `--------------------------------------------'
 * Mc: Mouse Cursor / Mb: Mouse Button / Mw: Mouse Wheel8
 */
 [4] = \
 KEYMAP(GRV, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, INS, DEL, \
 FN8, NO, NO, NO, NO, NO, WH_L,WH_D,MS_U,WH_U,WH_R,WBAK,WFWD,FN8, \
 LCTL,VOLD,VOLU,MUTE,NO, NO, NO, MS_L,MS_D,MS_R,BTN1,NO, ENT, \
 LSFT,NO, NO, NO, NO, BTN3,BTN2,BTN1,BTN4,BTN5,NO, RSFT,NO, \
 LGUI,LALT, TRNS, TRNS,TRNS),

 #if 0
 /* Layer 3: Mouse mode(HJKL)[Semicolon]
 * ,-----------------------------------------------------------.
 * |Esc| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12|Ins|Del|
 * |-----------------------------------------------------------|
@@ -86,7 +132,28 @@ const uint8_t keymaps[][MATRIX_ROWS][MATRIX_COLS] PROGMEM = {
 LSFT,NO, NO, NO, NO, BTN3,BTN2,BTN1,BTN4,BTN5,SLSH,RSFT,NO, \
 LGUI,LALT, BTN1, RALT,TRNS),

 /* Layer 4: Matias half-qwerty keyboard style (Space)
 /* Layer4: Mouse mode(HJKL)[Space]
 * ,-----------------------------------------------------------.
 * |Esc| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12|Ins|Del|
 * |-----------------------------------------------------------|
 * |Tab | | | | | |MwL|MwD|MwU|MwR| |Wbk|Wfr|Alt-T|
 * |-----------------------------------------------------------|
 * |Contro| | | | | |McL|McD|McU|McR|Fn0| |Return |
 * |-----------------------------------------------------------|
 * |Shift | | | | |Mb3|Mb2|Mb1|Mb4|Mb5| |Shift | |
 * `-----------------------------------------------------------'
 * |Gui |Alt | Fn0 |Alt |Fn0|
 * `--------------------------------------------'
 * Mc: Mouse Cursor / Mb: Mouse Button / Mw: Mouse Wheel 
 */
 KEYMAP(GRV, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, INS, DEL, \
 FN8, NO, NO, NO, NO, NO, WH_L,WH_D,WH_U,WH_R,NO, WBAK,WFWD,FN8, \
 LCTL,NO, ACL0,ACL1,ACL2,NO, MS_L,MS_D,MS_U,MS_R,BTN1,NO, ENT, \
 LSFT,NO, NO, NO, NO, BTN3,BTN2,BTN1,BTN4,BTN5,NO, RSFT,NO, \
 LGUI,LALT, TRNS, RALT,RGUI),
 #endif
 #if 0
 /* Layer x: Matias half-qwerty keyboard style[Space]
 * ,-----------------------------------------------------------.
 * | -| 0| 9| 8| 7| 6| 5| 4| 3| 2| 1| | | |Esc|
 * |-----------------------------------------------------------|
@@ -104,26 +171,7 @@ const uint8_t keymaps[][MATRIX_ROWS][MATRIX_COLS] PROGMEM = {
 LCTL,SCLN,L, K, J, H, G, F, D, S, A, RCTL,RCTL, \
 LSFT,SLSH,DOT, COMM,M, N, B, V, C, X, Z, RSFT,NO, \
 LGUI,LALT, TRNS, RALT,RGUI),

 /* Layer5: another Mouse mode (Space)
 * ,-----------------------------------------------------------.
 * |Esc| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12|Ins|Del|
 * |-----------------------------------------------------------|
 * |Tab | | | | | |MwL|MwD|MwU|MwR| |Wbk|Wfr|Close|
 * |-----------------------------------------------------------|
 * |Contro| | | | | |McL|McD|McU|McR|Fn0| |Return |
 * |-----------------------------------------------------------|
 * |Shift | | | | |Mb3|Mb2|Mb1|Mb4|Mb5| |Shift | |
 * `-----------------------------------------------------------'
 * |Gui |Alt | Fn0 |Alt |Fn0|
 * `--------------------------------------------'
 * Mc: Mouse Cursor / Mb: Mouse Button / Mw: Mouse Wheel 
 */
 KEYMAP(ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, INS, DEL, \
 TAB, NO, NO, NO, NO, NO, WH_L,WH_D,WH_U,WH_R,WSTP,WBAK,WFWD,FN8, \
 LCTL,NO, ACL0,ACL1,ACL2,NO, MS_L,MS_D,MS_U,MS_R,NO, NO, ENT, \
 LSFT,NO, NO, NO, NO, BTN3,BTN2,BTN1,BTN4,BTN5,NO, RSFT,NO, \
 LGUI,LALT, TRNS, RALT,RGUI),
 #endif
 };


@@ -136,6 +184,7 @@ enum function_id {
 enum macro_id {
 HELLO,
 VOLUP,
 ALT_TAB,
 };


@@ -151,18 +200,17 @@ const uint16_t fn_actions[] PROGMEM = {
 [1] = ACTION_LAYER_TAP_TOGGLE(1), // HHKB layer(toggle with 5 taps)
 [2] = ACTION_LAYER_TAP_KEY(2, KC_SLASH), // Cursor layer with Slash*
 [3] = ACTION_LAYER_TAP_KEY(3, KC_SCLN), // Mousekey layer with Semicolon*
 [4] = ACTION_MODS_TAP_KEY(MOD_RCTL, KC_ENT), // RControl with tap Enter*
 [5] = ACTION_MODS_ONESHOT(MOD_LSFT), // Oneshot Shift*
 [6] = ACTION_LAYER_TAP_KEY(5, KC_SPC), // Mousekey layer with Space
 [7] = ACTION_LAYER_TOGGLE(3), // Mousekey layer(toggle)
 [8] = ACTION_MODS_KEY(MOD_LCTL, KC_W), // Close Tab
 [9] = ACTION_MODS_KEY(MOD_LSFT, KC_4), // Shift stuck test

 // [8] = ACTION_LMOD_TAP_KEY(KC_LCTL, KC_BSPC), // LControl with tap Backspace
 // [9] = ACTION_LMOD_TAP_KEY(KC_LCTL, KC_ESC), // LControl with tap Esc
 [11] = ACTION_FUNCTION_TAP(LSHIFT_LPAREN), // Function: LShift with tap '('
 // [15] = ACTION_MACRO(HELLO), // Macro: say hello
 // [9] = ACTION_MACRO(VOLUP), // Macro: media key
 [4] = ACTION_LAYER_TAP_KEY(4, KC_SPC), // Mousekey layer with Space
 [5] = ACTION_LAYER_MOMENTARY(4), // Mousekey layer(IJKL)
 [6] = ACTION_MODS_TAP_KEY(MOD_RCTL, KC_ENT), // RControl with tap Enter
 [7] = ACTION_MODS_ONESHOT(MOD_LSFT), // Oneshot Shift
 [8] = ACTION_MACRO(ALT_TAB), // Application switching

 // [x] = ACTION_LMOD_TAP_KEY(KC_LCTL, KC_BSPC), // LControl with tap Backspace
 // [x] = ACTION_LMOD_TAP_KEY(KC_LCTL, KC_ESC), // LControl with tap Esc
 // [x] = ACTION_FUNCTION_TAP(LSHIFT_LPAREN), // Function: LShift with tap '('
 // [x] = ACTION_MACRO(HELLO), // Macro: say hello
 // [x] = ACTION_MACRO(VOLUP), // Macro: media key
 };


@@ -180,6 +228,10 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
 return (record->event.pressed ?
 MACRO( D(VOLU), U(VOLU), END ) :
 MACRO_NONE );
 case ALT_TAB:
 return (record->event.pressed ?
 MACRO( D(LALT), D(TAB), END ) :
 MACRO( U(TAB), END ));
 }
 return MACRO_NONE;
 }
--- a/keyboard/hhkb/keymap_jp.c
+++ b/keyboard/hhkb/keymap_jp.c
@@ -0,0 +1,50 @@
 /* 
 * HHKB JP Layout
 */
 #include "keymap_common.h"


 #ifdef KEYMAP_SECTION_ENABLE
 const uint8_t keymaps[][MATRIX_ROWS][MATRIX_COLS] __attribute__ ((section (".keymap.keymaps"))) = {
 #else
 const uint8_t keymaps[][MATRIX_ROWS][MATRIX_COLS] PROGMEM = {
 #endif
 /* Layer 0: Default Layer */
 KEYMAP_JP(ESC, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, JYEN,BSPC, \
 TAB, Q, W, E, R, T, Y, U, I, O, P, LBRC,RBRC, \
 LCTL,A, S, D, F, G, H, J, K, L, SCLN,QUOT,BSLS,ENT, \
 LSFT,Z, X, C, V, B, N, M, COMM,DOT, SLSH,RO, UP, RSFT, \
 FN0, ZKHK,LGUI,LALT,MHEN, SPC, HENK,KANA,RALT,FN0, LEFT,DOWN,RGHT),

 /* Layer 1: HHKB mode (HHKB Fn)
 * ,-----------------------------------------------------------.
 * |Pwr| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12|Ins|Del|
 * |-----------------------------------------------------------|
 * |Caps | | | | | | | |Psc|Slk|Pus|Up | | |
 * |------------------------------------------------------` |
 * | |VoD|VoU|Mut| | | *| /|Hom|PgU|Lef|Rig| | |
 * |-----------------------------------------------------------|
 * | | | | | | | +| -|End|PgD|Dow| | | |
 * |-----------------------------------------------------------|
 * | || | | | | | | | | || | | |
 * `-----------------------------------------------------------'
 */ 
 KEYMAP_JP(PWR, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, INS, DEL, \
 CAPS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,PSCR,SLCK,PAUS, UP, TRNS, \
 TRNS,VOLD,VOLU,MUTE,TRNS,TRNS,PAST,PSLS,HOME,PGUP,LEFT,RGHT,TRNS,PENT, \
 TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,PPLS,PMNS,END, PGDN,DOWN,TRNS,TRNS,TRNS, \
 TRNS,TRNS,TRNS,TRNS,TRNS, TRNS, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS),
 };



 /*
 * Fn action definition
 */
 #ifdef KEYMAP_SECTION_ENABLE
 const uint16_t fn_actions[] __attribute__ ((section (".keymap.fn_actions"))) = {
 #else
 const uint16_t fn_actions[] PROGMEM = {
 #endif
 [0] = ACTION_LAYER_MOMENTARY(1),
 };
--- a/keyboard/hhkb/keymap_spacefn.c
+++ b/keyboard/hhkb/keymap_spacefn.c
@@ -58,12 +58,53 @@ const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 * `-------------------------------------------'
 */
 KEYMAP(GRV, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, TRNS,DEL, \
 TRNS,TRNS,TRNS,ESC, TRNS,TRNS,TRNS,HOME,UP,  END, PSCR,SLCK,PAUS,INS, \
 TRNS,TRNS,TRNS,ESC, TRNS,TRNS,TRNS,HOME,FN3, END, PSCR,SLCK,PAUS,INS, \
 TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,PGUP,LEFT,DOWN,RGHT,TRNS,TRNS,TRNS, \
 TRNS,TRNS,TRNS,TRNS,TRNS,SPC, PGDN,GRV, FN2, TRNS,TRNS,TRNS,NO, \
 TRNS,TRNS, TRNS, TRNS,TRNS),
 };


 /*
 * user defined action function
 */
 enum function_id {
 CTRL_SPACE_I, // Ctrl + Up(SpaceFN) -> PgUp
 };

 void action_function(keyrecord_t *record, uint8_t id, uint8_t opt)
 {
 # define MODS_CTRL_MASK (MOD_BIT(KC_LCTRL)|MOD_BIT(KC_RCTRL))
 static uint8_t ctrl_space_i_prev_ctrl;

 switch (id) {
 // Ctrl + Up(SpaceFN) -> PgUp
 case CTRL_SPACE_I:
 ctrl_space_i_prev_ctrl = get_mods()&MODS_CTRL_MASK;
 if (record->event.pressed) {
 if (ctrl_space_i_prev_ctrl) {
 del_mods(ctrl_space_i_prev_ctrl); // remove Ctrl
 add_key(KC_PGUP);
 send_keyboard_report(); // send PgUp without Ctrl
 add_mods(ctrl_space_i_prev_ctrl); // return Ctrl but not sent
 } else {
 add_key(KC_UP);
 send_keyboard_report();
 }
 } else {
 if (ctrl_space_i_prev_ctrl) {
 del_key(KC_PGUP);
 send_keyboard_report();
 } else {
 del_key(KC_UP);
 send_keyboard_report();
 }
 }
 break;
 }
 }


 /*
 * Fn action definition
 */
@@ -71,5 +112,5 @@ const uint16_t PROGMEM fn_actions[] = {
 [0] = ACTION_LAYER_MOMENTARY(1),
 [1] = ACTION_LAYER_TAP_KEY(2, KC_SPACE),
 [2] = ACTION_MODS_KEY(MOD_LSFT, KC_GRV), // tilde
 [3] = ACTION_FUNCTION(CTRL_SPACE_I), // Ctrl + Up(SpaceFN) -> PgUp
 };

--- a/keyboard/hhkb/matrix.c
+++ b/keyboard/hhkb/matrix.c
@@ -20,20 +20,13 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 #include <stdint.h>
 #include <stdbool.h>
 #include <avr/io.h>
 #include <avr/interrupt.h>
 #include <util/delay.h>
 #include "print.h"
 #include "debug.h"
 #include "util.h"
 #include "timer.h"
 #include "matrix.h"


 // Timer resolution check
 #if (1000000/TIMER_RAW_FREQ > 20)
 # error "Timer resolution(>20us) is not enough for HHKB matrix scan tweak on V-USB."
 #endif
 #include "hhkb_avr.h"


 // matrix state buffer(1:on, 0:off)
@@ -43,122 +36,6 @@ static matrix_row_t _matrix0[MATRIX_ROWS];
 static matrix_row_t _matrix1[MATRIX_ROWS];


 // Matrix I/O ports
 //
 // row: HC4051[A,B,C] selects scan row0-7
 // col: LS145[A,B,C,D] selects scan col0-7 and enable(D)
 // key: on: 0/off: 1
 // prev: unknown: output previous key state(negated)?

 #if defined(__AVR_AT90USB1286__)
 // Ports for Teensy++
 // row: PB0-2
 // col: PB3-5,6
 // key: PE6(pull-uped)
 // prev: PE7
 #define KEY_INIT() do { \
 DDRB |= 0x7F; \
 DDRE |= (1<<7); \
 DDRE &= ~(1<<6); \
 PORTE |= (1<<6); \
 } while (0)
 #define KEY_SELECT(ROW, COL) (PORTB = (PORTB & 0xC0) | \
 (((COL) & 0x07)<<3) | \
 ((ROW) & 0x07))
 #define KEY_ENABLE() (PORTB &= ~(1<<6))
 #define KEY_UNABLE() (PORTB |= (1<<6))
 #define KEY_STATE() (PINE & (1<<6))
 #define KEY_PREV_ON() (PORTE |= (1<<7))
 #define KEY_PREV_OFF() (PORTE &= ~(1<<7))
 #define KEY_POWER_ON()
 #define KEY_POWER_OFF()

 #elif defined(__AVR_ATmega32U4__)
 // Ports for my designed Alt Controller PCB
 // row: PB0-2
 // col: PB3-5,6
 // key: PD7(pull-uped)
 // prev: PB7
 // power: PD4(L:off/H:on)
 #define KEY_INIT() do { \
 DDRB = 0xFF; \
 PORTB = 0x00; \
 DDRD &= ~0x80; \
 PORTD |= 0x80; \
 /* keyswitch board power on */ \
 DDRD |= (1<<4); \
 PORTD |= (1<<4); \
 KEY_UNABLE(); \
 KEY_PREV_OFF(); \
 } while (0)
 #define KEY_SELECT(ROW, COL) (PORTB = (PORTB & 0xC0) | \
 (((COL) & 0x07)<<3) | \
 ((ROW) & 0x07))
 #define KEY_ENABLE() (PORTB &= ~(1<<6))
 #define KEY_UNABLE() (PORTB |= (1<<6))
 #define KEY_STATE() (PIND & (1<<7))
 #define KEY_PREV_ON() (PORTB |= (1<<7))
 #define KEY_PREV_OFF() (PORTB &= ~(1<<7))
 #define KEY_POWER_ON()
 #define KEY_POWER_OFF()
 /*
 #define KEY_POWER_ON() do { \
 KEY_INIT(); \
 PORTD |= (1<<4); \
 _delay_ms(1); \
 } while (0)
 #define KEY_POWER_OFF() do { \
 PORTD &= ~(1<<4); \
 DDRB &= ~0xFF; \
 PORTB &= ~0xFF; \
 DDRB &= ~0x80; \
 PORTB &= ~0x80; \
 } while (0)
 */


 #elif defined(__AVR_ATmega328P__)
 // Ports for V-USB
 // key: PB0(pull-uped)
 // prev: PB1
 // row: PB2-4
 // col: PC0-2,3
 // power: PB5(Low:on/Hi-z:off)
 #define KEY_INIT() do { \
 DDRB |= 0x3E; \
 DDRB &= ~(1<<0); \
 PORTB |= 1<<0; \
 DDRC |= 0x0F; \
 KEY_UNABLE(); \
 KEY_PREV_OFF(); \
 } while (0)
 #define KEY_SELECT(ROW, COL) do { \
 PORTB = (PORTB & 0xE3) | ((ROW) & 0x07)<<2; \
 PORTC = (PORTC & 0xF8) | ((COL) & 0x07); \
 } while (0)
 #define KEY_ENABLE() (PORTC &= ~(1<<3))
 #define KEY_UNABLE() (PORTC |= (1<<3))
 #define KEY_STATE() (PINB & (1<<0))
 #define KEY_PREV_ON() (PORTB |= (1<<1))
 #define KEY_PREV_OFF() (PORTB &= ~(1<<1))
 // Power supply switching
 #define KEY_POWER_ON() do { \
 KEY_INIT(); \
 PORTB &= ~(1<<5); \
 _delay_ms(1); \
 } while (0)
 #define KEY_POWER_OFF() do { \
 DDRB &= ~0x3F; \
 PORTB &= ~0x3F; \
 DDRC &= ~0x0F; \
 PORTC &= ~0x0F; \
 } while (0)

 #else
 # error "define code for matrix scan"
 #endif


 inline
 uint8_t matrix_rows(void)
 {
@@ -199,13 +76,13 @@ uint8_t matrix_scan(void)
 for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
 for (uint8_t col = 0; col < MATRIX_COLS; col++) {
 KEY_SELECT(row, col);
 _delay_us(40);
 _delay_us(5);

 // Not sure this is needed. This just emulates HHKB controller's behaviour.
 if (matrix_prev[row] & (1<<col)) {
 KEY_PREV_ON();
 }
 _delay_us(7);
 _delay_us(10);

 // NOTE: KEY_STATE is valid only in 20us after KEY_ENABLE.
 // If V-USB interrupts in this section we could lose 40us or so
@@ -241,11 +118,13 @@ uint8_t matrix_scan(void)
 matrix[row] = matrix_prev[row];
 }

 _delay_us(5);
 KEY_PREV_OFF();
 KEY_UNABLE();

 // NOTE: KEY_STATE keep its state in 20us after KEY_ENABLE.
 // This takes 25us or more to make sure KEY_STATE returns to idle state.
 _delay_us(150);
 _delay_us(75);
 }
 }
 KEY_POWER_OFF();
--- a/keyboard/kitten_paw/Makefile.lufa
+++ b/keyboard/kitten_paw/Makefile.lufa
@@ -0,0 +1,117 @@
 #----------------------------------------------------------------------------
 # On command line:
 #
 # make all = Make software.
 #
 # make clean = Clean out built project files.
 #
 # make coff = Convert ELF to AVR COFF.
 #
 # make extcoff = Convert ELF to AVR Extended COFF.
 #
 # make program = Download the hex file to the device.
 # Please customize your programmer settings(PROGRAM_CMD)
 #
 # make teensy = Download the hex file to the device, using teensy_loader_cli.
 # (must have teensy_loader_cli installed).
 #
 # make dfu = Download the hex file to the device, using dfu-programmer (must
 # have dfu-programmer installed).
 #
 # make flip = Download the hex file to the device, using Atmel FLIP (must
 # have Atmel FLIP installed).
 #
 # make dfu-ee = Download the eeprom file to the device, using dfu-programmer
 # (must have dfu-programmer installed).
 #
 # make flip-ee = Download the eeprom file to the device, using Atmel FLIP
 # (must have Atmel FLIP installed).
 #
 # make debug = Start either simulavr or avarice as specified for debugging, 
 # with avr-gdb or avr-insight as the front end for debugging.
 #
 # make filename.s = Just compile filename.c into the assembler code only.
 #
 # make filename.i = Create a preprocessed source file for use in submitting
 # bug reports to the GCC project.
 #
 # To rebuild project do "make clean" then "make all".
 #----------------------------------------------------------------------------

 # Target file name (without extension).
 TARGET = kittenpaw_lufa

 # Directory common source filess exist
 TOP_DIR = ../..

 # Directory keyboard dependent files exist
 TARGET_DIR = .

 # List C source files here. (C dependencies are automatically generated.)
 SRC = keymap.c \
 matrix.c \
 led.c

 CONFIG_H = config.h

 # MCU name
 MCU = atmega32u2

 # Processor frequency.
 # This will define a symbol, F_CPU, in all source code files equal to the
 # processor frequency in Hz. You can then use this symbol in your source code to
 # calculate timings. Do NOT tack on a 'UL' at the end, this will be done
 # automatically to create a 32-bit value in your source code.
 #
 # This will be an integer division of F_USB below, as it is sourced by
 # F_USB after it has run through any CPU prescalers. Note that this value
 # does not *change* the processor frequency - it should merely be updated to
 # reflect the processor speed set externally so that the code can use accurate
 # software delays.
 F_CPU = 16000000

 #
 # LUFA specific
 #
 # Target architecture (see library "Board Types" documentation).
 ARCH = AVR8

 # Input clock frequency.
 # This will define a symbol, F_USB, in all source code files equal to the
 # input clock frequency (before any prescaling is performed) in Hz. This value may
 # differ from F_CPU if prescaling is used on the latter, and is required as the
 # raw input clock is fed directly to the PLL sections of the AVR for high speed
 # clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
 # at the end, this will be done automatically to create a 32-bit value in your
 # source code.
 #
 # If no clock division is performed on the input clock inside the AVR (via the
 # CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
 F_USB = $(F_CPU)


 # Build Options
 # comment out to disable the options.
 #
 #BOOTMAGIC_ENABLE = yes # Virtual DIP switch configuration(+1000)
 MOUSEKEY_ENABLE = yes # Mouse keys(+4700)
 EXTRAKEY_ENABLE = yes # Audio control and System control(+450)
 #CONSOLE_ENABLE = yes # Console for debug(+400)
 COMMAND_ENABLE = yes # Commands for debug and configuration
 #SLEEP_LED_ENABLE = yes # Breathing sleep LED during USB suspend
 #NKRO_ENABLE = yes # USB Nkey Rollover - not yet supported in LUFA


 # Boot Section Size in bytes
 # Teensy halfKay 512
 # Atmel DFU loader 4096
 # LUFA bootloader 4096
 OPT_DEFS += -DBOOTLOADER_SIZE=4096

 # Search Path
 VPATH += $(TARGET_DIR)
 VPATH += $(TOP_DIR)

 include $(TOP_DIR)/protocol/lufa.mk
 include $(TOP_DIR)/common.mk
 include $(TOP_DIR)/rules.mk
--- a/keyboard/kitten_paw/README.md
+++ b/keyboard/kitten_paw/README.md
@@ -0,0 +1,20 @@
 Kitten Paw controller firmware
 ======================
 Custom controller for the Costar Majestouch keyboard designed by bpiphany.

 *Note that this is not the official firmware*

 Build
 -----
 Move to this directory then just run `make` like:

 $ make -f Makefile.lufa

 At the moment only the LUFA stack is supported.


 Bootloader
 ---------
 To enter bootloader by hardware use a magnet above the controller before connecting the usb cable.

 It is still possible to use Boot Magic and Command (LSFT+RSFT+PAUS) to access the bootloader though.
--- a/keyboard/kitten_paw/config.h
+++ b/keyboard/kitten_paw/config.h
@@ -0,0 +1,43 @@
 /*
 Copyright 2014 Ralf Schmitt <[email protected]>

 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

 /* USB Device descriptor parameter */
 #define VENDOR_ID 0xFEED
 #define PRODUCT_ID 0x6050
 #define DEVICE_VER 0x0104
 #define MANUFACTURER Costar
 #define PRODUCT Majestouch

 /* message strings */
 #define DESCRIPTION t.m.k. keyboard firmware for Majestouch

 /* matrix size */
 #define MATRIX_ROWS 8
 #define MATRIX_COLS 18

 /* Set 0 if need no debouncing */
 #define DEBOUNCE 5

 /* key combination for command */
 #define IS_COMMAND() ( \
 keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
 )

 #endif
--- a/keyboard/kitten_paw/keymap.c
+++ b/keyboard/kitten_paw/keymap.c
@@ -0,0 +1,102 @@
 /*
 Copyright 2014 Ralf Schmitt <[email protected]>

 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 <stdint.h>
 #include <stdbool.h>
 #include <avr/pgmspace.h>
 #include "keycode.h"
 #include "action.h"
 #include "action_macro.h"
 #include "report.h"
 #include "host.h"
 #include "debug.h"
 #include "keymap.h"

 /*
 Matrix col/row mapping

 ,----. ,-------------------. ,-------------------. ,-------------------. ,--------------.
 |06/6| |07/4|08/4|08/2|08/6| |15/5|11/6|12/2|12/4| |14/4|14/5|14/6|14/0| |13/5|13/7|15/7|
 `----' `-------------------' `-------------------' `-------------------' `--------------'
 ,-------------------------------------------------------------------------. ,--------------. ,-------------------.
 |06/4|06/5|07/5|08/5|09/5|09/4|10/4|10/5|11/5|12/5|05/5|05/4|11/4| 14/2| |17/4|02/4|04/4| |16/1|17/1|04/1|04/0|
 |-------------------------------------------------------------------------| |--------------| |-------------------|
 |06/2 |06/7|07/7|08/7|09/7|09/2|10/2|10/7|11/7|12/7|05/7|05/2|11/2| 14/3| |16/4|02/5|04/5| |16/7|17/7|04/7| |
 |-------------------------------------------------------------------------| '--------------' |-------------- 02/7|
 |02/7 |06/3|07/3|08/3|09/3|09/6|10/6|10/3|11/3|12/3|05/3|05/6| 14/1| |16/2|17/2|04/2| |
 |-------------------------------------------------------------------------| ,----. |-------------------|
 |01/2 |06/1|07/1|08/1|09/1|09/0|10/0|10/1|11/1|12/1|05/0| 01/3| |02/6| |16/3|17/3|04/3| |
 |-------------------------------------------------------------------------| ,--------------. |-------------- 02/3|
 |15/4|03/2|13/6| 16/6 |13/0|0/3|12/0|15/1| |02/0|16/0|17/0| | 17/6 |04/6| |
 `-------------------------------------------------------------------------' `--------------' `-------------------'
 */

 #define KEYMAP( \
 KG6, KH4, KI4, KI2, KI6, KP5, KL6, KM2, KM4, KO4, KO5, KO6, KO0, KN5, KN7, KP7, \
 KG4, KG5, KH5, KI5, KJ5, KJ4, KK4, KK5, KL5, KM5, KF5, KF4, KL4, KO2, KR4, KC4, KE4, KQ1, KR1, KE1, KE0, \
 KG2, KG7, KH7, KI7, KJ7, KJ2, KK2, KK7, KL7, KM7, KF7, KF2, KL2, KO3, KQ4, KC5, KE5, KQ7, KR7, KE7, KC7, \
 KH2, KG3, KH3, KI3, KJ3, KJ6, KK6, KK3, KL3, KM3, KF3, KF6, KO1, KQ2, KR2, KE2, \
 KB2, KH6, KG1, KH1, KI1, KJ1, KJ0, KK0, KK1, KL1, KM1, KF0, KB3, KC6, KQ3, KR3, KE3, KC3, \
 KP4, KD2, KN6, KQ6, KN0, KA3, KM0, KP1, KC0, KQ0, KR0, KR6, KE6 \
 ) { \
 /* 0 1 2 3 4 5 6 7 */ \
 /* A 0 */ {KC_NO, KC_NO, KC_NO, KC_##KA3, KC_NO, KC_NO, KC_NO, KC_NO },\
 /* B 1 */ {KC_NO, KC_NO, KC_##KB2, KC_##KB3, KC_NO, KC_NO, KC_NO, KC_NO },\
 /* C 2 */ {KC_##KC0, KC_NO, KC_NO, KC_##KC3, KC_##KC4, KC_##KC5, KC_##KC6, KC_##KC7},\
 /* D 3 */ {KC_NO, KC_NO, KC_##KD2, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO },\
 /* E 4 */ {KC_##KE0, KC_##KE1, KC_##KE2, KC_##KE3, KC_##KE4, KC_##KE5, KC_##KE6, KC_##KE7},\
 /* F 5 */ {KC_##KF0, KC_NO, KC_##KF2, KC_##KF3, KC_##KF4, KC_##KF5, KC_##KF6, KC_##KF7},\
 /* G 6 */ {KC_NO, KC_##KG1, KC_##KG2, KC_##KG3, KC_##KG4, KC_##KG5, KC_##KG6, KC_##KG7},\
 /* H 7 */ {KC_NO, KC_##KH1, KC_##KH2, KC_##KH3, KC_##KH4, KC_##KH5, KC_##KH6, KC_##KH7},\
 /* I 8 */ {KC_NO, KC_##KI1, KC_##KI2, KC_##KI3, KC_##KI4, KC_##KI5, KC_##KI6, KC_##KI7},\
 /* J 9 */ {KC_##KJ0, KC_##KJ1, KC_##KJ2, KC_##KJ3, KC_##KJ4, KC_##KJ5, KC_##KJ6, KC_##KJ7},\
 /* K 10 */ {KC_##KK0, KC_##KK1, KC_##KK2, KC_##KK3, KC_##KK4, KC_##KK5, KC_##KK6, KC_##KK7},\
 /* L 11 */ {KC_NO, KC_##KL1, KC_##KL2, KC_##KL3, KC_##KL4, KC_##KL5, KC_##KL6, KC_##KL7},\
 /* M 12 */ {KC_##KM0, KC_##KM1, KC_##KM2, KC_##KM3, KC_##KM4, KC_##KM5, KC_NO, KC_##KM7},\
 /* N 13 */ {KC_##KN0, KC_NO, KC_NO, KC_NO, KC_NO, KC_##KN5, KC_##KN6, KC_##KN7},\
 /* O 14 */ {KC_##KO0, KC_##KO1, KC_##KO2, KC_##KO3, KC_##KO4, KC_##KO5, KC_##KO6, KC_NO },\
 /* P 15 */ {KC_NO, KC_##KP1, KC_NO, KC_NO, KC_##KP4, KC_##KP5, KC_NO, KC_##KP7},\
 /* Q 16 */ {KC_##KQ0, KC_##KQ1, KC_##KQ2, KC_##KQ3, KC_##KQ4, KC_NO, KC_##KQ6, KC_##KQ7},\
 /* R 17 */ {KC_##KR0, KC_##KR1, KC_##KR2, KC_##KR3, KC_##KR4, KC_NO, KC_##KR6, KC_##KR7} \
 }

 #include "keymap_ansi.h"

 #define KEYMAPS_SIZE (sizeof(keymaps) / sizeof(keymaps[0]))
 #define FN_ACTIONS_SIZE (sizeof(fn_actions) / sizeof(fn_actions[0]))

 /* translates key to keycode */
 uint8_t keymap_key_to_keycode(uint8_t layer, key_t key)
 {
 if (layer < KEYMAPS_SIZE) {
 return pgm_read_byte(&keymaps[(layer)][(key.col)][(key.row)]);
 } else {
 return pgm_read_byte(&keymaps[0][(key.col)][(key.row)]);
 }
 }

 /* translates Fn keycode to action */
 action_t keymap_fn_to_action(uint8_t keycode)
 {
 action_t action;
 if (FN_INDEX(keycode) < FN_ACTIONS_SIZE) {
 action.code = pgm_read_word(&fn_actions[FN_INDEX(keycode)]);
 } else {
 action.code = ACTION_NO;
 }
 return action;
 }
--- a/keyboard/kitten_paw/keymap_ansi.h
+++ b/keyboard/kitten_paw/keymap_ansi.h
@@ -0,0 +1,23 @@

 static const uint8_t PROGMEM keymaps[][MATRIX_COLS][MATRIX_ROWS] = {
 /* Layer 0: Standard ANSI layer */
 KEYMAP(\
 ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, PSCR,SLCK,PAUS, \
 GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS, EQL,BSPC, INS, HOME,PGUP, NLCK,PSLS,PAST,PMNS, \
 TAB, Q, W, E, R, T, Y, U, I, O, P, LBRC,RBRC,BSLS, DEL, END, PGDN, P7, P8, P9, PPLS, \
 CAPS,A, S, D, F, G, H, J, K, L, SCLN,QUOT, ENT, P4, P5, P6, \
 LSFT,NUBS,Z, X, C, V, B, N, M, COMM,DOT, SLSH, RSFT, UP, P1, P2, P3, PENT, \
 LCTL,LGUI,LALT, SPC, RALT,RGUI, FN0,RCTL, LEFT,DOWN,RGHT, P0, PDOT), \
 /* Layer 1: Function layer */
 KEYMAP(\
 CALC,MYCM,WSCH,WHOM,MAIL,VOLD,VOLU,MSEL,MSTP,MPLY,MPRV,MNXT,TRNS, WAKE, PWR,SLEP, \
 TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, TRNS,TRNS,TRNS, TRNS,TRNS,TRNS,TRNS, \
 TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, TRNS,TRNS,TRNS, TRNS,TRNS,TRNS,TRNS, \
 TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, TRNS, TRNS,TRNS,TRNS, \
 TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, TRNS, TRNS, TRNS,TRNS,TRNS,TRNS, \
 TRNS,TRNS,TRNS, TRNS, TRNS,TRNS,TRNS,TRNS, TRNS,TRNS,TRNS, TRNS,TRNS)
 };

 static const uint16_t PROGMEM fn_actions[] = {
 [0] = ACTION_LAYER_MOMENTARY(1)
 };
--- a/keyboard/kitten_paw/led.c
+++ b/keyboard/kitten_paw/led.c
@@ -0,0 +1,60 @@
 /*
 Copyright 2014 Ralf Schmitt <[email protected]>

 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 <avr/io.h>
 #include "stdint.h"
 #include "led.h"

 /* LED pin configuration
 *
 * Scroll Lock PB7
 * CAPS PC6
 * NUMLOCK PC5
 *
 */
 void led_set(uint8_t usb_led)
 {
 DDRB |= (1<<7);
 DDRC |= (1<<5) | (1<<6);

 if (usb_led & (1<<USB_LED_CAPS_LOCK))
 {
 PORTC &= ~(1<<6);
 }
 else
 {
 PORTC |= (1<<6);
 }

 if (usb_led & (1<<USB_LED_NUM_LOCK))
 {
 PORTC &= ~(1<<5);
 }
 else
 {
 PORTC |= (1<<5);
 }

 if (usb_led & (1<<USB_LED_SCROLL_LOCK))
 {
 PORTB &= ~(1<<7);
 }
 else
 {
 PORTB |= (1<<7);
 }
 }
--- a/keyboard/kitten_paw/matrix.c
+++ b/keyboard/kitten_paw/matrix.c
@@ -0,0 +1,239 @@
 /*
 Copyright 2014 Ralf Schmitt <[email protected]>

 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 <stdint.h>
 #include <stdbool.h>
 #include <avr/io.h>
 #include <util/delay.h>
 #include "print.h"
 #include "debug.h"
 #include "util.h"
 #include "matrix.h"

 #ifndef DEBOUNCE
 # define DEBOUNCE 0
 #endif
 static uint8_t debouncing = DEBOUNCE;

 static matrix_row_t matrix[MATRIX_ROWS];
 static matrix_row_t matrix_debouncing[MATRIX_ROWS];

 static uint8_t read_rows(void);
 static void init_rows(void);
 static void unselect_cols(void);
 static void select_col(uint8_t col);

 inline uint8_t matrix_rows(void)
 {
 return MATRIX_ROWS;
 }

 inline uint8_t matrix_cols(void)
 {
 return MATRIX_COLS;
 }

 void matrix_init(void)
 {
 unselect_cols();
 init_rows();
 for (uint8_t i=0; i < MATRIX_ROWS; i++) {
 matrix[i] = 0;
 matrix_debouncing[i] = 0;
 }
 }

 uint8_t matrix_scan(void)
 {
 for (uint8_t col = 0; col < MATRIX_COLS; col++) {
 select_col(col);
 _delay_us(3);
 uint8_t rows = read_rows();
 for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
 bool prev_bit = matrix_debouncing[row] & ((matrix_row_t)1<<col);
 bool curr_bit = rows & (1<<row);
 if (prev_bit != curr_bit) {
 matrix_debouncing[row] ^= ((matrix_row_t)1<<col);
 debouncing = DEBOUNCE;
 }
 }
 unselect_cols();
 }

 if (debouncing) {
 if (--debouncing) {
 _delay_ms(1);
 } else {
 for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
 matrix[i] = matrix_debouncing[i];
 }
 }
 }

 return 1;
 }

 bool matrix_is_modified(void)
 {
 if (debouncing) return false;
 return true;
 }

 inline bool matrix_is_on(uint8_t row, uint8_t col)
 {
 return (matrix[row] & ((matrix_row_t)1<<col));
 }

 inline matrix_row_t matrix_get_row(uint8_t row)
 {
 return matrix[row];
 }

 void matrix_print(void)
 {
 print("\nr/c 0123456789ABCDEF\n");
 for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
 xprintf("%02X: %032lb\n", row, bitrev32(matrix_get_row(row)));
 }
 }

 uint8_t matrix_key_count(void)
 {
 uint8_t count = 0;
 for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
 count += bitpop32(matrix[i]);
 }
 return count;
 }

 /* Row pin configuration
 *
 * row: 0 1 2 3 4 5 6 7
 * pin: PC2 PB1 PB2 PB3 PC7 PB4 PB5 PB6
 *
 */
 static void init_rows(void)
 {
 DDRC &= ~0b10000100;
 DDRB &= ~0b01111110;
 PORTC |= 0b10000100;
 PORTB |= 0b01111110;
 }

 static uint8_t read_rows(void)
 {
 return (PINC&(1<<2) ? 0 : (1<<0)) |
 (PINB&(1<<1) ? 0 : (1<<1)) |
 (PINB&(1<<2) ? 0 : (1<<2)) |
 (PINB&(1<<3) ? 0 : (1<<3)) |
 (PINC&(1<<7) ? 0 : (1<<4)) |
 (PINB&(1<<4) ? 0 : (1<<5)) |
 (PINB&(1<<5) ? 0 : (1<<6)) |
 (PINB&(1<<6) ? 0 : (1<<7));
 }

 /* These columns uses two 74HC42 4 to 10 bit demultiplexers (low active).
 *
 * COL PD1 PD0 PD2 PD6 PD5 PD4
 * 12 1 1 0 0 0 0
 * 11 1 1 0 0 0 1
 * 10 1 1 0 0 1 0
 * 9 1 1 0 0 1 1
 * 8 1 1 0 1 0 0
 * 7 1 1 0 1 0 1
 * 6 1 1 0 1 1 0
 * 5 1 1 0 1 1 1
 * 4 1 1 1 0 0 0
 * 3 1 1 1 0 0 1

 * COL PD2 PD6 PD1 PD0 PD5 PD4
 * 2 1 1 0 0 0 0
 * 1 1 1 0 0 0 1
 * 0 1 1 0 0 1 0
 * 17 1 1 0 0 1 1
 * 16 1 1 0 1 0 0
 * 1 1 0 1 0 1
 * 1 1 0 1 1 0
 * 15 1 1 0 1 1 1
 * 14 1 1 1 0 0 0
 * 13 1 1 1 0 0 1
 */
 static void unselect_cols(void)
 {
 DDRD |= 0b01110111;
 PORTD &= ~0b01110111;
 }

 static void select_col(uint8_t col)
 {
 switch (col) {
 case 0:
 PORTD |= (1<<5) | (1<<6) | (1<<2);
 break;
 case 1:
 PORTD |= (1<<4) | (1<<6) | (1<<2);
 break;
 case 2:
 PORTD |= (1<<6) | (1<<2);
 break;
 case 3:
 PORTD |= (1<<4) | (1<<2) | (1<<0) | (1<<1);
 break;
 case 4:
 PORTD |= (1<<2) | (1<<0) | (1<<1);
 break;
 case 5:
 PORTD |= (1<<4) | (1<<5) | (1<<6) | (1<<0) | (1<<1);
 break;
 case 6:
 PORTD |= (1<<5) | (1<<6) | (1<<0) | (1<<1);
 break;
 case 7:
 PORTD |= (1<<4) | (1<<6) | (1<<0) | (1<<1);
 break;
 case 8:
 PORTD |= (1<<6) | (1<<0) | (1<<1);
 break;
 case 9:
 PORTD |= (1<<4) | (1<<5) | (1<<0) | (1<<1);
 break;
 case 10:
 PORTD |= (1<<5) | (1<<0) | (1<<1);
 break;
 case 11:
 PORTD |= (1<<4) | (1<<0) | (1<<1);
 break;
 case 12:
 PORTD |= (1<<0) | (1<<1);
 break;
 case 13:
 PORTD |= (1<<4) | (1<<1) | (1<<6) | (1<<2);
 break;
 case 14:
 PORTD |= (1<<1) | (1<<6) | (1<<2);
 break;
 case 15:
 PORTD |= (1<<4) | (1<<5) | (1<<0) | (1<<6) | (1<<2);
 break;
 case 16:
 PORTD |= (1<<0) | (1<<6) | (1<<2);
 break;
 case 17:
 PORTD |= (1<<4) | (1<<5) | (1<<6) | (1<<2);
 break;
 }
 }
--- a/protocol/adb.c
+++ b/protocol/adb.c
@@ -128,6 +128,10 @@ uint16_t adb_host_kbd_recv(void)
 attention();
 send_byte(0x2C); // Addr:Keyboard(0010), Cmd:Talk(11), Register0(00)
 place_bit0(); // Stopbit(0)
 if (!wait_data_hi(500)) { // Service Request(310us Adjustable Keyboard): just ignored
 sei();
 return -30; // something wrong
 }
 if (!wait_data_lo(500)) { // Tlt/Stop to Start(140-260us)
 sei();
 return 0; // No data to send
--- a/protocol/lufa/lufa.c
+++ b/protocol/lufa/lufa.c
@@ -272,7 +272,9 @@ void EVENT_USB_Device_ControlRequest(void)
 // Interface
 switch (USB_ControlRequest.wIndex) {
 case KEYBOARD_INTERFACE:
 #ifdef NKRO_ENABLE
 case NKRO_INTERFACE:
 #endif
 Endpoint_ClearSETUP();

 while (!(Endpoint_IsOUTReceived())) {
--- a/protocol/ps2_mouse.c
+++ b/protocol/ps2_mouse.c
@@ -82,9 +82,14 @@ void ps2_mouse_task(void)
 mouse_report.x = ps2_host_recv_response();
 mouse_report.y = ps2_host_recv_response();
 } else {
 if (!debug_mouse) print("ps2_mouse: fail to get mouse packet\n");
 if (debug_mouse) print("ps2_mouse: fail to get mouse packet\n");
 return;
 }
 xprintf("%ud ", timer_read());
 print("ps2_mouse raw: [");
 phex(mouse_report.buttons); print("|");
 print_hex8((uint8_t)mouse_report.x); print(" ");
 print_hex8((uint8_t)mouse_report.y); print("]\n");

 /* if mouse moves or buttons state changes */
 if (mouse_report.x || mouse_report.y ||