5 files changed, 594 insertions, 27 deletions

diff --git a/quantum/dynamic_keymap.c b/quantum/dynamic_keymap.c
index ca056f630..11d28592d 100644
--- a/quantum/dynamic_keymap.c
+++ b/quantum/dynamic_keymap.c
@@ -20,28 +20,37 @@
 #include "progmem.h"  // to read default from flash
 #include "quantum.h"  // for send_string()
 #include "dynamic_keymap.h"
-
-#ifdef DYNAMIC_KEYMAP_ENABLE
-
-#    ifndef DYNAMIC_KEYMAP_EEPROM_ADDR
-#        error DYNAMIC_KEYMAP_EEPROM_ADDR not defined
-#    endif
-
-#    ifndef DYNAMIC_KEYMAP_LAYER_COUNT
-#        error DYNAMIC_KEYMAP_LAYER_COUNT not defined
-#    endif
-
-#    ifndef DYNAMIC_KEYMAP_MACRO_COUNT
-#        error DYNAMIC_KEYMAP_MACRO_COUNT not defined
-#    endif
-
-#    ifndef DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR
-#        error DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR not defined
-#    endif
-
-#    ifndef DYNAMIC_KEYMAP_MACRO_EEPROM_SIZE
-#        error DYNAMIC_KEYMAP_MACRO_EEPROM_SIZE not defined
-#    endif
+#include "via.h" // for default VIA_EEPROM_ADDR_END
+
+#ifndef DYNAMIC_KEYMAP_LAYER_COUNT
+#   define DYNAMIC_KEYMAP_LAYER_COUNT 4
+#endif
+
+#ifndef DYNAMIC_KEYMAP_MACRO_COUNT
+#   define DYNAMIC_KEYMAP_MACRO_COUNT 16
+#endif
+
+// If DYNAMIC_KEYMAP_EEPROM_ADDR not explicitly defined in config.h,
+// default it start after VIA_EEPROM_CUSTOM_ADDR+VIA_EEPROM_CUSTOM_SIZE
+#ifndef DYNAMIC_KEYMAP_EEPROM_ADDR
+#   ifdef VIA_EEPROM_CUSTOM_CONFIG_ADDR
+#       define DYNAMIC_KEYMAP_EEPROM_ADDR (VIA_EEPROM_CUSTOM_CONFIG_ADDR+VIA_EEPROM_CUSTOM_CONFIG_SIZE)
+#   else
+#       error DYNAMIC_KEYMAP_EEPROM_ADDR not defined
+#   endif 
+#endif
+
+// Dynamic macro starts after dynamic keymaps
+#ifndef DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR
+#   define DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR (DYNAMIC_KEYMAP_EEPROM_ADDR+(DYNAMIC_KEYMAP_LAYER_COUNT*MATRIX_ROWS*MATRIX_COLS*2))
+#endif
+
+// Dynamic macro uses up all remaining memory
+// Assumes 1K EEPROM on ATMega32U4
+// Override for anything different
+#ifndef DYNAMIC_KEYMAP_MACRO_EEPROM_SIZE
+#   define DYNAMIC_KEYMAP_MACRO_EEPROM_SIZE (1024-DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR)
+#endif
 
 uint8_t dynamic_keymap_get_layer_count(void) { return DYNAMIC_KEYMAP_LAYER_COUNT; }
 
@@ -208,5 +217,3 @@ void dynamic_keymap_macro_send(uint8_t id) {
         send_string(data);
     }
 }
