/* Copyright 2021 Nick Brassel (@tzarc) * * 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 . */ #include #include #include #include "hardware_id.h" #include "secure.h" #ifndef SECURE_ENABLE # define secure_get_status() SECURE_UNLOCKED # define secure_request_unlock() # define secure_lock() #endif #ifdef DYNAMIC_KEYMAP_ENABLE # define keymap_max_layer_count() DYNAMIC_KEYMAP_LAYER_COUNT #else # define keymap_max_layer_count() keymap_layer_count() #endif bool xap_respond_success(xap_token_t token) { xap_send(token, XAP_RESPONSE_FLAG_SUCCESS, NULL, 0); return true; } void xap_respond_failure(xap_token_t token, xap_response_flags_t response_flags) { xap_send(token, response_flags, NULL, 0); } bool xap_respond_data(xap_token_t token, const void *data, size_t length) { xap_send(token, XAP_RESPONSE_FLAG_SUCCESS, data, length); return true; } bool xap_respond_data_P(xap_token_t token, const void *data, size_t length) { uint8_t blob[length]; memcpy_P(blob, data, length); return xap_respond_data(token, blob, length); } bool xap_respond_u32(xap_token_t token, uint32_t value) { xap_send(token, XAP_RESPONSE_FLAG_SUCCESS, &value, sizeof(value)); return true; } bool xap_respond_get_config_blob_chunk(xap_token_t token, const void *data, size_t length) { if (length != sizeof(uint16_t)) { return false; } uint16_t offset; memcpy(&offset, data, sizeof(uint16_t)); xap_route_qmk_config_blob_chunk_t ret = {0}; bool get_config_blob_chunk(uint16_t offset, uint8_t * data, uint8_t data_len); if (!get_config_blob_chunk(offset, (uint8_t *)&ret, sizeof(ret))) { return false; } return xap_respond_data(token, &ret, sizeof(ret)); } bool xap_respond_secure_status(xap_token_t token, const void *data, size_t length) { uint8_t ret = secure_get_status(); return xap_respond_data(token, &ret, sizeof(ret)); } bool xap_respond_secure_unlock(xap_token_t token, const void *data, size_t length) { secure_request_unlock(); return xap_respond_success(token); } bool xap_respond_secure_lock(xap_token_t token, const void *data, size_t length) { secure_lock(); return xap_respond_success(token); } #ifdef BOOTLOADER_JUMP_SUPPORTED bool xap_respond_request_bootloader_jump(xap_token_t token, const void *data, size_t length) { uint8_t ret = secure_is_unlocked(); // TODO: post to deferred queue so this request can return? bool res = xap_respond_data(token, &ret, sizeof(ret)); reset_keyboard(); return res; } #endif #ifndef NO_RESET bool xap_respond_request_eeprom_reset(xap_token_t token, const void *data, size_t length) { uint8_t ret = secure_is_unlocked(); // TODO: post to deferred queue so this request can return? bool res = xap_respond_data(token, &ret, sizeof(ret)); eeconfig_disable(); soft_reset_keyboard(); return res; } #endif bool xap_respond_get_hardware_id(xap_token_t token, const void *data, size_t length) { hardware_id_t ret = get_hardware_id(); return xap_respond_data(token, &ret, sizeof(ret)); } bool xap_respond_keymap_get_layer_count(xap_token_t token, const void *data, size_t length) { uint8_t ret = keymap_max_layer_count(); return xap_respond_data(token, &ret, sizeof(ret)); } bool xap_respond_get_keymap_keycode(xap_token_t token, const void *data, size_t length) { if (length != sizeof(xap_route_keymap_get_keymap_keycode_arg_t)) { return false; } xap_route_keymap_get_keymap_keycode_arg_t *arg = (xap_route_keymap_get_keymap_keycode_arg_t *)data; if (arg->layer >= keymap_max_layer_count()) { return false; } uint16_t keycode = keycode_at_keymap_location(arg->layer, arg->row, arg->column); return xap_respond_data(token, &keycode, sizeof(keycode)); } #if ((defined(ENCODER_MAP_ENABLE))) bool xap_respond_get_encoder_keycode(xap_token_t token, const void *data, size_t length) { if (length != sizeof(xap_route_keymap_get_encoder_keycode_arg_t)) { return false; } xap_route_keymap_get_encoder_keycode_arg_t *arg = (xap_route_keymap_get_encoder_keycode_arg_t *)data; if (arg->layer >= keymap_max_layer_count()) { return false; } uint16_t keycode = keycode_at_encodermap_location(arg->layer, arg->encoder, arg->clockwise); return xap_respond_data(token, &keycode, sizeof(keycode)); } #endif #if ((defined(DYNAMIC_KEYMAP_ENABLE))) bool xap_respond_dynamic_keymap_set_keycode(xap_token_t token, const void *data, size_t length) { if (length != sizeof(xap_route_remapping_set_keymap_keycode_arg_t)) { return false; } xap_route_remapping_set_keymap_keycode_arg_t *arg = (xap_route_remapping_set_keymap_keycode_arg_t *)data; if (arg->layer >= keymap_max_layer_count()) { return false; } dynamic_keymap_set_keycode(arg->layer, arg->row, arg->column, arg->keycode); return xap_respond_success(token); } #endif #if ((defined(DYNAMIC_KEYMAP_ENABLE) && defined(ENCODER_MAP_ENABLE))) bool xap_respond_dynamic_encoder_set_keycode(xap_token_t token, const void *data, size_t length) { if (length != sizeof(xap_route_remapping_set_encoder_keycode_arg_t)) { return false; } xap_route_remapping_set_encoder_keycode_arg_t *arg = (xap_route_remapping_set_encoder_keycode_arg_t *)data; if (arg->layer >= keymap_max_layer_count()) { return false; } dynamic_keymap_set_encoder(arg->layer, arg->encoder, arg->clockwise, arg->keycode); return xap_respond_success(token); } #endif #define INVALID_EFFECT 0xFF #if ((defined(BACKLIGHT_ENABLE))) # include "backlight.h" extern backlight_config_t backlight_config; bool xap_respond_get_backlight_config(xap_token_t token, const void *data, size_t length) { xap_route_lighting_backlight_get_config_t ret; ret.enable = backlight_config.enable; ret.mode = backlight_config.breathing; ret.val = backlight_config.level; return xap_respond_data(token, &ret, sizeof(ret)); } bool xap_respond_set_backlight_config(xap_token_t token, const void *data, size_t length) { if (length != sizeof(xap_route_lighting_backlight_set_config_arg_t)) { return false; } xap_route_lighting_backlight_set_config_arg_t *arg = (xap_route_lighting_backlight_set_config_arg_t *)data; if (arg->enable) { backlight_level_noeeprom(arg->val); } else { backlight_level_noeeprom(0); } # ifdef BACKLIGHT_BREATHING if (arg->mode) { backlight_enable_breathing(); } else { backlight_disable_breathing(); } # endif return xap_respond_success(token); } bool xap_respond_save_backlight_config(xap_token_t token, const void *data, size_t length) { eeconfig_update_backlight_current(); return xap_respond_success(token); } #endif #if ((defined(RGBLIGHT_ENABLE))) # include "rgblight.h" extern rgblight_config_t rgblight_config; uint8_t rgblight2xap(uint8_t val); uint8_t xap2rgblight(uint8_t val); void rgblight_enabled_noeeprom(bool val) { val ? rgblight_enable_noeeprom() : rgblight_disable_noeeprom(); } bool xap_respond_get_rgblight_config(xap_token_t token, const void *data, size_t length) { xap_route_lighting_rgblight_get_config_t ret; ret.enable = rgblight_config.enable; ret.mode = rgblight2xap(rgblight_config.mode); ret.hue = rgblight_config.hue; ret.sat = rgblight_config.sat; ret.val = rgblight_config.val; ret.speed = rgblight_config.speed; return xap_respond_data(token, &ret, sizeof(ret)); } bool xap_respond_set_rgblight_config(xap_token_t token, const void *data, size_t length) { if (length != sizeof(xap_route_lighting_rgblight_set_config_arg_t)) { return false; } xap_route_lighting_rgblight_set_config_arg_t *arg = (xap_route_lighting_rgblight_set_config_arg_t *)data; uint8_t mode = xap2rgblight(arg->mode); if (mode == INVALID_EFFECT) { return false; } rgblight_enabled_noeeprom(arg->enable); rgblight_mode_noeeprom(mode); rgblight_sethsv_noeeprom(arg->hue, arg->sat, arg->val); rgblight_set_speed_noeeprom(arg->speed); return xap_respond_success(token); } bool xap_respond_save_rgblight_config(xap_token_t token, const void *data, size_t length) { eeconfig_update_rgblight_current(); return xap_respond_success(token); } #endif #if ((defined(RGB_MATRIX_ENABLE))) # include "rgb_matrix.h" extern rgb_config_t rgb_matrix_config; uint8_t rgb_matrix2xap(uint8_t val); uint8_t xap2rgb_matrix(uint8_t val); void rgb_matrix_enabled_noeeprom(bool val) { val ? rgb_matrix_enable_noeeprom() : rgb_matrix_disable_noeeprom(); } bool xap_respond_get_rgb_matrix_config(xap_token_t token, const void *data, size_t length) { xap_route_lighting_rgb_matrix_get_config_t ret; ret.enable = rgb_matrix_config.enable; ret.mode = rgb_matrix2xap(rgb_matrix_config.mode); ret.hue = rgb_matrix_config.hsv.h; ret.sat = rgb_matrix_config.hsv.s; ret.val = rgb_matrix_config.hsv.v; ret.speed = rgb_matrix_config.speed; ret.flags = rgb_matrix_config.flags; return xap_respond_data(token, &ret, sizeof(ret)); } bool xap_respond_set_rgb_matrix_config(xap_token_t token, const void *data, size_t length) { if (length != sizeof(xap_route_lighting_rgb_matrix_set_config_arg_t)) { return false; } xap_route_lighting_rgb_matrix_set_config_arg_t *arg = (xap_route_lighting_rgb_matrix_set_config_arg_t *)data; uint8_t mode = xap2rgb_matrix(arg->mode); if (mode == INVALID_EFFECT) { return false; } rgb_matrix_enabled_noeeprom(arg->enable); rgb_matrix_mode_noeeprom(mode); rgb_matrix_sethsv_noeeprom(arg->hue, arg->sat, arg->val); rgb_matrix_set_speed_noeeprom(arg->speed); rgb_matrix_set_flags_noeeprom(arg->flags); return xap_respond_success(token); } bool xap_respond_save_rgb_matrix_config(xap_token_t token, const void *data, size_t length) { eeconfig_update_rgb_matrix(); return xap_respond_success(token); } #endif