Merge branch 'virtual_dipsw'

README.md

@@ -106,6 +106,8 @@ Following commands can be also executed with `Magic` + key. In console mode `Mag
     v:      print device version & info
     t:      print timer count
     s:      print status
+    e:	    print eeprom config
+    n:	    toggle NKRO
     0/F10:  switch to Layer0
     1/F1:   switch to Layer1
     2/F2:   switch to Layer2
@@ -117,13 +119,24 @@ Following commands can be also executed with `Magic` + key. In console mode `Mag
 
 **TBD**
 
-### Conguration with Boot Magic
+### Boot Magic Configuration - Virtual DIP Switch
 Boot Magic are executed during boot up time. Press Magic key below then pulgin keyboard cable.
-These settings are stored in EEPROM.
+Note that you must use keys of **Layer 0** as Magic keys. These settings are stored in EEPROM so that retain your configure over power cycles.
 
+#### EEPROM
+- Skip reading EEPROM(`ESC`)
 - Clear configuration stored in EEPROM(`Backspace`)
+
+#### Bootloader
 - Kick up Bootloader(`B`)
+
+#### Debug
 - Debug enable(`D`)
+- Debug matrix enable(`D`+`X`)
+- Debug keyboard enable(`D`+`K`)
+- Debug mouse enable(`D`+`M`)
+
+#### Keymap
 - Swap Control and CapsLock(`Left Control`)
 - Change CapsLock to Control(`Casp Lock`)
 - Swap LeftAlt and Gui(`Left Alt`)
@@ -132,6 +145,12 @@ These settings are stored in EEPROM.
 - Swap Grave and Escape(`Grave`)
 - Swap BackSlash and BackSpace(`Back Slash`)
 
+#### Default Layer
+- Set Default Layer to 0(`0`)
+- Set Default Layer to 0(`1`)
+- Set Default Layer to 0(`2`)
+- Set Default Layer to 0(`3`)
+
 **TBD**
 
 

common.mk

@@ -9,7 +9,6 @@ SRC +=	$(COMMON_DIR)/host.c \
 	$(COMMON_DIR)/keymap.c \
 	$(COMMON_DIR)/timer.c \
 	$(COMMON_DIR)/print.c \
-	$(COMMON_DIR)/debug.c \
 	$(COMMON_DIR)/bootloader.c \
 	$(COMMON_DIR)/suspend.c \
 	$(COMMON_DIR)/util.c

common/bootmagic.c

@@ -2,53 +2,78 @@
 #include <stdbool.h>
 #include <util/delay.h>
 #include "matrix.h"
+#include "bootloader.h"
+#include "debug.h"
 #include "keymap.h"
 #include "eeconfig.h"
