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