vor 11 Jahren · 4edc5ab99c
--- a/common.mk
+++ b/common.mk
@@ -2,7 +2,6 @@ COMMON_DIR = common
 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
@@ -23,7 +23,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
 #include "debug.h"
 #include "util.h"
 #include "timer.h"
 #include "layer.h"
 #include "keyboard.h"
 #include "matrix.h"
 #include "bootloader.h"
 #include "command.h"
--- a/common/host.c
+++ b/common/host.c
@@ -56,6 +56,19 @@ uint8_t host_keyboard_leds(void)
 return (*driver->keyboard_leds)();
 }

 /* new interface */
 void host_register_key(uint8_t key)
 {
 host_add_key(key);
 host_send_keyboard_report();
 }

 void host_unregister_key(uint8_t key)
 {
 host_del_key(key);
 host_send_keyboard_report();
 }

 /* keyboard report operations */
 void host_add_key(uint8_t key)
 {
@@ -158,6 +171,14 @@ void host_send_keyboard_report(void)
 {
 if (!driver) return;
 (*driver->send_keyboard)(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)
@@ -216,7 +237,6 @@ static inline void del_key_byte(uint8_t code)
 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
@@ -39,6 +39,10 @@ void host_set_driver(host_driver_t *driver);
 host_driver_t *host_get_driver(void);
 uint8_t host_keyboard_leds(void);

 /* new interface */
 void host_register_key(uint8_t key);
 void host_unregister_key(uint8_t key);

 /* keyboard report operations */
 void host_add_key(uint8_t key);
 void host_del_key(uint8_t key);
--- a/common/keyboard.c
+++ b/common/keyboard.c
@@ -15,15 +15,16 @@ You should have received a copy of the GNU General Public License
 along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 #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 "timer.h"
 #include "print.h"
 #include "debug.h"
 #include "command.h"
 #include "util.h"
 #ifdef MOUSEKEY_ENABLE
 #include "mousekey.h"
 #endif
@@ -32,162 +33,444 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
 #endif


 static uint8_t last_leds = 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,
 MOUSEKEY_DOWN, MOUSEKEY_UP,
 DELAY
 } keykind_t;

 void keyboard_init(void)
 typedef enum { IDLE, DELAYING, WAITING, PRESSING } kbdstate_t;


 uint8_t current_layer = 0;
 uint8_t default_layer = 0;

 /* 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 const char *state_str(kbdstate_t state)
 {
 timer_init();
 matrix_init();
 #ifdef PS2_MOUSE_ENABLE
 ps2_mouse_init();
 #endif
 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_proc(void)
 static inline keykind_t get_keykind(uint8_t code, bool pressed)
 {
 uint8_t fn_bits = 0;
 #ifdef EXTRAKEY_ENABLE
 uint16_t consumer_code = 0;
 uint16_t system_code = 0;
 #endif

 matrix_scan();
 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 ? MOUSEKEY_DOWN : MOUSEKEY_UP);
 return NONE;
 }

 if (matrix_is_modified()) {
 if (debug_matrix) matrix_print();
 #ifdef DEBUG_LED
 // LED flash for debug
 DEBUG_LED_CONFIG;
 DEBUG_LED_ON;
 #endif
 static void layer_switch_on(uint8_t code)
 {
 if (!IS_FN(code)) return;
 fn_state_bits |= FN_BIT(code);
 if (current_layer != keymap_fn_layer(FN_INDEX(code))) {
 //TODO: clear all key execpt Mod key
 debug("Layer Switch(on): "); debug_hex(current_layer);
 current_layer = keymap_fn_layer(FN_INDEX(code));
 debug(" -> "); debug_hex(current_layer); debug("\n");
 }
 }

 if (matrix_has_ghost()) {
 // should send error?
 debug("matrix has ghost!!\n");
 return;
 static void layer_switch_off(uint8_t code)
 {
 if (!IS_FN(code)) return;
 fn_state_bits &= ~FN_BIT(code);
 if (current_layer != keymap_fn_layer(biton(fn_state_bits))) {
 //TODO: clear all key execpt Mod key
 debug("Layer Switch(off): "); debug_hex(current_layer);
 current_layer = keymap_fn_layer(biton(fn_state_bits));
 debug(" -> "); debug_hex(current_layer); debug("\n");
 }
 }

 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 inline uint8_t get_keycode(key_t key)
 {
 return keymap_get_keycode(current_layer, key.row, key.col);
 }

 // whether any key except modifier is down or not
 static inline bool is_anykey_down(void)
 {
 for (int r = 0; r < MATRIX_ROWS; r++) {
 matrix_row_t matrix_row = matrix_get_row(r);
 for (int c = 0; c < MATRIX_COLS; c++) {
 if (matrix_row && (1<<c)) {
 if (IS_KEY(get_keycode((key_t){ .row = r, .col = c }))) {
 return true;
 }
 #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;
 }
 }
 return false;
 }

 static void register_code(uint8_t code)
 {
 if IS_KEY(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_MOUSEKEY(code) {
 mousekey_on(code);
 mousekey_send();
 }
 }

 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_MOUSEKEY(code) {
 mousekey_off(code);
 mousekey_send();
 }
 }

 /*
 *
 * Event/State|IDLE DELAYING[f] WAITING[f,k] PRESSING
 * -----------+------------------------------------------------------------------
 * Fn Down |IDLE(L+) WAITING(Sk) WAITING(Sk) -
 * Up |IDLE(L-) IDLE(L-) IDLE(L-) IDLE(L-) 
 * Fnk Down |DELAYING(Sf) WAITING(Sk) WAINTING(Sk) PRESSING(Rf)
 * Up |IDLE(L-) IDLE(Rf,Uf) IDLE(Rf,Ps,Uf)*3 PRESSING(Uf)
 * Key Down |PRESSING(Rk) WAITING(Sk) WAITING(Sk) PRESSING(Rk)
 * Up |IDLE(Uk) DELAYING(Uk) IDLE(L+,Ps,Uk) IDLE(Uk)*4
 * Delay |- IDLE(L+) IDLE(L+,Ps) -
 * |
 * No key Down|IDLE(Ld) IDLE(Ld) IDLE(Ld) IDLE(Ld)
 *
 * *2: register Fnk if any key is pressing
 * *3: when Fnk == Stored Fnk, if not ignore.
 * *4: when no registered key any more
 *
 * States:
 * IDLE:
 * 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
 *
 * Actions:
 * Rk: register key
 * Uk: unregister key
 * Rf: register stored Fn(alt keycode)
 * Uf: unregister stored Fn(alt keycode)
 * Rs: register stored key
 * Us: unregister stored key
 * Sk: store key
 * Sf: store Fn
 * Ps: play stored key(Interpret stored key and transit state)
 * L+: Switch to new layer(*retain* Modifiers only)
 * L-: Switch back to last layer(*clear* stored key/Fn, *unregister* all Modifier/key)
 * Ld: Switch back to default layer(*clear* stored key/Fn, *unregister* all Modifier/key)
 */
 #define NEXT(state) do { \
 debug("NEXT: "); print_P(state_str(kbdstate)); \
 kbdstate = state; \
 debug(" -> "); print_P(state_str(kbdstate)); debug("\n"); \
 } while (0)

 static inline void process_key(keyevent_t event)
 {
 
 /* TODO: ring buffer
 static keyrecord_t waiting_keys[5];
 static uint8_t waiting_keys_head = 0;
 static uint8_t waiting_keys_tail = 0;
 */

 uint8_t code = get_keycode(event.key);
 keykind_t kind = get_keykind(code, event.pressed);

 uint8_t tmp_mods;

 //debug("kbdstate: "); debug_hex(kbdstate);
 debug("state: "); print_P(state_str(kbdstate));
 debug(" kind: "); debug_hex(kind);
 debug(" code: "); debug_hex(code);
 if (event.pressed) { debug("d"); } else { debug("u"); }
 debug("\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:
 // store event
 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:
 case MOUSEKEY_DOWN:
 register_code(code);
 NEXT(PRESSING);
 break;
 case MOD_DOWN:
 register_code(code);
 break;
 case KEY_UP:
 case MOUSEKEY_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:
 layer_switch_off(code);
 NEXT(IDLE);
 break;
 case FNK_DOWN:
 register_code(keymap_fn_keycode(FN_INDEX(code)));
 break;
 case FNK_UP:
 unregister_code(keymap_fn_keycode(FN_INDEX(code)));
 break;
 case KEY_DOWN:
 case MOD_DOWN:
 case MOUSEKEY_DOWN:
 register_code(code);
 break;
 case KEY_UP:
 case MOD_UP:
 case MOUSEKEY_UP:
 unregister_code(code);
 // no key registered? mousekey, mediakey, systemkey
 if (!host_has_anykey())
 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:
 case MOUSEKEY_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:
 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(keymap_fn_keycode(FN_INDEX(delayed_fn.code)));
 unregister_code(keymap_fn_keycode(FN_INDEX(delayed_fn.code)));
 host_set_mods(tmp_mods);
 NEXT(IDLE);
 } else {
 layer_switch_off(code);
 NEXT(IDLE);
 }
 break;
 case KEY_UP:
 case MOUSEKEY_UP:
 unregister_code(code);
 NEXT(IDLE);
 break;
 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:
 case MOUSEKEY_DOWN:
 tmp_mods = keyboard_report->mods;
 host_set_mods(delayed_fn.mods);
 register_code(keymap_fn_keycode(FN_INDEX(delayed_fn.code)));
 host_set_mods(waiting_key.mods);
 register_code(waiting_key.code);
 host_set_mods(tmp_mods);
 register_code(code);
 NEXT(IDLE);
 break;
 case MOD_DOWN:
 register_code(code);
 break;
 case FN_UP:
 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(keymap_fn_keycode(FN_INDEX(delayed_fn.code)));
 host_set_mods(waiting_key.mods);
 register_code(waiting_key.code);
 unregister_code(keymap_fn_keycode(FN_INDEX(delayed_fn.code)));
 host_set_mods(tmp_mods);
 NEXT(IDLE);
 } else {
 layer_switch_off(code);
 NEXT(IDLE);
 }
 break;
 case KEY_UP:
 case MOUSEKEY_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);
 // TODO: FAIL SAFE: unregister all keys when no key down
 }

 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;

 matrix_scan();
 if (command_proc()) {
 debug("COMMAND\n");
 // TODO: clear all keys
 host_clear_keyboard_report();
 host_send_keyboard_report();
 return;
 }
 for (int r = 0; r < MATRIX_ROWS; r++) {
 matrix_row = matrix_get_row(r);
 matrix_change = matrix_row ^ matrix_prev[r];
 if (matrix_change) {
 // TODO: print once per scan
 if (debug_matrix) matrix_print();

 // 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
 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: FAIL SAFE: clear all key if no key down

 #ifdef MOUSEKEY_ENABLE
 mousekey_send();
 #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 PS2_MOUSE_ENABLE
 // TODO: should comform new API
 if (ps2_mouse_read() == 0)
 ps2_mouse_usb_send();
 #endif
 // mousekey repeat & acceleration
 mousekey_task();

 if (last_leds != host_keyboard_leds()) {
 keyboard_set_leds(host_keyboard_leds());
 last_leds = host_keyboard_leds();
 }
 return;
 }

 void keyboard_set_leds(uint8_t leds)
--- a/common/keyboard.h
+++ b/common/keyboard.h
@@ -18,15 +18,41 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
 #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/layer.c
+++ b/common/layer.c
@@ -1,207 +0,0 @@
 /*
 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
@@ -1,32 +0,0 @@
 /*
 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
@@ -18,8 +18,23 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
 #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 */
@@ -35,11 +50,7 @@ bool matrix_has_ghost(void);
 /* 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
@@ -26,7 +26,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.


 static report_mouse_t report;
 static report_mouse_t report_prev;

 static uint8_t mousekey_repeat = 0;

@@ -38,84 +37,111 @@ static void mousekey_debug(void);
 * see wikipedia http://en.wikipedia.org/wiki/Mouse_keys
 */
 #ifndef MOUSEKEY_DELAY_TIME
 # define MOUSEKEY_DELAY_TIME 255
 # define MOUSEKEY_DELAY_TIME 20
 #endif

 #define MOUSEKEY_MOVE_INIT 5
 #define MOUSEKEY_WHEEL_INIT 1
 #define MOUSEKEY_MOVE_ACCEL 5
 #define MOUSEKEY_WHEEL_ACCEL 1

 static uint16_t last_timer = 0;

 // acceleration parameters
 uint8_t mousekey_move_unit = 2;
 uint8_t mousekey_resolution = 5;
 //uint8_t mousekey_move_unit = 2;
 //uint8_t mousekey_resolution = 5;


 static inline uint8_t move_unit(void)
 {
 uint16_t unit = 5 + mousekey_repeat*2;
 uint16_t unit = 5 + mousekey_repeat*4;
 return (unit > 63 ? 63 : unit);
 }

 void mousekey_decode(uint8_t code)
 {
 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;
 }

 bool mousekey_changed(void)
 {
 return (report.buttons != report_prev.buttons ||
 report.x || report.y || report.v || report.h);
 }

 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_DELAY_TIME)
 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 (report.x == 0 && report.y == 0 && report.v == 0 && report.h == 0)
 return;

 if (mousekey_repeat != 0xFF) {
 if (mousekey_repeat != UINT8_MAX)
 mousekey_repeat++;
 }


 if (report.x > 0) report.x = move_unit();
 if (report.x < 0) report.x = move_unit() * -1;
 if (report.y > 0) report.y = move_unit();
 if (report.y < 0) report.y = move_unit() * -1;

 if (report.x && report.y) {
 report.x *= 0.7;
 report.y *= 0.7;
 }

 if (report.v > 0) report.v = move_unit();
 if (report.v < 0) report.v = move_unit() * -1;
 if (report.h > 0) report.h = move_unit();
 if (report.h < 0) report.h = move_unit() * -1;

 mousekey_send();
 }

 void mousekey_on(uint8_t code)
 {
 if (code == KB_MS_UP) report.y = MOUSEKEY_MOVE_INIT * -1;
 else if (code == KB_MS_DOWN) report.y = MOUSEKEY_MOVE_INIT;
 else if (code == KB_MS_LEFT) report.x = MOUSEKEY_MOVE_INIT * -1;
 else if (code == KB_MS_RIGHT) report.x = MOUSEKEY_MOVE_INIT;
 else if (code == KB_MS_WH_UP) report.v = MOUSEKEY_WHEEL_INIT;
 else if (code == KB_MS_WH_DOWN) report.v = MOUSEKEY_WHEEL_INIT * -1;
 else if (code == KB_MS_WH_LEFT) report.h = MOUSEKEY_WHEEL_INIT * -1;
 else if (code == KB_MS_WH_RIGHT) report.h = MOUSEKEY_WHEEL_INIT;
 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;
 }

 void mousekey_off(uint8_t code)
 {
 if (code == KB_MS_UP && report.y < 0) report.y = 0;
 else if (code == KB_MS_DOWN && report.y > 0) report.y = 0;
 else if (code == KB_MS_LEFT && report.x < 0) report.x = 0;
 else if (code == KB_MS_RIGHT && report.x > 0) report.x = 0;
 else if (code == KB_MS_WH_UP && report.v > 0) report.v = 0;
 else if (code == KB_MS_WH_DOWN && report.v < 0) report.v = 0;
 else if (code == KB_MS_WH_LEFT && report.h < 0) report.h = 0;
 else if (code == KB_MS_WH_RIGHT && report.h > 0) report.h = 0;
 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;

 if (report.x == 0 && report.y == 0 && report.v == 0 && report.h == 0)
 mousekey_repeat = 0;
 }

 void mousekey_send(void)
 {
 mousekey_debug();
 host_mouse_send(&report);
 report_prev = report;
 last_timer = timer_read();
 mousekey_clear_report();
 }

 void mousekey_clear_report(void)
 void mousekey_clear(void)
 {
 report = (report_mouse_t){};
 /*
 report.buttons = 0;
 report.x = 0;
 report.y = 0;
 report.v = 0;
 report.h = 0;
 */
 }

 static void mousekey_debug(void)
--- a/common/mousekey.h
+++ b/common/mousekey.h
@@ -21,9 +21,10 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
 #include <stdbool.h>
 #include "host.h"

 void mousekey_decode(uint8_t code);
 bool mousekey_changed(void);
 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/timer.c
+++ b/common/timer.c
@@ -22,6 +22,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.


 // 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
@@ -33,8 +33,9 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
 #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))
 #define MOD_BIT(code) (1<<((code) & 0x07))
 #define FN_BIT(code) (1<<((code) - KB_FN0))
 #define FN_INDEX(code) ((code) - KB_FN0)


 /* Short names */
--- a/common/util.c
+++ b/common/util.c
@@ -17,19 +17,23 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.

 #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
@@ -28,7 +28,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
 #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/protocol/lufa/lufa.c
+++ b/protocol/lufa/lufa.c
@@ -475,7 +475,7 @@ int main(void)
 keyboard_init();
 host_set_driver(&lufa_driver);
 while (1) {
 keyboard_proc();
 keyboard_task();

 #if !defined(INTERRUPT_CONTROL_ENDPOINT)
 USB_USBTask();