-#include "bootloader.h"
 #include "bootmagic.h"
 
 
 void bootmagic(void)
 {
-    if (!BOOTMAGIC_IS_ENABLED()) { return; }
+    /* check signature */
-
+    if (!eeconfig_is_enabled()) {
-    /* do scans in case of bounce */
-    uint8_t scan = 100;
-    while (scan--) { matrix_scan(); _delay_ms(1); }
-
-    if (bootmagic_scan_keycode(BOOTMAGIC_BOOTLOADER_KEY)) {
-        bootloader_jump();
-    }
-
-    if (bootmagic_scan_keycode(BOOTMAGIC_DEBUG_ENABLE_KEY)) {
-        eeconfig_write_debug(eeconfig_read_debug() ^ EECONFIG_DEBUG_ENABLE);
-    }
-
-    if (bootmagic_scan_keycode(BOOTMAGIC_EEPROM_CLEAR_KEY)) {
         eeconfig_init();
     }
 
-    if (bootmagic_scan_keycode(BOOTMAGIC_SWAP_CONTROL_CPASLOCK)) {
+    /* do scans in case of bounce */
-        eeconfig_write_keyconf(eeconfig_read_keyconf() ^ EECONFIG_KEYCONF_SWAP_CONTROL_CAPSLOCK);
+    uint8_t scan = 100;
+    while (scan--) { matrix_scan(); _delay_ms(10); }
+
+    /* bootmagic skip */
+    if (bootmagic_scan_keycode(BOOTMAGIC_KEY_SKIP)) {
+        return;
     }
-    if (bootmagic_scan_keycode(BOOTMAGIC_CAPSLOCK_TO_CONTROL)) {
+
-        eeconfig_write_keyconf(eeconfig_read_keyconf() ^ EECONFIG_KEYCONF_CAPSLOCK_TO_CONTROL);
+    /* eeconfig clear */
+    if (bootmagic_scan_keycode(BOOTMAGIC_KEY_EEPROM_CLEAR)) {
+        eeconfig_init();
     }
-    if (bootmagic_scan_keycode(BOOTMAGIC_SWAP_LALT_LGUI)) {
+
-        eeconfig_write_keyconf(eeconfig_read_keyconf() ^ EECONFIG_KEYCONF_SWAP_LALT_LGUI);
+    /* bootloader */
+    if (bootmagic_scan_keycode(BOOTMAGIC_KEY_BOOTLOADER)) {
+        bootloader_jump();
     }
-    if (bootmagic_scan_keycode(BOOTMAGIC_SWAP_RALT_RGUI)) {
+
-        eeconfig_write_keyconf(eeconfig_read_keyconf() ^ EECONFIG_KEYCONF_SWAP_RALT_RGUI);
+    /* debug enable */
+    debug_config.raw = eeconfig_read_debug();
+    if (bootmagic_scan_keycode(BOOTMAGIC_KEY_DEBUG_ENABLE)) {
+        if (bootmagic_scan_keycode(BOOTMAGIC_KEY_DEBUG_MATRIX)) {
+            debug_config.matrix = !debug_config.matrix;
+        } else if (bootmagic_scan_keycode(BOOTMAGIC_KEY_DEBUG_KEYBOARD)) {
+            debug_config.keyboard = !debug_config.keyboard;
+        } else if (bootmagic_scan_keycode(BOOTMAGIC_KEY_DEBUG_MOUSE)) {
+            debug_config.mouse = !debug_config.mouse;
+        } else {
+            debug_config.enable = !debug_config.enable;
+        }
     }
-    if (bootmagic_scan_keycode(BOOTMAGIC_NO_GUI)) {
+    eeconfig_write_debug(debug_config.raw);
-        eeconfig_write_keyconf(eeconfig_read_keyconf() ^ EECONFIG_KEYCONF_NO_GUI);
+
+    /* keymap config */
+    keymap_config.raw = eeconfig_read_keymap();
+    if (bootmagic_scan_keycode(BOOTMAGIC_KEY_SWAP_CONTROL_CPASLOCK)) {
+        keymap_config.swap_control_capslock = !keymap_config.swap_control_capslock;
     }
-    if (bootmagic_scan_keycode(BOOTMAGIC_SWAP_GRAVE_ESC)) {
+    if (bootmagic_scan_keycode(BOOTMAGIC_KEY_CAPSLOCK_TO_CONTROL)) {
-        eeconfig_write_keyconf(eeconfig_read_keyconf() ^ EECONFIG_KEYCONF_SWAP_GRAVE_ESC);
+        keymap_config.capslock_to_control = !keymap_config.capslock_to_control;
     }
-    if (bootmagic_scan_keycode(BOOTMAGIC_SWAP_BACKSLASH_BACKSPACE)) {
+    if (bootmagic_scan_keycode(BOOTMAGIC_KEY_SWAP_LALT_LGUI)) {
-        eeconfig_write_keyconf(eeconfig_read_keyconf() ^ EECONFIG_KEYCONF_SWAP_BACKSLASH_BACKSPACE);
+        keymap_config.swap_lalt_lgui = !keymap_config.swap_lalt_lgui;
     }
+    if (bootmagic_scan_keycode(BOOTMAGIC_KEY_SWAP_RALT_RGUI)) {
+        keymap_config.swap_ralt_rgui = !keymap_config.swap_ralt_rgui;
+    }
+    if (bootmagic_scan_keycode(BOOTMAGIC_KEY_NO_GUI)) {
+        keymap_config.no_gui = !keymap_config.no_gui;
+    }
+    if (bootmagic_scan_keycode(BOOTMAGIC_KEY_SWAP_GRAVE_ESC)) {
+        keymap_config.swap_grave_esc = !keymap_config.swap_grave_esc;
+    }
+    if (bootmagic_scan_keycode(BOOTMAGIC_KEY_SWAP_BACKSLASH_BACKSPACE)) {
+        keymap_config.swap_backslash_backspace = !keymap_config.swap_backslash_backspace;
+    }
+    eeconfig_write_keymap(keymap_config.raw);
 }
 
 bool bootmagic_scan_keycode(uint8_t keycode)

common/bootmagic.h

@@ -2,71 +2,45 @@
 #define BOOTMAGIC_H
 
 
-#ifndef BOOTMAGIC_IS_ENABLED
+#ifndef BOOTMAGIC_KEY_SKIP
-#define BOOTMAGIC_IS_ENABLED()          true
+#define BOOTMAGIC_KEY_SKIP              KC_ESC
+#endif
+
+/* eeprom clear */
+#ifndef BOOTMAGIC_KEY_EEPROM_CLEAR
+#define BOOTMAGIC_KEY_EEPROM_CLEAR      KC_BSPACE
 #endif
 
 /* kick up bootloader */
-#ifndef BOOTMAGIC_BOOTLOADER_KEY
+#ifndef BOOTMAGIC_KEY_BOOTLOADER
-#define BOOTMAGIC_BOOTLOADER_KEY        KC_B
+#define BOOTMAGIC_KEY_BOOTLOADER        KC_B
-#endif
-/* debug enable */
-#ifndef BOOTMAGIC_DEBUG_ENABLE_KEY
-#define BOOTMAGIC_DEBUG_ENABLE_KEY      KC_D
-#endif
-/* eeprom clear */
-#ifndef BOOTMAGIC_EEPROM_CLEAR_KEY
-#define BOOTMAGIC_EEPROM_CLEAR_KEY      KC_BSPACE
 #endif
 
+/* debug enable */
+#define BOOTMAGIC_KEY_DEBUG_ENABLE      KC_D
+#define BOOTMAGIC_KEY_DEBUG_MATRIX      KC_X
+#define BOOTMAGIC_KEY_DEBUG_KEYBOARD    KC_K
+#define BOOTMAGIC_KEY_DEBUG_MOUSE       KC_M
+
 /*
- * key configure
+ * keymap config
  */
-/* swap control and capslock */
+#define BOOTMAGIC_KEY_SWAP_CONTROL_CPASLOCK     KC_LCTRL
-#ifndef BOOTMAGIC_SWAP_CONTROL_CPASLOCK
+#define BOOTMAGIC_KEY_CAPSLOCK_TO_CONTROL       KC_CAPSLOCK
-#define BOOTMAGIC_SWAP_CONTROL_CPASLOCK     KC_LCTRL
+#define BOOTMAGIC_KEY_SWAP_LALT_LGUI            KC_LALT
-#endif
+#define BOOTMAGIC_KEY_SWAP_RALT_RGUI            KC_RALT
-/* capslock to control */
+#define BOOTMAGIC_KEY_NO_GUI                    KC_LGUI
-#ifndef BOOTMAGIC_CAPSLOCK_TO_CONTROL
+#define BOOTMAGIC_KEY_SWAP_GRAVE_ESC            KC_GRAVE
-#define BOOTMAGIC_CAPSLOCK_TO_CONTROL       KC_CAPSLOCK
+#define BOOTMAGIC_KEY_SWAP_BACKSLASH_BACKSPACE  KC_BSLASH
-#endif
-/* swap alt and gui */
-#ifndef BOOTMAGIC_SWAP_LALT_LGUI
-#define BOOTMAGIC_SWAP_LALT_LGUI            KC_LALT
-#endif
-/* swap alt and gui */
-#ifndef BOOTMAGIC_SWAP_RALT_RGUI
-#define BOOTMAGIC_SWAP_RALT_RGUI            KC_RALT
-#endif
-/* no gui */
-#ifndef BOOTMAGIC_NO_GUI
-#define BOOTMAGIC_NO_GUI                    KC_LGUI
-#endif
-/* swap esc and grave */
-#ifndef BOOTMAGIC_SWAP_GRAVE_ESC
-#define BOOTMAGIC_SWAP_GRAVE_ESC            KC_GRAVE
-#endif
-/* swap backslash and backspace */
-#ifndef BOOTMAGIC_SWAP_BACKSLASH_BACKSPACE
-#define BOOTMAGIC_SWAP_BACKSLASH_BACKSPACE  KC_BSLASH
-#endif
 
 
 /*
  * change default layer
  */
-#ifndef BOOTMAGIC_DEFAULT_LAYER_0_KEY
+#define BOOTMAGIC_KEY_DEFAULT_LAYER_0   KC_0
-#define BOOTMAGIC_DEFAULT_LAYER_0_KEY   KC_0
+#define BOOTMAGIC_KEY_DEFAULT_LAYER_1   KC_1
-#endif
+#define BOOTMAGIC_KEY_DEFAULT_LAYER_2   KC_2
-#ifndef BOOTMAGIC_DEFAULT_LAYER_1_KEY
+#define BOOTMAGIC_KEY_DEFAULT_LAYER_3   KC_3
-#define BOOTMAGIC_DEFAULT_LAYER_1_KEY   KC_1
-#endif
-#ifndef BOOTMAGIC_DEFAULT_LAYER_2_KEY
-#define BOOTMAGIC_DEFAULT_LAYER_2_KEY   KC_2
-#endif
-#ifndef BOOTMAGIC_DEFAULT_LAYER_3_KEY
-#define BOOTMAGIC_DEFAULT_LAYER_3_KEY   KC_3
-#endif
 
 
 void bootmagic(void);

common/command.c

@@ -110,7 +110,7 @@ static void command_common_help(void)
     print("v:	print device version & info\n");
     print("t:	print timer count\n");
     print("s:	print status\n");
-    print("e:	print eeprom boot config\n");
+    print("e:	print eeprom config\n");
 #ifdef NKRO_ENABLE
     print("n:	toggle NKRO\n");
 #endif
@@ -125,28 +125,28 @@ static void command_common_help(void)
 }
 
 #ifdef BOOTMAGIC_ENABLE
-static void print_eeprom_config(void)
+static void print_eeconfig(void)
 {
-    uint8_t eebyte;
+    print("default_layer: "); print_dec(eeconfig_read_defalt_layer()); print("\n");
 
-    eebyte = eeconfig_read_debug();
+    debug_config_t dc;
-    print("debug: "); print_hex8(eebyte); print("\n");
+    dc.raw = eeconfig_read_debug();
+    print("debug_config.raw: "); print_hex8(dc.raw); print("\n");
+    print(".enable: "); print_dec(dc.enable); print("\n");
+    print(".matrix: "); print_dec(dc.matrix); print("\n");
+    print(".keyboard: "); print_dec(dc.keyboard); print("\n");
+    print(".mouse: "); print_dec(dc.mouse); print("\n");
 
-    eebyte = eeconfig_read_defalt_layer();
+    keymap_config_t kc;
-    print("defalt_layer: "); print_hex8(eebyte); print("\n");
+    kc.raw = eeconfig_read_keymap();
-
+    print("keymap_config.raw: "); print_hex8(kc.raw); print("\n");
-    eebyte = eeconfig_read_keyconf();
+    print(".swap_control_capslock: "); print_dec(kc.swap_control_capslock); print("\n");
-    print("keyconf: "); print_hex8(eebyte); print("\n");
+    print(".capslock_to_control: "); print_dec(kc.capslock_to_control); print("\n");
-
+    print(".swap_lalt_lgui: "); print_dec(kc.swap_lalt_lgui); print("\n");
-    keyconf kc;
+    print(".swap_ralt_rgui: "); print_dec(kc.swap_ralt_rgui); print("\n");
-    kc = (keyconf){ .raw = eebyte };
+    print(".no_gui: "); print_dec(kc.no_gui); print("\n");
-    print("keyconf.swap_control_capslock: "); print_hex8(kc.swap_control_capslock); print("\n");
+    print(".swap_grave_esc: "); print_dec(kc.swap_grave_esc); print("\n");
-    print("keyconf.capslock_to_control: "); print_hex8(kc.capslock_to_control); print("\n");
+    print(".swap_backslash_backspace: "); print_dec(kc.swap_backslash_backspace); print("\n");
-    print("keyconf.swap_lalt_lgui: "); print_hex8(kc.swap_lalt_lgui); print("\n");
-    print("keyconf.swap_ralt_rgui: "); print_hex8(kc.swap_ralt_rgui); print("\n");
-    print("keyconf.no_gui: "); print_hex8(kc.no_gui); print("\n");
-    print("keyconf.swap_grave_esc: "); print_hex8(kc.swap_grave_esc); print("\n");
-    print("keyconf.swap_backslash_backspace: "); print_hex8(kc.swap_backslash_backspace); print("\n");
 }
 #endif
 
@@ -162,8 +162,8 @@ static bool command_common(uint8_t code)
             break;
 #ifdef BOOTMAGIC_ENABLE
         case KC_E:
-            print("eeprom config\n");
+            print("eeconfig:\n");
-            print_eeprom_config();
+            print_eeconfig();
             break;
 #endif
         case KC_CAPSLOCK:

common/debug.c

@@ -1,8 +0,0 @@
-#include <stdbool.h>
-#include "debug.h"
-
-
-bool debug_enable = false;
-bool debug_matrix = false;
-bool debug_keyboard = false;
-bool debug_mouse = false;

common/debug.h

@@ -79,10 +79,26 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 extern "C" {
 #endif
 
-extern bool debug_enable;
+
-extern bool debug_matrix;
+/* NOTE: Not portable. Bit field order depends on implementation */
-extern bool debug_keyboard;
+typedef union {
-extern bool debug_mouse;
+    uint8_t raw;
+    struct {
+        bool enable:1;
+        bool matrix:1;
+        bool keyboard:1;
+        bool mouse:1;
+        uint8_t reserved:4;
+    };
+} debug_config_t;
+debug_config_t debug_config;
+
+/* for backward compatibility */
+#define debug_enable    (debug_config.enable)
+#define debug_matrix    (debug_config.matrix)
+#define debug_keyboard  (debug_config.keyboard)
+#define debug_mouse     (debug_config.mouse)
+
 
 #ifdef __cplusplus
 }

common/eeconfig.c

@@ -3,13 +3,12 @@
 #include <avr/eeprom.h>
 #include "eeconfig.h"
 
-
 void eeconfig_init(void)
 {
     eeprom_write_word(EECONFIG_MAGIC,          EECONFIG_MAGIC_NUMBER);
     eeprom_write_byte(EECONFIG_DEBUG,          0);
     eeprom_write_byte(EECONFIG_DEFAULT_LAYER,  0);
-    eeprom_write_byte(EECONFIG_KEYCONF,        0);
+    eeprom_write_byte(EECONFIG_KEYMAP,         0);
     eeprom_write_byte(EECONFIG_MOUSEKEY_ACCEL, 0);
 }
 
@@ -25,7 +24,7 @@ void eeconfig_disable(void)
 
 bool eeconfig_is_enabled(void)
 {
-    return EECONFIG_IS_ENABLED() && (eeprom_read_word(EECONFIG_MAGIC) == EECONFIG_MAGIC_NUMBER);
+    return (eeprom_read_word(EECONFIG_MAGIC) == EECONFIG_MAGIC_NUMBER);
 }
 
 uint8_t eeconfig_read_debug(void)      { return eeprom_read_byte(EECONFIG_DEBUG); }
@@ -34,5 +33,5 @@ void eeconfig_write_debug(uint8_t val) { eeprom_write_byte(EECONFIG_DEBUG, val);
 uint8_t eeconfig_read_defalt_layer(void)      { return eeprom_read_byte(EECONFIG_DEFAULT_LAYER); }
 void eeconfig_write_defalt_layer(uint8_t val) { eeprom_write_byte(EECONFIG_DEFAULT_LAYER, val); }
 
-uint8_t eeconfig_read_keyconf(void)      { return eeprom_read_byte(EECONFIG_KEYCONF); }
+uint8_t eeconfig_read_keymap(void)      { return eeprom_read_byte(EECONFIG_KEYMAP); }
-void eeconfig_write_keyconf(uint8_t val) { eeprom_write_byte(EECONFIG_KEYCONF, val); }
+void eeconfig_write_keymap(uint8_t val) { eeprom_write_byte(EECONFIG_KEYMAP, val); }

common/eeconfig.h

@@ -20,51 +20,33 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #include <stdint.h>
 
-#ifndef EECONFIG_IS_ENABLED
-#define EECONFIG_IS_ENABLED()       true
-#endif
 
-#define EECONFIG_MAGIC_NUMBER                   (uint16_t)0xFEED
+#define EECONFIG_MAGIC_NUMBER                       (uint16_t)0xFEED
 
 /* eeprom parameteter address */
-#define EECONFIG_MAGIC                          (uint16_t *)0
+#define EECONFIG_MAGIC                              (uint16_t *)0
-#define EECONFIG_DEBUG                          (uint8_t *)2
+#define EECONFIG_DEBUG                              (uint8_t *)2
-#define EECONFIG_DEFAULT_LAYER                  (uint8_t *)3
+#define EECONFIG_DEFAULT_LAYER                      (uint8_t *)3
-#define EECONFIG_KEYCONF                        (uint8_t *)4
+#define EECONFIG_KEYMAP                             (uint8_t *)4
-#define EECONFIG_MOUSEKEY_ACCEL                 (uint8_t *)5
+#define EECONFIG_MOUSEKEY_ACCEL                     (uint8_t *)5
 
 
 /* debug bit */
-#define EECONFIG_DEBUG_ENABLE                   (1<<0)
+#define EECONFIG_DEBUG_ENABLE                       (1<<0)
-#define EECONFIG_DEBUG_MATRIX                   (1<<1)
+#define EECONFIG_DEBUG_MATRIX                       (1<<1)
-#define EECONFIG_DEBUG_KEYBOARD                 (1<<2)
+#define EECONFIG_DEBUG_KEYBOARD                     (1<<2)
-#define EECONFIG_DEBUG_MOUSE                    (1<<3)
+#define EECONFIG_DEBUG_MOUSE                        (1<<3)
 
 /* keyconf bit */
-#define EECONFIG_KEYCONF_SWAP_CONTROL_CAPSLOCK     (1<<0)
+#define EECONFIG_KEYMAP_SWAP_CONTROL_CAPSLOCK       (1<<0)
-#define EECONFIG_KEYCONF_CAPSLOCK_TO_CONTROL       (1<<1)
+#define EECONFIG_KEYMAP_CAPSLOCK_TO_CONTROL         (1<<1)
-#define EECONFIG_KEYCONF_SWAP_LALT_LGUI            (1<<2)
+#define EECONFIG_KEYMAP_SWAP_LALT_LGUI              (1<<2)
-#define EECONFIG_KEYCONF_SWAP_RALT_RGUI            (1<<3)
+#define EECONFIG_KEYMAP_SWAP_RALT_RGUI              (1<<3)
-#define EECONFIG_KEYCONF_NO_GUI                    (1<<4)
+#define EECONFIG_KEYMAP_NO_GUI                      (1<<4)
-#define EECONFIG_KEYCONF_SWAP_GRAVE_ESC            (1<<5)
+#define EECONFIG_KEYMAP_SWAP_GRAVE_ESC              (1<<5)
-#define EECONFIG_KEYCONF_SWAP_BACKSLASH_BACKSPACE  (1<<6)
+#define EECONFIG_KEYMAP_SWAP_BACKSLASH_BACKSPACE    (1<<6)
 
 
-/* XXX: Not portable. Bit field order depends on implementation */
-typedef union {
-    uint8_t raw;
-    struct {
-        bool swap_control_capslock:1;
-        bool capslock_to_control:1;
-        bool swap_lalt_lgui:1;
-        bool swap_ralt_rgui:1;
-        bool no_gui:1;
-        bool swap_grave_esc:1;
-        bool swap_backslash_backspace:1;
-        bool reserved:1;
-    };
-} keyconf;
-
 bool eeconfig_is_enabled(void);
 
 void eeconfig_init(void);
@@ -79,7 +61,7 @@ void eeconfig_write_debug(uint8_t val);
 uint8_t eeconfig_read_defalt_layer(void);
 void eeconfig_write_defalt_layer(uint8_t val);
 
-uint8_t eeconfig_read_keyconf(void);
+uint8_t eeconfig_read_keymap(void);
-void eeconfig_write_keyconf(uint8_t val);
+void eeconfig_write_keymap(uint8_t val);
 
 #endif

common/keyboard.c

@@ -64,18 +64,6 @@ void keyboard_init(void)
 
 #ifdef BOOTMAGIC_ENABLE
     bootmagic();
-
-    if (eeconfig_is_enabled()) {
-        uint8_t config;
-        config = eeconfig_read_debug();
-        // ignored if debug is enabled by program before.
-        if (!debug_enable)   debug_enable   = (config & EECONFIG_DEBUG_ENABLE);
-        if (!debug_matrix)   debug_matrix   = (config & EECONFIG_DEBUG_MATRIX);
-        if (!debug_keyboard) debug_keyboard = (config & EECONFIG_DEBUG_KEYBOARD);
-        if (!debug_mouse)    debug_mouse    = (config & EECONFIG_DEBUG_MOUSE);
-    } else {
-        eeconfig_init();
-    }
 #endif
 }
 

common/keymap.c

@@ -34,6 +34,70 @@ action_t action_for_key(uint8_t layer, key_t key)
     switch (keycode) {
         case KC_FN0 ... KC_FN31:
             return keymap_fn_to_action(keycode);
+#ifdef BOOTMAGIC_ENABLE
+        case KC_CAPSLOCK:
+            if (keymap_config.swap_control_capslock || keymap_config.capslock_to_control) {
+                return keycode_to_action(KC_LCTL);
+            }
+            return keycode_to_action(KC_CAPS);
+        case KC_LCTL:
+            if (keymap_config.swap_control_capslock) {
+                return keycode_to_action(KC_CAPSLOCK);
+            }
+            return keycode_to_action(KC_LCTL);
+        case KC_LALT:
+            if (keymap_config.swap_lalt_lgui) {
+                if (keymap_config.no_gui) {
+                    return keycode_to_action(ACTION_NO);
+                }
+                return keycode_to_action(KC_LGUI);
+            }
+            return keycode_to_action(KC_LALT);
+        case KC_LGUI:
+            if (keymap_config.swap_lalt_lgui) {
+                return keycode_to_action(KC_LALT);
+            }
+            if (keymap_config.no_gui) {
+                return keycode_to_action(ACTION_NO);
+            }
+            return keycode_to_action(KC_LGUI);
+        case KC_RALT:
+            if (keymap_config.swap_ralt_rgui) {
+                if (keymap_config.no_gui) {
+                    return keycode_to_action(ACTION_NO);
+                }
+                return keycode_to_action(KC_RGUI);
+            }
+            return keycode_to_action(KC_RALT);
+        case KC_RGUI:
+            if (keymap_config.swap_ralt_rgui) {
+                return keycode_to_action(KC_RALT);
+            }
+            if (keymap_config.no_gui) {
+                return keycode_to_action(ACTION_NO);
+            }
+            return keycode_to_action(KC_RGUI);
+        case KC_GRAVE:
+            if (keymap_config.swap_grave_esc) {
+                return keycode_to_action(KC_ESC);
+            }
+            return keycode_to_action(KC_GRAVE);
+        case KC_ESC:
+            if (keymap_config.swap_grave_esc) {
+                return keycode_to_action(KC_GRAVE);
+            }
+            return keycode_to_action(KC_ESC);
+        case KC_BSLASH:
+            if (keymap_config.swap_backslash_backspace) {
+                return keycode_to_action(KC_BSPACE);
+            }
+            return keycode_to_action(KC_BSLASH);
+        case KC_BSPACE:
+            if (keymap_config.swap_backslash_backspace) {
+                return keycode_to_action(KC_BSLASH);
+            }
+            return keycode_to_action(KC_BSPACE);
+#endif
         default:
             return keycode_to_action(keycode);
     }

common/keymap.h

@@ -23,6 +23,25 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "action.h"
 
 
+#ifdef BOOTMAGIC_ENABLE
+/* NOTE: Not portable. Bit field order depends on implementation */
+typedef union {
+    uint8_t raw;
+    struct {
+        bool swap_control_capslock:1;
+        bool capslock_to_control:1;
+        bool swap_lalt_lgui:1;
+        bool swap_ralt_rgui:1;
+        bool no_gui:1;
+        bool swap_grave_esc:1;
+        bool swap_backslash_backspace:1;
+        bool reserved:1;
+    };
+} keymap_config_t;
+keymap_config_t keymap_config;
+#endif
+
+
 /* translates key to keycode */
 uint8_t keymap_key_to_keycode(uint8_t layer, key_t key);