logo

qmk_firmware

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

via.c (28341B)

    

  1. /* Copyright 2019 Jason Williams (Wilba)
  2.  *
  3.  * This program is free software: you can redistribute it and/or modify
  4.  * it under the terms of the GNU General Public License as published by
  5.  * the Free Software Foundation, either version 2 of the License, or
  6.  * (at your option) any later version.
  7.  *
  8.  * This program is distributed in the hope that it will be useful,
  9.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.  * GNU General Public License for more details.
  12.  *
  13.  * You should have received a copy of the GNU General Public License
  14.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15.  */
  17. #ifndef RAW_ENABLE
  18. #    error "RAW_ENABLE is not enabled"
  19. #endif
  21. #ifndef DYNAMIC_KEYMAP_ENABLE
  22. #    error "DYNAMIC_KEYMAP_ENABLE is not enabled"
  23. #endif
  25. #include "via.h"
  27. #include "raw_hid.h"
  28. #include "dynamic_keymap.h"
  29. #include "eeconfig.h"
  30. #include "matrix.h"
  31. #include "timer.h"
  32. #include "wait.h"
  33. #include "version.h" // for QMK_BUILDDATE used in EEPROM magic
  34. #include "nvm_via.h"
  36. #if defined(AUDIO_ENABLE)
  37. #    include "audio.h"
  38. #endif
  40. #if defined(BACKLIGHT_ENABLE)
  41. #    include "backlight.h"
  42. #endif
  44. #if defined(RGBLIGHT_ENABLE)
  45. #    include "rgblight.h"
  46. #endif
  48. #if (defined(RGB_MATRIX_ENABLE) || defined(LED_MATRIX_ENABLE))
  49. #    include <lib/lib8tion/lib8tion.h>
  50. #endif
  52. #if defined(RGB_MATRIX_ENABLE)
  53. #    include "rgb_matrix.h"
  54. #endif
  56. #if defined(LED_MATRIX_ENABLE)
  57. #    include "led_matrix.h"
  58. #endif
  60. // Can be called in an overriding via_init_kb() to test if keyboard level code usage of
  61. // EEPROM is invalid and use/save defaults.
  62. bool via_eeprom_is_valid(void) {
  63.     char *  p      = QMK_BUILDDATE; // e.g. "2019-11-05-11:29:54"
  64.     uint8_t magic0 = ((p[2] & 0x0F) << 4) | (p[3] & 0x0F);
  65.     uint8_t magic1 = ((p[5] & 0x0F) << 4) | (p[6] & 0x0F);
  66.     uint8_t magic2 = ((p[8] & 0x0F) << 4) | (p[9] & 0x0F);
  68.     uint8_t ee_magic0;
  69.     uint8_t ee_magic1;
  70.     uint8_t ee_magic2;
  71.     nvm_via_read_magic(&ee_magic0, &ee_magic1, &ee_magic2);
  73.     return ee_magic0 == magic0 && ee_magic1 == magic1 && ee_magic2 == magic2;
  74. }
  76. // Sets VIA/keyboard level usage of EEPROM to valid/invalid
  77. // Keyboard level code (eg. via_init_kb()) should not call this
  78. void via_eeprom_set_valid(bool valid) {
  79.     if (valid) {
  80.         char *  p      = QMK_BUILDDATE; // e.g. "2019-11-05-11:29:54"
  81.         uint8_t magic0 = ((p[2] & 0x0F) << 4) | (p[3] & 0x0F);
  82.         uint8_t magic1 = ((p[5] & 0x0F) << 4) | (p[6] & 0x0F);
  83.         uint8_t magic2 = ((p[8] & 0x0F) << 4) | (p[9] & 0x0F);
  84.         nvm_via_update_magic(magic0, magic1, magic2);
  85.     } else {
  86.         nvm_via_update_magic(0xFF, 0xFF, 0xFF);
  87.     }
  88. }
  90. // Override this at the keyboard code level to check
  91. // VIA's EEPROM valid state and reset to defaults as needed.
  92. // Used by keyboards that store their own state in EEPROM,
  93. // for backlight, rotary encoders, etc.
  94. // The override should not set via_eeprom_set_valid(true) as
  95. // the caller also needs to check the valid state.
  96. __attribute__((weak)) void via_init_kb(void) {}
  98. // Called by QMK core to initialize dynamic keymaps etc.
  99. void via_init(void) {
  100.     // Let keyboard level test EEPROM valid state,
  101.     // but not set it valid, it is done here.
  102.     via_init_kb();
  103.     via_set_layout_options_kb(via_get_layout_options());
  105.     // If the EEPROM has the magic, the data is good.
  106.     // OK to load from EEPROM.
  107.     if (!via_eeprom_is_valid()) {
  108.         eeconfig_init_via();
  109.     }
  110. }
  112. void eeconfig_init_via(void) {
  113.     // Erase any NVM storage if necessary
  114.     nvm_via_erase();
  115.     // set the magic number to false, in case this gets interrupted
  116.     via_eeprom_set_valid(false);
  117.     // This resets the layout options
  118.     via_set_layout_options(VIA_EEPROM_LAYOUT_OPTIONS_DEFAULT);
  119.     // This resets the keymaps in EEPROM to what is in flash.
  120.     dynamic_keymap_reset();
  121.     // This resets the macros in EEPROM to nothing.
  122.     dynamic_keymap_macro_reset();
  123.     // Save the magic number last, in case saving was interrupted
  124.     via_eeprom_set_valid(true);
  125. }
  127. // This is generalized so the layout options EEPROM usage can be
  128. // variable, between 1 and 4 bytes.
  129. uint32_t via_get_layout_options(void) {
  130.     return nvm_via_read_layout_options();
  131. }
  133. __attribute__((weak)) void via_set_layout_options_kb(uint32_t value) {}
  135. void via_set_layout_options(uint32_t value) {
  136.     via_set_layout_options_kb(value);
  137.     nvm_via_update_layout_options(value);
  138. }
  140. #if VIA_EEPROM_CUSTOM_CONFIG_SIZE > 0
  141. uint32_t via_read_custom_config(void *buf, uint32_t offset, uint32_t length) {
  142.     return nvm_via_read_custom_config(buf, offset, length);
  143. }
  144. uint32_t via_update_custom_config(const void *buf, uint32_t offset, uint32_t length) {
  145.     return nvm_via_update_custom_config(buf, offset, length);
  146. }
  147. #endif
  149. #if defined(AUDIO_ENABLE)
  150. float via_device_indication_song[][2] = SONG(STARTUP_SOUND);
  151. #endif // AUDIO_ENABLE
  153. // Used by VIA to tell a device to flash LEDs (or do something else) when that
  154. // device becomes the active device being configured, on startup or switching
  155. // between devices. This function will be called six times, at 200ms interval,
  156. // with an incrementing value starting at zero. Since this function is called
  157. // an even number of times, it can call a toggle function and leave things in
  158. // the original state.
  159. __attribute__((weak)) void via_set_device_indication(uint8_t value) {
  160. #if defined(BACKLIGHT_ENABLE)
  161.     backlight_toggle();
  162. #endif // BACKLIGHT_ENABLE
  163. #if defined(RGBLIGHT_ENABLE)
  164.     rgblight_toggle_noeeprom();
  165. #endif // RGBLIGHT_ENABLE
  166. #if defined(RGB_MATRIX_ENABLE)
  167.     rgb_matrix_toggle_noeeprom();
  168. #endif // RGB_MATRIX_ENABLE
  169. #if defined(LED_MATRIX_ENABLE)
  170.     led_matrix_toggle_noeeprom();
  171. #endif // LED_MATRIX_ENABLE
  172. #if defined(AUDIO_ENABLE)
  173.     if (value == 0) {
  174.         wait_ms(10);
  175.         PLAY_SONG(via_device_indication_song);
  176.     }
  177. #endif // AUDIO_ENABLE
  178. }
  180. // Called by QMK core to process VIA-specific keycodes.
  181. bool process_record_via(uint16_t keycode, keyrecord_t *record) {
  182.     // Handle macros
  183.     if (record->event.pressed) {
  184.         if (keycode >= QK_MACRO && keycode <= QK_MACRO_MAX) {
  185.             uint8_t id = keycode - QK_MACRO;
  186.             dynamic_keymap_macro_send(id);
  187.             return false;
  188.         }
  189.     }
  191.     return true;
  192. }
  194. //
  195. // via_custom_value_command() has the default handling of custom values for Core modules.
  196. // If a keyboard is using the default Core modules, it does not need to be overridden,
  197. // the VIA keyboard definition will have matching channel/IDs.
  198. //
  199. // If a keyboard has some extra custom values, then via_custom_value_command_kb() can be
  200. // overridden to handle the extra custom values, leaving via_custom_value_command() to
  201. // handle the custom values for Core modules.
  202. //
  203. // If a keyboard has custom values and code that are overlapping with Core modules,
  204. // then via_custom_value_command() can be overridden and call the same functions
  205. // as the default implementation, or do whatever else is required.
  206. //
  207. // DO NOT call raw_hid_send() in the override function.
  208. //
  210. // This is the default handler for "extra" custom values, i.e. keyboard-specific custom values
  211. // that are not handled by via_custom_value_command().
  212. __attribute__((weak)) void via_custom_value_command_kb(uint8_t *data, uint8_t length) {
  213.     // data = [ command_id, channel_id, value_id, value_data ]
  214.     uint8_t *command_id = &(data[0]);
  215.     // Return the unhandled state
  216.     *command_id = id_unhandled;
  217. }
  219. // This is the default handler for custom value commands.
  220. // It routes commands with channel IDs to command handlers as such:
  221. //
  222. //      id_qmk_backlight_channel    ->  via_qmk_backlight_command()
  223. //      id_qmk_rgblight_channel     ->  via_qmk_rgblight_command()
  224. //      id_qmk_rgb_matrix_channel   ->  via_qmk_rgb_matrix_command()
  225. //      id_qmk_led_matrix_channel   ->  via_qmk_led_matrix_command()
  226. //      id_qmk_audio_channel        ->  via_qmk_audio_command()
  227. //
  228. __attribute__((weak)) void via_custom_value_command(uint8_t *data, uint8_t length) {
  229.     // data = [ command_id, channel_id, value_id, value_data ]
  230.     uint8_t *channel_id = &(data[1]);
  232. #if defined(BACKLIGHT_ENABLE)
  233.     if (*channel_id == id_qmk_backlight_channel) {
  234.         via_qmk_backlight_command(data, length);
  235.         return;
  236.     }
  237. #endif // BACKLIGHT_ENABLE
  239. #if defined(RGBLIGHT_ENABLE)
  240.     if (*channel_id == id_qmk_rgblight_channel) {
  241.         via_qmk_rgblight_command(data, length);
  242.         return;
  243.     }
  244. #endif // RGBLIGHT_ENABLE
  246. #if defined(RGB_MATRIX_ENABLE)
  247.     if (*channel_id == id_qmk_rgb_matrix_channel) {
  248.         via_qmk_rgb_matrix_command(data, length);
  249.         return;
  250.     }
  251. #endif // RGB_MATRIX_ENABLE
  253. #if defined(LED_MATRIX_ENABLE)
  254.     if (*channel_id == id_qmk_led_matrix_channel) {
  255.         via_qmk_led_matrix_command(data, length);
  256.         return;
  257.     }
  258. #endif // LED_MATRIX_ENABLE
  260. #if defined(AUDIO_ENABLE)
  261.     if (*channel_id == id_qmk_audio_channel) {
  262.         via_qmk_audio_command(data, length);
  263.         return;
  264.     }
  265. #endif // AUDIO_ENABLE
  267.     (void)channel_id; // force use of variable
  269.     // If we haven't returned before here, then let the keyboard level code
  270.     // handle this, if it is overridden, otherwise by default, this will
  271.     // return the unhandled state.
  272.     via_custom_value_command_kb(data, length);
  273. }
  275. // Keyboard level code can override this, but shouldn't need to.
  276. // Controlling custom features should be done by overriding
  277. // via_custom_value_command_kb() instead.
  278. __attribute__((weak)) bool via_command_kb(uint8_t *data, uint8_t length) {
  279.     return false;
  280. }
  282. void raw_hid_receive(uint8_t *data, uint8_t length) {
  283.     uint8_t *command_id   = &(data[0]);
  284.     uint8_t *command_data = &(data[1]);
  286.     // If via_command_kb() returns true, the command was fully
  287.     // handled, including calling raw_hid_send()
  288.     if (via_command_kb(data, length)) {
  289.         return;
  290.     }
  292.     switch (*command_id) {
  293.         case id_get_protocol_version: {
  294.             command_data[0] = VIA_PROTOCOL_VERSION >> 8;
  295.             command_data[1] = VIA_PROTOCOL_VERSION & 0xFF;
  296.             break;
  297.         }
  298.         case id_get_keyboard_value: {
  299.             switch (command_data[0]) {
  300.                 case id_uptime: {
  301.                     uint32_t value  = timer_read32();
  302.                     command_data[1] = (value >> 24) & 0xFF;
  303.                     command_data[2] = (value >> 16) & 0xFF;
  304.                     command_data[3] = (value >> 8) & 0xFF;
  305.                     command_data[4] = value & 0xFF;
  306.                     break;
  307.                 }
  308.                 case id_layout_options: {
  309.                     uint32_t value  = via_get_layout_options();
  310.                     command_data[1] = (value >> 24) & 0xFF;
  311.                     command_data[2] = (value >> 16) & 0xFF;
  312.                     command_data[3] = (value >> 8) & 0xFF;
  313.                     command_data[4] = value & 0xFF;
  314.                     break;
  315.                 }
  316.                 case id_switch_matrix_state: {
  317.                     uint8_t offset = command_data[1];
  318.                     uint8_t rows   = 28 / ((MATRIX_COLS + 7) / 8);
  319.                     uint8_t i      = 2;
  320.                     for (uint8_t row = 0; row < rows && row + offset < MATRIX_ROWS; row++) {
  321.                         matrix_row_t value = matrix_get_row(row + offset);
  322. #if (MATRIX_COLS > 24)
  323.                         command_data[i++] = (value >> 24) & 0xFF;
  324. #endif
  325. #if (MATRIX_COLS > 16)
  326.                         command_data[i++] = (value >> 16) & 0xFF;
  327. #endif
  328. #if (MATRIX_COLS > 8)
  329.                         command_data[i++] = (value >> 8) & 0xFF;
  330. #endif
  331.                         command_data[i++] = value & 0xFF;
  332.                     }
  333.                     break;
  334.                 }
  335.                 case id_firmware_version: {
  336.                     uint32_t value  = VIA_FIRMWARE_VERSION;
  337.                     command_data[1] = (value >> 24) & 0xFF;
  338.                     command_data[2] = (value >> 16) & 0xFF;
  339.                     command_data[3] = (value >> 8) & 0xFF;
  340.                     command_data[4] = value & 0xFF;
  341.                     break;
  342.                 }
  343.                 default: {
  344.                     // The value ID is not known
  345.                     // Return the unhandled state
  346.                     *command_id = id_unhandled;
  347.                     break;
  348.                 }
  349.             }
  350.             break;
  351.         }
  352.         case id_set_keyboard_value: {
  353.             switch (command_data[0]) {
  354.                 case id_layout_options: {
  355.                     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];
  356.                     via_set_layout_options(value);
  357.                     break;
  358.                 }
  359.                 case id_device_indication: {
  360.                     uint8_t value = command_data[1];
  361.                     via_set_device_indication(value);
  362.                     break;
  363.                 }
  364.                 default: {
  365.                     // The value ID is not known
  366.                     // Return the unhandled state
  367.                     *command_id = id_unhandled;
  368.                     break;
  369.                 }
  370.             }
  371.             break;
  372.         }
  373.         case id_dynamic_keymap_get_keycode: {
  374.             uint16_t keycode = dynamic_keymap_get_keycode(command_data[0], command_data[1], command_data[2]);
  375.             command_data[3]  = keycode >> 8;
  376.             command_data[4]  = keycode & 0xFF;
  377.             break;
  378.         }
  379.         case id_dynamic_keymap_set_keycode: {
  380.             dynamic_keymap_set_keycode(command_data[0], command_data[1], command_data[2], (command_data[3] << 8) | command_data[4]);
  381.             break;
  382.         }
  383.         case id_dynamic_keymap_reset: {
  384.             dynamic_keymap_reset();
  385.             break;
  386.         }
  387.         case id_custom_set_value:
  388.         case id_custom_get_value:
  389.         case id_custom_save: {
  390.             via_custom_value_command(data, length);
  391.             break;
  392.         }
  393. #ifdef VIA_EEPROM_ALLOW_RESET
  394.         case id_eeprom_reset: {
  395.             via_eeprom_set_valid(false);
  396.             eeconfig_init_via();
  397.             break;
  398.         }
  399. #endif
  400.         case id_dynamic_keymap_macro_get_count: {
  401.             command_data[0] = dynamic_keymap_macro_get_count();
  402.             break;
  403.         }
  404.         case id_dynamic_keymap_macro_get_buffer_size: {
  405.             uint16_t size   = dynamic_keymap_macro_get_buffer_size();
  406.             command_data[0] = size >> 8;
  407.             command_data[1] = size & 0xFF;
  408.             break;
  409.         }
  410.         case id_dynamic_keymap_macro_get_buffer: {
  411.             uint16_t offset = (command_data[0] << 8) | command_data[1];
  412.             uint16_t size   = command_data[2]; // size <= 28
  413.             dynamic_keymap_macro_get_buffer(offset, size, &command_data[3]);
  414.             break;
  415.         }
  416.         case id_dynamic_keymap_macro_set_buffer: {
  417.             uint16_t offset = (command_data[0] << 8) | command_data[1];
  418.             uint16_t size   = command_data[2]; // size <= 28
  419.             dynamic_keymap_macro_set_buffer(offset, size, &command_data[3]);
  420.             break;
  421.         }
  422.         case id_dynamic_keymap_macro_reset: {
  423.             dynamic_keymap_macro_reset();
  424.             break;
  425.         }
  426.         case id_dynamic_keymap_get_layer_count: {
  427.             command_data[0] = dynamic_keymap_get_layer_count();
  428.             break;
  429.         }
  430.         case id_dynamic_keymap_get_buffer: {
  431.             uint16_t offset = (command_data[0] << 8) | command_data[1];
  432.             uint16_t size   = command_data[2]; // size <= 28
  433.             dynamic_keymap_get_buffer(offset, size, &command_data[3]);
  434.             break;
  435.         }
  436.         case id_dynamic_keymap_set_buffer: {
  437.             uint16_t offset = (command_data[0] << 8) | command_data[1];
  438.             uint16_t size   = command_data[2]; // size <= 28
  439.             dynamic_keymap_set_buffer(offset, size, &command_data[3]);
  440.             break;
  441.         }
  442. #ifdef ENCODER_MAP_ENABLE
  443.         case id_dynamic_keymap_get_encoder: {
  444.             uint16_t keycode = dynamic_keymap_get_encoder(command_data[0], command_data[1], command_data[2] != 0);
  445.             command_data[3]  = keycode >> 8;
  446.             command_data[4]  = keycode & 0xFF;
  447.             break;
  448.         }
  449.         case id_dynamic_keymap_set_encoder: {
  450.             dynamic_keymap_set_encoder(command_data[0], command_data[1], command_data[2] != 0, (command_data[3] << 8) | command_data[4]);
  451.             break;
  452.         }
  453. #endif
  454.         default: {
  455.             // The command ID is not known
  456.             // Return the unhandled state
  457.             *command_id = id_unhandled;
  458.             break;
  459.         }
  460.     }
  462.     // Return the same buffer, optionally with values changed
  463.     // (i.e. returning state to the host, or the unhandled state).
  464.     raw_hid_send(data, length);
  465. }
  467. #if defined(BACKLIGHT_ENABLE)
  469. void via_qmk_backlight_command(uint8_t *data, uint8_t length) {
  470.     // data = [ command_id, channel_id, value_id, value_data ]
  471.     uint8_t *command_id        = &(data[0]);
  472.     uint8_t *value_id_and_data = &(data[2]);
  474.     switch (*command_id) {
  475.         case id_custom_set_value: {
  476.             via_qmk_backlight_set_value(value_id_and_data);
  477.             break;
  478.         }
  479.         case id_custom_get_value: {
  480.             via_qmk_backlight_get_value(value_id_and_data);
  481.             break;
  482.         }
  483.         case id_custom_save: {
  484.             via_qmk_backlight_save();
  485.             break;
  486.         }
  487.         default: {
  488.             *command_id = id_unhandled;
  489.             break;
  490.         }
  491.     }
  492. }
  494. #    if BACKLIGHT_LEVELS == 0
  495. #        error BACKLIGHT_LEVELS == 0
  496. #    endif
  498. void via_qmk_backlight_get_value(uint8_t *data) {
  499.     // data = [ value_id, value_data ]
  500.     uint8_t *value_id   = &(data[0]);
  501.     uint8_t *value_data = &(data[1]);
  502.     switch (*value_id) {
  503.         case id_qmk_backlight_brightness: {
  504.             // level / BACKLIGHT_LEVELS * 255
  505.             value_data[0] = ((uint16_t)get_backlight_level() * UINT8_MAX) / BACKLIGHT_LEVELS;
  506.             break;
  507.         }
  508.         case id_qmk_backlight_effect: {
  509. #    ifdef BACKLIGHT_BREATHING
  510.             value_data[0] = is_backlight_breathing() ? 1 : 0;
  511. #    else
  512.             value_data[0] = 0;
  513. #    endif
  514.             break;
  515.         }
  516.     }
  517. }
  519. void via_qmk_backlight_set_value(uint8_t *data) {
  520.     // data = [ value_id, value_data ]
  521.     uint8_t *value_id   = &(data[0]);
  522.     uint8_t *value_data = &(data[1]);
  523.     switch (*value_id) {
  524.         case id_qmk_backlight_brightness: {
  525.             // level / 255 * BACKLIGHT_LEVELS
  526.             backlight_level_noeeprom(((uint16_t)value_data[0] * BACKLIGHT_LEVELS) / UINT8_MAX);
  527.             break;
  528.         }
  529.         case id_qmk_backlight_effect: {
  530. #    ifdef BACKLIGHT_BREATHING
  531.             if (value_data[0] == 0) {
  532.                 backlight_disable_breathing();
  533.             } else {
  534.                 backlight_enable_breathing();
  535.             }
  536. #    endif
  537.             break;
  538.         }
  539.     }
  540. }
  542. void via_qmk_backlight_save(void) {
  543.     eeconfig_update_backlight_current();
  544. }
  546. #endif // BACKLIGHT_ENABLE
  548. #if defined(RGBLIGHT_ENABLE)
  549. #    ifndef RGBLIGHT_LIMIT_VAL
  550. #        define RGBLIGHT_LIMIT_VAL 255
  551. #    endif
  553. void via_qmk_rgblight_command(uint8_t *data, uint8_t length) {
  554.     // data = [ command_id, channel_id, value_id, value_data ]
  555.     uint8_t *command_id        = &(data[0]);
  556.     uint8_t *value_id_and_data = &(data[2]);
  558.     switch (*command_id) {
  559.         case id_custom_set_value: {
  560.             via_qmk_rgblight_set_value(value_id_and_data);
  561.             break;
  562.         }
  563.         case id_custom_get_value: {
  564.             via_qmk_rgblight_get_value(value_id_and_data);
  565.             break;
  566.         }
  567.         case id_custom_save: {
  568.             via_qmk_rgblight_save();
  569.             break;
  570.         }
  571.         default: {
  572.             *command_id = id_unhandled;
  573.             break;
  574.         }
  575.     }
  576. }
  578. void via_qmk_rgblight_get_value(uint8_t *data) {
  579.     // data = [ value_id, value_data ]
  580.     uint8_t *value_id   = &(data[0]);
  581.     uint8_t *value_data = &(data[1]);
  582.     switch (*value_id) {
  583.         case id_qmk_rgblight_brightness: {
  584.             value_data[0] = ((uint16_t)rgblight_get_val() * UINT8_MAX) / RGBLIGHT_LIMIT_VAL;
  585.             break;
  586.         }
  587.         case id_qmk_rgblight_effect: {
  588.             value_data[0] = rgblight_is_enabled() ? rgblight_get_mode() : 0;
  589.             break;
  590.         }
  591.         case id_qmk_rgblight_effect_speed: {
  592.             value_data[0] = rgblight_get_speed();
  593.             break;
  594.         }
  595.         case id_qmk_rgblight_color: {
  596.             value_data[0] = rgblight_get_hue();
  597.             value_data[1] = rgblight_get_sat();
  598.             break;
  599.         }
  600.     }
  601. }
  603. void via_qmk_rgblight_set_value(uint8_t *data) {
  604.     // data = [ value_id, value_data ]
  605.     uint8_t *value_id   = &(data[0]);
  606.     uint8_t *value_data = &(data[1]);
  607.     switch (*value_id) {
  608.         case id_qmk_rgblight_brightness: {
  609.             rgblight_sethsv_noeeprom(rgblight_get_hue(), rgblight_get_sat(), ((uint16_t)value_data[0] * RGBLIGHT_LIMIT_VAL) / UINT8_MAX);
  610.             break;
  611.         }
  612.         case id_qmk_rgblight_effect: {
  613.             if (value_data[0] == 0) {
  614.                 rgblight_disable_noeeprom();
  615.             } else {
  616.                 rgblight_enable_noeeprom();
  617.                 rgblight_mode_noeeprom(value_data[0]);
  618.             }
  619.             break;
  620.         }
  621.         case id_qmk_rgblight_effect_speed: {
  622.             rgblight_set_speed_noeeprom(value_data[0]);
  623.             break;
  624.         }
  625.         case id_qmk_rgblight_color: {
  626.             rgblight_sethsv_noeeprom(value_data[0], value_data[1], rgblight_get_val());
  627.             break;
  628.         }
  629.     }
  630. }
  632. void via_qmk_rgblight_save(void) {
  633.     eeconfig_update_rgblight_current();
  634. }
  636. #endif // QMK_RGBLIGHT_ENABLE
  638. #if defined(RGB_MATRIX_ENABLE)
  640. void via_qmk_rgb_matrix_command(uint8_t *data, uint8_t length) {
  641.     // data = [ command_id, channel_id, value_id, value_data ]
  642.     uint8_t *command_id        = &(data[0]);
  643.     uint8_t *value_id_and_data = &(data[2]);
  645.     switch (*command_id) {
  646.         case id_custom_set_value: {
  647.             via_qmk_rgb_matrix_set_value(value_id_and_data);
  648.             break;
  649.         }
  650.         case id_custom_get_value: {
  651.             via_qmk_rgb_matrix_get_value(value_id_and_data);
  652.             break;
  653.         }
  654.         case id_custom_save: {
  655.             via_qmk_rgb_matrix_save();
  656.             break;
  657.         }
  658.         default: {
  659.             *command_id = id_unhandled;
  660.             break;
  661.         }
  662.     }
  663. }
  665. void via_qmk_rgb_matrix_get_value(uint8_t *data) {
  666.     // data = [ value_id, value_data ]
  667.     uint8_t *value_id   = &(data[0]);
  668.     uint8_t *value_data = &(data[1]);
  670.     switch (*value_id) {
  671.         case id_qmk_rgb_matrix_brightness: {
  672.             value_data[0] = ((uint16_t)rgb_matrix_get_val() * UINT8_MAX) / RGB_MATRIX_MAXIMUM_BRIGHTNESS;
  673.             break;
  674.         }
  675.         case id_qmk_rgb_matrix_effect: {
  676.             value_data[0] = rgb_matrix_is_enabled() ? rgb_matrix_get_mode() : 0;
  677.             break;
  678.         }
  679.         case id_qmk_rgb_matrix_effect_speed: {
  680.             value_data[0] = rgb_matrix_get_speed();
  681.             break;
  682.         }
  683.         case id_qmk_rgb_matrix_color: {
  684.             value_data[0] = rgb_matrix_get_hue();
  685.             value_data[1] = rgb_matrix_get_sat();
  686.             break;
  687.         }
  688.     }
  689. }
  691. void via_qmk_rgb_matrix_set_value(uint8_t *data) {
  692.     // data = [ value_id, value_data ]
  693.     uint8_t *value_id   = &(data[0]);
  694.     uint8_t *value_data = &(data[1]);
  695.     switch (*value_id) {
  696.         case id_qmk_rgb_matrix_brightness: {
  697.             rgb_matrix_sethsv_noeeprom(rgb_matrix_get_hue(), rgb_matrix_get_sat(), scale8(value_data[0], RGB_MATRIX_MAXIMUM_BRIGHTNESS));
  698.             break;
  699.         }
  700.         case id_qmk_rgb_matrix_effect: {
  701.             if (value_data[0] == 0) {
  702.                 rgb_matrix_disable_noeeprom();
  703.             } else {
  704.                 rgb_matrix_enable_noeeprom();
  705.                 rgb_matrix_mode_noeeprom(value_data[0]);
  706.             }
  707.             break;
  708.         }
  709.         case id_qmk_rgb_matrix_effect_speed: {
  710.             rgb_matrix_set_speed_noeeprom(value_data[0]);
  711.             break;
  712.         }
  713.         case id_qmk_rgb_matrix_color: {
  714.             rgb_matrix_sethsv_noeeprom(value_data[0], value_data[1], rgb_matrix_get_val());
  715.             break;
  716.         }
  717.     }
  718. }
  720. void via_qmk_rgb_matrix_save(void) {
  721.     eeconfig_force_flush_rgb_matrix();
  722. }
  724. #endif // RGB_MATRIX_ENABLE
  726. #if defined(LED_MATRIX_ENABLE)
  728. void via_qmk_led_matrix_command(uint8_t *data, uint8_t length) {
  729.     // data = [ command_id, channel_id, value_id, value_data ]
  730.     uint8_t *command_id        = &(data[0]);
  731.     uint8_t *value_id_and_data = &(data[2]);
  733.     switch (*command_id) {
  734.         case id_custom_set_value: {
  735.             via_qmk_led_matrix_set_value(value_id_and_data);
  736.             break;
  737.         }
  738.         case id_custom_get_value: {
  739.             via_qmk_led_matrix_get_value(value_id_and_data);
  740.             break;
  741.         }
  742.         case id_custom_save: {
  743.             via_qmk_led_matrix_save();
  744.             break;
  745.         }
  746.         default: {
  747.             *command_id = id_unhandled;
  748.             break;
  749.         }
  750.     }
  751. }
  753. void via_qmk_led_matrix_get_value(uint8_t *data) {
  754.     // data = [ value_id, value_data ]
  755.     uint8_t *value_id   = &(data[0]);
  756.     uint8_t *value_data = &(data[1]);
  758.     switch (*value_id) {
  759.         case id_qmk_led_matrix_brightness: {
  760.             value_data[0] = ((uint16_t)led_matrix_get_val() * UINT8_MAX) / LED_MATRIX_MAXIMUM_BRIGHTNESS;
  761.             break;
  762.         }
  763.         case id_qmk_led_matrix_effect: {
  764.             value_data[0] = led_matrix_is_enabled() ? led_matrix_get_mode() : 0;
  765.             break;
  766.         }
  767.         case id_qmk_led_matrix_effect_speed: {
  768.             value_data[0] = led_matrix_get_speed();
  769.             break;
  770.         }
  771.     }
  772. }
  774. void via_qmk_led_matrix_set_value(uint8_t *data) {
  775.     // data = [ value_id, value_data ]
  776.     uint8_t *value_id   = &(data[0]);
  777.     uint8_t *value_data = &(data[1]);
  778.     switch (*value_id) {
  779.         case id_qmk_led_matrix_brightness: {
  780.             led_matrix_set_val_noeeprom(scale8(value_data[0], LED_MATRIX_MAXIMUM_BRIGHTNESS));
  781.             break;
  782.         }
  783.         case id_qmk_led_matrix_effect: {
  784.             if (value_data[0] == 0) {
  785.                 led_matrix_disable_noeeprom();
  786.             } else {
  787.                 led_matrix_enable_noeeprom();
  788.                 led_matrix_mode_noeeprom(value_data[0]);
  789.             }
  790.             break;
  791.         }
  792.         case id_qmk_led_matrix_effect_speed: {
  793.             led_matrix_set_speed_noeeprom(value_data[0]);
  794.             break;
  795.         }
  796.     }
  797. }
  799. void via_qmk_led_matrix_save(void) {
  800.     eeconfig_force_flush_led_matrix();
  801. }
  803. #endif // LED_MATRIX_ENABLE
  805. #if defined(AUDIO_ENABLE)
  807. extern audio_config_t audio_config;
  809. void via_qmk_audio_command(uint8_t *data, uint8_t length) {
  810.     // data = [ command_id, channel_id, value_id, value_data ]
  811.     uint8_t *command_id        = &(data[0]);
  812.     uint8_t *value_id_and_data = &(data[2]);
  814.     switch (*command_id) {
  815.         case id_custom_set_value: {
  816.             via_qmk_audio_set_value(value_id_and_data);
  817.             break;
  818.         }
  819.         case id_custom_get_value: {
  820.             via_qmk_audio_get_value(value_id_and_data);
  821.             break;
  822.         }
  823.         case id_custom_save: {
  824.             via_qmk_audio_save();
  825.             break;
  826.         }
  827.         default: {
  828.             *command_id = id_unhandled;
  829.             break;
  830.         }
  831.     }
  832. }
  834. void via_qmk_audio_get_value(uint8_t *data) {
  835.     // data = [ value_id, value_data ]
  836.     uint8_t *value_id   = &(data[0]);
  837.     uint8_t *value_data = &(data[1]);
  838.     switch (*value_id) {
  839.         case id_qmk_audio_enable: {
  840.             value_data[0] = audio_config.enable ? 1 : 0;
  841.             break;
  842.         }
  843.         case id_qmk_audio_clicky_enable: {
  844.             value_data[0] = audio_config.clicky_enable ? 1 : 0;
  845.             break;
  846.         }
  847.     }
  848. }
  850. void via_qmk_audio_set_value(uint8_t *data) {
  851.     // data = [ value_id, value_data ]
  852.     uint8_t *value_id   = &(data[0]);
  853.     uint8_t *value_data = &(data[1]);
  854.     switch (*value_id) {
  855.         case id_qmk_audio_enable: {
  856.             audio_config.enable = value_data[0] ? 1 : 0;
  857.             break;
  858.         }
  859.         case id_qmk_audio_clicky_enable: {
  860.             audio_config.clicky_enable = value_data[0] ? 1 : 0;
  861.             break;
  862.         }
  863.     }
  864. }
  866. void via_qmk_audio_save(void) {
  867.     eeconfig_update_audio(&audio_config);
  868. }
  870. #endif // QMK_AUDIO_ENABLE