logo

qmk_firmware

custom branch of QMK firmware git clone https://anongit.hacktivis.me/git/qmk_firmware.git

nvm_dynamic_keymap.c (8588B)

    

  1. // Copyright 2024 Nick Brassel (@tzarc)
  2. // SPDX-License-Identifier: GPL-2.0-or-later
  4. #include "compiler_support.h"
  5. #include "keycodes.h"
  6. #include "eeprom.h"
  7. #include "dynamic_keymap.h"
  8. #include "nvm_dynamic_keymap.h"
  9. #include "nvm_eeprom_eeconfig_internal.h"
  10. #include "nvm_eeprom_via_internal.h"
  12. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  14. #ifdef ENCODER_ENABLE
  15. #    include "encoder.h"
  16. #endif
  18. #ifdef VIA_ENABLE
  19. #    include "via.h"
  20. #    define DYNAMIC_KEYMAP_EEPROM_START (VIA_EEPROM_CONFIG_END)
  21. #else
  22. #    define DYNAMIC_KEYMAP_EEPROM_START (EECONFIG_SIZE)
  23. #endif
  25. #ifndef DYNAMIC_KEYMAP_EEPROM_MAX_ADDR
  26. #    define DYNAMIC_KEYMAP_EEPROM_MAX_ADDR (TOTAL_EEPROM_BYTE_COUNT - 1)
  27. #endif
  29. STATIC_ASSERT(DYNAMIC_KEYMAP_EEPROM_MAX_ADDR <= (TOTAL_EEPROM_BYTE_COUNT - 1), "DYNAMIC_KEYMAP_EEPROM_MAX_ADDR is configured to use more space than what is available for the selected EEPROM driver");
  31. // Due to usage of uint16_t check for max 65535
  32. STATIC_ASSERT(DYNAMIC_KEYMAP_EEPROM_MAX_ADDR <= 65535, "DYNAMIC_KEYMAP_EEPROM_MAX_ADDR must be less than 65536");
  34. // If DYNAMIC_KEYMAP_EEPROM_ADDR not explicitly defined in config.h,
  35. #ifndef DYNAMIC_KEYMAP_EEPROM_ADDR
  36. #    define DYNAMIC_KEYMAP_EEPROM_ADDR DYNAMIC_KEYMAP_EEPROM_START
  37. #endif
  39. // Dynamic encoders starts after dynamic keymaps
  40. #ifndef DYNAMIC_KEYMAP_ENCODER_EEPROM_ADDR
  41. #    define DYNAMIC_KEYMAP_ENCODER_EEPROM_ADDR (DYNAMIC_KEYMAP_EEPROM_ADDR + (DYNAMIC_KEYMAP_LAYER_COUNT * MATRIX_ROWS * MATRIX_COLS * 2))
  42. #endif
  44. // Dynamic macro starts after dynamic encoders, but only when using ENCODER_MAP
  45. #ifdef ENCODER_MAP_ENABLE
  46. #    ifndef DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR
  47. #        define DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR (DYNAMIC_KEYMAP_ENCODER_EEPROM_ADDR + (DYNAMIC_KEYMAP_LAYER_COUNT * NUM_ENCODERS * 2 * 2))
  48. #    endif // DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR
  49. #else      // ENCODER_MAP_ENABLE
  50. #    ifndef DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR
  51. #        define DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR (DYNAMIC_KEYMAP_ENCODER_EEPROM_ADDR)
  52. #    endif // DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR
  53. #endif     // ENCODER_MAP_ENABLE
  55. // Sanity check that dynamic keymaps fit in available EEPROM
  56. // If there's not 100 bytes available for macros, then something is wrong.
  57. // The keyboard should override DYNAMIC_KEYMAP_LAYER_COUNT to reduce it,
  58. // or DYNAMIC_KEYMAP_EEPROM_MAX_ADDR to increase it, *only if* the microcontroller has
  59. // more than the default.
  60. STATIC_ASSERT((int64_t)(DYNAMIC_KEYMAP_EEPROM_MAX_ADDR) - (int64_t)(DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR) >= 100, "Dynamic keymaps are configured to use more EEPROM than is available.");
  62. #ifndef TOTAL_EEPROM_BYTE_COUNT
  63. #    error Unknown total EEPROM size. Cannot derive maximum for dynamic keymaps.
  64. #endif
  65. // Dynamic macros are stored after the keymaps and use what is available
  66. // up to and including DYNAMIC_KEYMAP_EEPROM_MAX_ADDR.
  67. #ifndef DYNAMIC_KEYMAP_MACRO_EEPROM_SIZE
  68. #    define DYNAMIC_KEYMAP_MACRO_EEPROM_SIZE (DYNAMIC_KEYMAP_EEPROM_MAX_ADDR - DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR + 1)
  69. #endif
  71. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  73. void nvm_dynamic_keymap_erase(void) {
  74.     // No-op, nvm_eeconfig_erase() will have already erased EEPROM if necessary.
  75. }
  77. void nvm_dynamic_keymap_macro_erase(void) {
  78.     // No-op, nvm_eeconfig_erase() will have already erased EEPROM if necessary.
  79. }
  81. static inline void *dynamic_keymap_key_to_eeprom_address(uint8_t layer, uint8_t row, uint8_t column) {
  82.     return ((void *)DYNAMIC_KEYMAP_EEPROM_ADDR) + (layer * MATRIX_ROWS * MATRIX_COLS * 2) + (row * MATRIX_COLS * 2) + (column * 2);
  83. }
  85. uint16_t nvm_dynamic_keymap_read_keycode(uint8_t layer, uint8_t row, uint8_t column) {
  86.     if (layer >= DYNAMIC_KEYMAP_LAYER_COUNT || row >= MATRIX_ROWS || column >= MATRIX_COLS) return KC_NO;
  87.     void *address = dynamic_keymap_key_to_eeprom_address(layer, row, column);
  88.     // Big endian, so we can read/write EEPROM directly from host if we want
  89.     uint16_t keycode = eeprom_read_byte(address) << 8;
  90.     keycode |= eeprom_read_byte(address + 1);
  91.     return keycode;
  92. }
  94. void nvm_dynamic_keymap_update_keycode(uint8_t layer, uint8_t row, uint8_t column, uint16_t keycode) {
  95.     if (layer >= DYNAMIC_KEYMAP_LAYER_COUNT || row >= MATRIX_ROWS || column >= MATRIX_COLS) return;
  96.     void *address = dynamic_keymap_key_to_eeprom_address(layer, row, column);
  97.     // Big endian, so we can read/write EEPROM directly from host if we want
  98.     eeprom_update_byte(address, (uint8_t)(keycode >> 8));
  99.     eeprom_update_byte(address + 1, (uint8_t)(keycode & 0xFF));
  100. }
  102. #ifdef ENCODER_MAP_ENABLE
  103. static void *dynamic_keymap_encoder_to_eeprom_address(uint8_t layer, uint8_t encoder_id) {
  104.     return ((void *)DYNAMIC_KEYMAP_ENCODER_EEPROM_ADDR) + (layer * NUM_ENCODERS * 2 * 2) + (encoder_id * 2 * 2);
  105. }
  107. uint16_t nvm_dynamic_keymap_read_encoder(uint8_t layer, uint8_t encoder_id, bool clockwise) {
  108.     if (layer >= DYNAMIC_KEYMAP_LAYER_COUNT || encoder_id >= NUM_ENCODERS) return KC_NO;
  109.     void *address = dynamic_keymap_encoder_to_eeprom_address(layer, encoder_id);
  110.     // Big endian, so we can read/write EEPROM directly from host if we want
  111.     uint16_t keycode = ((uint16_t)eeprom_read_byte(address + (clockwise ? 0 : 2))) << 8;
  112.     keycode |= eeprom_read_byte(address + (clockwise ? 0 : 2) + 1);
  113.     return keycode;
  114. }
  116. void nvm_dynamic_keymap_update_encoder(uint8_t layer, uint8_t encoder_id, bool clockwise, uint16_t keycode) {
  117.     if (layer >= DYNAMIC_KEYMAP_LAYER_COUNT || encoder_id >= NUM_ENCODERS) return;
  118.     void *address = dynamic_keymap_encoder_to_eeprom_address(layer, encoder_id);
  119.     // Big endian, so we can read/write EEPROM directly from host if we want
  120.     eeprom_update_byte(address + (clockwise ? 0 : 2), (uint8_t)(keycode >> 8));
  121.     eeprom_update_byte(address + (clockwise ? 0 : 2) + 1, (uint8_t)(keycode & 0xFF));
  122. }
  123. #endif // ENCODER_MAP_ENABLE
  125. void nvm_dynamic_keymap_read_buffer(uint32_t offset, uint32_t size, uint8_t *data) {
  126.     uint32_t dynamic_keymap_eeprom_size = DYNAMIC_KEYMAP_LAYER_COUNT * MATRIX_ROWS * MATRIX_COLS * 2;
  127.     void *   source                     = (void *)(uintptr_t)(DYNAMIC_KEYMAP_EEPROM_ADDR + offset);
  128.     uint8_t *target                     = data;
  129.     for (uint32_t i = 0; i < size; i++) {
  130.         if (offset + i < dynamic_keymap_eeprom_size) {
  131.             *target = eeprom_read_byte(source);
  132.         } else {
  133.             *target = 0x00;
  134.         }
  135.         source++;
  136.         target++;
  137.     }
  138. }
  140. void nvm_dynamic_keymap_update_buffer(uint32_t offset, uint32_t size, uint8_t *data) {
  141.     uint32_t dynamic_keymap_eeprom_size = DYNAMIC_KEYMAP_LAYER_COUNT * MATRIX_ROWS * MATRIX_COLS * 2;
  142.     void *   target                     = (void *)(uintptr_t)(DYNAMIC_KEYMAP_EEPROM_ADDR + offset);
  143.     uint8_t *source                     = data;
  144.     for (uint32_t i = 0; i < size; i++) {
  145.         if (offset + i < dynamic_keymap_eeprom_size) {
  146.             eeprom_update_byte(target, *source);
  147.         }
  148.         source++;
  149.         target++;
  150.     }
  151. }
  153. uint32_t nvm_dynamic_keymap_macro_size(void) {
  154.     return DYNAMIC_KEYMAP_MACRO_EEPROM_SIZE;
  155. }
  157. void nvm_dynamic_keymap_macro_read_buffer(uint32_t offset, uint32_t size, uint8_t *data) {
  158.     void *   source = (void *)(uintptr_t)(DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR + offset);
  159.     uint8_t *target = data;
  160.     for (uint16_t i = 0; i < size; i++) {
  161.         if (offset + i < DYNAMIC_KEYMAP_MACRO_EEPROM_SIZE) {
  162.             *target = eeprom_read_byte(source);
  163.         } else {
  164.             *target = 0x00;
  165.         }
  166.         source++;
  167.         target++;
  168.     }
  169. }
  171. void nvm_dynamic_keymap_macro_update_buffer(uint32_t offset, uint32_t size, uint8_t *data) {
  172.     void *   target = (void *)(uintptr_t)(DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR + offset);
  173.     uint8_t *source = data;
  174.     for (uint16_t i = 0; i < size; i++) {
  175.         if (offset + i < DYNAMIC_KEYMAP_MACRO_EEPROM_SIZE) {
  176.             eeprom_update_byte(target, *source);
  177.         }
  178.         source++;
  179.         target++;
  180.     }
  181. }
  183. void nvm_dynamic_keymap_macro_reset(void) {
  184.     void *  start     = (void *)(uintptr_t)(DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR);
  185.     void *  end       = (void *)(uintptr_t)(DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR + DYNAMIC_KEYMAP_MACRO_EEPROM_SIZE);
  186.     long    remaining = end - start;
  187.     uint8_t dummy[16] = {0};
  188.     for (int i = 0; i < DYNAMIC_KEYMAP_MACRO_EEPROM_SIZE; i += sizeof(dummy)) {
  189.         int this_loop = remaining < sizeof(dummy) ? remaining : sizeof(dummy);
  190.         eeprom_update_block(dummy, start, this_loop);
  191.         start += this_loop;
  192.         remaining -= this_loop;
  193.     }
  194. }