bastardkb/charybdis: add support for Charybdis (4x6 and 3x5) (#15333)

1 files changed, 343 insertions, 0 deletions

diff --git a/keyboards/bastardkb/charybdis/charybdis.c b/keyboards/bastardkb/charybdis/charybdis.c
new file mode 100644
index 0000000000..f94682ba41
--- /dev/null
+++ b/keyboards/bastardkb/charybdis/charybdis.c
@@ -0,0 +1,343 @@
+/*
+ * Copyright 2020 Christopher Courtney <drashna@live.com> (@drashna)
+ * Copyright 2021 Quentin LEBASTARD <qlebastard@gmail.com>
+ * Copyright 2021 Charly Delay <charly@codesink.dev> (@0xcharly)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Publicw 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/>.
+ */
+
+#include "charybdis.h"
+
+#ifdef CONSOLE_ENABLE
+#    include "print.h"
+#endif  // CONSOLE_ENABLE
+
+#ifdef POINTING_DEVICE_ENABLE
+#    ifndef CHARYBDIS_MINIMUM_DEFAULT_DPI
+#        define CHARYBDIS_MINIMUM_DEFAULT_DPI 400
+#    endif  // CHARYBDIS_MINIMUM_DEFAULT_DPI
+
+#    ifndef CHARYBDIS_DEFAULT_DPI_CONFIG_STEP
+#        define CHARYBDIS_DEFAULT_DPI_CONFIG_STEP 200
+#    endif  // CHARYBDIS_DEFAULT_DPI_CONFIG_STEP
+
+#    ifndef CHARYBDIS_MINIMUM_SNIPING_DPI
+#        define CHARYBDIS_MINIMUM_SNIPING_DPI 200
+#    endif  // CHARYBDIS_MINIMUM_SNIPER_MODE_DPI
+
+#    ifndef CHARYBDIS_SNIPING_DPI_CONFIG_STEP
+#        define CHARYBDIS_SNIPING_DPI_CONFIG_STEP 100
+#    endif  // CHARYBDIS_SNIPING_DPI_CONFIG_STEP
+
+// Fixed DPI for drag-scroll.
+#    ifndef CHARYBDIS_DRAGSCROLL_DPI
+#        define CHARYBDIS_DRAGSCROLL_DPI 100
+#    endif  // CHARYBDIS_DRAGSCROLL_DPI
+
+#    ifndef CHARYBDIS_DRAGSCROLL_BUFFER_SIZE
+#        define CHARYBDIS_DRAGSCROLL_BUFFER_SIZE 6
+#    endif  // !CHARYBDIS_DRAGSCROLL_BUFFER_SIZE
+
+#    ifndef CHARYBDIS_POINTER_ACCELERATION_FACTOR
+#        define CHARYBDIS_POINTER_ACCELERATION_FACTOR 24
+#    endif  // !CHARYBDIS_POINTER_ACCELERATION_FACTOR
+
+typedef union {
+    uint8_t raw;
+    struct {
+        uint8_t pointer_default_dpi : 4;  // 16 steps available.
+        uint8_t pointer_sniping_dpi : 2;  // 4 steps available.
+        bool    is_dragscroll_enabled : 1;
+        bool    is_sniping_enabled : 1;
+    } __attribute__((packed));
+} charybdis_config_t;
+
+static charybdis_config_t g_charybdis_config = {0};
+
+/**
+ * \brief Set the value of `config` from EEPROM.
+ *
+ * Note that `is_dragscroll_enabled` and `is_sniping_enabled` are purposefully
+ * ignored since we do not want to persist this state to memory.  In practice,
+ * this state is always written to maximize write-performances.  Therefore, we
+ * explicitly set them to `false` in this function.
+ */
+static void read_charybdis_config_from_eeprom(charybdis_config_t* config) {
+    config->raw                   = eeconfig_read_kb() & 0xff;
+    config->is_dragscroll_enabled = false;
+    config->is_sniping_enabled    = false;
+}
+
+/**
+ * \brief Save the value of `config` to eeprom.
+ *
+ * Note that all values are written verbatim, including whether drag-scroll
+ * and/or sniper mode are enabled.  `read_charybdis_config_from_eeprom(…)`
+ * resets these 2 values to `false` since it does not make sense to persist
+ * these across reboots of the board.
+ */
+static void write_charybdis_config_to_eeprom(charybdis_config_t* config) { eeconfig_update_kb(config->raw); }
+
+/** \brief Return the current value of the pointer's default DPI. */
+static uint16_t get_pointer_default_dpi(charybdis_config_t* config) { return (uint16_t)config->pointer_default_dpi * CHARYBDIS_DEFAULT_DPI_CONFIG_STEP + CHARYBDIS_MINIMUM_DEFAULT_DPI; }
+
+/** \brief Return the current value of the pointer's sniper-mode DPI. */
+static uint16_t get_pointer_sniping_dpi(charybdis_config_t* config) { return (uint16_t)config->pointer_sniping_dpi * CHARYBDIS_SNIPING_DPI_CONFIG_STEP + CHARYBDIS_MINIMUM_SNIPING_DPI; }
+
+/** \brief Set the appropriate DPI for the input config. */
+static void maybe_update_pointing_device_cpi(charybdis_config_t* config) {
+    if (config->is_dragscroll_enabled) {
+        pointing_device_set_cpi(CHARYBDIS_DRAGSCROLL_DPI);
+    } else if (config->is_sniping_enabled) {
+        pointing_device_set_cpi(get_pointer_sniping_dpi(config));
+    } else {
+        pointing_device_set_cpi(get_pointer_default_dpi(config));
+    }
+}
+
+/**
+ * \brief Update the pointer's default DPI to the next or previous step.
+ *
+ * Increases the DPI value if `forward` is `true`, decreases it otherwise.
+ * The increment/decrement steps are equal to CHARYBDIS_DEFAULT_DPI_CONFIG_STEP.
+ */
+static void step_pointer_default_dpi(charybdis_config_t* config, bool forward) {
+    config->pointer_default_dpi += forward ? 1 : -1;
+    maybe_update_pointing_device_cpi(config);
+}
+
+/**
+ * \brief Update the pointer's sniper-mode DPI to the next or previous step.
+ *
+ * Increases the DPI value if `forward` is `true`, decreases it otherwise.
+ * The increment/decrement steps are equal to CHARYBDIS_SNIPING_DPI_CONFIG_STEP.
+ */
+static void step_pointer_sniping_dpi(charybdis_config_t* config, bool forward) {
+    config->pointer_sniping_dpi += forward ? 1 : -1;
+    maybe_update_pointing_device_cpi(config);
+}
+
+uint16_t charybdis_get_pointer_default_dpi(void) { return get_pointer_default_dpi(&g_charybdis_config); }
+
+uint16_t charybdis_get_pointer_sniping_dpi(void) { return get_pointer_sniping_dpi(&g_charybdis_config); }
+
+void charybdis_cycle_pointer_default_dpi_noeeprom(bool forward) { step_pointer_default_dpi(&g_charybdis_config, forward); }
+
+void charybdis_cycle_pointer_default_dpi(bool forward) {
+    step_pointer_default_dpi(&g_charybdis_config, forward);
+    write_charybdis_config_to_eeprom(&g_charybdis_config);
+}
+
+void charybdis_cycle_pointer_sniping_dpi_noeeprom(bool forward) { step_pointer_sniping_dpi(&g_charybdis_config, forward); }
+
+void charybdis_cycle_pointer_sniping_dpi(bool forward) {
+    step_pointer_sniping_dpi(&g_charybdis_config, forward);
+    write_charybdis_config_to_eeprom(&g_charybdis_config);
+}
+
+bool charybdis_get_pointer_sniping_enabled(void) { return g_charybdis_config.is_sniping_enabled; }
+
+void charybdis_set_pointer_sniping_enabled(bool enable) {
+    g_charybdis_config.is_sniping_enabled = enable;
+    maybe_update_pointing_device_cpi(&g_charybdis_config);
+}
+
+bool charybdis_get_pointer_dragscroll_enabled(void) { return g_charybdis_config.is_dragscroll_enabled; }
+
+void charybdis_set_pointer_dragscroll_enabled(bool enable) {
+    g_charybdis_config.is_dragscroll_enabled = enable;
+    maybe_update_pointing_device_cpi(&g_charybdis_config);
+}
+
+void pointing_device_init_kb(void) { maybe_update_pointing_device_cpi(&g_charybdis_config); }
+
+#    ifndef CONSTRAIN_HID
+#        define CONSTRAIN_HID(value) ((value) < -127 ? -127 : ((value) > 127 ? 127 : (value)))
+#    endif  // !CONSTRAIN_HID
+
+/**
+ * \brief Add optional acceleration effect.
+ *
+ * If `CHARYBDIS_ENABLE_POINTER_ACCELERATION` is defined, add a simple and naive
+ * acceleration effect to the provided value.  Return the value unchanged
+ * otherwise.
+ */
+#    ifndef DISPLACEMENT_WITH_ACCELERATION
+#        ifdef CHARYBDIS_POINTER_ACCELERATION_ENABLE
+#            define DISPLACEMENT_WITH_ACCELERATION(d) (CONSTRAIN_HID(d > 0 ? d * d / CHARYBDIS_POINTER_ACCELERATION_FACTOR + d : -d * d / CHARYBDIS_POINTER_ACCELERATION_FACTOR + d))
+#        else  // !CHARYBDIS_POINTER_ACCELERATION_ENABLE
+#            define DISPLACEMENT_WITH_ACCELERATION(d) (d)
+#        endif  // CHARYBDIS_POINTER_ACCELERATION_ENABLE
+#    endif      // !DISPLACEMENT_WITH_ACCELERATION
+
+/**
+ * \brief Augment the pointing device behavior.
+ *
+ * Implement the Charybdis-specific features for pointing devices:
+ *   - Drag-scroll
+ *   - Sniping
+ *   - Acceleration
+ */
+static void pointing_device_task_charybdis(report_mouse_t* mouse_report) {
+    static int16_t scroll_buffer_x = 0;
+    static int16_t scroll_buffer_y = 0;
+    if (g_charybdis_config.is_dragscroll_enabled) {
+#    ifdef CHARYBDIS_DRAGSCROLL_REVERSE_X
+        scroll_buffer_x -= mouse_report->x;
+#    else
+        scroll_buffer_x += mouse_report->x;
+#    endif  // CHARYBDIS_DRAGSCROLL_REVERSE_X
+#    ifdef CHARYBDIS_DRAGSCROLL_REVERSE_Y
+        scroll_buffer_y -= mouse_report->y;
+#    else
+        scroll_buffer_y += mouse_report->y;
+#    endif  // CHARYBDIS_DRAGSCROLL_REVERSE_Y
+        mouse_report->x = 0;
+        mouse_report->y = 0;
+        if (abs(scroll_buffer_x) > CHARYBDIS_DRAGSCROLL_BUFFER_SIZE) {
+            mouse_report->h = scroll_buffer_x > 0 ? 1 : -1;
+            scroll_buffer_x = 0;
+        }
+        if (abs(scroll_buffer_y) > CHARYBDIS_DRAGSCROLL_BUFFER_SIZE) {
+            mouse_report->v = scroll_buffer_y > 0 ? 1 : -1;
+            scroll_buffer_y = 0;
+        }
+    } else if (!g_charybdis_config.is_sniping_enabled) {
+        mouse_report->x = DISPLACEMENT_WITH_ACCELERATION(mouse_report->x);
+        mouse_report->y = DISPLACEMENT_WITH_ACCELERATION(mouse_report->y);
+    }
+}
+
+report_mouse_t pointing_device_task_kb(report_mouse_t mouse_report) {
+    if (is_keyboard_master()) {
+        pointing_device_task_charybdis(&mouse_report);
+        mouse_report = pointing_device_task_user(mouse_report);
+    }
+    return mouse_report;
+}
+
+#    if defined(POINTING_DEVICE_ENABLE) && !defined(NO_CHARYBDIS_KEYCODES)
+/** \brief Whether SHIFT mod is enabled. */
+static bool has_shift_mod(void) {
+#        ifdef NO_ACTION_ONESHOT
+    return mod_config(get_mods()) & MOD_MASK_SHIFT;
+#        else
+    return mod_config(get_mods() | get_oneshot_mods()) & MOD_MASK_SHIFT;
+#        endif  // NO_ACTION_ONESHOT
+}
+#    endif  // POINTING_DEVICE_ENABLE && !NO_CHARYBDIS_KEYCODES
+
+/**
+ * \brief Outputs the Charybdis configuration to console.
+ *
+ * Prints the in-memory configuration structure to console, for debugging.
+ * Includes:
+ *   - raw value
+ *   - drag-scroll: on/off
+ *   - sniping: on/off
+ *   - default DPI: internal table index/actual DPI
+ *   - sniping DPI: internal table index/actual DPI
+ */
+static void debug_charybdis_config_to_console(charybdis_config_t* config) {
+#    ifdef CONSOLE_ENABLE
+    dprintf("(charybdis) process_record_kb: config = {\n"
+            "\traw = 0x%04X,\n"
+            "\t{\n"
+            "\t\tis_dragscroll_enabled=%b\n"
+            "\t\tis_sniping_enabled=%b\n"
+            "\t\tdefault_dpi=0x%02X (%ld)\n"
+            "\t\tsniping_dpi=0x%01X (%ld)\n"
+            "\t}\n"
+            "}\n",
+            config->raw, config->is_dragscroll_enabled, config->is_sniping_enabled, config->pointer_default_dpi, get_pointer_default_dpi(config), config->pointer_sniping_dpi, get_pointer_sniping_dpi(config));
+#    endif  // CONSOLE_ENABLE
+}
+
+bool process_record_kb(uint16_t keycode, keyrecord_t* record) {
+    if (!process_record_user(keycode, record)) {
+        debug_charybdis_config_to_console(&g_charybdis_config);
+        return false;
+    }
+#    ifdef POINTING_DEVICE_ENABLE
+#        ifndef NO_CHARYBDIS_KEYCODES
+    switch (keycode) {
+        case POINTER_DEFAULT_DPI_FORWARD:
+            if (record->event.pressed) {
+                // Step backward if shifted, forward otherwise.
+                charybdis_cycle_pointer_default_dpi(/* forward= */ !has_shift_mod());
+            }
+            break;
+        case POINTER_DEFAULT_DPI_REVERSE:
+            if (record->event.pressed) {
+                // Step forward if shifted, backward otherwise.
+                charybdis_cycle_pointer_default_dpi(/* forward= */ has_shift_mod());
+            }
+            break;
+        case POINTER_SNIPING_DPI_FORWARD:
+            if (record->event.pressed) {
+                // Step backward if shifted, forward otherwise.
+                charybdis_cycle_pointer_sniping_dpi(/* forward= */ !has_shift_mod());
+            }
+            break;
+        case POINTER_SNIPING_DPI_REVERSE:
+            if (record->event.pressed) {
+                // Step forward if shifted, backward otherwise.
+                charybdis_cycle_pointer_sniping_dpi(/* forward= */ has_shift_mod());
+            }
+            break;
+        case SNIPING_MODE:
+            charybdis_set_pointer_sniping_enabled(record->event.pressed);
+            break;
+        case SNIPING_MODE_TOGGLE:
+            if (record->event.pressed) {
+                charybdis_set_pointer_sniping_enabled(!charybdis_get_pointer_sniping_enabled());
+            }
+            break;
+        case DRAGSCROLL_MODE:
+            charybdis_set_pointer_dragscroll_enabled(record->event.pressed);
+            break;
+        case DRAGSCROLL_MODE_TOGGLE:
+            if (record->event.pressed) {
+                charybdis_set_pointer_dragscroll_enabled(!charybdis_get_pointer_dragscroll_enabled());
+            }
+            break;
+    }
+#        endif  // !NO_CHARYBDIS_KEYCODES
+#        ifndef MOUSEKEY_ENABLE
+    // Simulate mouse keys if full support is not enabled (reduces firmware size
+    // while maintaining support for mouse keys).
+    if (IS_MOUSEKEY_BUTTON(keycode)) {
+        report_mouse_t mouse_report = pointing_device_get_report();
+        mouse_report.buttons        = pointing_device_handle_buttons(mouse_report.buttons, record->event.pressed, keycode - KC_MS_BTN1);
+        pointing_device_set_report(mouse_report);
+        pointing_device_send();
+    }
+#        endif  // !MOUSEKEY_ENABLE
+#    endif      // POINTING_DEVICE_ENABLE
+    debug_charybdis_config_to_console(&g_charybdis_config);
+    return true;
+}
+
+void eeconfig_init_kb(void) {
+    g_charybdis_config.raw = 0;
+    write_charybdis_config_to_eeprom(&g_charybdis_config);
+    maybe_update_pointing_device_cpi(&g_charybdis_config);
+    eeconfig_init_user();
+}
+
+void matrix_init_kb(void) {
+    read_charybdis_config_from_eeprom(&g_charybdis_config);
+    matrix_init_user();
+}
+#endif  // POINTING_DEVICE_ENABLE