-
-#endif  // DYNAMIC_KEYMAP_ENABLE
diff --git a/quantum/quantum.c b/quantum/quantum.c
index 695da5fdc..bf159644a 100644
--- a/quantum/quantum.c
+++ b/quantum/quantum.c
@@ -213,6 +213,9 @@ bool process_record_quantum(keyrecord_t *record) {
 #if defined(RGB_MATRIX_ENABLE)
             process_rgb_matrix(keycode, record) &&
 #endif
+#if defined(VIA_ENABLE)
+            process_record_via(keycode, record) &&
+#endif
             process_record_kb(keycode, record) &&
 #if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED)
             process_midi(keycode, record) &&
@@ -560,9 +563,7 @@ __attribute__((weak)) void bootmagic_lite(void) {
 
     // We need multiple scans because debouncing can't be turned off.
     matrix_scan();
-#if defined(DEBOUNCING_DELAY) && DEBOUNCING_DELAY > 0
-    wait_ms(DEBOUNCING_DELAY * 2);
-#elif defined(DEBOUNCE) && DEBOUNCE > 0
+#if defined(DEBOUNCE) && DEBOUNCE > 0
     wait_ms(DEBOUNCE * 2);
 #else
     wait_ms(30);
diff --git a/quantum/quantum.h b/quantum/quantum.h
index 053b33b91..9758374f6 100644
--- a/quantum/quantum.h
+++ b/quantum/quantum.h
@@ -162,6 +162,14 @@ extern layer_state_t layer_state;
 #    include "process_dynamic_macro.h"
 #endif
 
+#ifdef DYNAMIC_KEYMAP_ENABLE
+#   include "dynamic_keymap.h"
+#endif
+
+#ifdef VIA_ENABLE
+#   include "via.h"
+#endif
+
 // Function substitutions to ease GPIO manipulation
 #if defined(__AVR__)
 typedef uint8_t pin_t;
diff --git a/quantum/via.c b/quantum/via.c
new file mode 100644
index 000000000..64b05324a
--- /dev/null
+++ b/quantum/via.c
@@ -0,0 +1,400 @@
+/* Copyright 2019 Jason Williams (Wilba)
+ *
+ * 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 RAW_ENABLE
+#    error "RAW_ENABLE is not enabled"
+#endif
+
+#ifndef DYNAMIC_KEYMAP_ENABLE
+#    error "DYNAMIC_KEYMAP_ENABLE is not enabled"
+#endif
+
+#include "quantum.h"
+
+#include "via.h"
+#include "raw_hid.h"
+#include "dynamic_keymap.h"
+#include "tmk_core/common/eeprom.h"
+#include "version.h" // for QMK_BUILDDATE used in EEPROM magic
+
+// Can be called in an overriding via_init_kb() to test if keyboard level code usage of
+// EEPROM is invalid and use/save defaults.
+bool via_eeprom_is_valid(void)
+{
+    char *p = QMK_BUILDDATE; // e.g. "2019-11-05-11:29:54"
+    uint8_t magic0 = ( ( p[2] & 0x0F ) << 4 ) | ( p[3]  & 0x0F );
+    uint8_t magic1 = ( ( p[5] & 0x0F ) << 4 ) | ( p[6]  & 0x0F );
+    uint8_t magic2 = ( ( p[8] & 0x0F ) << 4 ) | ( p[9]  & 0x0F );
+
+    return (eeprom_read_byte( (void*)VIA_EEPROM_MAGIC_ADDR+0 ) == magic0 &&
+            eeprom_read_byte( (void*)VIA_EEPROM_MAGIC_ADDR+1 ) == magic1 &&
+            eeprom_read_byte( (void*)VIA_EEPROM_MAGIC_ADDR+2 ) == magic2 );
+}
+
+// Sets VIA/keyboard level usage of EEPROM to valid/invalid
+// Keyboard level code (eg. via_init_kb()) should not call this
+void via_eeprom_set_valid(bool valid)
+{
+    char *p = QMK_BUILDDATE; // e.g. "2019-11-05-11:29:54"
+    uint8_t magic0 = ( ( p[2] & 0x0F ) << 4 ) | ( p[3]  & 0x0F );
+    uint8_t magic1 = ( ( p[5] & 0x0F ) << 4 ) | ( p[6]  & 0x0F );
+    uint8_t magic2 = ( ( p[8] & 0x0F ) << 4 ) | ( p[9]  & 0x0F );
+
+    eeprom_update_byte( (void*)VIA_EEPROM_MAGIC_ADDR+0, valid ? magic0 : 0xFF);
+    eeprom_update_byte( (void*)VIA_EEPROM_MAGIC_ADDR+1, valid ? magic1 : 0xFF);
+    eeprom_update_byte( (void*)VIA_EEPROM_MAGIC_ADDR+2, valid ? magic2 : 0xFF);
+}
+
+// Flag QMK and VIA/keyboard level EEPROM as invalid.
+// Used in bootmagic_lite() and VIA command handler.
+// Keyboard level code should not need to call this.
+void via_eeprom_reset(void)
+{
+    // Set the VIA specific EEPROM state as invalid.
+    via_eeprom_set_valid(false);
+    // Set the TMK/QMK EEPROM state as invalid.
+    eeconfig_disable();
+}
+
+// Override bootmagic_lite() so it can flag EEPROM as invalid
+// as well as jump to bootloader, thus performing a "factory reset"
+// of dynamic keymaps and optionally backlight/other settings.
+void bootmagic_lite(void)
+{
+    // The lite version of TMK's bootmagic based on Wilba.
+    // 100% less potential for accidentally making the
+    // keyboard do stupid things.
+
+    // We need multiple scans because debouncing can't be turned off.
+    matrix_scan();
+#if defined(DEBOUNCE) && DEBOUNCE > 0
+    wait_ms(DEBOUNCE * 2);
+#else
+    wait_ms(30);
+#endif
+    matrix_scan();
+
+    // If the Esc and space bar are held down on power up,
+    // reset the EEPROM valid state and jump to bootloader.
+    // Assumes Esc is at [0,0].
+    // This isn't very generalized, but we need something that doesn't
+    // rely on user's keymaps in firmware or EEPROM.
+    if (matrix_get_row(BOOTMAGIC_LITE_ROW) & (1 << BOOTMAGIC_LITE_COLUMN)) {
+        // This is the only difference from the default implementation.
+        via_eeprom_reset();
+        // Jump to bootloader.
+        bootloader_jump();
+    }
+}
+
+// Override this at the keyboard code level to check
+// VIA's EEPROM valid state and reset to defaults as needed.
+// Used by keyboards that store their own state in EEPROM,
+// for backlight, rotary encoders, etc.
+// The override should not set via_eeprom_set_valid(true) as
+// the caller also needs to check the valid state.
+__attribute__((weak)) void via_init_kb(void) {
+}
+
+// Called by QMK core to initialize dynamic keymaps etc.
+void via_init(void)
+{
+    // Let keyboard level test EEPROM valid state,
+    // but not set it valid, it is done here.
+    via_init_kb();
+
+    // If the EEPROM has the magic, the data is good.
+    // OK to load from EEPROM.
+    if (via_eeprom_is_valid()) {
+    } else      {
+        // This resets the layout options
+        via_set_layout_options(0);
+        // This resets the keymaps in EEPROM to what is in flash.
+        dynamic_keymap_reset();
+        // This resets the macros in EEPROM to nothing.
+        dynamic_keymap_macro_reset();
+        // Save the magic number last, in case saving was interrupted
+        via_eeprom_set_valid(true);
+    }
+}
+
+// This is generalized so the layout options EEPROM usage can be
+// variable, between 1 and 4 bytes.
+uint32_t via_get_layout_options(void)
+{
+    uint32_t value = 0;
+    // Start at the most significant byte
+    void * source = (void *)(VIA_EEPROM_LAYOUT_OPTIONS_ADDR);
+    for ( uint8_t i = 0; i < VIA_EEPROM_LAYOUT_OPTIONS_SIZE; i++ ) {
+        value = value << 8;
+        value |= eeprom_read_byte(source);
+        source++;
+    }
+    return value;
+}
+
+void via_set_layout_options(uint32_t value)
+{
+    // Start at the least significant byte
+    void * target = (void *)(VIA_EEPROM_LAYOUT_OPTIONS_ADDR+VIA_EEPROM_LAYOUT_OPTIONS_SIZE-1);
+    for ( uint8_t i = 0; i < VIA_EEPROM_LAYOUT_OPTIONS_SIZE; i++ ) {
+        eeprom_update_byte(target, value & 0xFF );
+        value = value >> 8;
+        target--;
+    }
+}
+
+// Called by QMK core to process VIA-specific keycodes.
+bool process_record_via(uint16_t keycode, keyrecord_t *record)
+{
+    // Handle macros
+    if (record->event.pressed) {
+        if ( keycode >= MACRO00 && keycode <= MACRO15 )
+        {
+            uint8_t id = keycode - MACRO00;
+            dynamic_keymap_macro_send(id);
+            return false;
+        }
+    }
+
+    // TODO: ideally this would be generalized and refactored into
+    // QMK core as advanced keycodes, until then, the simple case
+    // can be available here to keyboards using VIA
+    switch(keycode) {
+        case FN_MO13:
+            if (record->event.pressed) {
+                layer_on(1);
+                update_tri_layer(1, 2, 3);
+            } else {
+                layer_off(1);
+                update_tri_layer(1, 2, 3);
+            }
+            return false;
+            break;
+        case FN_MO23:
+            if (record->event.pressed) {
+                layer_on(2);
+                update_tri_layer(1, 2, 3);
+            } else {
+                layer_off(2);
+                update_tri_layer(1, 2, 3);
+            }
+            return false;
+            break;
+    }
+    return true;
+}
+
+// Keyboard level code can override this to handle custom messages from VIA.
+// See raw_hid_receive() implementation.
+// DO NOT call raw_hid_send() in the overide function.
+__attribute__((weak)) void raw_hid_receive_kb(uint8_t *data, uint8_t length) {
+    uint8_t *command_id = &(data[0]);
+    *command_id = id_unhandled;
+}
+
+// VIA handles received HID messages first, and will route to
+// raw_hid_receive_kb() for command IDs that are not handled here.
+// This gives the keyboard code level the ability to handle the command
+// specifically.
+//
+// raw_hid_send() is called at the end, with the same buffer, which was 
+// possibly modified with returned values.
+void raw_hid_receive( uint8_t *data, uint8_t length )
+{
+    uint8_t *command_id = &(data[0]);
+    uint8_t *command_data = &(data[1]);
+    switch ( *command_id )
+    {
+        case id_get_protocol_version:
+        {
+            command_data[0] = VIA_PROTOCOL_VERSION >> 8;
+            command_data[1] = VIA_PROTOCOL_VERSION & 0xFF;
+            break;
+        }
+        case id_get_keyboard_value:
+        {
+            switch ( command_data[0] )
+            {
+                case id_uptime:
+                {
+                    uint32_t value = timer_read32();
+                    command_data[1] = (value >> 24 ) & 0xFF;
+                    command_data[2] = (value >> 16 ) & 0xFF;
+                    command_data[3] = (value >> 8 ) & 0xFF;
+                    command_data[4] = value & 0xFF;
+                    break;
+                }
+                case id_layout_options:
+                {
+                    uint32_t value = via_get_layout_options();
+                    command_data[1] = (value >> 24 ) & 0xFF;
+                    command_data[2] = (value >> 16 ) & 0xFF;
+                    command_data[3] = (value >> 8 ) & 0xFF;
+                    command_data[4] = value & 0xFF;
+                    break;
+                }
+                case id_switch_matrix_state:
+                {
+#if ( (MATRIX_COLS/8+1)*MATRIX_ROWS <= 28 )
+                    uint8_t i = 1;
+                    for ( uint8_t row=0; row<MATRIX_ROWS; row++ ) {
+                        matrix_row_t value = matrix_get_row(row);
+#if (MATRIX_COLS > 24)
+                        command_data[i++] = (value >> 24 ) & 0xFF;
+#endif
+#if (MATRIX_COLS > 16)
+                        command_data[i++] = (value >> 16 ) & 0xFF;
+#endif
+#if (MATRIX_COLS > 8)
+                        command_data[i++] = (value >> 8 ) & 0xFF;
+#endif
+                        command_data[i++] = value & 0xFF;
+                    }
+#endif
+                    break;
+                }
+                default:
+                {
+                    raw_hid_receive_kb(data,length);
+                    break;
+                }
+            }
+            break;
+        }
+        case id_set_keyboard_value:
+        {
+            switch ( command_data[0] )
+            {
+                case id_layout_options:
+                {
+                    uint32_t value = ( (uint32_t)command_data[1] << 24 ) |
+                                     ( (uint32_t)command_data[2] << 16 ) |
+                                     ( (uint32_t)command_data[3] << 8 ) |
+                                       (uint32_t)command_data[4];
+                    via_set_layout_options(value);
+                    break;
+                }
+                default:
+                {
+                    raw_hid_receive_kb(data,length);
+                    break;
+                }
+            }
+            break;
+        }
+        case id_dynamic_keymap_get_keycode:
+        {
+            uint16_t keycode = dynamic_keymap_get_keycode( command_data[0], command_data[1], command_data[2] );
+            command_data[3] = keycode >> 8;
+            command_data[4] = keycode & 0xFF;
+            break;
+        }
+        case id_dynamic_keymap_set_keycode:
+        {
+            dynamic_keymap_set_keycode( command_data[0], command_data[1], command_data[2], ( command_data[3] << 8 ) | command_data[4] );
+            break;
+        }
+        case id_dynamic_keymap_reset:
+        {
+            dynamic_keymap_reset();
+            break;
+        }
+        case id_backlight_config_set_value:
+        case id_backlight_config_get_value:
+        case id_backlight_config_save:
+        {
+            raw_hid_receive_kb(data, length);
+            break;
+        }
+        case id_dynamic_keymap_macro_get_count:
+        {
+            command_data[0] = dynamic_keymap_macro_get_count();
+            break;
+        }
+        case id_dynamic_keymap_macro_get_buffer_size:
+        {
+            uint16_t size = dynamic_keymap_macro_get_buffer_size();
+            command_data[0] = size >> 8;
+            command_data[1] = size & 0xFF;
+            break;
+        }
+        case id_dynamic_keymap_macro_get_buffer:
+        {
+            uint16_t offset = ( command_data[0] << 8 ) | command_data[1];
+            uint16_t size = command_data[2]; // size <= 28
+            dynamic_keymap_macro_get_buffer( offset, size, &command_data[3] );
+            break;
+        }
+        case id_dynamic_keymap_macro_set_buffer:
+        {
+            uint16_t offset = ( command_data[0] << 8 ) | command_data[1];
+            uint16_t size = command_data[2]; // size <= 28
+            dynamic_keymap_macro_set_buffer( offset, size, &command_data[3] );
+            break;
+        }
+        case id_dynamic_keymap_macro_reset:
+        {
+            dynamic_keymap_macro_reset();
+            break;
+        }
+        case id_dynamic_keymap_get_layer_count:
+        {
+            command_data[0] = dynamic_keymap_get_layer_count();
+            break;
+        }
+        case id_dynamic_keymap_get_buffer:
+        {
+            uint16_t offset = ( command_data[0] << 8 ) | command_data[1];
+            uint16_t size = command_data[2]; // size <= 28
+            dynamic_keymap_get_buffer( offset, size, &command_data[3] );
+            break;
+        }
+        case id_dynamic_keymap_set_buffer:
+        {
+            uint16_t offset = ( command_data[0] << 8 ) | command_data[1];
+            uint16_t size = command_data[2]; // size <= 28
+            dynamic_keymap_set_buffer( offset, size, &command_data[3] );
+            break;
+        }
+        case id_eeprom_reset:
+        {
+            via_eeprom_reset();
+            break;
+        }
+        case id_bootloader_jump:
+        {
+            // Need to send data back before the jump
+            // Informs host that the command is handled
+            raw_hid_send( data, length );
+            // Give host time to read it
+            wait_ms(100);
+            bootloader_jump();
+            break;
+        }
+        default:
+        {
+            // The command ID is not known
+            // Return the unhandled state
+            *command_id = id_unhandled;
+            break;
+        }
+    }
+
+    // Return the same buffer, optionally with values changed
+    // (i.e. returning state to the host, or the unhandled state).
+    raw_hid_send( data, length );
+}
diff --git a/quantum/via.h b/quantum/via.h
new file mode 100644
index 000000000..f9a8017b2
--- /dev/null
+++ b/quantum/via.h
@@ -0,0 +1,151 @@
+/* Copyright 2019 Jason Williams (Wilba)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <tmk_core/common/eeconfig.h> // for EECONFIG_SIZE
+
+// Keyboard level code can change where VIA stores the magic.
+// The magic is the build date YYMMDD encoded as BCD in 3 bytes,
+// thus installing firmware built on a different date to the one
+// already installed can be detected and the EEPROM data is reset.
+// The only reason this is important is in case EEPROM usage changes
+// and the EEPROM was not explicitly reset by bootmagic lite.
+#ifndef VIA_EEPROM_MAGIC_ADDR
+#   define VIA_EEPROM_MAGIC_ADDR (EECONFIG_SIZE)
+#endif
+
+#define VIA_EEPROM_LAYOUT_OPTIONS_ADDR (VIA_EEPROM_MAGIC_ADDR+3)
+
+// Changing the layout options size after release will invalidate EEPROM,
+// but this is something that should be set correctly on initial implementation.
+// 1 byte is enough for most uses (i.e. 8 binary states, or 6 binary + 1 ternary/quaternary )
+#ifndef VIA_EEPROM_LAYOUT_OPTIONS_SIZE
+#   define VIA_EEPROM_LAYOUT_OPTIONS_SIZE 1
+#endif
+
+// The end of the EEPROM memory used by VIA
+// By default, dynamic keymaps will start at this if there is no
+// custom config
+#define VIA_EEPROM_CUSTOM_CONFIG_ADDR (VIA_EEPROM_LAYOUT_OPTIONS_ADDR+VIA_EEPROM_LAYOUT_OPTIONS_SIZE)
+
+#ifndef VIA_EEPROM_CUSTOM_CONFIG_SIZE
+#   define VIA_EEPROM_CUSTOM_CONFIG_SIZE 0
+#endif
+
+// This is changed only when the command IDs change,
+// so VIA Configurator can detect compatible firmware. 
+#define VIA_PROTOCOL_VERSION 0x0009
+
+enum via_command_id
+{
+    id_get_protocol_version = 0x01, // always 0x01
+    id_get_keyboard_value,
+    id_set_keyboard_value,
+    id_dynamic_keymap_get_keycode,
+    id_dynamic_keymap_set_keycode,
+    id_dynamic_keymap_reset,
+    id_backlight_config_set_value,
+    id_backlight_config_get_value,
+    id_backlight_config_save,
+    id_eeprom_reset,
+    id_bootloader_jump,
+    id_dynamic_keymap_macro_get_count,
+    id_dynamic_keymap_macro_get_buffer_size,
+    id_dynamic_keymap_macro_get_buffer,
+    id_dynamic_keymap_macro_set_buffer,
+    id_dynamic_keymap_macro_reset,
+    id_dynamic_keymap_get_layer_count,
+    id_dynamic_keymap_get_buffer,
+    id_dynamic_keymap_set_buffer,
+    id_unhandled = 0xFF,
+};
+
+enum via_keyboard_value_id
+{
+  id_uptime = 0x01,
+  id_layout_options,
+  id_switch_matrix_state
+};
+
+// Can't use SAFE_RANGE here, it might change if someone adds
+// new values to enum quantum_keycodes.
+// Need to keep checking 0x5F10 is still in the safe range.
+// TODO: merge this into quantum_keycodes
+// Backlight keycodes are in range 0x5F00-0x5F0F
+enum via_keycodes {
+    FN_MO13 = 0x5F10,
+    FN_MO23,
+    MACRO00,
+    MACRO01,
+    MACRO02,
+    MACRO03,
+    MACRO04,
+    MACRO05,
+    MACRO06,
+    MACRO07,
+    MACRO08,
+    MACRO09,
+    MACRO10,
+    MACRO11,
+    MACRO12,
+    MACRO13,
+    MACRO14,
+    MACRO15,
+};
+
+enum user_keycodes {
+  USER00 = 0x5F80,
+  USER01,
+  USER02,
+  USER03,
+  USER04,
+  USER05,
+  USER06,
+  USER07,
+  USER08,
+  USER09,
+  USER10,
+  USER11,
+  USER12,
+  USER13,
+  USER14,
+  USER15,
+};
+
+// Can be called in an overriding via_init_kb() to test if keyboard level code usage of
+// EEPROM is invalid and use/save defaults.
+bool via_eeprom_is_valid(void);
+
+// Sets VIA/keyboard level usage of EEPROM to valid/invalid
+// Keyboard level code (eg. via_init_kb()) should not call this
+void via_eeprom_set_valid(bool valid);
+
+// Flag QMK and VIA/keyboard level EEPROM as invalid.
+// Used in bootmagic_lite() and VIA command handler.
+// Keyboard level code should not need to call this.
+void via_eeprom_reset(void);
+
+// Called by QMK core to initialize dynamic keymaps etc.
+void via_init(void);
+
+// Used by VIA to store and retrieve the layout options.
+uint32_t via_get_layout_options(void);
+void via_set_layout_options(uint32_t value);
+
+// Called by QMK core to process VIA-specific keycodes.
+bool process_record_via(uint16_t keycode, keyrecord_t *record);
+