11 yıl önce · 3c822b511e
--- a/common.mk
+++ b/common.mk
 SRC += $(COMMON_DIR)/host.c \
 $(COMMON_DIR)/keyboard.c \
 $(COMMON_DIR)/command.c \
 $(COMMON_DIR)/layer.c \
 $(COMMON_DIR)/timer.c \
 $(COMMON_DIR)/print.c \
 $(COMMON_DIR)/debug.c \
--- a/common/command.c
+++ b/common/command.c
 #include <stdint.h>
 #include <stdbool.h>
 #include <util/delay.h>
 #include "usb_keycodes.h"
 #include "keycode.h"
 #include "host.h"
 #include "print.h"
 #include "debug.h"
 #include "util.h"
 #include "timer.h"
 #include "layer.h"
 #include "matrix.h"
 #include "keyboard.h"
 #include "bootloader.h"
 #include "command.h"
 #ifdef MOUSEKEY_ENABLE
 #include "mousekey.h"
 #endif
 #ifdef HOST_PJRC
 # include "usb_keyboard.h"
 #endif
 static uint8_t command_common(void);
 static void help(void);
 static bool command_common(uint8_t code);
 static void command_common_help(void);
 static bool command_console(uint8_t code);
 static void command_console_help(void);
 #ifdef MOUSEKEY_ENABLE
 static bool mousekey_console(uint8_t code);
 static void mousekey_console_help(void);
 #endif
 static uint8_t numkey2num(uint8_t code);
 static void switch_layer(uint8_t layer);
 static void clear_keyboard(void);
 static bool last_print_enable;
 uint8_t command_proc(void)
 {
 uint8_t processed = 0;
 last_print_enable = print_enable;
 typedef enum { ONESHOT, CONSOLE, MOUSEKEY } cmdstate_t;
 static cmdstate_t state = ONESHOT;
 if (!IS_COMMAND())
 return 0;
 print_enable = true;
 if (command_extra() || command_common()) {
 processed = 1;
 _delay_ms(500);
 bool command_proc(uint8_t code)
 {
 switch (state) {
 case ONESHOT:
 if (!IS_COMMAND())
 return false;
 return (command_extra(code) || command_common(code));
 case CONSOLE:
 command_console(code);
 break;
 #ifdef MOUSEKEY_ENABLE
 case MOUSEKEY:
 mousekey_console(code);
 break;
 #endif
 default:
 state = ONESHOT;
 return false;
 }
 print_enable = last_print_enable;
 return processed;
 return true;
 }
 /* This allows to define extra commands. return 0 when not processed. */
 uint8_t command_extra(void) __attribute__ ((weak));
 uint8_t command_extra(void)
 /* This allows to define extra commands. return false when not processed. */
 bool command_extra(uint8_t code) __attribute__ ((weak));
 bool command_extra(uint8_t code)
 {
 return 0;
 return false;
 }
 static uint8_t command_common(void)
 /***********************************************************
 * Command common
 ***********************************************************/
 static void command_common_help(void)
 {
 print_enable = true;
 print("\n\n----- Command Help -----\n");
 print("c: enter console mode\n");
 print("d: toggle debug enable\n");
 print("x: toggle matrix debug\n");
 print("k: toggle keyboard debug\n");
 print("m: toggle mouse debug\n");
 print("p: toggle print enable\n");
 print("v: print device version & info\n");
 print("t: print timer count\n");
 print("s: print status\n");
 #ifdef NKRO_ENABLE
 print("n: toggle NKRO\n");
 #endif
 print("0/F10: switch to Layer0 \n");
 print("1/F1: switch to Layer1 \n");
 print("2/F2: switch to Layer2 \n");
 print("3/F3: switch to Layer3 \n");
 print("4/F4: switch to Layer4 \n");
 print("PScr: power down/remote wake-up\n");
 print("Caps: Lock Keyboard(Child Proof)\n");
 print("Paus: jump to bootloader\n");
 }
 static bool command_common(uint8_t code)
 {
 switch (host_get_first_key()) {
 case KB_H:
 help();
 break;
 case KB_B:
 host_clear_keyboard_report();
 host_send_keyboard_report();
 print("jump to bootloader... ");
 static host_driver_t *host_driver = 0;
 switch (code) {
 case KC_CAPSLOCK:
 if (host_get_driver()) {
 host_driver = host_get_driver();
 host_set_driver(0);
 print("Locked.\n");
 } else {
 host_set_driver(host_driver);
 print("Unlocked.\n");
 }
 break;
 case KC_H:
 case KC_SLASH: /* ? */
 command_common_help();
 break;
 case KC_C:
 print_enable = true;
 debug_matrix = false;
 debug_keyboard = false;
 debug_mouse = false;
 debug_enable = false;
 command_console_help();
 print("\nEnter Console Mode\n");
 print("C> ");
 state = CONSOLE;
 break;
 case KC_PAUSE:
 clear_keyboard();
 print("\n\nJump to bootloader... ");
 _delay_ms(1000);
 bootloader_jump(); // not return
 print("not supported.\n");
 break;
 case KB_D:
 debug_enable = !debug_enable;
 case KC_D:
 if (debug_enable) {
 last_print_enable = true;
 print("debug enabled.\n");
 debug_matrix = true;
 debug_keyboard = true;
 debug_mouse = true;
 } else {
 print("debug disabled.\n");
 last_print_enable = false;
 debug_matrix = false;
 print("\nDEBUG: disabled.\n");
 debug_matrix = false;
 debug_keyboard = false;
 debug_mouse = false;
 debug_mouse = false;
 debug_enable = false;
 } else {
 print("\nDEBUG: enabled.\n");
 debug_matrix = true;
 debug_keyboard = true;
 debug_mouse = true;
 debug_enable = true;
 }
 break;
 case KB_X: // debug matrix toggle
 case KC_X: // debug matrix toggle
 debug_matrix = !debug_matrix;
 if (debug_matrix)
 print("debug matrix enabled.\n");
 else
 print("debug matrix disabled.\n");
 if (debug_matrix) {
 print("\nDEBUG: matrix enabled.\n");
 debug_enable = true;
 } else {
 print("\nDEBUG: matrix disabled.\n");
 }
 break;
 case KB_K: // debug keyboard toggle
 case KC_K: // debug keyboard toggle
 debug_keyboard = !debug_keyboard;
 if (debug_keyboard)
 print("debug keyboard enabled.\n");
 else
 print("debug keyboard disabled.\n");
 if (debug_keyboard) {
 print("\nDEBUG: keyboard enabled.\n");
 debug_enable = true;
 } else {
 print("\nDEBUG: keyboard disabled.\n");
 }
 break;
 case KB_M: // debug mouse toggle
 case KC_M: // debug mouse toggle
 debug_mouse = !debug_mouse;
 if (debug_mouse)
 print("debug mouse enabled.\n");
 else
 print("debug mouse disabled.\n");
 if (debug_mouse) {
 print("\nDEBUG: mouse enabled.\n");
 debug_enable = true;
 } else {
 print("\nDEBUG: mouse disabled.\n");
 }
 break;
 case KB_V: // print version & information
 case KC_V: // print version & information
 print("\n\n----- Version -----\n");
 print(STR(DESCRIPTION) "\n");
 print(STR(MANUFACTURER) "(" STR(VENDOR_ID) ")/");
 print(STR(PRODUCT) "(" STR(PRODUCT_ID) ") ");
 print("VERSION: " STR(DEVICE_VER) "\n");
 break;
 case KB_T: // print timer
 print("timer: "); phex16(timer_count); print("\n");
 case KC_T: // print timer
 print("timer: "); phex16(timer_count>>16); phex16(timer_count); print("\n");
 break;
 case KB_P: // print toggle
 if (last_print_enable) {
 case KC_P: // print toggle
 if (print_enable) {
 print("print disabled.\n");
 last_print_enable = false;
 print_enable = false;
 } else {
 last_print_enable = true;
 print_enable = true;
 print("print enabled.\n");
 }
 break;
 case KB_S:
 case KC_S:
 print("\n\n----- Status -----\n");
 print("host_keyboard_leds:"); phex(host_keyboard_leds()); print("\n");
 #ifdef HOST_PJRC
 print("UDCON: "); phex(UDCON); print("\n");
 #endif
 break;
 #ifdef NKRO_ENABLE
 case KB_N:
 // send empty report before change
 host_clear_keyboard_report();
 host_send_keyboard_report();
 case KC_N:
 keyboard_nkro = !keyboard_nkro;
 if (keyboard_nkro)
 print("NKRO: enabled\n");
 break;
 #endif
 #ifdef EXTRAKEY_ENABLE
 case KB_ESC:
 host_clear_keyboard_report();
 host_send_keyboard_report();
 case KC_PSCREEN:
 // TODO: Power key should take this feature? otherwise any key during suspend.
 #ifdef HOST_PJRC
 if (suspend && remote_wakeup) {
 usb_remote_wakeup();
 }
 #else
 host_system_send(SYSTEM_POWER_DOWN);
 _delay_ms(100);
 host_system_send(0);
 _delay_ms(500);
 #endif
 break;
 #endif
 case KB_BSPC:
 matrix_init();
 print("clear matrix\n");
 break;
 case KB_0:
 case KC_0:
 case KC_F10:
 switch_layer(0);
 break;
 case KB_1:
 case KC_1:
 case KC_F1:
 switch_layer(1);
 break;
 case KB_2:
 case KC_2:
 case KC_F2:
 switch_layer(2);
 break;
 case KB_3:
 case KC_3:
 case KC_F3:
 switch_layer(3);
 break;
 case KB_4:
 case KC_4:
 case KC_F4:
 switch_layer(4);
 break;
 default:
 return 0;
 print("?");
 return false;
 }
 return 1;
 return true;
 }
 static void help(void)
 /***********************************************************
 * Command console
 ***********************************************************/
 static void command_console_help(void)
 {
 print("b: jump to bootloader\n");
 print("d: toggle debug enable\n");
 print("x: toggle matrix debug\n");
 print("k: toggle keyboard debug\n");
 print("m: toggle mouse debug\n");
 print("p: toggle print enable\n");
 print("v: print version\n");
 print("t: print timer count\n");
 print("s: print status\n");
 #ifdef NKRO_ENABLE
 print("n: toggle NKRO\n");
 print_enable = true;
 print("\n\n----- Console Help -----\n");
 print("ESC/q: quit\n");
 #ifdef MOUSEKEY_ENABLE
 print("m: mousekey\n");
 #endif
 }
 static bool command_console(uint8_t code)
 {
 switch (code) {
 case KC_H:
 case KC_SLASH: /* ? */
 command_console_help();
 break;
 case KC_Q:
 case KC_ESC:
 print("\nQuit Console Mode\n");
 state = ONESHOT;
 return false;
 #ifdef MOUSEKEY_ENABLE
 case KC_M:
 mousekey_console_help();
 print("\nEnter Mousekey Console\n");
 print("M0>");
 state = MOUSEKEY;
 return true;
 #endif
 default:
 print("?");
 return false;
 }
 print("C> ");
 return true;
 }
 #ifdef MOUSEKEY_ENABLE
 /***********************************************************
 * Mousekey console
 ***********************************************************/
 static uint8_t mousekey_param = 0;
 static void mousekey_param_print(void)
 {
 print("\n\n----- Mousekey Parameters -----\n");
 print("1: mk_delay(*10ms): "); pdec(mk_delay); print("\n");
 print("2: mk_interval(ms): "); pdec(mk_interval); print("\n");
 print("3: mk_max_speed: "); pdec(mk_max_speed); print("\n");
 print("4: mk_time_to_max: "); pdec(mk_time_to_max); print("\n");
 print("5: mk_wheel_max_speed: "); pdec(mk_wheel_max_speed); print("\n");
 print("6: mk_wheel_time_to_max: "); pdec(mk_wheel_time_to_max); print("\n");
 }
 static void mousekey_param_inc(uint8_t param, uint8_t inc)
 {
 switch (param) {
 case 1:
 if (mk_delay + inc < UINT8_MAX)
 mk_delay += inc;
 else
 mk_delay = UINT8_MAX;
 print("mk_delay = "); pdec(mk_delay); print("\n");
 break;
 case 2:
 if (mk_interval + inc < UINT8_MAX)
 mk_interval += inc;
 else
 mk_interval = UINT8_MAX;
 print("mk_interval = "); pdec(mk_interval); print("\n");
 break;
 case 3:
 if (mk_max_speed + inc < UINT8_MAX)
 mk_max_speed += inc;
 else
 mk_max_speed = UINT8_MAX;
 print("mk_max_speed = "); pdec(mk_max_speed); print("\n");
 break;
 case 4:
 if (mk_time_to_max + inc < UINT8_MAX)
 mk_time_to_max += inc;
 else
 mk_time_to_max = UINT8_MAX;
 print("mk_time_to_max = "); pdec(mk_time_to_max); print("\n");
 break;
 case 5:
 if (mk_wheel_max_speed + inc < UINT8_MAX)
 mk_wheel_max_speed += inc;
 else
 mk_wheel_max_speed = UINT8_MAX;
 print("mk_wheel_max_speed = "); pdec(mk_wheel_max_speed); print("\n");
 break;
 case 6:
 if (mk_wheel_time_to_max + inc < UINT8_MAX)
 mk_wheel_time_to_max += inc;
 else
 mk_wheel_time_to_max = UINT8_MAX;
 print("mk_wheel_time_to_max = "); pdec(mk_wheel_time_to_max); print("\n");
 break;
 }
 }
 static void mousekey_param_dec(uint8_t param, uint8_t dec)
 {
 switch (param) {
 case 1:
 if (mk_delay > dec)
 mk_delay -= dec;
 else
 mk_delay = 0;
 print("mk_delay = "); pdec(mk_delay); print("\n");
 break;
 case 2:
 if (mk_interval > dec)
 mk_interval -= dec;
 else
 mk_interval = 0;
 print("mk_interval = "); pdec(mk_interval); print("\n");
 break;
 case 3:
 if (mk_max_speed > dec)
 mk_max_speed -= dec;
 else
 mk_max_speed = 0;
 print("mk_max_speed = "); pdec(mk_max_speed); print("\n");
 break;
 case 4:
 if (mk_time_to_max > dec)
 mk_time_to_max -= dec;
 else
 mk_time_to_max = 0;
 print("mk_time_to_max = "); pdec(mk_time_to_max); print("\n");
 break;
 case 5:
 if (mk_wheel_max_speed > dec)
 mk_wheel_max_speed -= dec;
 else
 mk_wheel_max_speed = 0;
 print("mk_wheel_max_speed = "); pdec(mk_wheel_max_speed); print("\n");
 break;
 case 6:
 if (mk_wheel_time_to_max > dec)
 mk_wheel_time_to_max -= dec;
 else
 mk_wheel_time_to_max = 0;
 print("mk_wheel_time_to_max = "); pdec(mk_wheel_time_to_max); print("\n");
 break;
 }
 }
 static void mousekey_console_help(void)
 {
 print("\n\n----- Mousekey Parameters Help -----\n");
 print("ESC/q: quit\n");
 print("1: select mk_delay(*10ms)\n");
 print("2: select mk_interval(ms)\n");
 print("3: select mk_max_speed\n");
 print("4: select mk_time_to_max\n");
 print("5: select mk_wheel_max_speed\n");
 print("6: select mk_wheel_time_to_max\n");
 print("p: print prameters\n");
 print("d: set default values\n");
 print("up: increase prameters(+1)\n");
 print("down: decrease prameters(-1)\n");
 print("pgup: increase prameters(+10)\n");
 print("pgdown: decrease prameters(-10)\n");
 print("\nspeed = delta * max_speed * (repeat / time_to_max)\n");
 print("where delta: cursor="); pdec(MOUSEKEY_MOVE_DELTA);
 print(", wheel="); pdec(MOUSEKEY_WHEEL_DELTA); print("\n");
 print("See http://en.wikipedia.org/wiki/Mouse_keys\n");
 }
 static bool mousekey_console(uint8_t code)
 {
 switch (code) {
 case KC_H:
 case KC_SLASH: /* ? */
 mousekey_console_help();
 break;
 case KC_Q:
 case KC_ESC:
 mousekey_param = 0;
 print("\nQuit Mousekey Console\n");
 print("C> ");
 state = CONSOLE;
 return false;
 case KC_P:
 mousekey_param_print();
 break;
 case KC_1:
 case KC_2:
 case KC_3:
 case KC_4:
 case KC_5:
 case KC_6:
 case KC_7:
 case KC_8:
 case KC_9:
 case KC_0:
 mousekey_param = numkey2num(code);
 print("selected parameter: "); pdec(mousekey_param); print("\n");
 break;
 case KC_UP:
 mousekey_param_inc(mousekey_param, 1);
 break;
 case KC_DOWN:
 mousekey_param_dec(mousekey_param, 1);
 break;
 case KC_PGUP:
 mousekey_param_inc(mousekey_param, 10);
 break;
 case KC_PGDN:
 mousekey_param_dec(mousekey_param, 10);
 break;
 case KC_D:
 mk_delay = MOUSEKEY_DELAY/10;
 mk_interval = MOUSEKEY_INTERVAL;
 mk_max_speed = MOUSEKEY_MAX_SPEED;
 mk_time_to_max = MOUSEKEY_TIME_TO_MAX;
 mk_wheel_max_speed = MOUSEKEY_WHEEL_MAX_SPEED;
 mk_wheel_time_to_max = MOUSEKEY_WHEEL_TIME_TO_MAX;
 print("set default values.\n");
 break;
 default:
 print("?");
 return false;
 }
 print("M"); pdec(mousekey_param); print("> ");
 return true;
 }
 #endif
 print("Backspace: clear matrix\n");
 print("ESC: power down/wake up\n");
 print("0: switch to Layer0 \n");
 print("1: switch to Layer1 \n");
 print("2: switch to Layer2 \n");
 print("3: switch to Layer3 \n");
 print("4: switch to Layer4 \n");
 /***********************************************************
 * Utilities
 ***********************************************************/
 static uint8_t numkey2num(uint8_t code)
 {
 switch (code) {
 case KC_1: return 1;
 case KC_2: return 2;
 case KC_3: return 3;
 case KC_4: return 4;
 case KC_5: return 5;
 case KC_6: return 6;
 case KC_7: return 7;
 case KC_8: return 8;
 case KC_9: return 9;
 case KC_0: return 0;
 }
 return 0;
 }
 static void switch_layer(uint8_t layer)
 default_layer = layer;
 print("switch to Layer: "); phex(layer); print("\n");
 }
 static void clear_keyboard(void)
 {
 host_clear_keys();
 host_clear_mods();
 host_send_keyboard_report();
 host_system_send(0);
 host_consumer_send(0);
 #ifdef MOUSEKEY_ENABLE
 mousekey_clear();
 mousekey_send();
 #endif
 }
--- a/common/command.h
+++ b/common/command.h
 #ifndef COMMAND_H
 #define COMMAND
 uint8_t command_proc(void);
 bool command_proc(uint8_t code);
 /* This allows to extend commands. Return 0 when command is not processed. */
 uint8_t command_extra(void);
 bool command_extra(uint8_t code);
 #endif
--- a/common/debug.h
+++ b/common/debug.h
 #define debug(s) if(debug_enable) print_P(PSTR(s))
 #define debug_P(s) if(debug_enable) print_P(s)
 #define debug_S(s) if(debug_enable) print_S(s)
 #define debug_hex(c) if(debug_enable) phex(c)
 #define debug_hex16(i) if(debug_enable) phex16(i)
 #define debug_bin(c) if(debug_enable) pbin(c)
--- a/common/host.c
+++ b/common/host.c
 /*
 Copyright 2011 Jun Wako <[email protected]>
 Copyright 2011,2012 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
 #include <stdint.h>
 #include <avr/interrupt.h>
 #include "usb_keycodes.h"
 #include "keycode.h"
 #include "host.h"
 #include "util.h"
 #include "debug.h"
 bool keyboard_nkro = false;
 #endif
 static host_driver_t *driver;
 static report_keyboard_t report0;
 static report_keyboard_t report1;
 report_keyboard_t *keyboard_report = &report0;
 report_keyboard_t *keyboard_report_prev = &report1;
 report_keyboard_t *keyboard_report = &(report_keyboard_t){};
 report_mouse_t mouse_report = {};
 static host_driver_t *driver;
 static uint16_t last_system_report = 0;
 static uint16_t last_consumer_report = 0;
 static inline void add_key_byte(uint8_t code);
 static inline void del_key_byte(uint8_t code);
 if (!driver) return 0;
 return (*driver->keyboard_leds)();
 }
 /* send report */
 void host_keyboard_send(report_keyboard_t *report)
 {
 if (!driver) return;
 (*driver->send_keyboard)(report);
 if (debug_keyboard) {
 print("keys: ");
 for (int i = 0; i < REPORT_KEYS; i++) {
 phex(keyboard_report->keys[i]); print(" ");
 }
 print(" mods: "); phex(keyboard_report->mods); print("\n");
 }
 }
 void host_mouse_send(report_mouse_t *report)
 {
 if (!driver) return;
 (*driver->send_mouse)(report);
 }
 void host_system_send(uint16_t report)
 {
 if (report == last_system_report) return;
 last_system_report = report;
 if (!driver) return;
 (*driver->send_system)(report);
 }
 void host_consumer_send(uint16_t report)
 {
 if (report == last_consumer_report) return;
 last_consumer_report = report;
 if (!driver) return;
 (*driver->send_consumer)(report);
 }
 /* keyboard report operations */
 /* keyboard report utils */
 void host_add_key(uint8_t key)
 {
 #ifdef NKRO_ENABLE
 del_key_byte(key);
 }
 void host_clear_keys(void)
 {
 for (int8_t i = 0; i < REPORT_KEYS; i++) {
 keyboard_report->keys[i] = 0;
 }
 }
 void host_add_mod_bit(uint8_t mod)
 {
 keyboard_report->mods |= mod;
 keyboard_report->mods = mods;
 }
 void host_add_code(uint8_t code)
 {
 if (IS_MOD(code)) {
 host_add_mod_bit(MOD_BIT(code));
 } else {
 host_add_key(code);
 }
 }
 void host_del_code(uint8_t code)
 {
 if (IS_MOD(code)) {
 host_del_mod_bit(MOD_BIT(code));
 } else {
 host_del_key(code);
 }
 }
 void host_swap_keyboard_report(void)
 {
 uint8_t sreg = SREG;
 cli();
 report_keyboard_t *tmp = keyboard_report_prev;
 keyboard_report_prev = keyboard_report;
 keyboard_report = tmp;
 SREG = sreg;
 }
 void host_clear_keyboard_report(void)
 void host_clear_mods(void)
 {
 keyboard_report->mods = 0;
 for (int8_t i = 0; i < REPORT_KEYS; i++) {
 keyboard_report->keys[i] = 0;
 }
 }
 uint8_t host_has_anykey(void)
 return cnt;
 }
 uint8_t host_has_anymod(void)
 {
 return bitpop(keyboard_report->mods);
 }
 uint8_t host_get_first_key(void)
 {
 #ifdef NKRO_ENABLE
 return keyboard_report->keys[0];
 }
 void host_send_keyboard_report(void)
 {
 if (!driver) return;
 (*driver->send_keyboard)(keyboard_report);
 host_keyboard_send(keyboard_report);
 }
 void host_mouse_send(report_mouse_t *report)
 uint8_t host_mouse_in_use(void)
 {
 if (!driver) return;
 (*driver->send_mouse)(report);
 return (mouse_report.buttons | mouse_report.x | mouse_report.y | mouse_report.v | mouse_report.h);
 }
 void host_system_send(uint16_t data)
 uint16_t host_last_sysytem_report(void)
 {
 static uint16_t last_data = 0;
 if (data == last_data) return;
 last_data = data;
 if (!driver) return;
 (*driver->send_system)(data);
 return last_system_report;
 }
 void host_consumer_send(uint16_t data)
 uint16_t host_last_consumer_report(void)
 {
 static uint16_t last_data = 0;
 if (data == last_data) return;
 last_data = data;
 if (!driver) return;
 (*driver->send_consumer)(data);
 return last_consumer_report;
 }
 static inline void add_key_byte(uint8_t code)
 {
 // TODO: fix ugly code
 int8_t i = 0;
 int8_t empty = -1;
 for (; i < REPORT_KEYS; i++) {
 if (keyboard_report_prev->keys[i] == code) {
 keyboard_report->keys[i] = code;
 if (keyboard_report->keys[i] == code) {
 break;
 }
 if (empty == -1 &&
 keyboard_report_prev->keys[i] == 0 &&
 keyboard_report->keys[i] == 0) {
 if (empty == -1 && keyboard_report->keys[i] == 0) {
 empty = i;
 }
 }
 for (; i < REPORT_KEYS; i++) {
 if (keyboard_report->keys[i] == code) {
 keyboard_report->keys[i] = 0;
 break;
 }
 }
 }
--- a/common/host.h
+++ b/common/host.h
 extern bool keyboard_nkro;
 #endif
 /* report */
 extern report_keyboard_t *keyboard_report;
 extern report_keyboard_t *keyboard_report_prev;
 extern report_mouse_t mouse_report;
 /* host driver */
 void host_set_driver(host_driver_t *driver);
 host_driver_t *host_get_driver(void);
 /* host driver interface */
 uint8_t host_keyboard_leds(void);
 void host_keyboard_send(report_keyboard_t *report);
 void host_mouse_send(report_mouse_t *report);
 void host_system_send(uint16_t data);
 void host_consumer_send(uint16_t data);
 /* keyboard report operations */
 /* keyboard report utils */
 void host_add_key(uint8_t key);
 void host_del_key(uint8_t key);
 void host_clear_keys(void);
 void host_add_mod_bit(uint8_t mod);
 void host_del_mod_bit(uint8_t mod);
 void host_set_mods(uint8_t mods);
 void host_add_code(uint8_t code);
 void host_del_code(uint8_t code);
 void host_swap_keyboard_report(void);
 void host_clear_keyboard_report(void);
 void host_clear_mods(void);
 uint8_t host_has_anykey(void);
 uint8_t host_has_anymod(void);
 uint8_t host_get_first_key(void);
 void host_send_keyboard_report(void);
 /* mouse report utils */
 uint8_t host_mouse_in_use(void);
 void host_send_keyboard_report(void);
 void host_mouse_send(report_mouse_t *report);
 void host_system_send(uint16_t data);
 void host_consumer_send(uint16_t data);
 uint16_t host_last_sysytem_report(void);
 uint16_t host_last_consumer_report(void);
 #ifdef __cplusplus
 }
--- a/common/keyboard.c
+++ b/common/keyboard.c
 along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 #include "keyboard.h"
 #include "host.h"
 #include "layer.h"
 #include "matrix.h"
 #include "keymap.h"
 #include "host.h"
 #include "led.h"
 #include "usb_keycodes.h"
 #include "keycode.h"
 #include "timer.h"
 #include "print.h"
 #include "debug.h"
 #include "command.h"
 #include "util.h"
 #ifdef MOUSEKEY_ENABLE
 #include "mousekey.h"
 #endif
 #ifdef EXTRAKEY_ENABLE
 #include <util/delay.h>
 #define Kdebug(s) do { if (debug_keyboard) debug(s); } while(0)
 #define Kdebug_P(s) do { if (debug_keyboard) debug_P(s); } while(0)
 #define Kdebug_hex(s) do { if (debug_keyboard) debug_hex(s); } while(0)
 #define LAYER_DELAY 250
 typedef enum keykind {
 NONE,
 FN_DOWN, FN_UP,
 FNK_DOWN, FNK_UP,
 KEY_DOWN, KEY_UP,
 MOD_DOWN, MOD_UP,
 } keykind_t;
 typedef enum { IDLE, DELAYING, WAITING, PRESSING } kbdstate_t;
 #ifdef KEYMAP_DEFAULT_LAYER
 uint8_t default_layer = KEYMAP_DEFAULT_LAYER;
 uint8_t current_layer = KEYMAP_DEFAULT_LAYER;
 #else
 uint8_t default_layer = 0;
 uint8_t current_layer = 0;
 #endif
 /* keyboard internal states */
 static kbdstate_t kbdstate = IDLE;
 static uint8_t fn_state_bits = 0;
 static keyrecord_t delayed_fn;
 static keyrecord_t waiting_key;
 static uint8_t last_leds = 0;
 static const char *state_str(kbdstate_t state)
 {
 if (state == IDLE) return PSTR("IDLE");
 if (state == DELAYING) return PSTR("DELAYING");
 if (state == WAITING) return PSTR("WAITING");
 if (state == PRESSING) return PSTR("PRESSING");
 return PSTR("UNKNOWN");
 }
 void keyboard_init(void)
 static inline keykind_t get_keykind(uint8_t code, bool pressed)
 {
 timer_init();
 matrix_init();
 #ifdef PS2_MOUSE_ENABLE
 ps2_mouse_init();
 #endif
 if IS_KEY(code) return (pressed ? KEY_DOWN : KEY_UP);
 if IS_MOD(code) return (pressed ? MOD_DOWN : MOD_UP);
 if IS_FN(code) {
 if (keymap_fn_keycode(FN_INDEX(code)))
 return (pressed ? FNK_DOWN : FNK_UP);
 else
 return (pressed ? FN_DOWN : FN_UP);
 }
 if IS_MOUSEKEY(code) return (pressed ? KEY_DOWN : KEY_UP);
 if IS_SYSTEM(code) return (pressed ? KEY_DOWN : KEY_UP);
 if IS_CONSUMER(code) return (pressed ? KEY_DOWN : KEY_UP);
 return NONE;
 }
 void keyboard_proc(void)
 static void clear_keyboard(void)
 {
 uint8_t fn_bits = 0;
 #ifdef EXTRAKEY_ENABLE
 uint16_t consumer_code = 0;
 uint16_t system_code = 0;
 host_clear_keys();
 host_clear_mods();
 host_send_keyboard_report();
 host_system_send(0);
 host_consumer_send(0);
 #ifdef MOUSEKEY_ENABLE
 mousekey_clear();
 mousekey_send();
 #endif
 }
 matrix_scan();
 static void clear_keyboard_but_mods(void)
 {
 host_clear_keys();
 host_send_keyboard_report();
 host_system_send(0);
 host_consumer_send(0);
 if (matrix_is_modified()) {
 if (debug_matrix) matrix_print();
 #ifdef DEBUG_LED
 // LED flash for debug
 DEBUG_LED_CONFIG;
 DEBUG_LED_ON;
 #ifdef MOUSEKEY_ENABLE
 mousekey_clear();
 mousekey_send();
 #endif
 }
 static bool anykey_sent_to_host(void)
 {
 return (host_has_anykey() || host_mouse_in_use() ||
 host_last_sysytem_report() || host_last_consumer_report());
 }
 static void layer_switch_on(uint8_t code)
 {
 if (!IS_FN(code)) return;
 fn_state_bits |= FN_BIT(code);
 uint8_t new_layer = (fn_state_bits ? keymap_fn_layer(biton(fn_state_bits)) : default_layer);
 if (current_layer != new_layer) {
 Kdebug("Layer Switch(on): "); Kdebug_hex(current_layer);
 Kdebug(" -> "); Kdebug_hex(new_layer); Kdebug("\n");
 clear_keyboard_but_mods();
 current_layer = new_layer;
 }
 }
 static bool layer_switch_off(uint8_t code)
 {
 if (!IS_FN(code)) return false;
 fn_state_bits &= ~FN_BIT(code);
 uint8_t new_layer = (fn_state_bits ? keymap_fn_layer(biton(fn_state_bits)) : default_layer);
 if (current_layer != new_layer) {
 Kdebug("Layer Switch(off): "); Kdebug_hex(current_layer);
 Kdebug(" -> "); Kdebug_hex(new_layer); Kdebug("\n");
 clear_keyboard_but_mods();
 current_layer = new_layer;
 return true;
 }
 return false;
 }
 if (matrix_has_ghost()) {
 // should send error?
 debug("matrix has ghost!!\n");
 return;
 static void register_code(uint8_t code)
 {
 if IS_KEY(code) {
 if (!command_proc(code)) {
 host_add_key(code);
 host_send_keyboard_report();
 }
 }
 else if IS_MOD(code) {
 host_add_mod_bit(MOD_BIT(code));
 host_send_keyboard_report();
 }
 else if IS_FN(code) {
 if (!command_proc(keymap_fn_keycode(FN_INDEX(code)))) {
 host_add_key(keymap_fn_keycode(FN_INDEX(code)));
 host_send_keyboard_report();
 }
 }
 else if IS_MOUSEKEY(code) {
 #ifdef MOUSEKEY_ENABLE
 mousekey_on(code);
 mousekey_send();
 #endif
 }
 else if IS_CONSUMER(code) {
 uint16_t usage = 0;
 switch (code) {
 case KC_AUDIO_MUTE:
 usage = AUDIO_MUTE;
 break;
 case KC_AUDIO_VOL_UP:
 usage = AUDIO_VOL_UP;
 break;
 case KC_AUDIO_VOL_DOWN:
 usage = AUDIO_VOL_DOWN;
 break;
 case KC_MEDIA_NEXT_TRACK:
 usage = TRANSPORT_NEXT_TRACK;
 break;
 case KC_MEDIA_PREV_TRACK:
 usage = TRANSPORT_PREV_TRACK;
 break;
 case KC_MEDIA_STOP:
 usage = TRANSPORT_STOP;
 break;
 case KC_MEDIA_PLAY_PAUSE:
 usage = TRANSPORT_PLAY_PAUSE;
 break;
 case KC_MEDIA_SELECT:
 usage = AL_CC_CONFIG;
 break;
 case KC_MAIL:
 usage = AL_EMAIL;
 break;
 case KC_CALCULATOR:
 usage = AL_CALCULATOR;
 break;
 case KC_MY_COMPUTER:
 usage = AL_LOCAL_BROWSER;
 break;
 case KC_WWW_SEARCH:
 usage = AC_SEARCH;
 break;
 case KC_WWW_HOME:
 usage = AC_HOME;
 break;
 case KC_WWW_BACK:
 usage = AC_BACK;
 break;
 case KC_WWW_FORWARD:
 usage = AC_FORWARD;
 break;
 case KC_WWW_STOP:
 usage = AC_STOP;
 break;
 case KC_WWW_REFRESH:
 usage = AC_REFRESH;
 break;
 case KC_WWW_FAVORITES:
 usage = AC_BOOKMARKS;
 break;
 }
 host_consumer_send(usage);
 }
 else if IS_SYSTEM(code) {
 uint16_t usage = 0;
 switch (code) {
 case KC_SYSTEM_POWER:
 usage = SYSTEM_POWER_DOWN;
 break;
 case KC_SYSTEM_SLEEP:
 usage = SYSTEM_SLEEP;
 break;
 case KC_SYSTEM_WAKE:
 usage = SYSTEM_WAKE_UP;
 break;
 }
 host_system_send(usage);
 }
 host_swap_keyboard_report();
 host_clear_keyboard_report();
 for (int row = 0; row < matrix_rows(); row++) {
 for (int col = 0; col < matrix_cols(); col++) {
 if (!matrix_is_on(row, col)) continue;
 }
 uint8_t code = layer_get_keycode(row, col);
 if (code == KB_NO) {
 // do nothing
 } else if (IS_MOD(code)) {
 host_add_mod_bit(MOD_BIT(code));
 } else if (IS_FN(code)) {
 fn_bits |= FN_BIT(code);
 }
 // TODO: use table or something
 #ifdef EXTRAKEY_ENABLE
 // System Control
 else if (code == KB_SYSTEM_POWER) {
 #ifdef HOST_PJRC
 if (suspend && remote_wakeup) {
 usb_remote_wakeup();
 }
 static void unregister_code(uint8_t code)
 {
 if IS_KEY(code) {
 host_del_key(code);
 host_send_keyboard_report();
 }
 else if IS_MOD(code) {
 host_del_mod_bit(MOD_BIT(code));
 host_send_keyboard_report();
 }
 else if IS_FN(code) {
 host_del_key(keymap_fn_keycode(FN_INDEX(code)));
 host_send_keyboard_report();
 }
 else if IS_MOUSEKEY(code) {
 #ifdef MOUSEKEY_ENABLE
 mousekey_off(code);
 mousekey_send();
 #endif
 system_code = SYSTEM_POWER_DOWN;
 } else if (code == KB_SYSTEM_SLEEP) {
 system_code = SYSTEM_SLEEP;
 } else if (code == KB_SYSTEM_WAKE) {
 system_code = SYSTEM_WAKE_UP;
 }
 // Consumer Page
 else if (code == KB_AUDIO_MUTE) {
 consumer_code = AUDIO_MUTE;
 } else if (code == KB_AUDIO_VOL_UP) {
 consumer_code = AUDIO_VOL_UP;
 } else if (code == KB_AUDIO_VOL_DOWN) {
 consumer_code = AUDIO_VOL_DOWN;
 }
 else if (code == KB_MEDIA_NEXT_TRACK) {
 consumer_code = TRANSPORT_NEXT_TRACK;
 } else if (code == KB_MEDIA_PREV_TRACK) {
 consumer_code = TRANSPORT_PREV_TRACK;
 } else if (code == KB_MEDIA_STOP) {
 consumer_code = TRANSPORT_STOP;
 } else if (code == KB_MEDIA_PLAY_PAUSE) {
 consumer_code = TRANSPORT_PLAY_PAUSE;
 } else if (code == KB_MEDIA_SELECT) {
 consumer_code = AL_CC_CONFIG;
 }
 else if (code == KB_MAIL) {
 consumer_code = AL_EMAIL;
 } else if (code == KB_CALCULATOR) {
 consumer_code = AL_CALCULATOR;
 } else if (code == KB_MY_COMPUTER) {
 consumer_code = AL_LOCAL_BROWSER;
 }
 else if (code == KB_WWW_SEARCH) {
 consumer_code = AC_SEARCH;
 } else if (code == KB_WWW_HOME) {
 consumer_code = AC_HOME;
 } else if (code == KB_WWW_BACK) {
 consumer_code = AC_BACK;
 } else if (code == KB_WWW_FORWARD) {
 consumer_code = AC_FORWARD;
 } else if (code == KB_WWW_STOP) {
 consumer_code = AC_STOP;
 } else if (code == KB_WWW_REFRESH) {
 consumer_code = AC_REFRESH;
 } else if (code == KB_WWW_FAVORITES) {
 consumer_code = AC_BOOKMARKS;
 }
 else if IS_CONSUMER(code) {
 host_consumer_send(0x0000);
 }
 else if IS_SYSTEM(code) {
 host_system_send(0x0000);
 }
 }
 /*
 *
 * Event/State|IDLE PRESSING DELAYING[f] WAITING[f,k] 
 * -----------+------------------------------------------------------------------
 * Fn Down |(L+) -*1 WAITING(Sk) IDLE(Rf,Ps)*7 
 * Up |(L-) IDLE(L-)*8 IDLE(L-)*8 IDLE(L-)*8 
 * Fnk Down |DELAYING(Sf)* (Rf) WAITING(Sk) IDLE(Rf,Ps,Rf) 
 * Up |(L-) IDLE(L-/Uf)*8 IDLE(Rf,Uf/L-)*3 IDLE(Rf,Ps,Uf/L-)*3 
 * Key Down |PRESSING(Rk) (Rk) WAITING(Sk) IDLE(Rf,Ps,Rk) 
 * Up |(Uk) IDLE(Uk)*4 (Uk) IDLE(L+,Ps,Pk)/(Uk)*a
 * |
 * Delay |- - IDLE(L+) IDLE(L+,Ps) 
 * Magic Key |COMMAND*5
 *
 * *1: ignore Fn if other key is down.
 * *2: register Fnk if any key is pressing
 * *3: register/unregister delayed Fnk and move to IDLE if code == delayed Fnk, else *8
 * *4: if no keys registered to host
 * *5: unregister all keys
 * *6: only if no keys down
 * *7: ignore Fn because Fnk key and stored key are down.
 * *8: move to IDLE if layer switch(off) occurs, else stay at current state
 * *9: repeat key if pressing Fnk twice quickly(move to PRESSING)
 * *a: layer switch and process waiting key and code if code == wainting key, else unregister key
 *
 * States:
 * IDLE: No key is down except modifiers
 * DELAYING: delay layer switch after pressing Fn with alt keycode
 * WAITING: key is pressed during DELAYING
 *
 * Events:
 * Fn: Fn key without alternative keycode
 * Fnk: Fn key with alternative keycode
 * -: ignore
 * Delay: layer switch delay term is elapsed
 *
 * Actions:
 * Rk: register key
 * Uk: unregister key
 * Rf: register Fn(alt keycode)
 * Uf: unregister Fn(alt keycode)
 * Rs: register stored key
 * Us: unregister stored key
 * Sk: Store key(waiting Key)
 * Sf: Store Fn(delayed Fn)
 * Ps: Process stored key
 * Ps: Process key
 * Is: Interpret stored keys in current layer
 * L+: Switch to new layer(*unregister* all keys but modifiers)
 * L-: Switch back to last layer(*unregister* all keys but modifiers)
 * Ld: Switch back to default layer(*unregister* all keys but modifiers)
 */
 #define NEXT(state) do { \
 Kdebug("NEXT: "); Kdebug_P(state_str(kbdstate)); \
 kbdstate = state; \
 Kdebug(" -> "); Kdebug_P(state_str(kbdstate)); Kdebug("\n"); \
 } while (0)
 static inline void process_key(keyevent_t event)
 {
 uint8_t code = keymap_get_keycode(current_layer, event.key.row, event.key.col);
 keykind_t kind = get_keykind(code, event.pressed);
 uint8_t tmp_mods;
 Kdebug("state: "); Kdebug_P(state_str(kbdstate));
 Kdebug(" kind: "); Kdebug_hex(kind);
 Kdebug(" code: "); Kdebug_hex(code);
 if (event.pressed) { Kdebug("d"); } else { Kdebug("u"); }
 Kdebug("\n");
 switch (kbdstate) {
 case IDLE:
 switch (kind) {
 case FN_DOWN:
 layer_switch_on(code);
 break;
 case FN_UP:
 layer_switch_off(code);
 break;
 case FNK_DOWN:
 // repeat Fn alt key when press Fn key down, up then down again quickly
 if (KEYEQ(delayed_fn.event.key, event.key) &&
 timer_elapsed(delayed_fn.time) < LAYER_DELAY) {
 register_code(code);
 NEXT(PRESSING);
 } else {
 delayed_fn = (keyrecord_t) {
 .event = event,
 .code = code,
 .mods = keyboard_report->mods,
 .time = timer_read()
 };
 NEXT(DELAYING);
 }
 break;
 case FNK_UP:
 layer_switch_off(code);
 break;
 case KEY_DOWN:
 register_code(code);
 NEXT(PRESSING);
 break;
 case MOD_DOWN:
 register_code(code);
 break;
 case KEY_UP:
 case MOD_UP:
 unregister_code(code);
 break;
 default:
 break;
 }
 #endif
 else if (IS_KEY(code)) {
 host_add_key(code);
 break;
 case PRESSING:
 switch (kind) {
 case FN_DOWN:
 // ignored when any key is pressed
 break;
 case FN_UP:
 if (layer_switch_off(code))
 NEXT(IDLE);
 break;
 case FNK_DOWN:
 register_code(code);
 break;
 case FNK_UP:
 if (layer_switch_off(code)) {
 NEXT(IDLE);
 } else {
 unregister_code(code);
 if (!anykey_sent_to_host())
 NEXT(IDLE);
 }
 break;
 case KEY_DOWN:
 case MOD_DOWN:
 register_code(code);
 break;
 case KEY_UP:
 case MOD_UP:
 unregister_code(code);
 if (!anykey_sent_to_host())
 NEXT(IDLE);
 break;
 default:
 break;
 }
 #ifdef MOUSEKEY_ENABLE
 else if (IS_MOUSEKEY(code)) {
 mousekey_decode(code);
 break;
 case DELAYING:
 switch (kind) {
 case FN_DOWN:
 case FNK_DOWN:
 case KEY_DOWN:
 waiting_key = (keyrecord_t) {
 .event = event,
 .code = code,
 .mods = keyboard_report->mods,
 .time = timer_read()
 };
 NEXT(WAITING);
 break;
 case MOD_DOWN:
 register_code(code);
 break;
 case FN_UP:
 if (layer_switch_off(code))
 NEXT(IDLE);
 break;
 case FNK_UP:
 if (code == delayed_fn.code) {
 // type Fn with alt keycode
 // restore the mod status at the time of pressing Fn key
 tmp_mods = keyboard_report->mods;
 host_set_mods(delayed_fn.mods);
 register_code(delayed_fn.code);
 unregister_code(delayed_fn.code);
 host_set_mods(tmp_mods);
 NEXT(IDLE);
 } else {
 if (layer_switch_off(code))
 NEXT(IDLE);
 }
 break;
 case KEY_UP:
 case MOD_UP:
 unregister_code(code);
 break;
 default:
 break;
 }
 #endif
 else {
 debug("ignore keycode: "); debug_hex(code); debug("\n");
 break;
 case WAITING:
 switch (kind) {
 case FN_DOWN:
 case FNK_DOWN:
 case KEY_DOWN:
 tmp_mods = keyboard_report->mods;
 host_set_mods(delayed_fn.mods);
 register_code(delayed_fn.code);
 host_set_mods(waiting_key.mods);
 register_code(waiting_key.code);
 host_set_mods(tmp_mods);
 if (kind == FN_DOWN) {
 // ignore Fn
 } else if (kind == FNK_DOWN) {
 register_code(code);
 } else if (kind == KEY_DOWN) {
 register_code(code);
 }
 NEXT(IDLE);
 break;
 case MOD_DOWN:
 register_code(code);
 break;
 case FN_UP:
 if (layer_switch_off(code))
 NEXT(IDLE);
 break;
 case FNK_UP:
 if (code == delayed_fn.code) {
 // alt down, key down, alt up
 tmp_mods = keyboard_report->mods;
 host_set_mods(delayed_fn.mods);
 register_code(delayed_fn.code);
 host_set_mods(waiting_key.mods);
 register_code(waiting_key.code);
 unregister_code(delayed_fn.code);
 host_set_mods(tmp_mods);
 NEXT(IDLE);
 } else {
 if (layer_switch_off(code))
 NEXT(IDLE);
 }
 break;
 case KEY_UP:
 if (code == waiting_key.code) {
 layer_switch_on(delayed_fn.code);
 NEXT(IDLE);
 // process waiting_key
 tmp_mods = keyboard_report->mods;
 host_set_mods(waiting_key.mods);
 process_key(waiting_key.event);
 host_set_mods(tmp_mods);
 process_key(event);
 } else {
 unregister_code(code);
 }
 break;
 case MOD_UP:
 unregister_code(code);
 break;
 default:
 break;
 }
 }
  break;
 }
 }
 layer_switching(fn_bits);
 void keyboard_init(void)
 {
 debug_keyboard = true;
 timer_init();
 matrix_init();
 #ifdef PS2_MOUSE_ENABLE
 ps2_mouse_init();
 #endif
 }
 void keyboard_task(void)
 {
 static matrix_row_t matrix_prev[MATRIX_ROWS];
 matrix_row_t matrix_row = 0;
 matrix_row_t matrix_change = 0;
 if (command_proc()) {
 return;
 matrix_scan();
 for (int r = 0; r < MATRIX_ROWS; r++) {
 matrix_row = matrix_get_row(r);
 matrix_change = matrix_row ^ matrix_prev[r];
 if (matrix_change) {
 if (debug_matrix) matrix_print();
 for (int c = 0; c < MATRIX_COLS; c++) {
 if (matrix_change & (1<<c)) {
 process_key((keyevent_t){
 .key = (key_t){ .row = r, .col = c },
 .pressed = (matrix_row & (1<<c))
 });
 // record a processed key
 matrix_prev[r] ^= (1<<c);
 // process a key per task call
 goto MATRIX_LOOP_END;
 }
 }
 }
 }
 MATRIX_LOOP_END:
 // TODO: should send only when changed from last report
 if (matrix_is_modified()) {
 host_send_keyboard_report();
 #ifdef EXTRAKEY_ENABLE
 host_consumer_send(consumer_code);
 host_system_send(system_code);
 #endif
 #ifdef DEBUG_LED
 // LED flash for debug
 DEBUG_LED_CONFIG;
 DEBUG_LED_OFF;
 #endif
 // layer switch when delay term elapses
 if (kbdstate == DELAYING || kbdstate == WAITING) {
 if (timer_elapsed(delayed_fn.time) > LAYER_DELAY) {
 if (kbdstate == DELAYING) {
 layer_switch_on(delayed_fn.code);
 NEXT(IDLE);
 }
 if (kbdstate == WAITING) {
 layer_switch_on(delayed_fn.code);
 NEXT(IDLE);
 uint8_t tmp_mods = keyboard_report->mods;
 host_set_mods(waiting_key.mods);
 process_key(waiting_key.event);
 host_set_mods(tmp_mods);
 }
 }
 }
 #ifdef MOUSEKEY_ENABLE
 mousekey_send();
 #endif
 #ifdef PS2_MOUSE_ENABLE
 // TODO: should comform new API
 if (ps2_mouse_read() == 0)
 ps2_mouse_usb_send();
 // mousekey repeat & acceleration
 mousekey_task();
 #endif
 if (last_leds != host_keyboard_leds()) {
 keyboard_set_leds(host_keyboard_leds());
 last_leds = host_keyboard_leds();
 // FAIL SAFE: clear all key if no key down
 if (matrix_change) {
 matrix_row_t is_matrix_on = 0;
 for (int r = 0; r < MATRIX_ROWS; r++) {
 is_matrix_on |= matrix_get_row(r);
 }
 if (!is_matrix_on) {
 Kdebug("FAIL SAFE: clear all keys(default layer).\n");
 clear_keyboard();
 current_layer = default_layer;
 }
 }
 return;
 }
 void keyboard_set_leds(uint8_t leds)
--- a/common/keyboard.h
+++ b/common/keyboard.h
 #ifndef KEYBOARD_H
 #define KEYBOARD_H
 #include <stdbool.h>
 #include <stdint.h>
 #ifdef __cplusplus
 extern "C" {
 #endif
 typedef struct {
 uint8_t row;
 uint8_t col;
 } key_t;
 typedef struct {
 key_t key;
 bool pressed;
 } keyevent_t;
 typedef struct {
 keyevent_t event;
 uint8_t code;
 uint8_t mods;
 uint16_t time;
 } keyrecord_t;
 #define KEYEQ(keya, keyb) (keya.row == keyb.row && keya.col == keyb.col)
 extern uint8_t current_layer;
 extern uint8_t default_layer;
 void keyboard_init(void);
 void keyboard_proc(void);
 void keyboard_task(void);
 void keyboard_set_leds(uint8_t leds);
 #ifdef __cplusplus
 }
 #endif
--- a/common/keycode.h
+++ b/common/keycode.h
 /*
 Copyright 2011,2012 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/>.
 */
 /* 
 * Keycodes based on HID Usage Keyboard/Keypad Page(0x07) plus special codes
 * http://www.usb.org/developers/devclass_docs/Hut1_12.pdf
 */
 #ifndef KEYCODE_H
 #define KEYCODE_H
 #define IS_ERROR(code) (KC_ROLL_OVER <= (code) && (code) <= KC_UNDEFINED)
 #define IS_ANY(code) (KC_A <= (code) && (code) <= 0xFF)
 #define IS_KEY(code) (KC_A <= (code) && (code) <= KC_EXSEL)
 #define IS_MOD(code) (KC_LCTRL <= (code) && (code) <= KC_RGUI)
 #define IS_FN(code) (KC_FN0 <= (code) && (code) <= KC_FN7)
 #define IS_MOUSEKEY(code) (KC_MS_UP <= (code) && (code) <= KC_MS_ACCEL2)
 #define IS_MOUSEKEY_MOVE(code) (KC_MS_UP <= (code) && (code) <= KC_MS_RIGHT)
 #define IS_MOUSEKEY_BUTTON(code) (KC_MS_BTN1 <= (code) && (code) <= KC_MS_BTN5)
 #define IS_MOUSEKEY_WHEEL(code) (KC_MS_WH_UP <= (code) && (code) <= KC_MS_WH_RIGHT)
 #define IS_MOUSEKEY_ACCEL(code) (KC_MS_ACCEL0 <= (code) && (code) <= KC_MS_ACCEL2)
 #define IS_SPECIAL(code) ((0xB0 <= (code) && (code) <= 0xDF) || (0xE8 <= (code) && (code) <= 0xFF))
 #define IS_CONSUMER(code) (KC_MUTE <= (code) && (code) <= KC_WFAV)
 #define IS_SYSTEM(code) (KC_POWER <= (code) && (code) <= KC_WAKE)
 #define MOD_BIT(code) (1<<MOD_INDEX(code))
 #define MOD_INDEX(code) ((code) & 0x07)
 #define FN_BIT(code) (1<<FN_INDEX(code))
 #define FN_INDEX(code) ((code) - KC_FN0)
 /*
 * Short names for ease of definition of keymap
 */
 #define KC_LCTL KC_LCTRL
 #define KC_RCTL KC_RCTRL
 #define KC_LSFT KC_LSHIFT
 #define KC_RSFT KC_RSHIFT
 #define KC_ESC KC_ESCAPE
 #define KC_BSPC KC_BSPACE
 #define KC_ENT KC_ENTER
 #define KC_DEL KC_DELETE
 #define KC_INS KC_INSERT
 #define KC_CAPS KC_CAPSLOCK
 #define KC_RGHT KC_RIGHT
 #define KC_PGDN KC_PGDOWN
 #define KC_PSCR KC_PSCREEN
 #define KC_SLCK KC_SCKLOCK
 #define KC_PAUS KC_PAUSE
 #define KC_BRK KC_PAUSE
 #define KC_NLCK KC_NUMLOCK
 #define KC_SPC KC_SPACE
 #define KC_MINS KC_MINUS
 #define KC_EQL KC_EQUAL
 #define KC_GRV KC_GRAVE
 #define KC_RBRC KC_RBRACKET
 #define KC_LBRC KC_LBRACKET
 #define KC_COMM KC_COMMA
 #define KC_BSLS KC_BSLASH
 #define KC_SLSH KC_SLASH
 #define KC_SCLN KC_SCOLON
 #define KC_QUOT KC_QUOTE
 #define KC_APP KC_APPLICATION
 #define KC_NUHS KC_NONUS_HASH
 #define KC_NUBS KC_NONUS_BSLASH
 #define KC_ERAS KC_ALT_ERASE,
 #define KC_CLR KC_CLEAR
 /* Japanese specific */
 #define KC_ZKHK KC_GRAVE
 #define KC_RO KC_INT1
 #define KC_KANA KC_INT2
 #define KC_JYEN KC_INT3
 #define KC_HENK KC_INT4
 #define KC_MHEN KC_INT5
 /* Keypad */
 #define KC_P1 KC_KP_1
 #define KC_P2 KC_KP_2
 #define KC_P3 KC_KP_3
 #define KC_P4 KC_KP_4
 #define KC_P5 KC_KP_5
 #define KC_P6 KC_KP_6
 #define KC_P7 KC_KP_7
 #define KC_P8 KC_KP_8
 #define KC_P9 KC_KP_9
 #define KC_P0 KC_KP_0
 #define KC_PDOT KC_KP_DOT
 #define KC_PCMM KC_KP_COMMA
 #define KC_PSLS KC_KP_SLASH
 #define KC_PAST KC_KP_ASTERISK
 #define KC_PMNS KC_KP_MINUS
 #define KC_PPLS KC_KP_PLUS
 #define KC_PEQL KC_KP_EQUAL
 #define KC_PENT KC_KP_ENTER
 /* Mousekey */
 #define KC_MS_U KC_MS_UP
 #define KC_MS_D KC_MS_DOWN
 #define KC_MS_L KC_MS_LEFT
 #define KC_MS_R KC_MS_RIGHT
 #define KC_BTN1 KC_MS_BTN1
 #define KC_BTN2 KC_MS_BTN2
 #define KC_BTN3 KC_MS_BTN3
 #define KC_BTN4 KC_MS_BTN4
 #define KC_BTN5 KC_MS_BTN5
 #define KC_WH_U KC_MS_WH_UP
 #define KC_WH_D KC_MS_WH_DOWN
 #define KC_WH_L KC_MS_WH_LEFT
 #define KC_WH_R KC_MS_WH_RIGHT
 #define KC_ACL0 KC_MS_ACCEL0
 #define KC_ACL1 KC_MS_ACCEL1
 #define KC_ACL2 KC_MS_ACCEL2
 /* Sytem Control */
 #define KC_PWR KC_SYSTEM_POWER
 #define KC_SLEP KC_SYSTEM_SLEEP
 #define KC_WAKE KC_SYSTEM_WAKE
 /* Consumer Page */
 #define KC_MUTE KC_AUDIO_MUTE
 #define KC_VOLU KC_AUDIO_VOL_UP
 #define KC_VOLD KC_AUDIO_VOL_DOWN
 #define KC_MNXT KC_MEDIA_NEXT_TRACK
 #define KC_MPRV KC_MEDIA_PREV_TRACK
 #define KC_MSTP KC_MEDIA_STOP
 #define KC_MPLY KC_MEDIA_PLAY_PAUSE
 #define KC_MSEL KC_MEDIA_SELECT
 #define KC_MAIL KC_MAIL
 #define KC_CALC KC_CALCULATOR
 #define KC_MYCM KC_MY_COMPUTER
 #define KC_WSCH KC_WWW_SEARCH
 #define KC_WHOM KC_WWW_HOME
 #define KC_WBAK KC_WWW_BACK
 #define KC_WFWD KC_WWW_FORWARD
 #define KC_WSTP KC_WWW_STOP
 #define KC_WREF KC_WWW_REFRESH
 #define KC_WFAV KC_WWW_FAVORITES
 /* USB HID Keyboard/Keypad Usage(0x07) */
 enum hid_keyboard_keypad_usage {
 KC_NO = 0x00,
 KC_ROLL_OVER,
 KC_POST_FAIL,
 KC_UNDEFINED,
 KC_A,
 KC_B,
 KC_C,
 KC_D,
 KC_E,
 KC_F,
 KC_G,
 KC_H,
 KC_I,
 KC_J,
 KC_K,
 KC_L,
 KC_M, /* 0x10 */
 KC_N,
 KC_O,
 KC_P,
 KC_Q,
 KC_R,
 KC_S,
 KC_T,
 KC_U,
 KC_V,
 KC_W,
 KC_X,
 KC_Y,
 KC_Z,
 KC_1,
 KC_2,
 KC_3, /* 0x20 */
 KC_4,
 KC_5,
 KC_6,
 KC_7,
 KC_8,
 KC_9,
 KC_0,
 KC_ENTER,
 KC_ESCAPE,
 KC_BSPACE,
 KC_TAB,
 KC_SPACE,
 KC_MINUS,
 KC_EQUAL,
 KC_LBRACKET,
 KC_RBRACKET, /* 0x30 */
 KC_BSLASH, /* \ (and |) */
 KC_NONUS_HASH, /* Non-US # and ~ */
 KC_SCOLON, /* ; (and :) */
 KC_QUOTE, /* ' and " */
 KC_GRAVE, /* Grave accent and tilde */
 KC_COMMA, /* , and < */
 KC_DOT, /* . and > */
 KC_SLASH, /* / and ? */
 KC_CAPSLOCK,
 KC_F1,
 KC_F2,
 KC_F3,
 KC_F4,
 KC_F5,
 KC_F6,
 KC_F7, /* 0x40 */
 KC_F8,
 KC_F9,
 KC_F10,
 KC_F11,
 KC_F12,
 KC_PSCREEN,
 KC_SCKLOCK,
 KC_PAUSE,
 KC_INSERT,
 KC_HOME,
 KC_PGUP,
 KC_DELETE,
 KC_END,
 KC_PGDOWN,
 KC_RIGHT,
 KC_LEFT, /* 0x50 */
 KC_DOWN,
 KC_UP,
 KC_NUMLOCK,
 KC_KP_SLASH,
 KC_KP_ASTERISK,
 KC_KP_MINUS,
 KC_KP_PLUS,
 KC_KP_ENTER,
 KC_KP_1,
 KC_KP_2,
 KC_KP_3,
 KC_KP_4,
 KC_KP_5,
 KC_KP_6,
 KC_KP_7,
 KC_KP_8, /* 0x60 */
 KC_KP_9,
 KC_KP_0,
 KC_KP_DOT,
 KC_NONUS_BSLASH, /* Non-US \ and | */
 KC_APPLICATION,
 KC_POWER,
 KC_KP_EQUAL,
 KC_F13,
 KC_F14,
 KC_F15,
 KC_F16,
 KC_F17,
 KC_F18,
 KC_F19,
 KC_F20,
 KC_F21, /* 0x70 */
 KC_F22,
 KC_F23,
 KC_F24,
 KC_EXECUTE,
 KC_HELP,
 KC_MENU,
 KC_SELECT,
 KC_STOP,
 KC_AGAIN,
 KC_UNDO,
 KC_CUT,
 KC_COPY,
 KC_PASTE,
 KC_FIND,
 KC__MUTE,
 KC__VOLUP, /* 0x80 */
 KC__VOLDOWN,
 KC_LOCKING_CAPS, /* locking Caps Lock */
 KC_LOCKING_NUM, /* locking Num Lock */
 KC_LOCKING_SCROLL, /* locking Scroll Lock */
 KC_KP_COMMA,
 KC_KP_EQUAL_AS400, /* equal sign on AS/400 */
 KC_INT1,
 KC_INT2,
 KC_INT3,
 KC_INT4,
 KC_INT5,
 KC_INT6,
 KC_INT7,
 KC_INT8,
 KC_INT9,
 KC_LANG1, /* 0x90 */
 KC_LANG2,
 KC_LANG3,
 KC_LANG4,
 KC_LANG5,
 KC_LANG6,
 KC_LANG7,
 KC_LANG8,
 KC_LANG9,
 KC_ALT_ERASE,
 KC_SYSREQ,
 KC_CANCEL,
 KC_CLEAR,
 KC_PRIOR,
 KC_RETURN,
 KC_SEPARATOR,
 KC_OUT, /* 0xA0 */
 KC_OPER,
 KC_CLEAR_AGAIN,
 KC_CRSEL,
 KC_EXSEL, /* 0xA4 */
 /* NOTE: 0xA5-DF are used for internal special purpose */
 #if 0
 /* NOTE: Following codes(0xB0-DD) are not used. Leave them for reference. */
 KC_KP_00 = 0xB0,
 KC_KP_000,
 KC_THOUSANDS_SEPARATOR,
 KC_DECIMAL_SEPARATOR,
 KC_CURRENCY_UNIT,
 KC_CURRENCY_SUB_UNIT,
 KC_KP_LPAREN,
 KC_KP_RPAREN,
 KC_KP_LCBRACKET, /* { */
 KC_KP_RCBRACKET, /* } */
 KC_KP_TAB,
 KC_KP_BSPACE,
 KC_KP_A,
 KC_KP_B,
 KC_KP_C,
 KC_KP_D,
 KC_KP_E, /* 0xC0 */
 KC_KP_F,
 KC_KP_XOR,
 KC_KP_HAT,
 KC_KP_PERC,
 KC_KP_LT,
 KC_KP_GT,
 KC_KP_AND,
 KC_KP_LAZYAND,
 KC_KP_OR,
 KC_KP_LAZYOR,
 KC_KP_COLON,
 KC_KP_HASH,
 KC_KP_SPACE,
 KC_KP_ATMARK,
 KC_KP_EXCLAMATION,
 KC_KP_MEM_STORE, /* 0xD0 */
 KC_KP_MEM_RECALL,
 KC_KP_MEM_CLEAR,
 KC_KP_MEM_ADD,
 KC_KP_MEM_SUB,
 KC_KP_MEM_MUL,
 KC_KP_MEM_DIV,
 KC_KP_PLUS_MINUS,
 KC_KP_CLEAR,
 KC_KP_CLEAR_ENTRY,
 KC_KP_BINARY,
 KC_KP_OCTAL,
 KC_KP_DECIMAL,
 KC_KP_HEXADECIMAL, /* 0xDD */
 #endif
 /* Modifiers */
 KC_LCTRL = 0xE0,
 KC_LSHIFT,
 KC_LALT,
 KC_LGUI,
 KC_RCTRL,
 KC_RSHIFT,
 KC_RALT,
 KC_RGUI,
 /* NOTE: 0xE8-FF are used for internal special purpose */ 
 };
 /* Special keycodes */
 /* NOTE: 0xA5-DF and 0xE8-FF are used for internal special purpose */
 enum internal_special_keycodes {
 /* System Control */
 KC_SYSTEM_POWER = 0xA5,
 KC_SYSTEM_SLEEP,
 KC_SYSTEM_WAKE, /* 0xA7 */
 /* 0xA8-AF */
 /* Consumer Page */
 KC_AUDIO_MUTE = 0xB0,
 KC_AUDIO_VOL_UP,
 KC_AUDIO_VOL_DOWN,
 KC_MEDIA_NEXT_TRACK,
 KC_MEDIA_PREV_TRACK,
 KC_MEDIA_STOP,
 KC_MEDIA_PLAY_PAUSE,
 KC_MEDIA_SELECT,
 KC_MAIL,
 KC_CALCULATOR,
 KC_MY_COMPUTER,
 KC_WWW_SEARCH,
 KC_WWW_HOME,
 KC_WWW_BACK,
 KC_WWW_FORWARD,
 KC_WWW_STOP,
 KC_WWW_REFRESH, /* 0xC0 */
 KC_WWW_FAVORITES, /* 0xC1 */
 /* 0xC2-DF vacant for future use */
 /* 0xE0-E7 for Modifiers. DO NOT USE. */
 /* Layer Switching */
 KC_FN0 = 0xE8,
 KC_FN1,
 KC_FN2,
 KC_FN3,
 KC_FN4,
 KC_FN5,
 KC_FN6,
 KC_FN7, /* 0xEF */
 /* Mousekey */
 KC_MS_UP = 0xF0,
 KC_MS_DOWN,
 KC_MS_LEFT,
 KC_MS_RIGHT,
 KC_MS_BTN1,
 KC_MS_BTN2,
 KC_MS_BTN3,
 KC_MS_BTN4,
 KC_MS_BTN5, /* 0xF8 */
 /* Mousekey wheel */
 KC_MS_WH_UP,
 KC_MS_WH_DOWN,
 KC_MS_WH_LEFT,
 KC_MS_WH_RIGHT, /* 0xFC */
 /* Mousekey accel */
 KC_MS_ACCEL0,
 KC_MS_ACCEL1,
 KC_MS_ACCEL2 /* 0xFF */
 };
 #endif /* KEYCODE_H */
--- a/common/layer.c
+++ b/common/layer.c
 /*
 Copyright 2011 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.h"
 #include "host.h"
 #include "debug.h"
 #include "timer.h"
 #include "usb_keycodes.h"
 #include "layer.h"
 /*
 * Parameters:
 * SWITCH_DELAY |=======|
 * SEND_FN_TERM |================|
 *
 * Fn key processing cases:
 * 1. release Fn after SEND_FN_TERM.
 * Layer sw ___________|~~~~~~~~~~~|___
 * Fn press ___|~~~~~~~~~~~~~~~~~~~|___
 * Fn send ___________________________
 *
 * 2. release Fn during SEND_FN_TERM.(not layer used)
 * Layer sw ___________|~~~~~~|________
 * Fn press ___|~~~~~~~~~~~~~~|________
 * Fn key send __________________|~|______
 * other key press ___________________________
 * other key send ___________________________
 *
 * 3. release Fn during SEND_FN_TERM.(layer used)
 * Layer sw ___________|~~~~~~|________
 * Fn press ___|~~~~~~~~~~~~~~|________
 * Fn key send ___________________________
 * Fn send ___________________________
 * other key press _____________|~~|__________
 * other key send _____________|~~|__________
 *
 * 4. press other key during SWITCH_DELAY.
 * Layer sw ___________________________
 * Fn key press ___|~~~~~~~~~|_____________
 * Fn key send ______|~~~~~~|_____________
 * other key press ______|~~~|________________
 * other key send _______|~~|________________
 *
 * 5. press Fn while press other key.
 * Layer sw ___________________________
 * Fn key press ___|~~~~~~~~~|_____________
 * Fn key send ___|~~~~~~~~~|_____________
 * other key press ~~~~~~~|___________________
 * other key send ~~~~~~~|___________________
 *
 * 6. press Fn twice quickly and keep holding down.(repeat)
 * Layer sw ___________________________
 * Fn key press ___|~|____|~~~~~~~~~~~~~~~~
 * Fn key send _____|~|__|~~~~~~~~~~~~~~~~
 */
 // LAYER_SWITCH_DELAY: prevent from moving to new layer
 #ifndef LAYER_SWITCH_DELAY
 # define LAYER_SWITCH_DELAY 150
 #endif
 // LAYER_SEND_FN_TERM: send keycode if release key in this term
 #ifndef LAYER_SEND_FN_TERM
 # define LAYER_SEND_FN_TERM 500
 #endif
 uint8_t default_layer = 0;
 uint8_t current_layer = 0;
 static bool layer_used = false;
 static uint8_t new_layer(uint8_t fn_bits);
 uint8_t layer_get_keycode(uint8_t row, uint8_t col)
 {
 uint8_t code = keymap_get_keycode(current_layer, row, col);
 // normal key or mouse key
 if ((IS_KEY(code) || IS_MOUSEKEY(code))) {
 layer_used = true;
 }
 return code;
 }
 // bit substract b from a
 #define BIT_SUBST(a, b) (a&(a^b))
 void layer_switching(uint8_t fn_bits)
 {
 // layer switching
 static uint8_t last_fn = 0;
 static uint8_t last_mods = 0;
 static uint16_t last_timer = 0; 
 static uint8_t sent_fn = 0;
 if (fn_bits == last_fn) { // Fn state is not changed
 if (fn_bits == 0) {
 // do nothing
 } else {
 if (!keymap_fn_keycode(BIT_SUBST(fn_bits, sent_fn)) ||
 timer_elapsed(last_timer) > LAYER_SWITCH_DELAY) {
 uint8_t _layer_to_switch = new_layer(BIT_SUBST(fn_bits, sent_fn));
 if (current_layer != _layer_to_switch) { // not switch layer yet
 debug("Fn case: 1,2,3(LAYER_SWITCH_DELAY passed)\n");
 debug("Switch Layer: "); debug_hex(current_layer);
 current_layer = _layer_to_switch;
 layer_used = false;
 debug(" -> "); debug_hex(current_layer); debug("\n");
 }
 } else {
 if (host_has_anykey()) { // other keys is pressed
 uint8_t _fn_to_send = BIT_SUBST(fn_bits, sent_fn);
 if (_fn_to_send) {
 debug("Fn case: 4(press other key during SWITCH_DELAY.)\n");
 // send only Fn key first
 uint8_t tmp_mods = keyboard_report->mods;
 host_add_code(keymap_fn_keycode(_fn_to_send));
 host_set_mods(last_mods);
 host_send_keyboard_report();
 host_set_mods(tmp_mods);
 host_del_code(keymap_fn_keycode(_fn_to_send));
 sent_fn |= _fn_to_send;
 }
 }
 }
 // add Fn keys to send
 //host_add_code(keymap_fn_keycode(fn_bits&sent_fn)); // TODO: do all Fn keys
 }
 } else { // Fn state is changed(edge)
 uint8_t fn_changed = 0;
 debug("fn_bits: "); debug_bin(fn_bits); debug("\n");
 debug("sent_fn: "); debug_bin(sent_fn); debug("\n");
 debug("last_fn: "); debug_bin(last_fn); debug("\n");
 debug("last_mods: "); debug_hex(last_mods); debug("\n");
 debug("last_timer: "); debug_hex16(last_timer); debug("\n");
 debug("timer_count: "); debug_hex16(timer_count); debug("\n");
 // pressed Fn
 if ((fn_changed = BIT_SUBST(fn_bits, last_fn))) {
 debug("fn_changed: "); debug_bin(fn_changed); debug("\n");
 if (host_has_anykey()) {
 debug("Fn case: 5(pressed Fn with other key)\n");
 sent_fn |= fn_changed;
 } else if (fn_changed & sent_fn) { // pressed same Fn in a row
 if (timer_elapsed(last_timer) > LAYER_SEND_FN_TERM) {
 debug("Fn case: 6(not repeat)\n");
 // time passed: not repeate
 sent_fn &= ~fn_changed;
 } else {
 debug("Fn case: 6(repeat)\n");
 }
 }
 }
 // released Fn
 if ((fn_changed = BIT_SUBST(last_fn, fn_bits))) {
 debug("fn_changed: "); debug_bin(fn_changed); debug("\n");
 if (timer_elapsed(last_timer) < LAYER_SEND_FN_TERM) {
 if (!layer_used && BIT_SUBST(fn_changed, sent_fn)) {
 debug("Fn case: 2(send Fn one shot: released Fn during LAYER_SEND_FN_TERM)\n");
 // send only Fn key first
 uint8_t tmp_mods = keyboard_report->mods;
 host_add_code(keymap_fn_keycode(fn_changed));
 host_set_mods(last_mods);
 host_send_keyboard_report();
 host_set_mods(tmp_mods);
 host_del_code(keymap_fn_keycode(fn_changed));
 sent_fn |= fn_changed;
 }
 }
 debug("Switch Layer(released Fn): "); debug_hex(current_layer);
 current_layer = new_layer(BIT_SUBST(fn_bits, sent_fn));
 debug(" -> "); debug_hex(current_layer); debug("\n");
 }
 layer_used = false;
 last_fn = fn_bits;
 last_mods = keyboard_report->mods;
 last_timer = timer_read();
 }
 // send Fn keys
 for (uint8_t i = 0; i < 8; i++) {
 if ((sent_fn & fn_bits) & (1<<i)) {
 host_add_code(keymap_fn_keycode(1<<i));
 }
 }
 }
 inline
 static uint8_t new_layer(uint8_t fn_bits)
 {
 return (fn_bits ? keymap_fn_layer(fn_bits) : default_layer);
 }
--- a/common/layer.h
+++ b/common/layer.h
 /*
 Copyright 2011 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/>.
 */
 #ifndef LAYER_H
 #define LAYER_H 1
 #include <stdint.h>
 extern uint8_t default_layer;
 extern uint8_t current_layer;
 /* return keycode for switch */
 uint8_t layer_get_keycode(uint8_t row, uint8_t col);
 /* process layer switching */
 void layer_switching(uint8_t fn_bits);
 #endif
--- a/common/matrix.h
+++ b/common/matrix.h
 #ifndef MATRIX_H
 #define MATRIX_H
 #include <stdint.h>
 #include <stdbool.h>
 #if (MATRIX_COLS <= 8)
 typedef uint8_t matrix_row_t;
 #elif (MATRIX_COLS <= 16)
 typedef uint16_t matrix_row_t;
 #elif (MATRIX_COLS <= 32)
 typedef uint32_t matrix_row_t;
 #else
 #error "MATRIX_COLS: invalid value"
 #endif
 #define MATRIX_IS_ON(row, col) (matrix_get_row(row) && (1<<col))
 /* number of matrix rows */
 uint8_t matrix_rows(void);
 /* number of matrix columns */
 /* whether a swtich is on */
 bool matrix_is_on(uint8_t row, uint8_t col);
 /* matrix state on row */
 #if (MATRIX_COLS <= 8)
 uint8_t matrix_get_row(uint8_t row);
 #else
 uint16_t matrix_get_row(uint8_t row);
 #endif
 matrix_row_t matrix_get_row(uint8_t row);
 /* count keys pressed */
 uint8_t matrix_key_count(void);
 /* print matrix for debug */
--- a/common/mousekey.c
+++ b/common/mousekey.c
 #include <stdint.h>
 #include <util/delay.h>
 #include "usb_keycodes.h"
 #include "keycode.h"
 #include "host.h"
 #include "timer.h"
 #include "print.h"
 #include "mousekey.h"
 static report_mouse_t report;
 static report_mouse_t report_prev;
 static uint8_t mousekey_repeat = 0;
 static uint8_t mousekey_accel = 0;
 static void mousekey_debug(void);
 /*
 * TODO: fix acceleration algorithm
 * see wikipedia http://en.wikipedia.org/wiki/Mouse_keys
 * Mouse keys acceleration algorithm
 * http://en.wikipedia.org/wiki/Mouse_keys
 *
 * speed = delta * max_speed * (repeat / time_to_max)**((1000+curve)/1000)
 */
 #ifndef MOUSEKEY_DELAY_TIME
 # define MOUSEKEY_DELAY_TIME 255
 #endif
 /* milliseconds between the initial key press and first repeated motion event (0-2550) */
 uint8_t mk_delay = MOUSEKEY_DELAY/10;
 /* milliseconds between repeated motion events (0-255) */
 uint8_t mk_interval = MOUSEKEY_INTERVAL;
 /* steady speed (in action_delta units) applied each event (0-255) */
 uint8_t mk_max_speed = MOUSEKEY_MAX_SPEED;
 /* number of events (count) accelerating to steady speed (0-255) */
 uint8_t mk_time_to_max = MOUSEKEY_TIME_TO_MAX;
 /* ramp used to reach maximum pointer speed (NOT SUPPORTED) */
 //int8_t mk_curve = 0;
 /* wheel params */
 uint8_t mk_wheel_max_speed = MOUSEKEY_WHEEL_MAX_SPEED;
 uint8_t mk_wheel_time_to_max = MOUSEKEY_WHEEL_TIME_TO_MAX;
 // acceleration parameters
 uint8_t mousekey_move_unit = 2;
 uint8_t mousekey_resolution = 5;
 static uint16_t last_timer = 0;
 static inline uint8_t move_unit(void)
 {
 uint16_t unit = 5 + mousekey_repeat*2;
 return (unit > 63 ? 63 : unit);
 }
 void mousekey_decode(uint8_t code)
 static uint8_t move_unit(void)
 {
 if (code == KB_MS_UP) report.y = -move_unit();
 else if (code == KB_MS_DOWN) report.y = move_unit();
 else if (code == KB_MS_LEFT) report.x = -move_unit();
 else if (code == KB_MS_RIGHT) report.x = move_unit();
 else if (code == KB_MS_BTN1) report.buttons |= MOUSE_BTN1;
 else if (code == KB_MS_BTN2) report.buttons |= MOUSE_BTN2;
 else if (code == KB_MS_BTN3) report.buttons |= MOUSE_BTN3;
 else if (code == KB_MS_BTN4) report.buttons |= MOUSE_BTN4;
 else if (code == KB_MS_BTN5) report.buttons |= MOUSE_BTN5;
 else if (code == KB_MS_WH_UP) report.v += move_unit()/4;
 else if (code == KB_MS_WH_DOWN) report.v -= move_unit()/4;
 else if (code == KB_MS_WH_LEFT) report.h -= move_unit()/4;
 else if (code == KB_MS_WH_RIGHT)report.h += move_unit()/4;
 uint16_t unit;
 if (mousekey_accel & (1<<0)) {
 unit = (MOUSEKEY_MOVE_DELTA * mk_max_speed)/4;
 } else if (mousekey_accel & (1<<1)) {
 unit = (MOUSEKEY_MOVE_DELTA * mk_max_speed)/2;
 } else if (mousekey_accel & (1<<2)) {
 unit = (MOUSEKEY_MOVE_DELTA * mk_max_speed);
 } else if (mousekey_repeat == 0) {
 unit = MOUSEKEY_MOVE_DELTA;
 } else if (mousekey_repeat >= mk_time_to_max) {
 unit = MOUSEKEY_MOVE_DELTA * mk_max_speed;
 } else {
 unit = (MOUSEKEY_MOVE_DELTA * mk_max_speed * mousekey_repeat) / mk_time_to_max;
 }
 return (unit > MOUSEKEY_MOVE_MAX ? MOUSEKEY_MOVE_MAX : (unit == 0 ? 1 : unit));
 }
 bool mousekey_changed(void)
 static uint8_t wheel_unit(void)
 {
 return (report.buttons != report_prev.buttons ||
 report.x || report.y || report.v || report.h);
 uint16_t unit;
 if (mousekey_accel & (1<<0)) {
 unit = (MOUSEKEY_WHEEL_DELTA * mk_wheel_max_speed)/4;
 } else if (mousekey_accel & (1<<1)) {
 unit = (MOUSEKEY_WHEEL_DELTA * mk_wheel_max_speed)/2;
 } else if (mousekey_accel & (1<<2)) {
 unit = (MOUSEKEY_WHEEL_DELTA * mk_wheel_max_speed);
 } else if (mousekey_repeat == 0) {
 unit = MOUSEKEY_WHEEL_DELTA;
 } else if (mousekey_repeat >= mk_time_to_max) {
 unit = MOUSEKEY_WHEEL_DELTA * mk_wheel_max_speed;
 } else {
 unit = (MOUSEKEY_WHEEL_DELTA * mk_wheel_max_speed * mousekey_repeat) / mk_wheel_time_to_max;
 }
 return (unit > MOUSEKEY_WHEEL_MAX ? MOUSEKEY_WHEEL_MAX : (unit == 0 ? 1 : unit));
 }
 void mousekey_send(void)
 void mousekey_task(void)
 {
 static uint16_t last_timer = 0;
 if (!mousekey_changed()) {
 mousekey_repeat = 0;
 mousekey_clear_report();
 if (timer_elapsed(last_timer) < (mousekey_repeat ? mk_interval : mk_delay*10))
 return;
 }
 // send immediately when buttun state is changed
 if (report.buttons == report_prev.buttons) {
 if (timer_elapsed(last_timer) < 100) {
 mousekey_clear_report();
 return;
 }
 }
 if (mouse_report.x == 0 && mouse_report.y == 0 && mouse_report.v == 0 && mouse_report.h == 0)
 return;
 if (mousekey_repeat != 0xFF) {
 if (mousekey_repeat != UINT8_MAX)
 mousekey_repeat++;
 }
 if (report.x && report.y) {
 report.x *= 0.7;
 report.y *= 0.7;
 if (mouse_report.x > 0) mouse_report.x = move_unit();
 if (mouse_report.x < 0) mouse_report.x = move_unit() * -1;
 if (mouse_report.y > 0) mouse_report.y = move_unit();
 if (mouse_report.y < 0) mouse_report.y = move_unit() * -1;
 /* diagonal move [1/sqrt(2) = 0.7] */
 if (mouse_report.x && mouse_report.y) {
 mouse_report.x *= 0.7;
 mouse_report.y *= 0.7;
 }
 if (mouse_report.v > 0) mouse_report.v = wheel_unit();
 if (mouse_report.v < 0) mouse_report.v = wheel_unit() * -1;
 if (mouse_report.h > 0) mouse_report.h = wheel_unit();
 if (mouse_report.h < 0) mouse_report.h = wheel_unit() * -1;
 mousekey_send();
 }
 void mousekey_on(uint8_t code)
 {
 if (code == KC_MS_UP) mouse_report.y = move_unit() * -1;
 else if (code == KC_MS_DOWN) mouse_report.y = move_unit();
 else if (code == KC_MS_LEFT) mouse_report.x = move_unit() * -1;
 else if (code == KC_MS_RIGHT) mouse_report.x = move_unit();
 else if (code == KC_MS_WH_UP) mouse_report.v = wheel_unit();
 else if (code == KC_MS_WH_DOWN) mouse_report.v = wheel_unit() * -1;
 else if (code == KC_MS_WH_LEFT) mouse_report.h = wheel_unit() * -1;
 else if (code == KC_MS_WH_RIGHT) mouse_report.h = wheel_unit();
 else if (code == KC_MS_BTN1) mouse_report.buttons |= MOUSE_BTN1;
 else if (code == KC_MS_BTN2) mouse_report.buttons |= MOUSE_BTN2;
 else if (code == KC_MS_BTN3) mouse_report.buttons |= MOUSE_BTN3;
 else if (code == KC_MS_BTN4) mouse_report.buttons |= MOUSE_BTN4;
 else if (code == KC_MS_BTN5) mouse_report.buttons |= MOUSE_BTN5;
 else if (code == KC_MS_ACCEL0) mousekey_accel |= (1<<0);
 else if (code == KC_MS_ACCEL1) mousekey_accel |= (1<<1);
 else if (code == KC_MS_ACCEL2) mousekey_accel |= (1<<2);
 }
 void mousekey_off(uint8_t code)
 {
 if (code == KC_MS_UP && mouse_report.y < 0) mouse_report.y = 0;
 else if (code == KC_MS_DOWN && mouse_report.y > 0) mouse_report.y = 0;
 else if (code == KC_MS_LEFT && mouse_report.x < 0) mouse_report.x = 0;
 else if (code == KC_MS_RIGHT && mouse_report.x > 0) mouse_report.x = 0;
 else if (code == KC_MS_WH_UP && mouse_report.v > 0) mouse_report.v = 0;
 else if (code == KC_MS_WH_DOWN && mouse_report.v < 0) mouse_report.v = 0;
 else if (code == KC_MS_WH_LEFT && mouse_report.h < 0) mouse_report.h = 0;
 else if (code == KC_MS_WH_RIGHT && mouse_report.h > 0) mouse_report.h = 0;
 else if (code == KC_MS_BTN1) mouse_report.buttons &= ~MOUSE_BTN1;
 else if (code == KC_MS_BTN2) mouse_report.buttons &= ~MOUSE_BTN2;
 else if (code == KC_MS_BTN3) mouse_report.buttons &= ~MOUSE_BTN3;
 else if (code == KC_MS_BTN4) mouse_report.buttons &= ~MOUSE_BTN4;
 else if (code == KC_MS_BTN5) mouse_report.buttons &= ~MOUSE_BTN5;
 else if (code == KC_MS_ACCEL0) mousekey_accel &= ~(1<<0);
 else if (code == KC_MS_ACCEL1) mousekey_accel &= ~(1<<1);
 else if (code == KC_MS_ACCEL2) mousekey_accel &= ~(1<<2);
 if (mouse_report.x == 0 && mouse_report.y == 0 && mouse_report.v == 0 && mouse_report.h == 0)
 mousekey_repeat = 0;
 }
 void mousekey_send(void)
 {
 mousekey_debug();
 host_mouse_send(&report);
 report_prev = report;
 host_mouse_send(&mouse_report);
 last_timer = timer_read();
 mousekey_clear_report();
 }
 void mousekey_clear_report(void)
 void mousekey_clear(void)
 {
 report.buttons = 0;
 report.x = 0;
 report.y = 0;
 report.v = 0;
 report.h = 0;
 mouse_report = (report_mouse_t){};
 mousekey_repeat = 0;
 mousekey_accel = 0;
 }
 static void mousekey_debug(void)
 {
 if (!debug_mouse) return;
 print("mousekey [btn|x y v h]rep: [");
 phex(report.buttons); print("|");
 phex(report.x); print(" ");
 phex(report.y); print(" ");
 phex(report.v); print(" ");
 phex(report.h); print("]");
 phex(mousekey_repeat);
 print("\n");
 print("mousekey [btn|x y v h](rep/acl): [");
 phex(mouse_report.buttons); print("|");
 phex(mouse_report.x); print(" ");
 phex(mouse_report.y); print(" ");
 phex(mouse_report.v); print(" ");
 phex(mouse_report.h); print("](");
 phex(mousekey_repeat); print("/");
 phex(mousekey_accel); print(")\n");
 }
--- a/common/mousekey.h
+++ b/common/mousekey.h
 #include <stdbool.h>
 #include "host.h"
 void mousekey_decode(uint8_t code);
 bool mousekey_changed(void);
 /* max value on report descriptor */
 #define MOUSEKEY_MOVE_MAX 127
 #define MOUSEKEY_WHEEL_MAX 127
 #ifndef MOUSEKEY_MOVE_DELTA
 #define MOUSEKEY_MOVE_DELTA 5
 #endif
 #ifndef MOUSEKEY_WHEEL_DELTA
 #define MOUSEKEY_WHEEL_DELTA 1
 #endif
 #ifndef MOUSEKEY_DELAY
 #define MOUSEKEY_DELAY 300
 #endif
 #ifndef MOUSEKEY_INTERVAL
 #define MOUSEKEY_INTERVAL 50
 #endif
 #ifndef MOUSEKEY_MAX_SPEED
 #define MOUSEKEY_MAX_SPEED 10
 #endif
 #ifndef MOUSEKEY_TIME_TO_MAX
 #define MOUSEKEY_TIME_TO_MAX 20
 #endif
 #ifndef MOUSEKEY_WHEEL_MAX_SPEED
 #define MOUSEKEY_WHEEL_MAX_SPEED 16
 #endif
 #ifndef MOUSEKEY_WHEEL_TIME_TO_MAX
 #define MOUSEKEY_WHEEL_TIME_TO_MAX 40
 #endif
 uint8_t mk_delay;
 uint8_t mk_interval;
 uint8_t mk_max_speed;
 uint8_t mk_time_to_max;
 uint8_t mk_wheel_max_speed;
 uint8_t mk_wheel_time_to_max;
 void mousekey_task(void);
 void mousekey_on(uint8_t code);
 void mousekey_off(uint8_t code);
 void mousekey_clear(void);
 void mousekey_send(void);
 void mousekey_clear_report(void);
 #endif
--- a/common/print.c
+++ b/common/print.c
 phex(i);
 }
 void pdec(uint8_t i)
 {
 if (!print_enable) return;
 if (i/100) sendchar('0' + (i/100));
 if (i/100 || i%100/10) sendchar('0' + (i%100/10));
 sendchar('0' + (i%10));
 }
 void pbin(unsigned char c)
 {
--- a/common/print.h
+++ b/common/print.h
 void print_P(const char *s);
 void phex(unsigned char c);
 void phex16(unsigned int i);
 void pdec(uint8_t i);
 void pbin(unsigned char c);
 void pbin_reverse(unsigned char c);
 #ifdef __cplusplus
--- a/common/timer.c
+++ b/common/timer.c
 // counter resolution 1ms
 // NOTE: union { uint32_t timer32; struct { uint16_t dummy; uint16_t timer16; }}
 volatile uint32_t timer_count = 0;
 void timer_init(void)
--- a/common/usb_keycodes.h
+++ b/common/usb_keycodes.h
 /*
 Copyright 2011 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/>.
 */
 /* 
 * Key codes: HID Keyboard/Keypad Page(0x07)
 * http://www.usb.org/developers/devclass_docs/Hut1_12.pdf
 */
 #ifndef USB_KEYCODES_H
 #define USB_KEYCODES_H
 #define IS_ERROR(code) (KB_ROLL_OVER <= (code) && (code) <= KB_UNDEFINED)
 #define IS_ANY(code) (KB_A <= (code))
 #define IS_KEY(code) (KB_A <= (code) && (code) <= KB_EXSEL)
 #define IS_MOD(code) (KB_LCTRL <= (code) && (code) <= KB_RGUI)
 #define IS_FN(code) (KB_FN0 <= (code) && (code) <= KB_FN7)
 #define IS_MOUSEKEY(code) (KB_MS_UP <= (code) && (code) <= KB_MS_WH_RIGHT)
 #define IS_MOUSEKEY_MOVE(code) (KB_MS_UP <= (code) && (code) <= KB_MS_RIGHT)
 #define IS_MOUSEKEY_BUTTON(code) (KB_MS_BTN1 <= (code) && (code) <= KB_MS_BTN5)
 #define IS_MOUSEKEY_WHEEL(code) (KB_MS_WH_UP <= (code) && (code) <= KB_MS_WH_RIGHT)
 #define MOD_BIT(code) (1<<((code) & 0x07))
 #define FN_BIT(code) (1<<((code) - KB_FN0))
 /* Short names */
 #define KB_LCTL KB_LCTRL
 #define KB_RCTL KB_RCTRL
 #define KB_LSFT KB_LSHIFT
 #define KB_RSFT KB_RSHIFT
 #define KB_ESC KB_ESCAPE
 #define KB_BSPC KB_BSPACE
 #define KB_ENT KB_ENTER
 #define KB_DEL KB_DELETE
 #define KB_INS KB_INSERT
 #define KB_CAPS KB_CAPSLOCK
 #define KB_RGHT KB_RIGHT
 #define KB_PGDN KB_PGDOWN
 #define KB_PSCR KB_PSCREEN
 #define KB_SLCK KB_SCKLOCK
 #define KB_PAUS KB_PAUSE
 #define KB_BRK KB_PAUSE
 #define KB_NLCK KB_NUMLOCK
 #define KB_SPC KB_SPACE
 #define KB_MINS KB_MINUS
 #define KB_EQL KB_EQUAL
 #define KB_GRV KB_GRAVE
 #define KB_RBRC KB_RBRACKET
 #define KB_LBRC KB_LBRACKET
 #define KB_COMM KB_COMMA
 #define KB_BSLS KB_BSLASH
 #define KB_SLSH KB_SLASH
 #define KB_SCLN KB_SCOLON
 #define KB_QUOT KB_QUOTE
 #define KB_APP KB_APPLICATION
 #define KB_NUHS KB_NONUS_HASH
 #define KB_NUBS KB_NONUS_BSLASH
 #define KB_ERAS KB_ALT_ERASE,
 #define KB_CLR KB_CLEAR
 /* for Japanese */
 #define KB_ZKHK KB_GRAVE
 #define KB_RO KB_INT1
 #define KB_KANA KB_INT2
 #define KB_JYEN KB_INT3
 #define KB_HENK KB_INT4
 #define KB_MHEN KB_INT5
 /* Keypad */
 #define KB_P1 KB_KP_1
 #define KB_P2 KB_KP_2
 #define KB_P3 KB_KP_3
 #define KB_P4 KB_KP_4
 #define KB_P5 KB_KP_5
 #define KB_P6 KB_KP_6
 #define KB_P7 KB_KP_7
 #define KB_P8 KB_KP_8
 #define KB_P9 KB_KP_9
 #define KB_P0 KB_KP_0
 #define KB_PDOT KB_KP_DOT
 #define KB_PCMM KB_KP_COMMA
 #define KB_PSLS KB_KP_SLASH
 #define KB_PAST KB_KP_ASTERISK
 #define KB_PMNS KB_KP_MINUS
 #define KB_PPLS KB_KP_PLUS
 #define KB_PEQL KB_KP_EQUAL
 #define KB_PENT KB_KP_ENTER
 /* Mousekey */
 #define KB_MS_U KB_MS_UP
 #define KB_MS_D KB_MS_DOWN
 #define KB_MS_L KB_MS_LEFT
 #define KB_MS_R KB_MS_RIGHT
 #define KB_BTN1 KB_MS_BTN1
 #define KB_BTN2 KB_MS_BTN2
 #define KB_BTN3 KB_MS_BTN3
 #define KB_BTN4 KB_MS_BTN4
 #define KB_BTN5 KB_MS_BTN5
 #define KB_WH_U KB_MS_WH_UP
 #define KB_WH_D KB_MS_WH_DOWN
 #define KB_WH_L KB_MS_WH_LEFT
 #define KB_WH_R KB_MS_WH_RIGHT
 /* Sytem Control & Consumer usage */
 #define KB_PWR KB_SYSTEM_POWER
 #define KB_SLEP KB_SYSTEM_SLEEP
 #define KB_WAKE KB_SYSTEM_WAKE
 #define KB_MUTE KB_AUDIO_MUTE
 #define KB_VOLU KB_AUDIO_VOL_UP
 #define KB_VOLD KB_AUDIO_VOL_DOWN
 #define KB_MNXT KB_MEDIA_NEXT_TRACK
 #define KB_MPRV KB_MEDIA_PREV_TRACK
 #define KB_MSTP KB_MEDIA_STOP
 #define KB_MPLY KB_MEDIA_PLAY_PAUSE
 #define KB_MSEL KB_MEDIA_SELECT
 #define KB_MAIL KB_MAIL
 #define KB_CALC KB_CALCULATOR
 #define KB_MYCM KB_MY_COMPUTER
 #define KB_WSCH KB_WWW_SEARCH
 #define KB_WHOM KB_WWW_HOME
 #define KB_WBAK KB_WWW_BACK
 #define KB_WFWD KB_WWW_FORWARD
 #define KB_WSTP KB_WWW_STOP
 #define KB_WREF KB_WWW_REFRESH
 #define KB_WFAV KB_WWW_FAVORITES
 /* Special keycode */
 enum special_keycodes {
 /* System Control */
 KB_SYSTEM_POWER = 0xB0,
 KB_SYSTEM_SLEEP,
 KB_SYSTEM_WAKE,
 /* Consumer Page */
 KB_AUDIO_MUTE,
 KB_AUDIO_VOL_UP,
 KB_AUDIO_VOL_DOWN,
 KB_MEDIA_NEXT_TRACK,
 KB_MEDIA_PREV_TRACK,
 KB_MEDIA_STOP,
 KB_MEDIA_PLAY_PAUSE,
 KB_MEDIA_SELECT,
 KB_MAIL,
 KB_CALCULATOR,
 KB_MY_COMPUTER,
 KB_WWW_SEARCH,
 KB_WWW_HOME,
 KB_WWW_BACK, /* 0xC0 */
 KB_WWW_FORWARD,
 KB_WWW_STOP,
 KB_WWW_REFRESH,
 KB_WWW_FAVORITES,
 /* reserve 0xE0-E7 for Modifiers */
 /* Layer Switching */
 KB_FN0 = 0xE8,
 KB_FN1,
 KB_FN2,
 KB_FN3,
 KB_FN4,
 KB_FN5,
 KB_FN6,
 KB_FN7,
 /* Mousekey */
 KB_MS_UP = 0xF0,
 KB_MS_DOWN,
 KB_MS_LEFT,
 KB_MS_RIGHT,
 KB_MS_BTN1,
 KB_MS_BTN2,
 KB_MS_BTN3,
 KB_MS_BTN4,
 KB_MS_BTN5,
 /* Mousekey wheel */
 KB_MS_WH_UP,
 KB_MS_WH_DOWN,
 KB_MS_WH_LEFT,
 KB_MS_WH_RIGHT,
 };
 enum keycodes {
 KB_NO = 0,
 KB_ROLL_OVER,
 KB_POST_FAIL,
 KB_UNDEFINED,
 KB_A,
 KB_B,
 KB_C,
 KB_D,
 KB_E,
 KB_F,
 KB_G,
 KB_H,
 KB_I,
 KB_J,
 KB_K,
 KB_L,
 KB_M, /* 0x10 */
 KB_N,
 KB_O,
 KB_P,
 KB_Q,
 KB_R,
 KB_S,
 KB_T,
 KB_U,
 KB_V,
 KB_W,
 KB_X,
 KB_Y,
 KB_Z,
 KB_1,
 KB_2,
 KB_3, /* 0x20 */
 KB_4,
 KB_5,
 KB_6,
 KB_7,
 KB_8,
 KB_9,
 KB_0,
 KB_ENTER,
 KB_ESCAPE,
 KB_BSPACE,
 KB_TAB,
 KB_SPACE,
 KB_MINUS,
 KB_EQUAL,
 KB_LBRACKET,
 KB_RBRACKET, /* 0x30 */
 KB_BSLASH, /* \ (and |) */
 KB_NONUS_HASH, /* Non-US # and ~ */
 KB_SCOLON, /* ; (and :) */
 KB_QUOTE, /* ' and " */
 KB_GRAVE, /* Grave accent and tilde */
 KB_COMMA, /* , and < */
 KB_DOT, /* . and > */
 KB_SLASH, /* / and ? */
 KB_CAPSLOCK,
 KB_F1,
 KB_F2,
 KB_F3,
 KB_F4,
 KB_F5,
 KB_F6,
 KB_F7, /* 0x40 */
 KB_F8,
 KB_F9,
 KB_F10,
 KB_F11,
 KB_F12,
 KB_PSCREEN,
 KB_SCKLOCK,
 KB_PAUSE,
 KB_INSERT,
 KB_HOME,
 KB_PGUP,
 KB_DELETE,
 KB_END,
 KB_PGDOWN,
 KB_RIGHT,
 KB_LEFT, /* 0x50 */
 KB_DOWN,
 KB_UP,
 KB_NUMLOCK,
 KB_KP_SLASH,
 KB_KP_ASTERISK,
 KB_KP_MINUS,
 KB_KP_PLUS,
 KB_KP_ENTER,
 KB_KP_1,
 KB_KP_2,
 KB_KP_3,
 KB_KP_4,
 KB_KP_5,
 KB_KP_6,
 KB_KP_7,
 KB_KP_8, /* 0x60 */
 KB_KP_9,
 KB_KP_0,
 KB_KP_DOT,
 KB_NONUS_BSLASH, /* Non-US \ and | */
 KB_APPLICATION,
 KB_POWER,
 KB_KP_EQUAL,
 KB_F13,
 KB_F14,
 KB_F15,
 KB_F16,
 KB_F17,
 KB_F18,
 KB_F19,
 KB_F20,
 KB_F21, /* 0x70 */
 KB_F22,
 KB_F23,
 KB_F24,
 KB_EXECUTE,
 KB_HELP,
 KB_MENU,
 KB_SELECT,
 KB_STOP,
 KB_AGAIN,
 KB_UNDO,
 KB_CUT,
 KB_COPY,
 KB_PASTE,
 KB_FIND,
 KB__MUTE,
 KB__VOLUP, /* 0x80 */
 KB__VOLDOWN,
 KB_LOCKING_CAPS, /* locking Caps Lock */
 KB_LOCKING_NUM, /* locking Num Lock */
 KB_LOCKING_SCROLL, /* locking Scroll Lock */
 KB_KP_COMMA,
 KB_KP_EQUAL_AS400, /* equal sign on AS/400 */
 KB_INT1,
 KB_INT2,
 KB_INT3,
 KB_INT4,
 KB_INT5,
 KB_INT6,
 KB_INT7,
 KB_INT8,
 KB_INT9,
 KB_LANG1, /* 0x90 */
 KB_LANG2,
 KB_LANG3,
 KB_LANG4,
 KB_LANG5,
 KB_LANG6,
 KB_LANG7,
 KB_LANG8,
 KB_LANG9,
 KB_ALT_ERASE,
 KB_SYSREQ,
 KB_CANCEL,
 KB_CLEAR,
 KB_PRIOR,
 KB_RETURN,
 KB_SEPARATOR,
 KB_OUT, /* 0xA0 */
 KB_OPER,
 KB_CLEAR_AGAIN,
 KB_CRSEL,
 KB_EXSEL,
 /* NOTE: 0xB0-DF are used as special_keycodes */
 #if 0
 KB_KP_00 = 0xB0,
 KB_KP_000,
 KB_THOUSANDS_SEPARATOR,
 KB_DECIMAL_SEPARATOR,
 KB_CURRENCY_UNIT,
 KB_CURRENCY_SUB_UNIT,
 KB_KP_LPAREN,
 KB_KP_RPAREN,
 KB_KP_LCBRACKET, /* { */
 KB_KP_RCBRACKET, /* } */
 KB_KP_TAB,
 KB_KP_BSPACE,
 KB_KP_A,
 KB_KP_B,
 KB_KP_C,
 KB_KP_D,
 KB_KP_E, /* 0xC0 */
 KB_KP_F,
 KB_KP_XOR,
 KB_KP_HAT,
 KB_KP_PERC,
 KB_KP_LT,
 KB_KP_GT,
 KB_KP_AND,
 KB_KP_LAZYAND,
 KB_KP_OR,
 KB_KP_LAZYOR,
 KB_KP_COLON,
 KB_KP_HASH,
 KB_KP_SPACE,
 KB_KP_ATMARK,
 KB_KP_EXCLAMATION,
 KB_KP_MEM_STORE, /* 0xD0 */
 KB_KP_MEM_RECALL,
 KB_KP_MEM_CLEAR,
 KB_KP_MEM_ADD,
 KB_KP_MEM_SUB,
 KB_KP_MEM_MUL,
 KB_KP_MEM_DIV,
 KB_KP_PLUS_MINUS,
 KB_KP_CLEAR,
 KB_KP_CLEAR_ENTRY,
 KB_KP_BINARY,
 KB_KP_OCTAL,
 KB_KP_DECIMAL,
 KB_KP_HEXADECIMAL,
 #endif
 /* Modifiers */
 KB_LCTRL = 0xE0,
 KB_LSHIFT,
 KB_LALT,
 KB_LGUI,
 KB_RCTRL,
 KB_RSHIFT,
 KB_RALT,
 KB_RGUI,
 /* NOTE: 0xE8-FF are used as special_keycodes */
 };
 #endif /* USB_KEYCODES_H */
--- a/common/util.c
+++ b/common/util.c
 #include "util.h"
 // bit population
 int bitpop(uint8_t bits)
 // bit population - return number of on-bit
 uint8_t bitpop(uint8_t bits)
 {
 int c;
 uint8_t c;
 for (c = 0; bits; c++)
 bits &= bits -1;
 return c;
 /*
 const uint8_t bit_count[] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4 };
 return bit_count[bits>>4] + bit_count[bits&0x0F]
 */
 }
 // most significant on-bit
 int biton(uint8_t bits)
 // most significant on-bit - return highest location of on-bit
 uint8_t biton(uint8_t bits)
 {
 int n = 0;
 uint8_t n = 0;
 if (bits >> 4) { bits >>= 4; n += 4;}
 if (bits >> 2) { bits >>= 2; n += 2;}
 if (bits >> 1) { bits >>= 1; n += 1;}
--- a/common/util.h
+++ b/common/util.h
 #define XSTR(s) #s
 int bitpop(uint8_t bits);
 int biton(uint8_t bits);
 uint8_t bitpop(uint8_t bits);
 uint8_t biton(uint8_t bits);
 #endif
--- a/converter/adb_usb/README.md
+++ b/converter/adb_usb/README.md
 ------
 You can change a keymap by editing code of keymap.c like following.
 This is a keymap for AEK, however, also used for other keyboards.
 How to define the keymap is probably obvious. You can find key symbols in usb_keycodes.h.
 How to define the keymap is probably obvious. You can find key symbols in keycode.h.
 If you want to define some keymaps than just one, see hhkb/keymap.c and
 macway/keymap.c as examples. Keymap(layer) switching may needs a bit of
 effort at this time.
--- a/converter/adb_usb/config.h
+++ b/converter/adb_usb/config.h
 /* key combination for command */
 #include "adb.h"
 #include "matrix.h"
 #define IS_COMMAND() ( \
 matrix_is_on(MATRIX_ROW(ADB_POWER), MATRIX_COL(ADB_POWER)) \
 )
--- a/converter/adb_usb/keymap.c
+++ b/converter/adb_usb/keymap.c
 #include <stdbool.h>
 #include <avr/pgmspace.h>
 #include "usb_keyboard.h"
 #include "usb_keycodes.h"
 #include "keycode.h"
 #include "print.h"
 #include "debug.h"
 #include "util.h"
 K38,K06,K07,K08,K09,K0B,K2D,K2E,K2B,K2F,K2C, K7B, K3E, K53,K54,K55, \
 K36,K3A,K37, K31, K3B,K3D,K3C, K52, K41,K4C \
 ) { \
 { KB_##K00, KB_##K01, KB_##K02, KB_##K03, KB_##K04, KB_##K05, KB_##K06, KB_##K07 }, \
 { KB_##K08, KB_##K09, KB_NO, KB_##K0B, KB_##K0C, KB_##K0D, KB_##K0E, KB_##K0F }, \
 { KB_##K10, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_##K17 }, \
 { KB_##K18, KB_##K19, KB_##K1A, KB_##K1B, KB_##K1C, KB_##K1D, KB_##K1E, KB_##K1F }, \
 { KB_##K20, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_##K27 }, \
 { KB_##K28, KB_##K29, KB_##K2A, KB_##K2B, KB_##K2C, KB_##K2D, KB_##K2E, KB_##K2F }, \
 { KB_##K30, KB_##K31, KB_##K32, KB_##K33, KB_NO, KB_##K35, KB_##K36, KB_##K37 }, \
 { KB_##K38, KB_##K39, KB_##K3A, KB_##K3B, KB_##K3C, KB_##K3D, KB_##K3E, KB_NO }, \
 { KB_NO, KB_##K41, KB_NO, KB_##K43, KB_NO, KB_##K45, KB_NO, KB_##K47 }, \
 { KB_NO, KB_NO, KB_NO, KB_##K4B, KB_##K4C, KB_NO, KB_##K4E, KB_NO }, \
 { KB_NO, KB_##K51, KB_##K52, KB_##K53, KB_##K54, KB_##K55, KB_##K56, KB_##K57 }, \
 { KB_##K58, KB_##K59, KB_NO, KB_##K5B, KB_##K5C, KB_NO, KB_NO, KB_NO }, \
 { KB_##K60, KB_##K61, KB_##K62, KB_##K63, KB_##K64, KB_##K65, KB_NO, KB_##K67 }, \
 { KB_NO, KB_##K69, KB_NO, KB_##K6B, KB_NO, KB_##K6D, KB_NO, KB_##K6F }, \
 { KB_NO, KB_##K71, KB_##K72, KB_##K73, KB_##K74, KB_##K75, KB_##K76, KB_##K77 }, \
 { KB_##K78, KB_##K79, KB_##K7A, KB_##K7B, KB_NO, KB_NO, KB_NO, KB_##K7F } \
 { 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_NO, KC_##K35, KC_##K36, KC_##K37 }, \
 { KC_##K38, KC_##K39, KC_##K3A, KC_##K3B, KC_##K3C, KC_##K3D, KC_##K3E, KC_NO }, \
 { KC_NO, KC_##K41, KC_NO, KC_##K43, KC_NO, KC_##K45, KC_NO, KC_##K47 }, \
 { KC_NO, KC_NO, KC_NO, KC_##K4B, KC_##K4C, KC_NO, KC_##K4E, KC_NO }, \
 { KC_NO, KC_##K51, 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_##K60, KC_##K61, KC_##K62, KC_##K63, KC_##K64, KC_##K65, KC_NO, KC_##K67 }, \
 { KC_NO, KC_##K69, KC_NO, KC_##K6B, KC_NO, KC_##K6D, KC_NO, 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_NO, KC_NO, KC_NO, KC_##K7F } \
 }
 // 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[] = {
 KB_NO, // Fn0
 KB_NO, // Fn1
 KB_NO, // Fn2
 KB_NO, // Fn3
 KB_NO, // Fn4
 KB_NO, // Fn5
 KB_NO, // Fn6
 KB_NO // Fn7
 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] = {
--- a/converter/m0110_usb/config.h
+++ b/converter/m0110_usb/config.h
 /* key combination for command */
 #define IS_COMMAND() ( \
 keyboard_report->mods == (MOD_BIT(KB_LALT) | MOD_BIT(KB_LGUI)) \
 keyboard_report->mods == (MOD_BIT(KC_LALT) | MOD_BIT(KC_LGUI)) \
 )
--- a/converter/m0110_usb/keymap.c
+++ b/converter/m0110_usb/keymap.c
 #include <stdbool.h>
 #include <avr/pgmspace.h>
 #include "usb_keyboard.h"
 #include "usb_keycodes.h"
 #include "keycode.h"
 #include "print.h"
 #include "debug.h"
 #include "util.h"
 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 \
 ) { \
 { KB_##K00, KB_##K01, KB_##K02, KB_##K03, KB_##K04, KB_##K05, KB_##K06, KB_##K07 }, \
 { KB_##K08, KB_##K09, KB_NO, KB_##K0B, KB_##K0C, KB_##K0D, KB_##K0E, KB_##K0F }, \
 { KB_##K10, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_##K17 }, \
 { KB_##K18, KB_##K19, KB_##K1A, KB_##K1B, KB_##K1C, KB_##K1D, KB_##K1E, KB_##K1F }, \
 { KB_##K20, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_##K27 }, \
 { KB_##K28, KB_##K29, KB_##K2A, KB_##K2B, KB_##K2C, KB_##K2D, KB_##K2E, KB_##K2F }, \
 { KB_##K30, KB_##K31, KB_##K32, KB_##K33, KB_##K34, KB_NO, KB_NO, KB_##K37 }, \
 { KB_##K38, KB_##K39, KB_##K3A, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, \
 { KB_NO, KB_##K41, KB_##K42, KB_NO, KB_NO, KB_NO, KB_##K46, KB_##K47 }, \
 { KB_##K48, KB_NO, KB_NO, KB_NO, KB_##K4C, KB_##K4D, KB_##K4E, KB_NO }, \
 { KB_NO, KB_NO, KB_##K52, KB_##K53, KB_##K54, KB_##K55, KB_##K56, KB_##K57 }, \
 { KB_##K58, KB_##K59, KB_NO, KB_##K5B, KB_##K5C, KB_NO, KB_NO, KB_NO }, \
 { KB_NO, KB_NO, KB_##K62, KB_NO, KB_NO, KB_NO, KB_##K66, KB_NO }, \
 { KB_##K68, KB_NO, KB_NO, KB_NO, KB_NO, KB_##K6D, KB_NO, KB_NO }, \
 { 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 }, \
 }
 // See layer.c for details.
 static const uint8_t PROGMEM fn_keycode[] = {
 #ifndef HASU
 KB_NO, // Fn0
 KB_NO, // Fn1
 KB_NO, // Fn2
 KB_NO, // Fn3
 KB_NO, // Fn4
 KB_NO, // Fn5
 KB_NO, // Fn6
 KB_NO // Fn7
 KC_NO, // Fn0
 KC_NO, // Fn1
 KC_NO, // Fn2
 KC_NO, // Fn3
 KC_NO, // Fn4
 KC_NO, // Fn5
 KC_NO, // Fn6
 KC_NO // Fn7
 #else
 KB_ENTER, // Fn0
 KB_SCOLON, // Fn1
 KB_SLASH, // Fn2
 KB_UP, // Fn3
 KB_NO, // Fn4
 KB_NO, // Fn5
 KB_NO, // Fn6
 KB_NO // Fn7
 KC_ENTER, // Fn0
 KC_SCOLON, // Fn1
 KC_SLASH, // Fn2
 KC_UP, // Fn3
 KC_NO, // Fn4
 KC_NO, // Fn5
 KC_NO, // Fn6
 KC_NO // Fn7
 #endif
 };
--- a/converter/news_usb/config_pjrc.h
+++ b/converter/news_usb/config_pjrc.h
 /* key combination for command */
 #define IS_COMMAND() ( \
 keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_RSHIFT)) || \
 keyboard_report->mods == (MOD_BIT(KB_LCTRL) | MOD_BIT(KB_RSHIFT)) \
 keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) || \
 keyboard_report->mods == (MOD_BIT(KC_LCTRL) | MOD_BIT(KC_RSHIFT)) \
 )
--- a/converter/news_usb/keymap.c
+++ b/converter/news_usb/keymap.c
 #include <stdint.h>
 #include <stdbool.h>
 #include <avr/pgmspace.h>
 #include "usb_keycodes.h"
 #include "keycode.h"
 #include "util.h"
 #include "keymap.h"
 K36,K37,K38,K39,K3A,K3B,K3C,K3D,K3E,K3F,K40,K41, K42, K6D, K57,K59,K58, \
 K43,K44,K45, K46, K47, K48,K49,K4A, K6E, K66,K5B,K5C,K5D \
 ) { \
 { KB_NO, KB_##K01, KB_##K02, KB_##K03, KB_##K04, KB_##K05, KB_##K06, KB_##K07 }, \
 { KB_##K08, KB_##K09, KB_##K0A, KB_##K0B, KB_##K0C, KB_##K0D, KB_##K0E, KB_##K0F }, \
 { KB_##K10, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_##K17 }, \
 { KB_##K18, KB_##K19, KB_##K1A, KB_##K1B, KB_##K1C, KB_##K1D, KB_##K1E, KB_##K1F }, \
 { KB_##K20, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_##K27 }, \
 { KB_##K28, KB_##K29, KB_##K2A, KB_##K2B, KB_##K2C, KB_##K2D, KB_##K2E, KB_##K2F }, \
 { KB_##K30, KB_##K31, KB_##K32, KB_##K33, KB_##K34, KB_##K35, KB_##K36, KB_##K37 }, \
 { KB_##K38, KB_##K39, KB_##K3A, KB_##K3B, KB_##K3C, KB_##K3D, KB_##K3E, KB_##K3F }, \
 { KB_##K40, KB_##K41, KB_##K42, KB_##K43, KB_##K44, KB_##K45, KB_##K46, KB_##K47 }, \
 { KB_##K48, KB_##K49, KB_##K4A, KB_##K4B, KB_##K4C, KB_##K4D, KB_##K4E, KB_##K4F }, \
 { KB_##K50, KB_##K51, KB_##K52, KB_##K53, KB_##K54, KB_##K55, KB_##K56, KB_##K57 }, \
 { KB_##K58, KB_##K59, KB_##K5A, KB_##K5B, KB_##K5C, KB_##K5D, KB_NO, KB_NO }, \
 { KB_NO, KB_NO, KB_NO, KB_NO, KB_##K64, KB_##K65, KB_##K66, KB_NO }, \
 { KB_##K68, KB_##K69, KB_##K6A, KB_##K6B, KB_##K6C, KB_##K6D, KB_##K6E, KB_NO }, \
 { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, }, \
 { KB_NO, KB_NO, KB_##K7A, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO } \
 { KC_NO, 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_##K34, KC_##K35, KC_##K36, KC_##K37 }, \
 { KC_##K38, KC_##K39, KC_##K3A, KC_##K3B, KC_##K3C, KC_##K3D, KC_##K3E, KC_##K3F }, \
 { KC_##K40, KC_##K41, KC_##K42, KC_##K43, KC_##K44, KC_##K45, KC_##K46, KC_##K47 }, \
 { KC_##K48, KC_##K49, KC_##K4A, KC_##K4B, KC_##K4C, KC_##K4D, 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_NO, KC_NO }, \
 { KC_NO, KC_NO, KC_NO, KC_NO, KC_##K64, KC_##K65, KC_##K66, KC_NO }, \
 { KC_##K68, KC_##K69, KC_##K6A, KC_##K6B, KC_##K6C, KC_##K6D, KC_##K6E, KC_NO }, \
 { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, }, \
 { KC_NO, KC_NO, KC_##K7A, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO } \
 }
 // 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[] = {
 KB_NO, // Fn0
 KB_NO, // Fn1
 KB_NO, // Fn2
 KB_NO, // Fn3
 KB_NO, // Fn4
 KB_NO, // Fn5
 KB_NO, // Fn6
 KB_NO // Fn7
 KC_NO, // Fn0
 KC_NO, // Fn1
 KC_NO, // Fn2
 KC_NO, // Fn3
 KC_NO, // Fn4
 KC_NO, // Fn5
 KC_NO, // Fn6
 KC_NO // Fn7
 };
--- a/converter/ps2_usb/config.h
+++ b/converter/ps2_usb/config.h
 /* key combination for command */
 #define IS_COMMAND() ( \
 keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_RSHIFT)) || \
 keyboard_report->mods == (MOD_BIT(KB_LCTRL) | MOD_BIT(KB_RSHIFT)) \
 keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) || \
 keyboard_report->mods == (MOD_BIT(KC_LCTRL) | MOD_BIT(KC_RSHIFT)) \
 )
--- a/converter/ps2_usb/keymap.c
+++ b/converter/ps2_usb/keymap.c
 #include <stdint.h>
 #include <stdbool.h>
 #include <avr/pgmspace.h>
 #include "usb_keycodes.h"
 #include "keycode.h"
 #include "print.h"
 #include "debug.h"
 #include "util.h"
 K90, KBA, KB8, KB0, /* WWW Search, Home, Back, Forward */ \
 KA8, KA0, K98 /* WWW Stop, Refresh, Favorites */ \
 ) { \
 { KB_NO, KB_##K01, KB_NO, KB_##K03, KB_##K04, KB_##K05, KB_##K06, KB_##K07 }, \
 { KB_##K08, KB_##K09, KB_##K0A, KB_##K0B, KB_##K0C, KB_##K0D, KB_##K0E, KB_NO }, \
 { KB_##K10, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_NO }, \
 { KB_##K18, KB_NO, KB_##K1A, KB_##K1B, KB_##K1C, KB_##K1D, KB_##K1E, KB_NO }, \
 { KB_##K20, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_NO }, \
 { KB_##K28, KB_##K29, KB_##K2A, KB_##K2B, KB_##K2C, KB_##K2D, KB_##K2E, KB_NO }, \
 { KB_##K30, KB_##K31, KB_##K32, KB_##K33, KB_##K34, KB_##K35, KB_##K36, KB_NO }, \
 { KB_##K38, KB_NO, KB_##K3A, KB_##K3B, KB_##K3C, KB_##K3D, KB_##K3E, KB_NO }, \
 { KB_##K40, KB_##K41, KB_##K42, KB_##K43, KB_##K44, KB_##K45, KB_##K46, KB_NO }, \
 { KB_##K48, KB_##K49, KB_##K4A, KB_##K4B, KB_##K4C, KB_##K4D, KB_##K4E, KB_NO }, \
 { KB_##K50, KB_##K51, KB_##K52, KB_NO, KB_##K54, KB_##K55, KB_NO, KB_##K57 }, \
 { KB_##K58, KB_##K59, KB_##K5A, KB_##K5B, KB_NO, KB_##K5D, KB_NO, KB_##K5F }, \
 { KB_NO, KB_##K61, KB_NO, KB_NO, KB_##K64, KB_NO, KB_##K66, KB_##K67 }, \
 { KB_NO, KB_##K69, KB_##K6A, KB_##K6B, KB_##K6C, KB_NO, KB_NO, KB_NO }, \
 { KB_##K70, KB_##K71, KB_##K72, KB_##K73, KB_##K74, KB_##K75, KB_##K76, KB_##K77 }, \
 { KB_##K78, KB_##K79, KB_##K7A, KB_##K7B, KB_##K7C, KB_##K7D, KB_##K7E, KB_NO }, \
 { KB_NO, KB_NO, KB_NO, KB_##K83, KB_NO, KB_NO, KB_NO, KB_NO }, \
 { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, \
 { KB_##K90, KB_##K91, KB_NO, KB_NO, KB_##K94, KB_##K95, KB_NO, KB_NO }, \
 { KB_##K98, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_##K9F }, \
 { KB_##KA0, KB_##KA1, KB_NO, KB_##KA3, KB_NO, KB_NO, KB_NO, KB_##KA7 }, \
 { KB_##KA8, KB_NO, KB_NO, KB_##KAB, KB_NO, KB_NO, KB_NO, KB_##KAF }, \
 { KB_##KB0, KB_NO, KB_##KB2, KB_NO, KB_##KB4, KB_NO, KB_NO, KB_##KB7 }, \
 { KB_##KB8, KB_NO, KB_##KBA, KB_##KBB, KB_NO, KB_NO, KB_NO, KB_##KBF }, \
 { KB_##KC0, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, \
 { KB_##KC8, KB_NO, KB_##KCA, KB_NO, KB_NO, KB_##KCD, KB_NO, KB_NO }, \
 { KB_##KD0, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, \
 { KB_NO, KB_NO, KB_##KDA, KB_NO, KB_NO, KB_NO, KB_##KDE, KB_NO }, \
 { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, \
 { KB_NO, KB_##KE9, KB_NO, KB_##KEB, KB_##KEC, KB_NO, KB_NO, KB_NO }, \
 { KB_##KF0, KB_##KF1, KB_##KF2, KB_NO, KB_##KF4, KB_##KF5, KB_NO, KB_NO }, \
 { KB_NO, KB_NO, KB_##KFA, KB_NO, KB_##KFC, KB_##KFD, KB_##KFE, KB_NO }, \
 { KC_NO, KC_##K01, KC_NO, 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_NO }, \
 { KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_NO }, \
 { KC_##K18, KC_NO, KC_##K1A, KC_##K1B, KC_##K1C, KC_##K1D, KC_##K1E, KC_NO }, \
 { KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_NO }, \
 { KC_##K28, KC_##K29, KC_##K2A, KC_##K2B, KC_##K2C, KC_##K2D, KC_##K2E, KC_NO }, \
 { KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_NO }, \
 { KC_##K38, KC_NO, KC_##K3A, KC_##K3B, KC_##K3C, KC_##K3D, KC_##K3E, KC_NO }, \
 { KC_##K40, KC_##K41, KC_##K42, KC_##K43, KC_##K44, KC_##K45, KC_##K46, KC_NO }, \
 { KC_##K48, KC_##K49, KC_##K4A, KC_##K4B, KC_##K4C, KC_##K4D, KC_##K4E, KC_NO }, \
 { KC_##K50, KC_##K51, KC_##K52, KC_NO, KC_##K54, KC_##K55, KC_NO, KC_##K57 }, \
 { KC_##K58, KC_##K59, KC_##K5A, KC_##K5B, KC_NO, KC_##K5D, KC_NO, KC_##K5F }, \
 { KC_NO, KC_##K61, KC_NO, KC_NO, KC_##K64, KC_NO, KC_##K66, KC_##K67 }, \
 { KC_NO, KC_##K69, KC_##K6A, KC_##K6B, KC_##K6C, KC_NO, KC_NO, KC_NO }, \
 { KC_##K70, 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_##K7E, KC_NO }, \
 { KC_NO, KC_NO, KC_NO, KC_##K83, 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_##K90, KC_##K91, KC_NO, KC_NO, KC_##K94, KC_##K95, KC_NO, KC_NO }, \
 { KC_##K98, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_##K9F }, \
 { KC_##KA0, KC_##KA1, KC_NO, KC_##KA3, KC_NO, KC_NO, KC_NO, KC_##KA7 }, \
 { KC_##KA8, KC_NO, KC_NO, KC_##KAB, KC_NO, KC_NO, KC_NO, KC_##KAF }, \
 { KC_##KB0, KC_NO, KC_##KB2, KC_NO, KC_##KB4, KC_NO, KC_NO, KC_##KB7 }, \
 { KC_##KB8, KC_NO, KC_##KBA, KC_##KBB, KC_NO, KC_NO, KC_NO, KC_##KBF }, \
 { KC_##KC0, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \
 { KC_##KC8, KC_NO, KC_##KCA, KC_NO, KC_NO, KC_##KCD, KC_NO, KC_NO }, \
 { KC_##KD0, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \
 { KC_NO, KC_NO, KC_##KDA, KC_NO, KC_NO, KC_NO, KC_##KDE, KC_NO }, \
 { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \
 { KC_NO, KC_##KE9, KC_NO, KC_##KEB, KC_##KEC, KC_NO, KC_NO, KC_NO }, \
 { KC_##KF0, KC_##KF1, KC_##KF2, KC_NO, KC_##KF4, KC_##KF5, KC_NO, KC_NO }, \
 { KC_NO, KC_NO, KC_##KFA, KC_NO, KC_##KFC, KC_##KFD, KC_##KFE, KC_NO }, \
 }
 /* US layout */
 // 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[] = {
 KB_SCLN, // Fn0
 KB_SLSH, // Fn1
 KB_NO, // Fn2
 KB_NO, // Fn3
 KB_NO, // Fn4
 KB_NO, // Fn5
 KB_NO, // Fn6
 KB_NO // Fn7
 KC_SCLN, // Fn0
 KC_SLSH, // Fn1
 KC_NO, // Fn2
 KC_NO, // Fn3
 KC_NO, // Fn4
 KC_NO, // Fn5
 KC_NO, // Fn6
 KC_NO // Fn7
 };
 // The keymap is a 32*8 byte array which convert a PS/2 scan code into a USB keycode.
 // See usb_keycodes.h for USB keycodes. You should omit a 'KB_' prefix of USB keycodes in keymap macro.
 // See keycode.h for USB keycodes. You should omit a 'KC_' prefix of USB keycodes in keymap macro.
 // Use KEYMAP_ISO() or KEYMAP_JIS() instead of KEYMAP() if your keyboard is ISO or JIS.
 static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 /* 0: default
--- a/converter/ps2_usb/keymap_jis.c
+++ b/converter/ps2_usb/keymap_jis.c
 #include <stdint.h>
 #include <stdbool.h>
 #include <avr/pgmspace.h>
 #include "usb_keycodes.h"
 #include "keycode.h"
 #include "print.h"
 #include "debug.h"
 #include "util.h"
 K90, KBA, KB8, KB0, /* WWW Search, Home, Back, Forward */ \
 KA8, KA0, K98 /* WWW Stop, Refresh, Favorites */ \
 ) { \
 { KB_NO, KB_##K01, KB_NO, KB_##K03, KB_##K04, KB_##K05, KB_##K06, KB_##K07 }, \
 { KB_##K08, KB_##K09, KB_##K0A, KB_##K0B, KB_##K0C, KB_##K0D, KB_##K0E, KB_NO }, \
 { KB_##K10, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_NO }, \
 { KB_##K18, KB_NO, KB_##K1A, KB_##K1B, KB_##K1C, KB_##K1D, KB_##K1E, KB_NO }, \
 { KB_##K20, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_NO }, \
 { KB_##K28, KB_##K29, KB_##K2A, KB_##K2B, KB_##K2C, KB_##K2D, KB_##K2E, KB_NO }, \
 { KB_##K30, KB_##K31, KB_##K32, KB_##K33, KB_##K34, KB_##K35, KB_##K36, KB_NO }, \
 { KB_##K38, KB_NO, KB_##K3A, KB_##K3B, KB_##K3C, KB_##K3D, KB_##K3E, KB_NO }, \
 { KB_##K40, KB_##K41, KB_##K42, KB_##K43, KB_##K44, KB_##K45, KB_##K46, KB_NO }, \
 { KB_##K48, KB_##K49, KB_##K4A, KB_##K4B, KB_##K4C, KB_##K4D, KB_##K4E, KB_NO }, \
 { KB_##K50, KB_##K51, KB_##K52, KB_NO, KB_##K54, KB_##K55, KB_NO, KB_##K57 }, \
 { KB_##K58, KB_##K59, KB_##K5A, KB_##K5B, KB_NO, KB_##K5D, KB_NO, KB_##K5F }, \
 { KB_NO, KB_##K61, KB_NO, KB_NO, KB_##K64, KB_NO, KB_##K66, KB_##K67 }, \
 { KB_NO, KB_##K69, KB_##K6A, KB_##K6B, KB_##K6C, KB_NO, KB_NO, KB_NO }, \
 { KB_##K70, KB_##K71, KB_##K72, KB_##K73, KB_##K74, KB_##K75, KB_##K76, KB_##K77 }, \
 { KB_##K78, KB_##K79, KB_##K7A, KB_##K7B, KB_##K7C, KB_##K7D, KB_##K7E, KB_NO }, \
 { KB_NO, KB_NO, KB_NO, KB_##K83, KB_NO, KB_NO, KB_NO, KB_NO }, \
 { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, \
 { KB_##K90, KB_##K91, KB_NO, KB_NO, KB_##K94, KB_##K95, KB_NO, KB_NO }, \
 { KB_##K98, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_##K9F }, \
 { KB_##KA0, KB_##KA1, KB_NO, KB_##KA3, KB_NO, KB_NO, KB_NO, KB_##KA7 }, \
 { KB_##KA8, KB_NO, KB_NO, KB_##KAB, KB_NO, KB_NO, KB_NO, KB_##KAF }, \
 { KB_##KB0, KB_NO, KB_##KB2, KB_NO, KB_##KB4, KB_NO, KB_NO, KB_##KB7 }, \
 { KB_##KB8, KB_NO, KB_##KBA, KB_##KBB, KB_NO, KB_NO, KB_NO, KB_##KBF }, \
 { KB_##KC0, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, \
 { KB_##KC8, KB_NO, KB_##KCA, KB_NO, KB_NO, KB_##KCD, KB_NO, KB_NO }, \
 { KB_##KD0, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, \
 { KB_NO, KB_NO, KB_##KDA, KB_NO, KB_NO, KB_NO, KB_##KDE, KB_NO }, \
 { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, \
 { KB_NO, KB_##KE9, KB_NO, KB_##KEB, KB_##KEC, KB_NO, KB_NO, KB_NO }, \
 { KB_##KF0, KB_##KF1, KB_##KF2, KB_NO, KB_##KF4, KB_##KF5, KB_NO, KB_NO }, \
 { KB_NO, KB_NO, KB_##KFA, KB_NO, KB_##KFC, KB_##KFD, KB_##KFE, KB_NO }, \
 { KC_NO, KC_##K01, KC_NO, 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_NO }, \
 { KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_NO }, \
 { KC_##K18, KC_NO, KC_##K1A, KC_##K1B, KC_##K1C, KC_##K1D, KC_##K1E, KC_NO }, \
 { KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_NO }, \
 { KC_##K28, KC_##K29, KC_##K2A, KC_##K2B, KC_##K2C, KC_##K2D, KC_##K2E, KC_NO }, \
 { KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_NO }, \
 { KC_##K38, KC_NO, KC_##K3A, KC_##K3B, KC_##K3C, KC_##K3D, KC_##K3E, KC_NO }, \
 { KC_##K40, KC_##K41, KC_##K42, KC_##K43, KC_##K44, KC_##K45, KC_##K46, KC_NO }, \
 { KC_##K48, KC_##K49, KC_##K4A, KC_##K4B, KC_##K4C, KC_##K4D, KC_##K4E, KC_NO }, \
 { KC_##K50, KC_##K51, KC_##K52, KC_NO, KC_##K54, KC_##K55, KC_NO, KC_##K57 }, \
 { KC_##K58, KC_##K59, KC_##K5A, KC_##K5B, KC_NO, KC_##K5D, KC_NO, KC_##K5F }, \
 { KC_NO, KC_##K61, KC_NO, KC_NO, KC_##K64, KC_NO, KC_##K66, KC_##K67 }, \
 { KC_NO, KC_##K69, KC_##K6A, KC_##K6B, KC_##K6C, KC_NO, KC_NO, KC_NO }, \
 { KC_##K70, 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_##K7E, KC_NO }, \
 { KC_NO, KC_NO, KC_NO, KC_##K83, 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_##K90, KC_##K91, KC_NO, KC_NO, KC_##K94, KC_##K95, KC_NO, KC_NO }, \
 { KC_##K98, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_##K9F }, \
 { KC_##KA0, KC_##KA1, KC_NO, KC_##KA3, KC_NO, KC_NO, KC_NO, KC_##KA7 }, \
 { KC_##KA8, KC_NO, KC_NO, KC_##KAB, KC_NO, KC_NO, KC_NO, KC_##KAF }, \
 { KC_##KB0, KC_NO, KC_##KB2, KC_NO, KC_##KB4, KC_NO, KC_NO, KC_##KB7 }, \
 { KC_##KB8, KC_NO, KC_##KBA, KC_##KBB, KC_NO, KC_NO, KC_NO, KC_##KBF }, \
 { KC_##KC0, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \
 { KC_##KC8, KC_NO, KC_##KCA, KC_NO, KC_NO, KC_##KCD, KC_NO, KC_NO }, \
 { KC_##KD0, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \
 { KC_NO, KC_NO, KC_##KDA, KC_NO, KC_NO, KC_NO, KC_##KDE, KC_NO }, \
 { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \
 { KC_NO, KC_##KE9, KC_NO, KC_##KEB, KC_##KEC, KC_NO, KC_NO, KC_NO }, \
 { KC_##KF0, KC_##KF1, KC_##KF2, KC_NO, KC_##KF4, KC_##KF5, KC_NO, KC_NO }, \
 { KC_NO, KC_NO, KC_##KFA, KC_NO, KC_##KFC, KC_##KFD, KC_##KFE, KC_NO }, \
 }
 /* JIS layout */
 // 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[] = {
 KB_SCLN, // Fn0
 KB_SLSH, // Fn1
 KB_BSPC, // Fn2
 KB_NO, // Fn3
 KB_NO, // Fn4
 KB_SPC, // Fn5
 KB_NO, // Fn6
 KB_NO // Fn7
 KC_SCLN, // Fn0
 KC_SLSH, // Fn1
 KC_BSPC, // Fn2
 KC_NO, // Fn3
 KC_NO, // Fn4
 KC_SPC, // Fn5
 KC_NO, // Fn6
 KC_NO // Fn7
 };
 // The keymap is a 32*8 byte array which convert a PS/2 scan code into a USB keycode.
 // See usb_keycodes.h for USB keycodes. You should omit a 'KB_' prefix of USB keycodes in keymap macro.
 // See keycode.h for USB keycodes. You should omit a 'KC_' prefix of USB keycodes in keymap macro.
 // Use KEYMAP_ISO() or KEYMAP_JIS() instead of KEYMAP() if your keyboard is ISO or JIS.
 static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 /* 0: JIS LAYOUT
--- a/converter/terminal_usb/config_102_pjrc.h
+++ b/converter/terminal_usb/config_102_pjrc.h
 /* key combination for command */
 #define IS_COMMAND() ( \
 keyboard_report->mods == (MOD_BIT(KB_RALT) | MOD_BIT(KB_RCTL)) \
 keyboard_report->mods == (MOD_BIT(KC_RALT) | MOD_BIT(KC_RCTL)) \
 )
--- a/converter/terminal_usb/config_122_pjrc.h
+++ b/converter/terminal_usb/config_122_pjrc.h
 /* key combination for command */
 #define IS_COMMAND() ( \
 keyboard_report->mods == (MOD_BIT(KB_RALT) | MOD_BIT(KB_RCTL)) \
 keyboard_report->mods == (MOD_BIT(KC_RALT) | MOD_BIT(KC_RCTL)) \
 )
--- a/converter/terminal_usb/keymap_102.c
+++ b/converter/terminal_usb/keymap_102.c
 #include <stdint.h>
 #include <stdbool.h>
 #include <avr/pgmspace.h>
 #include "usb_keycodes.h"
 #include "keycode.h"
 #include "print.h"
 #include "debug.h"
 #include "util.h"
 K12,K13,K1A,K22,K21,K2A,K32,K31,K3A,K41,K49,K4A, K51,K59, K63, K69,K72,K7A,K79, \
 K11, K19, K29, K39, K58, K61,K60,K6A, K68,K70,K71,K78 \
 ) { \
 { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_##K07 }, \
 { KB_##K08, KB_NO, KB_NO, KB_NO, KB_NO, KB_##K0D, KB_##K0E, KB_##K0F }, \
 { KB_NO, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_##K17 }, \
 { KB_NO, KB_##K19, KB_##K1A, KB_##K1B, KB_##K1C, KB_##K1D, KB_##K1E, KB_##K1F }, \
 { KB_NO, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_##K27 }, \
 { KB_NO, KB_##K29, KB_##K2A, KB_##K2B, KB_##K2C, KB_##K2D, KB_##K2E, KB_##K2F }, \
 { KB_NO, KB_##K31, KB_##K32, KB_##K33, KB_##K34, KB_##K35, KB_##K36, KB_##K37 }, \
 { KB_NO, KB_##K39, KB_##K3A, KB_##K3B, KB_##K3C, KB_##K3D, KB_##K3E, KB_##K3F }, \
 { KB_NO, KB_##K41, KB_##K42, KB_##K43, KB_##K44, KB_##K45, KB_##K46, KB_##K47 }, \
 { KB_NO, KB_##K49, KB_##K4A, KB_##K4B, KB_##K4C, KB_##K4D, KB_##K4E, KB_##K4F }, \
 { KB_NO, KB_##K51, KB_##K52, KB_##K53, KB_##K54, KB_##K55, KB_##K56, KB_##K57 }, \
 { KB_##K58, KB_##K59, KB_##K5A, KB_##K5B, KB_##K5C, KB_##K5D, KB_##K5E, KB_##K5F }, \
 { KB_##K60, KB_##K61, KB_##K62, KB_##K63, KB_##K64, KB_##K65, KB_##K66, KB_##K67 }, \
 { KB_##K68, KB_##K69, KB_##K6A, KB_##K6B, KB_##K6C, KB_##K6D, KB_##K6E, KB_##K6F }, \
 { KB_##K70, KB_##K71, KB_##K72, KB_##K73, KB_##K74, KB_##K75, KB_##K76, KB_##K77 }, \
 { KB_##K78, KB_##K79, KB_##K7A, KB_##K7B, KB_##K7C, KB_##K7D, KB_##K7E, KB_NO }, \
 { KB_NO, KB_NO, KB_NO, KB_NO, KB_##K84, KB_NO, KB_NO, KB_NO, }, \
 { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_##K07 }, \
 { KC_##K08, KC_NO, KC_NO, KC_NO, KC_NO, KC_##K0D, KC_##K0E, KC_##K0F }, \
 { KC_NO, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_##K17 }, \
 { KC_NO, KC_##K19, KC_##K1A, KC_##K1B, KC_##K1C, KC_##K1D, KC_##K1E, KC_##K1F }, \
 { KC_NO, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_##K27 }, \
 { KC_NO, KC_##K29, KC_##K2A, KC_##K2B, KC_##K2C, KC_##K2D, KC_##K2E, KC_##K2F }, \
 { KC_NO, KC_##K31, KC_##K32, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_##K37 }, \
 { KC_NO, KC_##K39, KC_##K3A, KC_##K3B, KC_##K3C, KC_##K3D, KC_##K3E, KC_##K3F }, \
 { KC_NO, KC_##K41, KC_##K42, KC_##K43, KC_##K44, KC_##K45, KC_##K46, KC_##K47 }, \
 { KC_NO, KC_##K49, KC_##K4A, KC_##K4B, KC_##K4C, KC_##K4D, KC_##K4E, KC_##K4F }, \
 { KC_NO, 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_##K6C, KC_##K6D, KC_##K6E, KC_##K6F }, \
 { KC_##K70, 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_##K7E, KC_NO }, \
 { KC_NO, KC_NO, KC_NO, KC_NO, KC_##K84, KC_NO, KC_NO, KC_NO, }, \
 }
 // 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[] = {
 KB_SCLN, // Fn0
 KB_SLSH, // Fn1
 KB_ESC, // Fn2
 KB_NO, // Fn3
 KB_NO, // Fn4
 KB_NO, // Fn5
 KB_NO, // Fn6
 KB_NO // Fn7
 KC_SCLN, // Fn0
 KC_SLSH, // Fn1
 KC_ESC, // Fn2
 KC_NO, // Fn3
 KC_NO, // Fn4
 KC_NO, // Fn5
 KC_NO, // Fn6
 KC_NO // Fn7
 };
--- a/converter/terminal_usb/keymap_122.c
+++ b/converter/terminal_usb/keymap_122.c
 #include <stdint.h>
 #include <stdbool.h>
 #include <avr/pgmspace.h>
 #include "usb_keycodes.h"
 #include "keycode.h"
 #include "print.h"
 #include "debug.h"
 #include "util.h"
 K83,K0A, K12,K13,K1A,K22,K21,K2A,K32,K31,K3A,K41,K49,K4A, K51,K59, K61,K62,K6A, K69,K72,K7A,K79, \
 K01,K09, K11, K19, K29, K39, K58, K60, K68,K70,K71,K78 \
 ) { \
 { KB_NO, KB_##K01, KB_NO, KB_##K03, KB_##K04, KB_##K05, KB_##K06, KB_##K07 }, \
 { KB_##K08, KB_##K09, KB_##K0A, KB_##K0B, KB_##K0C, KB_##K0D, KB_##K0E, KB_##K0F }, \
 { KB_##K10, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_##K17 }, \
 { KB_##K18, KB_##K19, KB_##K1A, KB_##K1B, KB_##K1C, KB_##K1D, KB_##K1E, KB_##K1F }, \
 { KB_##K20, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_##K27 }, \
 { KB_##K28, KB_##K29, KB_##K2A, KB_##K2B, KB_##K2C, KB_##K2D, KB_##K2E, KB_##K2F }, \
 { KB_##K30, KB_##K31, KB_##K32, KB_##K33, KB_##K34, KB_##K35, KB_##K36, KB_##K37 }, \
 { KB_##K38, KB_##K39, KB_##K3A, KB_##K3B, KB_##K3C, KB_##K3D, KB_##K3E, KB_##K3F }, \
 { KB_##K40, KB_##K41, KB_##K42, KB_##K43, KB_##K44, KB_##K45, KB_##K46, KB_##K47 }, \
 { KB_##K48, KB_##K49, KB_##K4A, KB_##K4B, KB_##K4C, KB_##K4D, KB_##K4E, KB_##K4F }, \
 { KB_##K50, KB_##K51, KB_##K52, KB_##K53, KB_##K54, KB_##K55, KB_##K56, KB_##K57 }, \
 { KB_##K58, KB_##K59, KB_##K5A, KB_##K5B, KB_##K5C, KB_##K5D, KB_##K5E, KB_##K5F }, \
 { KB_##K60, KB_##K61, KB_##K62, KB_##K63, KB_##K64, KB_##K65, KB_##K66, KB_##K67 }, \
 { KB_##K68, KB_##K69, KB_##K6A, KB_##K6B, KB_##K6C, KB_##K6D, KB_##K6E, KB_##K6F }, \
 { KB_##K70, KB_##K71, KB_##K72, KB_##K73, KB_##K74, KB_##K75, KB_##K76, KB_##K77 }, \
 { KB_##K78, KB_##K79, KB_##K7A, KB_##K7B, KB_##K7C, KB_##K7D, KB_##K7E, KB_NO }, \
 { KB_NO, KB_NO, KB_NO, KB_##K83, KB_##K84, KB_NO, KB_NO, KB_NO, }, \
 { KC_NO, KC_##K01, KC_NO, 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_##K34, KC_##K35, KC_##K36, KC_##K37 }, \
 { KC_##K38, KC_##K39, KC_##K3A, KC_##K3B, KC_##K3C, KC_##K3D, KC_##K3E, KC_##K3F }, \
 { KC_##K40, KC_##K41, KC_##K42, KC_##K43, KC_##K44, KC_##K45, KC_##K46, KC_##K47 }, \
 { KC_##K48, KC_##K49, KC_##K4A, KC_##K4B, KC_##K4C, KC_##K4D, 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_##K6C, KC_##K6D, KC_##K6E, KC_##K6F }, \
 { KC_##K70, 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_##K7E, KC_NO }, \
 { KC_NO, KC_NO, KC_NO, KC_##K83, KC_##K84, KC_NO, KC_NO, KC_NO, }, \
 }
 // 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[] = {
 KB_NO, // Fn0
 KB_NO, // Fn1
 KB_NO, // Fn2
 KB_NO, // Fn3
 KB_NO, // Fn4
 KB_NO, // Fn5
 KB_NO, // Fn6
 KB_NO // Fn7
 KC_NO, // Fn0
 KC_NO, // Fn1
 KC_NO, // Fn2
 KC_NO, // Fn3
 KC_NO, // Fn4
 KC_NO, // Fn5
 KC_NO, // Fn6
 KC_NO // Fn7
 };
--- a/converter/usb_usb/config.h
+++ b/converter/usb_usb/config.h
 /* key combination for command */
 #define IS_COMMAND() (keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_RSHIFT))) 
 #define IS_COMMAND() (keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) 
 #endif
--- a/converter/usb_usb/keymap.c
+++ b/converter/usb_usb/keymap.c
 */
 #include <avr/pgmspace.h>
 #include "usb_keycodes.h"
 #include "keycode.h"
 #include "util.h"
 #include "keymap.h"
 KE1,K1D,K1B,K06,K19,K05,K11,K10,K36,K37,K38, KE5, K52, K59,K5A,K5B, \
 KE0,KE3,KE2, K2C, KE6,KE7,K65,KE4, K50,K51,K4F, K62, K63,K58 \
 ) { \
 { KB_NO, KB_NO, KB_NO, KB_NO, KB_##K04, KB_##K05, KB_##K06, KB_##K07 }, /* 00-07 */ \
 { KB_##K08, KB_##K09, KB_##K0A, KB_##K0B, KB_##K0C, KB_##K0D, KB_##K0E, KB_##K0F }, /* 08-0F */ \
 { KB_##K10, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_##K17 }, /* 10-17 */ \
 { KB_##K18, KB_##K19, KB_##K1A, KB_##K1B, KB_##K1C, KB_##K1D, KB_##K1E, KB_##K1F }, /* 18-1F */ \
 { KB_##K20, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_##K27 }, /* 20-27 */ \
 { KB_##K28, KB_##K29, KB_##K2A, KB_##K2B, KB_##K2C, KB_##K2D, KB_##K2E, KB_##K2F }, /* 28-2F */ \
 { KB_##K30, KB_##K31, KB_NO, KB_##K33, KB_##K34, KB_##K35, KB_##K36, KB_##K37 }, /* 30-37 */ \
 { KB_##K38, KB_##K39, KB_##K3A, KB_##K3B, KB_##K3C, KB_##K3D, KB_##K3E, KB_##K3F }, /* 38-3F */ \
 { KB_##K40, KB_##K41, KB_##K42, KB_##K43, KB_##K44, KB_##K45, KB_##K46, KB_##K47 }, /* 40-47 */ \
 { KB_##K48, KB_##K49, KB_##K4A, KB_##K4B, KB_##K4C, KB_##K4D, KB_##K4E, KB_##K4F }, /* 48-4F */ \
 { KB_##K50, KB_##K51, KB_##K52, KB_##K53, KB_##K54, KB_##K55, KB_##K56, KB_##K57 }, /* 50-57 */ \
 { KB_##K58, KB_##K59, KB_##K5A, KB_##K5B, KB_##K5C, KB_##K5D, KB_##K5E, KB_##K5F }, /* 58-5F */ \
 { KB_##K60, KB_##K61, KB_##K62, KB_##K63, KB_NO, KB_##K65, KB_NO, KB_NO }, /* 60-67 */ \
 { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* 68-6F */ \
 { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* 70-77 */ \
 { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* 78-7F */ \
 { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* 80-87 */ \
 { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* 88-8F */ \
 { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* 90-97 */ \
 { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* 98-9F */ \
 { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* A0-A7 */ \
 { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* A8-AF */ \
 { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* B0-B7 */ \
 { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* B8-BF */ \
 { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* C0-C7 */ \
 { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* C8-CF */ \
 { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* D0-D7 */ \
 { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* D8-DF */ \
 { KB_##KE0, KB_##KE1, KB_##KE2, KB_##KE3, KB_##KE4, KB_##KE5, KB_##KE6, KB_##KE7 }, /* E0-E7 */ \
 { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* E8-EF */ \
 { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* F0-F7 */ \
 { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* F8-FF */ \
 { KC_NO, KC_NO, KC_NO, KC_NO, KC_##K04, KC_##K05, KC_##K06, KC_##K07 }, /* 00-07 */ \
 { KC_##K08, KC_##K09, KC_##K0A, KC_##K0B, KC_##K0C, KC_##K0D, KC_##K0E, KC_##K0F }, /* 08-0F */ \
 { KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_##K17 }, /* 10-17 */ \
 { KC_##K18, KC_##K19, KC_##K1A, KC_##K1B, KC_##K1C, KC_##K1D, KC_##K1E, KC_##K1F }, /* 18-1F */ \
 { KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_##K27 }, /* 20-27 */ \
 { KC_##K28, KC_##K29, KC_##K2A, KC_##K2B, KC_##K2C, KC_##K2D, KC_##K2E, KC_##K2F }, /* 28-2F */ \
 { KC_##K30, KC_##K31, KC_NO, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_##K37 }, /* 30-37 */ \
 { KC_##K38, KC_##K39, KC_##K3A, KC_##K3B, KC_##K3C, KC_##K3D, KC_##K3E, KC_##K3F }, /* 38-3F */ \
 { KC_##K40, KC_##K41, KC_##K42, KC_##K43, KC_##K44, KC_##K45, KC_##K46, KC_##K47 }, /* 40-47 */ \
 { KC_##K48, KC_##K49, KC_##K4A, KC_##K4B, KC_##K4C, KC_##K4D, KC_##K4E, KC_##K4F }, /* 48-4F */ \
 { KC_##K50, KC_##K51, KC_##K52, KC_##K53, KC_##K54, KC_##K55, KC_##K56, KC_##K57 }, /* 50-57 */ \
 { KC_##K58, KC_##K59, KC_##K5A, KC_##K5B, KC_##K5C, KC_##K5D, KC_##K5E, KC_##K5F }, /* 58-5F */ \
 { KC_##K60, KC_##K61, KC_##K62, KC_##K63, KC_NO, KC_##K65, KC_NO, KC_NO }, /* 60-67 */ \
 { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* 68-6F */ \
 { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* 70-77 */ \
 { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* 78-7F */ \
 { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* 80-87 */ \
 { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* 88-8F */ \
 { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* 90-97 */ \
 { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* 98-9F */ \
 { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* A0-A7 */ \
 { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* A8-AF */ \
 { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* B0-B7 */ \
 { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* B8-BF */ \
 { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* C0-C7 */ \
 { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* C8-CF */ \
 { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* D0-D7 */ \
 { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* D8-DF */ \
 { KC_##KE0, KC_##KE1, KC_##KE2, KC_##KE3, KC_##KE4, KC_##KE5, KC_##KE6, KC_##KE7 }, /* E0-E7 */ \
 { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* E8-EF */ \
 { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* F0-F7 */ \
 { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* F8-FF */ \
 }
 static const uint8_t PROGMEM fn_layer[] = { 5, 6, 5, 0, 0, 0, 0, 0 };
 // Codes to register by clicking Fn key(0-7)
 static const uint8_t PROGMEM fn_keycode[] = { KB_SCLN, KB_SLSH, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO };
 static const uint8_t PROGMEM fn_keycode[] = { KC_SCLN, KC_SLSH, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO };
 static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 /* 0: default
--- a/converter/usb_usb/main.cpp
+++ b/converter/usb_usb/main.cpp
 DDRF = (1<<7);
 for (;;) {
 PORTF ^= (1<<7);
 keyboard_proc();
 keyboard_task();
 timer = timer_read();
 usb_host.Task();
--- a/converter/usb_usb/matrix.c
+++ b/converter/usb_usb/matrix.c
 #include <stdint.h>
 #include <stdbool.h>
 #include "usb_hid.h"
 #include "usb_keycodes.h"
 #include "keycode.h"
 #include "util.h"
 #include "print.h"
 #include "debug.h"
--- a/converter/x68k_usb/config_pjrc.h
+++ b/converter/x68k_usb/config_pjrc.h
 /* key combination for command */
 #define IS_COMMAND() ( \
 keyboard_report->mods == (MOD_BIT(KB_LALT) | MOD_BIT(KB_RALT)) || \
 keyboard_report->mods == (MOD_BIT(KB_LCTRL) | MOD_BIT(KB_RSHIFT)) \
 keyboard_report->mods == (MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT)) || \
 keyboard_report->mods == (MOD_BIT(KC_LCTRL) | MOD_BIT(KC_RSHIFT)) \
 )
--- a/converter/x68k_usb/keymap.c
+++ b/converter/x68k_usb/keymap.c
 #include <stdint.h>
 #include <stdbool.h>
 #include <avr/pgmspace.h>
 #include "usb_keycodes.h"
 #include "keycode.h"
 #include "util.h"
 #include "keymap.h"
 K70,K2A,K2B,K2C,K2D,K2E,K2F,K30,K31,K32,K33,K34, K3B,K3E,K3D, K4B,K4C,K4D,K4E, \
 K5F,K55,K56, K35, K57,K58,K59,K60, K72, K73, K4F,K50,K51 \
 ) { \
 { KB_NO, KB_##K01, KB_##K02, KB_##K03, KB_##K04, KB_##K05, KB_##K06, KB_##K07 }, \
 { KB_##K08, KB_##K09, KB_##K0A, KB_##K0B, KB_##K0C, KB_##K0D, KB_##K0E, KB_##K0F }, \
 { KB_##K10, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_##K17 }, \
 { KB_##K18, KB_##K19, KB_##K1A, KB_##K1B, KB_##K1C, KB_##K1D, KB_##K1E, KB_##K1F }, \
 { KB_##K20, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_##K27 }, \
 { KB_##K28, KB_##K29, KB_##K2A, KB_##K2B, KB_##K2C, KB_##K2D, KB_##K2E, KB_##K2F }, \
 { KB_##K30, KB_##K31, KB_##K32, KB_##K33, KB_##K34, KB_##K35, KB_##K36, KB_##K37 }, \
 { KB_##K38, KB_##K39, KB_##K3A, KB_##K3B, KB_##K3C, KB_##K3D, KB_##K3E, KB_##K3F }, \
 { KB_##K40, KB_##K41, KB_##K42, KB_##K43, KB_##K44, KB_##K45, KB_##K46, KB_##K47 }, \
 { KB_##K48, KB_##K49, KB_##K4A, KB_##K4B, KB_##K4C, KB_##K4D, KB_##K4E, KB_##K4F }, \
 { KB_##K50, KB_##K51, KB_##K52, KB_##K53, KB_##K54, KB_##K55, KB_##K56, KB_##K57 }, \
 { KB_##K58, KB_##K59, KB_##K5A, KB_##K5B, KB_##K5C, KB_##K5D, KB_##K5E, KB_##K5F }, \
 { KB_##K60, KB_##K61, KB_##K62, KB_##K63, KB_##K64, KB_##K65, KB_##K66, KB_##K67 }, \
 { KB_##K68, KB_##K69, KB_##K6A, KB_##K6B, KB_##K6C, KB_NO, KB_NO, KB_NO }, \
 { KB_##K70, KB_##K71, KB_##K72, KB_##K73, KB_NO, KB_NO, KB_NO, KB_NO, }, \
 { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO } \
 { KC_NO, 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_##K34, KC_##K35, KC_##K36, KC_##K37 }, \
 { KC_##K38, KC_##K39, KC_##K3A, KC_##K3B, KC_##K3C, KC_##K3D, KC_##K3E, KC_##K3F }, \
 { KC_##K40, KC_##K41, KC_##K42, KC_##K43, KC_##K44, KC_##K45, KC_##K46, KC_##K47 }, \
 { KC_##K48, KC_##K49, KC_##K4A, KC_##K4B, KC_##K4C, KC_##K4D, 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_##K6C, KC_NO, KC_NO, KC_NO }, \
 { KC_##K70, KC_##K71, KC_##K72, KC_##K73, KC_NO, KC_NO, KC_NO, KC_NO, }, \
 { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO } \
 }
 // 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[] = {
 KB_NO, // Fn0
 KB_NO, // Fn1
 KB_NO, // Fn2
 KB_NO, // Fn3
 KB_NO, // Fn4
 KB_NO, // Fn5
 KB_NO, // Fn6
 KB_NO // Fn7
 KC_NO, // Fn0
 KC_NO, // Fn1
 KC_NO, // Fn2
 KC_NO, // Fn3
 KC_NO, // Fn4
 KC_NO, // Fn5
 KC_NO, // Fn6
 KC_NO // Fn7
 };
--- a/keyboard/IIgs_Standard/README
+++ b/keyboard/IIgs_Standard/README
 0. When DEBOUNCE defined, there is a errors. 
 1. Layer Change by toggling Clear Key 
 2. Eject Key add. (following files should be modified.) 
 common/usb_keycodes.h 
 common/keycode.h 
 common/keyboard.c 
 3. Use bluetooth 
 EOF 
--- a/keyboard/IIgs_Standard/config.h
+++ b/keyboard/IIgs_Standard/config.h
 /* key combination for command */ 
 #define IS_COMMAND() ( \ 
 keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_LCTRL) | MOD_BIT(KB_LALT) | MOD_BIT(KB_LGUI)) || \ 
 keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_RSHIFT)) \ 
 keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_LCTRL) | MOD_BIT(KC_LALT) | MOD_BIT(KC_LGUI)) || \ 
 keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \ 
 ) 
--- a/keyboard/IIgs_Standard/keymap.c
+++ b/keyboard/IIgs_Standard/keymap.c
 #include <stdint.h> 
 #include <stdbool.h> 
 #include <avr/pgmspace.h> 
 #include "usb_keycodes.h" 
 #include "keycode.h" 
 #include "print.h" 
 #include "debug.h" 
 #include "util.h" 
 { R5C0, R5C1, R5C2, R5C3, R5C4, R5C5, R5C6, R5C7 }, \ 
 { R6C0, R6C1, R6C2, R6C3, R6C4, R6C5, R6C6, R6C7 }, \ 
 { R7C0, R7C1, R7C2, R7C3, R7C4, R7C5, R7C6, R7C7 }, \ 
 { R8C0, R8C1, KB_NO, KB_NO, KB_NO,KB_NO, KB_NO, KB_NO }, \ 
 { R8C0, R8C1, KC_NO, KC_NO, KC_NO,KC_NO, KC_NO, KC_NO }, \ 
 { R9C0, R9C1, R9C2, R9C3, R9C4, R9C5, R9C6, R9C7 }, \ 
 { R10C0,R10C1, R10C2, R10C3, R10C4,R10C5, KB_NO, KB_NO} \ 
 { R10C0,R10C1, R10C2, R10C3, R10C4,R10C5, KC_NO, KC_NO} \ 
 } 
 #define KEYCODE(layer, row, col) (pgm_read_byte(&keymaps[(layer)][(row)][(col)])) 
 // 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[] = { 
 KB_NO, // Fn0 
 KB_NO, // Fn1 
 KB_SLSH, // Fn2 
 KB_SCLN, // Fn3 
 KB_SPC, // Fn4 
 KB_NO, // Fn5 
 KB_NO, // Fn6 
 KB_NO // Fn7 
 KC_NO, // Fn0 
 KC_NO, // Fn1 
 KC_SLSH, // Fn2 
 KC_SCLN, // Fn3 
 KC_SPC, // Fn4 
 KC_NO, // Fn5 
 KC_NO, // Fn6 
 KC_NO // Fn7 
 }; 
 static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { 
 * |CAPS|Alt |Gui |` |SPC |BSLS |LFT|RGT|DN|UP| | 0 | . | T | 
 * `-----------------------------------------------------------' |---------------' 
 */ 
 KEYMAP( KB_PWR, 
 KB_ESC, KB_1, KB_2, KB_3, KB_4, KB_5, KB_6, KB_7, KB_8, KB_9, KB_0, KB_MINS,KB_EQL, KB_BSPC, KB_FN1, KB_PEQL, KB_PSLS, KB_PAST, \ 
 KB_TAB, KB_Q, KB_W, KB_E, KB_R, KB_T, KB_Y, KB_U, KB_I, KB_O, KB_P, KB_LBRC,KB_RBRC, KB_P7, KB_P8, KB_P9, KB_PPLS, \ 
 KB_LCTL,KB_A, KB_S, KB_D, KB_F, KB_G, KB_H, KB_J, KB_K, KB_L, KB_SCLN, KB_QUOT,KB_ENT, KB_P4, KB_P5, KB_P6, KB_PMNS, \ 
 KB_LSFT,KB_Z, KB_X, KB_C, KB_V, KB_B, KB_N, KB_M, KB_COMM,KB_DOT, KB_SLSH, KB_P1, KB_P2, KB_P3, \ 
 KB_CAPS,KB_LALT,KB_LGUI,KB_GRV, KB_SPC, KB_BSLS,KB_LEFT,KB_RGHT,KB_DOWN,KB_UP, KB_P0, KB_PDOT, KB_PENT), 
 KEYMAP( KC_PWR, 
 KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS,KC_EQL, KC_BSPC, KC_FN1, KC_PEQL, KC_PSLS, KC_PAST, \ 
 KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC,KC_RBRC, KC_P7, KC_P8, KC_P9, KC_PPLS, \ 
 KC_LCTL,KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT,KC_ENT, KC_P4, KC_P5, KC_P6, KC_PMNS, \ 
 KC_LSFT,KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM,KC_DOT, KC_SLSH, KC_P1, KC_P2, KC_P3, \ 
 KC_CAPS,KC_LALT,KC_LGUI,KC_GRV, KC_SPC, KC_BSLS,KC_LEFT,KC_RGHT,KC_DOWN,KC_UP, KC_P0, KC_PDOT, KC_PENT), 
 /* Layer 1: Tenkey use Layer 
 * |CAPS|Alt |Gui |` |SPC |BSLS |LFT|RGT|DN|UP| | 0 | . | T | 
 * `-----------------------------------------------------------' `---------------' 
 */ 
 KEYMAP( KB_PWR, \ 
 KB_ESC, KB_1, KB_2, KB_3, KB_4, KB_5, KB_6, KB_7, KB_8, KB_9, KB_0, KB_MINS,KB_EQL, KB_BSPC, KB_FN1, KB_PEQL, KB_PSLS, KB_MUTE, \ 
 KB_TAB, KB_Q, KB_W, KB_E, KB_R, KB_T, KB_Y, KB_U, KB_I, KB_O, KB_P, KB_LBRC,KB_RBRC, KB_INS, KB_P8, KB_PGUP, KB_VOLU, \ 
 KB_LCTL,KB_A, KB_S, KB_D, KB_F, KB_G, KB_H, KB_J, KB_K, KB_L, KB_SCLN, KB_QUOT,KB_ENT, KB_DEL, KB_UP, KB_PGDN, KB_VOLD, \ 
 KB_LSFT,KB_Z, KB_X, KB_C, KB_V, KB_B, KB_N, KB_M, KB_COMM,KB_DOT, KB_SLSH, KB_LEFT, KB_DOWN, KB_RIGHT, \ 
 KB_CAPS,KB_LALT,KB_LGUI,KB_GRV, KB_SPC, KB_BSLS,KB_LEFT,KB_RGHT,KB_DOWN,KB_UP, KB_P0, KB_PDOT, KB_PENT), 
 KEYMAP( KC_PWR, \ 
 KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS,KC_EQL, KC_BSPC, KC_FN1, KC_PEQL, KC_PSLS, KC_MUTE, \ 
 KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC,KC_RBRC, KC_INS, KC_P8, KC_PGUP, KC_VOLU, \ 
 KC_LCTL,KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT,KC_ENT, KC_DEL, KC_UP, KC_PGDN, KC_VOLD, \ 
 KC_LSFT,KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM,KC_DOT, KC_SLSH, KC_LEFT, KC_DOWN, KC_RIGHT, \ 
 KC_CAPS,KC_LALT,KC_LGUI,KC_GRV, KC_SPC, KC_BSLS,KC_LEFT,KC_RGHT,KC_DOWN,KC_UP, KC_P0, KC_PDOT, KC_PENT), 
 }; 
--- a/keyboard/hbkb/config.h
+++ b/keyboard/hbkb/config.h
 /* key combination for command */
 #define IS_COMMAND() ( \
 keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_LCTRL) | MOD_BIT(KB_LALT) | MOD_BIT(KB_LGUI)) || \
 keyboard_report->mods == (MOD_BIT(KB_LALT) | MOD_BIT(KB_RALT)) \
 keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_LCTRL) | MOD_BIT(KC_LALT) | MOD_BIT(KC_LGUI)) || \
 keyboard_report->mods == (MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT)) \
 )
--- a/keyboard/hbkb/keymap.c
+++ b/keyboard/hbkb/keymap.c
 #include <stdint.h>
 #include <stdbool.h>
 #include <avr/pgmspace.h>
 #include "usb_keycodes.h"
 #include "keycode.h"
 #include "print.h"
 #include "debug.h"
 #include "util.h"
 K11, K26, K36, K46, K56, K57, K77, K76, K86, K96, KA7, K16, \
 K02, KB0, K67, KB7, K06 \
 ) { \
 { KB_NO, KB_NO, KB_##K02, KB_NO, KB_NO, KB_NO, KB_##K06, KB_NO }, \
 { KB_NO, KB_##K11, KB_NO, KB_NO, KB_NO, KB_NO, KB_##K16, KB_NO }, \
 { KB_NO, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_NO }, \
 { KB_NO, KB_##K31, KB_NO, KB_##K33, KB_##K34, KB_##K35, KB_##K36, KB_NO }, \
 { KB_NO, KB_NO, KB_NO, KB_##K43, KB_##K44, KB_##K45, KB_##K46, KB_NO }, \
 { KB_##K50, KB_##K51, KB_##K52, KB_##K53, KB_##K54, KB_##K55, KB_##K56, KB_##K57 }, \
 { KB_NO, KB_##K61, KB_NO, KB_NO, KB_##K64, KB_##K65, KB_##K66, KB_##K67 }, \
 { KB_##K70, KB_##K71, KB_##K72, KB_##K73, KB_##K74, KB_##K75, KB_##K76, KB_##K77 }, \
 { KB_NO, KB_##K81, KB_##K82, KB_##K83, KB_##K84, KB_##K85, KB_##K86, KB_NO }, \
 { KB_NO, KB_NO, KB_NO, KB_##K93, KB_##K94, KB_##K95, KB_##K96, KB_NO }, \
 { KB_##KA0, KB_##KA1, KB_##KA2, KB_##KA3, KB_##KA4, KB_##KA5, KB_NO, KB_##KA7 }, \
 { KB_##KB0, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_##KB7 }, \
 { KC_NO, KC_NO, KC_##K02, KC_NO, KC_NO, KC_NO, KC_##K06, KC_NO }, \
 { KC_NO, KC_##K11, KC_NO, KC_NO, KC_NO, KC_NO, KC_##K16, KC_NO }, \
 { KC_NO, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_NO }, \
 { KC_NO, KC_##K31, KC_NO, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_NO }, \
 { KC_NO, KC_NO, KC_NO, KC_##K43, KC_##K44, KC_##K45, KC_##K46, KC_NO }, \
 { KC_##K50, KC_##K51, KC_##K52, KC_##K53, KC_##K54, KC_##K55, KC_##K56, KC_##K57 }, \
 { KC_NO, KC_##K61, KC_NO, KC_NO, KC_##K64, KC_##K65, KC_##K66, KC_##K67 }, \
 { KC_##K70, KC_##K71, KC_##K72, KC_##K73, KC_##K74, KC_##K75, KC_##K76, KC_##K77 }, \
 { KC_NO, KC_##K81, KC_##K82, KC_##K83, KC_##K84, KC_##K85, KC_##K86, KC_NO }, \
 { KC_NO, KC_NO, KC_NO, KC_##K93, KC_##K94, KC_##K95, KC_##K96, KC_NO }, \
 { KC_##KA0, KC_##KA1, KC_##KA2, KC_##KA3, KC_##KA4, KC_##KA5, KC_NO, KC_##KA7 }, \
 { KC_##KB0, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_##KB7 }, \
 }
 #define KEYCODE(layer, row, col) (pgm_read_byte(&keymaps[(layer)][(row)][(col)]))
 // 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[] = {
 KB_NO, // Fn0
 KB_NO, // Fn1
 KB_SLSH, // Fn2
 KB_SCLN, // Fn3
 KB_SPC, // Fn4
 KB_NO, // Fn5
 KB_NO, // Fn6
 KB_NO // Fn7
 KC_NO, // Fn0
 KC_NO, // Fn1
 KC_SLSH, // Fn2
 KC_SCLN, // Fn3
 KC_SPC, // Fn4
 KC_NO, // Fn5
 KC_NO, // Fn6
 KC_NO // Fn7
 };
 static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
--- a/keyboard/hhkb/Makefile.iwrap
+++ b/keyboard/hhkb/Makefile.iwrap
 TARGET_DIR = .
 # keyboard dependent files
 SRC = main.c \
 SRC = \
 keymap.c \
 matrix.c \
 led.c
 # MCU name, you MUST set this to match the board you are using
 # type "make clean" after changing this, so all files will be rebuilt
 MCU = atmega168p
 MCU = atmega328p
 # avrdude doesn't know atmega168p
 AVRDUDE_MCU = atmega168
 AVRDUDE_MCU = $(MCU)
 # Processor frequency.
 # Search Path
 VPATH = $(TARGET_DIR)
 VPATH += $(TOP_DIR)
 include $(TOP_DIR)/protocol/iwrap.mk
 #include $(TOP_DIR)/protocol/iwrap.mk
 # To be swatchable btween Bluetooth and USB. Comment out if you don't need USB.
 include $(TOP_DIR)/protocol/vusb.mk
 include $(TOP_DIR)/protocol.mk
 #include $(TOP_DIR)/protocol.mk
 include $(TOP_DIR)/common.mk
 include $(TOP_DIR)/rules.mk
--- a/keyboard/hhkb/config.h
+++ b/keyboard/hhkb/config.h
 /* matrix size */
 #define MATRIX_ROWS 8
 #define MATRIX_COLS 8
 /* define if matrix has ghost */
 //#define MATRIX_HAS_GHOST
 /* key combination for command */
 #define IS_COMMAND() (keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_RSHIFT))) 
 #define IS_COMMAND() (keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) 
 /* mouse keys */
 #ifdef MOUSEKEY_ENABLE
 # define MOUSEKEY_DELAY_TIME 192
 # define MOUSEKEY_DELAY_TIME 100
 #endif
--- a/keyboard/hhkb/config_iwrap.h
+++ b/keyboard/hhkb/config_iwrap.h
 /* key combination for command */
 #define IS_COMMAND() (keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_RSHIFT))) 
 #define IS_COMMAND() (keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) 
 /* mouse keys */
 #ifdef MOUSEKEY_ENABLE
--- a/keyboard/hhkb/config_vusb.h
+++ b/keyboard/hhkb/config_vusb.h
 /* key combination for command */
 #define IS_COMMAND() (keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_RSHIFT))) 
 #define IS_COMMAND() (keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) 
 /* mouse keys */
 #ifdef MOUSEKEY_ENABLE
 # define MOUSEKEY_DELAY_TIME 255
 # define MOUSEKEY_DELAY_TIME 100
 #endif
--- a/keyboard/hhkb/keymap.c
+++ b/keyboard/hhkb/keymap.c
 #include <stdbool.h>
 #include <avr/pgmspace.h>
 #include "host.h"
 #include "usb_keycodes.h"
 #include "keycode.h"
 #include "print.h"
 #include "debug.h"
 #include "util.h"
 K35, K36, K37, K57, K56 \
 ) \
 { \
 { KB_##K00, KB_##K01, KB_##K02, KB_##K03, KB_##K04, KB_##K05, KB_##K06, KB_##K07 }, \
 { KB_##K10, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_##K17 }, \
 { KB_##K20, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_NO }, \
 { KB_##K30, KB_##K31, KB_##K32, KB_##K33, KB_##K34, KB_##K35, KB_##K36, KB_##K37 }, \
 { KB_##K40, KB_##K41, KB_##K42, KB_##K43, KB_##K44, KB_##K45, KB_##K46, KB_NO }, \
 { KB_##K50, KB_##K51, KB_##K52, KB_##K53, KB_##K54, KB_##K55, KB_##K56, KB_##K57 }, \
 { KB_##K60, KB_##K61, KB_##K62, KB_##K63, KB_##K64, KB_##K65, KB_##K66, KB_NO }, \
 { KB_##K70, KB_##K71, KB_##K72, KB_##K73, KB_##K74, KB_##K75, KB_##K76, KB_NO } \
 { KC_##K00, KC_##K01, KC_##K02, KC_##K03, KC_##K04, KC_##K05, KC_##K06, KC_##K07 }, \
 { KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_##K17 }, \
 { KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_NO }, \
 { KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_##K37 }, \
 { KC_##K40, KC_##K41, KC_##K42, KC_##K43, KC_##K44, KC_##K45, KC_##K46, KC_NO }, \
 { KC_##K50, KC_##K51, KC_##K52, KC_##K53, KC_##K54, KC_##K55, KC_##K56, KC_##K57 }, \
 { KC_##K60, KC_##K61, KC_##K62, KC_##K63, KC_##K64, KC_##K65, KC_##K66, KC_NO }, \
 { KC_##K70, KC_##K71, KC_##K72, KC_##K73, KC_##K74, KC_##K75, KC_##K76, KC_NO } \
 }
 #define KEYCODE(layer, row, col) (pgm_read_byte(&keymaps[(layer)][(row)][(col)]))
 2, // Fn2
 3, // Fn3
 3, // Fn4
 4, // Fn5
 5, // 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[] = {
 KB_NO, // Fn0
 KB_NO, // Fn1
 KB_SLSH, // Fn2
 KB_SCLN, // Fn3
 KB_NO, // Fn4
 KB_SPC, // Fn5
 KB_NO, // Fn6
 KB_NO // Fn7
 KC_NO, // Fn0
 KC_NO, // Fn1
 KC_SLSH, // Fn2
 KC_SCLN, // Fn3
 KC_NO, // Fn4
 KC_SPC, // Fn5
 KC_NO, // Fn6
 KC_NO // Fn7
 };
 static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 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,ENT, \
 LSFT,Z, X, C, V, B, N, M, COMM,DOT, FN2, RSFT,FN1, \
 LGUI,LALT, SPC, RALT,FN4),
 LGUI,LALT, FN5, RALT,FN4),
 /* Layer 1: HHKB mode (HHKB Fn)
 * ,-----------------------------------------------------------.
 */
 #ifdef HOST_IWRAP
 // iWRAP does not support mouse wheel, use these keycodes to remap as wheel
 #define KB_KPPL KB_KP_PLUS
 #define KB_KPMI KB_KP_MINUS
 #define KB_KPAS KB_KP_ASTERISK
 #define KB_KPSL KB_KP_SLASH
 #define KC_KPPL KC_KP_PLUS
 #define KC_KPMI KC_KP_MINUS
 #define KC_KPAS KC_KP_ASTERISK
 #define KC_KPSL KC_KP_SLASH
 KEYMAP(ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, INS, DEL, \
 TAB, KPAS,KPPL,MS_U,KPMI,KPSL,KPAS,KPPL,KPMI,KPSL,NO, NO, NO, BSPC, \
 LCTL,NO, MS_L,MS_D,MS_R,NO, MS_L,MS_D,MS_U,MS_R,FN3, NO, ENT, \
 LGUI,LALT, BTN1, RALT,FN4),
 #else
 KEYMAP(ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, INS, DEL, \
 TAB, WH_L,WH_U,MS_U,WH_D,WH_R,WH_L,WH_D,WH_U,WH_R,NO, NO, NO, BSPC, \
 LCTL,NO, MS_L,MS_D,MS_R,NO, MS_L,MS_D,MS_U,MS_R,FN3, NO, ENT, \
 LSFT,BTN4,BTN5,BTN1,BTN2,BTN3,BTN2,BTN1,BTN4,BTN5,NO, RSFT,NO, \
 TAB, NO, NO, NO, NO, NO, WH_L,WH_D,WH_U,WH_R,NO, NO, NO, BSPC, \
 LCTL,NO, ACL0,ACL1,ACL2,NO, MS_L,MS_D,MS_U,MS_R,FN3, NO, ENT, \
 LSFT,NO, NO, NO, NO, BTN3,BTN2,BTN1,BTN4,BTN5,NO, RSFT,NO, \
 LGUI,LALT, BTN1, RALT,FN4),
 #endif
 * |Gui |Alt |xxxxxxxxxxxxxxxxxxxxxxx|Alt |Gui|
 * `--------------------------------------------'
 */
 /*
 KEYMAP(MINS,0, 9, 8, 7, 6, 5, 4, 3, 2, 1, NO, NO, NO, ESC, \
 BSPC,P, O, I, U, Y, T, R, E, W, Q, NO, NO, TAB, \
 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, FN5, RALT,RGUI)
 */
 /* Mouse mode (Space) */
 LGUI,LALT, FN5, RALT,RGUI),
 /* Layer5: another Mouse mode (Space) */
 #ifdef HOST_IWRAP
 KEYMAP(ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, INS, DEL, \
 TAB, KPAS,KPPL,MS_U,KPMI,KPSL,KPAS,KPPL,KPMI,KPSL,NO, NO, NO, BSPC, \
 LGUI,LALT, FN5, RALT,RGUI),
 #else
 KEYMAP(ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, INS, DEL, \
 TAB, WH_L,WH_U,MS_U,WH_D,WH_R,WH_L,WH_D,WH_U,WH_R,NO, NO, NO, BSPC, \
 LCTL,NO, MS_L,MS_D,MS_R,NO, MS_L,MS_D,MS_U,MS_R,FN3, NO, ENT, \
 LSFT,BTN4,BTN5,BTN1,BTN2,BTN3,BTN2,BTN1,BTN4,BTN5,NO, RSFT,NO, \
 TAB, NO, NO, NO, NO, NO, WH_L,WH_D,WH_U,WH_R,NO, NO, NO, BSPC, \
 LCTL,NO, ACL0,ACL1,ACL2,NO, MS_L,MS_D,MS_U,MS_R,FN3, NO, ENT, \
 LSFT,NO, NO, NO, NO, BTN3,BTN2,BTN1,BTN4,BTN5,NO, RSFT,NO, \
 LGUI,LALT, FN5, RALT,RGUI),
 #endif
 };
 return KEYCODE(layer, row, col);
 }
 uint8_t keymap_fn_layer(uint8_t fn_bits)
 uint8_t keymap_fn_layer(uint8_t index)
 {
 return pgm_read_byte(&fn_layer[biton(fn_bits)]);
 return pgm_read_byte(&fn_layer[index]);
 }
 uint8_t keymap_fn_keycode(uint8_t fn_bits)
 uint8_t keymap_fn_keycode(uint8_t index)
 {
 return pgm_read_byte(&fn_keycode[(biton(fn_bits))]);
 return pgm_read_byte(&fn_keycode[index]);
 }
--- a/keyboard/hhkb/matrix.c
+++ b/keyboard/hhkb/matrix.c
 // matrix state buffer(1:on, 0:off)
 #if (MATRIX_COLS <= 8)
 static uint8_t *matrix;
 static uint8_t *matrix_prev;
 static uint8_t _matrix0[MATRIX_ROWS];
 static uint8_t _matrix1[MATRIX_ROWS];
 #else
 static uint16_t *matrix;
 static uint16_t *matrix_prev;
 static uint16_t _matrix0[MATRIX_ROWS];
 static uint16_t _matrix1[MATRIX_ROWS];
 #endif
 // HHKB has no ghost and no bounce.
 #ifdef MATRIX_HAS_GHOST
 static bool matrix_has_ghost_in_row(uint8_t row);
 #endif
 static matrix_row_t *matrix;
 static matrix_row_t *matrix_prev;
 static matrix_row_t _matrix0[MATRIX_ROWS];
 static matrix_row_t _matrix1[MATRIX_ROWS];
 // Matrix I/O ports
 #define KEY_POWER_ON() do { \
 KEY_INIT(); \
 PORTB &= ~(1<<5); \
 _delay_us(200); \
 _delay_ms(1);  \
 } while (0)
 #define KEY_POWER_OFF() do { \
 DDRB &= ~0x3F; \
 }
 // Ignore if this code region execution time elapses more than 20us.
 // MEMO: 20[us] * (TIMER_RAW_FREQ / 1000000)[count per us]
 // MEMO: then change above using this rule: a/(b/c) = a*1/(b/c) = a*(c/b)
 if (TIMER_DIFF_RAW(TIMER_RAW, last) > 20/(1000000/TIMER_RAW_FREQ)) {
 matrix[row] = matrix_prev[row];
 }
 inline
 bool matrix_has_ghost(void)
 {
 #ifdef MATRIX_HAS_GHOST
 for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
 if (matrix_has_ghost_in_row(i))
 return true;
 }
 #endif
 return false;
 }
 pbin_reverse(matrix_get_row(row));
 #else
 pbin_reverse16(matrix_get_row(row));
 #endif
 #ifdef MATRIX_HAS_GHOST
 if (matrix_has_ghost_in_row(row)) {
 print(" <ghost");
 }
 #endif
 print("\n");
 }
 }
 return count;
 }
 #ifdef MATRIX_HAS_GHOST
 inline
 static bool matrix_has_ghost_in_row(uint8_t row)
 {
 // no ghost exists in case less than 2 keys on
 if (((matrix[row] - 1) & matrix[row]) == 0)
 return false;
 // ghost exists in case same state as other row
 for (uint8_t i=0; i < MATRIX_ROWS; i++) {
 if (i != row && (matrix[i] & matrix[row]) == matrix[row])
 return true;
 }
 return false;
 }
 #endif
--- a/keyboard/macway/config.h
+++ b/keyboard/macway/config.h
 /* key combination for command */
 #define IS_COMMAND() ( \
 keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_LCTRL) | MOD_BIT(KB_LALT) | MOD_BIT(KB_LGUI)) || \
 keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_RSHIFT)) \
 keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_LCTRL) | MOD_BIT(KC_LALT) | MOD_BIT(KC_LGUI)) || \
 keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
 )
--- a/keyboard/macway/keymap.c
+++ b/keyboard/macway/keymap.c
 #include <stdint.h>
 #include <stdbool.h>
 #include <avr/pgmspace.h>
 #include "usb_keycodes.h"
 #include "keycode.h"
 #include "print.h"
 #include "debug.h"
 #include "util.h"
 K67, K16, K26, K36, K46, K47, K57, K56, K66, K76, K87, K32, K35, \
 K75, K22, K00, K07, K21, K04, K37, K27, K17 \
 ) { \
 { KB_##K00, KB_##K01, KB_##K02, KB_NO, KB_##K04, KB_NO, KB_##K06, KB_##K07 }, \
 { KB_##K10, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_##K17 }, \
 { KB_##K20, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_NO, KB_##K26, KB_##K27 }, \
 { KB_##K30, KB_NO, KB_##K32, KB_##K33, KB_##K34, KB_##K35, KB_##K36, KB_##K37 }, \
 { KB_##K40, KB_##K41, KB_##K42, KB_##K43, KB_##K44, KB_##K45, KB_##K46, KB_##K47 }, \
 { KB_##K50, KB_##K51, KB_##K52, KB_##K53, KB_##K54, KB_##K55, KB_##K56, KB_##K57 }, \
 { KB_##K60, KB_##K61, KB_##K62, KB_##K63, KB_##K64, KB_NO, KB_##K66, KB_##K67 }, \
 { KB_##K70, KB_NO, KB_NO, KB_##K73, KB_##K74, KB_##K75, KB_##K76, KB_NO }, \
 { KB_##K80, KB_##K81, KB_##K82, KB_##K83, KB_##K84, KB_##K85, KB_NO, KB_##K87 } \
 { KC_##K00, KC_##K01, KC_##K02, KC_NO, KC_##K04, KC_NO, KC_##K06, KC_##K07 }, \
 { KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_##K17 }, \
 { KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_NO, KC_##K26, KC_##K27 }, \
 { KC_##K30, KC_NO, KC_##K32, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_##K37 }, \
 { KC_##K40, KC_##K41, KC_##K42, KC_##K43, KC_##K44, KC_##K45, KC_##K46, KC_##K47 }, \
 { KC_##K50, KC_##K51, KC_##K52, KC_##K53, KC_##K54, KC_##K55, KC_##K56, KC_##K57 }, \
 { KC_##K60, KC_##K61, KC_##K62, KC_##K63, KC_##K64, KC_NO, KC_##K66, KC_##K67 }, \
 { KC_##K70, KC_NO, KC_NO, KC_##K73, KC_##K74, KC_##K75, KC_##K76, KC_NO }, \
 { KC_##K80, KC_##K81, KC_##K82, KC_##K83, KC_##K84, KC_##K85, KC_NO, KC_##K87 } \
 }
 #define KEYCODE(layer, row, col) (pgm_read_byte(&keymaps[(layer)][(row)][(col)]))
 // 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[] = {
 KB_NO, // Fn0
 KB_NO, // Fn1
 KB_SLSH, // Fn2
 KB_SCLN, // Fn3
 KB_SPC, // Fn4
 KB_NO, // Fn5
 KB_NO, // Fn6
 KB_NO // Fn7
 KC_NO, // Fn0
 KC_NO, // Fn1
 KC_SLSH, // Fn2
 KC_SCLN, // Fn3
 KC_SPC, // Fn4
 KC_NO, // Fn5
 KC_NO, // Fn6
 KC_NO // Fn7
 };
 static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
--- a/protocol/iwrap.mk
+++ b/protocol/iwrap.mk
 IWRAP_DIR = protocol/iwrap
 OPT_DEFS += -DHOST_IWRAP
 SRC += iwrap.c \
 suart.S \
 sendchar_uart.c \
 uart.c
 SRC += $(IWRAP_DIR)/iwrap.c \
 $(IWRAP_DIR)/suart.S \
 $(IWRAP_DIR)/sendchar_uart.c \
 $(IWRAP_DIR)/uart.c
 # Search Path
--- a/protocol/iwrap/iwrap.c
+++ b/protocol/iwrap/iwrap.c
 #include <string.h>
 #include <avr/interrupt.h>
 #include <util/delay.h>
 #include "usb_keycodes.h"
 #include "keycode.h"
 #include "suart.h"
 #include "uart.h"
 #include "report.h"
--- a/protocol/iwrap/main.c
+++ b/protocol/iwrap/main.c
 #include "suart.h"
 #include "timer.h"
 #include "debug.h"
 #include "usb_keycodes.h"
 #include "keycode.h"
 #include "command.h"
 if (host_get_driver() == vusb_driver())
 usbPoll();
 #endif
 keyboard_proc();
 keyboard_task();
 #ifdef HOST_VUSB
 if (host_get_driver() == vusb_driver())
 vusb_transfer_keyboard();
 static uint8_t key2asc(uint8_t key)
 {
 switch (key) {
 case KB_A: return 'a';
 case KB_B: return 'b';
 case KB_C: return 'c';
 case KB_D: return 'd';
 case KB_E: return 'e';
 case KB_F: return 'f';
 case KB_G: return 'g';
 case KB_H: return 'h';
 case KB_I: return 'i';
 case KB_J: return 'j';
 case KB_K: return 'k';
 case KB_L: return 'l';
 case KB_M: return 'm';
 case KB_N: return 'n';
 case KB_O: return 'o';
 case KB_P: return 'p';
 case KB_Q: return 'q';
 case KB_R: return 'r';
 case KB_S: return 's';
 case KB_T: return 't';
 case KB_U: return 'u';
 case KB_V: return 'v';
 case KB_W: return 'w';
 case KB_X: return 'x';
 case KB_Y: return 'y';
 case KB_Z: return 'z';
 case KB_1: return '1';
 case KB_2: return '2';
 case KB_3: return '3';
 case KB_4: return '4';
 case KB_5: return '5';
 case KB_6: return '6';
 case KB_7: return '7';
 case KB_8: return '8';
 case KB_9: return '9';
 case KB_0: return '0';
 case KB_ENTER: return '\n';
 case KB_ESCAPE: return 0x1B;
 case KB_BSPACE: return '\b';
 case KB_TAB: return '\t';
 case KB_SPACE: return ' ';
 case KB_MINUS: return '-';
 case KB_EQUAL: return '=';
 case KB_LBRACKET: return '[';
 case KB_RBRACKET: return ']';
 case KB_BSLASH: return '\\';
 case KB_NONUS_HASH: return '\\';
 case KB_SCOLON: return ';';
 case KB_QUOTE: return '\'';
 case KB_GRAVE: return '`';
 case KB_COMMA: return ',';
 case KB_DOT: return '.';
 case KB_SLASH: return '/';
 case KC_A: return 'a';
 case KC_B: return 'b';
 case KC_C: return 'c';
 case KC_D: return 'd';
 case KC_E: return 'e';
 case KC_F: return 'f';
 case KC_G: return 'g';
 case KC_H: return 'h';
 case KC_I: return 'i';
 case KC_J: return 'j';
 case KC_K: return 'k';
 case KC_L: return 'l';
 case KC_M: return 'm';
 case KC_N: return 'n';
 case KC_O: return 'o';
 case KC_P: return 'p';
 case KC_Q: return 'q';
 case KC_R: return 'r';
 case KC_S: return 's';
 case KC_T: return 't';
 case KC_U: return 'u';
 case KC_V: return 'v';
 case KC_W: return 'w';
 case KC_X: return 'x';
 case KC_Y: return 'y';
 case KC_Z: return 'z';
 case KC_1: return '1';
 case KC_2: return '2';
 case KC_3: return '3';
 case KC_4: return '4';
 case KC_5: return '5';
 case KC_6: return '6';
 case KC_7: return '7';
 case KC_8: return '8';
 case KC_9: return '9';
 case KC_0: return '0';
 case KC_ENTER: return '\n';
 case KC_ESCAPE: return 0x1B;
 case KC_BSPACE: return '\b';
 case KC_TAB: return '\t';
 case KC_SPACE: return ' ';
 case KC_MINUS: return '-';
 case KC_EQUAL: return '=';
 case KC_LBRACKET: return '[';
 case KC_RBRACKET: return ']';
 case KC_BSLASH: return '\\';
 case KC_NONUS_HASH: return '\\';
 case KC_SCOLON: return ';';
 case KC_QUOTE: return '\'';
 case KC_GRAVE: return '`';
 case KC_COMMA: return ',';
 case KC_DOT: return '.';
 case KC_SLASH: return '/';
 default: return 0x00;
 }
 }
--- a/protocol/lufa/lufa.c
+++ b/protocol/lufa/lufa.c
 keyboard_init();
 host_set_driver(&lufa_driver);
 while (1) {
 keyboard_proc();
 keyboard_task();
 #if !defined(INTERRUPT_CONTROL_ENDPOINT)
 USB_USBTask();
--- a/protocol/pjrc/main.c
+++ b/protocol/pjrc/main.c
 host_set_driver(pjrc_driver());
 while (1) {
 keyboard_proc(); 
 keyboard_task(); 
 }
 }
--- a/protocol/pjrc/usb_keyboard.c
+++ b/protocol/pjrc/usb_keyboard.c
 #include <avr/interrupt.h>
 #include <avr/pgmspace.h>
 #include "usb_keycodes.h"
 #include "keycode.h"
 #include "usb_keyboard.h"
 #include "print.h"
 #include "debug.h"
--- a/protocol/vusb/main.c
+++ b/protocol/vusb/main.c
 // TODO: configuration process is incosistent. it sometime fails.
 // To prevent failing to configure NOT scan keyboard during configuration
 if (usbConfiguration && usbInterruptIsReady()) {
 keyboard_proc();
 keyboard_task();
 }
 vusb_transfer_keyboard();
 }
--- a/protocol/vusb/vusb.c
+++ b/protocol/vusb/vusb.c
 if (usbInterruptIsReady()) {
 if (kbuf_head != kbuf_tail) {
 usbSetInterrupt((void *)&kbuf[kbuf_tail], sizeof(report_keyboard_t));
 if (!debug_keyboard) {
 print("keys: ");
 for (int i = 0; i < REPORT_KEYS; i++) { phex(kbuf[kbuf_tail].keys[i]); print(" "); }
 print(" mods: "); phex((kbuf[kbuf_tail]).mods); print("\n");
 }
 kbuf_tail = (kbuf_tail + 1) % KBUF_SIZE;
 if (debug_keyboard) {
 print("V-USB: kbuf["); pdec(kbuf_tail); print("->"); pdec(kbuf_head); print("](");
 phex((kbuf_head < kbuf_tail) ? (KBUF_SIZE - kbuf_tail + kbuf_head) : (kbuf_head - kbuf_tail));
 print(")\n");
 }
 }
 }
 }
 if(rq->bRequest == USBRQ_HID_GET_REPORT){
 debug("GET_REPORT:");
 /* we only have one report type, so don't look at wValue */
 usbMsgPtr = (void *)keyboard_report_prev;
 return sizeof(*keyboard_report_prev);
 usbMsgPtr = (void *)keyboard_report;
 return sizeof(*keyboard_report);
 }else if(rq->bRequest == USBRQ_HID_GET_IDLE){
 debug("GET_IDLE: ");
 //debug_hex(vusb_idle_rate);