Added wireless support; Added Lemokey L3; Added Keychron V1 Max

keyboards/keychron/bluetooth/bat_level_animation.c

@@ -0,0 +1,142 @@
+
+#include "quantum.h"
+#include "bluetooth.h"
+#include "indicator.h"
+#include "lpm.h"
+#if defined(PROTOCOL_CHIBIOS)
+#    include <usb_main.h>
+#elif if defined(PROTOCOL_LUFA)
+#    include "lufa.h"
+#endif
+#include "eeprom.h"
+
+#ifndef BAT_LEVEL_GROWING_INTERVAL
+#    define BAT_LEVEL_GROWING_INTERVAL 150
+#endif
+
+#ifndef BAT_LEVEL_ON_INTERVAL
+#    define BAT_LEVEL_ON_INTERVAL 3000
+#endif
+
+#ifdef LED_MATRIX_ENABLE
+#    define LED_DRIVER_IS_ENABLED led_matrix_is_enabled
+#endif
+
+#ifdef RGB_MATRIX_ENABLE
+#    define LED_DRIVER_IS_ENABLED rgb_matrix_is_enabled
+#endif
+
+enum {
+    BAT_LVL_ANI_NONE,
+    BAT_LVL_ANI_GROWING,
+    BAT_LVL_ANI_BLINK_OFF,
+    BAT_LVL_ANI_BLINK_ON,
+};
+
+static uint8_t  animation_state = 0;
+static uint32_t bat_lvl_ani_timer_buffer = 0;
+static uint8_t  bat_percentage;
+static uint8_t  cur_percentage;
+static uint32_t time_interval;
+#ifdef RGB_MATRIX_ENABLE
+static uint8_t r, g, b;
+#endif
+
+extern indicator_config_t indicator_config;
+extern backlight_state_t  original_backlight_state;
+
+void bat_level_animiation_start(uint8_t percentage) {
+    /* Turn on backlight mode for indicator */
+    indicator_enable();
+
+    animation_state          = BAT_LVL_ANI_GROWING;
+    bat_percentage           = percentage;
+    bat_lvl_ani_timer_buffer = sync_timer_read32();
+    cur_percentage           = 0;
+    time_interval            = BAT_LEVEL_GROWING_INTERVAL;
+#ifdef RGB_MATRIX_ENABLE
+    r = g = b = 255;
+#endif
+}
+
+void bat_level_animiation_stop(void) {
+    animation_state = BAT_LVL_ANI_NONE;
+}
+
+bool bat_level_animiation_actived(void) {
+    return animation_state;
+}
+
+void bat_level_animiation_indicate(void) {
+#ifdef LED_MATRIX_ENABLE
+    uint8_t  bat_lvl_led_list[10] = BAT_LEVEL_LED_LIST;
+
+    for (uint8_t i = 0; i <= LED_MATRIX_LED_COUNT; i++) {
+        led_matrix_set_value(i, 0);
+    }
+
+    if (animation_state == BAT_LVL_ANI_GROWING || animation_state == BAT_LVL_ANI_BLINK_ON)
+        for (uint8_t i = 0; i < cur_percentage / 10; i++)
+            led_matrix_set_value(bat_lvl_led_list[i], 255);
+#endif
+
+#ifdef RGB_MATRIX_ENABLE
+    uint8_t  bat_lvl_led_list[10] = BAT_LEVEL_LED_LIST;
+
+    for (uint8_t i = 0; i <= RGB_MATRIX_LED_COUNT; i++) {
+        rgb_matrix_set_color(i, 0, 0, 0);
+    }
+
+    if (animation_state == BAT_LVL_ANI_GROWING || animation_state == BAT_LVL_ANI_BLINK_ON) {
+        for (uint8_t i = 0; i < cur_percentage / 10; i++) {
+            rgb_matrix_set_color(bat_lvl_led_list[i], r, g, b);
+        }
+    }
+#endif
+}
+
+void bat_level_animiation_update(void) {
+    switch (animation_state) {
+        case BAT_LVL_ANI_GROWING:
+            if (cur_percentage < bat_percentage)
+                cur_percentage += 10;
+            else {
+                if (cur_percentage == 0) cur_percentage = 10;
+                animation_state = BAT_LVL_ANI_BLINK_OFF;
+            }
+            break;
+
+        case BAT_LVL_ANI_BLINK_OFF:
+#ifdef RGB_MATRIX_ENABLE
+            if (bat_percentage < 30) {
+                r = 255;
+                b = g = 0;
+            } else {
+                r = b = 0;
+                g     = 255;
+            }
+#endif
+            time_interval   = BAT_LEVEL_ON_INTERVAL;
+            animation_state = BAT_LVL_ANI_BLINK_ON;
+            break;
+
+        case BAT_LVL_ANI_BLINK_ON:
+            animation_state = BAT_LVL_ANI_NONE;
+            indicator_eeconfig_reload();
+            if (indicator_config.value == 0 && !LED_DRIVER_IS_ENABLED()) {
+                indicator_disable();
+            }
+            break;
+
+        default:
+            break;
+    }
+
+    bat_lvl_ani_timer_buffer = sync_timer_read32();
+}
+
+void bat_level_animiation_task(void) {
+    if (animation_state && sync_timer_elapsed32(bat_lvl_ani_timer_buffer) > time_interval) {
+        bat_level_animiation_update();
+    }
+}

keyboards/keychron/bluetooth/bat_level_animation.h

@@ -1,4 +1,4 @@
-/* Copyright 2022 @ Keychron(https://www.keychron.com)
+/* Copyright 2022 @ lokher (https://www.keychron.com)
  *
  * 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
@@ -16,10 +16,8 @@
 
 #pragma once
 
-#define SNLED27351_CURRENT_TUNE { 0xFF, 0xFF, 0x70, 0xFF, 0xFF, 0x70, 0xFF, 0xFF, 0x70, 0xFF, 0xFF, 0x70 }
-
-/* turn off effects when suspended */
-#define RGB_DISABLE_WHEN_USB_SUSPENDED
-
-#define RGB_MATRIX_KEYPRESSES
-#define RGB_MATRIX_FRAMEBUFFER_EFFECTS
+void bat_level_animiation_start(uint8_t percentage);
+void bat_level_animiation_stop(void);
+bool bat_level_animiation_actived(void);
+void bat_level_animiation_indicate(void);
+void bat_level_animiation_task(void);

keyboards/keychron/bluetooth/battery.c

@@ -0,0 +1,140 @@
+/* Copyright 2022 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "quantum.h"
+#include "bluetooth.h"
+#include "battery.h"
+#include "transport.h"
+#include "ckbt51.h"
+#include "lpm.h"
+#include "indicator.h"
+#include "rtc_timer.h"
+
+#define BATTERY_EMPTY_COUNT 10
+#define CRITICAL_LOW_COUNT 20
+
+static uint32_t bat_monitor_timer_buffer = 0;
+static uint16_t voltage                  = FULL_VOLTAGE_VALUE;
+static uint8_t  bat_empty                = 0;
+static uint8_t  critical_low             = 0;
+static uint8_t  bat_state;
+static uint8_t  power_on_sample = 0;
+
+void battery_init(void) {
+    bat_state = BAT_NOT_CHARGING;
+}
+__attribute__((weak)) void battery_measure(void) {
+    ckbt51_read_state_reg(0x05, 0x02);
+}
+
+/* Calculate the voltage */
+__attribute__((weak)) void battery_calculate_voltage(uint16_t value) {}
+
+void battery_set_voltage(uint16_t value) {
+    voltage = value;
+}
+
+uint16_t battery_get_voltage(void) {
+    return voltage;
+}
+
+uint8_t battery_get_percentage(void) {
+    if (voltage > FULL_VOLTAGE_VALUE) return 100;
+
+    if (voltage > EMPTY_VOLTAGE_VALUE) {
+        return ((uint32_t)voltage - EMPTY_VOLTAGE_VALUE) * 80 / (FULL_VOLTAGE_VALUE - EMPTY_VOLTAGE_VALUE) + 20;
+    }
+
+    if (voltage > SHUTDOWN_VOLTAGE_VALUE) {
+        return ((uint32_t)voltage - SHUTDOWN_VOLTAGE_VALUE) * 20 / (EMPTY_VOLTAGE_VALUE - SHUTDOWN_VOLTAGE_VALUE);
+    } else
+        return 0;
+}
+
+bool battery_is_empty(void) {
+    return bat_empty > BATTERY_EMPTY_COUNT;
+}
+
+bool battery_is_critical_low(void) {
+    return critical_low > CRITICAL_LOW_COUNT;
+}
+
+void battery_check_empty(void) {
+    if (voltage < EMPTY_VOLTAGE_VALUE) {
+        if (bat_empty <= BATTERY_EMPTY_COUNT) {
+            if (++bat_empty > BATTERY_EMPTY_COUNT) {
+#if defined(BAT_LOW_LED_PIN) || defined(BAT_LOW_LED_PIN_STATE)
+                indicator_battery_low_enable(true);
+#endif
+#if defined(LOW_BAT_IND_INDEX)
+                indicator_battery_low_backlit_enable(true);
+#endif
+                power_on_sample = VOLTAGE_POWER_ON_MEASURE_COUNT;
+            }
+        }
+    }
+}
+
+void battery_check_critical_low(void) {
+    if (voltage < SHUTDOWN_VOLTAGE_VALUE) {
+        if (critical_low <= CRITICAL_LOW_COUNT) {
+            if (++critical_low > CRITICAL_LOW_COUNT) bluetooth_low_battery_shutdown();
+        }
+    } else if (critical_low <= CRITICAL_LOW_COUNT) {
+        critical_low = 0;
+    }
+}
+
+bool battery_power_on_sample(void) {
+    return power_on_sample < VOLTAGE_POWER_ON_MEASURE_COUNT;
+}
+
+void battery_task(void) {
+    uint32_t t = rtc_timer_elapsed_ms(bat_monitor_timer_buffer);
+    if (get_transport() == TRANSPORT_BLUETOOTH && bluetooth_get_state() == BLUETOOTH_CONNECTED) {
+        if ((battery_power_on_sample()
+#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
+             && !indicator_is_enabled()
+#endif
+             && t > BACKLIGHT_OFF_VOLTAGE_MEASURE_INTERVAL) ||
+            t > VOLTAGE_MEASURE_INTERVAL) {
+
+            battery_check_empty();
+            battery_check_critical_low();
+
+            bat_monitor_timer_buffer = rtc_timer_read_ms();
+            if (bat_monitor_timer_buffer > RTC_MAX_TIME) {
+                bat_monitor_timer_buffer = 0;
+                rtc_timer_clear();
+            }
+
+            battery_measure();
+            power_on_sample++;
+            if (power_on_sample > VOLTAGE_POWER_ON_MEASURE_COUNT) power_on_sample = VOLTAGE_POWER_ON_MEASURE_COUNT;
+        }
+    }
+
+    if ((bat_empty || critical_low) && usb_power_connected()) {
+        bat_empty    = false;
+        critical_low = false;
+#if defined(BAT_LOW_LED_PIN) || defined(BAT_LOW_LED_PIN_STATE)
+        indicator_battery_low_enable(false);
+#endif
+#if defined(LOW_BAT_IND_INDEX)
+        indicator_battery_low_backlit_enable(false);
+#endif
+    }
+}

keyboards/keychron/bluetooth/battery.h

@@ -0,0 +1,60 @@
+/* Copyright 2022 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+enum {
+    BAT_NOT_CHARGING = 0,
+    BAT_CHARGING,
+    BAT_CHARGING_FINISHED,
+};
+
+#ifndef FULL_VOLTAGE_VALUE
+#    define FULL_VOLTAGE_VALUE 4100
+#endif
+
+#ifndef EMPTY_VOLTAGE_VALUE
+#    define EMPTY_VOLTAGE_VALUE 3500
+#endif
+
+#ifndef SHUTDOWN_VOLTAGE_VALUE
+#    define SHUTDOWN_VOLTAGE_VALUE 3300
+#endif
+
+#ifndef VOLTAGE_MEASURE_INTERVAL
+#    define VOLTAGE_MEASURE_INTERVAL 3000
+#endif
+
+#ifndef VOLTAGE_POWER_ON_MEASURE_COUNT
+#    define VOLTAGE_POWER_ON_MEASURE_COUNT 15
+#endif
+
+#ifndef BACKLIGHT_OFF_VOLTAGE_MEASURE_INTERVAL
+#    define BACKLIGHT_OFF_VOLTAGE_MEASURE_INTERVAL 200
+#endif
+
+void battery_init(void);
+void battery_measure(void);
+void     battery_calculte_voltage(uint16_t value);
+void     battery_set_voltage(uint16_t value);
+uint16_t battery_get_voltage(void);
+uint8_t battery_get_percentage(void);
+void indicator_battery_low_enable(bool enable);
+bool battery_is_empty(void);
+bool battery_is_critical_low(void);
+bool     battery_power_on_sample(void);
+
+void battery_task(void);

keyboards/keychron/bluetooth/bluetooth.c

@@ -0,0 +1,484 @@
+/* Copyright 2022 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "action.h"
+#include "quantum.h"
+#include "bluetooth.h"
+#include "report_buffer.h"
+#include "lpm.h"
+#include "battery.h"
+#include "indicator.h"
+#include "transport.h"
+#include "rtc_timer.h"
+
+extern uint8_t         pairing_indication;
+extern host_driver_t   chibios_driver;
+extern report_buffer_t kb_rpt;
+extern uint32_t        retry_time_buffer;
+extern uint8_t         retry;
+
+#ifdef NKRO_ENABLE
+extern nkro_t nkro;
+#endif
+
+static uint8_t host_index = 0;
+static uint8_t led_state  = 0;
+
+extern bluetooth_transport_t bluetooth_transport;
+static bluetooth_state_t     bt_state                  = BLUETOOTH_RESET;
+static bool                  pincodeEntry              = false;
+uint8_t                      bluetooth_report_protocol = true;
+
+/* declarations */
+uint8_t bluetooth_keyboard_leds(void);
+void    bluetooth_send_keyboard(report_keyboard_t *report);
+void    bluetooth_send_nkro(report_nkro_t *report);
+void    bluetooth_send_mouse(report_mouse_t *report);
+void    bluetooth_send_extra(report_extra_t *report);
+
+/* host struct */
+host_driver_t bluetooth_driver = {bluetooth_keyboard_leds, bluetooth_send_keyboard, bluetooth_send_nkro, bluetooth_send_mouse, bluetooth_send_extra};
+
+#define BLUETOOTH_EVENT_QUEUE_SIZE 16
+bluetooth_event_t bt_event_queue[BLUETOOTH_EVENT_QUEUE_SIZE];
+uint8_t           bt_event_queue_head;
+uint8_t           bt_event_queue_tail;
+
+void bluetooth_bt_event_queue_init(void) {
+    // Initialise the event queue
+    memset(&bt_event_queue, 0, sizeof(bt_event_queue));
+    bt_event_queue_head = 0;
+    bt_event_queue_tail = 0;
+}
+
+bool bluetooth_event_queue_enqueue(bluetooth_event_t event) {
+    uint8_t next = (bt_event_queue_head + 1) % BLUETOOTH_EVENT_QUEUE_SIZE;
+    if (next == bt_event_queue_tail) {
+        /* Override the first report */
+        bt_event_queue_tail = (bt_event_queue_tail + 1) % BLUETOOTH_EVENT_QUEUE_SIZE;
+    }
+    bt_event_queue[bt_event_queue_head] = event;
+    bt_event_queue_head                 = next;
+    return true;
+}
+
+static inline bool bluetooth_event_queue_dequeue(bluetooth_event_t *event) {
+    if (bt_event_queue_head == bt_event_queue_tail) {
+        return false;
+    }
+    *event              = bt_event_queue[bt_event_queue_tail];
+    bt_event_queue_tail = (bt_event_queue_tail + 1) % BLUETOOTH_EVENT_QUEUE_SIZE;
+    return true;
+}
+
+/*
+ * Bluetooth init.
+ */
+void bluetooth_init(void) {
+    bt_state = BLUETOOTH_INITIALIZED;
+
+    bluetooth_bt_event_queue_init();
+#ifndef DISABLE_REPORT_BUFFER
+    report_buffer_init();
+#endif
+    indicator_init();
+#ifdef BLUETOOTH_INT_INPUT_PIN
+    setPinInputHigh(BLUETOOTH_INT_INPUT_PIN);
+#endif
+
+    lpm_init();
+    rtc_timer_init();
+
+#ifdef BLUETOOTH_NKRO_ENABLE
+    keymap_config.raw = eeconfig_read_keymap();
+    nkro.bluetooth    = keymap_config.nkro;
+#endif
+}
+
+/*
+ * Bluetooth trasponrt init. Bluetooth module driver shall use this function to register a callback
+ * to its implementation.
+ */
+void bluetooth_set_transport(bluetooth_transport_t *transport) {
+    if (transport) memcpy(&bluetooth_transport, transport, sizeof(bluetooth_transport_t));
+}
+
+/*
+ * Enter pairing with current host index
+ */
+void bluetooth_pairing(void) {
+    if (battery_is_critical_low()) return;
+
+    bluetooth_pairing_ex(0, NULL);
+    bt_state = BLUETOOTH_PARING;
+}
+
+/*
+ * Enter pairing with specified host index and param
+ */
+void bluetooth_pairing_ex(uint8_t host_idx, void *param) {
+    if (battery_is_critical_low()) return;
+
+    if (bluetooth_transport.pairing_ex) bluetooth_transport.pairing_ex(host_idx, param);
+    bt_state = BLUETOOTH_PARING;
+
+    host_index = host_idx;
+}
+
+/*
+ * Initiate connection request to paired host
+ */
+void bluetooth_connect(void) {
+    /*  Work around empty report after wakeup, which leads to reconneect/disconnected loop */
+    if (battery_is_critical_low() || sync_timer_read32() == 0) return;
+
+    bluetooth_transport.connect_ex(0, 0);
+    bt_state = BLUETOOTH_RECONNECTING;
+}
+
+/*
+ * Initiate connection request to paired host with argument
+ */
+void bluetooth_connect_ex(uint8_t host_idx, uint16_t timeout) {
+    if (battery_is_critical_low()) return;
+
+    if (host_idx != 0) {
+        if (host_index == host_idx && bt_state == BLUETOOTH_CONNECTED) return;
+        host_index = host_idx;
+        led_state  = 0;
+    }
+    bluetooth_transport.connect_ex(host_idx, timeout);
+    bt_state = BLUETOOTH_RECONNECTING;
+}
+
+/* Initiate a disconnection */
+void bluetooth_disconnect(void) {
+    if (bluetooth_transport.disconnect) bluetooth_transport.disconnect();
+}
+
+/* Called when the BT device is reset. */
+static void bluetooth_enter_reset(uint8_t reason) {
+    bt_state = BLUETOOTH_RESET;
+    bluetooth_enter_reset_kb(reason);
+}
+
+/* Enters discoverable state. Upon entering this state we perform the following actions:
+ *   - change state to BLUETOOTH_PARING
+ *   - set pairing indication
+ */
+static void bluetooth_enter_discoverable(uint8_t host_idx) {
+    bt_state = BLUETOOTH_PARING;
+    indicator_set(bt_state, host_idx);
+    bluetooth_enter_discoverable_kb(host_idx);
+}
+
+/*
+ * Enters reconnecting state. Upon entering this state we perform the following actions:
+ *   - change state to RECONNECTING
+ *   - set reconnect indication
+ */
+static void bluetooth_enter_reconnecting(uint8_t host_idx) {
+    bt_state = BLUETOOTH_RECONNECTING;
+    indicator_set(bt_state, host_idx);
+    bluetooth_enter_reconnecting_kb(host_idx);
+}
+
+/* Enters connected state. Upon entering this state we perform the following actions:
+ *   - change state to CONNECTED
+ *   - set connected indication
+ *   - enable bluetooth NKRO is support
+ */
+static void bluetooth_enter_connected(uint8_t host_idx) {
+    bt_state = BLUETOOTH_CONNECTED;
+    indicator_set(bt_state, host_idx);
+    host_index = host_idx;
+
+    clear_keyboard();
+
+    /* Enable NKRO since it may be disabled in pin code entry */
+#if defined(NKRO_ENABLE) && defined(BLUETOOTH_NKRO_ENABLE)
+    keymap_config.nkro = nkro.bluetooth;
+#else
+    keymap_config.nkro = false;
+#endif
+
+    bluetooth_enter_connected_kb(host_idx);
+#if defined(BAT_LOW_LED_PIN) || defined(BAT_LOW_LED_PIN_STATE)
+    if (battery_is_empty()) {
+        indicator_battery_low_enable(true);
+    }
+#endif
+}
+
+/* Enters disconnected state. Upon entering this state we perform the following actions:
+ *   - change state to DISCONNECTED
+ *   - set disconnected indication
+ */
+static void bluetooth_enter_disconnected(uint8_t host_idx) {
+    uint8_t previous_state = bt_state;
+    bt_state               = BLUETOOTH_DISCONNECTED;
+
+    if (previous_state == BLUETOOTH_CONNECTED) {
+        lpm_timer_reset();
+        indicator_set(BLUETOOTH_SUSPEND, host_idx);
+    } else
+        indicator_set(bt_state, host_idx);
+
+#ifndef DISABLE_REPORT_BUFFER
+    report_buffer_init();
+#endif
+    retry = 0;
+    bluetooth_enter_disconnected_kb(host_idx);
+#if defined(BAT_LOW_LED_PIN) || defined(BAT_LOW_LED_PIN_STATE)
+    indicator_battery_low_enable(false);
+#endif
+#if defined(LOW_BAT_IND_INDEX)
+    indicator_battery_low_backlit_enable(false);
+#endif
+}
+
+/* Enter pin code entry state. */
+static void bluetooth_enter_pin_code_entry(void) {
+#if defined(NKRO_ENABLE)
+    keymap_config.nkro = FALSE;
+#endif
+    pincodeEntry = true;
+    bluetooth_enter_pin_code_entry_kb();
+}
+
+/* Exit pin code entry state. */
+static void bluetooth_exit_pin_code_entry(void) {
+#if defined(NKRO_ENABLE)
+    keymap_config.nkro = true;
+#endif
+    pincodeEntry = false;
+    bluetooth_exit_pin_code_entry_kb();
+}
+
+__attribute__((weak)) void bluetooth_enter_reset_kb(uint8_t reason){};
+__attribute__((weak)) void bluetooth_enter_discoverable_kb(uint8_t host_idx){};
+__attribute__((weak)) void bluetooth_enter_reconnecting_kb(uint8_t host_idx){};
+__attribute__((weak)) void bluetooth_enter_connected_kb(uint8_t host_idx){};
+__attribute__((weak)) void bluetooth_enter_disconnected_kb(uint8_t host_idx){};
+__attribute__((weak)) void bluetooth_enter_pin_code_entry_kb(void) {}
+__attribute__((weak)) void bluetooth_exit_pin_code_entry_kb(void){};
+
+/*  */
+static void bluetooth_hid_set_protocol(bool report_protocol) {
+    bluetooth_report_protocol = false;
+}
+
+uint8_t bluetooth_keyboard_leds(void) {
+    if (bt_state == BLUETOOTH_CONNECTED) {
+        return led_state;
+    }
+
+    return 0;
+}
+
+extern keymap_config_t keymap_config;
+
+void bluetooth_send_keyboard(report_keyboard_t *report) {
+    if (bt_state == BLUETOOTH_PARING && !pincodeEntry) return;
+
+    if (bt_state == BLUETOOTH_CONNECTED || (bt_state == BLUETOOTH_PARING && pincodeEntry)) {
+        if (bluetooth_transport.send_keyboard) {
+#ifndef DISABLE_REPORT_BUFFER
+            bool firstBuffer = false;
+            if (report_buffer_is_empty() && report_buffer_next_inverval() && report_buffer_get_retry() == 0) {
+                firstBuffer = true;
+            }
+
+            report_buffer_t report_buffer;
+            report_buffer.type = REPORT_TYPE_KB;
+            memcpy(&report_buffer.keyboard, report, sizeof(report_keyboard_t));
+            report_buffer_enqueue(&report_buffer);
+
+            if (firstBuffer) {
+                report_buffer_set_retry(0);
+                report_buffer_task();
+            }
+#else
+            bluetooth_transport.send_keyboard(&report->nkro.mods);
+#endif
+        }
+    } else if (bt_state != BLUETOOTH_RESET) {
+        bluetooth_connect();
+    }
+}
+void bluetooth_send_nkro(report_nkro_t *report) {
+    if (bt_state == BLUETOOTH_PARING && !pincodeEntry) return;
+
+    if (bt_state == BLUETOOTH_CONNECTED || (bt_state == BLUETOOTH_PARING && pincodeEntry)) {
+        if (bluetooth_transport.send_keyboard) {
+#ifndef DISABLE_REPORT_BUFFER
+            if (report_buffer_is_empty() && report_buffer_next_inverval()) {
+                bluetooth_transport.send_keyboard(&report->mods);
+                report_buffer_update_timer();
+            } else {
+                report_buffer_t report_buffer;
+                report_buffer.type = REPORT_TYPE_NKRO;
+                memcpy(&report_buffer.nkro, report, sizeof(report_nkro_t));
+                report_buffer_enqueue(&report_buffer);
+            }
+#else
+            bluetooth_transport.send_nkro(&report->mods);
+#endif
+        }
+    } else if (bt_state != BLUETOOTH_RESET) {
+        bluetooth_connect();
+    }
+}
+
+void bluetooth_send_mouse(report_mouse_t *report) {
+    if (bt_state == BLUETOOTH_CONNECTED) {
+        if (bluetooth_transport.send_mouse) bluetooth_transport.send_mouse((uint8_t *)report);
+    } else if (bt_state != BLUETOOTH_RESET) {
+        bluetooth_connect();
+    }
+}
+
+void bluetooth_send_system(uint16_t data) {
+    if (bt_state == BLUETOOTH_CONNECTED) {
+        if (bluetooth_transport.send_system) bluetooth_transport.send_system(data);
+    } else if (bt_state != BLUETOOTH_RESET) {
+        bluetooth_connect();
+    }
+}
+
+void bluetooth_send_consumer(uint16_t data) {
+    if (bt_state == BLUETOOTH_CONNECTED) {
+#ifndef DISABLE_REPORT_BUFFER
+        if (report_buffer_is_empty() && report_buffer_next_inverval()) {
+            if (bluetooth_transport.send_consumer) bluetooth_transport.send_consumer(data);
+            report_buffer_update_timer();
+        } else {
+            report_buffer_t report_buffer;
+            report_buffer.type     = REPORT_TYPE_CONSUMER;
+            report_buffer.consumer = data;
+            report_buffer_enqueue(&report_buffer);
+        }
+#else
+        if (bluetooth_transport.send_consumer) bluetooth_transport.send_consumer(data);
+#endif
+    } else if (bt_state != BLUETOOTH_RESET) {
+        bluetooth_connect();
+    }
+}
+
+void bluetooth_send_extra(report_extra_t *report) {
+    if (report->report_id == REPORT_ID_SYSTEM) {
+        bluetooth_send_system(report->usage);
+    } else if (report->report_id == REPORT_ID_CONSUMER) {
+        bluetooth_send_consumer(report->usage);
+    }
+}
+
+void bluetooth_low_battery_shutdown(void) {
+#if defined(BAT_LOW_LED_PIN) || defined(BAT_LOW_LED_PIN_STATE)
+    indicator_battery_low_enable(false);
+#endif
+#if defined(LOW_BAT_IND_INDEX)
+    indicator_battery_low_backlit_enable(false);
+#endif
+    clear_keyboard();
+    send_keyboard_report();
+    wait_ms(50);
+    bluetooth_disconnect();
+}
+
+void bluetooth_event_queue_task(void) {
+    bluetooth_event_t event;
+    while (bluetooth_event_queue_dequeue(&event)) {
+        switch (event.evt_type) {
+            case EVT_RESET:
+                bluetooth_enter_reset(event.params.reason);
+                break;
+            case EVT_CONNECTED:
+                bluetooth_enter_connected(event.params.hostIndex);
+                break;
+            case EVT_DISCOVERABLE:
+                bluetooth_enter_discoverable(event.params.hostIndex);
+                break;
+            case EVT_RECONNECTING:
+                bluetooth_enter_reconnecting(event.params.hostIndex);
+                break;
+            case EVT_DISCONNECTED:
+                led_state = 0;
+                bluetooth_enter_disconnected(event.params.hostIndex);
+                break;
+            case EVT_BT_PINCODE_ENTRY:
+                bluetooth_enter_pin_code_entry();
+                break;
+            case EVT_EXIT_BT_PINCODE_ENTRY:
+                bluetooth_exit_pin_code_entry();
+                break;
+            case EVT_HID_INDICATOR:
+                led_state = event.params.led;
+                break;
+            case EVT_HID_SET_PROTOCOL:
+                bluetooth_hid_set_protocol(event.params.protocol);
+                break;
+            case EVT_CONECTION_INTERVAL:
+                report_buffer_set_inverval(event.params.interval);
+                break;
+            default:
+                break;
+        }
+    }
+}
+
+void bluetooth_task(void) {
+    bluetooth_transport.task();
+    bluetooth_event_queue_task();
+#ifndef DISABLE_REPORT_BUFFER
+    report_buffer_task();
+#endif
+    indicator_task();
+    battery_task();
+    lpm_task();
+}
+
+bluetooth_state_t bluetooth_get_state(void) {
+    return bt_state;
+};
+
+__attribute__((weak)) bool process_record_kb_bt(uint16_t keycode, keyrecord_t *record) {
+    return true;
+};
+
+bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
+    if (!process_record_user(keycode, record)) {
+        return false;
+    }
+
+    if (get_transport() == TRANSPORT_BLUETOOTH) {
+        lpm_timer_reset();
+
+#if defined(BAT_LOW_LED_PIN) || defined(LOW_BAT_IND_INDEX)
+        if (battery_is_empty() && bluetooth_get_state() == BLUETOOTH_CONNECTED && record->event.pressed) {
+#    if defined(BAT_LOW_LED_PIN) || defined(BAT_LOW_LED_PIN_STATE)
+            indicator_battery_low_enable(true);
+#    endif
+#    if defined(LOW_BAT_IND_INDEX)
+            indicator_battery_low_backlit_enable(true);
+#    endif
+        }
+#endif
+    }
+    return process_record_kb_bt(keycode, record);
+    // return process_record_user(keycode, record);
+}

keyboards/keychron/bluetooth/bluetooth.h

@@ -0,0 +1,87 @@
+/* Copyright 2022 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "bluetooth_event_type.h"
+#include "action.h"
+
+/* Low power mode */
+#ifndef LOW_POWER_MODE
+#    define LOW_POWER_MODE PM_STOP1
+#endif
+
+/* Wake pin used for blueooth module/controller to wake up MCU in low power mode*/
+#ifndef BLUETOOTH_INT_INPUT_PIN
+#    define WAKE_PIN A5
+#endif
+
+/* Type of an enumeration of the possible BT state.*/
+typedef enum {
+    BLUETOOTH_RESET,
+    BLUETOOTH_INITIALIZED,  // 1
+    BLUETOOTH_DISCONNECTED, // 2
+    BLUETOOTH_CONNECTED,    // 3
+    BLUETOOTH_PARING,       // 4
+    BLUETOOTH_RECONNECTING, // 5
+    BLUETOOTH_SUSPEND
+} bluetooth_state_t;
+
+extern event_listener_t bt_driver;
+
+typedef struct {
+    void (*init)(bool);
+    void (*connect_ex)(uint8_t, uint16_t);
+    void (*pairing_ex)(uint8_t, void *);
+    void (*disconnect)(void);
+    void (*send_keyboard)(uint8_t *);
+    void (*send_nkro)(uint8_t *);
+    void (*send_consumer)(uint16_t);
+    void (*send_system)(uint16_t);
+    void (*send_mouse)(uint8_t *);
+    void (*task)(void);
+} bluetooth_transport_t;
+
+void bluetooth_init(void);
+void bluetooth_set_transport(bluetooth_transport_t *transport);
+void bluetooth_task(void);
+
+bool bluetooth_event_queue_enqueue(bluetooth_event_t event);
+
+void bluetooth_connect(void);
+void bluetooth_connect_ex(uint8_t host_idx, uint16_t timeout);
+void bluetooth_disconnect(void);
+
+void bluetooth_pairing(void);
+void bluetooth_pairing_ex(uint8_t host_idx, void *param);
+bool bluetooth_is_activated(void);
+
+void bluetooth_enter_reset_kb(uint8_t reason);
+void bluetooth_enter_discoverable_kb(uint8_t host_idx);
+void bluetooth_enter_reconnecting_kb(uint8_t host_idx);
+void bluetooth_enter_connected_kb(uint8_t host_idx);
+void bluetooth_enter_disconnected_kb(uint8_t host_idx);
+void bluetooth_enter_pin_code_entry_kb(void);
+void bluetooth_exit_pin_code_entry_kb(void);
+
+void              bluetooth_task(void);
+void              bluetooth_pre_task(void);
+void              bluetooth_post_task(void);
+bluetooth_state_t bluetooth_get_state(void);
+
+void bluetooth_low_battery_shutdown(void);
+
+bool process_record_kb_bt(uint16_t keycode, keyrecord_t *record);

keyboards/keychron/bluetooth/bluetooth.mk

@@ -0,0 +1,23 @@
+
+OPT_DEFS += -DKC_BLUETOOTH_ENABLE
+
+BLUETOOTH_DIR = bluetooth
+SRC += \
+     $(BLUETOOTH_DIR)/bluetooth.c \
+     $(BLUETOOTH_DIR)/report_buffer.c \
+     $(BLUETOOTH_DIR)/ckbt51.c \
+     $(BLUETOOTH_DIR)/indicator.c \
+     $(BLUETOOTH_DIR)/bluetooth_main.c \
+     $(BLUETOOTH_DIR)/transport.c \
+     $(BLUETOOTH_DIR)/lpm.c \
+     $(BLUETOOTH_DIR)/lpm_stm32l432.c \
+     $(BLUETOOTH_DIR)/battery.c \
+     $(BLUETOOTH_DIR)/factory_test.c \
+     $(BLUETOOTH_DIR)/bat_level_animation.c \
+     $(BLUETOOTH_DIR)/rtc_timer.c
+
+VPATH += $(TOP_DIR)/keyboards/keychron/$(BLUETOOTH_DIR)
+
+# Work around RTC clock issue without touching chibios, refer to the link for this bug
+# https://forum.chibios.org/viewtopic.php?f=35&t=6197
+OPT_DEFS += -DRCC_APBENR1_RTCAPBEN

keyboards/keychron/bluetooth/bluetooth_config.h

@@ -0,0 +1,38 @@
+/* Copyright 2022 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef BLUETOOTH_CONFIG_H
+#define BLUETOOTH_CONFIG_H
+
+#include "config.h"
+
+//
+#ifndef HOST_DEVICES_COUNT
+#    define HOST_DEVICES_COUNT                      3
+#endif
+
+//  Uint: Second
+#ifndef DISCONNECTED_BACKLIGHT_OFF_DELAY_TIME
+#    define DISCONNECTED_BACKLIGHT_OFF_DELAY_TIME   40
+#endif
+
+//  Uint: Second, the timer restarts on key activities.
+#ifndef CONNECTED_BACKLIGHT_OFF_DELAY_TIME
+#    define CONNECTED_BACKLIGHT_OFF_DELAY_TIME      600
+#endif
+
+#endif
+

keyboards/keychron/bluetooth/bluetooth_event_type.h

@@ -0,0 +1,44 @@
+/* Copyright 2022 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+/* Type of an enumeration of the possible BT events.*/
+typedef enum {
+    EVT_NONE = 0,
+    EVT_RESET,
+    EVT_DISCOVERABLE,
+    EVT_RECONNECTING,
+    EVT_CONNECTED,
+    EVT_DISCONNECTED,
+    EVT_BT_PINCODE_ENTRY,
+    EVT_EXIT_BT_PINCODE_ENTRY,
+    EVT_HID_SET_PROTOCOL,
+    EVT_HID_INDICATOR,
+    EVT_CONECTION_INTERVAL,
+} event_type_t;
+
+typedef struct {
+    event_type_t evt_type; /*The type of the event. */
+    union {
+        uint8_t reason;    /* Parameters to BLUETOOTH_RESET event */
+        uint8_t hostIndex; /* Parameters to connection event from EVT_DISCOVERABLE to EVT_DISCONECTED */
+        uint8_t led;       /* Parameters to EVT_HID_INDICATOR event */
+        uint8_t protocol;  /* Parameters to EVT_HID_SET_PROTOCOL event */
+        uint8_t interval;  /* Parameters to EVT_CONECTION_INTERVAL event */
+    } params;
+} bluetooth_event_t;
+

keyboards/keychron/bluetooth/bluetooth_main.c

@@ -0,0 +1,37 @@
+/* Copyright 2022 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "quantum.h"
+#include "bluetooth.h"
+#include "transport.h"
+
+__attribute__((weak)) void bluetooth_pre_task(void) {}
+__attribute__((weak)) void bluetooth_post_task(void) {}
+
+void bluetooth_tasks(void) {
+    bluetooth_pre_task();
+    bluetooth_task();
+    bluetooth_post_task();
+
+    /* usb_remote_wakeup() should be invoked last so that we have chance
+     * to switch to bluetooth after start-up when usb is not connected
+     */
+    if (get_transport() == TRANSPORT_USB) usb_remote_wakeup();
+}
+
+void housekeeping_task_kb(void) {
+    bluetooth_tasks();
+}

keyboards/keychron/bluetooth/ckbt51.c

@@ -0,0 +1,606 @@
+/* Copyright 2021 @ Keychron (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdbool.h>
+#include "quantum.h"
+#include "ckbt51.h"
+#include "bluetooth.h"
+#include "battery.h"
+#include "raw_hid.h"
+#include "report_buffer.h"
+
+#ifndef RAW_EPSIZE
+#    define RAW_EPSIZE 32
+#endif
+
+#ifndef CKBT51_INT_INPUT_PIN
+#    error "CKBT51_INT_INPUT_PIN is not defined"
+#endif
+
+#ifndef CKBT51_TX_RETRY_COUNT
+#    define CKBT51_TX_RETRY_COUNT 3
+#endif
+
+/* CKBT51 disable its uart peripheral to save power if uart inactivity for 3s, need to
+ * assert this pin and wait some time for its uart getting ready before sending  data*/
+#define CKBT51_WAKE_WAIT_TIME 3000 // us
+
+enum {
+    /* HID Report  */
+    CKBT51_CMD_SEND_KB       = 0x11,
+    CKBT51_CMD_SEND_KB_NKRO  = 0x12,
+    CKBT51_CMD_SEND_CONSUMER = 0x13,
+    CKBT51_CMD_SEND_SYSTEM   = 0x14,
+    CKBT51_CMD_SEND_FN       = 0x15, // Not used currently
+    CKBT51_CMD_SEND_MOUSE    = 0x16, // Not used currently
+    CKBT51_CMD_SEND_BOOT_KB  = 0x17,
+    /* Bluetooth connections */
+    CKBT51_CMD_PAIRING        = 0x21,
+    CKBT51_CMD_CONNECT        = 0x22,
+    CKBT51_CMD_DISCONNECT     = 0x23,
+    CKBT51_CMD_SWITCH_HOST    = 0x24,
+    CKBT51_CMD_READ_STATE_REG = 0x25,
+    /* Battery */
+    CKBT51_CMD_BATTERY_MANAGE = 0x31,
+    CKBT51_CMD_UPDATE_BAT_LVL = 0x32,
+    /* Set/get parameters */
+    CKBT51_CMD_GET_MODULE_INFO = 0x40,
+    CKBT51_CMD_SET_CONFIG      = 0x41,
+    CKBT51_CMD_GET_CONFIG      = 0x42,
+    CKBT51_CMD_SET_BDA         = 0x43,
+    CKBT51_CMD_GET_BDA         = 0x44,
+    CKBT51_CMD_SET_NAME        = 0x45,
+    CKBT51_CMD_GET_NAME        = 0x46,
+    /* DFU */
+    CKBT51_CMD_GET_DFU_VER      = 0x60,
+    CKBT51_CMD_HAND_SHAKE_TOKEN = 0x61,
+    CKBT51_CMD_START_DFU        = 0x62,
+    CKBT51_CMD_SEND_FW_DATA     = 0x63,
+    CKBT51_CMD_VERIFY_CRC32     = 0x64,
+    CKBT51_CMD_SWITCH_FW        = 0x65,
+    /* Factory test */
+    CKBT51_CMD_FACTORY_RESET = 0x71,
+    CKBT51_CMD_INT_PIN_TEST  = 0x72,
+    CKBT51_CMD_RADIO_TEST    = 0x73,
+    /* Event */
+    CKBT51_EVT_CKBT51_CMD_RECEIVED = 0xA1,
+    CKBT51_EVT_OTA_RSP             = 0xA3,
+    CKBT51_CONNECTION_EVT_ACK      = 0xA4,
+};
+
+enum {
+    CKBT51_EVT_ACK           = 0xA1,
+    CKBT51_EVT_QUERY_RSP     = 0xA2,
+    CKBT51_EVT_RESET         = 0xB0,
+    CKBT51_EVT_LE_CONNECTION = 0xB1,
+    CKBT51_EVT_HOST_TYPE     = 0xB2,
+    CKBT51_EVT_CONNECTION    = 0xB3,
+    CKBT51_EVT_HID_EVENT     = 0xB4,
+    CKBT51_EVT_BATTERY       = 0xB5,
+};
+
+enum { CKBT51_CONNECTED = 0x20, CKBT51_DISCOVERABLE = 0x21, CKBT51_RECONNECTING = 0x22, CKBT51_DISCONNECTED = 0x23, CKBT51_PINCODE_ENTRY = 0x24, CKBT51_EXIT_PINCODE_ENTRY = 0x25 };
+
+enum {
+    ACK_SUCCESS = 0x00,
+    ACK_CHECKSUM_ERROR,
+    ACK_FIFO_HALF_WARNING,
+    ACK_FIFO_FULL_ERROR,
+};
+
+static uint8_t payload[PACKET_MAX_LEN];
+static uint8_t reg_offset = 0xFF;
+
+bluetooth_transport_t bluetooth_transport = {ckbt51_init, ckbt51_connect, ckbt51_become_discoverable, ckbt51_disconnect, ckbt51_send_keyboard, ckbt51_send_nkro, ckbt51_send_consumer, ckbt51_send_system, ckbt51_send_mouse, ckbt51_task};
+
+void ckbt51_init(bool wakeup_from_low_power_mode) {
+#if (HAL_USE_SERIAL == TRUE)
+    SerialConfig config = {460800, 0, USART_CR2_STOP1_BITS, 0};
+
+    if (wakeup_from_low_power_mode) {
+        sdInit();
+        sdStart(&WT_DRIVER, &config);
+
+        return;
+    }
+
+    sdStart(&WT_DRIVER, &config);
+    palSetPadMode(WT_DRIVER_UART_TX_BANK, WT_DRIVER_UART_TX, PAL_MODE_ALTERNATE(WT_DRIVER_UART_TX_PAL_MODE));
+    palSetPadMode(WT_DRIVER_UART_RX_BANK, WT_DRIVER_UART_RX, PAL_MODE_ALTERNATE(WT_DRIVER_UART_RX_PAL_MODE));
+#endif
+
+    setPinOutput(CKBT51_INT_INPUT_PIN);
+    writePinHigh(CKBT51_INT_INPUT_PIN);
+}
+
+void ckbt51_send_cmd(uint8_t* payload, uint8_t len, bool ack_enable, bool retry) {
+    static uint8_t sn = 0;
+    uint8_t        i;
+    uint8_t        pkt[PACKET_MAX_LEN] = {0};
+    memset(pkt, 0, PACKET_MAX_LEN);
+
+    if (!retry) ++sn;
+    if (sn == 0) ++sn;
+
+    systime_t start = 0;
+
+    for (i = 0; i < 3; i++) {
+        writePin(CKBT51_INT_INPUT_PIN, i % 2);
+        start = chVTGetSystemTime();
+        while (chTimeI2US(chVTTimeElapsedSinceX(start)) < CKBT51_WAKE_WAIT_TIME / 3) {
+        };
+    }
+    writePinHigh(CKBT51_INT_INPUT_PIN);
+
+    uint16_t checksum = 0;
+    for (i = 0; i < len; i++)
+        checksum += payload[i];
+
+    i        = 0;
+    pkt[i++] = 0xAA;
+    pkt[i++] = ack_enable ? 0x56 : 0x55;
+    pkt[i++] = len + 2;
+    pkt[i++] = ~(len + 2) & 0xFF;
+    pkt[i++] = sn;
+    memcpy(pkt + i, payload, len);
+    i += len;
+    pkt[i++] = checksum & 0xFF;
+    pkt[i++] = (checksum >> 8) & 0xFF;
+
+    sdWrite(&WT_DRIVER, pkt, i);
+}
+
+void ckbt51_send_keyboard(uint8_t* report) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = CKBT51_CMD_SEND_KB;
+    memcpy(payload + i, report, 8);
+    i += 8;
+
+    ckbt51_send_cmd(payload, i, true, false);
+}
+
+void ckbt51_send_nkro(uint8_t* report) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = CKBT51_CMD_SEND_KB_NKRO;
+    memcpy(payload + i, report, 20); // NKRO report lenght is limited to 20 bytes
+    i += 20;
+
+    ckbt51_send_cmd(payload, i, true, false);
+}
+
+void ckbt51_send_consumer(uint16_t report) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = CKBT51_CMD_SEND_CONSUMER;
+    payload[i++] = report & 0xFF;
+    payload[i++] = ((report) >> 8) & 0xFF;
+    i += 4; // QMK doesn't send multiple consumer reports, just skip 2nd and 3rd consumer reports
+
+    ckbt51_send_cmd(payload, i, true, false);
+}
+
+void ckbt51_send_system(uint16_t report) {
+    /* CKBT51 supports only System Sleep */
+    if ((report & 0xFF) != 0x82) return;
+
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = CKBT51_CMD_SEND_SYSTEM;
+    payload[i++] = 0x01 << ((report & 0xFF) - 0x82);
+
+    ckbt51_send_cmd(payload, i, true, false);
+}
+
+void ckbt51_send_mouse(uint8_t* report) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = CKBT51_CMD_SEND_MOUSE;            // Cmd type
+    payload[i++] = report[1];                        // Button
+    payload[i++] = report[2];                        // X
+    payload[i++] = (report[2] & 0x80) ? 0xff : 0x00; // ckbt51 use 16bit report, set high byte
+    payload[i++] = report[3];                        // Y
+    payload[i++] = (report[3] & 0x80) ? 0xff : 0x00; // ckbt51 use 16bit report, set high byte
+    payload[i++] = report[4];                        // V wheel
+    payload[i++] = report[5];                        // H wheel
+
+    ckbt51_send_cmd(payload, i, false, false);
+}
+
+/* Send ack to connection event, bluetooth module will retry 2 times if no ack received */
+void ckbt51_send_conn_evt_ack(void) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = CKBT51_CONNECTION_EVT_ACK;
+
+    ckbt51_send_cmd(payload, i, false, false);
+}
+
+void ckbt51_become_discoverable(uint8_t host_idx, void* param) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    pairing_param_t default_pairing_param = {0, 0, PAIRING_MODE_LESC_OR_SSP, BT_MODE_CLASSIC, 0, NULL};
+
+    if (param == NULL) {
+        param = &default_pairing_param;
+    }
+    pairing_param_t* p = (pairing_param_t*)param;
+
+    payload[i++] = CKBT51_CMD_PAIRING; // Cmd type
+    payload[i++] = host_idx;           // Host Index
+    payload[i++] = p->timeout & 0xFF;  // Timeout
+    payload[i++] = (p->timeout >> 8) & 0xFF;
+    payload[i++] = p->pairingMode;
+    payload[i++] = p->BRorLE;  // BR/LE
+    payload[i++] = p->txPower; // LE TX POWER
+    if (p->leName) {
+        memcpy(&payload[i], p->leName, strlen(p->leName));
+        i += strlen(p->leName);
+    }
+
+    ckbt51_send_cmd(payload, i, true, false);
+}
+
+/* Timeout : 2 ~ 255 seconds */
+void ckbt51_connect(uint8_t hostIndex, uint16_t timeout) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = CKBT51_CMD_CONNECT;
+    payload[i++] = hostIndex;      // Host index
+    payload[i++] = timeout & 0xFF; // Timeout
+    payload[i++] = (timeout >> 8) & 0xFF;
+
+    ckbt51_send_cmd(payload, i, true, false);
+}
+
+void ckbt51_disconnect(void) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = CKBT51_CMD_DISCONNECT;
+    payload[i++] = 0; // Sleep mode
+
+    ckbt51_send_cmd(payload, i, true, false);
+}
+
+void ckbt51_switch_host(uint8_t hostIndex) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = CKBT51_CMD_SWITCH_HOST;
+    payload[i++] = hostIndex;
+
+    ckbt51_send_cmd(payload, i, true, false);
+}
+
+void ckbt51_read_state_reg(uint8_t reg, uint8_t len) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = CKBT51_CMD_READ_STATE_REG;
+    payload[i++] = reg_offset = reg;
+    payload[i++]              = len;
+
+    // TODO
+    ckbt51_send_cmd(payload, i, false, false);
+}
+
+void ckbt51_get_info(module_info_t* info) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = CKBT51_CMD_GET_MODULE_INFO;
+    ckbt51_send_cmd(payload, i, false, false);
+}
+
+void ckbt51_set_param(module_param_t* param) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = CKBT51_CMD_SET_CONFIG;
+    memcpy(payload + i, param, sizeof(module_param_t));
+    i += sizeof(module_param_t);
+
+    ckbt51_send_cmd(payload, i, true, false);
+}
+
+void ckbt51_get_param(module_param_t* param) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = CKBT51_CMD_GET_CONFIG;
+
+    ckbt51_send_cmd(payload, i, false, false);
+}
+
+void ckbt51_set_local_name(const char* name) {
+    uint8_t i   = 0;
+    uint8_t len = strlen(name);
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = CKBT51_CMD_SET_NAME;
+    memcpy(payload + i, name, len);
+    i += len;
+    ckbt51_send_cmd(payload, i, true, false);
+}
+
+void ckbt51_get_local_name(void) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = CKBT51_CMD_GET_NAME;
+
+    ckbt51_send_cmd(payload, i, false, false);
+}
+
+void ckbt51_factory_reset(void) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = CKBT51_CMD_FACTORY_RESET;
+
+    ckbt51_send_cmd(payload, i, false, false);
+}
+
+void ckbt51_int_pin_test(bool enable) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+    payload[i++] = CKBT51_CMD_INT_PIN_TEST;
+    payload[i++] = enable;
+
+    ckbt51_send_cmd(payload, i, false, false);
+}
+
+void ckbt51_radio_test(uint8_t channel) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+    payload[i++] = CKBT51_CMD_RADIO_TEST;
+    payload[i++] = channel;
+    payload[i++] = 0;
+
+    ckbt51_send_cmd(payload, i, false, false);
+}
+
+void ckbt51_dfu_tx(uint8_t rsp, uint8_t* data, uint8_t len, uint8_t sn) {
+    uint16_t checksum        = 0;
+    uint8_t  buf[RAW_EPSIZE] = {0};
+    uint8_t  i               = 0;
+
+    buf[i++] = 0x03;
+    buf[i++] = 0xAA;
+    buf[i++] = 0x57;
+    buf[i++] = len;
+    buf[i++] = ~len;
+    buf[i++] = sn;
+    buf[i++] = rsp;
+    memcpy(&buf[i], data, len);
+    i += len;
+
+    for (uint8_t k = 0; k < i; k++)
+        checksum += buf[i];
+
+    raw_hid_send(buf, RAW_EPSIZE);
+
+    if (len > 25) {
+        i = 0;
+        memset(buf, 0, RAW_EPSIZE);
+        buf[i++] = 0x03;
+        memcpy(&buf[i], data + 25, len - 25);
+        i = i + len - 25;
+        raw_hid_send(buf, RAW_EPSIZE);
+    }
+}
+
+void ckbt51_dfu_rx(uint8_t* data, uint8_t length) {
+    if (data[0] == 0xAA && (data[1] == 0x55 || data[1] == 0x56) && data[2] == (~data[3] & 0xFF)) {
+        uint16_t checksum    = 0;
+        uint8_t  payload_len = data[2];
+
+        /* Check payload_len validity */
+        if (payload_len > RAW_EPSIZE - PACKECT_HEADER_LEN) return;
+
+        uint8_t* payload = &data[PACKECT_HEADER_LEN];
+
+        for (uint8_t i = 0; i < payload_len - 2; i++) {
+            checksum += payload[i];
+        }
+
+        /* Verify checksum */
+        if ((checksum & 0xFF) != payload[payload_len - 2] || checksum >> 8 != payload[payload_len - 1]) return;
+        static uint8_t sn = 0;
+
+        bool retry = true;
+        if (sn != data[4]) {
+            sn    = data[4];
+            retry = false;
+        }
+
+        if ((payload[0] & 0xF0) == 0x60) {
+            ckbt51_send_cmd(payload, payload_len - 2, data[1] == 0x56, retry);
+        }
+    }
+}
+
+__attribute__((weak)) void ckbt51_default_ack_handler(uint8_t* data, uint8_t len){};
+
+static void ack_handler(uint8_t* data, uint8_t len) {
+    switch (data[1]) {
+        case CKBT51_CMD_SEND_KB:
+        case CKBT51_CMD_SEND_KB_NKRO:
+        case CKBT51_CMD_SEND_CONSUMER:
+        case CKBT51_CMD_SEND_SYSTEM:
+        case CKBT51_CMD_SEND_MOUSE:
+            switch (data[2]) {
+                case ACK_SUCCESS:
+                    report_buffer_set_retry(0);
+                    report_buffer_set_inverval(DEFAULT_REPORT_INVERVAL_MS);
+                    break;
+                case ACK_FIFO_HALF_WARNING:
+                    report_buffer_set_retry(0);
+                    report_buffer_set_inverval(DEFAULT_REPORT_INVERVAL_MS + 5);
+                    break;
+                case ACK_FIFO_FULL_ERROR:
+                    report_buffer_set_retry(10);
+                    break;
+            }
+            break;
+        default:
+            ckbt51_default_ack_handler(data, len);
+            break;
+    }
+}
+
+static void query_rsp_handler(uint8_t* data, uint8_t len) {
+    if (data[2]) return;
+
+    switch (data[1]) {
+        case CKBT51_CMD_READ_STATE_REG:
+            switch (reg_offset) {
+                case 0x05:
+                    battery_calculte_voltage(data[3] | (data[4] << 8));
+                    break;
+            }
+            reg_offset = 0xFF;
+            break;
+        default:
+            break;
+    }
+}
+
+static void ckbt51_event_handler(uint8_t evt_type, uint8_t* data, uint8_t len, uint8_t sn) {
+    bluetooth_event_t event = {0};
+
+    switch (evt_type) {
+        case CKBT51_EVT_ACK:
+            ack_handler(data, len);
+            break;
+        case CKBT51_EVT_RESET:
+            dprintf("CKBT51_EVT_RESET\n");
+            event.evt_type      = EVT_RESET;
+            event.params.reason = data[0];
+            break;
+        case CKBT51_EVT_LE_CONNECTION:
+            dprintf("CKBT51_EVT_LE_CONNECTION\n");
+            break;
+        case CKBT51_EVT_HOST_TYPE:
+            dprintf("CKBT51_EVT_HOST_TYPE\n");
+            break;
+        case CKBT51_EVT_CONNECTION:
+            dprintf("CKBT51_EVT_CONNECTION %d\n", data[0]);
+            /* Only connection status change message will retry 2 times if no ack  */
+            ckbt51_send_conn_evt_ack();
+            switch (data[0]) {
+                case CKBT51_CONNECTED:
+                    event.evt_type = EVT_CONNECTED;
+                    break;
+                case CKBT51_DISCOVERABLE:
+                    event.evt_type = EVT_DISCOVERABLE;
+                    break;
+                case CKBT51_RECONNECTING:
+                    event.evt_type = EVT_RECONNECTING;
+                    break;
+                case CKBT51_DISCONNECTED:
+                    event.evt_type = EVT_DISCONNECTED;
+                    break;
+                case CKBT51_PINCODE_ENTRY:
+                    event.evt_type = EVT_BT_PINCODE_ENTRY;
+                    break;
+                case CKBT51_EXIT_PINCODE_ENTRY:
+                    event.evt_type = EVT_EXIT_BT_PINCODE_ENTRY;
+                    break;
+            }
+            event.params.hostIndex = data[2];
+            break;
+        case CKBT51_EVT_HID_EVENT:
+            dprintf("CKBT51_EVT_HID_EVENT\n");
+            event.evt_type   = EVT_HID_INDICATOR;
+            event.params.led = data[0];
+            break;
+        case CKBT51_EVT_QUERY_RSP:
+            dprintf("CKBT51_EVT_QUERY_RSP\n");
+            query_rsp_handler(data, len);
+            break;
+        case CKBT51_EVT_OTA_RSP:
+            dprintf("CKBT51_EVT_OTA_RSP\n");
+            ckbt51_dfu_tx(CKBT51_EVT_OTA_RSP, data, len, sn);
+            break;
+        case CKBT51_EVT_BATTERY:
+            if (data[0] == 0x01) {
+                dprintf("CKBT51_EVT_BATTERY\n");
+                battery_calculte_voltage(data[1] | (data[2] << 8));
+            }
+            break;
+        default:
+            dprintf("Unknown event!!!\n");
+            break;
+    }
+
+    if (event.evt_type) bluetooth_event_queue_enqueue(event);
+}
+
+void ckbt51_task(void) {
+    static bool    wait_for_new_pkt = true;
+    static uint8_t len              = 0xff;
+    static uint8_t sn               = 0;
+
+    if (wait_for_new_pkt && WT_DRIVER.iqueue.q_counter >= PACKECT_HEADER_LEN) {
+        uint8_t buf[32] = {0};
+
+        if (wait_for_new_pkt) {
+            if (sdGet(&WT_DRIVER) == 0xAA && sdGet(&WT_DRIVER) == 0x57) {
+                for (uint8_t i = 0; i < 3; i++) {
+                    buf[i] = sdGet(&WT_DRIVER);
+                }
+                // Check wheather len is valid
+                if ((~buf[0] & 0xFF) == buf[1]) {
+                    len = buf[0];
+                    sn  = buf[2];
+
+                    wait_for_new_pkt = false;
+                }
+            }
+        }
+    }
+
+    if (!wait_for_new_pkt && WT_DRIVER.iqueue.q_counter >= len) {
+        uint8_t buf[32] = {0};
+
+        for (uint8_t i = 0; i < len; i++) {
+            buf[i] = sdGetTimeout(&WT_DRIVER, TIME_IMMEDIATE);
+        }
+
+        wait_for_new_pkt = true;
+
+        uint16_t checksum = 0;
+        for (int i = 0; i < len - 2; i++)
+            checksum += buf[i];
+
+        if ((checksum & 0xff) == buf[len - 2] && ((checksum >> 8) & 0xff) == buf[len - 1]) {
+            ckbt51_event_handler(buf[0], buf + 1, len - 3, sn);
+        } else {
+            // TODO: Error handle
+        }
+    }
+}

keyboards/keychron/bluetooth/ckbt51.h

@@ -0,0 +1,157 @@
+/* Copyright 2021 @ Keychron (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "stdint.h"
+
+#ifdef WT_DRIVER_UART_BANK
+#    define WT_DRIVER_UART_TX_BANK WT_DRIVER_UART_BANK
+#    define WT_DRIVER_UART_RX_BANK WT_DRIVER_UART_BANK
+#endif
+
+#ifndef WT_DRIVER_UART_TX_BANK
+#    define WT_DRIVER_UART_TX_BANK GPIOA
+#endif
+
+#ifndef WT_DRIVER_UART_RX_BANK
+#    define WT_DRIVER_UART_RX_BANK GPIOA
+#endif
+
+#ifndef WT_DRIVER_UART_TX
+#    define WT_DRIVER_UART_TX 2
+#endif
+
+#ifndef WT_DRIVER_UART_RX
+#    define WT_DRIVER_UART_RX 3
+#endif
+
+#ifndef WT_DRIVER
+#    define WT_DRIVER SD2
+#endif
+
+#ifdef USE_GPIOV1
+#    ifndef WT_DRIVER_UART_TX_PAL_MODE
+#        define WT_DRIVER_UART_TX_PAL_MODE PAL_MODE_STM32_ALTERNATE_PUSHPULL
+#    endif
+#    ifndef WT_DRIVER_UART_RX_PAL_MODE
+#        define WT_DRIVER_UART_RX_PAL_MODE PAL_MODE_STM32_ALTERNATE_PUSHPULL
+#    endif
+#else
+// The default PAL alternate modes are used to signal that the pins are used for I2C
+#    ifndef WT_DRIVER_UART_TX_PAL_MODE
+#        define WT_DRIVER_UART_TX_PAL_MODE 7
+#    endif
+#    ifndef WT_DRIVER_UART_RX_PAL_MODE
+#        define WT_DRIVER_UART_RX_PAL_MODE 7
+#    endif
+#endif
+
+// Error checking
+#if !STM32_SERIAL_USE_USART1 && !STM32_SERIAL_USE_USART2 && !STM32_SERIAL_USE_USART3 && !STM32_SERIAL_USE_UART4 && !STM32_SERIAL_USE_UART5 && !STM32_SERIAL_USE_USART6 && !STM32_SERIAL_USE_UART7 && !STM32_SERIAL_USE_UART8 && !STM32_SERIAL_USE_LPUART1
+#    error "BT driver activated but no USART/UART peripheral assigned"
+#endif
+
+#define PACKECT_HEADER_LEN 5
+#define BDA_LEN 6
+#define PACKET_MAX_LEN 64
+
+enum {
+    PAIRING_MODE_DEFAULT = 0x00,
+    PAIRING_MODE_JUST_WORK,
+    PAIRING_MODE_PASSKEY_ENTRY,
+    PAIRING_MODE_LESC_OR_SSP,
+    PAIRING_MODE_INVALID
+};
+
+enum {
+    BT_MODE_DEFAUL,
+    BT_MODE_CLASSIC,
+    BT_MODE_LE,     // Note: CKBT51 doesn't support BLE
+    BT_MODE_INVALID,
+};
+
+typedef struct {
+    uint8_t     hostIndex;
+    uint16_t    timeout;     /* Pairing timeout, valid value range from 30 to 3600 seconds, 0 for default */
+    uint8_t     pairingMode; /* 0: default, 1: Just Works, 2: Passkey Entry */
+    uint8_t     BRorLE;      /* Only available for dual mode module. Keep 0 for single mode module */
+    uint8_t     txPower;     /* Only available for BLE module */
+    const char* leName;      /* Only available for BLE module */
+} pairing_param_t;
+
+typedef struct {
+    uint8_t  type;
+    uint16_t full_votage;
+    uint16_t empty_voltage;
+    uint16_t shutdown_voltage;
+} battery_param_t;
+
+typedef struct {
+    uint8_t  model_name[11];
+    uint8_t  mode;
+    uint8_t  bluetooth_version;
+    uint8_t  firmware_version[11];
+    uint8_t  hardware_version[11];
+    uint16_t cmd_set_verson;
+} __attribute__((packed)) module_info_t;
+
+typedef struct {
+    uint8_t  event_mode; /* Must be 0x02 */
+    uint16_t connected_idle_timeout;
+    uint16_t pairing_timeout;   /* Range: 30 ~ 3600 second, 0 for default */
+    uint8_t  pairing_mode;      /* 0: default, 1: Just Works, 2: Passkey Entry */
+    uint16_t reconnect_timeout; /* 0: default, 0xFF: Unlimited time, 2 ~ 254 seconds */
+    uint8_t  report_rate;       /* 90 or 133 */
+    uint8_t  rsvd1;
+    uint8_t  rsvd2;
+    uint8_t  vendor_id_source; /* 0: From Bluetooth SIG, 1: From USB-IF */
+    uint16_t verndor_id;       /* No effect, the vendor ID is 0x3434 */
+    uint16_t product_id;
+    /* Below parametes is only available for BLE module  */
+    uint16_t le_connection_interval_min;
+    uint16_t le_connection_interval_max;
+    uint16_t le_connection_interval_timeout;
+} __attribute__((packed)) module_param_t;
+
+void ckbt51_init(bool wakeup_from_low_power_mode);
+void ckbt51_send_cmd(uint8_t* payload, uint8_t len, bool ack_enable, bool retry);
+
+void ckbt51_send_keyboard(uint8_t* report);
+void ckbt51_send_nkro(uint8_t* report);
+void ckbt51_send_consumer(uint16_t report);
+void ckbt51_send_system(uint16_t report);
+void ckbt51_send_mouse(uint8_t* report);
+
+void ckbt51_become_discoverable(uint8_t host_idx, void* param);
+void ckbt51_connect(uint8_t hostIndex, uint16_t timeout);
+void ckbt51_disconnect(void);
+void ckbt51_switch_host(uint8_t hostIndex);
+void ckbt51_read_state_reg(uint8_t reg, uint8_t len);
+
+void ckbt51_get_info(module_info_t* info);
+void ckbt51_set_param(module_param_t* param);
+void ckbt51_get_param(module_param_t* param);
+void ckbt51_set_local_name(const char* name);
+void ckbt51_get_local_name(void);
+
+void ckbt51_factory_reset(void);
+void ckbt51_int_pin_test(bool enable);
+void ckbt51_dfu_rx(uint8_t* data, uint8_t length);
+void ckbt51_radio_test(uint8_t channel);
+
+void ckbt51_task(void);
+

keyboards/keychron/bluetooth/factory_test.c

@@ -0,0 +1,343 @@
+/* Copyright 2021 @ Keychron (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "quantum.h"
+#include "raw_hid.h"
+#ifdef KC_BLUETOOTH_ENABLE
+#    include "transport.h"
+#    include "ckbt51.h"
+#endif
+
+#ifndef RAW_EPSIZE
+#    define RAW_EPSIZE 32
+#endif
+
+#ifndef BL_TEST_KEY1
+#    define BL_TEST_KEY1 KC_RIGHT
+#endif
+
+#ifndef BL_TEST_KEY2
+#    define BL_TEST_KEY2 KC_HOME
+#endif
+
+extern bool bt_factory_reset;
+
+enum {
+    BACKLIGHT_TEST_OFF = 0,
+    BACKLIGHT_TEST_WHITE,
+    BACKLIGHT_TEST_RED,
+    BACKLIGHT_TEST_GREEN,
+    BACKLIGHT_TEST_BLUE,
+    BACKLIGHT_TEST_MAX,
+};
+
+enum {
+    KEY_PRESS_FN             = 0x01 << 0,
+    KEY_PRESS_J              = 0x01 << 1,
+    KEY_PRESS_Z              = 0x01 << 2,
+    KEY_PRESS_BL_KEY1        = 0x01 << 3,
+    KEY_PRESS_BL_KEY2        = 0x01 << 4,
+    KEY_PRESS_FACTORY_RESET  = KEY_PRESS_FN | KEY_PRESS_J | KEY_PRESS_Z,
+    KEY_PRESS_BACKLIGTH_TEST = KEY_PRESS_FN | KEY_PRESS_BL_KEY1 | KEY_PRESS_BL_KEY2,
+};
+
+enum {
+    FACTORY_TEST_CMD_BACKLIGHT = 0x01,
+    FACTORY_TEST_CMD_OS_SWITCH,
+    FACTORY_TEST_CMD_JUMP_TO_BL,
+    FACTORY_TEST_CMD_INT_PIN,
+    FACTORY_TEST_CMD_GET_TRANSPORT,
+    FACTORY_TEST_CMD_CHARGING_ADC,
+    FACTORY_TEST_CMD_RADIO_CARRIER,
+};
+
+enum {
+    OS_SWITCH = 0x01,
+};
+
+static uint32_t factory_reset_timer = 0;
+static uint8_t  factory_reset_state = 0;
+static uint8_t  backlight_test_mode = BACKLIGHT_TEST_OFF;
+
+static uint32_t factory_reset_ind_timer = 0;
+static uint8_t  factory_reset_ind_state = 0;
+static bool     report_os_sw_state      = false;
+
+void factory_timer_start(void) {
+    factory_reset_timer = timer_read32() == 0 ? 1 : timer_read32();
+}
+
+static inline void factory_timer_check(void) {
+    if (sync_timer_elapsed32(factory_reset_timer) > 3000) {
+        factory_reset_timer = 0;
+
+        if (factory_reset_state == KEY_PRESS_FACTORY_RESET) {
+            factory_reset_ind_timer = timer_read32() == 0 ? 1 : timer_read32();
+            factory_reset_ind_state++;
+
+            layer_state_t default_layer_tmp = default_layer_state;
+            eeconfig_init();
+            default_layer_set(default_layer_tmp);
+#ifdef LED_MATRIX_ENABLE
+            if (!led_matrix_is_enabled()) led_matrix_enable();
+            led_matrix_init();
+#endif
+#ifdef RGB_MATRIX_ENABLE
+            if (!rgb_matrix_is_enabled()) rgb_matrix_enable();
+            rgb_matrix_init();
+#endif
+#ifdef KC_BLUETOOTH_ENABLE
+            ckbt51_factory_reset();
+            bt_factory_reset = true;
+#endif
+        } else if (factory_reset_state == KEY_PRESS_BACKLIGTH_TEST) {
+#ifdef LED_MATRIX_ENABLE
+            if (!led_matrix_is_enabled()) led_matrix_enable();
+#endif
+#ifdef RGB_MATRIX_ENABLE
+            if (!rgb_matrix_is_enabled()) rgb_matrix_enable();
+#endif
+            backlight_test_mode = BACKLIGHT_TEST_WHITE;
+        }
+
+        factory_reset_state = 0;
+    }
+}
+
+static inline void factory_reset_ind_timer_check(void) {
+    if (factory_reset_ind_timer && timer_elapsed32(factory_reset_ind_timer) > 250) {
+        if (factory_reset_ind_state++ > 6) {
+            factory_reset_ind_timer = factory_reset_ind_state = 0;
+        } else {
+            factory_reset_ind_timer = timer_read32() == 0 ? 1 : timer_read32();
+        }
+    }
+}
+
+void process_record_factory_reset(uint16_t keycode, keyrecord_t *record) {
+    switch (keycode) {
+#if defined(FN_KEY1) || defined(FN_KEY2)
+#    ifdef FN_KEY1
+        case FN_KEY1: /* fall through */
+#    endif
+#    ifdef FN_KEY2
+        case FN_KEY2:
+#    endif
+            if (record->event.pressed) {
+                factory_reset_state |= KEY_PRESS_FN;
+            } else {
+                factory_reset_state &= ~KEY_PRESS_FN;
+                factory_reset_timer = 0;
+            }
+            break;
+#endif
+        case KC_J:
+            if (record->event.pressed) {
+                factory_reset_state |= KEY_PRESS_J;
+                if (factory_reset_state == 0x07) factory_timer_start();
+            } else {
+                factory_reset_state &= ~KEY_PRESS_J;
+                factory_reset_timer = 0;
+            }
+            break;
+        case KC_Z:
+            if (record->event.pressed) {
+                factory_reset_state |= KEY_PRESS_Z;
+                if (factory_reset_state == 0x07) factory_timer_start();
+            } else {
+                factory_reset_state &= ~KEY_PRESS_Z;
+                factory_reset_timer = 0;
+            }
+            break;
+#ifdef BL_TEST_KEY1
+        case BL_TEST_KEY1:
+            if (record->event.pressed) {
+                if (backlight_test_mode) {
+                    if (++backlight_test_mode >= BACKLIGHT_TEST_MAX) {
+                        backlight_test_mode = BACKLIGHT_TEST_WHITE;
+                    }
+                } else {
+                    factory_reset_state |= KEY_PRESS_BL_KEY1;
+                    if (factory_reset_state == 0x19) factory_timer_start();
+                }
+            } else {
+                factory_reset_state &= ~KEY_PRESS_BL_KEY1;
+                factory_reset_timer = 0;
+            }
+            break;
+#endif
+#ifdef BL_TEST_KEY2
+        case BL_TEST_KEY2:
+            if (record->event.pressed) {
+                if (backlight_test_mode) {
+                    backlight_test_mode = BACKLIGHT_TEST_OFF;
+                } else {
+                    factory_reset_state |= KEY_PRESS_BL_KEY2;
+                    if (factory_reset_state == 0x19) factory_timer_start();
+                }
+            } else {
+                factory_reset_state &= ~KEY_PRESS_BL_KEY2;
+                factory_reset_timer = 0;
+            }
+            break;
+#endif
+    }
+}
+
+#ifdef LED_MATRIX_ENABLE
+bool led_matrix_indicators_user(void) {
+    if (factory_reset_ind_state) {
+        led_matrix_set_value_all(factory_reset_ind_state % 2 ? 0 : 255);
+    }
+
+    return true;
+}
+#endif
+
+#ifdef RGB_MATRIX_ENABLE
+bool rgb_matrix_indicators_user(void) {
+    if (factory_reset_ind_state) {
+        backlight_test_mode = BACKLIGHT_TEST_OFF;
+        rgb_matrix_set_color_all(factory_reset_ind_state % 2 ? 0 : 255, 0, 0);
+    } else if (backlight_test_mode) {
+        switch (backlight_test_mode) {
+            case BACKLIGHT_TEST_WHITE:
+                rgb_matrix_set_color_all(255, 255, 255);
+                break;
+            case BACKLIGHT_TEST_RED:
+                rgb_matrix_set_color_all(255, 0, 0);
+                break;
+            case BACKLIGHT_TEST_GREEN:
+                rgb_matrix_set_color_all(0, 255, 0);
+                break;
+            case BACKLIGHT_TEST_BLUE:
+                rgb_matrix_set_color_all(0, 0, 255);
+                break;
+        }
+    }
+
+    return true;
+}
+#endif
+
+void factory_reset_task(void) {
+    if (factory_reset_timer) factory_timer_check();
+    if (factory_reset_ind_timer) factory_reset_ind_timer_check();
+}
+
+void factory_test_send(uint8_t *payload, uint8_t length) {
+    uint16_t checksum         = 0;
+    uint8_t  data[RAW_EPSIZE] = {0};
+
+    uint8_t i = 0;
+    data[i++] = 0xAB;
+
+    memcpy(&data[i], payload, length);
+    i += length;
+
+    for (uint8_t i = 1; i < RAW_EPSIZE - 3; i++)
+        checksum += data[i];
+    data[RAW_EPSIZE - 2] = checksum & 0xFF;
+    data[RAW_EPSIZE - 1] = (checksum >> 8) & 0xFF;
+
+    raw_hid_send(data, RAW_EPSIZE);
+}
+
+void factory_test_rx(uint8_t *data, uint8_t length) {
+    if (data[0] == 0xAB) {
+        uint16_t checksum = 0;
+
+        for (uint8_t i = 1; i < RAW_EPSIZE - 3; i++) {
+            checksum += data[i];
+        }
+        /* Verify checksum */
+        if ((checksum & 0xFF) != data[RAW_EPSIZE - 2] || checksum >> 8 != data[RAW_EPSIZE - 1]) return;
+
+#ifdef KC_BLUETOOTH_ENABLE
+        uint8_t payload[32];
+        uint8_t len = 0;
+#endif
+
+        switch (data[1]) {
+            case FACTORY_TEST_CMD_BACKLIGHT:
+                backlight_test_mode = data[2];
+                factory_reset_timer = 0;
+                break;
+            case FACTORY_TEST_CMD_OS_SWITCH:
+                report_os_sw_state = data[2];
+                if (report_os_sw_state) {
+                    dip_switch_read(true);
+                }
+                break;
+            case FACTORY_TEST_CMD_JUMP_TO_BL:
+                // if (memcmp(&data[2], "JumpToBootloader", strlen("JumpToBootloader")) == 0) bootloader_jump();
+                break;
+#ifdef KC_BLUETOOTH_ENABLE
+            case FACTORY_TEST_CMD_INT_PIN:
+                switch (data[2]) {
+                    /* Enalbe/disable test */
+                    case 0xA1:
+                        ckbt51_int_pin_test(data[3]);
+                        break;
+                    /* Set INT state */
+                    case 0xA2:
+                        writePin(CKBT51_INT_INPUT_PIN, data[3]);
+                        break;
+                    /* Report INT state */
+                    case 0xA3:
+                        payload[len++] = FACTORY_TEST_CMD_INT_PIN;
+                        payload[len++] = 0xA3;
+                        payload[len++] = readPin(BLUETOOTH_INT_INPUT_PIN);
+                        factory_test_send(payload, len);
+                        break;
+                }
+                break;
+            case FACTORY_TEST_CMD_GET_TRANSPORT:
+                payload[len++] = FACTORY_TEST_CMD_GET_TRANSPORT;
+                payload[len++] = get_transport();
+                payload[len++] = readPin(USB_POWER_SENSE_PIN);
+                factory_test_send(payload, len);
+                break;
+#endif
+#ifdef BATTERY_CHARGE_DONE_DETECT_ADC
+            case FACTORY_TEST_CMD_CHARGING_ADC:
+            case 0xA1:
+                battery_charging_monitor(data[3]);
+                break;
+            case 0xA2:
+                payload[len++] = FACTORY_TEST_CMD_CHARGING_ADC;
+                payload[len++] = battery_adc_read_charging_pin();
+                factory_test_send(payload, len);
+                break;
+#endif
+            case FACTORY_TEST_CMD_RADIO_CARRIER:
+                if (data[2] < 79) ckbt51_radio_test(data[2]);
+                break;
+        }
+    }
+}
+
+bool dip_switch_update_user(uint8_t index, bool active) {
+    if (report_os_sw_state) {
+#ifdef INVERT_OS_SWITCH_STATE
+        active = !active;
+#endif
+        uint8_t payload[3] = {FACTORY_TEST_CMD_OS_SWITCH, OS_SWITCH, active};
+        factory_test_send(payload, 3);
+    }
+
+    return true;
+}

keyboards/keychron/bluetooth/factory_test.h

@@ -0,0 +1,24 @@
+/* Copyright 2022 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#define FACTORY_RESET_CHECK process_record_factory_reset
+#define FACTORY_RESET_TASK factory_reset_task
+
+void process_record_factory_reset(uint16_t keycode, keyrecord_t *record);
+void factory_reset_task(void);
+void factory_test_rx(uint8_t *data, uint8_t length);

keyboards/keychron/bluetooth/indicator.c

@@ -0,0 +1,607 @@
+/* Copyright 2021 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "quantum.h"
+#include "indicator.h"
+#include "transport.h"
+#include "battery.h"
+#include "eeconfig.h"
+#include "bluetooth_config.h"
+#include "config.h"
+#include "rtc_timer.h"
+
+#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
+#    ifdef LED_MATRIX_ENABLE
+#        include "led_matrix.h"
+#    endif
+#    ifdef RGB_MATRIX_ENABLE
+#        include "rgb_matrix.h"
+#    endif
+#    include "i2c_master.h"
+#    include "bat_level_animation.h"
+#    include "eeprom.h"
+#endif
+
+#ifdef LED_MATRIX_ENABLE
+#    define DECIDE_TIME(t, duration) (duration == 0 ? LED_MATRIX_TIMEOUT_INFINITE : ((t > duration) ? t : duration))
+#endif
+#ifdef RGB_MATRIX_ENABLE
+#    define DECIDE_TIME(t, duration) (duration == 0 ? RGB_MATRIX_TIMEOUT_INFINITE : ((t > duration) ? t : duration))
+#endif
+
+#define LED_ON 0x80
+#define INDICATOR_SET(s) memcpy(&indicator_config, &s##_config, sizeof(indicator_config_t));
+
+enum {
+    BACKLIGHT_OFF            = 0x00,
+    BACKLIGHT_ON_CONNECTED   = 0x01,
+    BACKLIGHT_ON_UNCONNECTED = 0x02,
+};
+
+static indicator_config_t pairing_config      = INDICATOR_CONFIG_PARING;
+static indicator_config_t connected_config    = INDICATOR_CONFIG_CONNECTD;
+static indicator_config_t reconnecting_config = INDICATOR_CONFIG_RECONNECTING;
+static indicator_config_t disconnected_config = INDICATOR_CONFIG_DISCONNECTED;
+indicator_config_t indicator_config;
+static bluetooth_state_t indicator_state;
+static uint16_t          next_period;
+static indicator_type_t  type;
+static uint32_t          indicator_timer_buffer = 0;
+
+#if defined(BAT_LOW_LED_PIN) || defined(BAT_LOW_LED_PIN_STATE)
+static uint32_t bat_low_pin_indicator  = 0;
+static uint32_t bat_low_blink_duration = 0;
+#    ifdef BAT_LOW_LED_PIN_STATE
+bool bat_low_led_pin_state = false;
+#    endif
+#endif
+
+#if defined(LOW_BAT_IND_INDEX)
+static uint32_t bat_low_backlit_indicator = 0;
+static uint8_t  bat_low_ind_state         = 0;
+static uint32_t rtc_time                  = 0;
+#endif
+
+#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
+backlight_state_t original_backlight_state;
+
+static uint8_t host_led_matrix_list[HOST_DEVICES_COUNT] = HOST_LED_MATRIX_LIST;
+#endif
+
+#ifdef HOST_LED_PIN_LIST
+static pin_t host_led_pin_list[HOST_DEVICES_COUNT] = HOST_LED_PIN_LIST;
+#endif
+
+#ifdef LED_MATRIX_ENABLE
+#    define LED_DRIVER led_matrix_driver
+#    define LED_INDICATORS_KB led_matrix_indicators_kb
+#    define LED_INDICATORS_USER led_matrix_indicators_user
+#    define LED_NONE_INDICATORS_KB led_matrix_none_indicators_kb
+#    define SET_ALL_LED_OFF() led_matrix_set_value_all(0)
+#    define SET_LED_OFF(idx) led_matrix_set_value(idx, 0)
+#    define SET_LED_ON(idx) led_matrix_set_value(idx, 255)
+#    define SET_LED_BT(idx) led_matrix_set_value(idx, 255)
+#    define SET_LED_LOW_BAT(idx) led_matrix_set_value(idx, 255)
+#    define LED_DRIVER_IS_ENABLED led_matrix_is_enabled
+#    define LED_DRIVER_EECONFIG_RELOAD() \
+        eeprom_read_block(&led_matrix_eeconfig, EECONFIG_LED_MATRIX, sizeof(led_matrix_eeconfig)); \
+        if (!led_matrix_eeconfig.mode) { \
+            eeconfig_update_led_matrix_default(); \
+        }
+#    define LED_DRIVER_ALLOW_SHUTDOWN led_matrix_driver_allow_shutdown
+#    define LED_DRIVER_ENABLE_NOEEPROM led_matrix_enable_noeeprom
+#    define LED_DRIVER_DISABLE_NOEEPROM led_matrix_disable_noeeprom
+#    define LED_DRIVER_DISABLE_TIMEOUT_SET led_matrix_disable_timeout_set
+#    define LED_DRIVER_DISABLE_TIME_RESET led_matrix_disable_time_reset
+#endif
+
+#ifdef RGB_MATRIX_ENABLE
+#    define LED_DRIVER rgb_matrix_driver
+#    define LED_INDICATORS_KB rgb_matrix_indicators_kb
+#    define LED_INDICATORS_USER rgb_matrix_indicators_user
+#    define LED_NONE_INDICATORS_KB rgb_matrix_none_indicators_kb
+#    define SET_ALL_LED_OFF() rgb_matrix_set_color_all(0, 0, 0)
+#    define SET_LED_OFF(idx) rgb_matrix_set_color(idx, 0, 0, 0)
+#    define SET_LED_ON(idx) rgb_matrix_set_color(idx, 255, 255, 255)
+#    define SET_LED_BT(idx) rgb_matrix_set_color(idx, 0, 0, 255)
+#    define SET_LED_LOW_BAT(idx) rgb_matrix_set_color(idx, 255, 0, 0)
+#    define LED_DRIVER_IS_ENABLED rgb_matrix_is_enabled
+#    define LED_DRIVER_EECONFIG_RELOAD() \
+        eeprom_read_block(&rgb_matrix_config, EECONFIG_RGB_MATRIX, sizeof(rgb_matrix_config)); \
+        if (!rgb_matrix_config.mode) {  \
+            eeconfig_update_rgb_matrix_default();  \
+        }
+#    define LED_DRIVER_ALLOW_SHUTDOWN rgb_matrix_driver_allow_shutdown
+#    define LED_DRIVER_ENABLE_NOEEPROM rgb_matrix_enable_noeeprom
+#    define LED_DRIVER_DISABLE_NOEEPROM rgb_matrix_disable_noeeprom
+#    define LED_DRIVER_DISABLE_TIMEOUT_SET rgb_matrix_disable_timeout_set
+#    define LED_DRIVER_DISABLE_TIME_RESET rgb_matrix_disable_time_reset
+#endif
+void indicator_init(void) {
+    memset(&indicator_config, 0, sizeof(indicator_config));
+
+#ifdef HOST_LED_PIN_LIST
+    for (uint8_t i = 0; i < HOST_DEVICES_COUNT; i++) {
+        setPinOutput(host_led_pin_list[i]);
+        writePin(host_led_pin_list[i], !HOST_LED_PIN_ON_STATE);
+    }
+#endif
+
+#ifdef BAT_LOW_LED_PIN
+    setPinOutput(BAT_LOW_LED_PIN);
+    writePin(BAT_LOW_LED_PIN, !BAT_LOW_LED_PIN_ON_STATE);
+#endif
+}
+
+#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
+void indicator_enable(void) {
+    if (!LED_DRIVER_IS_ENABLED()) {
+        LED_DRIVER_ENABLE_NOEEPROM();
+    }
+}
+
+inline void indicator_disable(void) {
+    LED_DRIVER_DISABLE_NOEEPROM();
+}
+
+void indicator_set_backlit_timeout(uint32_t time) {
+    LED_DRIVER_DISABLE_TIMEOUT_SET(time);
+}
+
+static inline void indicator_reset_backlit_time(void) {
+    LED_DRIVER_DISABLE_TIME_RESET();
+}
+
+bool indicator_is_enabled(void) {
+    return LED_DRIVER_IS_ENABLED();
+}
+
+void indicator_eeconfig_reload(void) {
+    LED_DRIVER_EECONFIG_RELOAD();
+}
+
+#endif
+
+bool indicator_is_running(void) {
+    return
+#if defined(BAT_LOW_LED_PIN) || defined(BAT_LOW_LED_PIN_STATE)
+        bat_low_blink_duration ||
+#endif
+#if defined(LOW_BAT_IND_INDEX)
+        bat_low_ind_state ||
+#endif
+        !!indicator_config.value;
+}
+
+static void indicator_timer_cb(void *arg) {
+    if (*(indicator_type_t *)arg != INDICATOR_LAST) type = *(indicator_type_t *)arg;
+
+    bool time_up = false;
+    switch (type) {
+        case INDICATOR_NONE:
+            break;
+        case INDICATOR_OFF:
+            next_period = 0;
+            time_up     = true;
+            break;
+
+        case INDICATOR_ON:
+            if (indicator_config.value) {
+                if (indicator_config.elapsed == 0) {
+                    indicator_config.value |= LED_ON;
+
+                    if (indicator_config.duration) {
+                        indicator_config.elapsed += indicator_config.duration;
+                    }
+                } else
+                    time_up = true;
+            }
+            break;
+
+        case INDICATOR_ON_OFF:
+            if (indicator_config.value) {
+                if (indicator_config.elapsed == 0) {
+                    indicator_config.value |= LED_ON;
+                    next_period = indicator_config.on_time;
+                } else {
+                    indicator_config.value = indicator_config.value & 0x0F;
+                    next_period            = indicator_config.duration - indicator_config.on_time;
+                }
+
+                if ((indicator_config.duration == 0 || indicator_config.elapsed <= indicator_config.duration) && next_period != 0) {
+                    indicator_config.elapsed += next_period;
+                } else {
+                    time_up = true;
+                }
+            }
+            break;
+
+        case INDICATOR_BLINK:
+            if (indicator_config.value) {
+                if (indicator_config.value & LED_ON) {
+                    indicator_config.value = indicator_config.value & 0x0F;
+                    next_period            = indicator_config.off_time;
+                } else {
+                    indicator_config.value |= LED_ON;
+                    next_period = indicator_config.on_time;
+                }
+
+                if ((indicator_config.duration == 0 || indicator_config.elapsed <= indicator_config.duration) && next_period != 0) {
+                    indicator_config.elapsed += next_period;
+                } else {
+                    time_up = true;
+                }
+            }
+            break;
+        default:
+            time_up = true;
+
+            next_period = 0;
+            break;
+    }
+
+#ifdef HOST_LED_PIN_LIST
+    if (indicator_config.value) {
+        uint8_t idx = (indicator_config.value & 0x0F) - 1;
+
+        if (idx < HOST_DEVICES_COUNT) {
+            if ((indicator_config.value & 0x80) && !time_up) {
+               writePin(host_led_pin_list[idx], HOST_LED_PIN_ON_STATE);
+            } else {
+               writePin(host_led_pin_list[idx], !HOST_LED_PIN_ON_STATE);
+            }
+        }
+    }
+#endif
+
+    if (time_up) {
+        /* Set indicator to off on timeup, avoid keeping light up until next update in raindrop effect */
+        indicator_config.value = indicator_config.value & 0x0F;
+#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
+        LED_INDICATORS_KB();
+#endif
+        indicator_config.value = 0;
+    }
+
+    if (indicator_config.value == 0) {
+        indicator_eeconfig_reload();
+        if (!LED_DRIVER_IS_ENABLED()) indicator_disable();
+    }
+}
+
+void indicator_set(bluetooth_state_t state, uint8_t host_index) {
+    if (get_transport() != TRANSPORT_BLUETOOTH) return;
+    dprintf("indicator set: %d, %d\n", state, host_index);
+
+    static uint8_t current_state = 0;
+    static uint8_t current_host  = 0;
+
+    bool host_index_changed = false;
+    if (current_host != host_index && state != BLUETOOTH_DISCONNECTED) {
+        host_index_changed = true;
+        current_host       = host_index;
+    }
+
+    if (current_state != state || host_index_changed) {
+        current_state = state;
+    } else {
+        return;
+    }
+
+    indicator_timer_buffer = sync_timer_read32();
+
+    /* Turn on backlight mode for indicator */
+    indicator_enable();
+    indicator_reset_backlit_time();
+
+    switch (state) {
+        case BLUETOOTH_DISCONNECTED:
+#ifdef HOST_LED_PIN_LIST
+            writePin(host_led_pin_list[host_index - 1], !HOST_LED_PIN_ON_STATE);
+#endif
+            INDICATOR_SET(disconnected);
+            indicator_config.value = (indicator_config.type == INDICATOR_NONE) ? 0 : host_index;
+            indicator_timer_cb((void *)&indicator_config.type);
+
+            if (battery_is_critical_low()) {
+                indicator_set_backlit_timeout(1000);
+            } else {
+                /* Set timer so that user has chance to turn on the backlight when is off */
+                indicator_set_backlit_timeout(DECIDE_TIME(DISCONNECTED_BACKLIGHT_DISABLE_TIMEOUT * 1000, indicator_config.duration));
+            }
+            break;
+
+        case BLUETOOTH_CONNECTED:
+            if (indicator_state != BLUETOOTH_CONNECTED) {
+                INDICATOR_SET(connected);
+                indicator_config.value = (indicator_config.type == INDICATOR_NONE) ? 0 : host_index;
+                indicator_timer_cb((void *)&indicator_config.type);
+            }
+            indicator_set_backlit_timeout(DECIDE_TIME(CONNECTED_BACKLIGHT_DISABLE_TIMEOUT * 1000, indicator_config.duration));
+            break;
+
+        case BLUETOOTH_PARING:
+            INDICATOR_SET(pairing);
+            indicator_config.value = (indicator_config.type == INDICATOR_NONE) ? 0 : LED_ON | host_index;
+            indicator_timer_cb((void *)&indicator_config.type);
+            indicator_set_backlit_timeout(DECIDE_TIME(DISCONNECTED_BACKLIGHT_DISABLE_TIMEOUT * 1000, indicator_config.duration));
+            break;
+
+        case BLUETOOTH_RECONNECTING:
+            INDICATOR_SET(reconnecting);
+            indicator_config.value = (indicator_config.type == INDICATOR_NONE) ? 0 : LED_ON | host_index;
+            indicator_timer_cb((void *)&indicator_config.type);
+            indicator_set_backlit_timeout(DECIDE_TIME(DISCONNECTED_BACKLIGHT_DISABLE_TIMEOUT * 1000, indicator_config.duration));
+            break;
+
+        case BLUETOOTH_SUSPEND:
+            INDICATOR_SET(disconnected);
+            indicator_config.value = (indicator_config.type == INDICATOR_NONE) ? 0 : host_index;
+            indicator_timer_cb((void *)&indicator_config.type);
+            indicator_set_backlit_timeout(100);
+            break;
+
+        default:
+            break;
+    }
+
+    indicator_state = state;
+}
+
+void indicator_stop(void) {
+    indicator_config.value = 0;
+    indicator_eeconfig_reload();
+
+    if (indicator_is_enabled()) {
+        indicator_enable();
+    } else {
+        indicator_disable();
+    }
+}
+
+#if defined(BAT_LOW_LED_PIN) || defined(BAT_LOW_LED_PIN_STATE)
+void indicator_battery_low_enable(bool enable) {
+    if (enable) {
+        if (bat_low_blink_duration == 0) {
+            bat_low_blink_duration = bat_low_pin_indicator = sync_timer_read32() | 1;
+        } else
+            bat_low_blink_duration = sync_timer_read32() | 1;
+    } else {
+#    if defined(BAT_LOW_LED_PIN)
+        writePin(BAT_LOW_LED_PIN, !BAT_LOW_LED_PIN_ON_STATE);
+#    else
+        bat_low_led_pin_state = false;
+#    endif
+    }
+}
+#endif
+
+#if defined(LOW_BAT_IND_INDEX)
+void indicator_battery_low_backlit_enable(bool enable) {
+    if (enable) {
+        uint32_t t = rtc_timer_read_ms();
+        /* Check overflow */
+        if (rtc_time > t) {
+            if (bat_low_ind_state == 0)
+                rtc_time = t; // Update rtc_time if indicating is not running
+            else {
+                rtc_time += t;
+            }
+        }
+        /* Indicating at first time or after the interval */
+        if ((rtc_time == 0 || t - rtc_time > LOW_BAT_LED_TRIG_INTERVAL) && bat_low_ind_state == 0) {
+            bat_low_backlit_indicator = enable ? (timer_read32() == 0 ? 1 : timer_read32()) : 0;
+            rtc_time                  = rtc_timer_read_ms();
+            bat_low_ind_state         = 1;
+
+            indicator_enable();
+        }
+    } else {
+        rtc_time          = 0;
+        bat_low_ind_state = 0;
+
+        indicator_eeconfig_reload();
+        if (!LED_DRIVER_IS_ENABLED()) indicator_disable();
+    }
+}
+#endif
+
+void indicator_battery_low(void) {
+#if defined(BAT_LOW_LED_PIN) || defined(BAT_LOW_LED_PIN_STATE)
+    if (bat_low_pin_indicator && sync_timer_elapsed32(bat_low_pin_indicator) > (LOW_BAT_LED_BLINK_PERIOD)) {
+#    if defined(BAT_LOW_LED_PIN)
+        togglePin(BAT_LOW_LED_PIN);
+#    else
+        bat_low_led_pin_state = !bat_low_led_pin_state;
+#    endif
+        bat_low_pin_indicator = sync_timer_read32() | 1;
+        // Turn off low battery indication if we reach the duration
+#    if defined(BAT_LOW_LED_PIN)
+        if (sync_timer_elapsed32(bat_low_blink_duration) > LOW_BAT_LED_BLINK_DURATION && palReadLine(BAT_LOW_LED_PIN) != BAT_LOW_LED_PIN_ON_STATE) {
+#    elif defined(BAT_LOW_LED_PIN_STATE)
+        if (sync_timer_elapsed32(bat_low_blink_duration) > LOW_BAT_LED_BLINK_DURATION) {
+#    endif
+            bat_low_blink_duration = bat_low_pin_indicator = 0;
+        }
+    }
+#endif
+#if defined(LOW_BAT_IND_INDEX)
+    if (bat_low_ind_state) {
+        if ((bat_low_ind_state & 0x0F) <= (LOW_BAT_LED_BLINK_TIMES) && sync_timer_elapsed32(bat_low_backlit_indicator) > (LOW_BAT_LED_BLINK_PERIOD)) {
+            if (bat_low_ind_state & 0x80) {
+                bat_low_ind_state &= 0x7F;
+                bat_low_ind_state++;
+            } else {
+                bat_low_ind_state |= 0x80;
+            }
+
+            bat_low_backlit_indicator = sync_timer_read32() == 0 ? 1 : sync_timer_read32();
+
+            /*  Restore backligth state */
+            if ((bat_low_ind_state & 0x0F) > (LOW_BAT_LED_BLINK_TIMES)) {
+#    if defined(NUM_LOCK_INDEX) || defined(CAPS_LOCK_INDEX) || defined(SCROLL_LOCK_INDEX) || defined(COMPOSE_LOCK_INDEX) || defined(KANA_LOCK_INDEX)
+                if (LED_DRIVER_ALLOW_SHUTDOWN())
+#    endif
+                    indicator_disable();
+            }
+        } else if ((bat_low_ind_state & 0x0F) > (LOW_BAT_LED_BLINK_TIMES)) {
+            bat_low_ind_state = 0;
+        }
+    }
+#endif
+}
+
+void indicator_task(void) {
+    bat_level_animiation_task();
+
+    if (indicator_config.value && sync_timer_elapsed32(indicator_timer_buffer) >= next_period) {
+        indicator_timer_cb((void *)&type);
+        indicator_timer_buffer = sync_timer_read32();
+    }
+
+    indicator_battery_low();
+}
+
+#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
+__attribute__((weak)) void os_state_indicate(void) {
+#    if defined(NUM_LOCK_INDEX)
+    if (host_keyboard_led_state().num_lock) {
+        SET_LED_ON(NUM_LOCK_INDEX);
+    }
+#    endif
+#    if defined(CAPS_LOCK_INDEX)
+    if (host_keyboard_led_state().caps_lock) {
+#        if defined(DIM_CAPS_LOCK)
+        SET_LED_OFF(CAPS_LOCK_INDEX);
+#        else
+        SET_LED_ON(CAPS_LOCK_INDEX);
+#        endif
+    }
+#    endif
+#    if defined(SCROLL_LOCK_INDEX)
+    if (host_keyboard_led_state().scroll_lock) {
+        SET_LED_ON(SCROLL_LOCK_INDEX);
+    }
+#    endif
+#    if defined(COMPOSE_LOCK_INDEX)
+    if (host_keyboard_led_state().compose) {
+        SET_LED_ON(COMPOSE_LOCK_INDEX);
+    }
+#    endif
+#    if defined(KANA_LOCK_INDEX)
+    if (host_keyboard_led_state().kana) {
+        SET_LED_ON(KANA_LOCK_INDEX);
+    }
+#    endif
+}
+
+bool LED_INDICATORS_KB(void) {
+    if (!LED_INDICATORS_USER()) {
+        return false;
+    }
+
+    if (get_transport() == TRANSPORT_BLUETOOTH) {
+        /* Prevent backlight flash caused by key activities */
+        if (battery_is_critical_low()) {
+            SET_ALL_LED_OFF();
+             return false;
+        }
+
+#    if (defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)) && defined(LOW_BAT_IND_INDEX)
+        if (battery_is_empty()) SET_ALL_LED_OFF();
+        if (bat_low_ind_state && (bat_low_ind_state & 0x0F) <= LOW_BAT_LED_BLINK_TIMES) {
+            if (bat_low_ind_state & 0x80)
+                SET_LED_LOW_BAT(LOW_BAT_IND_INDEX);
+            else
+                SET_LED_OFF(LOW_BAT_IND_INDEX);
+        }
+#    endif
+        if (bat_level_animiation_actived()) {
+            bat_level_animiation_indicate();
+        }
+        static uint8_t last_host_index = 0xFF;
+
+        if (indicator_config.value) {
+            uint8_t host_index = indicator_config.value & 0x0F;
+
+            if (indicator_config.highlight) {
+                SET_ALL_LED_OFF();
+            } else if (last_host_index != host_index) {
+                SET_LED_OFF(host_led_matrix_list[last_host_index - 1]);
+                last_host_index = host_index;
+            }
+
+            if (indicator_config.value & 0x80) {
+                SET_LED_BT(host_led_matrix_list[host_index - 1]);
+            } else {
+                SET_LED_OFF(host_led_matrix_list[host_index - 1]);
+            }
+        } else
+            os_state_indicate();
+
+    } else
+        os_state_indicate();
+
+   return false;
+}
+
+bool led_update_kb(led_t led_state) {
+    bool res = led_update_user(led_state);
+    if (res) {
+        led_update_ports(led_state);
+
+        if (!LED_DRIVER_IS_ENABLED()) {
+    #    if defined(LED_MATRIX_DRIVER_SHUTDOWN_ENABLE) || defined(RGB_MATRIX_DRIVER_SHUTDOWN_ENABLE)
+            LED_DRIVER.exit_shutdown();
+    #    endif
+            SET_ALL_LED_OFF();
+            os_state_indicate();
+            LED_DRIVER.flush();
+    #    if defined(LED_MATRIX_DRIVER_SHUTDOWN_ENABLE) || defined(RGB_MATRIX_DRIVER_SHUTDOWN_ENABLE)
+            if (LED_DRIVER_ALLOW_SHUTDOWN()) LED_DRIVER.shutdown();
+    #    endif
+        }
+    }
+
+    return res;
+}
+
+void LED_NONE_INDICATORS_KB(void) {
+    os_state_indicate();
+}
+
+#    if defined(LED_MATRIX_DRIVER_SHUTDOWN_ENABLE) || defined(RGB_MATRIX_DRIVER_SHUTDOWN_ENABLE)
+bool LED_DRIVER_ALLOW_SHUTDOWN(void) {
+#        if defined(NUM_LOCK_INDEX)
+    if (host_keyboard_led_state().num_lock) return false;
+#        endif
+#        if defined(CAPS_LOCK_INDEX) && !defined(DIM_CAPS_LOCK)
+    if (host_keyboard_led_state().caps_lock) return false;
+#        endif
+#        if defined(SCROLL_LOCK_INDEX)
+    if (host_keyboard_led_state().scroll_lock) return false;
+#        endif
+#        if defined(COMPOSE_LOCK_INDEX)
+    if (host_keyboard_led_state().compose) return false;
+#        endif
+#        if defined(KANA_LOCK_INDEX)
+    if (host_keyboard_led_state().kana) return false;
+#        endif
+    return true;
+}
+#    endif
+
+#endif

keyboards/keychron/bluetooth/indicator.h

@@ -0,0 +1,118 @@
+/* Copyright 2022 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "config.h"
+#include "bluetooth.h"
+
+/* Indication of pairing */
+#ifndef INDICATOR_CONFIG_PARING
+#    define INDICATOR_CONFIG_PARING {INDICATOR_BLINK, 1000, 1000, 0, true, 0};
+#endif
+
+/* Indication on Connected */
+#ifndef INDICATOR_CONFIG_CONNECTD
+#    define INDICATOR_CONFIG_CONNECTD {INDICATOR_ON_OFF, 2000, 250, 2000, true, 0};
+#endif
+
+/* Reconnecting indication */
+#ifndef INDICATOR_CONFIG_RECONNECTING
+#    define INDICATOR_CONFIG_RECONNECTING {INDICATOR_BLINK, 100, 100, 600, true, 0};
+#endif
+
+/* Disconnected indication */
+#ifndef INDICATOR_CONFIG_DISCONNECTED
+#    define INDICATOR_CONFIG_DISCONNECTED {INDICATOR_NONE, 100, 100, 600, false, 0};
+#endif
+
+/* Uint: Second */
+#ifndef DISCONNECTED_BACKLIGHT_DISABLE_TIMEOUT
+#    define DISCONNECTED_BACKLIGHT_OFF_DELAY_TIME 40
+#endif
+
+/* Uint: Second, the timer restarts on key activities. */
+#ifndef CONNECTED_BACKLIGHT_DISABLE_TIMEOUT
+#    define CONNECTED_BACKLIGHT_OFF_DELAY_TIME 600
+#endif
+
+#if defined(BAT_LOW_LED_PIN) || defined(BAT_LOW_LED_PIN_STATE)
+/* Uint: ms */
+#    ifndef LOW_BAT_LED_BLINK_PERIOD
+#        define LOW_BAT_LED_BLINK_PERIOD 1000
+#    endif
+
+#    ifndef LOW_BAT_LED_BLINK_DURATION
+#        define LOW_BAT_LED_BLINK_DURATION 10000
+#    endif
+#endif
+
+#ifdef LOW_BAT_IND_INDEX
+/* Uint: ms */
+#    ifndef LOW_BAT_LED_BLINK_PERIOD
+#        define LOW_BAT_LED_BLINK_PERIOD 500
+#    endif
+
+#    ifndef LOW_BAT_LED_BLINK_TIMES
+#        define LOW_BAT_LED_BLINK_TIMES 3
+#    endif
+
+#    ifndef LOW_BAT_LED_TRIG_INTERVAL
+#        define LOW_BAT_LED_TRIG_INTERVAL 30000
+#    endif
+#endif
+
+#if BT_HOST_MAX_COUNT > 6
+#    pragma error("HOST_COUNT max value is 6")
+#endif
+
+typedef enum { INDICATOR_NONE, INDICATOR_OFF, INDICATOR_ON, INDICATOR_ON_OFF, INDICATOR_BLINK, INDICATOR_LAST } indicator_type_t;
+
+typedef struct PACKED {
+    indicator_type_t type;
+    uint32_t         on_time;
+    uint32_t         off_time;
+    uint32_t         duration;
+    bool             highlight;
+    uint8_t          value;
+    uint32_t         elapsed;
+} indicator_config_t;
+
+typedef struct PACKED {
+    uint8_t value;
+    bool    saved;
+} backlight_state_t;
+
+void indicator_init(void);
+void indicator_set(bluetooth_state_t state, uint8_t host_index);
+void indicator_backlight_timer_reset(bool enable);
+bool indicator_hook_key(uint16_t keycode);
+void indicator_enable(void);
+void indicator_disable(void);
+void indicator_stop(void);
+void indicator_eeconfig_reload(void);
+bool indicator_is_enabled(void);
+bool indicator_is_running(void);
+void os_state_indicate(void);
+
+#ifdef BAT_LOW_LED_PIN
+void indicator_battery_low_enable(bool enable);
+#endif
+#if defined(LOW_BAT_IND_INDEX)
+void indicator_battery_low_backlit_enable(bool enable);
+#endif
+
+void indicator_task(void);

keyboards/keychron/bluetooth/lpm.c

@@ -0,0 +1,92 @@
+/* Copyright 2022 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+/******************************************************************************
+ *
+ *  Filename:      lpm.c
+ *
+ *  Description:   Contains low power mode implementation
+ *
+ ******************************************************************************/
+
+#include "quantum.h"
+#if defined(PROTOCOL_CHIBIOS)
+#    include <usb_main.h>
+#endif
+#include "bluetooth.h"
+#include "indicator.h"
+#include "lpm.h"
+#include "transport.h"
+#include "battery.h"
+
+extern matrix_row_t          matrix[MATRIX_ROWS];
+extern bluetooth_transport_t bluetooth_transport;
+
+static uint32_t     lpm_timer_buffer;
+static bool         lpm_time_up               = false;
+static matrix_row_t empty_matrix[MATRIX_ROWS] = {0};
+
+void lpm_init(void) {
+#ifdef USB_POWER_SENSE_PIN
+#    if (USB_POWER_CONNECTED_LEVEL == 0)
+    setPinInputHigh(USB_POWER_SENSE_PIN);
+#    else
+    setPinInputLow(USB_POWER_SENSE_PIN);
+#    endif
+#endif
+    lpm_timer_reset();
+}
+
+inline void lpm_timer_reset(void) {
+    lpm_time_up      = false;
+    lpm_timer_buffer = sync_timer_read32();
+}
+
+void lpm_timer_stop(void) {
+    lpm_time_up      = false;
+    lpm_timer_buffer = 0;
+}
+
+static inline bool lpm_any_matrix_action(void) { return memcmp(matrix, empty_matrix, sizeof(empty_matrix)); }
+
+/* Implement of entering low power mode and wakeup varies per mcu or platform */
+__attribute__((weak)) void enter_power_mode(pm_t mode) {}
+
+__attribute__((weak)) bool usb_power_connected(void) {
+#ifdef USB_POWER_SENSE_PIN
+    return readPin(USB_POWER_SENSE_PIN) == USB_POWER_CONNECTED_LEVEL;
+#endif
+
+    return true;
+}
+
+void lpm_task(void) {
+    if (!lpm_time_up && sync_timer_elapsed32(lpm_timer_buffer) > RUN_MODE_PROCESS_TIME) {
+        lpm_time_up      = true;
+        lpm_timer_buffer = 0;
+    }
+
+    if (get_transport() == TRANSPORT_BLUETOOTH && lpm_time_up && !indicator_is_running()
+#ifdef LED_MATRIX_ENABLE
+        && led_matrix_is_driver_shutdown()
+#endif
+#ifdef RGB_MATRIX_ENABLE
+        && rgb_matrix_is_driver_shutdown()
+#endif
+        && !lpm_any_matrix_action() && !battery_power_on_sample())
+
+        enter_power_mode(LOW_POWER_MODE);
+}

keyboards/keychron/bluetooth/lpm.h

@@ -0,0 +1,30 @@
+/* Copyright 2022 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#ifndef RUN_MODE_PROCESS_TIME
+#    define RUN_MODE_PROCESS_TIME 1000
+#endif
+
+typedef enum { PM_RUN, PM_LOW_POWER_RUN, PM_SLEEP, PM_LOW_POWER_SLEEP, PM_STOP0, PM_STOP1, PM_STOP2, PM_STANDBY_WITH_RAM, PM_STANDBY, PM_SHUTDOWN } pm_t;
+
+void lpm_init(void);
+void lpm_timer_reset(void);
+void lpm_timer_stop(void);
+bool usb_power_connected(void);
+void enter_power_mode(pm_t mode);
+void lpm_task(void);

keyboards/keychron/bluetooth/lpm_stm32l432.c

@@ -0,0 +1,330 @@
+/* Copyright 2022 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+/******************************************************************************
+ *
+ *  Filename:      lpm_stm32l432.c
+ *
+ *  Description:   Contains low power mode implementation
+ *
+ ******************************************************************************/
+
+#include "quantum.h"
+#include <usb_main.h>
+#include "bluetooth.h"
+#include "indicator.h"
+#include "lpm.h"
+#include "transport.h"
+#include "battery.h"
+#include "report_buffer.h"
+#include "stm32_bd.inc"
+#include "debounce.h"
+
+extern pin_t                 row_pins[MATRIX_ROWS];
+extern void                  select_all_cols(void);
+extern bluetooth_transport_t bluetooth_transport;
+
+static pm_t power_mode = PM_RUN;
+
+static inline void stm32_clock_fast_init(void);
+
+bool lpm_set(pm_t mode) {
+    switch (mode) {
+#ifdef LOW_POWER_RUN_MODE_ENABLE
+        case PM_RUN:
+            if (power_mode != PM_LOW_POWER_RUN)) return;
+            /* Set main regulator */
+            PWR->CR1 &= ~PWR_CR1_LPR;
+            while (PWR->SR2 & PWR_SR2_REGLPF)
+                ;
+            // TODO: restore sysclk
+            return true;
+            // break;
+
+        case PM_LOW_POWER_RUN:
+            if (power_mode != PM_RUN) return;
+
+            // FLASH->ACR |= FLASH_ACR_RUN_PD;   // Optional
+            // TODO: Decrease sysclk below 2 MHz
+            PWR->CR1 |= PWR_CR1_LPR;
+            return true;
+            // break;
+#endif
+        case PM_SLEEP:
+            /* Wake source: Any interrupt or event */
+            if (power_mode != PM_RUN) return false;
+
+            SCB->SCR &= ~SCB_SCR_SLEEPDEEP_Msk;
+            break;
+
+#ifdef LOW_POWER_RUN_MODE_ENABLE
+        case PM_LOW_POWER_SLEEP:
+            /* Wake source: Any interrupt or event */
+            if (power_mode != PM_LOW_POWER_RUN) return; /* Can only transit from PM_LOW_POWER_RUN */
+
+            SCB->SCR &= ~SCB_SCR_SLEEPDEEP_Msk;
+            __WFI();
+            exit_low_power_mode();
+            break;
+#endif
+        case PM_STOP0:
+            /* Wake source: Reset pin, all I/Os, BOR, PVD, PVM, RTC, LCD, IWDG,
+               COMPx, USARTx, LPUART1, I2Cx, LPTIMx, USB, SWPMI */
+            if (power_mode != PM_RUN) return false;
+
+            SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk;
+            PWR->CR1 |= PWR_CR1_LPMS_STOP0;
+            break;
+
+        case PM_STOP1:
+            /* Wake source: Reset pin, all I/Os, BOR, PVD, PVM, RTC, LCD, IWDG,
+               COMPx, USARTx, LPUART1, I2Cx, LPTIMx, USB, SWPMI */
+            if (power_mode != PM_RUN && power_mode != PM_LOW_POWER_RUN) return false;
+
+            SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk;
+            PWR->CR1 |= PWR_CR1_LPMS_STOP1;
+            break;
+
+        case PM_STOP2:
+            /* Wake source: Reset pin, all I/Os, BOR, PVD, PVM, RTC, LCD, IWDG,
+               COMPx (x=1, 2), I2C3, LPUART1, LPTIM1, LPTIM2 */
+            if (power_mode != PM_RUN) return false;
+
+            SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk;
+            PWR->CR1 |= PWR_CR1_LPMS_STOP2;
+            break;
+
+        case PM_STANDBY_WITH_RAM:
+            /* Wake source: Reset, 5 I/O(PA0, PC13, PE6, PA2, PC5), BOR, RTC, IWDG */
+            if (power_mode != PM_RUN && power_mode != PM_LOW_POWER_RUN) return false;
+
+            SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk;
+            PWR->CR1 |= PWR_CR1_LPMS_STANDBY;
+            PWR->CR3 |= PWR_CR3_RRS;
+            break;
+
+        case PM_STANDBY:
+            /* Wake source: Reset, 2 I/O(PA0, PA2) in STM32L432Kx,, BOR, RTC, IWDG */
+            if (power_mode != PM_RUN && power_mode != PM_LOW_POWER_RUN) return false;
+
+            SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk;
+            PWR->CR1 |= PWR_CR1_LPMS_STANDBY;
+            PWR->CR3 &= ~PWR_CR3_RRS;
+            break;
+
+        case PM_SHUTDOWN:
+            /* Wake source: Reset, 2 I/O(PA0, PA2) in STM32L432Kx, RTC */
+            if (power_mode != PM_RUN && power_mode != PM_LOW_POWER_RUN) return false;
+
+            SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk;
+            PWR->CR1 |= PWR_CR1_LPMS_SHUTDOWN;
+            break;
+
+        default:
+            return false;
+    }
+
+    return true;
+}
+
+static inline void enter_low_power_mode_prepare(void) {
+#if defined(KEEP_USB_CONNECTION_IN_BLUETOOTH_MODE)
+    /* Usb unit is actived and running, stop and disconnect first */
+    usbStop(&USBD1);
+    usbDisconnectBus(&USBD1);
+
+    /* Isolate USB to save power.*/
+    PWR->CR2 &= ~PWR_CR2_USV; /*PWR_CR2_USV is available on STM32L4x2xx and STM32L4x3xx devices only. */
+#endif
+
+    palEnableLineEvent(BLUETOOTH_INT_INPUT_PIN, PAL_EVENT_MODE_FALLING_EDGE);
+    palEnableLineEvent(USB_POWER_SENSE_PIN, PAL_EVENT_MODE_BOTH_EDGES);
+
+    /* Enable key matrix wake up */
+    pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
+
+    for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
+        if (row_pins[x] != NO_PIN) {
+            palEnableLineEvent(row_pins[x], PAL_EVENT_MODE_BOTH_EDGES);
+        }
+    }
+
+    select_all_cols();
+
+#if defined(DIP_SWITCH_PINS)
+#    define NUMBER_OF_DIP_SWITCHES (sizeof(dip_switch_pad) / sizeof(pin_t))
+    static pin_t dip_switch_pad[] = DIP_SWITCH_PINS;
+
+    for (uint8_t i = 0; i < NUMBER_OF_DIP_SWITCHES; i++) {
+        setPinInputLow(dip_switch_pad[i]);
+    }
+#endif
+}
+
+static inline void lpm_wakeup(void) {
+    chSysLock();
+    stm32_clock_fast_init();
+    chSysUnlock();
+
+    if (bluetooth_transport.init) bluetooth_transport.init(true);
+
+    chSysLock();
+    SCB->SCR &= ~SCB_SCR_SLEEPDEEP_Msk;
+
+    PWR->SCR |= PWR_SCR_CWUF;
+    PWR->SCR |= PWR_SCR_CSBF;
+
+    /* TIMx is disable during stop/standby/sleep mode, init after wakeup */
+    stInit();
+    timer_init();
+    chSysUnlock();
+    battery_init();
+
+    /* Disable all wake up pins */
+    for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
+        if (row_pins[x] != NO_PIN) {
+            palDisableLineEvent(row_pins[x]);
+        }
+    }
+    palDisableLineEvent(BLUETOOTH_INT_INPUT_PIN);
+
+#ifdef USB_POWER_SENSE_PIN
+    palDisableLineEvent(USB_POWER_SENSE_PIN);
+
+#    if defined(KEEP_USB_CONNECTION_IN_BLUETOOTH_MODE)
+    if (usb_power_connected()) {
+        hsi48_init();
+        /* Remove USB isolation.*/
+        // PWR->CR2 |= PWR_CR2_USV; /* PWR_CR2_USV is available on STM32L4x2xx and STM32L4x3xx devices only. */
+        usb_power_connect();
+        usb_start(&USBD1);
+    }
+#    endif
+
+#endif
+
+#if defined(DIP_SWITCH_PINS)
+    dip_switch_init();
+    dip_switch_read(true);
+#endif
+}
+
+/*
+ * NOTE:
+ * 1. Shall not use PM_LOW_POWER_RUN, PM_LOW_POWER_SLEEP, due to PM_LOW_POWER_RUN
+ *    need to decrease system clock below 2 MHz. Dynamic clock is not yet supported
+ *    for STM32L432xx in latest ChibiOS 21.6.0 so far.
+ * 2. Care must be taken to use PM_STANDBY_WITH_RAM, PM_STANDBY, PM_SHUTDOWN due to
+ *    limited wake source, thus can't be waken via keyscan. PM_SHUTDOWN need LSE.
+ * 3. Reference from AN4621: STM32L4 and STM32L4+ ultra-low-power features overview
+ *    for detail wake source
+ */
+
+void enter_power_mode(pm_t mode) {
+#if defined(KEEP_USB_CONNECTION_IN_BLUETOOTH_MODE)
+    /* Don't enter low power mode if attached to the host */
+    if (mode > PM_SLEEP && usb_power_connected()) return;
+#endif
+
+    if (!lpm_set(mode)) return;
+    enter_low_power_mode_prepare();
+
+    //    __DSB();
+    __WFI();
+    //    __ISB();
+
+    lpm_wakeup();
+    lpm_timer_reset();
+    report_buffer_init();
+
+    /* Call debounce_free() to avoid memory leak as debounce_init() invoked in matrix_init() allocates
+     * new memory when using per row/key debounce
+     */
+    debounce_free();
+    matrix_init();
+    power_mode = PM_RUN;
+}
+
+void usb_power_connect(void) {
+    PWR->CR2 |= PWR_CR2_USV;
+}
+
+void usb_power_disconnect(void) {
+    PWR->CR2 &= ~PWR_CR2_USV;
+}
+
+/*
+ * This is a simplified version of stm32_clock_init() by removing unnecessary clock initlization
+ * code snippet. The original stm32_clock_init() take about 2ms, but ckbt51 sends data via uart
+ * about 200us after wakeup pin is assert, it means that we must get everything ready before data
+ * coming when wakeup pin interrupt of MCU is triggerred.
+ * Here we reduce clock init time to less than 100us.
+ */
+void stm32_clock_fast_init(void) {
+#if !STM32_NO_INIT
+    /* Clocks setup.*/
+    msi_init();   // 6.x us
+    hsi16_init(); // 4.x us
+
+    /* PLLs activation, if required.*/
+    pll_init();
+    pllsai1_init();
+    pllsai2_init();
+    /* clang-format off */
+    /* Other clock-related settings (dividers, MCO etc).*/
+  RCC->CFGR = STM32_MCOPRE | STM32_MCOSEL | STM32_STOPWUCK |
+              STM32_PPRE2  | STM32_PPRE1  | STM32_HPRE;
+    /* CCIPR register initialization, note, must take care of the _OFF
+       pseudo settings.*/
+    {
+    uint32_t ccipr = STM32_DFSDMSEL  | STM32_SWPMI1SEL | STM32_ADCSEL    |
+                     STM32_CLK48SEL  | STM32_LPTIM2SEL | STM32_LPTIM1SEL |
+                     STM32_I2C3SEL   | STM32_I2C2SEL   | STM32_I2C1SEL   |
+                     STM32_UART5SEL  | STM32_UART4SEL  | STM32_USART3SEL |
+                     STM32_USART2SEL | STM32_USART1SEL | STM32_LPUART1SEL;
+/* clang-format on */
+#    if STM32_SAI2SEL != STM32_SAI2SEL_OFF
+        ccipr |= STM32_SAI2SEL;
+#    endif
+#    if STM32_SAI1SEL != STM32_SAI1SEL_OFF
+        ccipr |= STM32_SAI1SEL;
+#    endif
+        RCC->CCIPR = ccipr;
+    }
+
+    /* Set flash WS's for SYSCLK source */
+    if (STM32_FLASHBITS > STM32_MSI_FLASHBITS) {
+        FLASH->ACR = (FLASH->ACR & ~FLASH_ACR_LATENCY_Msk) | STM32_FLASHBITS;
+        while ((FLASH->ACR & FLASH_ACR_LATENCY_Msk) != (STM32_FLASHBITS & FLASH_ACR_LATENCY_Msk)) {
+        }
+    }
+
+    /* Switching to the configured SYSCLK source if it is different from MSI.*/
+#    if (STM32_SW != STM32_SW_MSI)
+    RCC->CFGR |= STM32_SW; /* Switches on the selected clock source.   */
+    /* Wait until SYSCLK is stable.*/
+    while ((RCC->CFGR & RCC_CFGR_SWS) != (STM32_SW << 2))
+        ;
+#    endif
+
+    /* Reduce the flash WS's for SYSCLK source if they are less than MSI WSs */
+    if (STM32_FLASHBITS < STM32_MSI_FLASHBITS) {
+        FLASH->ACR = (FLASH->ACR & ~FLASH_ACR_LATENCY_Msk) | STM32_FLASHBITS;
+        while ((FLASH->ACR & FLASH_ACR_LATENCY_Msk) != (STM32_FLASHBITS & FLASH_ACR_LATENCY_Msk)) {
+        }
+    }
+#endif /* STM32_NO_INIT */
+}

keyboards/keychron/bluetooth/lpm_stm32l432.h

@@ -1,4 +1,4 @@
-/* Copyright 2020 QMK
+/* Copyright 2022 @ lokher (https://www.keychron.com)
  *
  * 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
@@ -16,7 +16,4 @@
 
 #pragma once
 
-#include_next <mcuconf.h>
-
-#undef STM32_I2C_USE_I2C1
-#define STM32_I2C_USE_I2C1 TRUE
+typedef enum { PM_RUN, PM_LOW_POWER_RUN, PM_SLEEP, PM_LOW_POWER_SLEEP, PM_STOP0, PM_STOP1, PM_STOP2, PM_STANDBY_WITH_RAM, PM_STANDBY, PM_SHUTDOWN } pm_t;

keyboards/keychron/bluetooth/report_buffer.c

@@ -0,0 +1,141 @@
+/* Copyright 2022 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "quantum.h"
+#include "report_buffer.h"
+#include "bluetooth.h"
+#include "lpm.h"
+
+/* The report buffer is mainly used to fix key press lost issue of macro
+ * when bluetooth module fifo isn't large enough. The maximun macro
+ * string length is determined by this queue size, and should be
+ * REPORT_BUFFER_QUEUE_SIZE devided by 2 since each character is implemented
+ * by sending a key pressing then a key releasing report.
+ * Please note that it cosume sizeof(report_buffer_t)  * REPORT_BUFFER_QUEUE_SIZE
+ * bytes RAM, with default setting, used RAM size is
+ *        sizeof(report_buffer_t) * 256 = 34* 256  =  8704 bytes
+ */
+#ifndef REPORT_BUFFER_QUEUE_SIZE
+#    define REPORT_BUFFER_QUEUE_SIZE 512
+#endif
+
+extern bluetooth_transport_t bluetooth_transport;
+
+/* report_interval value should be less than bluetooth connection interval because
+ * it takes some time for communicating between mcu and bluetooth module. Carefully
+ * set this value to feed the bt module so that we don't lost the key report nor lost
+ * the anchor point of bluetooth interval. The bluetooth connection interval varies
+ * if BLE is used, invoke report_buffer_set_inverval() to update the value
+ */
+uint8_t report_interval = DEFAULT_REPORT_INVERVAL_MS;
+
+static uint32_t report_timer_buffer = 0;
+uint32_t        retry_time_buffer   = 0;
+report_buffer_t report_buffer_queue[REPORT_BUFFER_QUEUE_SIZE];
+uint16_t         report_buffer_queue_head;
+uint16_t         report_buffer_queue_tail;
+report_buffer_t kb_rpt;
+uint8_t         retry = 0;
+
+void report_buffer_init(void) {
+    // Initialise the report queue
+    memset(&report_buffer_queue, 0, sizeof(report_buffer_queue));
+    report_buffer_queue_head = 0;
+    report_buffer_queue_tail = 0;
+    retry                    = 0;
+    report_timer_buffer      = sync_timer_read32();
+}
+
+bool report_buffer_enqueue(report_buffer_t *report) {
+    uint16_t next = (report_buffer_queue_head + 1) % REPORT_BUFFER_QUEUE_SIZE;
+    if (next == report_buffer_queue_tail) {
+        return false;
+    }
+
+    report_buffer_queue[report_buffer_queue_head] = *report;
+    report_buffer_queue_head                      = next;
+    return true;
+}
+
+inline bool report_buffer_dequeue(report_buffer_t *report) {
+    if (report_buffer_queue_head == report_buffer_queue_tail) {
+        return false;
+    }
+
+    *report                  = report_buffer_queue[report_buffer_queue_tail];
+    report_buffer_queue_tail = (report_buffer_queue_tail + 1) % REPORT_BUFFER_QUEUE_SIZE;
+    return true;
+}
+
+bool report_buffer_is_empty() {
+    return report_buffer_queue_head == report_buffer_queue_tail;
+}
+
+void report_buffer_update_timer(void) {
+    report_timer_buffer = sync_timer_read32();
+}
+
+bool report_buffer_next_inverval(void) {
+    return sync_timer_elapsed32(report_timer_buffer) > report_interval;
+}
+
+void report_buffer_set_inverval(uint8_t interval) {
+    report_interval = interval;
+}
+
+uint8_t report_buffer_get_retry(void) {
+    return retry;
+}
+
+void report_buffer_set_retry(uint8_t times) {
+    retry = times;
+}
+
+void report_buffer_task(void) {
+    if (bluetooth_get_state() == BLUETOOTH_CONNECTED && (!report_buffer_is_empty() || retry) && report_buffer_next_inverval()) {
+        bool pending_data = false;
+
+        if (!retry) {
+            if (report_buffer_dequeue(&kb_rpt) && kb_rpt.type != REPORT_TYPE_NONE) {
+                if (sync_timer_read32() > 2) {
+                    pending_data      = true;
+                    retry             = RETPORT_RETRY_COUNT;
+                    retry_time_buffer = sync_timer_read32();
+                }
+            }
+        } else {
+            if (sync_timer_elapsed32(retry_time_buffer) > 7) {
+                pending_data = true;
+                --retry;
+                retry_time_buffer = sync_timer_read32();
+            }
+        }
+
+        if (pending_data) {
+#if defined(NKRO_ENABLE) && defined(BLUETOOTH_NKRO_ENABLE)
+            if (kb_rpt.type == REPORT_TYPE_NKRO && bluetooth_transport.send_nkro) {
+                bluetooth_transport.send_nkro(&kb_rpt.nkro.mods);
+            } else if (kb_rpt.type == REPORT_TYPE_KB && bluetooth_transport.send_keyboard)
+                bluetooth_transport.send_keyboard(&kb_rpt.keyboard.mods);
+#else
+            if (kb_rpt.type == REPORT_TYPE_KB && bluetooth_transport.send_keyboard) bluetooth_transport.send_keyboard(&kb_rpt.keyboard.mods);
+#endif
+            if (kb_rpt.type == REPORT_TYPE_CONSUMER && bluetooth_transport.send_consumer) bluetooth_transport.send_consumer(kb_rpt.consumer);
+            report_timer_buffer = sync_timer_read32();
+            lpm_timer_reset();
+        }
+    }
+}

keyboards/keychron/bluetooth/report_buffer.h

@@ -0,0 +1,56 @@
+/* Copyright 2022 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "report.h"
+
+/* Default report interval value */
+#ifndef DEFAULT_REPORT_INVERVAL_MS
+#    define DEFAULT_REPORT_INVERVAL_MS 3
+#endif
+
+/* Default report interval value */
+#ifndef RETPORT_RETRY_COUNT
+#    define RETPORT_RETRY_COUNT 30
+#endif
+
+enum {
+    REPORT_TYPE_NONE,
+    REPORT_TYPE_KB,
+    REPORT_TYPE_NKRO,
+    REPORT_TYPE_CONSUMER,
+};
+
+typedef struct {
+    uint8_t type;
+    union {
+        report_keyboard_t keyboard;
+        report_nkro_t     nkro;
+        uint16_t          consumer;
+    };
+} report_buffer_t;
+
+void    report_buffer_init(void);
+bool    report_buffer_enqueue(report_buffer_t *report);
+bool    report_buffer_dequeue(report_buffer_t *report);
+bool    report_buffer_is_empty(void);
+void    report_buffer_update_timer(void);
+bool    report_buffer_next_inverval(void);
+void    report_buffer_set_inverval(uint8_t interval);
+uint8_t report_buffer_get_retry(void);
+void    report_buffer_set_retry(uint8_t times);
+void    report_buffer_task(void);

keyboards/keychron/bluetooth/rtc_timer.c

@@ -0,0 +1,43 @@
+/* Copyright 2023 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+ 
+#include "hal.h"
+
+#if (HAL_USE_RTC)
+
+#    include "rtc_timer.h"
+
+void rtc_timer_init(void) {
+    rtc_timer_clear();
+}
+
+void rtc_timer_clear(void) {
+    RTCDateTime tm = {0, 0, 0, 0, 0, 0};
+    rtcSetTime(&RTCD1, &tm);
+}
+
+uint32_t rtc_timer_read_ms(void) {
+    RTCDateTime tm;
+    rtcGetTime(&RTCD1, &tm);
+
+    return tm.millisecond;
+}
+
+uint32_t rtc_timer_elapsed_ms(uint32_t last) {
+    return TIMER_DIFF_32(rtc_timer_read_ms(), last);
+}
+
+#endif

keyboards/keychron/bluetooth/rtc_timer.h

@@ -0,0 +1,43 @@
+/* Copyright 2023 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "timer.h"
+#include <stdint.h>
+
+#define RTC_MAX_TIME (24 * 3600 * 1000) // Set to 1 day
+
+#if 0
+#    define TIMER_DIFF(a, b, max) ((max == UINT8_MAX) ? ((uint8_t)((a) - (b))) : ((max == UINT16_MAX) ? ((uint16_t)((a) - (b))) : ((max == UINT32_MAX) ? ((uint32_t)((a) - (b))) : ((a) >= (b) ? (a) - (b) : (max) + 1 - (b) + (a)))))
+#    define TIMER_DIFF_8(a, b) TIMER_DIFF(a, b, UINT8_MAX)
+#    define TIMER_DIFF_16(a, b) TIMER_DIFF(a, b, UINT16_MAX)
+#    define TIMER_DIFF_32(a, b) TIMER_DIFF(a, b, UINT32_MAX)
+#    define TIMER_DIFF_RAW(a, b) TIMER_DIFF_8(a, b)
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void     rtc_timer_init(void);
+void     rtc_timer_clear(void);
+uint32_t rtc_timer_read_ms(void);
+uint32_t rtc_timer_elapsed_ms(uint32_t last);
+
+#ifdef __cplusplus
+}
+#endif

keyboards/keychron/bluetooth/transport.c

@@ -0,0 +1,190 @@
+/* Copyright 2022 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "quantum.h"
+#include "bluetooth.h"
+#include "indicator.h"
+#include "lpm.h"
+#if defined(PROTOCOL_CHIBIOS)
+#    include <usb_main.h>
+#endif
+#include "transport.h"
+
+#ifndef REINIT_LED_DRIVER
+#    define REINIT_LED_DRIVER 1
+#endif
+
+#if defined(PROTOCOL_CHIBIOS)
+extern host_driver_t chibios_driver;
+#endif
+extern host_driver_t   bluetooth_driver;
+extern keymap_config_t keymap_config;
+
+static transport_t transport = TRANSPORT_USB;
+
+#ifdef NKRO_ENABLE
+nkro_t nkro = {false, false};
+#endif
+
+static void transport_changed(transport_t new_transport);
+
+__attribute__((weak)) void bt_transport_enable(bool enable) {
+    if (enable) {
+        if (host_get_driver() != &bluetooth_driver) {
+            host_set_driver(&bluetooth_driver);
+
+            /* Disconnect and reconnect to sync the bluetooth state
+             * TODO: query bluetooth state to sync
+             */
+            bluetooth_disconnect();
+            bluetooth_connect();
+            // TODO: Clear USB report
+        }
+    } else {
+        indicator_stop();
+
+        if (bluetooth_get_state() == BLUETOOTH_CONNECTED) {
+            report_keyboard_t empty_report = {0};
+            bluetooth_driver.send_keyboard(&empty_report);
+        }
+    }
+}
+
+/* There is no dedicated pin for USB power on chip such as STM32L432, but USB power
+ * can be connected and disconnected via registers.
+ * Overwrite these two functions if such chip is used. */
+__attribute__((weak)) void usb_power_connect(void) {}
+__attribute__((weak)) void usb_power_disconnect(void) {}
+
+__attribute__((weak)) void usb_transport_enable(bool enable) {
+    if (enable) {
+        if (host_get_driver() != &chibios_driver) {
+#if !defined(KEEP_USB_CONNECTION_IN_BLUETOOTH_MODE)
+            usb_power_connect();
+            usb_start(&USBD1);
+#endif
+            host_set_driver(&chibios_driver);
+        }
+    } else {
+        if (USB_DRIVER.state == USB_ACTIVE) {
+            report_keyboard_t empty_report = {0};
+            chibios_driver.send_keyboard(&empty_report);
+        }
+
+#if !defined(KEEP_USB_CONNECTION_IN_BLUETOOTH_MODE)
+        usbStop(&USBD1);
+        usbDisconnectBus(&USBD1);
+        usb_power_disconnect();
+#endif
+    }
+}
+
+void set_transport(transport_t new_transport) {
+    if (transport != new_transport) {
+        transport = new_transport;
+
+        clear_keyboard();
+
+        switch (transport) {
+            case TRANSPORT_USB:
+                usb_transport_enable(true);
+                bt_transport_enable(false);
+                lpm_timer_stop();
+#ifdef NKRO_ENABLE
+#    if defined(BLUETOOTH_NKRO_ENABLE)
+                nkro.bluetooth = keymap_config.nkro;
+#    endif
+                keymap_config.nkro = nkro.usb;
+#endif
+                break;
+
+            case TRANSPORT_BLUETOOTH:
+                bt_transport_enable(true);
+                usb_transport_enable(false);
+                lpm_timer_reset();
+#if defined(NKRO_ENABLE)
+                nkro.usb = keymap_config.nkro;
+#    if defined(BLUETOOTH_NKRO_ENABLE)
+                keymap_config.nkro = nkro.bluetooth;
+#    else
+                keymap_config.nkro = FALSE;
+#    endif
+#endif
+                break;
+            default:
+                break;
+        }
+
+        transport_changed(transport);
+    }
+}
+
+transport_t get_transport(void) {
+    return transport;
+}
+
+/* Changing transport may cause bronw-out reset of led driver
+ * withoug MCU reset, which lead backlight to not work,
+ * reinit the led driver workgound this issue */
+static void reinit_led_drvier(void) {
+    /* Wait circuit to discharge for a while */
+    systime_t start = chVTGetSystemTime();
+    while (chTimeI2MS(chVTTimeElapsedSinceX(start)) < 100) {
+    };
+
+#ifdef LED_MATRIX_ENABLE
+    led_matrix_init();
+#endif
+#ifdef RGB_MATRIX_ENABLE
+    rgb_matrix_init();
+#endif
+}
+
+void transport_changed(transport_t new_transport) {
+#if (REINIT_LED_DRIVER)
+    reinit_led_drvier();
+#endif
+
+#if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_TIMEOUT)
+#    if (RGB_MATRIX_TIMEOUT > 0)
+    rgb_matrix_disable_timeout_set(RGB_MATRIX_TIMEOUT_INFINITE);
+    rgb_matrix_disable_time_reset();
+#    endif
+#endif
+#if defined(LED_MATRIX_ENABLE) && defined(LED_MATRIX_TIMEOUT)
+#    if (LED_MATRIX_TIMEOUT > 0)
+    led_matrix_disable_timeout_set(LED_MATRIX_TIMEOUT_INFINITE);
+    led_matrix_disable_time_reset();
+#    endif
+#endif
+}
+
+void usb_remote_wakeup(void) {
+    if (USB_DRIVER.state == USB_SUSPENDED) {
+        while (USB_DRIVER.state == USB_SUSPENDED) {
+            /* Do this in the suspended state */
+            suspend_power_down(); // on AVR this deep sleeps for 15ms
+            /* Remote wakeup */
+            if (suspend_wakeup_condition()) {
+                usbWakeupHost(&USB_DRIVER);
+            }
+        }
+        wait_ms(500);
+        /* Woken up */
+        // variables has been already cleared by the wakeup hook
+        send_keyboard_report();
+    }
+}

keyboards/keychron/bluetooth/transport.h

@@ -1,4 +1,4 @@
-/* Copyright 2022 @ Keychron(https://www.keychron.com)
+/* Copyright 2022 @ lokher (https://www.keychron.com)
  *
  * 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
@@ -16,19 +16,24 @@
 
 #pragma once
 
-/* Disable DIP switch in matrix data */
-#define MATRIX_MASKED
+typedef enum {
+    TRANSPORT_NONE,
+    TRANSPORT_USB,
+    TRANSPORT_BLUETOOTH,
+} transport_t;
 
-/* DIP switch */
-#define DIP_SWITCH_MATRIX_GRID  { {5,4} }
+#ifdef NKRO_ENABLE
+typedef struct {
+    bool usb : 1;
+    bool bluetooth : 1;
+} nkro_t;
+#endif
 
-/* EEPROM Driver Configuration */
-#define WEAR_LEVELING_LOGICAL_SIZE 2048
-#define WEAR_LEVELING_BACKING_SIZE (WEAR_LEVELING_LOGICAL_SIZE * 2)
+void        set_transport(transport_t new_transport);
+transport_t get_transport(void);
 
-/* Increase I2C speed to 1000 KHz */
-#define I2C1_TIMINGR_PRESC 0U
-#define I2C1_TIMINGR_SCLDEL 3U
-#define I2C1_TIMINGR_SDADEL 0U
-#define I2C1_TIMINGR_SCLH 15U
-#define I2C1_TIMINGR_SCLL 51U
+void bt_transport_enable(bool enable);
+void usb_power_connect(void);
+void usb_power_disconnect(void);
+void usb_transport_enable(bool enable);
+void usb_remote_wakeup(void);

keyboards/keychron/c1_pro/ansi/rgb/info.json

@@ -1,229 +0,0 @@
-{
-    "usb": {
-        "pid": "0x0510",
-        "device_version": "1.0.0"
-    },
-    "features": {
-        "rgb_matrix": true
-    },
-    "layouts": {
-        "LAYOUT_tkl_ansi": {
-            "layout": [
-                {"matrix":[0, 0], "x":0, "y":0},
-                {"matrix":[0, 1], "x":2, "y":0},
-                {"matrix":[0, 2], "x":3, "y":0},
-                {"matrix":[0, 3], "x":4, "y":0},
-                {"matrix":[0, 4], "x":5, "y":0},
-                {"matrix":[0, 5], "x":6.5, "y":0},
-                {"matrix":[0, 6], "x":7.5, "y":0},
-                {"matrix":[0, 7], "x":8.5, "y":0},
-                {"matrix":[0, 8], "x":9.5, "y":0},
-                {"matrix":[0, 9], "x":11, "y":0},
-                {"matrix":[0,10], "x":12, "y":0},
-                {"matrix":[0,11], "x":13, "y":0},
-                {"matrix":[0,12], "x":14, "y":0},
-                {"matrix":[0,14], "x":15.25, "y":0},
-                {"matrix":[0,15], "x":16.25, "y":0},
-                {"matrix":[3,14], "x":17.25, "y":0},
-
-                {"matrix":[1, 0], "x":0, "y":1.25},
-                {"matrix":[1, 1], "x":1, "y":1.25},
-                {"matrix":[1, 2], "x":2, "y":1.25},
-                {"matrix":[1, 3], "x":3, "y":1.25},
-                {"matrix":[1, 4], "x":4, "y":1.25},
-                {"matrix":[1, 5], "x":5, "y":1.25},
-                {"matrix":[1, 6], "x":6, "y":1.25},
-                {"matrix":[1, 7], "x":7, "y":1.25},
-                {"matrix":[1, 8], "x":8, "y":1.25},
-                {"matrix":[1, 9], "x":9, "y":1.25},
-                {"matrix":[1,10], "x":10, "y":1.25},
-                {"matrix":[1,11], "x":11, "y":1.25},
-                {"matrix":[1,12], "x":12, "y":1.25},
-                {"matrix":[1,13], "x":13, "y":1.25, "w":2},
-                {"matrix":[1,14], "x":15.25, "y":1.25},
-                {"matrix":[1,15], "x":16.25, "y":1.25},
-                {"matrix":[3,15], "x":17.25, "y":1.25},
-
-                {"matrix":[2, 0], "x":0, "y":2.25, "w":1.5},
-                {"matrix":[2, 1], "x":1.5, "y":2.25},
-                {"matrix":[2, 2], "x":2.5, "y":2.25},
-                {"matrix":[2, 3], "x":3.5, "y":2.25},
-                {"matrix":[2, 4], "x":4.5, "y":2.25},
-                {"matrix":[2, 5], "x":5.5, "y":2.25},
-                {"matrix":[2, 6], "x":6.5, "y":2.25},
-                {"matrix":[2, 7], "x":7.5, "y":2.25},
-                {"matrix":[2, 8], "x":8.5, "y":2.25},
-                {"matrix":[2, 9], "x":9.5, "y":2.25},
-                {"matrix":[2,10], "x":10.5, "y":2.25},
-                {"matrix":[2,11], "x":11.5, "y":2.25},
-                {"matrix":[2,12], "x":12.5, "y":2.25},
-                {"matrix":[2,13], "x":13.5, "y":2.25, "w":1.5},
-                {"matrix":[2,14], "x":15.25, "y":2.25},
-                {"matrix":[2,15], "x":16.25, "y":2.25},
-                {"matrix":[3,12], "x":17.25, "y":2.25},
-
-                {"matrix":[3, 0], "x":0, "y":3.25, "w":1.75},
-                {"matrix":[3, 1], "x":1.75, "y":3.25},
-                {"matrix":[3, 2], "x":2.75, "y":3.25},
-                {"matrix":[3, 3], "x":3.75, "y":3.25},
-                {"matrix":[3, 4], "x":4.75, "y":3.25},
-                {"matrix":[3, 5], "x":5.75, "y":3.25},
-                {"matrix":[3, 6], "x":6.75, "y":3.25},
-                {"matrix":[3, 7], "x":7.75, "y":3.25},
-                {"matrix":[3, 8], "x":8.75, "y":3.25},
-                {"matrix":[3, 9], "x":9.75, "y":3.25},
-                {"matrix":[3,10], "x":10.75, "y":3.25},
-                {"matrix":[3,11], "x":11.75, "y":3.25},
-                {"matrix":[3,13], "x":12.75, "y":3.25, "w":2.25},
-
-                {"matrix":[4, 0], "x":0, "y":4.25, "w":2.25},
-                {"matrix":[4, 2], "x":2.25, "y":4.25},
-                {"matrix":[4, 3], "x":3.25, "y":4.25},
-                {"matrix":[4, 4], "x":4.25, "y":4.25},
-                {"matrix":[4, 5], "x":5.25, "y":4.25},
-                {"matrix":[4, 6], "x":6.25, "y":4.25},
-                {"matrix":[4, 7], "x":7.25, "y":4.25},
-                {"matrix":[4, 8], "x":8.25, "y":4.25},
-                {"matrix":[4, 9], "x":9.25, "y":4.25},
-                {"matrix":[4,10], "x":10.25, "y":4.25},
-                {"matrix":[4,11], "x":11.25, "y":4.25},
-                {"matrix":[4,13], "x":12.25, "y":4.25, "w":2.75},
-                {"matrix":[4,15], "x":16.25, "y":4.25},
-
-                {"matrix":[5, 0], "x":0, "y":5.25, "w":1.25},
-                {"matrix":[5, 1], "x":1.25, "y":5.25, "w":1.25},
-                {"matrix":[5, 2], "x":2.5, "y":5.25, "w":1.25},
-                {"matrix":[5, 6], "x":3.75, "y":5.25, "w":6.25},
-                {"matrix":[5,10], "x":10, "y":5.25, "w":1.25},
-                {"matrix":[5,11], "x":11.25, "y":5.25, "w":1.25},
-                {"matrix":[5,12], "x":12.5, "y":5.25, "w":1.25},
-                {"matrix":[5,13], "x":13.75, "y":5.25, "w":1.25},
-                {"matrix":[5,14], "x":15.25, "y":5.25},
-                {"matrix":[5,15], "x":16.25, "y":5.25},
-                {"matrix":[4,14], "x":17.25, "y":5.25}
-            ]
-        }
-    },
-    "rgb_matrix": {
-        "driver": "snled27351",
-        "animations": {
-            "breathing": true,
-            "band_spiral_val": true,
-            "cycle_all": true,
-            "cycle_left_right": true,
-            "cycle_up_down": true,
-            "rainbow_moving_chevron": true,
-            "cycle_out_in": true,
-            "cycle_out_in_dual": true,
-            "cycle_pinwheel": true,
-            "cycle_spiral": true,
-            "dual_beacon": true,
-            "rainbow_beacon": true,
-            "jellybean_raindrops": true,
-            "pixel_rain": true,
-            "typing_heatmap": true,
-            "digital_rain": true,
-            "solid_reactive_simple": true,
-            "solid_reactive_multiwide": true,
-            "solid_reactive_multinexus": true,
-            "splash": true,
-            "solid_splash": true
-        },
-        "layout": [
-            {"matrix":[0, 0],  "flags":1, "x":0,   "y":0},
-            {"matrix":[0, 1],  "flags":1, "x":26,  "y":0},
-            {"matrix":[0, 2],  "flags":1, "x":39,  "y":0},
-            {"matrix":[0, 3],  "flags":1, "x":52,  "y":0},
-            {"matrix":[0, 4],  "flags":1, "x":65,  "y":0},
-            {"matrix":[0, 5],  "flags":1, "x":85,  "y":0},
-            {"matrix":[0, 6],  "flags":1, "x":98,  "y":0},
-            {"matrix":[0, 7],  "flags":1, "x":111, "y":0},
-            {"matrix":[0, 8],  "flags":1, "x":124, "y":0},
-            {"matrix":[0, 9],  "flags":1, "x":143, "y":0},
-            {"matrix":[0, 10], "flags":1, "x":156, "y":0},
-            {"matrix":[0, 11], "flags":1, "x":169, "y":0},
-            {"matrix":[0, 12], "flags":1, "x":182, "y":0},
-            {"matrix":[0, 14], "flags":1, "x":198, "y":0},
-            {"matrix":[0, 15], "flags":1, "x":211, "y":0},
-            {"matrix":[3, 14], "flags":1, "x":224, "y":0},
-
-            {"matrix":[1, 0],  "flags":1, "x":0,   "y":15},
-            {"matrix":[1, 1],  "flags":4, "x":15,  "y":15},
-            {"matrix":[1, 2],  "flags":4, "x":26,  "y":15},
-            {"matrix":[1, 3],  "flags":4, "x":39,  "y":15},
-            {"matrix":[1, 4],  "flags":4, "x":52,  "y":15},
-            {"matrix":[1, 5],  "flags":4, "x":65,  "y":15},
-            {"matrix":[1, 6],  "flags":4, "x":78,  "y":15},
-            {"matrix":[1, 7],  "flags":4, "x":91,  "y":15},
-            {"matrix":[1, 8],  "flags":4, "x":104, "y":15},
-            {"matrix":[1, 9],  "flags":4, "x":117, "y":15},
-            {"matrix":[1, 10], "flags":4, "x":130, "y":15},
-            {"matrix":[1, 11], "flags":4, "x":143, "y":15},
-            {"matrix":[1, 12], "flags":4, "x":156, "y":15},
-            {"matrix":[1, 13], "flags":1, "x":176, "y":15},
-            {"matrix":[1, 14], "flags":1, "x":198, "y":15},
-            {"matrix":[1, 15], "flags":1, "x":211, "y":15},
-            {"matrix":[3, 15], "flags":1, "x":224, "y":15},
-
-            {"matrix":[2, 0],  "flags":1, "x":3,   "y":27},
-            {"matrix":[2, 1],  "flags":4, "x":20,  "y":27},
-            {"matrix":[2, 2],  "flags":4, "x":33,  "y":27},
-            {"matrix":[2, 3],  "flags":4, "x":46,  "y":27},
-            {"matrix":[2, 4],  "flags":4, "x":59,  "y":27},
-            {"matrix":[2, 5],  "flags":4, "x":72,  "y":27},
-            {"matrix":[2, 6],  "flags":4, "x":85,  "y":27},
-            {"matrix":[2, 7],  "flags":4, "x":98,  "y":27},
-            {"matrix":[2, 8],  "flags":4, "x":111, "y":27},
-            {"matrix":[2, 9],  "flags":4, "x":124, "y":27},
-            {"matrix":[2, 10], "flags":4, "x":137, "y":27},
-            {"matrix":[2, 11], "flags":4, "x":150, "y":27},
-            {"matrix":[2, 12], "flags":4, "x":163, "y":27},
-            {"matrix":[2, 13], "flags":4, "x":179, "y":27},
-            {"matrix":[2, 14], "flags":1, "x":198, "y":27},
-            {"matrix":[2, 15], "flags":1, "x":211, "y":27},
-            {"matrix":[3, 12], "flags":1, "x":224, "y":27},
-
-            {"matrix":[3, 0],  "flags":8, "x":5,   "y":39},
-            {"matrix":[3, 1],  "flags":4, "x":23,  "y":39},
-            {"matrix":[3, 2],  "flags":4, "x":36,  "y":39},
-            {"matrix":[3, 3],  "flags":4, "x":49,  "y":39},
-            {"matrix":[3, 4],  "flags":4, "x":62,  "y":39},
-            {"matrix":[3, 5],  "flags":4, "x":75,  "y":39},
-            {"matrix":[3, 6],  "flags":4, "x":88,  "y":39},
-            {"matrix":[3, 7],  "flags":4, "x":101, "y":39},
-            {"matrix":[3, 8],  "flags":4, "x":114, "y":39},
-            {"matrix":[3, 9],  "flags":4, "x":127, "y":39},
-            {"matrix":[3, 10], "flags":4, "x":140, "y":39},
-            {"matrix":[3, 11], "flags":4, "x":153, "y":39},
-            {"matrix":[3, 13], "flags":1, "x":174, "y":39},
-
-            {"matrix":[4, 12], "flags":8, "x":211, "y":39},
-
-            {"matrix":[4, 0],  "flags":1, "x":8,   "y":52},
-            {"matrix":[4, 2],  "flags":4, "x":29,  "y":52},
-            {"matrix":[4, 3],  "flags":4, "x":42,  "y":52},
-            {"matrix":[4, 4],  "flags":4, "x":55,  "y":52},
-            {"matrix":[4, 5],  "flags":4, "x":68,  "y":52},
-            {"matrix":[4, 6],  "flags":4, "x":82,  "y":52},
-            {"matrix":[4, 7],  "flags":4, "x":95, "y":52},
-            {"matrix":[4, 8],  "flags":4, "x":108, "y":52},
-            {"matrix":[4, 9],  "flags":4, "x":121, "y":52},
-            {"matrix":[4, 10], "flags":4, "x":134, "y":52},
-            {"matrix":[4, 11], "flags":4, "x":147, "y":52},
-            {"matrix":[4, 13], "flags":1, "x":171, "y":52},
-            {"matrix":[4, 15], "flags":1, "x":211, "y":52},
-
-            {"matrix":[5, 0],  "flags":1, "x":2,   "y":64},
-            {"matrix":[5, 1],  "flags":1, "x":18,  "y":64},
-            {"matrix":[5, 2],  "flags":1, "x":34,  "y":64},
-            {"matrix":[5, 6],  "flags":4, "x":83,  "y":64},
-            {"matrix":[5, 10], "flags":1, "x":132, "y":64},
-            {"matrix":[5, 11], "flags":1, "x":148, "y":64},
-            {"matrix":[5, 12], "flags":4, "x":165, "y":64},
-            {"matrix":[5, 13], "flags":1, "x":181, "y":64},
-            {"matrix":[5, 14], "flags":1, "x":198, "y":64},
-            {"matrix":[5, 15], "flags":1, "x":211, "y":64},
-            {"matrix":[4, 14], "flags":1, "x":224, "y":64}
-        ]
-    }
-}

keyboards/keychron/c1_pro/ansi/rgb/keymaps/keychron/keymap.c

@@ -1,72 +0,0 @@
-/* Copyright 2023 @ Keychron (https://www.keychron.com)
- *
- * 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 <http://www.gnu.org/licenses/>.
- */
-
-#include QMK_KEYBOARD_H
-#include "keychron_common.h"
-
-enum layers{
-    MAC_BASE,
-    MAC_FN,
-    WIN_BASE,
-    WIN_FN
-};
-
-const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-    [MAC_BASE] = LAYOUT_tkl_ansi(
-        KC_ESC,             KC_BRID,  KC_BRIU,  KC_MCTL,  KC_LPAD,  RGB_VAD,  RGB_VAI,  KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_MUTE,  KC_VOLD,    KC_VOLU,  KC_SNAP,  KC_SIRI,  RGB_MOD,
-        KC_GRV,   KC_1,     KC_2,     KC_3,     KC_4,     KC_5,     KC_6,     KC_7,     KC_8,     KC_9,     KC_0,     KC_MINS,  KC_EQL,     KC_BSPC,  KC_INS,   KC_HOME,  KC_PGUP,
-        KC_TAB,   KC_Q,     KC_W,     KC_E,     KC_R,     KC_T,     KC_Y,     KC_U,     KC_I,     KC_O,     KC_P,     KC_LBRC,  KC_RBRC,    KC_BSLS,  KC_DEL,   KC_END,   KC_PGDN,
-        KC_CAPS,  KC_A,     KC_S,     KC_D,     KC_F,     KC_G,     KC_H,     KC_J,     KC_K,     KC_L,     KC_SCLN,  KC_QUOT,              KC_ENT,
-        KC_LSFT,            KC_Z,     KC_X,     KC_C,     KC_V,     KC_B,     KC_N,     KC_M,     KC_COMM,  KC_DOT,   KC_SLSH,              KC_RSFT,            KC_UP,
-        KC_LCTL,  KC_LOPTN, KC_LCMMD,                               KC_SPC,                                 KC_RCMMD, KC_ROPTN, MO(MAC_FN), KC_RCTL,  KC_LEFT,  KC_DOWN,  KC_RGHT),
-
-    [MAC_FN] = LAYOUT_tkl_ansi(
-        _______,            KC_F1,    KC_F2,    KC_F3,    KC_F4,    KC_F5,    KC_F6,    KC_F7,    KC_F8,    KC_F9,    KC_F10,   KC_F11,     KC_F12,   _______,  _______,  RGB_TOG,
-        _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,
-        RGB_TOG,  RGB_MOD,  RGB_VAI,  RGB_HUI,  RGB_SAI,  RGB_SPI,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,
-        _______,  RGB_RMOD, RGB_VAD,  RGB_HUD,  RGB_SAD,  RGB_SPD,  _______,  _______,  _______,  _______,  _______,  _______,              _______,
-        _______,            _______,  _______,  _______,  _______,  _______,  NK_TOGG,  _______,  _______,  _______,  _______,              _______,            _______,
-        _______,  _______,  _______,                                _______,                                _______,  _______,  _______,    _______,  _______,  _______,  _______),
-
-    [WIN_BASE] = LAYOUT_tkl_ansi(
-        KC_ESC,             KC_F1,    KC_F2,    KC_F3,    KC_F4,    KC_F5,    KC_F6,    KC_F7,    KC_F8,    KC_F9,    KC_F10,   KC_F11,     KC_F12,   KC_PSCR,  KC_CRTA,  RGB_MOD,
-        KC_GRV,   KC_1,     KC_2,     KC_3,     KC_4,     KC_5,     KC_6,     KC_7,     KC_8,     KC_9,     KC_0,     KC_MINS,  KC_EQL,     KC_BSPC,  KC_INS,   KC_HOME,  KC_PGUP,
-        KC_TAB,   KC_Q,     KC_W,     KC_E,     KC_R,     KC_T,     KC_Y,     KC_U,     KC_I,     KC_O,     KC_P,     KC_LBRC,  KC_RBRC,    KC_BSLS,  KC_DEL,   KC_END,   KC_PGDN,
-        KC_CAPS,  KC_A,     KC_S,     KC_D,     KC_F,     KC_G,     KC_H,     KC_J,     KC_K,     KC_L,     KC_SCLN,  KC_QUOT,              KC_ENT,
-        KC_LSFT,            KC_Z,     KC_X,     KC_C,     KC_V,     KC_B,     KC_N,     KC_M,     KC_COMM,  KC_DOT,   KC_SLSH,              KC_RSFT,            KC_UP,
-        KC_LCTL,  KC_LCMD,  KC_LALT,                                KC_SPC,                                 KC_RALT,  KC_RWIN,  MO(WIN_FN), KC_RCTL,  KC_LEFT,  KC_DOWN,  KC_RGHT),
-
-    [WIN_FN] = LAYOUT_tkl_ansi(
-        _______,            KC_BRID,  KC_BRIU,  KC_TASK,  KC_FLXP,  RGB_VAD,  RGB_VAI,  KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_MUTE,  KC_VOLD,    KC_VOLU,  _______,  _______,  RGB_TOG,
-        _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,
-        RGB_TOG,  RGB_MOD,  RGB_VAI,  RGB_HUI,  RGB_SAI,  RGB_SPI,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,
-        _______,  RGB_RMOD, RGB_VAD,  RGB_HUD,  RGB_SAD,  RGB_SPD,  _______,  _______,  _______,  _______,  _______,  _______,              _______,
-        _______,            _______,  _______,  _______,  _______,  _______,  NK_TOGG,  _______,  _______,  _______,  _______,              _______,            _______,
-        _______,  _______,  _______,                                _______,                                _______,  _______,  _______,    _______,  _______,  _______,  _______),
-};
-
-// clang-format on
-
-void housekeeping_task_user(void) {
-    housekeeping_task_keychron();
-}
-
-bool process_record_user(uint16_t keycode, keyrecord_t *record) {
-    if (!process_record_keychron(keycode, record)) {
-        return false;
-    }
-    return true;
-}

keyboards/keychron/c1_pro/ansi/rgb/keymaps/keychron/rules.mk

@@ -1,4 +0,0 @@
-VIA_ENABLE = yes
-
-VPATH += keyboards/keychron/common
-SRC += keychron_common.c

keyboards/keychron/c1_pro/ansi/rgb/rgb.c

@@ -1,168 +0,0 @@
-/* Copyright 2023 @ Keychron (https://www.keychron.com)
- *
- * 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 <http://www.gnu.org/licenses/>.
- */
-
-#include "quantum.h"
-
-// clang-format off
-#ifdef RGB_MATRIX_ENABLE
-const snled27351_led_t PROGMEM g_snled27351_leds[RGB_MATRIX_LED_COUNT] = {
-/* Refer to SNLED27351 manual for these locations
- *   driver
- *   |  R location
- *   |  |       G location
- *   |  |       |       B location
- *   |  |       |       | */
-    {0, I_1,    G_1,    H_1},
-    {0, I_2,    G_2,    H_2},
-    {0, I_3,    G_3,    H_3},
-    {0, I_4,    G_4,    H_4},
-    {0, I_5,    G_5,    H_5},
-    {0, I_6,    G_6,    H_6},
-    {0, I_7,    G_7,    H_7},
-    {0, I_8,    G_8,    H_8},
-    {0, I_9,    G_9,    H_9},
-    {0, I_10,   G_10,   H_10},
-    {0, I_11,   G_11,   H_11},
-    {0, I_12,   G_12,   H_12},
-    {0, I_13,   G_13,   H_13},
-    {0, I_15,   G_15,   H_15},
-    {0, I_16,   G_16,   H_16},
-    {1, I_15,   G_15,   H_15},
-
-    {0, C_1,    A_1,    B_1},
-    {0, C_2,    A_2,    B_2},
-    {0, C_3,    A_3,    B_3},
-    {0, C_4,    A_4,    B_4},
-    {0, C_5,    A_5,    B_5},
-    {0, C_6,    A_6,    B_6},
-    {0, C_7,    A_7,    B_7},
-    {0, C_8,    A_8,    B_8},
-    {0, C_9,    A_9,    B_9},
-    {0, C_10,   A_10,   B_10},
-    {0, C_11,   A_11,   B_11},
-    {0, C_12,   A_12,   B_12},
-    {0, C_13,   A_13,   B_13},
-    {0, C_14,   A_14,   B_14},
-    {0, C_15,   A_15,   B_15},
-    {0, C_16,   A_16,   B_16},
-    {1, I_16,   G_16,   H_16},
-
-    {0, F_1,    D_1,    E_1},
-    {0, F_2,    D_2,    E_2},
-    {0, F_3,    D_3,    E_3},
-    {0, F_4,    D_4,    E_4},
-    {0, F_5,    D_5,    E_5},
-    {0, F_6,    D_6,    E_6},
-    {0, F_7,    D_7,    E_7},
-    {0, F_8,    D_8,    E_8},
-    {0, F_9,    D_9,    E_9},
-    {0, F_10,   D_10,   E_10},
-    {0, F_11,   D_11,   E_11},
-    {0, F_12,   D_12,   E_12},
-    {0, F_13,   D_13,   E_13},
-    {0, F_14,   D_14,   E_14},
-    {0, F_15,   D_15,   E_15},
-    {0, F_16,   D_16,   E_16},
-    {1, I_13,   G_13,   H_13},
-
-    {1, I_1,    G_1,    H_1},
-    {1, I_2,    G_2,    H_2},
-    {1, I_3,    G_3,    H_3},
-    {1, I_4,    G_4,    H_4},
-    {1, I_5,    G_5,    H_5},
-    {1, I_6,    G_6,    H_6},
-    {1, I_7,    G_7,    H_7},
-    {1, I_8,    G_8,    H_8},
-    {1, I_9,    G_9,    H_9},
-    {1, I_10,   G_10,   H_10},
-    {1, I_11,   G_11,   H_11},
-    {1, I_12,   G_12,   H_12},
-    {1, I_14,   G_14,   H_14},
-
-    {0, I_14,   G_14,   H_14}, // CAPS_MAC_WIN_LED_INDEX
-
-    {1, C_1,    A_1,    B_1},
-    {1, C_3,    A_3,    B_3},
-    {1, C_4,    A_4,    B_4},
-    {1, C_5,    A_5,    B_5},
-    {1, C_6,    A_6,    B_6},
-    {1, C_7,    A_7,    B_7},
-    {1, C_8,    A_8,    B_8},
-    {1, C_9,    A_9,    B_9},
-    {1, C_10,   A_10,   B_10},
-    {1, C_11,   A_11,   B_11},
-    {1, C_12,   A_12,   B_12},
-    {1, C_14,   A_14,   B_14},
-    {1, C_16,   A_16,   B_16},
-
-    {1, F_1,    D_1,    E_1},
-    {1, F_2,    D_2,    E_2},
-    {1, F_3,    D_3,    E_3},
-    {1, F_7,    D_7,    E_7},
-    {1, F_11,   D_11,   E_11},
-    {1, F_12,   D_12,   E_12},
-    {1, F_13,   D_13,   E_13},
-    {1, F_14,   D_14,   E_14},
-    {1, F_15,   D_15,   E_15},
-    {1, F_16,   D_16,   E_16},
-    {1, C_15,   A_15,   B_15},
-};
-
-// clang-format on
-
-bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
-    if (!process_record_user(keycode, record)) {
-        return false;
-    }
-    switch (keycode) {
-        case RGB_TOG:
-            if (record->event.pressed) {
-                switch (rgb_matrix_get_flags()) {
-                    case LED_FLAG_ALL: {
-                        rgb_matrix_set_flags(LED_FLAG_NONE);
-                        rgb_matrix_set_color_all(0, 0, 0);
-                    } break;
-                    default: {
-                        rgb_matrix_set_flags(LED_FLAG_ALL);
-                    } break;
-                }
-            }
-            if (!rgb_matrix_is_enabled()) {
-                rgb_matrix_set_flags(LED_FLAG_ALL);
-                rgb_matrix_enable();
-            }
-            return false;
-    }
-    return true;
-}
-
-bool rgb_matrix_indicators_advanced_kb(uint8_t led_min, uint8_t led_max) {
-    if (!rgb_matrix_indicators_advanced_user(led_min, led_max)) {
-        return false;
-    }
-    if ((host_keyboard_led_state().caps_lock) && (default_layer_state == (1 << 0))) {
-        rgb_matrix_set_color(CAPS_MAC_WIN_LED_INDEX, 0, 255, 255);
-    } else if ((!host_keyboard_led_state().caps_lock) && (default_layer_state == (1 << 0))) {
-        rgb_matrix_set_color(CAPS_MAC_WIN_LED_INDEX, 0, 0, 255);
-    } else if ((host_keyboard_led_state().caps_lock) && (default_layer_state == (1 << 2))) {
-        rgb_matrix_set_color(CAPS_MAC_WIN_LED_INDEX, 255, 255, 0);
-    } else if ((!host_keyboard_led_state().caps_lock) && (default_layer_state == (1 << 2))) {
-        rgb_matrix_set_color(CAPS_MAC_WIN_LED_INDEX, 255, 0, 0);
-    }
-    return true;
-}
-
-#endif

keyboards/keychron/c1_pro/ansi/rgb/rules.mk

@@ -1 +0,0 @@
-# Build Options

keyboards/keychron/c1_pro/ansi/white/info.json

@@ -1,226 +0,0 @@
-{
-    "usb": {
-        "pid": "0x0513",
-        "device_version": "1.0.0"
-    },
-    "features": {
-        "led_matrix": true
-    },
-    "layouts": {
-        "LAYOUT_tkl_ansi": {
-            "layout": [
-                {"matrix":[0, 0], "x":0, "y":0},
-                {"matrix":[0, 1], "x":2, "y":0},
-                {"matrix":[0, 2], "x":3, "y":0},
-                {"matrix":[0, 3], "x":4, "y":0},
-                {"matrix":[0, 4], "x":5, "y":0},
-                {"matrix":[0, 5], "x":6.5, "y":0},
-                {"matrix":[0, 6], "x":7.5, "y":0},
-                {"matrix":[0, 7], "x":8.5, "y":0},
-                {"matrix":[0, 8], "x":9.5, "y":0},
-                {"matrix":[0, 9], "x":11, "y":0},
-                {"matrix":[0,10], "x":12, "y":0},
-                {"matrix":[0,11], "x":13, "y":0},
-                {"matrix":[0,12], "x":14, "y":0},
-                {"matrix":[0,14], "x":15.25, "y":0},
-                {"matrix":[0,15], "x":16.25, "y":0},
-                {"matrix":[0,13], "x":17.25, "y":0},
-
-                {"matrix":[1, 0], "x":0, "y":1.25},
-                {"matrix":[1, 1], "x":1, "y":1.25},
-                {"matrix":[1, 2], "x":2, "y":1.25},
-                {"matrix":[1, 3], "x":3, "y":1.25},
-                {"matrix":[1, 4], "x":4, "y":1.25},
-                {"matrix":[1, 5], "x":5, "y":1.25},
-                {"matrix":[1, 6], "x":6, "y":1.25},
-                {"matrix":[1, 7], "x":7, "y":1.25},
-                {"matrix":[1, 8], "x":8, "y":1.25},
-                {"matrix":[1, 9], "x":9, "y":1.25},
-                {"matrix":[1,10], "x":10, "y":1.25},
-                {"matrix":[1,11], "x":11, "y":1.25},
-                {"matrix":[1,12], "x":12, "y":1.25},
-                {"matrix":[1,13], "x":13, "y":1.25, "w":2},
-                {"matrix":[1,14], "x":15.25, "y":1.25},
-                {"matrix":[1,15], "x":16.25, "y":1.25},
-                {"matrix":[3,12], "x":17.25, "y":1.25},
-
-                {"matrix":[2, 0], "x":0, "y":2.25, "w":1.5},
-                {"matrix":[2, 1], "x":1.5, "y":2.25},
-                {"matrix":[2, 2], "x":2.5, "y":2.25},
-                {"matrix":[2, 3], "x":3.5, "y":2.25},
-                {"matrix":[2, 4], "x":4.5, "y":2.25},
-                {"matrix":[2, 5], "x":5.5, "y":2.25},
-                {"matrix":[2, 6], "x":6.5, "y":2.25},
-                {"matrix":[2, 7], "x":7.5, "y":2.25},
-                {"matrix":[2, 8], "x":8.5, "y":2.25},
-                {"matrix":[2, 9], "x":9.5, "y":2.25},
-                {"matrix":[2,10], "x":10.5, "y":2.25},
-                {"matrix":[2,11], "x":11.5, "y":2.25},
-                {"matrix":[2,12], "x":12.5, "y":2.25},
-                {"matrix":[2,13], "x":13.5, "y":2.25, "w":1.5},
-                {"matrix":[2,14], "x":15.25, "y":2.25},
-                {"matrix":[2,15], "x":16.25, "y":2.25},
-                {"matrix":[3,14], "x":17.25, "y":2.25},
-
-                {"matrix":[3, 0], "x":0, "y":3.25, "w":1.75},
-                {"matrix":[3, 1], "x":1.75, "y":3.25},
-                {"matrix":[3, 2], "x":2.75, "y":3.25},
-                {"matrix":[3, 3], "x":3.75, "y":3.25},
-                {"matrix":[3, 4], "x":4.75, "y":3.25},
-                {"matrix":[3, 5], "x":5.75, "y":3.25},
-                {"matrix":[3, 6], "x":6.75, "y":3.25},
-                {"matrix":[3, 7], "x":7.75, "y":3.25},
-                {"matrix":[3, 8], "x":8.75, "y":3.25},
-                {"matrix":[3, 9], "x":9.75, "y":3.25},
-                {"matrix":[3,10], "x":10.75, "y":3.25},
-                {"matrix":[3,11], "x":11.75, "y":3.25},
-                {"matrix":[3,13], "x":12.75, "y":3.25, "w":2.25},
-
-                {"matrix":[4, 0], "x":0, "y":4.25, "w":2.25},
-                {"matrix":[4, 2], "x":2.25, "y":4.25},
-                {"matrix":[4, 3], "x":3.25, "y":4.25},
-                {"matrix":[4, 4], "x":4.25, "y":4.25},
-                {"matrix":[4, 5], "x":5.25, "y":4.25},
-                {"matrix":[4, 6], "x":6.25, "y":4.25},
-                {"matrix":[4, 7], "x":7.25, "y":4.25},
-                {"matrix":[4, 8], "x":8.25, "y":4.25},
-                {"matrix":[4, 9], "x":9.25, "y":4.25},
-                {"matrix":[4,10], "x":10.25, "y":4.25},
-                {"matrix":[4,11], "x":11.25, "y":4.25},
-                {"matrix":[4,13], "x":12.25, "y":4.25, "w":2.75},
-                {"matrix":[4,15], "x":16.25, "y":4.25},
-
-                {"matrix":[5, 0], "x":0, "y":5.25, "w":1.25},
-                {"matrix":[5, 1], "x":1.25, "y":5.25, "w":1.25},
-                {"matrix":[5, 2], "x":2.5, "y":5.25, "w":1.25},
-                {"matrix":[5, 6], "x":3.75, "y":5.25, "w":6.25},
-                {"matrix":[5,10], "x":10, "y":5.25, "w":1.25},
-                {"matrix":[5,11], "x":11.25, "y":5.25, "w":1.25},
-                {"matrix":[5,12], "x":12.5, "y":5.25, "w":1.25},
-                {"matrix":[5,13], "x":13.75, "y":5.25, "w":1.25},
-                {"matrix":[5,14], "x":15.25, "y":5.25},
-                {"matrix":[5,15], "x":16.25, "y":5.25},
-                {"matrix":[3,15], "x":17.25, "y":5.25}
-            ]
-        }
-    },
-    "led_matrix": {
-        "driver": "snled27351",
-        "animations": {
-            "none": true,
-            "solid": true,
-            "breathing": true,
-            "band_pinwheel": true,
-            "band_spiral": true,
-            "cycle_left_right": true,
-            "cycle_up_down": true,
-            "cycle_out_in": true,
-            "dual_beacon": true,
-            "solid_reactive_simple": true,
-            "solid_reactive_multiwide": true,
-            "solid_reactive_multinexus": true,
-            "solid_splash": true,
-            "wave_left_right": true,
-            "wave_up_down": true,
-            "effect_max": true
-        },
-        "layout": [
-            {"matrix":[0, 0],  "flags":1, "x":0,   "y":0},
-            {"matrix":[0, 1],  "flags":1, "x":26,  "y":0},
-            {"matrix":[0, 2],  "flags":1, "x":39,  "y":0},
-            {"matrix":[0, 3],  "flags":1, "x":52,  "y":0},
-            {"matrix":[0, 4],  "flags":1, "x":65,  "y":0},
-            {"matrix":[0, 5],  "flags":1, "x":85,  "y":0},
-            {"matrix":[0, 6],  "flags":1, "x":98,  "y":0},
-            {"matrix":[0, 7],  "flags":1, "x":111, "y":0},
-            {"matrix":[0, 8],  "flags":1, "x":124, "y":0},
-            {"matrix":[0, 9],  "flags":1, "x":143, "y":0},
-            {"matrix":[0, 10], "flags":1, "x":156, "y":0},
-            {"matrix":[0, 11], "flags":1, "x":169, "y":0},
-            {"matrix":[0, 12], "flags":1, "x":182, "y":0},
-            {"matrix":[0, 14], "flags":1, "x":198, "y":0},
-            {"matrix":[0, 15], "flags":1, "x":211, "y":0},
-            {"matrix":[0, 13], "flags":1, "x":224, "y":0},
-
-            {"matrix":[1, 0],  "flags":1, "x":0,   "y":15},
-            {"matrix":[1, 1],  "flags":4, "x":15,  "y":15},
-            {"matrix":[1, 2],  "flags":4, "x":26,  "y":15},
-            {"matrix":[1, 3],  "flags":4, "x":39,  "y":15},
-            {"matrix":[1, 4],  "flags":4, "x":52,  "y":15},
-            {"matrix":[1, 5],  "flags":4, "x":65,  "y":15},
-            {"matrix":[1, 6],  "flags":4, "x":78,  "y":15},
-            {"matrix":[1, 7],  "flags":4, "x":91,  "y":15},
-            {"matrix":[1, 8],  "flags":4, "x":104, "y":15},
-            {"matrix":[1, 9],  "flags":4, "x":117, "y":15},
-            {"matrix":[1, 10], "flags":4, "x":130, "y":15},
-            {"matrix":[1, 11], "flags":4, "x":143, "y":15},
-            {"matrix":[1, 12], "flags":4, "x":156, "y":15},
-            {"matrix":[1, 13], "flags":1, "x":176, "y":15},
-            {"matrix":[1, 14], "flags":1, "x":198, "y":15},
-            {"matrix":[1, 15], "flags":1, "x":211, "y":15},
-            {"matrix":[3, 12], "flags":1, "x":224, "y":15},
-
-            {"matrix":[2, 0],  "flags":1, "x":3,   "y":27},
-            {"matrix":[2, 1],  "flags":4, "x":20,  "y":27},
-            {"matrix":[2, 2],  "flags":4, "x":33,  "y":27},
-            {"matrix":[2, 3],  "flags":4, "x":46,  "y":27},
-            {"matrix":[2, 4],  "flags":4, "x":59,  "y":27},
-            {"matrix":[2, 5],  "flags":4, "x":72,  "y":27},
-            {"matrix":[2, 6],  "flags":4, "x":85,  "y":27},
-            {"matrix":[2, 7],  "flags":4, "x":98,  "y":27},
-            {"matrix":[2, 8],  "flags":4, "x":111, "y":27},
-            {"matrix":[2, 9],  "flags":4, "x":124, "y":27},
-            {"matrix":[2, 10], "flags":4, "x":137, "y":27},
-            {"matrix":[2, 11], "flags":4, "x":150, "y":27},
-            {"matrix":[2, 12], "flags":4, "x":163, "y":27},
-            {"matrix":[2, 13], "flags":4, "x":179, "y":27},
-            {"matrix":[2, 14], "flags":1, "x":198, "y":27},
-            {"matrix":[2, 15], "flags":1, "x":211, "y":27},
-            {"matrix":[3, 14], "flags":1, "x":224, "y":27},
-
-            {"matrix":[3, 0],  "flags":8, "x":5,   "y":39},
-            {"matrix":[3, 1],  "flags":4, "x":23,  "y":39},
-            {"matrix":[3, 2],  "flags":4, "x":36,  "y":39},
-            {"matrix":[3, 3],  "flags":4, "x":49,  "y":39},
-            {"matrix":[3, 4],  "flags":4, "x":62,  "y":39},
-            {"matrix":[3, 5],  "flags":4, "x":75,  "y":39},
-            {"matrix":[3, 6],  "flags":4, "x":88,  "y":39},
-            {"matrix":[3, 7],  "flags":4, "x":101, "y":39},
-            {"matrix":[3, 8],  "flags":4, "x":114, "y":39},
-            {"matrix":[3, 9],  "flags":4, "x":127, "y":39},
-            {"matrix":[3, 10], "flags":4, "x":140, "y":39},
-            {"matrix":[3, 11], "flags":4, "x":153, "y":39},
-            {"matrix":[3, 13], "flags":1, "x":174, "y":39},
-
-            {"matrix":[4, 12], "flags":8, "x":198, "y":39},
-            {"matrix":[4, 12], "flags":8, "x":211, "y":39},
-            {"matrix":[4, 12], "flags":8, "x":224, "y":39},
-
-            {"matrix":[4, 0],  "flags":1, "x":8,   "y":52},
-            {"matrix":[4, 2],  "flags":4, "x":29,  "y":52},
-            {"matrix":[4, 3],  "flags":4, "x":42,  "y":52},
-            {"matrix":[4, 4],  "flags":4, "x":55,  "y":52},
-            {"matrix":[4, 5],  "flags":4, "x":68,  "y":52},
-            {"matrix":[4, 6],  "flags":4, "x":82,  "y":52},
-            {"matrix":[4, 7],  "flags":4, "x":95, "y":52},
-            {"matrix":[4, 8],  "flags":4, "x":108, "y":52},
-            {"matrix":[4, 9],  "flags":4, "x":121, "y":52},
-            {"matrix":[4, 10], "flags":4, "x":134, "y":52},
-            {"matrix":[4, 11], "flags":4, "x":147, "y":52},
-            {"matrix":[4, 13], "flags":1, "x":171, "y":52},
-            {"matrix":[4, 15], "flags":1, "x":211, "y":52},
-
-            {"matrix":[5, 0],  "flags":1, "x":2,   "y":64},
-            {"matrix":[5, 1],  "flags":1, "x":18,  "y":64},
-            {"matrix":[5, 2],  "flags":1, "x":34,  "y":64},
-            {"matrix":[5, 6],  "flags":4, "x":83,  "y":64},
-            {"matrix":[5, 10], "flags":1, "x":132, "y":64},
-            {"matrix":[5, 11], "flags":1, "x":148, "y":64},
-            {"matrix":[5, 12], "flags":4, "x":165, "y":64},
-            {"matrix":[5, 13], "flags":1, "x":181, "y":64},
-            {"matrix":[5, 14], "flags":1, "x":198, "y":64},
-            {"matrix":[5, 15], "flags":1, "x":211, "y":64},
-            {"matrix":[3, 15], "flags":1, "x":224, "y":64}
-        ]
-    }
-}

keyboards/keychron/c1_pro/ansi/white/keymaps/keychron/rules.mk

@@ -1,4 +0,0 @@
-VIA_ENABLE = yes
-
-VPATH += keyboards/keychron/common
-SRC += keychron_common.c

keyboards/keychron/c1_pro/ansi/white/rules.mk

@@ -1 +0,0 @@
-# Build Options

keyboards/keychron/c1_pro/ansi/white/white.c

@@ -1,176 +0,0 @@
-/* Copyright 2023 @ Keychron (https://www.keychron.com)
- *
- * 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 <http://www.gnu.org/licenses/>.
- */
-
-#include "quantum.h"
-
-// clang-format off
-#ifdef LED_MATRIX_ENABLE
-const snled27351_led_t PROGMEM g_snled27351_leds[LED_MATRIX_LED_COUNT] = {
-/* Refer to SNLED27351 manual for these locations
- *   driver
- *   |  LED address
- *   |  |   */
-    {0, A_16}, // esc
-    {0, A_15}, // f1
-    {0, A_14}, // f2
-    {0, A_13}, // f3
-    {0, A_12}, // f4
-    {0, A_11}, // f5
-    {0, A_10}, // f6
-    {0, A_9},  // f7
-    {0, A_8},  // f8
-    {0, A_7},  // f9
-    {0, A_6},  // f10
-    {0, A_5},  // f11
-    {0, A_4},  // f12
-    {0, A_2},  // print
-    {0, A_1},  // siri
-    {0, G_1},  // light
-
-    {0, B_16}, // ~
-    {0, B_15}, // 1!
-    {0, B_14}, // 2@
-    {0, B_13}, // 3#
-    {0, B_12}, // 4$
-    {0, B_11}, // 5%
-    {0, B_10}, // 6^
-    {0, B_9},  // 7&
-    {0, B_8},  // 8*
-    {0, B_7},  // 9(
-    {0, B_6},  // 0)
-    {0, B_5},  // -_
-    {0, B_4},  // =+
-    {0, B_3},  // back space
-    {0, B_2},  // INS
-    {0, B_1},  // HOME
-    {0, H_1},  // PGUP
-
-    {0, C_16}, // tab
-    {0, C_15}, // q
-    {0, C_14}, // w
-    {0, C_13}, // e
-    {0, C_12}, // r
-    {0, C_11}, // t
-    {0, C_10}, // y
-    {0, C_9},  // u
-    {0, C_8},  // i
-    {0, C_7},  // o
-    {0, C_6},  // p
-    {0, C_5},  // [{
-    {0, C_4},  // ]}
-    {0, C_3},  // \|
-    {0, C_2},  // DEL
-    {0, C_1},  // END
-    {0, G_6},  // PGDN
-
-    {0, D_16}, // caps lock
-    {0, D_15}, // a
-    {0, D_14}, // s
-    {0, D_13}, // d
-    {0, D_12}, // f
-    {0, D_11}, // g
-    {0, D_10}, // h
-    {0, D_9},  // j
-    {0, D_8},  // k
-    {0, D_7},  // l
-    {0, D_6},  // ;:
-    {0, D_5},  // '"
-    {0, D_3},  // enter
-
-    {0, H_7},  // CPAS
-    {0, H_8},  // MAC
-    {0, H_9},  // WIN
-
-    {0, E_16}, // left shift
-    {0, E_14}, // z
-    {0, E_13}, // x
-    {0, E_12}, // c
-    {0, E_11}, // v
-    {0, E_10}, // b
-    {0, E_9},  // b
-    {0, E_8},  // n
-    {0, E_7},  // m
-    {0, E_6},  // ,<
-    {0, E_5},  // .>
-    {0, E_3},  // right shift
-    {0, E_1},  // up
-
-    {0, F_16}, // left ctrl
-    {0, F_15}, // left command
-    {0, F_14}, // left option
-    {0, F_10}, // space
-    {0, F_6},  // right command
-    {0, F_5},  // right option
-    {0, F_4},  // right ctrl
-    {0, F_3},  // Fn
-    {0, F_2},  // left
-    {0, F_1},  // down
-    {0, G_13}, // right
-};
-
-// clang-format on
-
-bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
-    if (!process_record_user(keycode, record)) {
-        return false;
-    }
-    switch (keycode) {
-        case BL_TOGG:
-            if (record->event.pressed) {
-                switch (led_matrix_get_flags()) {
-                    case LED_FLAG_ALL: {
-                        led_matrix_set_flags(LED_FLAG_NONE);
-                        led_matrix_set_value_all(0);
-                    } break;
-                    default: {
-                        led_matrix_set_flags(LED_FLAG_ALL);
-                    } break;
-                }
-            }
-            if (!led_matrix_is_enabled()) {
-                led_matrix_set_flags(LED_FLAG_ALL);
-                led_matrix_enable();
-            }
-            return false;
-    }
-    return true;
-}
-
-bool led_matrix_indicators_advanced_kb(uint8_t led_min, uint8_t led_max) {
-    if (!led_matrix_indicators_advanced_user(led_min, led_max)) {
-        return false;
-    }
-    if ((host_keyboard_led_state().caps_lock) && (default_layer_state == (1 << 0))) {
-        led_matrix_set_value(CAPS_LOCK_LED_INDEX, 255);
-        led_matrix_set_value(MAC_LOCK_LED_INDEX, 255);
-        led_matrix_set_value(WIN_LOCK_LED_INDEX, 0);
-    } else if ((!host_keyboard_led_state().caps_lock) && (default_layer_state == (1 << 0))) {
-        led_matrix_set_value(CAPS_LOCK_LED_INDEX, 0);
-        led_matrix_set_value(MAC_LOCK_LED_INDEX, 255);
-        led_matrix_set_value(WIN_LOCK_LED_INDEX, 0);
-    } else if ((host_keyboard_led_state().caps_lock) && (default_layer_state == (1 << 2))) {
-        led_matrix_set_value(CAPS_LOCK_LED_INDEX, 255);
-        led_matrix_set_value(MAC_LOCK_LED_INDEX, 0);
-        led_matrix_set_value(WIN_LOCK_LED_INDEX, 255);
-    } else if ((!host_keyboard_led_state().caps_lock) && (default_layer_state == (1 << 2))) {
-        led_matrix_set_value(CAPS_LOCK_LED_INDEX, 0);
-        led_matrix_set_value(MAC_LOCK_LED_INDEX, 0);
-        led_matrix_set_value(WIN_LOCK_LED_INDEX, 255);
-    }
-    return true;
-}
-
-#endif

keyboards/keychron/c1_pro/config.h

@@ -1,37 +0,0 @@
-/* Copyright 2023 @ Keychron(https://www.keychron.com)
- *
- * 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 <http://www.gnu.org/licenses/>.
- */
-
-#pragma once
-
-/* DIP switch */
-#define DIP_SWITCH_MATRIX_GRID { { 5, 4 } }
-
-/* Disable DIP switch in matrix data */
-#define MATRIX_MASKED
-
-/* EEPROM Driver Configuration */
-#define WEAR_LEVELING_LOGICAL_SIZE 2048
-#define WEAR_LEVELING_BACKING_SIZE (WEAR_LEVELING_LOGICAL_SIZE * 2)
-
-/* Increase I2C speed to 1000 KHz */
-#define I2C1_TIMINGR_PRESC 0U
-#define I2C1_TIMINGR_SCLDEL 3U
-#define I2C1_TIMINGR_SDADEL 0U
-#define I2C1_TIMINGR_SCLH 15U
-#define I2C1_TIMINGR_SCLL 51U
-
-/* Old default behavior of mod-taps */
-#define HOLD_ON_OTHER_KEY_PRESS

keyboards/keychron/c2_pro/ansi/rgb/info.json

@@ -1,266 +0,0 @@
-{
-    "usb": {
-        "pid": "0x0520",
-        "device_version": "1.0.0"
-    },
-    "features": {
-        "rgb_matrix": true
-    },
-    "layouts": {
-        "LAYOUT": {
-            "layout": [
-                {"matrix":[0, 0], "x":0, "y":0},
-                {"matrix":[0, 1], "x":2, "y":0},
-                {"matrix":[0, 2], "x":3, "y":0},
-                {"matrix":[0, 3], "x":4, "y":0},
-                {"matrix":[0, 4], "x":5, "y":0},
-                {"matrix":[0, 5], "x":6.5, "y":0},
-                {"matrix":[0, 6], "x":7.5, "y":0},
-                {"matrix":[0, 7], "x":8.5, "y":0},
-                {"matrix":[0, 8], "x":9.5, "y":0},
-                {"matrix":[0, 9], "x":11, "y":0},
-                {"matrix":[0,10], "x":12, "y":0},
-                {"matrix":[0,11], "x":13, "y":0},
-                {"matrix":[0,12], "x":14, "y":0},
-                {"matrix":[0,14], "x":15.25, "y":0},
-                {"matrix":[0,15], "x":16.25, "y":0},
-                {"matrix":[0,16], "x":17.25, "y":0},
-
-                {"matrix":[1, 0], "x":0, "y":1.25},
-                {"matrix":[1, 1], "x":1, "y":1.25},
-                {"matrix":[1, 2], "x":2, "y":1.25},
-                {"matrix":[1, 3], "x":3, "y":1.25},
-                {"matrix":[1, 4], "x":4, "y":1.25},
-                {"matrix":[1, 5], "x":5, "y":1.25},
-                {"matrix":[1, 6], "x":6, "y":1.25},
-                {"matrix":[1, 7], "x":7, "y":1.25},
-                {"matrix":[1, 8], "x":8, "y":1.25},
-                {"matrix":[1, 9], "x":9, "y":1.25},
-                {"matrix":[1,10], "x":10, "y":1.25},
-                {"matrix":[1,11], "x":11, "y":1.25},
-                {"matrix":[1,12], "x":12, "y":1.25},
-                {"matrix":[1,13], "x":13, "y":1.25, "w":2},
-                {"matrix":[1,14], "x":15.25, "y":1.25},
-                {"matrix":[1,15], "x":16.25, "y":1.25},
-                {"matrix":[1,16], "x":17.25, "y":1.25},
-                {"matrix":[1,17], "x":18.5, "y":1.25},
-                {"matrix":[1,18], "x":19.5, "y":1.25},
-                {"matrix":[0,17], "x":20.5, "y":1.25},
-                {"matrix":[0,18], "x":21.5, "y":1.25},
-
-                {"matrix":[2, 0], "x":0, "y":2.25, "w":1.5},
-                {"matrix":[2, 1], "x":1.5, "y":2.25},
-                {"matrix":[2, 2], "x":2.5, "y":2.25},
-                {"matrix":[2, 3], "x":3.5, "y":2.25},
-                {"matrix":[2, 4], "x":4.5, "y":2.25},
-                {"matrix":[2, 5], "x":5.5, "y":2.25},
-                {"matrix":[2, 6], "x":6.5, "y":2.25},
-                {"matrix":[2, 7], "x":7.5, "y":2.25},
-                {"matrix":[2, 8], "x":8.5, "y":2.25},
-                {"matrix":[2, 9], "x":9.5, "y":2.25},
-                {"matrix":[2,10], "x":10.5, "y":2.25},
-                {"matrix":[2,11], "x":11.5, "y":2.25},
-                {"matrix":[2,12], "x":12.5, "y":2.25},
-                {"matrix":[2,13], "x":13.5, "y":2.25, "w":1.5},
-                {"matrix":[2,14], "x":15.25, "y":2.25},
-                {"matrix":[2,15], "x":16.25, "y":2.25},
-                {"matrix":[2,16], "x":17.25, "y":2.25},
-                {"matrix":[2,17], "x":18.5, "y":2.25},
-                {"matrix":[2,18], "x":19.5, "y":2.25},
-                {"matrix":[3,14], "x":20.5, "y":2.25},
-                {"matrix":[3,15], "x":21.5, "y":2.25, "h":2},
-
-                {"matrix":[3, 0], "x":0, "y":3.25, "w":1.75},
-                {"matrix":[3, 1], "x":1.75, "y":3.25},
-                {"matrix":[3, 2], "x":2.75, "y":3.25},
-                {"matrix":[3, 3], "x":3.75, "y":3.25},
-                {"matrix":[3, 4], "x":4.75, "y":3.25},
-                {"matrix":[3, 5], "x":5.75, "y":3.25},
-                {"matrix":[3, 6], "x":6.75, "y":3.25},
-                {"matrix":[3, 7], "x":7.75, "y":3.25},
-                {"matrix":[3, 8], "x":8.75, "y":3.25},
-                {"matrix":[3, 9], "x":9.75, "y":3.25},
-                {"matrix":[3,10], "x":10.75, "y":3.25},
-                {"matrix":[3,11], "x":11.75, "y":3.25},
-                {"matrix":[3,13], "x":12.75, "y":3.25, "w":2.25},
-                {"matrix":[3,17], "x":18.5, "y":3.25},
-                {"matrix":[3,18], "x":19.5, "y":3.25},
-                {"matrix":[3,16], "x":20.5, "y":3.25},
-
-                {"matrix":[4, 0], "x":0, "y":4.25, "w":2.25},
-                {"matrix":[4, 2], "x":2.25, "y":4.25},
-                {"matrix":[4, 3], "x":3.25, "y":4.25},
-                {"matrix":[4, 4], "x":4.25, "y":4.25},
-                {"matrix":[4, 5], "x":5.25, "y":4.25},
-                {"matrix":[4, 6], "x":6.25, "y":4.25},
-                {"matrix":[4, 7], "x":7.25, "y":4.25},
-                {"matrix":[4, 8], "x":8.25, "y":4.25},
-                {"matrix":[4, 9], "x":9.25, "y":4.25},
-                {"matrix":[4,10], "x":10.25, "y":4.25},
-                {"matrix":[4,11], "x":11.25, "y":4.25},
-                {"matrix":[4,13], "x":12.25, "y":4.25, "w":2.75},
-                {"matrix":[4,15], "x":16.25, "y":4.25},
-                {"matrix":[4,17], "x":18.5, "y":4.25},
-                {"matrix":[4,18], "x":19.5, "y":4.25},
-                {"matrix":[4,14], "x":20.5, "y":4.25},
-                {"matrix":[4,16], "x":21.5, "y":4.25, "h":2},
-
-                {"matrix":[5, 0], "x":0, "y":5.25, "w":1.25},
-                {"matrix":[5, 1], "x":1.25, "y":5.25, "w":1.25},
-                {"matrix":[5, 2], "x":2.5, "y":5.25, "w":1.25},
-                {"matrix":[5, 6], "x":3.75, "y":5.25, "w":6.25},
-                {"matrix":[5,10], "x":10, "y":5.25, "w":1.25},
-                {"matrix":[5,11], "x":11.25, "y":5.25, "w":1.25},
-                {"matrix":[5,12], "x":12.5, "y":5.25, "w":1.25},
-                {"matrix":[5,13], "x":13.75, "y":5.25, "w":1.25},
-                {"matrix":[5,14], "x":15.25, "y":5.25},
-                {"matrix":[5,15], "x":16.25, "y":5.25},
-                {"matrix":[5,16], "x":17.25, "y":5.25},
-                {"matrix":[5,17], "x":18.5, "y":5.25, "w":2},
-                {"matrix":[5,18], "x":20.5, "y":5.25}
-            ]
-        }
-    },
-    "rgb_matrix": {
-        "driver": "snled27351",
-        "animations": {
-            "breathing": true,
-            "band_spiral_val": true,
-            "cycle_all": true,
-            "cycle_left_right": true,
-            "cycle_up_down": true,
-            "rainbow_moving_chevron": true,
-            "cycle_out_in": true,
-            "cycle_out_in_dual": true,
-            "cycle_pinwheel": true,
-            "cycle_spiral": true,
-            "dual_beacon": true,
-            "rainbow_beacon": true,
-            "jellybean_raindrops": true,
-            "pixel_rain": true,
-            "typing_heatmap": true,
-            "digital_rain": true,
-            "solid_reactive_simple": true,
-            "solid_reactive_multiwide": true,
-            "solid_reactive_multinexus": true,
-            "splash": true,
-            "solid_splash": true
-        },
-        "layout": [
-            {"matrix":[0, 0],  "flags":1, "x":0,   "y":0},
-            {"matrix":[0, 1],  "flags":1, "x":21,  "y":0},
-            {"matrix":[0, 2],  "flags":1, "x":31,  "y":0},
-            {"matrix":[0, 3],  "flags":1, "x":42,  "y":0},
-            {"matrix":[0, 4],  "flags":1, "x":52,  "y":0},
-            {"matrix":[0, 5],  "flags":1, "x":68,  "y":0},
-            {"matrix":[0, 6],  "flags":1, "x":78,  "y":0},
-            {"matrix":[0, 7],  "flags":1, "x":89,  "y":0},
-            {"matrix":[0, 8],  "flags":1, "x":99,  "y":0},
-            {"matrix":[0, 9],  "flags":1, "x":115, "y":0},
-            {"matrix":[0, 10], "flags":1, "x":125, "y":0},
-            {"matrix":[0, 11], "flags":1, "x":136, "y":0},
-            {"matrix":[0, 12], "flags":1, "x":146, "y":0},
-            {"matrix":[0, 14], "flags":1, "x":159, "y":0},
-            {"matrix":[0, 15], "flags":1, "x":169, "y":0},
-            {"matrix":[0, 16], "flags":1, "x":180, "y":0},
-
-            {"matrix":[0, 13], "flags":8, "x":193, "y":0},
-            {"matrix":[0, 13], "flags":8, "x":203, "y":0},
-            {"matrix":[0, 13], "flags":8, "x":214, "y":0},
-            {"matrix":[0, 13], "flags":8, "x":224, "y":0},
-
-            {"matrix":[1, 0],  "flags":4, "x":0,   "y":15},
-            {"matrix":[1, 1],  "flags":4, "x":10,  "y":15},
-            {"matrix":[1, 2],  "flags":4, "x":21,  "y":15},
-            {"matrix":[1, 3],  "flags":4, "x":31,  "y":15},
-            {"matrix":[1, 4],  "flags":4, "x":42,  "y":15},
-            {"matrix":[1, 5],  "flags":4, "x":52,  "y":15},
-            {"matrix":[1, 6],  "flags":4, "x":63,  "y":15},
-            {"matrix":[1, 7],  "flags":4, "x":73,  "y":15},
-            {"matrix":[1, 8],  "flags":4, "x":83,  "y":15},
-            {"matrix":[1, 9],  "flags":4, "x":94,  "y":15},
-            {"matrix":[1, 10], "flags":4, "x":104, "y":15},
-            {"matrix":[1, 11], "flags":4, "x":115, "y":15},
-            {"matrix":[1, 12], "flags":4, "x":125, "y":15},
-            {"matrix":[1, 13], "flags":1, "x":141, "y":15},
-            {"matrix":[1, 14], "flags":1, "x":159, "y":15},
-            {"matrix":[1, 15], "flags":1, "x":169, "y":15},
-            {"matrix":[1, 16], "flags":1, "x":180, "y":15},
-            {"matrix":[1, 17], "flags":8, "x":193, "y":15},
-            {"matrix":[1, 18], "flags":4, "x":203, "y":15},
-            {"matrix":[0, 17], "flags":4, "x":214, "y":15},
-            {"matrix":[0, 18], "flags":4, "x":224, "y":15},
-
-            {"matrix":[2, 0],  "flags":1, "x":3,   "y":27},
-            {"matrix":[2, 1],  "flags":4, "x":16,  "y":27},
-            {"matrix":[2, 2],  "flags":4, "x":26,  "y":27},
-            {"matrix":[2, 3],  "flags":4, "x":36,  "y":27},
-            {"matrix":[2, 4],  "flags":4, "x":47,  "y":27},
-            {"matrix":[2, 5],  "flags":4, "x":57,  "y":27},
-            {"matrix":[2, 6],  "flags":4, "x":68,  "y":27},
-            {"matrix":[2, 7],  "flags":4, "x":78,  "y":27},
-            {"matrix":[2, 8],  "flags":4, "x":89,  "y":27},
-            {"matrix":[2, 9],  "flags":4, "x":99,  "y":27},
-            {"matrix":[2, 10], "flags":4, "x":109, "y":27},
-            {"matrix":[2, 11], "flags":4, "x":120, "y":27},
-            {"matrix":[2, 12], "flags":4, "x":130, "y":27},
-            {"matrix":[2, 13], "flags":4, "x":143, "y":27},
-            {"matrix":[2, 14], "flags":1, "x":159, "y":27},
-            {"matrix":[2, 15], "flags":1, "x":169, "y":27},
-            {"matrix":[2, 16], "flags":1, "x":180, "y":27},
-            {"matrix":[2, 17], "flags":4, "x":193, "y":27},
-            {"matrix":[2, 18], "flags":4, "x":203, "y":27},
-            {"matrix":[3, 14], "flags":4, "x":214, "y":27},
-            {"matrix":[3, 15], "flags":4, "x":224, "y":27},
-
-            {"matrix":[3, 0],  "flags":8, "x":4,   "y":40},
-            {"matrix":[3, 1],  "flags":4, "x":18,  "y":40},
-            {"matrix":[3, 2],  "flags":4, "x":29,  "y":40},
-            {"matrix":[3, 3],  "flags":4, "x":39,  "y":40},
-            {"matrix":[3, 4],  "flags":4, "x":50,  "y":40},
-            {"matrix":[3, 5],  "flags":4, "x":60,  "y":40},
-            {"matrix":[3, 6],  "flags":4, "x":70,  "y":40},
-            {"matrix":[3, 7],  "flags":4, "x":81,  "y":40},
-            {"matrix":[3, 8],  "flags":4, "x":91,  "y":40},
-            {"matrix":[3, 9],  "flags":4, "x":102, "y":40},
-            {"matrix":[3, 10], "flags":4, "x":112, "y":40},
-            {"matrix":[3, 11], "flags":4, "x":123, "y":40},
-            {"matrix":[3, 13], "flags":4, "x":139, "y":40},
-            {"matrix":[3, 17], "flags":4, "x":193, "y":40},
-            {"matrix":[3, 18], "flags":4, "x":203, "y":40},
-            {"matrix":[3, 16], "flags":4, "x":214, "y":40},
-
-            {"matrix":[4, 0],  "flags":1, "x":7,   "y":52},
-            {"matrix":[4, 2],  "flags":4, "x":23,  "y":52},
-            {"matrix":[4, 3],  "flags":4, "x":34,  "y":52},
-            {"matrix":[4, 4],  "flags":4, "x":44,  "y":52},
-            {"matrix":[4, 5],  "flags":4, "x":55,  "y":52},
-            {"matrix":[4, 6],  "flags":4, "x":65,  "y":52},
-            {"matrix":[4, 7],  "flags":4, "x":76,  "y":52},
-            {"matrix":[4, 8],  "flags":4, "x":86,  "y":52},
-            {"matrix":[4, 9],  "flags":4, "x":96,  "y":52},
-            {"matrix":[4, 10], "flags":4, "x":107, "y":52},
-            {"matrix":[4, 11], "flags":4, "x":117, "y":52},
-            {"matrix":[4, 13], "flags":1, "x":137, "y":52},
-            {"matrix":[4, 15], "flags":1, "x":169, "y":52},
-            {"matrix":[4, 17], "flags":4, "x":193, "y":52},
-            {"matrix":[4, 18], "flags":4, "x":203, "y":52},
-            {"matrix":[4, 14], "flags":4, "x":214, "y":52},
-            {"matrix":[4, 16], "flags":4, "x":224, "y":52},
-
-            {"matrix":[5, 0],  "flags":1, "x":1,   "y":64},
-            {"matrix":[5, 1],  "flags":1, "x":14,  "y":64},
-            {"matrix":[5, 2],  "flags":1, "x":27,  "y":64},
-            {"matrix":[5, 6],  "flags":4, "x":66,  "y":64},
-            {"matrix":[5, 10], "flags":1, "x":105, "y":64},
-            {"matrix":[5, 11], "flags":1, "x":118, "y":64},
-            {"matrix":[5, 12], "flags":4, "x":131, "y":64},
-            {"matrix":[5, 13], "flags":1, "x":145, "y":64},
-            {"matrix":[5, 14], "flags":1, "x":159, "y":64},
-            {"matrix":[5, 15], "flags":1, "x":169, "y":64},
-            {"matrix":[5, 16], "flags":1, "x":180, "y":64},
-            {"matrix":[5, 17], "flags":4, "x":198, "y":64},
-            {"matrix":[5, 18], "flags":4, "x":214, "y":64}
-        ]
-    }
-}

keyboards/keychron/c2_pro/ansi/rgb/keymaps/default/keymap.c

@@ -1,63 +0,0 @@
-/* Copyright 2023 @ Keychron (https://www.keychron.com)
- *
- * 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 <http://www.gnu.org/licenses/>.
- */
-
-#include QMK_KEYBOARD_H
-
-// clang-format off
-
-enum layers{
-  MAC_BASE,
-  MAC_FN,
-  WIN_BASE,
-  WIN_FN
-};
-
-#define KC_TASK LGUI(KC_TAB)
-#define KC_FLXP LGUI(KC_E)
-
-const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-    [MAC_BASE] = LAYOUT(
-        KC_ESC,             KC_BRID,  KC_BRIU,  KC_MCTL,  KC_LPAD,  RGB_VAD,  RGB_VAI,  KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_MUTE,  KC_VOLD,    KC_VOLU,  KC_NO,    KC_NO,    RGB_MOD,
-        KC_GRV,   KC_1,     KC_2,     KC_3,     KC_4,     KC_5,     KC_6,     KC_7,     KC_8,     KC_9,     KC_0,     KC_MINS,  KC_EQL,     KC_BSPC,  KC_INS,   KC_HOME,  KC_PGUP,  KC_NUM,   KC_PSLS,  KC_PAST,  KC_PMNS,
-        KC_TAB,   KC_Q,     KC_W,     KC_E,     KC_R,     KC_T,     KC_Y,     KC_U,     KC_I,     KC_O,     KC_P,     KC_LBRC,  KC_RBRC,    KC_BSLS,  KC_DEL,   KC_END,   KC_PGDN,  KC_P7,    KC_P8,    KC_P9,    KC_PPLS,
-        KC_CAPS,  KC_A,     KC_S,     KC_D,     KC_F,     KC_G,     KC_H,     KC_J,     KC_K,     KC_L,     KC_SCLN,  KC_QUOT,              KC_ENT,                                 KC_P4,    KC_P5,    KC_P6,
-        KC_LSFT,            KC_Z,     KC_X,     KC_C,     KC_V,     KC_B,     KC_N,     KC_M,     KC_COMM,  KC_DOT,   KC_SLSH,              KC_RSFT,            KC_UP,              KC_P1,    KC_P2,    KC_P3,    KC_PENT,
-        KC_LCTL,  KC_LOPT,  KC_LCMD,                                KC_SPC,                                 KC_RCMD,  KC_ROPT,  MO(MAC_FN), KC_RCTL,  KC_LEFT,  KC_DOWN,  KC_RGHT,  KC_P0,              KC_PDOT         ),
-
-    [MAC_FN] = LAYOUT(
-        _______,            KC_F1,    KC_F2,    KC_F3,    KC_F4,    KC_F5,    KC_F6,    KC_F7,    KC_F8,    KC_F9,    KC_F10,   KC_F11,     KC_F12,   _______,  _______,  RGB_TOG,
-        _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,
-        RGB_TOG,  RGB_MOD,  RGB_VAI,  RGB_HUI,  RGB_SAI,  RGB_SPI,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,
-        _______,  RGB_RMOD, RGB_VAD,  RGB_HUD,  RGB_SAD,  RGB_SPD,  _______,  _______,  _______,  _______,  _______,  _______,              _______,                                _______,  _______,  _______,
-        _______,            _______,  _______,  _______,  _______,  _______,  NK_TOGG,  _______,  _______,  _______,  _______,              _______,            _______,            _______,  _______,  _______,  _______,
-        _______,  _______,  _______,                                _______,                                _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,            _______         ),
-
-    [WIN_BASE] = LAYOUT(
-        KC_ESC,             KC_F1,    KC_F2,    KC_F3,    KC_F4,    KC_F5,    KC_F6,    KC_F7,    KC_F8,    KC_F9,    KC_F10,   KC_F11,     KC_F12,   KC_PSCR,  KC_NO,    RGB_MOD,
-        KC_GRV,   KC_1,     KC_2,     KC_3,     KC_4,     KC_5,     KC_6,     KC_7,     KC_8,     KC_9,     KC_0,     KC_MINS,  KC_EQL,     KC_BSPC,  KC_INS,   KC_HOME,  KC_PGUP,  KC_NUM,   KC_PSLS,  KC_PAST,  KC_PMNS,
-        KC_TAB,   KC_Q,     KC_W,     KC_E,     KC_R,     KC_T,     KC_Y,     KC_U,     KC_I,     KC_O,     KC_P,     KC_LBRC,  KC_RBRC,    KC_BSLS,  KC_DEL,   KC_END,   KC_PGDN,  KC_P7,    KC_P8,    KC_P9,    KC_PPLS,
-        KC_CAPS,  KC_A,     KC_S,     KC_D,     KC_F,     KC_G,     KC_H,     KC_J,     KC_K,     KC_L,     KC_SCLN,  KC_QUOT,              KC_ENT,                                 KC_P4,    KC_P5,    KC_P6,
-        KC_LSFT,            KC_Z,     KC_X,     KC_C,     KC_V,     KC_B,     KC_N,     KC_M,     KC_COMM,  KC_DOT,   KC_SLSH,              KC_RSFT,            KC_UP,              KC_P1,    KC_P2,    KC_P3,    KC_PENT,
-        KC_LCTL,  KC_LWIN,  KC_LALT,                                KC_SPC,                                 KC_RALT,  KC_RWIN,  MO(WIN_FN), KC_RCTL,  KC_LEFT,  KC_DOWN,  KC_RGHT,  KC_P0,              KC_PDOT         ),
-
-    [WIN_FN] = LAYOUT(
-        _______,            KC_BRID,  KC_BRIU,  KC_TASK,  KC_FLXP,  RGB_VAD,  RGB_VAI,  KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_MUTE,  KC_VOLD,    KC_VOLU,  _______,  _______,  RGB_TOG,
-        _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,
-        RGB_TOG,  RGB_MOD,  RGB_VAI,  RGB_HUI,  RGB_SAI,  RGB_SPI,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,
-        _______,  RGB_RMOD, RGB_VAD,  RGB_HUD,  RGB_SAD,  RGB_SPD,  _______,  _______,  _______,  _______,  _______,  _______,              _______,                                _______,  _______,  _______,
-        _______,            _______,  _______,  _______,  _______,  _______,  NK_TOGG,  _______,  _______,  _______,  _______,              _______,            _______,            _______,  _______,  _______,  _______,
-        _______,  _______,  _______,                                _______,                                _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,            _______         ),
-};

keyboards/keychron/c2_pro/ansi/rgb/keymaps/keychron/rules.mk

@@ -1,4 +0,0 @@
-VIA_ENABLE = yes
-
-VPATH += keyboards/keychron/common
-SRC += keychron_common.c

keyboards/keychron/c2_pro/ansi/rgb/keymaps/via/keymap.c

@@ -1,61 +0,0 @@
-/* Copyright 2023 @ Keychron (https://www.keychron.com)
- *
- * 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 <http://www.gnu.org/licenses/>.
- */
-
-#include QMK_KEYBOARD_H
-
-enum layers{
-  MAC_BASE,
-  MAC_FN,
-  WIN_BASE,
-  WIN_FN
-};
-
-#define KC_TASK LGUI(KC_TAB)
-#define KC_FLXP LGUI(KC_E)
-
-const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-    [MAC_BASE] = LAYOUT(
-        KC_ESC,             KC_BRID,  KC_BRIU,  KC_MCTL,  KC_LPAD,  RGB_VAD,  RGB_VAI,  KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_MUTE,  KC_VOLD,    KC_VOLU,  KC_NO,    KC_NO,    RGB_MOD,
-        KC_GRV,   KC_1,     KC_2,     KC_3,     KC_4,     KC_5,     KC_6,     KC_7,     KC_8,     KC_9,     KC_0,     KC_MINS,  KC_EQL,     KC_BSPC,  KC_INS,   KC_HOME,  KC_PGUP,  KC_NUM,   KC_PSLS,  KC_PAST,  KC_PMNS,
-        KC_TAB,   KC_Q,     KC_W,     KC_E,     KC_R,     KC_T,     KC_Y,     KC_U,     KC_I,     KC_O,     KC_P,     KC_LBRC,  KC_RBRC,    KC_BSLS,  KC_DEL,   KC_END,   KC_PGDN,  KC_P7,    KC_P8,    KC_P9,    KC_PPLS,
-        KC_CAPS,  KC_A,     KC_S,     KC_D,     KC_F,     KC_G,     KC_H,     KC_J,     KC_K,     KC_L,     KC_SCLN,  KC_QUOT,              KC_ENT,                                 KC_P4,    KC_P5,    KC_P6,
-        KC_LSFT,            KC_Z,     KC_X,     KC_C,     KC_V,     KC_B,     KC_N,     KC_M,     KC_COMM,  KC_DOT,   KC_SLSH,              KC_RSFT,            KC_UP,              KC_P1,    KC_P2,    KC_P3,    KC_PENT,
-        KC_LCTL,  KC_LOPT,  KC_LCMD,                                KC_SPC,                                 KC_RCMD,  KC_ROPT,  MO(MAC_FN), KC_RCTL,  KC_LEFT,  KC_DOWN,  KC_RGHT,  KC_P0,              KC_PDOT         ),
-
-    [MAC_FN] = LAYOUT(
-        _______,            KC_F1,    KC_F2,    KC_F3,    KC_F4,    KC_F5,    KC_F6,    KC_F7,    KC_F8,    KC_F9,    KC_F10,   KC_F11,     KC_F12,   _______,  _______,  RGB_TOG,
-        _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,
-        RGB_TOG,  RGB_MOD,  RGB_VAI,  RGB_HUI,  RGB_SAI,  RGB_SPI,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,
-        _______,  RGB_RMOD, RGB_VAD,  RGB_HUD,  RGB_SAD,  RGB_SPD,  _______,  _______,  _______,  _______,  _______,  _______,              _______,                                _______,  _______,  _______,
-        _______,            _______,  _______,  _______,  _______,  _______,  NK_TOGG,  _______,  _______,  _______,  _______,              _______,            _______,            _______,  _______,  _______,  _______,
-        _______,  _______,  _______,                                _______,                                _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,            _______         ),
-
-    [WIN_BASE] = LAYOUT(
-        KC_ESC,             KC_F1,    KC_F2,    KC_F3,    KC_F4,    KC_F5,    KC_F6,    KC_F7,    KC_F8,    KC_F9,    KC_F10,   KC_F11,     KC_F12,   KC_PSCR,  KC_NO,    RGB_MOD,
-        KC_GRV,   KC_1,     KC_2,     KC_3,     KC_4,     KC_5,     KC_6,     KC_7,     KC_8,     KC_9,     KC_0,     KC_MINS,  KC_EQL,     KC_BSPC,  KC_INS,   KC_HOME,  KC_PGUP,  KC_NUM,   KC_PSLS,  KC_PAST,  KC_PMNS,
-        KC_TAB,   KC_Q,     KC_W,     KC_E,     KC_R,     KC_T,     KC_Y,     KC_U,     KC_I,     KC_O,     KC_P,     KC_LBRC,  KC_RBRC,    KC_BSLS,  KC_DEL,   KC_END,   KC_PGDN,  KC_P7,    KC_P8,    KC_P9,    KC_PPLS,
-        KC_CAPS,  KC_A,     KC_S,     KC_D,     KC_F,     KC_G,     KC_H,     KC_J,     KC_K,     KC_L,     KC_SCLN,  KC_QUOT,              KC_ENT,                                 KC_P4,    KC_P5,    KC_P6,
-        KC_LSFT,            KC_Z,     KC_X,     KC_C,     KC_V,     KC_B,     KC_N,     KC_M,     KC_COMM,  KC_DOT,   KC_SLSH,              KC_RSFT,            KC_UP,              KC_P1,    KC_P2,    KC_P3,    KC_PENT,
-        KC_LCTL,  KC_LWIN,  KC_LALT,                                KC_SPC,                                 KC_RALT,  KC_RWIN,  MO(WIN_FN), KC_RCTL,  KC_LEFT,  KC_DOWN,  KC_RGHT,  KC_P0,              KC_PDOT         ),
-
-    [WIN_FN] = LAYOUT(
-        _______,            KC_BRID,  KC_BRIU,  KC_TASK,  KC_FLXP,  RGB_VAD,  RGB_VAI,  KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_MUTE,  KC_VOLD,    KC_VOLU,  _______,  _______,  RGB_TOG,
-        _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,
-        RGB_TOG,  RGB_MOD,  RGB_VAI,  RGB_HUI,  RGB_SAI,  RGB_SPI,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,
-        _______,  RGB_RMOD, RGB_VAD,  RGB_HUD,  RGB_SAD,  RGB_SPD,  _______,  _______,  _______,  _______,  _______,  _______,              _______,                                _______,  _______,  _______,
-        _______,            _______,  _______,  _______,  _______,  _______,  NK_TOGG,  _______,  _______,  _______,  _______,              _______,            _______,            _______,  _______,  _______,  _______,
-        _______,  _______,  _______,                                _______,                                _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,            _______         ),
-};

keyboards/keychron/c2_pro/ansi/rgb/rules.mk

@@ -1,2 +0,0 @@
-# Build Options
-SRC += matrix.c

keyboards/keychron/c2_pro/ansi/white/keymaps/keychron/rules.mk

@@ -1,4 +0,0 @@
-VIA_ENABLE = yes
-
-VPATH += keyboards/keychron/common
-SRC += keychron_common.c

keyboards/keychron/c2_pro/ansi/white/keymaps/via/keymap.c

@@ -1,61 +0,0 @@
-/* Copyright 2023 @ Keychron (https://www.keychron.com)
- *
- * 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 <http://www.gnu.org/licenses/>.
- */
-
-#include QMK_KEYBOARD_H
-
-enum layers{
-  MAC_BASE,
-  MAC_FN,
-  WIN_BASE,
-  WIN_FN
-};
-
-#define KC_TASK LGUI(KC_TAB)
-#define KC_FLXP LGUI(KC_E)
-
-const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-    [MAC_BASE] = LAYOUT(
-        KC_ESC,             KC_BRID,  KC_BRIU,  KC_MCTL,  KC_LPAD,  BL_DOWN,  BL_UP,    KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_MUTE,  KC_VOLD,    KC_VOLU,  KC_NO,    KC_NO,    BL_STEP,
-        KC_GRV,   KC_1,     KC_2,     KC_3,     KC_4,     KC_5,     KC_6,     KC_7,     KC_8,     KC_9,     KC_0,     KC_MINS,  KC_EQL,     KC_BSPC,  KC_INS,   KC_HOME,  KC_PGUP,  KC_NUM,   KC_PSLS,  KC_PAST,  KC_PMNS,
-        KC_TAB,   KC_Q,     KC_W,     KC_E,     KC_R,     KC_T,     KC_Y,     KC_U,     KC_I,     KC_O,     KC_P,     KC_LBRC,  KC_RBRC,    KC_BSLS,  KC_DEL,   KC_END,   KC_PGDN,  KC_P7,    KC_P8,    KC_P9,    KC_PPLS,
-        KC_CAPS,  KC_A,     KC_S,     KC_D,     KC_F,     KC_G,     KC_H,     KC_J,     KC_K,     KC_L,     KC_SCLN,  KC_QUOT,              KC_ENT,                                 KC_P4,    KC_P5,    KC_P6,
-        KC_LSFT,            KC_Z,     KC_X,     KC_C,     KC_V,     KC_B,     KC_N,     KC_M,     KC_COMM,  KC_DOT,   KC_SLSH,              KC_RSFT,            KC_UP,              KC_P1,    KC_P2,    KC_P3,    KC_PENT,
-        KC_LCTL,  KC_LOPT,  KC_LCMD,                                KC_SPC,                                 KC_RCMD,  KC_ROPT,  MO(MAC_FN), KC_RCTL,  KC_LEFT,  KC_DOWN,  KC_RGHT,  KC_P0,              KC_PDOT         ),
-
-    [MAC_FN] = LAYOUT(
-        _______,            KC_F1,    KC_F2,    KC_F3,    KC_F4,    KC_F5,    KC_F6,    KC_F7,    KC_F8,    KC_F9,    KC_F10,   KC_F11,     KC_F12,   _______,  _______,  BL_TOGG,
-        _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,
-        BL_TOGG,  BL_STEP,  BL_UP,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,
-        _______,  _______,  BL_DOWN,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,              _______,                                _______,  _______,  _______,
-        _______,            _______,  _______,  _______,  _______,  _______,  NK_TOGG,  _______,  _______,  _______,  _______,              _______,            _______,            _______,  _______,  _______,  _______,
-        _______,  _______,  _______,                                _______,                                _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,            _______         ),
-
-    [WIN_BASE] = LAYOUT(
-        KC_ESC,             KC_F1,    KC_F2,    KC_F3,    KC_F4,    KC_F5,    KC_F6,    KC_F7,    KC_F8,    KC_F9,    KC_F10,   KC_F11,     KC_F12,   KC_PSCR,  KC_NO,    BL_STEP,
-        KC_GRV,   KC_1,     KC_2,     KC_3,     KC_4,     KC_5,     KC_6,     KC_7,     KC_8,     KC_9,     KC_0,     KC_MINS,  KC_EQL,     KC_BSPC,  KC_INS,   KC_HOME,  KC_PGUP,  KC_NUM,   KC_PSLS,  KC_PAST,  KC_PMNS,
-        KC_TAB,   KC_Q,     KC_W,     KC_E,     KC_R,     KC_T,     KC_Y,     KC_U,     KC_I,     KC_O,     KC_P,     KC_LBRC,  KC_RBRC,    KC_BSLS,  KC_DEL,   KC_END,   KC_PGDN,  KC_P7,    KC_P8,    KC_P9,    KC_PPLS,
-        KC_CAPS,  KC_A,     KC_S,     KC_D,     KC_F,     KC_G,     KC_H,     KC_J,     KC_K,     KC_L,     KC_SCLN,  KC_QUOT,              KC_ENT,                                 KC_P4,    KC_P5,    KC_P6,
-        KC_LSFT,            KC_Z,     KC_X,     KC_C,     KC_V,     KC_B,     KC_N,     KC_M,     KC_COMM,  KC_DOT,   KC_SLSH,              KC_RSFT,            KC_UP,              KC_P1,    KC_P2,    KC_P3,    KC_PENT,
-        KC_LCTL,  KC_LWIN,  KC_LALT,                                KC_SPC,                                 KC_RALT,  KC_RWIN,  MO(WIN_FN), KC_RCTL,  KC_LEFT,  KC_DOWN,  KC_RGHT,  KC_P0,              KC_PDOT         ),
-
-    [WIN_FN] = LAYOUT(
-        _______,            KC_BRID,  KC_BRIU,  KC_TASK,  KC_FLXP,  BL_DOWN,   BL_UP,   KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_MUTE,  KC_VOLD,    KC_VOLU,  _______,  _______,  BL_TOGG,
-        _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,
-        BL_TOGG,  BL_STEP,  BL_UP,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,
-        _______,  _______,  BL_DOWN,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,              _______,                                _______,  _______,  _______,
-        _______,            _______,  _______,  _______,  _______,  _______,  NK_TOGG,  _______,  _______,  _______,  _______,              _______,            _______,            _______,  _______,  _______,  _______,
-        _______,  _______,  _______,                                _______,                                _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,            _______         ),
-};

keyboards/keychron/c2_pro/ansi/white/rules.mk

@@ -1,2 +0,0 @@
-# Build Options
-SRC += matrix.c

keyboards/keychron/c2_pro/c2_pro.c

@@ -1,129 +0,0 @@
-/* Copyright 2023 @ Keychron (https://www.keychron.com)
- *
- * 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 <http://www.gnu.org/licenses/>.
- */
-
-#include "quantum.h"
-
-// clang-format off
-const matrix_row_t matrix_mask[] = {
-    0b11111111111111111111,
-    0b11111111111111111111,
-    0b11111111111111111111,
-    0b11111111111111111111,
-    0b11111111111111111111,
-    0b11111111111111101111,
-};
-
-// clang-format on
-
-#ifdef DIP_SWITCH_ENABLE
-
-bool dip_switch_update_kb(uint8_t index, bool active) {
-    if (!dip_switch_update_user(index, active)) {
-        return false;
-    }
-    if (index == 0) {
-        default_layer_set(1UL << (active ? 2 : 0));
-    }
-    return true;
-}
-
-#endif // DIP_SWITCH_ENABLE
-
-#    ifdef RGB_MATRIX_ENABLE
-#        define LED_SET_FLAGS rgb_matrix_set_flags
-#        define LED_GET_FLAGS rgb_matrix_get_flags
-#        define LED_SET_ALL_OFF rgb_matrix_set_color_all(COLOR_BLACK)
-#        define LED_IS_ENABLED rgb_matrix_is_enabled
-#        define LED_ENABLE rgb_matrix_enable
-#        define LED_MATRIX_INDICATORS_KB rgb_matrix_indicators_kb
-#        define LED_MATRIX_INDICATORS_USER rgb_matrix_indicators_user
-#        define LED_MATRIX_SET_COLOR rgb_matrix_set_color
-#        define LED_MATRIX_UPDATE_PWN_BUFFERS rgb_matrix_update_pwm_buffers
-#        define LED_MATRIX_INDICATORS_NONE_KB rgb_matrix_indicators_none_kb
-#        define LED_MATRIX_IS_ENABLED rgb_matrix_is_enabled
-#        define COLOR_WHITE 255, 255, 255
-#        define COLOR_BLACK 0, 0, 0
-#    endif
-
-#    ifdef LED_MATRIX_ENABLE
-#        define LED_SET_FLAGS led_matrix_set_flags
-#        define LED_GET_FLAGS led_matrix_get_flags
-#        define LED_SET_ALL_OFF led_matrix_set_value_all(COLOR_BLACK)
-#        define LED_IS_ENABLED led_matrix_is_enabled
-#        define LED_ENABLE led_matrix_enable
-#        define LED_MATRIX_INDICATORS_KB led_matrix_indicators_kb
-#        define LED_MATRIX_INDICATORS_USER led_matrix_indicators_user
-#        define LED_MATRIX_SET_COLOR led_matrix_set_value
-#        define LED_MATRIX_UPDATE_PWN_BUFFERS led_matrix_update_pwm_buffers
-#        define LED_MATRIX_INDICATORS_NONE_KB led_matrix_indicators_none_kb
-#        define LED_MATRIX_IS_ENABLED led_matrix_is_enabled
-#        define COLOR_WHITE 255
-#        define COLOR_BLACK 0
-
-bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
-    if (!process_record_user(keycode, record)) {
-        return false;
-    }
-    switch (keycode) {
-        case RGB_TOG:
-            if (record->event.pressed) {
-                switch (LED_GET_FLAGS()) {
-                    case LED_FLAG_ALL: {
-                        LED_SET_FLAGS(LED_FLAG_NONE);
-                        LED_SET_ALL_OFF;
-                    } break;
-                    default: {
-                        LED_SET_FLAGS(LED_FLAG_ALL);
-                    } break;
-                }
-            }
-            if (!LED_IS_ENABLED()) {
-                LED_SET_FLAGS(LED_FLAG_ALL);
-                LED_ENABLE();
-            }
-            return false;
-    }
-    return true;
-}
-
-bool LED_MATRIX_INDICATORS_KB(void) {
-    if (!LED_MATRIX_INDICATORS_USER()) {
-        return false;
-    }
-    if (host_keyboard_led_state().caps_lock) {
-        LED_MATRIX_SET_COLOR(CAPS_LED_INDEX, COLOR_WHITE);
-    } else {
-        LED_MATRIX_SET_COLOR(CAPS_LED_INDEX, COLOR_BLACK);
-    }
-    if (host_keyboard_led_state().num_lock) {
-        LED_MATRIX_SET_COLOR(NUM_LED_INDEX, COLOR_WHITE);
-    } else {
-        LED_MATRIX_SET_COLOR(NUM_LED_INDEX, COLOR_BLACK);
-    }
-    if (default_layer_state == (1 << 0)) {
-        LED_MATRIX_SET_COLOR(MAC_LED_INDEX, COLOR_WHITE);
-    } else {
-        LED_MATRIX_SET_COLOR(MAC_LED_INDEX, COLOR_BLACK);
-    }
-    if (default_layer_state == (1 << 2)) {
-        LED_MATRIX_SET_COLOR(WIN_LED_INDEX, COLOR_WHITE);
-    } else {
-        LED_MATRIX_SET_COLOR(WIN_LED_INDEX, COLOR_BLACK);
-    }
-    return true;
-}
-
-#endif

keyboards/keychron/c2_pro/config.h

@@ -1,44 +0,0 @@
-/* Copyright 2023 @ Keychron(https://www.keychron.com)
- *
- * 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 <http://www.gnu.org/licenses/>.
- */
-
-#pragma once
-
-/* DIP switch */
-#define DIP_SWITCH_MATRIX_GRID { { 5, 4 } }
-
-/* Disable DIP switch in matrix data */
-#define MATRIX_MASKED
-
-/* EEPROM Driver Configuration */
-#define WEAR_LEVELING_LOGICAL_SIZE 2048
-#define WEAR_LEVELING_BACKING_SIZE (WEAR_LEVELING_LOGICAL_SIZE * 2)
-
-/* Increase I2C speed to 1000 KHz */
-#define I2C1_TIMINGR_PRESC 0U
-#define I2C1_TIMINGR_SCLDEL 3U
-#define I2C1_TIMINGR_SDADEL 0U
-#define I2C1_TIMINGR_SCLH 15U
-#define I2C1_TIMINGR_SCLL 51U
-
-/* Old default behavior of mod-taps */
-#define HOLD_ON_OTHER_KEY_PRESS
-
-/* HC595 used pins definiton */
-#define HC595_STCP A0
-#define HC595_SHCP A1
-#define HC595_DS C15
-#define SHIFT_COL_START 11
-#define SHIFT_COL_END 18

keyboards/keychron/c2_pro/readme.md

@@ -1,23 +0,0 @@
-# Keychron C2 Pro
-
-![Keychron C2 Pro](https://i.imgur.com/BQE1tFOh.jpg)
-
-A customizable 100% keyboard.
-
-* Keyboard Maintainer: [Keychron](https://github.com/keychron)
-* Hardware Supported: Keychron C2 Pro
-* Hardware Availability: [Keychron](https://www.keychron.com)
-
-Make example for this keyboard (after setting up your build environment):
-
-    make keychron/c2/ansi/rgb:default
-    make keychron/c2/ansi/white:default
-
-Flashing example for this keyboard:
-
-    make keychron/c2/ansi/rgb:default:flash
-    make keychron/c2/ansi/white:default:flash
-
-**Reset Key**: Hold down the key located at *K00*, commonly programmed as *Esc* while plugging in the keyboard.
-
-See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs).

keyboards/keychron/common/Backup 1 of factory_test.c

@@ -0,0 +1,445 @@
+/* Copyright 2021 @ Keychron (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "quantum.h"
+#include "raw_hid.h"
+#include "via.h"
+
+#include "keychron_task.h"
+#ifdef LK_WIRELESS_ENABLE
+#    include "transport.h"
+#    include "battery.h"
+#    include "lpm.h"
+#    include "lkbt51.h"
+#    include "indicator.h"
+#endif
+#include "config.h"
+#include "version.h"
+
+#ifndef RAW_EPSIZE
+#    define RAW_EPSIZE 32
+#endif
+
+#ifndef BL_CYCLE_KEY
+#    define BL_CYCLE_KEY KC_RIGHT
+#endif
+
+#ifndef BL_TRIG_KEY
+#    define BL_TRIG_KEY KC_HOME
+#endif
+
+#ifndef P2P4G_CELAR_MASK
+#    define P2P4G_CELAR_MASK P2P4G_CLEAR_PAIRING_TYPE_C
+#endif
+
+enum {
+    BACKLIGHT_TEST_OFF = 0,
+    BACKLIGHT_TEST_WHITE,
+    BACKLIGHT_TEST_RED,
+    BACKLIGHT_TEST_GREEN,
+    BACKLIGHT_TEST_BLUE,
+    BACKLIGHT_TEST_MAX,
+};
+
+enum {
+    KEY_PRESS_FN             = 0x01 << 0,
+    KEY_PRESS_J              = 0x01 << 1,
+    KEY_PRESS_Z              = 0x01 << 2,
+    KEY_PRESS_BL_KEY1        = 0x01 << 3,
+    KEY_PRESS_BL_KEY2        = 0x01 << 4,
+    KEY_PRESS_FACTORY_RESET  = KEY_PRESS_FN | KEY_PRESS_J | KEY_PRESS_Z,
+    KEY_PRESS_BACKLIGTH_TEST = KEY_PRESS_FN | KEY_PRESS_BL_KEY1 | KEY_PRESS_BL_KEY2,
+};
+
+enum {
+    FACTORY_TEST_CMD_BACKLIGHT = 0x01,
+    FACTORY_TEST_CMD_OS_SWITCH,
+    FACTORY_TEST_CMD_JUMP_TO_BL,
+    FACTORY_TEST_CMD_INT_PIN,
+    FACTORY_TEST_CMD_GET_TRANSPORT,
+    FACTORY_TEST_CMD_CHARGING_ADC,
+    FACTORY_TEST_CMD_RADIO_CARRIER,
+    FACTORY_TEST_CMD_GET_BUILD_TIME,
+};
+
+enum {
+    P2P4G_CLEAR_PAIRING_TYPE_A = 0x01 << 0,
+    P2P4G_CLEAR_PAIRING_TYPE_C = 0x01 << 1,
+};
+
+enum {
+    OS_SWITCH = 0x01,
+};
+
+static uint32_t factory_reset_timer = 0;
+static uint8_t  factory_reset_state = 0;
+static uint8_t  backlight_test_mode = BACKLIGHT_TEST_OFF;
+
+static uint32_t factory_reset_ind_timer = 0;
+static uint8_t  factory_reset_ind_state = 0;
+static bool     report_os_sw_state      = false;
+static bool     keys_released           = true;
+
+void factory_timer_start(void) {
+    factory_reset_timer = timer_read32();
+}
+
+static inline void factory_timer_check(void) {
+    if (timer_elapsed32(factory_reset_timer) > 3000) {
+        factory_reset_timer = 0;
+
+        if (factory_reset_state == KEY_PRESS_FACTORY_RESET) {
+            factory_reset_ind_timer = timer_read32();
+            factory_reset_ind_state++;
+            keys_released = false;
+
+            clear_keyboard(); // Avoid key being pressed after NKRO state changed
+            layer_state_t default_layer_tmp = default_layer_state;
+            eeconfig_init();
+            keymap_config.raw = eeconfig_read_keymap();
+            default_layer_set(default_layer_tmp);
+#ifdef LED_MATRIX_ENABLE
+            if (!led_matrix_is_enabled()) led_matrix_enable();
+            led_matrix_init();
+#endif
+#ifdef RGB_MATRIX_ENABLE
+            if (!rgb_matrix_is_enabled()) rgb_matrix_enable();
+            rgb_matrix_init();
+#endif
+#ifdef LK_WIRELESS_ENABLE
+            lkbt51_factory_reset(P2P4G_CELAR_MASK);
+#endif
+        } else if (factory_reset_state == KEY_PRESS_BACKLIGTH_TEST) {
+#ifdef LED_MATRIX_ENABLE
+            if (!led_matrix_is_enabled()) led_matrix_enable();
+#endif
+#ifdef RGB_MATRIX_ENABLE
+            if (!rgb_matrix_is_enabled()) rgb_matrix_enable();
+#endif
+            backlight_test_mode = BACKLIGHT_TEST_WHITE;
+        }
+
+        factory_reset_state = 0;
+    }
+}
+
+static inline void factory_reset_ind_timer_check(void) {
+    if (factory_reset_ind_timer && timer_elapsed32(factory_reset_ind_timer) > 250) {
+        if (factory_reset_ind_state++ > 6) {
+            factory_reset_ind_timer = factory_reset_ind_state = 0;
+        } else {
+            factory_reset_ind_timer = timer_read32();
+        }
+    }
+}
+
+bool process_record_factory_test(uint16_t keycode, keyrecord_t *record) {
+    switch (keycode) {
+#if defined(FN_KEY_1) || defined(FN_KEY_2)
+#    if defined(FN_KEY_1)
+        case FN_KEY_1: /* fall through */
+#    endif
+#    if defined(FN_KEY_2)
+        case FN_KEY_2:
+#    endif
+#    if defined(FN_KEY_3)
+        case FN_KEY_3:
+#    endif
+            if (record->event.pressed) {
+                factory_reset_state |= KEY_PRESS_FN;
+            } else {
+                factory_reset_state &= ~KEY_PRESS_FN;
+                factory_reset_timer = 0;
+            }
+            break;
+#endif
+        case KC_J:
+            if (record->event.pressed) {
+                factory_reset_state |= KEY_PRESS_J;
+                if (factory_reset_state == 0x07) factory_timer_start();
+                if (factory_reset_state & KEY_PRESS_FN) return false;
+            } else {
+                factory_reset_state &= ~KEY_PRESS_J;
+                factory_reset_timer = 0;
+            }
+            break;
+        case KC_Z:
+#if defined(FN_Z_KEY)
+        case FN_Z_KEY:
+#endif
+            if (record->event.pressed) {
+                factory_reset_state |= KEY_PRESS_Z;
+                if (factory_reset_state == 0x07) factory_timer_start();
+                if ((factory_reset_state & KEY_PRESS_FN) && keycode == KC_Z) return false;
+            } else {
+                factory_reset_state &= ~KEY_PRESS_Z;
+                factory_reset_timer = 0;
+                /* Avoid changing backlight effect on key released if FN_Z_KEY is mode*/
+
+                if (!keys_released && keycode >= QK_BACKLIGHT_ON && keycode <= RGB_MODE_TWINKLE) {
+                    keys_released = true;
+                    return false;
+                }
+            }
+            break;
+#if defined(BL_CYCLE_KEY) || defined(BL_CYCLE_KEY_2)
+#    if defined(BL_CYCLE_KEY)
+        case BL_CYCLE_KEY:
+#    endif
+#    if defined(FN_BL_CYCLE_KEY)
+        case FN_BL_CYCLE_KEY:
+#    endif
+            if (record->event.pressed) {
+                if (backlight_test_mode) {
+                    if (++backlight_test_mode >= BACKLIGHT_TEST_MAX) {
+                        backlight_test_mode = BACKLIGHT_TEST_WHITE;
+                    }
+                } else {
+                    factory_reset_state |= KEY_PRESS_BL_KEY1;
+                    if (factory_reset_state == 0x19) {
+                        factory_timer_start();
+                    }
+                }
+            } else {
+                factory_reset_state &= ~KEY_PRESS_BL_KEY1;
+                factory_reset_timer = 0;
+            }
+            break;
+#endif
+#if defined(BL_TRIG_KEY) || defined(BL_TRIG_KEY_2)
+#    if defined(BL_TRIG_KEY)
+        case BL_TRIG_KEY:
+#    endif
+#    if defined(FN_BL_TRIG_KEY)
+        case FN_BL_TRIG_KEY:
+#    endif
+            if (record->event.pressed) {
+                if (backlight_test_mode) {
+                    backlight_test_mode = BACKLIGHT_TEST_OFF;
+                } else {
+                    factory_reset_state |= KEY_PRESS_BL_KEY2;
+                    if (factory_reset_state == 0x19) {
+                        factory_timer_start();
+                    }
+                }
+            } else {
+                factory_reset_state &= ~KEY_PRESS_BL_KEY2;
+                factory_reset_timer = 0;
+            }
+            break;
+#endif
+    }
+
+    return true;
+}
+
+#ifdef LED_MATRIX_ENABLE
+bool factory_test_indicator(void) {
+    if (factory_reset_ind_state) {
+        led_matrix_set_value_all(factory_reset_ind_state % 2 ? 0 : 255);
+        return false;
+    }
+
+    return true;
+}
+#endif
+
+#ifdef RGB_MATRIX_ENABLE
+bool factory_test_indicator(void) {
+    if (factory_reset_ind_state) {
+        backlight_test_mode = BACKLIGHT_TEST_OFF;
+        rgb_matrix_set_color_all(factory_reset_ind_state % 2 ? 0 : 255, 0, 0);
+        return false;
+    } else if (backlight_test_mode) {
+        switch (backlight_test_mode) {
+            case BACKLIGHT_TEST_WHITE:
+                rgb_matrix_set_color_all(255, 255, 255);
+                break;
+            case BACKLIGHT_TEST_RED:
+                rgb_matrix_set_color_all(255, 0, 0);
+                break;
+            case BACKLIGHT_TEST_GREEN:
+                rgb_matrix_set_color_all(0, 255, 0);
+                break;
+            case BACKLIGHT_TEST_BLUE:
+                rgb_matrix_set_color_all(0, 0, 255);
+                break;
+        }
+        return false;
+    }
+
+    return true;
+}
+#endif
+
+bool factory_reset_indicating(void) {
+    return factory_reset_ind_timer;
+}
+
+bool factory_test_task(void) {
+    if (factory_reset_timer) factory_timer_check();
+    if (factory_reset_ind_timer) factory_reset_ind_timer_check();
+
+    return true;
+}
+
+#ifdef LEMOKEY_CALLBACK_ENABLE
+void factory_test_init(void) {
+    register_lemokey_task(factory_test_task, false);
+    register_record_process(process_record_factory_test, false);
+    register_led_indicator_task(factory_test_indicator, false);
+}
+#endif
+
+void factory_test_send(uint8_t *payload, uint8_t length) {
+#ifdef RAW_ENABLE
+    uint16_t checksum         = 0;
+    uint8_t  data[RAW_EPSIZE] = {0};
+
+    uint8_t i = 0;
+    data[i++] = 0xAB;
+
+    memcpy(&data[i], payload, length);
+    i += length;
+
+    for (uint8_t i = 1; i < RAW_EPSIZE - 3; i++)
+        checksum += data[i];
+    data[RAW_EPSIZE - 2] = checksum & 0xFF;
+    data[RAW_EPSIZE - 1] = (checksum >> 8) & 0xFF;
+
+    raw_hid_send(data, RAW_EPSIZE);
+#endif
+}
+
+void factory_test_rx(uint8_t *data, uint8_t length) {
+    if (data[0] == 0xAB) {
+        uint16_t checksum = 0;
+
+        for (uint8_t i = 1; i < RAW_EPSIZE - 3; i++) {
+            checksum += data[i];
+        }
+        /* Verify checksum */
+        if ((checksum & 0xFF) != data[RAW_EPSIZE - 2] || checksum >> 8 != data[RAW_EPSIZE - 1]) return;
+
+#ifdef LK_WIRELESS_ENABLE
+        uint8_t payload[32];
+        uint8_t len = 0;
+#endif
+
+        switch (data[1]) {
+            case FACTORY_TEST_CMD_BACKLIGHT:
+                backlight_test_mode = data[2];
+                factory_reset_timer = 0;
+                break;
+            case FACTORY_TEST_CMD_OS_SWITCH:
+                report_os_sw_state = data[2];
+                if (report_os_sw_state) {
+                    // dip_switch_read(true);
+                }
+                break;
+            case FACTORY_TEST_CMD_JUMP_TO_BL:
+                // if (memcmp(&data[2], "JumpToBootloader", strlen("JumpToBootloader")) == 0) bootloader_jump();
+                break;
+#ifdef LK_WIRELESS_ENABLE
+            case FACTORY_TEST_CMD_INT_PIN:
+                switch (data[2]) {
+                    /* Enalbe/disable test */
+                    case 0xA1:
+                        lkbt51_int_pin_test(data[3]);
+                        break;
+                    /* Set INT state */
+                    case 0xA2:
+                        kc_printf("pin %d\n\r", data[3]);
+                        writePin(BLUETOOTH_INT_OUTPUT_PIN, data[3]);
+                        break;
+                        /* Report INT state */
+                        //                    case 0xA3:
+                        //                        payload[len++] = FACTORY_TEST_CMD_INT_PIN;
+                        //                        payload[len++] = 0xA3;
+                        //                        payload[len++] = readPin(LKBT51_INT_INPUT_PIN);
+                        //                        factory_test_send(payload, len);
+                        //                        break;
+                }
+                break;
+            case FACTORY_TEST_CMD_GET_TRANSPORT:
+                payload[len++] = FACTORY_TEST_CMD_GET_TRANSPORT;
+                payload[len++] = get_transport();
+                payload[len++] = readPin(USB_POWER_SENSE_PIN);
+                factory_test_send(payload, len);
+                break;
+#endif
+#ifdef BATTERY_CHARGE_DONE_DETECT_ADC
+            case FACTORY_TEST_CMD_CHARGING_ADC:
+            case 0xA1:
+                battery_charging_monitor(data[3]);
+                break;
+            case 0xA2:
+                payload[len++] = FACTORY_TEST_CMD_CHARGING_ADC;
+                payload[len++] = battery_adc_read_charging_pin();
+                factory_test_send(payload, len);
+                break;
+#endif
+#ifdef LK_WIRELESS_ENABLE
+            case FACTORY_TEST_CMD_RADIO_CARRIER:
+                if (data[2] < 79) lkbt51_radio_test(data[2]);
+                break;
+
+#    ifdef WERELESS_PRESSURE_TEST
+            case 0x70:
+                switch (data[2]) {
+                    /* Enalbe/disable test */
+                    case 0xB1:
+                        SEND_STRING("abcdefghijklmnopqrstuvwxyz1234567890abcdefghijklmnopqrstuvwxyz1234567890abcdefghijklmnopqrstuvwxyz1234567890\n");
+                        break;
+                    case 0xB2:
+                        payload[len++] = 0x70;
+                        payload[len++] = 0xB2;
+                        payload[len++] = wireless_get_state();
+                        factory_test_send(payload, len);
+                        break;
+                }
+                break;
+#    endif
+#endif
+            case FACTORY_TEST_CMD_GET_BUILD_TIME: {
+                payload[len++] = FACTORY_TEST_CMD_GET_BUILD_TIME;
+                payload[len++] = 'v';
+                if ((DEVICE_VER & 0xF000) != 0) itoa((DEVICE_VER >> 12), (char *)&payload[len++], 16);
+                itoa((DEVICE_VER >> 8) & 0xF, (char *)&payload[len++], 16);
+                payload[len++] = '.';
+                itoa((DEVICE_VER >> 4) & 0xF, (char *)&payload[len++], 16);
+                payload[len++] = '.';
+                itoa((DEVICE_VER >> 4) & 0xF, (char *)&payload[len++], 16);
+                payload[len++] = ' ';
+                memcpy(&payload[len], QMK_BUILDDATE, sizeof(QMK_BUILDDATE));
+                len += sizeof(QMK_BUILDDATE);
+                factory_test_send(payload, len);
+            } break;
+        }
+    }
+}
+
+bool dip_switch_update_user(uint8_t index, bool active) {
+    if (report_os_sw_state) {
+#ifdef INVERT_OS_SWITCH_STATE
+        active = !active;
+#endif
+        uint8_t payload[3] = {FACTORY_TEST_CMD_OS_SWITCH, OS_SWITCH, active};
+        factory_test_send(payload, 3);
+    }
+
+    return true;
+}

keyboards/keychron/common/Backup 1 of keychron_common.c

@@ -0,0 +1,210 @@
+/* Copyright 2023 @ Keychron (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include QMK_KEYBOARD_H
+#include "keychron_common.h"
+#include "raw_hid.h"
+#include "version.h"
+
+#ifdef FACTORY_TEST_ENABLE
+#    include "factory_test.h"
+#    include "keychron_common.h"
+#endif
+
+#ifdef LK_WIRELESS_ENABLE
+#    include "lkbt51.h"
+#endif
+
+bool     is_siri_active = false;
+uint32_t siri_timer     = 0;
+
+static uint8_t mac_keycode[4] = {KC_LOPT, KC_ROPT, KC_LCMD, KC_RCMD};
+
+static key_combination_t key_comb_list[4] = {{2, {KC_LWIN, KC_TAB}}, {2, {KC_LWIN, KC_E}}, {3, {KC_LSFT, KC_LCMD, KC_4}}, {2, {KC_LWIN, KC_C}}};
+
+bool process_record_lemokey_common(uint16_t keycode, keyrecord_t *record) {
+    switch (keycode) {
+        case KC_MCTRL:
+            if (record->event.pressed) {
+                register_code(KC_MISSION_CONTROL);
+            } else {
+                unregister_code(KC_MISSION_CONTROL);
+            }
+            return false; // Skip all further processing of this key
+        case KC_LNPAD:
+            if (record->event.pressed) {
+                register_code(KC_LAUNCHPAD);
+            } else {
+                unregister_code(KC_LAUNCHPAD);
+            }
+            return false; // Skip all further processing of this key
+        case KC_LOPTN:
+        case KC_ROPTN:
+        case KC_LCMMD:
+        case KC_RCMMD:
+            if (record->event.pressed) {
+                register_code(mac_keycode[keycode - KC_LOPTN]);
+            } else {
+                unregister_code(mac_keycode[keycode - KC_LOPTN]);
+            }
+            return false; // Skip all further processing of this key
+        case KC_SIRI:
+            if (record->event.pressed) {
+                if (!is_siri_active) {
+                    is_siri_active = true;
+                    register_code(KC_LCMD);
+                    register_code(KC_SPACE);
+                }
+                siri_timer = timer_read32();
+            } else {
+                // Do something else when release
+            }
+            return false; // Skip all further processing of this key
+        case KC_TASK:
+        case KC_FILE:
+        case KC_SNAP:
+        case KC_CTANA:
+            if (record->event.pressed) {
+                for (uint8_t i = 0; i < key_comb_list[keycode - KC_TASK].len; i++) {
+                    register_code(key_comb_list[keycode - KC_TASK].keycode[i]);
+                }
+            } else {
+                for (uint8_t i = 0; i < key_comb_list[keycode - KC_TASK].len; i++) {
+                    unregister_code(key_comb_list[keycode - KC_TASK].keycode[i]);
+                }
+            }
+            return false; // Skip all further processing of this key
+        default:
+            return true; // Process all other keycodes normally
+    }
+}
+
+void lemokey_common_task(void) {
+    if (is_siri_active && timer_elapsed32(siri_timer) > 500) {
+        unregister_code(KC_LCMD);
+        unregister_code(KC_SPACE);
+        is_siri_active = false;
+        siri_timer     = 0;
+    }
+}
+
+#ifdef ENCODER_ENABLE
+static void encoder0_pad_cb(void *param) {
+    (void)param;
+    encoder_inerrupt_read(0);
+}
+
+void encoder_cb_init(void) {
+    pin_t encoders_pad_a[] = ENCODERS_PAD_A;
+    pin_t encoders_pad_b[] = ENCODERS_PAD_B;
+    palEnableLineEvent(encoders_pad_a[0], PAL_EVENT_MODE_BOTH_EDGES);
+    palEnableLineEvent(encoders_pad_b[0], PAL_EVENT_MODE_BOTH_EDGES);
+    palSetLineCallback(encoders_pad_a[0], encoder0_pad_cb, NULL);
+    palSetLineCallback(encoders_pad_b[0], encoder0_pad_cb, NULL);
+}
+#endif
+
+//__attribute__((weak)) bool raw_hid_receive_lemokey(uint8_t *data, uint8_t length) { return true; }
+#define PROTOCOL_VERSION 0x02
+
+enum { kc_get_protocol_version = 0xA0, kc_get_firmware_version = 0xA1, kc_get_support_feature = 0xA2, kc_get_default_layer = 0xA3 };
+
+enum {
+    FEATURE_DEFAULT_LAYER = 0x01 << 0,
+    FEATURE_BLUETOOTH     = 0x01 << 1,
+    FEATURE_P2P4G         = 0x01 << 2,
+    FEATURE_ANALOG_MATRIX = 0x01 << 3,
+};
+
+void get_support_feature(uint8_t *data) {
+    data[1] = FEATURE_DEFAULT_LAYER
+#ifdef KC_BLUETOOTH_ENABLE
+              | FEATURE_BLUETOOTH
+#endif
+#ifdef LK_WIRELESS_ENABLE
+              | FEATURE_BLUETOOTH | FEATURE_P2P4G
+#endif
+#ifdef ANANLOG_MATRIX
+              | FEATURE_ANALOG_MATRIX
+#endif
+        ;
+}
+
+bool via_command_kb(uint8_t *data, uint8_t length) {
+    // if (!raw_hid_receive_lemokey(data, length))
+    //     return false;
+    switch (data[0]) {
+        case kc_get_protocol_version:
+            data[1] = PROTOCOL_VERSION;
+            raw_hid_send(data, length);
+            break;
+
+        case kc_get_firmware_version: {
+            uint8_t i = 1;
+            data[i++] = 'v';
+            if ((DEVICE_VER & 0xF000) != 0) itoa((DEVICE_VER >> 12), (char *)&data[i++], 16);
+            itoa((DEVICE_VER >> 8) & 0xF, (char *)&data[i++], 16);
+            data[i++] = '.';
+            itoa((DEVICE_VER >> 4) & 0xF, (char *)&data[i++], 16);
+            data[i++] = '.';
+            itoa((DEVICE_VER >> 4) & 0xF, (char *)&data[i++], 16);
+            data[i++] = ' ';
+            memcpy(&data[i], QMK_BUILDDATE, sizeof(QMK_BUILDDATE));
+            i += sizeof(QMK_BUILDDATE);
+            raw_hid_send(data, length);
+        } break;
+
+        case kc_get_support_feature:
+            get_support_feature(&data[1]);
+            raw_hid_send(data, length);
+            break;
+
+        case kc_get_default_layer:
+            data[1] = get_highest_layer(default_layer_state);
+            raw_hid_send(data, length);
+            break;
+
+#ifdef ANANLOG_MATRIX
+        case 0xA9:
+            analog_matrix_rx(data, length);
+            break;
+#endif
+#ifdef LK_WIRELESS_ENABLE
+        case 0xAA:
+            lkbt51_dfu_rx(data, length);
+            break;
+#endif
+#ifdef FACTORY_TEST_ENABLE
+        case 0xAB:
+            factory_test_rx(data, length);
+            break;
+#endif
+        default:
+            return false;
+    }
+
+    return true;
+}
+
+#if !defined(VIA_ENABLE)
+void raw_hid_receive(uint8_t *data, uint8_t length) {
+    switch (data[0]) {
+        case RAW_HID_CMD:
+            via_command_kb(data, length);
+            break;
+    }
+}
+#endif

keyboards/keychron/common/Backup 1 of keychron_common.h

@@ -0,0 +1,75 @@
+/* Copyright 2023 @ Keychron (https://www.lemokey.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "stdint.h"
+
+// clang-format off
+enum {
+    KC_LOPTN = QK_KB_0,
+    KC_ROPTN,
+    KC_LCMMD,
+    KC_RCMMD,
+    KC_MCTRL,
+    KC_LNPAD,
+    KC_TASK_VIEW,
+    KC_FILE_EXPLORER,
+    KC_SCREEN_SHOT,
+    KC_CORTANA,
+    KC_SIRI,
+#ifdef LK_WIRELESS_ENABLE
+    BT_HST1,
+    BT_HST2,
+    BT_HST3,
+    P2P4G,
+    BAT_LVL,
+#else
+    BT_HST1 = _______,
+    BT_HST2 = _______,
+    BT_HST3 = _______,
+    P2P4G   = _______,
+    BAT_LVL = _______,
+#endif
+#ifdef DANANLOG_MATRIX
+    PROF1,
+    PROF2,
+    PROF3,
+#else
+    PROF1 = _______,
+    PROF2 = _______,
+    PROF3 = _______,
+#endif
+    NEW_SAFE_RANGE,
+};
+
+#define KC_TASK KC_TASK_VIEW
+#define KC_FILE KC_FILE_EXPLORER
+#define KC_SNAP KC_SCREEN_SHOT
+#define KC_CTANA KC_CORTANA
+
+typedef struct PACKED {
+    uint8_t len;
+    uint8_t keycode[3];
+} key_combination_t;
+
+bool process_record_lemokey_common(uint16_t keycode, keyrecord_t *record);
+void lemokey_common_task(void);
+
+#ifdef ENCODER_ENABLE
+void encoder_cb_init(void);
+#endif
+

keyboards/keychron/common/Backup 1 of keychron_task.c

@@ -0,0 +1,239 @@
+/* Copyright 2023 @ Keychron (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdlib.h>
+#include "keychron_task.h"
+#include "quantum.h"
+#include "keychron_common.h"
+#ifdef FACTORY_TEST_ENABLE
+#    include "factory_test.h"
+#endif
+
+#ifdef LEMOKEY_CALLBACK_ENABLE
+
+typedef struct lk_node {
+    lemokey_cb      lk_cb;
+    struct lk_node *next;
+} lk_Node;
+
+typedef struct lk_process_node {
+    lemokey_record_process_cb process_cb;
+    struct lk_process_node   *next;
+} lk_process_Node;
+
+lk_Node         *p;
+lk_Node         *lk_task_list = NULL;
+lk_process_Node *p_process;
+lk_process_Node *lk_record_process_list = NULL;
+
+#    if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
+lk_Node *led_indicator_task_list = NULL;
+#    endif
+
+void register_lemokey_cb(lk_Node **head, lemokey_cb cb, bool priority) {
+    /* Create task node */
+    lk_Node *task = (lk_Node *)malloc(sizeof(lk_Node));
+    task->lk_cb   = cb;
+    task->next    = NULL;
+
+    /* Add to the list*/
+    if (*head) {
+        if (priority) {
+            task->next = *head;
+            *head      = task;
+        } else {
+            p = *head;
+            while (p->next)
+                p = p->next;
+            p->next = task;
+        }
+    } else {
+        *head = task;
+    }
+}
+
+void deregister_lemokey_cb(lk_Node **head, lemokey_cb cb) {
+    p = *head;
+    while (p) {
+        if (p->lk_cb == cb) {
+            // lk_Node* temp = p;
+            // if
+        }
+    }
+}
+
+void register_lemokey_task(lemokey_cb cb, bool priority) {
+    register_lemokey_cb(&lk_task_list, cb, priority);
+}
+
+void register_led_indicator_task(lemokey_cb cb, bool priority) {
+    register_lemokey_cb(&led_indicator_task_list, cb, priority);
+}
+
+void register_record_process(lemokey_record_process_cb cb, bool priority) {
+    lk_process_Node *process = (lk_process_Node *)malloc(sizeof(lk_process_Node));
+    process->process_cb      = cb;
+    process->next            = NULL;
+
+    /* Add to the list*/
+    if (lk_record_process_list) {
+        if (priority) {
+            process->next          = lk_record_process_list;
+            lk_record_process_list = process;
+        } else {
+            p_process = lk_record_process_list;
+            while (p_process->next)
+                p_process = p_process->next;
+            p_process->next = process;
+        }
+    } else {
+        lk_record_process_list = process;
+    }
+}
+
+inline void lemokey_task(void) {
+    p = lk_task_list;
+    while (p) {
+        p->lk_cb();
+        p = p->next;
+    }
+}
+
+inline bool process_record_lemokey(uint16_t keycode, keyrecord_t *record) {
+    p_process = lk_record_process_list;
+    while (p_process) {
+        if (!p_process->process_cb(keycode, record)) {
+            return false;
+        }
+        p_process = p_process->next;
+    }
+
+    return true;
+}
+
+#    if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
+#        if defined(LED_MATRIX_ENABLE)
+inline bool led_matrix_indicators_lemokey(void) {
+#        else
+inline bool rgb_matrix_indicators_lemokey(void) {
+#        endif
+
+    p = led_indicator_task_list;
+    while (p) {
+        p->lk_cb();
+        p = p->next;
+    }
+
+    return true;
+}
+#    endif
+
+#else
+
+__attribute__((weak)) bool process_record_lemokey_kb(uint16_t keycode, keyrecord_t *record) {
+    return true;
+}
+
+bool process_record_lemokey(uint16_t keycode, keyrecord_t *record) {
+#    ifdef LK_WIRELESS_ENABLE
+    extern bool process_record_wireless(uint16_t keycode, keyrecord_t * record);
+    if (!process_record_wireless(keycode, record)) return false;
+#    endif
+#    ifdef FACTORY_TEST_ENABLE
+    if (!process_record_factory_test(keycode, record)) return false;
+#    endif
+    // extern bool process_record_lemokey_kb(uint16_t keycode, keyrecord_t *record);
+
+    if (!process_record_lemokey_kb(keycode, record)) return false;
+
+    return true;
+}
+
+#    if defined(LED_MATRIX_ENABLE)
+bool led_matrix_indicators_lemokey(void) {
+#        ifdef LK_WIRELESS_ENABLE
+    extern bool led_matrix_indicators_bt(void);
+    led_matrix_indicators_bt();
+#        endif
+#        ifdef FACTORY_TEST_ENABLE
+    factory_test_indicator();
+#        endif
+    return true;
+}
+#    endif
+
+#    if defined(RGB_MATRIX_ENABLE)
+bool rgb_matrix_indicators_lemokey(void) {
+#        ifdef LK_WIRELESS_ENABLE
+    extern bool rgb_matrix_indicators_bt(void);
+    rgb_matrix_indicators_bt();
+#        endif
+#        ifdef FACTORY_TEST_ENABLE
+    factory_test_indicator();
+#        endif
+    return true;
+}
+#    endif
+
+__attribute__((weak)) bool lemokey_task_kb(void) {
+    return true;
+}
+
+void lemokey_task(void) {
+#    ifdef LK_WIRELESS_ENABLE
+    extern void wireless_tasks(void);
+    wireless_tasks();
+#    endif
+#    ifdef FACTORY_TEST_ENABLE
+    factory_test_task();
+#    endif
+    lemokey_common_task();
+
+    lemokey_task_kb();
+}
+#endif // #ifdef LEMOKEY_CALLBACK_ENABLE
+
+bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
+    if (!process_record_user(keycode, record)) return false;
+
+    if (!process_record_lemokey(keycode, record)) return false;
+
+    return true;
+}
+
+#ifdef RGB_MATRIX_ENABLE
+bool rgb_matrix_indicators_kb(void) {
+    if (!rgb_matrix_indicators_user()) return false;
+
+    rgb_matrix_indicators_lemokey();
+
+    return true;
+}
+#endif
+
+#ifdef LED_MATRIX_ENABLE
+bool led_matrix_indicators_kb(void) {
+    if (!led_matrix_indicators_user()) return false;
+
+    led_matrix_indicators_lemokey();
+
+    return true;
+}
+#endif
+
+void housekeeping_task_kb(void) {
+    lemokey_task();
+}

keyboards/keychron/common/Backup 1 of keychron_task.h

@@ -0,0 +1,41 @@
+/* Copyright 2022 @ Keychron (https://www.lemokey.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+ 
+#pragma once
+
+#include "stdint.h"
+#include "action.h"
+
+#ifdef LEMOKEY_CALLBACK_ENABLE
+typedef bool (*lemokey_cb)(void);
+typedef bool (*lemokey_record_process_cb)(uint16_t keycode, keyrecord_t *record);
+
+
+bool process_record_lemokey(uint16_t keycode, keyrecord_t *record);
+
+void register_lemokey_task(lemokey_cb cb, bool priority);
+void register_record_process(lemokey_record_process_cb cb, bool priority);
+#if defined(LED_MATRIX_ENABLE) ||  defined(RGB_MATRIX_ENABLE)
+void register_led_indicator_task(lemokey_cb cb, bool priority);
+#endif
+
+#else
+bool lemokey_task_kb(void);
+bool process_record_lemokey_kb(uint16_t keycode, keyrecord_t *record);
+
+#endif
+void lemokey_task(void);
+

keyboards/keychron/common/Backup 2 of factory_test.c

@@ -0,0 +1,445 @@
+/* Copyright 2021 @ Keychron (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "quantum.h"
+#include "raw_hid.h"
+#include "via.h"
+
+#include "keychron_task.h"
+#ifdef LK_WIRELESS_ENABLE
+#    include "transport.h"
+#    include "battery.h"
+#    include "lpm.h"
+#    include "lkbt51.h"
+#    include "indicator.h"
+#endif
+#include "config.h"
+#include "version.h"
+
+#ifndef RAW_EPSIZE
+#    define RAW_EPSIZE 32
+#endif
+
+#ifndef BL_CYCLE_KEY
+#    define BL_CYCLE_KEY KC_RIGHT
+#endif
+
+#ifndef BL_TRIG_KEY
+#    define BL_TRIG_KEY KC_HOME
+#endif
+
+#ifndef P2P4G_CELAR_MASK
+#    define P2P4G_CELAR_MASK P2P4G_CLEAR_PAIRING_TYPE_C
+#endif
+
+enum {
+    BACKLIGHT_TEST_OFF = 0,
+    BACKLIGHT_TEST_WHITE,
+    BACKLIGHT_TEST_RED,
+    BACKLIGHT_TEST_GREEN,
+    BACKLIGHT_TEST_BLUE,
+    BACKLIGHT_TEST_MAX,
+};
+
+enum {
+    KEY_PRESS_FN             = 0x01 << 0,
+    KEY_PRESS_J              = 0x01 << 1,
+    KEY_PRESS_Z              = 0x01 << 2,
+    KEY_PRESS_BL_KEY1        = 0x01 << 3,
+    KEY_PRESS_BL_KEY2        = 0x01 << 4,
+    KEY_PRESS_FACTORY_RESET  = KEY_PRESS_FN | KEY_PRESS_J | KEY_PRESS_Z,
+    KEY_PRESS_BACKLIGTH_TEST = KEY_PRESS_FN | KEY_PRESS_BL_KEY1 | KEY_PRESS_BL_KEY2,
+};
+
+enum {
+    FACTORY_TEST_CMD_BACKLIGHT = 0x01,
+    FACTORY_TEST_CMD_OS_SWITCH,
+    FACTORY_TEST_CMD_JUMP_TO_BL,
+    FACTORY_TEST_CMD_INT_PIN,
+    FACTORY_TEST_CMD_GET_TRANSPORT,
+    FACTORY_TEST_CMD_CHARGING_ADC,
+    FACTORY_TEST_CMD_RADIO_CARRIER,
+    FACTORY_TEST_CMD_GET_BUILD_TIME,
+};
+
+enum {
+    P2P4G_CLEAR_PAIRING_TYPE_A = 0x01 << 0,
+    P2P4G_CLEAR_PAIRING_TYPE_C = 0x01 << 1,
+};
+
+enum {
+    OS_SWITCH = 0x01,
+};
+
+static uint32_t factory_reset_timer = 0;
+static uint8_t  factory_reset_state = 0;
+static uint8_t  backlight_test_mode = BACKLIGHT_TEST_OFF;
+
+static uint32_t factory_reset_ind_timer = 0;
+static uint8_t  factory_reset_ind_state = 0;
+static bool     report_os_sw_state      = false;
+static bool     keys_released           = true;
+
+void factory_timer_start(void) {
+    factory_reset_timer = timer_read32();
+}
+
+static inline void factory_timer_check(void) {
+    if (timer_elapsed32(factory_reset_timer) > 3000) {
+        factory_reset_timer = 0;
+
+        if (factory_reset_state == KEY_PRESS_FACTORY_RESET) {
+            factory_reset_ind_timer = timer_read32();
+            factory_reset_ind_state++;
+            keys_released = false;
+
+            clear_keyboard(); // Avoid key being pressed after NKRO state changed
+            layer_state_t default_layer_tmp = default_layer_state;
+            eeconfig_init();
+            keymap_config.raw = eeconfig_read_keymap();
+            default_layer_set(default_layer_tmp);
+#ifdef LED_MATRIX_ENABLE
+            if (!led_matrix_is_enabled()) led_matrix_enable();
+            led_matrix_init();
+#endif
+#ifdef RGB_MATRIX_ENABLE
+            if (!rgb_matrix_is_enabled()) rgb_matrix_enable();
+            rgb_matrix_init();
+#endif
+#ifdef LK_WIRELESS_ENABLE
+            lkbt51_factory_reset(P2P4G_CELAR_MASK);
+#endif
+        } else if (factory_reset_state == KEY_PRESS_BACKLIGTH_TEST) {
+#ifdef LED_MATRIX_ENABLE
+            if (!led_matrix_is_enabled()) led_matrix_enable();
+#endif
+#ifdef RGB_MATRIX_ENABLE
+            if (!rgb_matrix_is_enabled()) rgb_matrix_enable();
+#endif
+            backlight_test_mode = BACKLIGHT_TEST_WHITE;
+        }
+
+        factory_reset_state = 0;
+    }
+}
+
+static inline void factory_reset_ind_timer_check(void) {
+    if (factory_reset_ind_timer && timer_elapsed32(factory_reset_ind_timer) > 250) {
+        if (factory_reset_ind_state++ > 6) {
+            factory_reset_ind_timer = factory_reset_ind_state = 0;
+        } else {
+            factory_reset_ind_timer = timer_read32();
+        }
+    }
+}
+
+bool process_record_factory_test(uint16_t keycode, keyrecord_t *record) {
+    switch (keycode) {
+#if defined(FN_KEY_1) || defined(FN_KEY_2)
+#    if defined(FN_KEY_1)
+        case FN_KEY_1: /* fall through */
+#    endif
+#    if defined(FN_KEY_2)
+        case FN_KEY_2:
+#    endif
+#    if defined(FN_KEY_3)
+        case FN_KEY_3:
+#    endif
+            if (record->event.pressed) {
+                factory_reset_state |= KEY_PRESS_FN;
+            } else {
+                factory_reset_state &= ~KEY_PRESS_FN;
+                factory_reset_timer = 0;
+            }
+            break;
+#endif
+        case KC_J:
+            if (record->event.pressed) {
+                factory_reset_state |= KEY_PRESS_J;
+                if (factory_reset_state == 0x07) factory_timer_start();
+                if (factory_reset_state & KEY_PRESS_FN) return false;
+            } else {
+                factory_reset_state &= ~KEY_PRESS_J;
+                factory_reset_timer = 0;
+            }
+            break;
+        case KC_Z:
+#if defined(FN_Z_KEY)
+        case FN_Z_KEY:
+#endif
+            if (record->event.pressed) {
+                factory_reset_state |= KEY_PRESS_Z;
+                if (factory_reset_state == 0x07) factory_timer_start();
+                if ((factory_reset_state & KEY_PRESS_FN) && keycode == KC_Z) return false;
+            } else {
+                factory_reset_state &= ~KEY_PRESS_Z;
+                factory_reset_timer = 0;
+                /* Avoid changing backlight effect on key released if FN_Z_KEY is mode*/
+
+                if (!keys_released && keycode >= QK_BACKLIGHT_ON && keycode <= RGB_MODE_TWINKLE) {
+                    keys_released = true;
+                    return false;
+                }
+            }
+            break;
+#if defined(BL_CYCLE_KEY) || defined(BL_CYCLE_KEY_2)
+#    if defined(BL_CYCLE_KEY)
+        case BL_CYCLE_KEY:
+#    endif
+#    if defined(FN_BL_CYCLE_KEY)
+        case FN_BL_CYCLE_KEY:
+#    endif
+            if (record->event.pressed) {
+                if (backlight_test_mode) {
+                    if (++backlight_test_mode >= BACKLIGHT_TEST_MAX) {
+                        backlight_test_mode = BACKLIGHT_TEST_WHITE;
+                    }
+                } else {
+                    factory_reset_state |= KEY_PRESS_BL_KEY1;
+                    if (factory_reset_state == 0x19) {
+                        factory_timer_start();
+                    }
+                }
+            } else {
+                factory_reset_state &= ~KEY_PRESS_BL_KEY1;
+                factory_reset_timer = 0;
+            }
+            break;
+#endif
+#if defined(BL_TRIG_KEY) || defined(BL_TRIG_KEY_2)
+#    if defined(BL_TRIG_KEY)
+        case BL_TRIG_KEY:
+#    endif
+#    if defined(FN_BL_TRIG_KEY)
+        case FN_BL_TRIG_KEY:
+#    endif
+            if (record->event.pressed) {
+                if (backlight_test_mode) {
+                    backlight_test_mode = BACKLIGHT_TEST_OFF;
+                } else {
+                    factory_reset_state |= KEY_PRESS_BL_KEY2;
+                    if (factory_reset_state == 0x19) {
+                        factory_timer_start();
+                    }
+                }
+            } else {
+                factory_reset_state &= ~KEY_PRESS_BL_KEY2;
+                factory_reset_timer = 0;
+            }
+            break;
+#endif
+    }
+
+    return true;
+}
+
+#ifdef LED_MATRIX_ENABLE
+bool factory_test_indicator(void) {
+    if (factory_reset_ind_state) {
+        led_matrix_set_value_all(factory_reset_ind_state % 2 ? 0 : 255);
+        return false;
+    }
+
+    return true;
+}
+#endif
+
+#ifdef RGB_MATRIX_ENABLE
+bool factory_test_indicator(void) {
+    if (factory_reset_ind_state) {
+        backlight_test_mode = BACKLIGHT_TEST_OFF;
+        rgb_matrix_set_color_all(factory_reset_ind_state % 2 ? 0 : 255, 0, 0);
+        return false;
+    } else if (backlight_test_mode) {
+        switch (backlight_test_mode) {
+            case BACKLIGHT_TEST_WHITE:
+                rgb_matrix_set_color_all(255, 255, 255);
+                break;
+            case BACKLIGHT_TEST_RED:
+                rgb_matrix_set_color_all(255, 0, 0);
+                break;
+            case BACKLIGHT_TEST_GREEN:
+                rgb_matrix_set_color_all(0, 255, 0);
+                break;
+            case BACKLIGHT_TEST_BLUE:
+                rgb_matrix_set_color_all(0, 0, 255);
+                break;
+        }
+        return false;
+    }
+
+    return true;
+}
+#endif
+
+bool factory_reset_indicating(void) {
+    return factory_reset_ind_timer;
+}
+
+bool factory_test_task(void) {
+    if (factory_reset_timer) factory_timer_check();
+    if (factory_reset_ind_timer) factory_reset_ind_timer_check();
+
+    return true;
+}
+
+#ifdef LEMOKEY_CALLBACK_ENABLE
+void factory_test_init(void) {
+    register_keychron_task(factory_test_task, false);
+    register_record_process(process_record_factory_test, false);
+    register_led_indicator_task(factory_test_indicator, false);
+}
+#endif
+
+void factory_test_send(uint8_t *payload, uint8_t length) {
+#ifdef RAW_ENABLE
+    uint16_t checksum         = 0;
+    uint8_t  data[RAW_EPSIZE] = {0};
+
+    uint8_t i = 0;
+    data[i++] = 0xAB;
+
+    memcpy(&data[i], payload, length);
+    i += length;
+
+    for (uint8_t i = 1; i < RAW_EPSIZE - 3; i++)
+        checksum += data[i];
+    data[RAW_EPSIZE - 2] = checksum & 0xFF;
+    data[RAW_EPSIZE - 1] = (checksum >> 8) & 0xFF;
+
+    raw_hid_send(data, RAW_EPSIZE);
+#endif
+}
+
+void factory_test_rx(uint8_t *data, uint8_t length) {
+    if (data[0] == 0xAB) {
+        uint16_t checksum = 0;
+
+        for (uint8_t i = 1; i < RAW_EPSIZE - 3; i++) {
+            checksum += data[i];
+        }
+        /* Verify checksum */
+        if ((checksum & 0xFF) != data[RAW_EPSIZE - 2] || checksum >> 8 != data[RAW_EPSIZE - 1]) return;
+
+#ifdef LK_WIRELESS_ENABLE
+        uint8_t payload[32];
+        uint8_t len = 0;
+#endif
+
+        switch (data[1]) {
+            case FACTORY_TEST_CMD_BACKLIGHT:
+                backlight_test_mode = data[2];
+                factory_reset_timer = 0;
+                break;
+            case FACTORY_TEST_CMD_OS_SWITCH:
+                report_os_sw_state = data[2];
+                if (report_os_sw_state) {
+                    // dip_switch_read(true);
+                }
+                break;
+            case FACTORY_TEST_CMD_JUMP_TO_BL:
+                // if (memcmp(&data[2], "JumpToBootloader", strlen("JumpToBootloader")) == 0) bootloader_jump();
+                break;
+#ifdef LK_WIRELESS_ENABLE
+            case FACTORY_TEST_CMD_INT_PIN:
+                switch (data[2]) {
+                    /* Enalbe/disable test */
+                    case 0xA1:
+                        lkbt51_int_pin_test(data[3]);
+                        break;
+                    /* Set INT state */
+                    case 0xA2:
+                        kc_printf("pin %d\n\r", data[3]);
+                        writePin(BLUETOOTH_INT_OUTPUT_PIN, data[3]);
+                        break;
+                        /* Report INT state */
+                        //                    case 0xA3:
+                        //                        payload[len++] = FACTORY_TEST_CMD_INT_PIN;
+                        //                        payload[len++] = 0xA3;
+                        //                        payload[len++] = readPin(LKBT51_INT_INPUT_PIN);
+                        //                        factory_test_send(payload, len);
+                        //                        break;
+                }
+                break;
+            case FACTORY_TEST_CMD_GET_TRANSPORT:
+                payload[len++] = FACTORY_TEST_CMD_GET_TRANSPORT;
+                payload[len++] = get_transport();
+                payload[len++] = readPin(USB_POWER_SENSE_PIN);
+                factory_test_send(payload, len);
+                break;
+#endif
+#ifdef BATTERY_CHARGE_DONE_DETECT_ADC
+            case FACTORY_TEST_CMD_CHARGING_ADC:
+            case 0xA1:
+                battery_charging_monitor(data[3]);
+                break;
+            case 0xA2:
+                payload[len++] = FACTORY_TEST_CMD_CHARGING_ADC;
+                payload[len++] = battery_adc_read_charging_pin();
+                factory_test_send(payload, len);
+                break;
+#endif
+#ifdef LK_WIRELESS_ENABLE
+            case FACTORY_TEST_CMD_RADIO_CARRIER:
+                if (data[2] < 79) lkbt51_radio_test(data[2]);
+                break;
+
+#    ifdef WERELESS_PRESSURE_TEST
+            case 0x70:
+                switch (data[2]) {
+                    /* Enalbe/disable test */
+                    case 0xB1:
+                        SEND_STRING("abcdefghijklmnopqrstuvwxyz1234567890abcdefghijklmnopqrstuvwxyz1234567890abcdefghijklmnopqrstuvwxyz1234567890\n");
+                        break;
+                    case 0xB2:
+                        payload[len++] = 0x70;
+                        payload[len++] = 0xB2;
+                        payload[len++] = wireless_get_state();
+                        factory_test_send(payload, len);
+                        break;
+                }
+                break;
+#    endif
+#endif
+            case FACTORY_TEST_CMD_GET_BUILD_TIME: {
+                payload[len++] = FACTORY_TEST_CMD_GET_BUILD_TIME;
+                payload[len++] = 'v';
+                if ((DEVICE_VER & 0xF000) != 0) itoa((DEVICE_VER >> 12), (char *)&payload[len++], 16);
+                itoa((DEVICE_VER >> 8) & 0xF, (char *)&payload[len++], 16);
+                payload[len++] = '.';
+                itoa((DEVICE_VER >> 4) & 0xF, (char *)&payload[len++], 16);
+                payload[len++] = '.';
+                itoa((DEVICE_VER >> 4) & 0xF, (char *)&payload[len++], 16);
+                payload[len++] = ' ';
+                memcpy(&payload[len], QMK_BUILDDATE, sizeof(QMK_BUILDDATE));
+                len += sizeof(QMK_BUILDDATE);
+                factory_test_send(payload, len);
+            } break;
+        }
+    }
+}
+
+bool dip_switch_update_user(uint8_t index, bool active) {
+    if (report_os_sw_state) {
+#ifdef INVERT_OS_SWITCH_STATE
+        active = !active;
+#endif
+        uint8_t payload[3] = {FACTORY_TEST_CMD_OS_SWITCH, OS_SWITCH, active};
+        factory_test_send(payload, 3);
+    }
+
+    return true;
+}

keyboards/keychron/common/Backup 2 of keychron_task.c

@@ -0,0 +1,239 @@
+/* Copyright 2023 @ Keychron (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdlib.h>
+#include "keychron_task.h"
+#include "quantum.h"
+#include "keychron_common.h"
+#ifdef FACTORY_TEST_ENABLE
+#    include "factory_test.h"
+#endif
+
+#ifdef LEMOKEY_CALLBACK_ENABLE
+
+typedef struct lk_node {
+    keychron_cb      lk_cb;
+    struct lk_node *next;
+} lk_Node;
+
+typedef struct lk_process_node {
+    keychron_record_process_cb process_cb;
+    struct lk_process_node   *next;
+} lk_process_Node;
+
+lk_Node         *p;
+lk_Node         *lk_task_list = NULL;
+lk_process_Node *p_process;
+lk_process_Node *lk_record_process_list = NULL;
+
+#    if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
+lk_Node *led_indicator_task_list = NULL;
+#    endif
+
+void register_keychron_cb(lk_Node **head, keychron_cb cb, bool priority) {
+    /* Create task node */
+    lk_Node *task = (lk_Node *)malloc(sizeof(lk_Node));
+    task->lk_cb   = cb;
+    task->next    = NULL;
+
+    /* Add to the list*/
+    if (*head) {
+        if (priority) {
+            task->next = *head;
+            *head      = task;
+        } else {
+            p = *head;
+            while (p->next)
+                p = p->next;
+            p->next = task;
+        }
+    } else {
+        *head = task;
+    }
+}
+
+void deregister_keychron_cb(lk_Node **head, keychron_cb cb) {
+    p = *head;
+    while (p) {
+        if (p->lk_cb == cb) {
+            // lk_Node* temp = p;
+            // if
+        }
+    }
+}
+
+void register_keychron_task(keychron_cb cb, bool priority) {
+    register_keychron_cb(&lk_task_list, cb, priority);
+}
+
+void register_led_indicator_task(keychron_cb cb, bool priority) {
+    register_keychron_cb(&led_indicator_task_list, cb, priority);
+}
+
+void register_record_process(keychron_record_process_cb cb, bool priority) {
+    lk_process_Node *process = (lk_process_Node *)malloc(sizeof(lk_process_Node));
+    process->process_cb      = cb;
+    process->next            = NULL;
+
+    /* Add to the list*/
+    if (lk_record_process_list) {
+        if (priority) {
+            process->next          = lk_record_process_list;
+            lk_record_process_list = process;
+        } else {
+            p_process = lk_record_process_list;
+            while (p_process->next)
+                p_process = p_process->next;
+            p_process->next = process;
+        }
+    } else {
+        lk_record_process_list = process;
+    }
+}
+
+inline void keychron_task(void) {
+    p = lk_task_list;
+    while (p) {
+        p->lk_cb();
+        p = p->next;
+    }
+}
+
+inline bool process_record_keychron(uint16_t keycode, keyrecord_t *record) {
+    p_process = lk_record_process_list;
+    while (p_process) {
+        if (!p_process->process_cb(keycode, record)) {
+            return false;
+        }
+        p_process = p_process->next;
+    }
+
+    return true;
+}
+
+#    if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
+#        if defined(LED_MATRIX_ENABLE)
+inline bool led_matrix_indicators_keychron(void) {
+#        else
+inline bool rgb_matrix_indicators_keychron(void) {
+#        endif
+
+    p = led_indicator_task_list;
+    while (p) {
+        p->lk_cb();
+        p = p->next;
+    }
+
+    return true;
+}
+#    endif
+
+#else
+
+__attribute__((weak)) bool process_record_keychron_kb(uint16_t keycode, keyrecord_t *record) {
+    return true;
+}
+
+bool process_record_keychron(uint16_t keycode, keyrecord_t *record) {
+#    ifdef LK_WIRELESS_ENABLE
+    extern bool process_record_wireless(uint16_t keycode, keyrecord_t * record);
+    if (!process_record_wireless(keycode, record)) return false;
+#    endif
+#    ifdef FACTORY_TEST_ENABLE
+    if (!process_record_factory_test(keycode, record)) return false;
+#    endif
+    // extern bool process_record_keychron_kb(uint16_t keycode, keyrecord_t *record);
+
+    if (!process_record_keychron_kb(keycode, record)) return false;
+
+    return true;
+}
+
+#    if defined(LED_MATRIX_ENABLE)
+bool led_matrix_indicators_keychron(void) {
+#        ifdef LK_WIRELESS_ENABLE
+    extern bool led_matrix_indicators_bt(void);
+    led_matrix_indicators_bt();
+#        endif
+#        ifdef FACTORY_TEST_ENABLE
+    factory_test_indicator();
+#        endif
+    return true;
+}
+#    endif
+
+#    if defined(RGB_MATRIX_ENABLE)
+bool rgb_matrix_indicators_keychron(void) {
+#        ifdef LK_WIRELESS_ENABLE
+    extern bool rgb_matrix_indicators_bt(void);
+    rgb_matrix_indicators_bt();
+#        endif
+#        ifdef FACTORY_TEST_ENABLE
+    factory_test_indicator();
+#        endif
+    return true;
+}
+#    endif
+
+__attribute__((weak)) bool keychron_task_kb(void) {
+    return true;
+}
+
+void keychron_task(void) {
+#    ifdef LK_WIRELESS_ENABLE
+    extern void wireless_tasks(void);
+    wireless_tasks();
+#    endif
+#    ifdef FACTORY_TEST_ENABLE
+    factory_test_task();
+#    endif
+    keychron_common_task();
+
+    keychron_task_kb();
+}
+#endif // #ifdef LEMOKEY_CALLBACK_ENABLE
+
+bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
+    if (!process_record_user(keycode, record)) return false;
+
+    if (!process_record_keychron(keycode, record)) return false;
+
+    return true;
+}
+
+#ifdef RGB_MATRIX_ENABLE
+bool rgb_matrix_indicators_kb(void) {
+    if (!rgb_matrix_indicators_user()) return false;
+
+    rgb_matrix_indicators_keychron();
+
+    return true;
+}
+#endif
+
+#ifdef LED_MATRIX_ENABLE
+bool led_matrix_indicators_kb(void) {
+    if (!led_matrix_indicators_user()) return false;
+
+    led_matrix_indicators_keychron();
+
+    return true;
+}
+#endif
+
+void housekeeping_task_kb(void) {
+    keychron_task();
+}

keyboards/keychron/common/Backup 2 of keychron_task.h

@@ -13,18 +13,29 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-
+ 
 #pragma once
 
-/* If PH3 used with a stronger pull resistor then the following definition needs be included */
-// #define MATRIX_UNSELECT_DRIVE_HIGH
+#include "stdint.h"
+#include "action.h"
 
-/* RGB Matrix Configuration */
-#define RGB_MATRIX_LED_COUNT 91
+#ifdef LEMOKEY_CALLBACK_ENABLE
+typedef bool (*keychron_cb)(void);
+typedef bool (*keychron_record_process_cb)(uint16_t keycode, keyrecord_t *record);
 
-#define SNLED27351_CURRENT_TUNE \
-    { 0x94, 0x94, 0x44, 0x94, 0x94, 0x44, 0x94, 0x94, 0x44, 0x94, 0x94, 0x44 }
 
-/* Enable CapsLcok LED */
-#define CAPS_LOCK_LED_INDEX 50
+bool process_record_keychron(uint16_t keycode, keyrecord_t *record);
+
+void register_keychron_task(keychron_cb cb, bool priority);
+void register_record_process(keychron_record_process_cb cb, bool priority);
+#if defined(LED_MATRIX_ENABLE) ||  defined(RGB_MATRIX_ENABLE)
+void register_led_indicator_task(keychron_cb cb, bool priority);
+#endif
+
+#else
+bool keychron_task_kb(void);
+bool process_record_keychron_kb(uint16_t keycode, keyrecord_t *record);
+
+#endif
+void keychron_task(void);
 

keyboards/keychron/common/common.mk

@@ -0,0 +1,4 @@
+COMMON_DIR = common
+SRC += $(COMMON_DIR)/matrix.c
+
+VPATH += $(TOP_DIR)/keyboards/keychron/$(COMMON_DIR)

keyboards/keychron/common/factory_test.c

@@ -0,0 +1,445 @@
+/* Copyright 2021 @ Keychron (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "quantum.h"
+#include "raw_hid.h"
+#include "via.h"
+
+#include "keychron_task.h"
+#ifdef LK_WIRELESS_ENABLE
+#    include "transport.h"
+#    include "battery.h"
+#    include "lpm.h"
+#    include "lkbt51.h"
+#    include "indicator.h"
+#endif
+#include "config.h"
+#include "version.h"
+
+#ifndef RAW_EPSIZE
+#    define RAW_EPSIZE 32
+#endif
+
+#ifndef BL_CYCLE_KEY
+#    define BL_CYCLE_KEY KC_RIGHT
+#endif
+
+#ifndef BL_TRIG_KEY
+#    define BL_TRIG_KEY KC_HOME
+#endif
+
+#ifndef P2P4G_CELAR_MASK
+#    define P2P4G_CELAR_MASK P2P4G_CLEAR_PAIRING_TYPE_C
+#endif
+
+enum {
+    BACKLIGHT_TEST_OFF = 0,
+    BACKLIGHT_TEST_WHITE,
+    BACKLIGHT_TEST_RED,
+    BACKLIGHT_TEST_GREEN,
+    BACKLIGHT_TEST_BLUE,
+    BACKLIGHT_TEST_MAX,
+};
+
+enum {
+    KEY_PRESS_FN             = 0x01 << 0,
+    KEY_PRESS_J              = 0x01 << 1,
+    KEY_PRESS_Z              = 0x01 << 2,
+    KEY_PRESS_BL_KEY1        = 0x01 << 3,
+    KEY_PRESS_BL_KEY2        = 0x01 << 4,
+    KEY_PRESS_FACTORY_RESET  = KEY_PRESS_FN | KEY_PRESS_J | KEY_PRESS_Z,
+    KEY_PRESS_BACKLIGTH_TEST = KEY_PRESS_FN | KEY_PRESS_BL_KEY1 | KEY_PRESS_BL_KEY2,
+};
+
+enum {
+    FACTORY_TEST_CMD_BACKLIGHT = 0x01,
+    FACTORY_TEST_CMD_OS_SWITCH,
+    FACTORY_TEST_CMD_JUMP_TO_BL,
+    FACTORY_TEST_CMD_INT_PIN,
+    FACTORY_TEST_CMD_GET_TRANSPORT,
+    FACTORY_TEST_CMD_CHARGING_ADC,
+    FACTORY_TEST_CMD_RADIO_CARRIER,
+    FACTORY_TEST_CMD_GET_BUILD_TIME,
+};
+
+enum {
+    P2P4G_CLEAR_PAIRING_TYPE_A = 0x01 << 0,
+    P2P4G_CLEAR_PAIRING_TYPE_C = 0x01 << 1,
+};
+
+enum {
+    OS_SWITCH = 0x01,
+};
+
+static uint32_t factory_reset_timer = 0;
+static uint8_t  factory_reset_state = 0;
+static uint8_t  backlight_test_mode = BACKLIGHT_TEST_OFF;
+
+static uint32_t factory_reset_ind_timer = 0;
+static uint8_t  factory_reset_ind_state = 0;
+static bool     report_os_sw_state      = false;
+static bool     keys_released           = true;
+
+void factory_timer_start(void) {
+    factory_reset_timer = timer_read32();
+}
+
+static inline void factory_timer_check(void) {
+    if (timer_elapsed32(factory_reset_timer) > 3000) {
+        factory_reset_timer = 0;
+
+        if (factory_reset_state == KEY_PRESS_FACTORY_RESET) {
+            factory_reset_ind_timer = timer_read32();
+            factory_reset_ind_state++;
+            keys_released = false;
+
+            clear_keyboard(); // Avoid key being pressed after NKRO state changed
+            layer_state_t default_layer_tmp = default_layer_state;
+            eeconfig_init();
+            keymap_config.raw = eeconfig_read_keymap();
+            default_layer_set(default_layer_tmp);
+#ifdef LED_MATRIX_ENABLE
+            if (!led_matrix_is_enabled()) led_matrix_enable();
+            led_matrix_init();
+#endif
+#ifdef RGB_MATRIX_ENABLE
+            if (!rgb_matrix_is_enabled()) rgb_matrix_enable();
+            rgb_matrix_init();
+#endif
+#ifdef LK_WIRELESS_ENABLE
+            lkbt51_factory_reset(P2P4G_CELAR_MASK);
+#endif
+        } else if (factory_reset_state == KEY_PRESS_BACKLIGTH_TEST) {
+#ifdef LED_MATRIX_ENABLE
+            if (!led_matrix_is_enabled()) led_matrix_enable();
+#endif
+#ifdef RGB_MATRIX_ENABLE
+            if (!rgb_matrix_is_enabled()) rgb_matrix_enable();
+#endif
+            backlight_test_mode = BACKLIGHT_TEST_WHITE;
+        }
+
+        factory_reset_state = 0;
+    }
+}
+
+static inline void factory_reset_ind_timer_check(void) {
+    if (factory_reset_ind_timer && timer_elapsed32(factory_reset_ind_timer) > 250) {
+        if (factory_reset_ind_state++ > 6) {
+            factory_reset_ind_timer = factory_reset_ind_state = 0;
+        } else {
+            factory_reset_ind_timer = timer_read32();
+        }
+    }
+}
+
+bool process_record_factory_test(uint16_t keycode, keyrecord_t *record) {
+    switch (keycode) {
+#if defined(FN_KEY_1) || defined(FN_KEY_2)
+#    if defined(FN_KEY_1)
+        case FN_KEY_1: /* fall through */
+#    endif
+#    if defined(FN_KEY_2)
+        case FN_KEY_2:
+#    endif
+#    if defined(FN_KEY_3)
+        case FN_KEY_3:
+#    endif
+            if (record->event.pressed) {
+                factory_reset_state |= KEY_PRESS_FN;
+            } else {
+                factory_reset_state &= ~KEY_PRESS_FN;
+                factory_reset_timer = 0;
+            }
+            break;
+#endif
+        case KC_J:
+            if (record->event.pressed) {
+                factory_reset_state |= KEY_PRESS_J;
+                if (factory_reset_state == 0x07) factory_timer_start();
+                if (factory_reset_state & KEY_PRESS_FN) return false;
+            } else {
+                factory_reset_state &= ~KEY_PRESS_J;
+                factory_reset_timer = 0;
+            }
+            break;
+        case KC_Z:
+#if defined(FN_Z_KEY)
+        case FN_Z_KEY:
+#endif
+            if (record->event.pressed) {
+                factory_reset_state |= KEY_PRESS_Z;
+                if (factory_reset_state == 0x07) factory_timer_start();
+                if ((factory_reset_state & KEY_PRESS_FN) && keycode == KC_Z) return false;
+            } else {
+                factory_reset_state &= ~KEY_PRESS_Z;
+                factory_reset_timer = 0;
+                /* Avoid changing backlight effect on key released if FN_Z_KEY is mode*/
+
+                if (!keys_released && keycode >= QK_BACKLIGHT_ON && keycode <= RGB_MODE_TWINKLE) {
+                    keys_released = true;
+                    return false;
+                }
+            }
+            break;
+#if defined(BL_CYCLE_KEY) || defined(BL_CYCLE_KEY_2)
+#    if defined(BL_CYCLE_KEY)
+        case BL_CYCLE_KEY:
+#    endif
+#    if defined(FN_BL_CYCLE_KEY)
+        case FN_BL_CYCLE_KEY:
+#    endif
+            if (record->event.pressed) {
+                if (backlight_test_mode) {
+                    if (++backlight_test_mode >= BACKLIGHT_TEST_MAX) {
+                        backlight_test_mode = BACKLIGHT_TEST_WHITE;
+                    }
+                } else {
+                    factory_reset_state |= KEY_PRESS_BL_KEY1;
+                    if (factory_reset_state == 0x19) {
+                        factory_timer_start();
+                    }
+                }
+            } else {
+                factory_reset_state &= ~KEY_PRESS_BL_KEY1;
+                factory_reset_timer = 0;
+            }
+            break;
+#endif
+#if defined(BL_TRIG_KEY) || defined(BL_TRIG_KEY_2)
+#    if defined(BL_TRIG_KEY)
+        case BL_TRIG_KEY:
+#    endif
+#    if defined(FN_BL_TRIG_KEY)
+        case FN_BL_TRIG_KEY:
+#    endif
+            if (record->event.pressed) {
+                if (backlight_test_mode) {
+                    backlight_test_mode = BACKLIGHT_TEST_OFF;
+                } else {
+                    factory_reset_state |= KEY_PRESS_BL_KEY2;
+                    if (factory_reset_state == 0x19) {
+                        factory_timer_start();
+                    }
+                }
+            } else {
+                factory_reset_state &= ~KEY_PRESS_BL_KEY2;
+                factory_reset_timer = 0;
+            }
+            break;
+#endif
+    }
+
+    return true;
+}
+
+#ifdef LED_MATRIX_ENABLE
+bool factory_test_indicator(void) {
+    if (factory_reset_ind_state) {
+        led_matrix_set_value_all(factory_reset_ind_state % 2 ? 0 : 255);
+        return false;
+    }
+
+    return true;
+}
+#endif
+
+#ifdef RGB_MATRIX_ENABLE
+bool factory_test_indicator(void) {
+    if (factory_reset_ind_state) {
+        backlight_test_mode = BACKLIGHT_TEST_OFF;
+        rgb_matrix_set_color_all(factory_reset_ind_state % 2 ? 0 : 255, 0, 0);
+        return false;
+    } else if (backlight_test_mode) {
+        switch (backlight_test_mode) {
+            case BACKLIGHT_TEST_WHITE:
+                rgb_matrix_set_color_all(255, 255, 255);
+                break;
+            case BACKLIGHT_TEST_RED:
+                rgb_matrix_set_color_all(255, 0, 0);
+                break;
+            case BACKLIGHT_TEST_GREEN:
+                rgb_matrix_set_color_all(0, 255, 0);
+                break;
+            case BACKLIGHT_TEST_BLUE:
+                rgb_matrix_set_color_all(0, 0, 255);
+                break;
+        }
+        return false;
+    }
+
+    return true;
+}
+#endif
+
+bool factory_reset_indicating(void) {
+    return factory_reset_ind_timer;
+}
+
+bool factory_test_task(void) {
+    if (factory_reset_timer) factory_timer_check();
+    if (factory_reset_ind_timer) factory_reset_ind_timer_check();
+
+    return true;
+}
+
+#ifdef KEYCHRON_CALLBACK_ENABLE
+void factory_test_init(void) {
+    register_keychron_task(factory_test_task, false);
+    register_record_process(process_record_factory_test, false);
+    register_led_indicator_task(factory_test_indicator, false);
+}
+#endif
+
+void factory_test_send(uint8_t *payload, uint8_t length) {
+#ifdef RAW_ENABLE
+    uint16_t checksum         = 0;
+    uint8_t  data[RAW_EPSIZE] = {0};
+
+    uint8_t i = 0;
+    data[i++] = 0xAB;
+
+    memcpy(&data[i], payload, length);
+    i += length;
+
+    for (uint8_t i = 1; i < RAW_EPSIZE - 3; i++)
+        checksum += data[i];
+    data[RAW_EPSIZE - 2] = checksum & 0xFF;
+    data[RAW_EPSIZE - 1] = (checksum >> 8) & 0xFF;
+
+    raw_hid_send(data, RAW_EPSIZE);
+#endif
+}
+
+void factory_test_rx(uint8_t *data, uint8_t length) {
+    if (data[0] == 0xAB) {
+        uint16_t checksum = 0;
+
+        for (uint8_t i = 1; i < RAW_EPSIZE - 3; i++) {
+            checksum += data[i];
+        }
+        /* Verify checksum */
+        if ((checksum & 0xFF) != data[RAW_EPSIZE - 2] || checksum >> 8 != data[RAW_EPSIZE - 1]) return;
+
+#ifdef LK_WIRELESS_ENABLE
+        uint8_t payload[32];
+        uint8_t len = 0;
+#endif
+
+        switch (data[1]) {
+            case FACTORY_TEST_CMD_BACKLIGHT:
+                backlight_test_mode = data[2];
+                factory_reset_timer = 0;
+                break;
+            case FACTORY_TEST_CMD_OS_SWITCH:
+                report_os_sw_state = data[2];
+                if (report_os_sw_state) {
+                    // dip_switch_read(true);
+                }
+                break;
+            case FACTORY_TEST_CMD_JUMP_TO_BL:
+                // if (memcmp(&data[2], "JumpToBootloader", strlen("JumpToBootloader")) == 0) bootloader_jump();
+                break;
+#ifdef LK_WIRELESS_ENABLE
+            case FACTORY_TEST_CMD_INT_PIN:
+                switch (data[2]) {
+                    /* Enalbe/disable test */
+                    case 0xA1:
+                        lkbt51_int_pin_test(data[3]);
+                        break;
+                    /* Set INT state */
+                    case 0xA2:
+                        kc_printf("pin %d\n\r", data[3]);
+                        writePin(BLUETOOTH_INT_OUTPUT_PIN, data[3]);
+                        break;
+                        /* Report INT state */
+                        //                    case 0xA3:
+                        //                        payload[len++] = FACTORY_TEST_CMD_INT_PIN;
+                        //                        payload[len++] = 0xA3;
+                        //                        payload[len++] = readPin(LKBT51_INT_INPUT_PIN);
+                        //                        factory_test_send(payload, len);
+                        //                        break;
+                }
+                break;
+            case FACTORY_TEST_CMD_GET_TRANSPORT:
+                payload[len++] = FACTORY_TEST_CMD_GET_TRANSPORT;
+                payload[len++] = get_transport();
+                payload[len++] = readPin(USB_POWER_SENSE_PIN);
+                factory_test_send(payload, len);
+                break;
+#endif
+#ifdef BATTERY_CHARGE_DONE_DETECT_ADC
+            case FACTORY_TEST_CMD_CHARGING_ADC:
+            case 0xA1:
+                battery_charging_monitor(data[3]);
+                break;
+            case 0xA2:
+                payload[len++] = FACTORY_TEST_CMD_CHARGING_ADC;
+                payload[len++] = battery_adc_read_charging_pin();
+                factory_test_send(payload, len);
+                break;
+#endif
+#ifdef LK_WIRELESS_ENABLE
+            case FACTORY_TEST_CMD_RADIO_CARRIER:
+                if (data[2] < 79) lkbt51_radio_test(data[2]);
+                break;
+
+#    ifdef WERELESS_PRESSURE_TEST
+            case 0x70:
+                switch (data[2]) {
+                    /* Enalbe/disable test */
+                    case 0xB1:
+                        SEND_STRING("abcdefghijklmnopqrstuvwxyz1234567890abcdefghijklmnopqrstuvwxyz1234567890abcdefghijklmnopqrstuvwxyz1234567890\n");
+                        break;
+                    case 0xB2:
+                        payload[len++] = 0x70;
+                        payload[len++] = 0xB2;
+                        payload[len++] = wireless_get_state();
+                        factory_test_send(payload, len);
+                        break;
+                }
+                break;
+#    endif
+#endif
+            case FACTORY_TEST_CMD_GET_BUILD_TIME: {
+                payload[len++] = FACTORY_TEST_CMD_GET_BUILD_TIME;
+                payload[len++] = 'v';
+                if ((DEVICE_VER & 0xF000) != 0) itoa((DEVICE_VER >> 12), (char *)&payload[len++], 16);
+                itoa((DEVICE_VER >> 8) & 0xF, (char *)&payload[len++], 16);
+                payload[len++] = '.';
+                itoa((DEVICE_VER >> 4) & 0xF, (char *)&payload[len++], 16);
+                payload[len++] = '.';
+                itoa((DEVICE_VER >> 4) & 0xF, (char *)&payload[len++], 16);
+                payload[len++] = ' ';
+                memcpy(&payload[len], QMK_BUILDDATE, sizeof(QMK_BUILDDATE));
+                len += sizeof(QMK_BUILDDATE);
+                factory_test_send(payload, len);
+            } break;
+        }
+    }
+}
+
+bool dip_switch_update_user(uint8_t index, bool active) {
+    if (report_os_sw_state) {
+#ifdef INVERT_OS_SWITCH_STATE
+        active = !active;
+#endif
+        uint8_t payload[3] = {FACTORY_TEST_CMD_OS_SWITCH, OS_SWITCH, active};
+        factory_test_send(payload, 3);
+    }
+
+    return true;
+}

keyboards/keychron/common/factory_test.h

@@ -0,0 +1,34 @@
+/* Copyright 2022 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#define FACTORY_RESET_CHECK process_record_factory_test
+#define FACTORY_RESET_TASK factory_test_task
+
+void factory_test_init(void);
+
+#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
+bool factory_test_indicator(void);
+#endif
+
+//void process_record_factory_test(uint16_t keycode, keyrecord_t *record);
+bool factory_reset_indicating(void);
+void factory_test_task(void);
+void factory_test_rx(uint8_t *data, uint8_t length);
+
+bool process_record_factory_test(uint16_t keycode, keyrecord_t *record);
+

keyboards/keychron/common/keychron_common.c

@@ -1,4 +1,4 @@
-/* Copyright 2022 @ Keychron (https://www.keychron.com)
+/* Copyright 2023 @ Keychron (https://www.keychron.com)
  *
  * 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
@@ -14,47 +14,43 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include QMK_KEYBOARD_H
 #include "keychron_common.h"
-#include "sync_timer.h"
+#include "raw_hid.h"
+#include "version.h"
 
-bool is_siri_active = false;
-uint32_t siri_timer = 0;
+#ifdef FACTORY_TEST_ENABLE
+#    include "factory_test.h"
+#    include "keychron_common.h"
+#endif
 
-key_combination_t key_comb_list[4] = {
-    {2, {KC_LWIN, KC_TAB}},
-    {2, {KC_LWIN, KC_E}},
-    {3, {KC_LSFT, KC_LCMD, KC_4}},
-    {2, {KC_LWIN, KC_C}}
-};
+#ifdef LK_WIRELESS_ENABLE
+#    include "lkbt51.h"
+#endif
 
-static uint8_t mac_keycode[4] = { KC_LOPT, KC_ROPT, KC_LCMD, KC_RCMD };
+bool     is_siri_active = false;
+uint32_t siri_timer     = 0;
 
-void housekeeping_task_keychron(void) {
-    if (is_siri_active) {
-        if (sync_timer_elapsed32(siri_timer) >= 500) {
-            unregister_code(KC_LCMD);
-            unregister_code(KC_SPACE);
-            is_siri_active = false;
-        }
-    }
-}
+static uint8_t mac_keycode[4] = {KC_LOPT, KC_ROPT, KC_LCMD, KC_RCMD};
 
-bool process_record_keychron(uint16_t keycode, keyrecord_t *record) {
+static key_combination_t key_comb_list[4] = {{2, {KC_LWIN, KC_TAB}}, {2, {KC_LWIN, KC_E}}, {3, {KC_LSFT, KC_LCMD, KC_4}}, {2, {KC_LWIN, KC_C}}};
+
+bool process_record_keychron_common(uint16_t keycode, keyrecord_t *record) {
     switch (keycode) {
-        case QK_KB_0:
+        case KC_MCTRL:
             if (record->event.pressed) {
                 register_code(KC_MISSION_CONTROL);
             } else {
                 unregister_code(KC_MISSION_CONTROL);
             }
-            return false;  // Skip all further processing of this key
-        case QK_KB_1:
+            return false; // Skip all further processing of this key
+        case KC_LNPAD:
             if (record->event.pressed) {
                 register_code(KC_LAUNCHPAD);
             } else {
                 unregister_code(KC_LAUNCHPAD);
             }
-            return false;  // Skip all further processing of this key
+            return false; // Skip all further processing of this key
         case KC_LOPTN:
         case KC_ROPTN:
         case KC_LCMMD:
@@ -64,7 +60,7 @@ bool process_record_keychron(uint16_t keycode, keyrecord_t *record) {
             } else {
                 unregister_code(mac_keycode[keycode - KC_LOPTN]);
             }
-            return false;  // Skip all further processing of this key
+            return false; // Skip all further processing of this key
         case KC_SIRI:
             if (record->event.pressed) {
                 if (!is_siri_active) {
@@ -72,15 +68,15 @@ bool process_record_keychron(uint16_t keycode, keyrecord_t *record) {
                     register_code(KC_LCMD);
                     register_code(KC_SPACE);
                 }
-                siri_timer = sync_timer_read32();
+                siri_timer = timer_read32();
             } else {
                 // Do something else when release
             }
-            return false;  // Skip all further processing of this key
+            return false; // Skip all further processing of this key
         case KC_TASK:
-        case KC_FLXP:
+        case KC_FILE:
         case KC_SNAP:
-        case KC_CRTA:
+        case KC_CTANA:
             if (record->event.pressed) {
                 for (uint8_t i = 0; i < key_comb_list[keycode - KC_TASK].len; i++) {
                     register_code(key_comb_list[keycode - KC_TASK].keycode[i]);
@@ -90,8 +86,125 @@ bool process_record_keychron(uint16_t keycode, keyrecord_t *record) {
                     unregister_code(key_comb_list[keycode - KC_TASK].keycode[i]);
                 }
             }
-            return false;  // Skip all further processing of this key
+            return false; // Skip all further processing of this key
         default:
-            return true;  // Process all other keycodes normally
+            return true; // Process all other keycodes normally
     }
 }
+
+void keychron_common_task(void) {
+    if (is_siri_active && timer_elapsed32(siri_timer) > 500) {
+        unregister_code(KC_LCMD);
+        unregister_code(KC_SPACE);
+        is_siri_active = false;
+        siri_timer     = 0;
+    }
+}
+
+#ifdef ENCODER_ENABLE
+static void encoder0_pad_cb(void *param) {
+    (void)param;
+    encoder_inerrupt_read(0);
+}
+
+void encoder_cb_init(void) {
+    pin_t encoders_pad_a[] = ENCODERS_PAD_A;
+    pin_t encoders_pad_b[] = ENCODERS_PAD_B;
+    palEnableLineEvent(encoders_pad_a[0], PAL_EVENT_MODE_BOTH_EDGES);
+    palEnableLineEvent(encoders_pad_b[0], PAL_EVENT_MODE_BOTH_EDGES);
+    palSetLineCallback(encoders_pad_a[0], encoder0_pad_cb, NULL);
+    palSetLineCallback(encoders_pad_b[0], encoder0_pad_cb, NULL);
+}
+#endif
+
+//__attribute__((weak)) bool raw_hid_receive_keychron(uint8_t *data, uint8_t length) { return true; }
+#define PROTOCOL_VERSION 0x02
+
+enum { kc_get_protocol_version = 0xA0, kc_get_firmware_version = 0xA1, kc_get_support_feature = 0xA2, kc_get_default_layer = 0xA3 };
+
+enum {
+    FEATURE_DEFAULT_LAYER = 0x01 << 0,
+    FEATURE_BLUETOOTH     = 0x01 << 1,
+    FEATURE_P2P4G         = 0x01 << 2,
+    FEATURE_ANALOG_MATRIX = 0x01 << 3,
+};
+
+void get_support_feature(uint8_t *data) {
+    data[1] = FEATURE_DEFAULT_LAYER
+#ifdef KC_BLUETOOTH_ENABLE
+              | FEATURE_BLUETOOTH
+#endif
+#ifdef LK_WIRELESS_ENABLE
+              | FEATURE_BLUETOOTH | FEATURE_P2P4G
+#endif
+#ifdef ANANLOG_MATRIX
+              | FEATURE_ANALOG_MATRIX
+#endif
+        ;
+}
+
+bool via_command_kb(uint8_t *data, uint8_t length) {
+    // if (!raw_hid_receive_keychron(data, length))
+    //     return false;
+    switch (data[0]) {
+        case kc_get_protocol_version:
+            data[1] = PROTOCOL_VERSION;
+            raw_hid_send(data, length);
+            break;
+
+        case kc_get_firmware_version: {
+            uint8_t i = 1;
+            data[i++] = 'v';
+            if ((DEVICE_VER & 0xF000) != 0) itoa((DEVICE_VER >> 12), (char *)&data[i++], 16);
+            itoa((DEVICE_VER >> 8) & 0xF, (char *)&data[i++], 16);
+            data[i++] = '.';
+            itoa((DEVICE_VER >> 4) & 0xF, (char *)&data[i++], 16);
+            data[i++] = '.';
+            itoa((DEVICE_VER >> 4) & 0xF, (char *)&data[i++], 16);
+            data[i++] = ' ';
+            memcpy(&data[i], QMK_BUILDDATE, sizeof(QMK_BUILDDATE));
+            i += sizeof(QMK_BUILDDATE);
+            raw_hid_send(data, length);
+        } break;
+
+        case kc_get_support_feature:
+            get_support_feature(&data[1]);
+            raw_hid_send(data, length);
+            break;
+
+        case kc_get_default_layer:
+            data[1] = get_highest_layer(default_layer_state);
+            raw_hid_send(data, length);
+            break;
+
+#ifdef ANANLOG_MATRIX
+        case 0xA9:
+            analog_matrix_rx(data, length);
+            break;
+#endif
+#ifdef LK_WIRELESS_ENABLE
+        case 0xAA:
+            lkbt51_dfu_rx(data, length);
+            break;
+#endif
+#ifdef FACTORY_TEST_ENABLE
+        case 0xAB:
+            factory_test_rx(data, length);
+            break;
+#endif
+        default:
+            return false;
+    }
+
+    return true;
+}
+
+#if !defined(VIA_ENABLE)
+void raw_hid_receive(uint8_t *data, uint8_t length) {
+    switch (data[0]) {
+        case RAW_HID_CMD:
+            via_command_kb(data, length);
+            break;
+    }
+}
+#endif

keyboards/keychron/common/keychron_common.h

@@ -1,4 +1,4 @@
-/* Copyright 2022 @ Keychron (https://www.keychron.com)
+/* Copyright 2023 @ Keychron (https://www.keychron.com)
  *
  * 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
@@ -16,37 +16,60 @@
 
 #pragma once
 
-#include <stdint.h>
-#include <stdbool.h>
-#include "action.h"
+#include "stdint.h"
 
-#ifdef VIA_ENABLE
-#    include "via.h"
-#endif
-
-#include "quantum_keycodes.h"
-
-enum custom_keycodes {
-    KC_LOPTN = QK_KB_2, // TECH DEBT: Starts at QK_KB_2 to maintain ordering with VIA definitions. See #19884. Revert to QK_KB_0 when VIA catches up with QMK.
+// clang-format off
+enum {
+    KC_LOPTN = QK_KB_0,
     KC_ROPTN,
     KC_LCMMD,
     KC_RCMMD,
-    KC_SIRI,
+    KC_MCTRL,
+    KC_LNPAD,
     KC_TASK_VIEW,
     KC_FILE_EXPLORER,
     KC_SCREEN_SHOT,
-    KC_CORTANA
+    KC_CORTANA,
+    KC_SIRI,
+#ifdef LK_WIRELESS_ENABLE
+    BT_HST1,
+    BT_HST2,
+    BT_HST3,
+    P2P4G,
+    BAT_LVL,
+#else
+    BT_HST1 = _______,
+    BT_HST2 = _______,
+    BT_HST3 = _______,
+    P2P4G   = _______,
+    BAT_LVL = _______,
+#endif
+#ifdef DANANLOG_MATRIX
+    PROF1,
+    PROF2,
+    PROF3,
+#else
+    PROF1 = _______,
+    PROF2 = _______,
+    PROF3 = _______,
+#endif
+    NEW_SAFE_RANGE,
 };
 
 #define KC_TASK KC_TASK_VIEW
-#define KC_FLXP KC_FILE_EXPLORER
+#define KC_FILE KC_FILE_EXPLORER
 #define KC_SNAP KC_SCREEN_SHOT
-#define KC_CRTA KC_CORTANA
+#define KC_CTANA KC_CORTANA
 
 typedef struct PACKED {
     uint8_t len;
     uint8_t keycode[3];
 } key_combination_t;
 
-void housekeeping_task_keychron(void);
-bool process_record_keychron(uint16_t keycode, keyrecord_t *record);
+bool process_record_keychron_common(uint16_t keycode, keyrecord_t *record);
+void keychron_common_task(void);
+
+#ifdef ENCODER_ENABLE
+void encoder_cb_init(void);
+#endif
+

keyboards/keychron/common/keychron_common.mk

@@ -0,0 +1,10 @@
+OPT_DEFS += -DFACTORY_TEST_ENABLE
+
+KEYCHRON_COMMON_DIR = common
+SRC += \
+	$(KEYCHRON_COMMON_DIR)/keychron_task.c \
+    $(KEYCHRON_COMMON_DIR)/keychron_common.c \
+    $(KEYCHRON_COMMON_DIR)/factory_test.c
+
+VPATH += $(TOP_DIR)/keyboards/keychron/$(KEYCHRON_COMMON_DIR)
+

keyboards/keychron/common/keychron_task.c

@@ -0,0 +1,239 @@
+/* Copyright 2023 @ Keychron (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdlib.h>
+#include "keychron_task.h"
+#include "quantum.h"
+#include "keychron_common.h"
+#ifdef FACTORY_TEST_ENABLE
+#    include "factory_test.h"
+#endif
+
+#ifdef KEYCHRON_CALLBACK_ENABLE
+
+typedef struct lk_node {
+    keychron_cb      lk_cb;
+    struct lk_node *next;
+} lk_Node;
+
+typedef struct lk_process_node {
+    keychron_record_process_cb process_cb;
+    struct lk_process_node   *next;
+} lk_process_Node;
+
+lk_Node         *p;
+lk_Node         *lk_task_list = NULL;
+lk_process_Node *p_process;
+lk_process_Node *lk_record_process_list = NULL;
+
+#    if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
+lk_Node *led_indicator_task_list = NULL;
+#    endif
+
+void register_keychron_cb(lk_Node **head, keychron_cb cb, bool priority) {
+    /* Create task node */
+    lk_Node *task = (lk_Node *)malloc(sizeof(lk_Node));
+    task->lk_cb   = cb;
+    task->next    = NULL;
+
+    /* Add to the list*/
+    if (*head) {
+        if (priority) {
+            task->next = *head;
+            *head      = task;
+        } else {
+            p = *head;
+            while (p->next)
+                p = p->next;
+            p->next = task;
+        }
+    } else {
+        *head = task;
+    }
+}
+
+void deregister_keychron_cb(lk_Node **head, keychron_cb cb) {
+    p = *head;
+    while (p) {
+        if (p->lk_cb == cb) {
+            // lk_Node* temp = p;
+            // if
+        }
+    }
+}
+
+void register_keychron_task(keychron_cb cb, bool priority) {
+    register_keychron_cb(&lk_task_list, cb, priority);
+}
+
+void register_led_indicator_task(keychron_cb cb, bool priority) {
+    register_keychron_cb(&led_indicator_task_list, cb, priority);
+}
+
+void register_record_process(keychron_record_process_cb cb, bool priority) {
+    lk_process_Node *process = (lk_process_Node *)malloc(sizeof(lk_process_Node));
+    process->process_cb      = cb;
+    process->next            = NULL;
+
+    /* Add to the list*/
+    if (lk_record_process_list) {
+        if (priority) {
+            process->next          = lk_record_process_list;
+            lk_record_process_list = process;
+        } else {
+            p_process = lk_record_process_list;
+            while (p_process->next)
+                p_process = p_process->next;
+            p_process->next = process;
+        }
+    } else {
+        lk_record_process_list = process;
+    }
+}
+
+inline void keychron_task(void) {
+    p = lk_task_list;
+    while (p) {
+        p->lk_cb();
+        p = p->next;
+    }
+}
+
+inline bool process_record_keychron(uint16_t keycode, keyrecord_t *record) {
+    p_process = lk_record_process_list;
+    while (p_process) {
+        if (!p_process->process_cb(keycode, record)) {
+            return false;
+        }
+        p_process = p_process->next;
+    }
+
+    return true;
+}
+
+#    if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
+#        if defined(LED_MATRIX_ENABLE)
+inline bool led_matrix_indicators_keychron(void) {
+#        else
+inline bool rgb_matrix_indicators_keychron(void) {
+#        endif
+
+    p = led_indicator_task_list;
+    while (p) {
+        p->lk_cb();
+        p = p->next;
+    }
+
+    return true;
+}
+#    endif
+
+#else
+
+__attribute__((weak)) bool process_record_keychron_kb(uint16_t keycode, keyrecord_t *record) {
+    return true;
+}
+
+bool process_record_keychron(uint16_t keycode, keyrecord_t *record) {
+#    ifdef LK_WIRELESS_ENABLE
+    extern bool process_record_wireless(uint16_t keycode, keyrecord_t * record);
+    if (!process_record_wireless(keycode, record)) return false;
+#    endif
+#    ifdef FACTORY_TEST_ENABLE
+    if (!process_record_factory_test(keycode, record)) return false;
+#    endif
+    // extern bool process_record_keychron_kb(uint16_t keycode, keyrecord_t *record);
+
+    if (!process_record_keychron_kb(keycode, record)) return false;
+
+    return true;
+}
+
+#    if defined(LED_MATRIX_ENABLE)
+bool led_matrix_indicators_keychron(void) {
+#        ifdef LK_WIRELESS_ENABLE
+    extern bool led_matrix_indicators_bt(void);
+    led_matrix_indicators_bt();
+#        endif
+#        ifdef FACTORY_TEST_ENABLE
+    factory_test_indicator();
+#        endif
+    return true;
+}
+#    endif
+
+#    if defined(RGB_MATRIX_ENABLE)
+bool rgb_matrix_indicators_keychron(void) {
+#        ifdef LK_WIRELESS_ENABLE
+    extern bool rgb_matrix_indicators_bt(void);
+    rgb_matrix_indicators_bt();
+#        endif
+#        ifdef FACTORY_TEST_ENABLE
+    factory_test_indicator();
+#        endif
+    return true;
+}
+#    endif
+
+__attribute__((weak)) bool keychron_task_kb(void) {
+    return true;
+}
+
+void keychron_task(void) {
+#    ifdef LK_WIRELESS_ENABLE
+    extern void wireless_tasks(void);
+    wireless_tasks();
+#    endif
+#    ifdef FACTORY_TEST_ENABLE
+    factory_test_task();
+#    endif
+    keychron_common_task();
+
+    keychron_task_kb();
+}
+#endif // #ifdef KEYCHRON_CALLBACK_ENABLE
+
+bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
+    if (!process_record_user(keycode, record)) return false;
+
+    if (!process_record_keychron(keycode, record)) return false;
+
+    return true;
+}
+
+#ifdef RGB_MATRIX_ENABLE
+bool rgb_matrix_indicators_kb(void) {
+    if (!rgb_matrix_indicators_user()) return false;
+
+    rgb_matrix_indicators_keychron();
+
+    return true;
+}
+#endif
+
+#ifdef LED_MATRIX_ENABLE
+bool led_matrix_indicators_kb(void) {
+    if (!led_matrix_indicators_user()) return false;
+
+    led_matrix_indicators_keychron();
+
+    return true;
+}
+#endif
+
+void housekeeping_task_kb(void) {
+    keychron_task();
+}

keyboards/keychron/common/keychron_task.h

@@ -13,20 +13,29 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-
+ 
 #pragma once
 
-/* DIP switch */
-#define DIP_SWITCH_MATRIX_GRID  { {4,4} }
+#include "stdint.h"
+#include "action.h"
 
-/* Disable DIP switch in matrix data */
-#define MATRIX_MASKED
+#ifdef KEYCHRON_CALLBACK_ENABLE
+typedef bool (*keychron_cb)(void);
+typedef bool (*keychron_record_process_cb)(uint16_t keycode, keyrecord_t *record);
 
-/* turn off effects when suspended */
-#define RGB_DISABLE_WHEN_USB_SUSPENDED
 
-#define SNLED27351_CURRENT_TUNE \
-    { 0xCA, 0xCA, 0x60, 0xCA, 0xCA, 0x60, 0xCA, 0xCA, 0x60, 0xCA, 0xCA, 0x60 }
+bool process_record_keychron(uint16_t keycode, keyrecord_t *record);
+
+void register_keychron_task(keychron_cb cb, bool priority);
+void register_record_process(keychron_record_process_cb cb, bool priority);
+#if defined(LED_MATRIX_ENABLE) ||  defined(RGB_MATRIX_ENABLE)
+void register_led_indicator_task(keychron_cb cb, bool priority);
+#endif
+
+#else
+bool keychron_task_kb(void);
+bool process_record_keychron_kb(uint16_t keycode, keyrecord_t *record);
+
+#endif
+void keychron_task(void);
 
-#define RGB_MATRIX_KEYPRESSES
-#define RGB_MATRIX_FRAMEBUFFER_EFFECTS

keyboards/keychron/common/matrix.c

@@ -0,0 +1,218 @@
+/* Copyright 2023 @ Keychron (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "quantum.h"
+
+#ifndef HC595_STCP
+#    define HC595_STCP B0
+#endif
+#ifndef HC595_SHCP
+#    define HC595_SHCP A1
+#endif
+#ifndef HC595_DS
+#    define HC595_DS A7
+#endif
+
+#ifndef HC595_START_INDEX
+#    define HC595_START_INDEX 0
+#endif
+#ifndef HC595_END_INDEX
+#    define HC595_END_INDEX 15
+#endif
+#ifndef HC595_OFFSET_INDEX
+#    define HC595_OFFSET_INDEX 0
+#endif
+
+#if defined(HC595_START_INDEX) && defined(HC595_END_INDEX)
+#    if ((HC595_END_INDEX - HC595_START_INDEX + 1) > 16)
+#        define SIZE_T uint32_t
+#        define UNSELECT_ALL_COL 0xFFFFFFFF
+#        define SELECT_ALL_COL 0x00000000
+#    elif ((HC595_END_INDEX - HC595_START_INDEX + 1) > 8)
+#        define SIZE_T uint16_t
+#        define UNSELECT_ALL_COL 0xFFFF
+#        define SELECT_ALL_COL 0x0000
+#    else
+#        define SIZE_T uint8_t
+#        define UNSELECT_ALL_COL 0xFF
+#        define SELECT_ALL_COL 0x00
+#    endif
+#endif
+
+pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
+pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
+
+static inline uint8_t readMatrixPin(pin_t pin) {
+    if (pin != NO_PIN) {
+        return readPin(pin);
+    } else {
+        return 1;
+    }
+}
+
+static inline void setPinOutput_writeLow(pin_t pin) {
+    setPinOutput(pin);
+    writePinLow(pin);
+}
+
+static inline void setPinOutput_writeHigh(pin_t pin) {
+    setPinOutput(pin);
+    writePinHigh(pin);
+}
+
+static inline void HC595_delay(uint16_t n) {
+    while (n-- > 0) {
+        asm volatile("nop" ::: "memory");
+    }
+}
+
+static void HC595_output(SIZE_T data, bool bit_flag) {
+    uint8_t n = 1;
+
+    ATOMIC_BLOCK_FORCEON {
+        for (uint8_t i = 0; i < (HC595_END_INDEX - HC595_START_INDEX + 1); i++) {
+            if (data & 0x1) {
+                writePinHigh(HC595_DS);
+            } else {
+                writePinLow(HC595_DS);
+            }
+            writePinHigh(HC595_SHCP);
+            HC595_delay(n);
+            writePinLow(HC595_SHCP);
+            HC595_delay(n);
+            if (bit_flag) {
+                break;
+            } else {
+                data = data >> 1;
+            }
+        }
+        writePinHigh(HC595_STCP);
+        HC595_delay(n);
+        writePinLow(HC595_STCP);
+        HC595_delay(n);
+    }
+}
+
+static void select_col(uint8_t col) {
+    if (col < HC595_START_INDEX || col > HC595_END_INDEX) {
+        setPinOutput_writeLow(col_pins[col]);
+    } else {
+        if (col == HC595_START_INDEX) {
+            HC595_output(0x00, true);
+            if (col < HC595_OFFSET_INDEX) {
+                HC595_output(0x01, true);
+            }
+        }
+    }
+}
+
+static void unselect_col(uint8_t col) {
+    if (col < HC595_START_INDEX || col > HC595_END_INDEX) {
+#ifdef MATRIX_UNSELECT_DRIVE_HIGH
+        setPinOutput_writeHigh(col_pins[col]);
+#else
+        setPinInputHigh(col_pins[col]);
+#endif
+    } else {
+        HC595_output(0x01, true);
+    }
+}
+
+static void unselect_cols(void) {
+    for (uint8_t col = 0; col < MATRIX_COLS; col++) {
+        if (col < HC595_START_INDEX || col > HC595_END_INDEX) {
+#ifdef MATRIX_UNSELECT_DRIVE_HIGH
+            setPinOutput_writeHigh(col_pins[col]);
+#else
+            setPinInputHigh(col_pins[col]);
+#endif
+        } else {
+            if (col == HC595_START_INDEX) {
+                HC595_output(UNSELECT_ALL_COL, false);
+            }
+            break;
+        }
+    }
+}
+
+void select_all_cols(void) {
+    for (uint8_t col = 0; col < MATRIX_COLS; col++) {
+        if (col < HC595_START_INDEX || col > HC595_END_INDEX) {
+            setPinOutput_writeLow(col_pins[col]);
+        } else {
+            if (col == HC595_START_INDEX) {
+                HC595_output(SELECT_ALL_COL, false);
+            }
+            break;
+        }
+    }
+}
+
+static void matrix_read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col, matrix_row_t row_shifter) {
+    // Select col
+    select_col(current_col); // select col
+    HC595_delay(200);
+
+    // For each row...
+    for (uint8_t row_index = 0; row_index < MATRIX_ROWS; row_index++) {
+        // Check row pin state
+        if (readMatrixPin(row_pins[row_index]) == 0) {
+            // Pin LO, set col bit
+            current_matrix[row_index] |= row_shifter;
+        } else {
+            // Pin HI, clear col bit
+            current_matrix[row_index] &= ~row_shifter;
+        }
+    }
+
+    // Unselect col
+    unselect_col(current_col);
+    HC595_delay(200); // wait for all Row signals to go HIGH
+}
+
+void matrix_init_custom(void) {
+    setPinOutput(HC595_DS);
+    setPinOutput(HC595_STCP);
+    setPinOutput(HC595_SHCP);
+
+    for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
+        if (row_pins[x] != NO_PIN) {
+            setPinInputHigh(row_pins[x]);
+        }
+    }
+
+    unselect_cols();
+}
+
+bool matrix_scan_custom(matrix_row_t current_matrix[]) {
+    matrix_row_t curr_matrix[MATRIX_ROWS] = {0};
+
+    // Set col, read rows
+    matrix_row_t row_shifter = MATRIX_ROW_SHIFTER;
+    for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++, row_shifter <<= 1) {
+        matrix_read_rows_on_col(curr_matrix, current_col, row_shifter);
+    }
+
+    bool changed = memcmp(current_matrix, curr_matrix, sizeof(curr_matrix)) != 0;
+    if (changed) memcpy(current_matrix, curr_matrix, sizeof(curr_matrix));
+
+    return changed;
+}
+
+void suspend_wakeup_init_kb(void) {
+    // code will run on keyboard wakeup
+    clear_keyboard();
+}

keyboards/keychron/common/wireless/bat_level_animation.c

@@ -0,0 +1,147 @@
+
+#include "quantum.h"
+#include "wireless.h"
+#include "indicator.h"
+#include "lpm.h"
+#if defined(PROTOCOL_CHIBIOS)
+#    include <usb_main.h>
+#elif if defined(PROTOCOL_LUFA)
+#    include "lufa.h"
+#endif
+#include "eeprom.h"
+
+#if (defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)) && defined(BAT_LEVEL_LED_LIST)
+
+#ifndef BAT_LEVEL_GROWING_INTERVAL
+#    define BAT_LEVEL_GROWING_INTERVAL 150
+#endif
+
+#ifndef BAT_LEVEL_ON_INTERVAL
+#    define BAT_LEVEL_ON_INTERVAL 3000
+#endif
+
+#ifdef LED_MATRIX_ENABLE
+#    define LED_DRIVER_IS_ENABLED led_matrix_is_enabled
+#endif
+
+#ifdef RGB_MATRIX_ENABLE
+#    define LED_DRIVER_IS_ENABLED rgb_matrix_is_enabled
+#endif
+
+enum {
+    BAT_LVL_ANI_NONE,
+    BAT_LVL_ANI_GROWING,
+    BAT_LVL_ANI_BLINK_OFF,
+    BAT_LVL_ANI_BLINK_ON,
+};
+
+static uint8_t  animation_state = 0;
+static uint32_t bat_lvl_ani_timer_buffer = 0;
+static uint8_t  bat_percentage;
+static uint8_t  cur_percentage;
+static uint32_t time_interval;
+#ifdef RGB_MATRIX_ENABLE
+static uint8_t r, g, b;
+#endif
+
+extern indicator_config_t indicator_config;
+extern backlight_state_t  original_backlight_state;
+
+void bat_level_animiation_start(uint8_t percentage) {
+    /* Turn on backlight mode for indicator */
+    indicator_enable();
+
+    animation_state          = BAT_LVL_ANI_GROWING;
+    bat_percentage           = percentage;
+    bat_lvl_ani_timer_buffer = timer_read32();
+    cur_percentage           = 0;
+    time_interval            = BAT_LEVEL_GROWING_INTERVAL;
+#ifdef RGB_MATRIX_ENABLE
+    r = g = b = 255;
+#endif
+}
+
+void bat_level_animiation_stop(void) {
+    animation_state = BAT_LVL_ANI_NONE;
+}
+
+bool bat_level_animiation_actived(void) {
+    return animation_state;
+}
+
+void bat_level_animiation_indicate(void) {
+#ifdef LED_MATRIX_ENABLE
+    uint8_t  bat_lvl_led_list[10] = BAT_LEVEL_LED_LIST;
+
+    for (uint8_t i = 0; i <= LED_MATRIX_LED_COUNT; i++) {
+        led_matrix_set_value(i, 0);
+    }
+
+    if (animation_state == BAT_LVL_ANI_GROWING || animation_state == BAT_LVL_ANI_BLINK_ON)
+        for (uint8_t i = 0; i < cur_percentage / 10; i++)
+            led_matrix_set_value(bat_lvl_led_list[i], 255);
+#endif
+
+#ifdef RGB_MATRIX_ENABLE
+    uint8_t  bat_lvl_led_list[10] = BAT_LEVEL_LED_LIST;
+
+    for (uint8_t i = 0; i <= RGB_MATRIX_LED_COUNT; i++) {
+        rgb_matrix_set_color(i, 0, 0, 0);
+    }
+
+    if (animation_state == BAT_LVL_ANI_GROWING || animation_state == BAT_LVL_ANI_BLINK_ON) {
+        for (uint8_t i = 0; i < cur_percentage / 10; i++) {
+            rgb_matrix_set_color(bat_lvl_led_list[i], r, g, b);
+        }
+    }
+#endif
+}
+
+void bat_level_animiation_update(void) {
+    switch (animation_state) {
+        case BAT_LVL_ANI_GROWING:
+            if (cur_percentage < bat_percentage)
+                cur_percentage += 10;
+            else {
+                if (cur_percentage == 0) cur_percentage = 10;
+                animation_state = BAT_LVL_ANI_BLINK_OFF;
+            }
+            break;
+
+        case BAT_LVL_ANI_BLINK_OFF:
+#ifdef RGB_MATRIX_ENABLE
+            if (bat_percentage < 30) {
+                r = 255;
+                b = g = 0;
+            } else {
+                r = b = 0;
+                g     = 255;
+            }
+#endif
+            time_interval   = BAT_LEVEL_ON_INTERVAL;
+            animation_state = BAT_LVL_ANI_BLINK_ON;
+            break;
+
+        case BAT_LVL_ANI_BLINK_ON:
+            animation_state = BAT_LVL_ANI_NONE;
+            indicator_eeconfig_reload();
+            if (indicator_config.value == 0 && !LED_DRIVER_IS_ENABLED()) {
+                indicator_disable();
+            }
+            lpm_timer_reset();
+            break;
+
+        default:
+            break;
+    }
+
+    bat_lvl_ani_timer_buffer = timer_read32();
+}
+
+void bat_level_animiation_task(void) {
+    if (animation_state && sync_timer_elapsed32(bat_lvl_ani_timer_buffer) > time_interval) {
+        bat_level_animiation_update();
+    }
+}
+
+#endif

keyboards/keychron/common/wireless/bat_level_animation.h

@@ -1,4 +1,4 @@
-/* Copyright 2020 QMK
+/* Copyright 2022 @ lokher (https://www.keychron.com)
  *
  * 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
@@ -16,7 +16,8 @@
 
 #pragma once
 
-#include_next <mcuconf.h>
-
-#undef STM32_I2C_USE_I2C1
-#define STM32_I2C_USE_I2C1 TRUE
+void bat_level_animiation_start(uint8_t percentage);
+void bat_level_animiation_stop(void);
+bool bat_level_animiation_actived(void);
+void bat_level_animiation_indicate(void);
+void bat_level_animiation_task(void);

keyboards/keychron/common/wireless/battery.c

@@ -0,0 +1,239 @@
+/* Copyright 2022~2023 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "quantum.h"
+#include "wireless.h"
+#include "battery.h"
+#include "transport.h"
+#include "lkbt51.h"
+#include "lpm.h"
+#include "indicator.h"
+#include "rtc_timer.h"
+#include "analog.h"
+
+#define BATTERY_EMPTY_COUNT 10
+#define CRITICAL_LOW_COUNT 20
+
+/* Battery voltage resistive voltage divider setting of MCU */
+#ifndef RVD_R1
+#    define RVD_R1 10 // Upper side resitor value (uint: KΩ)
+#endif
+#ifndef RVD_R2
+#    define RVD_R2 10 // Lower side resitor value (uint: KΩ)
+#endif
+
+/* Battery voltage resistive voltage divider setting of Bluetooth */
+#ifndef LKBT51_RVD_R1
+#    define LKBT51_RVD_R1 560
+#endif
+#ifndef LKBT51_RVD_R2
+#    define LKBT51_RVD_R2 499
+#endif
+
+#ifndef VOLTAGE_TRIM_LED_MATRIX
+#    define VOLTAGE_TRIM_LED_MATRIX 30
+#endif
+
+#ifndef VOLTAGE_TRIM_RGB_MATRIX
+#    define VOLTAGE_TRIM_RGB_MATRIX 60
+#endif
+
+#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
+extern uint8_t g_pwm_buffer[DRIVER_COUNT][192];
+#endif
+
+static uint32_t bat_monitor_timer_buffer = 0;
+static uint16_t voltage                  = FULL_VOLTAGE_VALUE;
+static uint8_t  bat_empty                = 0;
+static uint8_t  critical_low             = 0;
+static uint8_t  bat_state;
+static uint8_t  power_on_sample = 0;
+
+void battery_init(void) {
+    bat_state = BAT_NOT_CHARGING;
+#if defined(BAT_CHARGING_PIN)
+#    if (BAT_CHARGING_LEVEL == 0)
+    palSetLineMode(BAT_CHARGING_PIN, PAL_MODE_INPUT_PULLUP);
+#    else
+    palSetLineMode(BAT_CHARGING_PIN, PAL_MODE_INPUT_PULLDOWN);
+#    endif
+#endif
+
+#ifdef BAT_ADC_ENABLE_PIN
+    palSetLineMode(BAT_ADC_ENABLE_PIN, PAL_MODE_OUTPUT_PUSHPULL);
+    writePin(BAT_ADC_ENABLE_PIN, 1);
+#endif
+#ifdef BAT_ADC_PIN
+    palSetLineMode(BAT_ADC_PIN, PAL_MODE_INPUT_ANALOG);
+#endif
+}
+
+void battery_stop(void) {
+#if (HAL_USE_ADC)
+#    ifdef BAT_ADC_ENABLE_PIN
+    writePin(BAT_ADC_ENABLE_PIN, 0);
+#    endif
+#    ifdef BAT_ADC_PIN
+    palSetLineMode(BAT_ADC_PIN, PAL_MODE_INPUT_ANALOG);
+    analog_stop(BAT_ADC_PIN);
+#    endif
+#endif
+}
+
+__attribute__((weak)) void battery_measure(void) {
+    lkbt51_read_state_reg(0x05, 0x02);
+}
+
+/* Calculate the voltage */
+__attribute__((weak)) void battery_calculate_voltage(bool vol_src_bt, uint16_t value) {
+    uint16_t voltage;
+
+    if (vol_src_bt)
+        voltage = ((uint32_t)value) * (LKBT51_RVD_R1 + LKBT51_RVD_R2) / LKBT51_RVD_R2;
+    else
+        voltage = (uint32_t)value * 3300 / 1024 * (RVD_R1 + RVD_R2) / RVD_R2;
+
+#ifdef LED_MATRIX_ENABLE
+    if (led_matrix_is_enabled()) {
+        uint32_t totalBuf = 0;
+
+        for (uint8_t i = 0; i < DRIVER_COUNT; i++)
+            for (uint8_t j = 0; j < 192; j++)
+                totalBuf += g_pwm_buffer[i][j];
+        /* We assumpt it is linear relationship*/
+        voltage += (VOLTAGE_TRIM_LED_MATRIX * totalBuf / LED_MATRIX_LED_COUNT / 255);
+    }
+#endif
+#ifdef RGB_MATRIX_ENABLE
+    if (rgb_matrix_is_enabled()) {
+        uint32_t totalBuf = 0;
+
+        for (uint8_t i = 0; i < DRIVER_COUNT; i++)
+            for (uint8_t j = 0; j < 192; j++)
+                totalBuf += g_pwm_buffer[i][j];
+        /* We assumpt it is linear relationship*/
+        uint32_t compensation = VOLTAGE_TRIM_RGB_MATRIX * totalBuf / RGB_MATRIX_LED_COUNT / 255 / 3;
+
+        voltage += compensation;
+    }
+#endif
+
+    battery_set_voltage(voltage);
+}
+
+void battery_set_voltage(uint16_t value) {
+    voltage = value;
+}
+
+uint16_t battery_get_voltage(void) {
+    return voltage;
+}
+
+uint8_t battery_get_percentage(void) {
+    if (voltage > FULL_VOLTAGE_VALUE) return 100;
+
+    if (voltage > EMPTY_VOLTAGE_VALUE) {
+        return ((uint32_t)voltage - EMPTY_VOLTAGE_VALUE) * 80 / (FULL_VOLTAGE_VALUE - EMPTY_VOLTAGE_VALUE) + 20;
+    }
+
+    if (voltage > SHUTDOWN_VOLTAGE_VALUE) {
+        return ((uint32_t)voltage - SHUTDOWN_VOLTAGE_VALUE) * 20 / (EMPTY_VOLTAGE_VALUE - SHUTDOWN_VOLTAGE_VALUE);
+    } else
+        return 0;
+}
+
+bool battery_is_empty(void) {
+    return bat_empty > BATTERY_EMPTY_COUNT;
+}
+
+bool battery_is_critical_low(void) {
+    return critical_low > CRITICAL_LOW_COUNT;
+}
+
+void battery_check_empty(void) {
+    if (voltage < EMPTY_VOLTAGE_VALUE) {
+        if (bat_empty <= BATTERY_EMPTY_COUNT) {
+            if (++bat_empty > BATTERY_EMPTY_COUNT) {
+#ifdef BAT_LOW_LED_PIN
+                indicator_battery_low_enable(true);
+#endif
+#if defined(LOW_BAT_IND_INDEX)
+                indicator_battery_low_backlit_enable(true);
+#endif
+                power_on_sample = VOLTAGE_POWER_ON_MEASURE_COUNT;
+            }
+        }
+    }
+}
+
+void battery_check_critical_low(void) {
+    if (voltage < SHUTDOWN_VOLTAGE_VALUE) {
+        if (critical_low <= CRITICAL_LOW_COUNT) {
+            if (++critical_low > CRITICAL_LOW_COUNT) wireless_low_battery_shutdown();
+        }
+    } else if (critical_low <= CRITICAL_LOW_COUNT) {
+        critical_low = 0;
+    }
+}
+
+bool battery_power_on_sample(void) {
+    return power_on_sample < VOLTAGE_POWER_ON_MEASURE_COUNT;
+}
+
+void battery_task(void) {
+    uint32_t t = rtc_timer_elapsed_ms(bat_monitor_timer_buffer);
+    if ((get_transport() & TRANSPORT_WIRELESS) && (wireless_get_state() == WT_CONNECTED || battery_power_on_sample())) {
+#if defined(BAT_CHARGING_PIN)
+        if (usb_power_connected() && t > VOLTAGE_MEASURE_INTERVAL) {
+            if (readPin(BAT_CHARGING_PIN) == BAT_CHARGING_LEVEL)
+                lkbt51_update_bat_state(BAT_CHARGING);
+            else
+                lkbt51_update_bat_state(BAT_FULL_CHARGED);
+        }
+#endif
+
+        if ((battery_power_on_sample()
+#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
+             && !indicator_is_enabled()
+#endif
+             && t > BACKLIGHT_OFF_VOLTAGE_MEASURE_INTERVAL) ||
+            t > VOLTAGE_MEASURE_INTERVAL) {
+
+            battery_check_empty();
+            battery_check_critical_low();
+
+            bat_monitor_timer_buffer = rtc_timer_read_ms();
+            if (bat_monitor_timer_buffer > RTC_MAX_TIME) {
+                bat_monitor_timer_buffer = 0;
+                rtc_timer_clear();
+            }
+
+            battery_measure();
+            if (power_on_sample < VOLTAGE_POWER_ON_MEASURE_COUNT) power_on_sample++;
+        }
+    }
+
+    if ((bat_empty || critical_low) && usb_power_connected()) {
+        bat_empty    = false;
+        critical_low = false;
+#ifdef BAT_LOW_LED_PIN
+        indicator_battery_low_enable(false);
+#endif
+#if defined(LOW_BAT_IND_INDEX)
+        indicator_battery_low_backlit_enable(false);
+#endif
+    }
+}

keyboards/keychron/common/wireless/battery.h

@@ -0,0 +1,62 @@
+/* Copyright 2022~2023 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+enum {
+    BAT_NOT_CHARGING = 0,
+    BAT_CHARGING,
+    BAT_FULL_CHARGED,
+};
+
+#ifndef FULL_VOLTAGE_VALUE
+#    define FULL_VOLTAGE_VALUE 4100
+#endif
+
+#ifndef EMPTY_VOLTAGE_VALUE
+#    define EMPTY_VOLTAGE_VALUE 3500
+#endif
+
+#ifndef SHUTDOWN_VOLTAGE_VALUE
+#    define SHUTDOWN_VOLTAGE_VALUE 3300
+#endif
+
+#ifndef VOLTAGE_MEASURE_INTERVAL
+#    define VOLTAGE_MEASURE_INTERVAL 3000
+#endif
+
+#ifndef VOLTAGE_POWER_ON_MEASURE_COUNT
+#    define VOLTAGE_POWER_ON_MEASURE_COUNT 15
+#endif
+
+#ifndef BACKLIGHT_OFF_VOLTAGE_MEASURE_INTERVAL
+#    define BACKLIGHT_OFF_VOLTAGE_MEASURE_INTERVAL 200
+#endif
+
+void battery_init(void);
+void battery_stop(void);
+
+void     battery_measure(void);
+void     battery_calculate_voltage(bool vol_src_bt, uint16_t value);
+void     battery_set_voltage(uint16_t value);
+uint16_t battery_get_voltage(void);
+uint8_t  battery_get_percentage(void);
+void     indicator_battery_low_enable(bool enable);
+bool     battery_is_empty(void);
+bool     battery_is_critical_low(void);
+bool     battery_power_on_sample(void);
+
+void battery_task(void);

keyboards/keychron/common/wireless/indicator.c

@@ -0,0 +1,723 @@
+/* Copyright 2023 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "quantum.h"
+#include "indicator.h"
+#include "transport.h"
+#include "battery.h"
+#include "eeconfig.h"
+#include "wireless_config.h"
+#include "config.h"
+#include "rtc_timer.h"
+#include "keychron_common.h"
+#include "usb_main.h"
+#ifdef FACTORY_TEST_ENABLE
+#    include "factory_test.h"
+#endif
+#include "lpm.h"
+
+#include "keychron_task.h"
+#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
+#    ifdef LED_MATRIX_ENABLE
+#        include "led_matrix.h"
+#    endif
+#    ifdef RGB_MATRIX_ENABLE
+#        include "rgb_matrix.h"
+#    endif
+#    include "bat_level_animation.h"
+#    include "eeprom.h"
+#endif
+
+#define HOST_INDEX_MASK 0x0F
+#define HOST_P2P4G 0x10
+#define LED_ON 0x80
+
+// #define RGB_MATRIX_TIMEOUT_INFINITE 0xFFFFFFFF
+#ifdef LED_MATRIX_ENABLE
+#    define DECIDE_TIME(t, duration) (duration == 0 ? LED_MATRIX_TIMEOUT_INFINITE : ((t > duration) ? t : duration))
+#endif
+#ifdef RGB_MATRIX_ENABLE
+#    define DECIDE_TIME(t, duration) (duration == 0 ? RGB_MATRIX_TIMEOUT_INFINITE : ((t > duration) ? t : duration))
+#endif
+
+#define INDICATOR_SET(s) memcpy(&indicator_config, &s##_config, sizeof(indicator_config_t));
+
+enum {
+    BACKLIGHT_OFF            = 0x00,
+    BACKLIGHT_ON_CONNECTED   = 0x01,
+    BACKLIGHT_ON_UNCONNECTED = 0x02,
+};
+
+static indicator_config_t pairing_config      = INDICATOR_CONFIG_PARING;
+static indicator_config_t connected_config    = INDICATOR_CONFIG_CONNECTD;
+static indicator_config_t reconnecting_config = INDICATOR_CONFIG_RECONNECTING;
+static indicator_config_t disconnected_config = INDICATOR_CONFIG_DISCONNECTED;
+indicator_config_t        indicator_config;
+static wt_state_t         indicator_state;
+static uint16_t           next_period;
+static indicator_type_t   type;
+static uint32_t           indicator_timer_buffer = 0;
+
+#if defined(BAT_LOW_LED_PIN)
+static uint32_t bat_low_pin_indicator  = 0;
+static uint32_t bat_low_blink_duration = 0;
+#endif
+
+#if defined(LOW_BAT_IND_INDEX)
+static uint32_t bat_low_backlit_indicator = 0;
+static uint8_t  bat_low_ind_state         = 0;
+static uint32_t rtc_time                  = 0;
+#endif
+
+#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
+backlight_state_t original_backlight_state;
+
+#    ifdef BT_HOST_LED_MATRIX_LIST
+static uint8_t bt_host_led_matrix_list[BT_HOST_DEVICES_COUNT] = BT_HOST_LED_MATRIX_LIST;
+#    endif
+
+#    ifdef P2P4G_HOST_LED_MATRIX_LIST
+static uint8_t p2p4g_host_led_matrix_list[P2P4G_HOST_DEVICES_COUNT] = P2P4G_HOST_LED_MATRIX_LIST;
+#    endif
+
+#endif
+
+#ifdef BT_HOST_LED_PIN_LIST
+static pin_t bt_led_pin_list[BT_HOST_DEVICES_COUNT] = BT_HOST_LED_PIN_LIST;
+#endif
+
+#ifdef P24G_HOST_LED_PIN_LIST
+static pin_t p24g_led_pin_list[P24G_HOST_DEVICES_COUNT] = P24G_HOST_LED_PIN_LIST;
+#endif
+
+#ifdef LED_MATRIX_ENABLE
+#    define LED_DRIVER led_matrix_driver
+#    define LED_INDICATORS_KB led_matrix_indicators_bt
+#    define LED_INDICATORS_USER led_matrix_indicators_user
+#    define LED_NONE_INDICATORS_KB led_matrix_none_indicators_kb
+#    define SET_ALL_LED_OFF() led_matrix_set_value_all(0)
+#    define SET_LED_OFF(idx) led_matrix_set_value(idx, 0)
+#    define SET_LED_ON(idx) led_matrix_set_value(idx, 255)
+#    define SET_LED_BT(idx) led_matrix_set_value(idx, 255)
+#    define SET_LED_P24G(idx) led_matrix_set_value(idx, 255)
+#    define SET_LED_LOW_BAT(idx) led_matrix_set_value(idx, 255)
+#    define LED_DRIVER_IS_ENABLED led_matrix_is_enabled
+#    define LED_DRIVER_EECONFIG_RELOAD()                                                           \
+        eeprom_read_block(&led_matrix_eeconfig, EECONFIG_LED_MATRIX, sizeof(led_matrix_eeconfig)); \
+        if (!led_matrix_eeconfig.mode) {                                                           \
+            eeconfig_update_led_matrix_default();                                                  \
+        }
+#    define LED_DRIVER_ALLOW_SHUTDOWN led_matrix_driver_allow_shutdown
+#    define LED_DRIVER_SHUTDOWN led_matrix_driver_shutdown
+#    define LED_DRIVER_EXIT_SHUTDOWN led_matrix_driver_exit_shutdown
+#    define LED_DRIVER_ENABLE_NOEEPROM led_matrix_enable_noeeprom
+#    define LED_DRIVER_DISABLE_NOEEPROM led_matrix_disable_noeeprom
+#    define LED_DRIVER_DISABLE_TIMEOUT_SET led_matrix_disable_timeout_set
+#    define LED_DRIVER_DISABLE_TIME_RESET led_matrix_disable_time_reset
+#    define LED_DRIVER_TIMEOUTED led_matrix_timeouted
+#endif
+
+#ifdef RGB_MATRIX_ENABLE
+#    define LED_DRIVER rgb_matrix_driver
+#    define LED_INDICATORS_KB rgb_matrix_indicators_bt
+#    define LED_INDICATORS_USER rgb_matrix_indicators_user
+#    define LED_NONE_INDICATORS_KB rgb_matrix_none_indicators_kb
+#    define SET_ALL_LED_OFF() rgb_matrix_set_color_all(0, 0, 0)
+#    define SET_LED_OFF(idx) rgb_matrix_set_color(idx, 0, 0, 0)
+#    define SET_LED_ON(idx) rgb_matrix_set_color(idx, 255, 255, 255)
+#    define SET_LED_BT(idx) rgb_matrix_set_color(idx, 0, 0, 255)
+#    define SET_LED_P24G(idx) rgb_matrix_set_color(idx, 0, 255, 0)
+#    define SET_LED_LOW_BAT(idx) rgb_matrix_set_color(idx, 255, 0, 0)
+#    define LED_DRIVER_IS_ENABLED rgb_matrix_is_enabled
+#    define LED_DRIVER_EECONFIG_RELOAD()                                                       \
+        eeprom_read_block(&rgb_matrix_config, EECONFIG_RGB_MATRIX, sizeof(rgb_matrix_config)); \
+        if (!rgb_matrix_config.mode) {                                                         \
+            eeconfig_update_rgb_matrix_default();                                              \
+        }
+#    define LED_DRIVER_ALLOW_SHUTDOWN rgb_matrix_driver_allow_shutdown
+#    define LED_DRIVER_SHUTDOWN rgb_matrix_driver_shutdown
+#    define LED_DRIVER_EXIT_SHUTDOWN rgb_matrix_driver_exit_shutdown
+#    define LED_DRIVER_ENABLE_NOEEPROM rgb_matrix_enable_noeeprom
+#    define LED_DRIVER_DISABLE_NOEEPROM rgb_matrix_disable_noeeprom
+#    define LED_DRIVER_DISABLE_TIMEOUT_SET rgb_matrix_disable_timeout_set
+#    define LED_DRIVER_DISABLE_TIME_RESET rgb_matrix_disable_time_reset
+#    define LED_DRIVER_TIMEOUTED rgb_matrix_timeouted
+#endif
+
+bool LED_INDICATORS_KB(void);
+
+void indicator_init(void) {
+    memset(&indicator_config, 0, sizeof(indicator_config));
+
+#ifdef BT_HOST_LED_PIN_LIST
+    for (uint8_t i = 0; i < BT_HOST_DEVICES_COUNT; i++) {
+        setPinOutput(bt_led_pin_list[i]);
+        writePin(bt_led_pin_list[i], !HOST_LED_PIN_ON_STATE);
+    }
+#endif
+
+#ifdef P24G_HOST_LED_PIN_LIST
+    for (uint8_t i = 0; i < P24G_HOST_DEVICES_COUNT; i++) {
+        setPinOutput(p24g_led_pin_list[i]);
+        writePin(p24g_led_pin_list[i], !HOST_LED_PIN_ON_STATE);
+    }
+#endif
+
+#ifdef BAT_LOW_LED_PIN
+    setPinOutput(BAT_LOW_LED_PIN);
+    writePin(BAT_LOW_LED_PIN, !BAT_LOW_LED_PIN_ON_STATE);
+#endif
+#ifdef KEYCHRON_CALLBACK_ENABLE
+    register_led_indicator_task(LED_INDICATORS_KB, false);
+#endif
+}
+
+#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
+void indicator_enable(void) {
+    if (!LED_DRIVER_IS_ENABLED()) {
+        LED_DRIVER_ENABLE_NOEEPROM();
+    }
+}
+
+inline void indicator_disable(void) {
+    LED_DRIVER_DISABLE_NOEEPROM();
+}
+
+void indicator_set_backlit_timeout(uint32_t time) {
+    LED_DRIVER_DISABLE_TIMEOUT_SET(time);
+}
+
+static inline void indicator_reset_backlit_time(void) {
+    LED_DRIVER_DISABLE_TIME_RESET();
+}
+
+bool indicator_is_enabled(void) {
+    return LED_DRIVER_IS_ENABLED();
+}
+
+void indicator_eeconfig_reload(void) {
+    LED_DRIVER_EECONFIG_RELOAD();
+}
+
+#endif
+
+bool indicator_is_running(void) {
+    return
+#if defined(BAT_LOW_LED_PIN)
+        bat_low_blink_duration ||
+#endif
+#if defined(LOW_BAT_IND_INDEX)
+        bat_low_ind_state ||
+#endif
+        !!indicator_config.value;
+}
+
+static void indicator_timer_cb(void *arg) {
+    if (*(indicator_type_t *)arg != INDICATOR_LAST) type = *(indicator_type_t *)arg;
+
+    bool time_up = false;
+    switch (type) {
+        case INDICATOR_NONE:
+            break;
+        case INDICATOR_OFF:
+            next_period = 0;
+            time_up     = true;
+            break;
+
+        case INDICATOR_ON:
+            if (indicator_config.value) {
+                if (indicator_config.elapsed == 0) {
+                    indicator_config.value |= LED_ON;
+
+                    if (indicator_config.duration) {
+                        indicator_config.elapsed += indicator_config.duration;
+                    }
+                } else
+                    time_up = true;
+            }
+            break;
+
+        case INDICATOR_ON_OFF:
+            if (indicator_config.value) {
+                if (indicator_config.elapsed == 0) {
+                    indicator_config.value |= LED_ON;
+                    next_period = indicator_config.on_time;
+                } else {
+                    indicator_config.value = indicator_config.value & 0x1F;
+                    next_period            = indicator_config.duration - indicator_config.on_time;
+                }
+
+                if ((indicator_config.duration == 0 || indicator_config.elapsed <= indicator_config.duration) && next_period != 0) {
+                    indicator_config.elapsed += next_period;
+                } else {
+                    time_up = true;
+                }
+            }
+            break;
+
+        case INDICATOR_BLINK:
+            if (indicator_config.value) {
+                if (indicator_config.value & LED_ON) {
+                    indicator_config.value = indicator_config.value & 0x1F;
+                    next_period            = indicator_config.off_time;
+                } else {
+                    indicator_config.value |= LED_ON;
+                    next_period = indicator_config.on_time;
+                }
+
+                if ((indicator_config.duration == 0 || indicator_config.elapsed <= indicator_config.duration) && next_period != 0) {
+                    indicator_config.elapsed += next_period;
+                } else {
+                    time_up = true;
+                }
+            }
+            break;
+        default:
+            time_up = true;
+
+            next_period = 0;
+            break;
+    }
+
+#if defined(BT_HOST_LED_PIN_LIST) || defined(P24G_HOST_LED_PIN_LIST)
+    if (indicator_config.value) {
+        uint8_t idx = (indicator_config.value & HOST_INDEX_MASK) - 1;
+
+        pin_t  *led_lin_list = NULL;
+        uint8_t led_count;
+#    if defined(P24G_HOST_LED_PIN_LIST)
+        if (indicator_config.value & HOST_P2P4G) {
+            if (idx < P24G_HOST_DEVICES_COUNT) led_lin_list = p24g_led_pin_list;
+            led_count = P24G_HOST_DEVICES_COUNT;
+        } else
+#    endif
+        {
+            if (idx < BT_HOST_DEVICES_COUNT) led_lin_list = bt_led_pin_list;
+            led_count = BT_HOST_DEVICES_COUNT;
+        }
+
+        for (uint8_t i = 0; i < led_count; i++) {
+            if (i != idx) writePin(led_lin_list[idx], !HOST_LED_PIN_ON_STATE);
+        }
+
+        if (led_lin_list) {
+            if ((indicator_config.value & LED_ON) && !time_up) {
+                writePin(led_lin_list[idx], HOST_LED_PIN_ON_STATE);
+            } else {
+                writePin(led_lin_list[idx], !HOST_LED_PIN_ON_STATE);
+            }
+        }
+    }
+#endif
+
+    if (time_up) {
+        /* Set indicator to off on timeup, avoid keeping light up until next update in raindrop effect */
+        indicator_config.value = indicator_config.value & 0x1F;
+#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
+        LED_INDICATORS_KB();
+#endif
+
+        indicator_config.value = 0;
+        lpm_timer_reset();
+    }
+
+    if (indicator_config.value == 0) {
+#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
+        indicator_eeconfig_reload();
+        if (!LED_DRIVER_IS_ENABLED()) indicator_disable();
+#endif
+    }
+}
+
+void indicator_set(wt_state_t state, uint8_t host_index) {
+    if (get_transport() == TRANSPORT_USB) return;
+
+    static uint8_t current_state      = 0;
+    static uint8_t current_host       = 0;
+    bool           host_index_changed = false;
+
+    if (host_index == 24) host_index = HOST_P2P4G | 0x01;
+
+    if (current_host != host_index && state != WT_DISCONNECTED) {
+        host_index_changed = true;
+        current_host       = host_index;
+    }
+
+    if (current_state != state || host_index_changed || state == WT_RECONNECTING) {
+        current_state = state;
+    } else {
+        return;
+    }
+
+    indicator_timer_buffer = timer_read32();
+
+#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
+    /* Turn on backlight mode for indicator */
+    indicator_enable();
+    indicator_reset_backlit_time();
+#endif
+
+    switch (state) {
+        case WT_DISCONNECTED:
+
+#if defined(BT_HOST_LED_PIN_LIST)
+            if ((host_index & HOST_P2P4G) != HOST_P2P4G) writePin(bt_led_pin_list[(host_index & HOST_INDEX_MASK) - 1], !HOST_LED_PIN_ON_STATE);
+#endif
+#if defined(P24G_HOST_LED_PIN_LIST)
+            if (host_index & HOST_P2P4G) writePin(p24g_led_pin_list[(host_index & HOST_INDEX_MASK) - 1], !HOST_LED_PIN_ON_STATE);
+#endif
+
+            INDICATOR_SET(disconnected);
+            indicator_config.value = (indicator_config.type == INDICATOR_NONE) ? 0 : host_index;
+            indicator_timer_cb((void *)&indicator_config.type);
+#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
+            if (battery_is_critical_low()) {
+                indicator_set_backlit_timeout(1000);
+
+            } else {
+                /* Set timer so that user has chance to turn on the backlight when is off */
+                indicator_set_backlit_timeout(DECIDE_TIME(DISCONNECTED_BACKLIGHT_DISABLE_TIMEOUT * 1000, indicator_config.duration));
+            }
+#endif
+            break;
+
+        case WT_CONNECTED:
+            if (indicator_state != WT_CONNECTED) {
+                INDICATOR_SET(connected);
+                indicator_config.value = (indicator_config.type == INDICATOR_NONE) ? 0 : host_index;
+                indicator_timer_cb((void *)&indicator_config.type);
+            }
+#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
+            indicator_set_backlit_timeout(DECIDE_TIME(CONNECTED_BACKLIGHT_DISABLE_TIMEOUT * 1000, indicator_config.duration));
+#endif
+            break;
+
+        case WT_PARING:
+            INDICATOR_SET(pairing);
+            indicator_config.value = (indicator_config.type == INDICATOR_NONE) ? 0 : LED_ON | host_index;
+            indicator_timer_cb((void *)&indicator_config.type);
+#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
+            indicator_set_backlit_timeout(DECIDE_TIME(DISCONNECTED_BACKLIGHT_DISABLE_TIMEOUT * 1000, indicator_config.duration));
+#endif
+            break;
+
+        case WT_RECONNECTING:
+            INDICATOR_SET(reconnecting);
+            indicator_config.value = (indicator_config.type == INDICATOR_NONE) ? 0 : LED_ON | host_index;
+            indicator_timer_cb((void *)&indicator_config.type);
+#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
+            indicator_set_backlit_timeout(DECIDE_TIME(DISCONNECTED_BACKLIGHT_DISABLE_TIMEOUT * 1000, indicator_config.duration));
+#endif
+            break;
+
+        case WT_SUSPEND:
+            INDICATOR_SET(disconnected);
+            indicator_config.value = (indicator_config.type == INDICATOR_NONE) ? 0 : host_index;
+            indicator_timer_cb((void *)&indicator_config.type);
+#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
+#    ifdef FACTORY_TEST_ENABLE
+            if (factory_reset_indicating())
+                indicator_set_backlit_timeout(3000);
+            else
+#    endif
+            {
+                indicator_set_backlit_timeout(1000);
+            }
+#endif
+
+#if defined(BT_HOST_LED_PIN_LIST)
+            for (uint8_t i = 0; i < BT_HOST_DEVICES_COUNT; i++)
+                writePin(bt_led_pin_list[i], !HOST_LED_PIN_ON_STATE);
+#endif
+#if defined(P24G_HOST_LED_PIN_LIST)
+            for (uint8_t i = 0; i < P24G_HOST_DEVICES_COUNT; i++)
+                writePin(p24g_led_pin_list[i], !HOST_LED_PIN_ON_STATE);
+#endif
+            break;
+
+        default:
+            break;
+    }
+
+    indicator_state = state;
+}
+
+void indicator_stop(void) {
+    indicator_config.value = 0;
+#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
+    indicator_eeconfig_reload();
+
+    if (indicator_is_enabled()) {
+        indicator_enable();
+    } else {
+        indicator_disable();
+    }
+#endif
+}
+
+#ifdef BAT_LOW_LED_PIN
+void indicator_battery_low_enable(bool enable) {
+    if (enable) {
+        if (bat_low_blink_duration == 0) {
+            bat_low_blink_duration = bat_low_pin_indicator = timer_read32();
+        } else
+            bat_low_blink_duration = timer_read32();
+    } else
+        writePin(BAT_LOW_LED_PIN, !BAT_LOW_LED_PIN_ON_STATE);
+}
+#endif
+
+#if defined(LOW_BAT_IND_INDEX)
+void indicator_battery_low_backlit_enable(bool enable) {
+    if (enable) {
+        uint32_t t = rtc_timer_read_ms();
+        /* Check overflow */
+        if (rtc_time > t) {
+            if (bat_low_ind_state == 0)
+                rtc_time = t; // Update rtc_time if indicating is not running
+            else {
+                rtc_time += t;
+            }
+        }
+        /* Indicating at first time or after the interval */
+        if ((rtc_time == 0 || t - rtc_time > LOW_BAT_LED_TRIG_INTERVAL) && bat_low_ind_state == 0) {
+            bat_low_backlit_indicator = enable ? timer_read32() : 0;
+            rtc_time                  = rtc_timer_read_ms();
+            bat_low_ind_state         = 1;
+
+            indicator_enable();
+        }
+    } else {
+        rtc_time          = 0;
+        bat_low_ind_state = 0;
+
+        indicator_eeconfig_reload();
+        if (!LED_DRIVER_IS_ENABLED()) indicator_disable();
+    }
+}
+#endif
+
+void indicator_battery_low(void) {
+#ifdef BAT_LOW_LED_PIN
+    if (bat_low_pin_indicator && timer_elapsed32(bat_low_pin_indicator) > (LOW_BAT_LED_BLINK_PERIOD)) {
+        togglePin(BAT_LOW_LED_PIN);
+        bat_low_pin_indicator = timer_read32();
+        // Turn off low battery indication if we reach the duration
+        if (timer_elapsed32(bat_low_blink_duration) > LOW_BAT_LED_BLINK_DURATION && palReadLine(BAT_LOW_LED_PIN) != BAT_LOW_LED_PIN_ON_STATE) {
+            bat_low_blink_duration = bat_low_pin_indicator = 0;
+        }
+    }
+#endif
+#if defined(LOW_BAT_IND_INDEX)
+    if (bat_low_ind_state) {
+        if ((bat_low_ind_state & 0x0F) <= (LOW_BAT_LED_BLINK_TIMES) && timer_elapsed32(bat_low_backlit_indicator) > (LOW_BAT_LED_BLINK_PERIOD)) {
+            if (bat_low_ind_state & 0x80) {
+                bat_low_ind_state &= 0x7F;
+                bat_low_ind_state++;
+            } else {
+                bat_low_ind_state |= 0x80;
+            }
+
+            bat_low_backlit_indicator = timer_read32();
+
+            /*  Restore backligth state */
+            if ((bat_low_ind_state & 0x0F) > (LOW_BAT_LED_BLINK_TIMES)) {
+#    if defined(NUM_LOCK_INDEX) || defined(CAPS_LOCK_INDEX) || defined(SCROLL_LOCK_INDEX) || defined(COMPOSE_LOCK_INDEX) || defined(KANA_LOCK_INDEX)
+                if (LED_DRIVER_ALLOW_SHUTDOWN())
+#    endif
+                    indicator_disable();
+            }
+        } else if ((bat_low_ind_state & 0x0F) > (LOW_BAT_LED_BLINK_TIMES)) {
+            bat_low_ind_state = 0;
+            lpm_timer_reset();
+        }
+    }
+#endif
+}
+
+void indicator_task(void) {
+#if (defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)) && defined(BAT_LEVEL_LED_LIST)
+    bat_level_animiation_task();
+#endif
+    if (indicator_config.value && timer_elapsed32(indicator_timer_buffer) >= next_period) {
+        indicator_timer_cb((void *)&type);
+        indicator_timer_buffer = timer_read32();
+    }
+
+    indicator_battery_low();
+}
+
+#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
+__attribute__((weak)) void os_state_indicate(void) {
+#    if defined(RGB_DISABLE_WHEN_USB_SUSPENDED) || defined(LED_DISABLE_WHEN_USB_SUSPENDED)
+    if (get_transport() == TRANSPORT_USB && USB_DRIVER.state == USB_SUSPENDED) return;
+#    endif
+
+#    if defined(NUM_LOCK_INDEX)
+    if (host_keyboard_led_state().num_lock) {
+        SET_LED_ON(NUM_LOCK_INDEX);
+    }
+#    endif
+#    if defined(CAPS_LOCK_INDEX)
+    if (host_keyboard_led_state().caps_lock) {
+#        if defined(DIM_CAPS_LOCK)
+        SET_LED_OFF(CAPS_LOCK_INDEX);
+#        else
+        SET_LED_ON(CAPS_LOCK_INDEX);
+#        endif
+    }
+#    endif
+#    if defined(SCROLL_LOCK_INDEX)
+    if (host_keyboard_led_state().scroll_lock) {
+        SET_LED_ON(SCROLL_LOCK_INDEX);
+    }
+#    endif
+#    if defined(COMPOSE_LOCK_INDEX)
+    if (host_keyboard_led_state().compose) {
+        SET_LED_ON(COMPOSE_LOCK_INDEX);
+    }
+#    endif
+#    if defined(KANA_LOCK_INDEX)
+    if (host_keyboard_led_state().kana) {
+        SET_LED_ON(KANA_LOCK_INDEX);
+    }
+#    endif
+}
+
+bool LED_INDICATORS_KB(void) {
+    if (get_transport() & TRANSPORT_WIRELESS) {
+        /* Prevent backlight flash caused by key activities */
+        if (battery_is_critical_low()) {
+            SET_ALL_LED_OFF();
+            return true;
+        }
+
+#    if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
+        if (battery_is_empty()) SET_ALL_LED_OFF();
+#        if defined(LOW_BAT_IND_INDEX)
+        if (bat_low_ind_state && (bat_low_ind_state & 0x0F) <= LOW_BAT_LED_BLINK_TIMES) {
+            uint8_t idx_list[] = LOW_BAT_IND_INDEX;
+            for (uint8_t i = 0; i < sizeof(idx_list); i++) {
+                if (bat_low_ind_state & LED_ON) {
+                    SET_LED_LOW_BAT(idx_list[i]);
+                } else {
+                    SET_LED_OFF(idx_list[i]);
+                }
+            }
+        }
+#        endif
+#    endif
+#    if (defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)) && defined(BAT_LEVEL_LED_LIST)
+        if (bat_level_animiation_actived()) {
+            bat_level_animiation_indicate();
+        }
+#    endif
+        static uint8_t last_host_index = 0xFF;
+
+        if (indicator_config.value) {
+            uint8_t host_index = indicator_config.value & HOST_INDEX_MASK;
+
+            if (indicator_config.highlight) {
+                SET_ALL_LED_OFF();
+            } else if (last_host_index != host_index) {
+                if (indicator_config.value & HOST_P2P4G)
+                    SET_LED_OFF(p2p4g_host_led_matrix_list[host_index - 1]);
+                else
+                    SET_LED_OFF(bt_host_led_matrix_list[host_index - 1]);
+                last_host_index = host_index;
+            }
+
+            if (indicator_config.value & LED_ON) {
+#    ifdef P2P4G_HOST_LED_MATRIX_LIST
+                if (indicator_config.value & HOST_P2P4G)
+                    SET_LED_P24G(p2p4g_host_led_matrix_list[host_index - 1]);
+                else
+#    endif
+                    SET_LED_BT(bt_host_led_matrix_list[host_index - 1]);
+
+            } else {
+#    ifdef P2P4G_HOST_LED_MATRIX_LIST
+                if (indicator_config.value & HOST_P2P4G)
+                    SET_LED_OFF(p2p4g_host_led_matrix_list[host_index - 1]);
+                else
+#    endif
+                    SET_LED_OFF(bt_host_led_matrix_list[host_index - 1]);
+            }
+        } else
+            os_state_indicate();
+
+    } else
+        os_state_indicate();
+
+    if (!LED_INDICATORS_USER()) return true;
+
+    return true;
+}
+
+bool led_update_kb(led_t led_state) {
+    bool res = led_update_user(led_state);
+    if (res) {
+        led_update_ports(led_state);
+
+        if (!LED_DRIVER_IS_ENABLED() || (LED_DRIVER_IS_ENABLED() && LED_DRIVER_TIMEOUTED())) {
+#    if defined(LED_MATRIX_DRIVER_SHUTDOWN_ENABLE) || defined(RGB_MATRIX_DRIVER_SHUTDOWN_ENABLE)
+            LED_DRIVER_EXIT_SHUTDOWN();
+#    endif
+            SET_ALL_LED_OFF();
+            os_state_indicate();
+            LED_DRIVER.flush();
+#    if defined(LED_MATRIX_DRIVER_SHUTDOWN_ENABLE) || defined(RGB_MATRIX_DRIVER_SHUTDOWN_ENABLE)
+            if (LED_DRIVER_ALLOW_SHUTDOWN()) LED_DRIVER_SHUTDOWN();
+#    endif
+        }
+    }
+
+    return res;
+}
+
+void LED_NONE_INDICATORS_KB(void) {
+#    if defined(RGB_DISABLE_WHEN_USB_SUSPENDED)
+    if (get_transport() == TRANSPORT_USB && USB_DRIVER.state == USB_SUSPENDED) return;
+#    endif
+#    if defined(LED_DISABLE_WHEN_USB_SUSPENDED)
+    if (get_transport() == TRANSPORT_USB && USB_DRIVER.state == USB_SUSPENDED) return;
+#    endif
+
+    os_state_indicate();
+}
+
+#    if defined(LED_MATRIX_DRIVER_SHUTDOWN_ENABLE) || defined(RGB_MATRIX_DRIVER_SHUTDOWN_ENABLE)
+bool LED_DRIVER_ALLOW_SHUTDOWN(void) {
+#        if defined(NUM_LOCK_INDEX)
+    if (host_keyboard_led_state().num_lock) return false;
+#        endif
+#        if defined(CAPS_LOCK_INDEX) && !defined(DIM_CAPS_LOCK)
+    if (host_keyboard_led_state().caps_lock) return false;
+#        endif
+#        if defined(SCROLL_LOCK_INDEX)
+    if (host_keyboard_led_state().scroll_lock) return false;
+#        endif
+#        if defined(COMPOSE_LOCK_INDEX)
+    if (host_keyboard_led_state().compose) return false;
+#        endif
+#        if defined(KANA_LOCK_INDEX)
+    if (host_keyboard_led_state().kana) return false;
+#        endif
+    return true;
+}
+#    endif
+
+#endif

keyboards/keychron/common/wireless/indicator.h

@@ -0,0 +1,117 @@
+/* Copyright 2023 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "config.h"
+#include "wireless.h"
+
+/* Indication of pairing */
+#ifndef INDICATOR_CONFIG_PARING
+#    define INDICATOR_CONFIG_PARING {INDICATOR_BLINK, 1000, 1000, 0, true, 0};
+#endif
+
+/* Indication on Connected */
+#ifndef INDICATOR_CONFIG_CONNECTD
+#    define INDICATOR_CONFIG_CONNECTD {INDICATOR_ON_OFF, 2000, 250, 2000, true, 0};
+#endif
+
+/* Reconnecting indication */
+#ifndef INDICATOR_CONFIG_RECONNECTING
+#    define INDICATOR_CONFIG_RECONNECTING {INDICATOR_BLINK, 100, 100, 600, true, 0};
+#endif
+
+/* Disconnected indication */
+#ifndef INDICATOR_CONFIG_DISCONNECTED
+#    define INDICATOR_CONFIG_DISCONNECTED {INDICATOR_NONE, 100, 100, 600, false, 0};
+#endif
+
+/* Uint: Second */
+#ifndef DISCONNECTED_BACKLIGHT_DISABLE_TIMEOUT
+#    define DISCONNECTED_BACKLIGHT_OFF_DELAY_TIME 40
+#endif
+
+/* Uint: Second, the timer restarts on key activities. */
+#ifndef CONNECTED_BACKLIGHT_DISABLE_TIMEOUT
+#    define CONNECTED_BACKLIGHT_OFF_DELAY_TIME 600
+#endif
+
+#ifdef BAT_LOW_LED_PIN
+/* Uint: ms */
+#    ifndef LOW_BAT_LED_BLINK_PERIOD
+#        define LOW_BAT_LED_BLINK_PERIOD 1000
+#    endif
+
+#    ifndef LOW_BAT_LED_BLINK_DURATION
+#        define LOW_BAT_LED_BLINK_DURATION 10000
+#    endif
+#endif
+
+#ifdef LOW_BAT_IND_INDEX
+/* Uint: ms */
+#    ifndef LOW_BAT_LED_BLINK_PERIOD
+#        define LOW_BAT_LED_BLINK_PERIOD 500
+#    endif
+
+#    ifndef LOW_BAT_LED_BLINK_TIMES
+#        define LOW_BAT_LED_BLINK_TIMES 3
+#    endif
+
+#    ifndef LOW_BAT_LED_TRIG_INTERVAL
+#        define LOW_BAT_LED_TRIG_INTERVAL 30000
+#    endif
+#endif
+
+#if BT_HOST_MAX_COUNT > 6
+#    pragma error("HOST_COUNT max value is 6")
+#endif
+
+typedef enum { INDICATOR_NONE, INDICATOR_OFF, INDICATOR_ON, INDICATOR_ON_OFF, INDICATOR_BLINK, INDICATOR_LAST } indicator_type_t;
+
+typedef struct {
+    indicator_type_t type;
+    uint32_t         on_time;
+    uint32_t         off_time;
+    uint32_t         duration;
+    bool             highlight;
+    uint8_t          value;
+    uint32_t         elapsed;
+} indicator_config_t;
+
+typedef struct {
+    uint8_t value;
+    bool    saved;
+} backlight_state_t;
+
+void indicator_init(void);
+void indicator_set(wt_state_t state, uint8_t host_index);
+void indicator_backlight_timer_reset(bool enable);
+bool indicator_hook_key(uint16_t keycode);
+void indicator_enable(void);
+void indicator_disable(void);
+void indicator_stop(void);
+void indicator_eeconfig_reload(void);
+bool indicator_is_enabled(void);
+bool indicator_is_running(void);
+
+#ifdef BAT_LOW_LED_PIN
+void indicator_battery_low_enable(bool enable);
+#endif
+#if defined(LOW_BAT_IND_INDEX)
+void indicator_battery_low_backlit_enable(bool enable);
+#endif
+
+void indicator_task(void);

keyboards/keychron/common/wireless/keychron_wireless_common.c

@@ -0,0 +1,155 @@
+/* Copyright 2022 @ Keychron (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include QMK_KEYBOARD_H
+#ifdef LK_WIRELESS_ENABLE
+#    include "lkbt51.h"
+#    include "wireless.h"
+#    include "indicator.h"
+#    include "transport.h"
+#    include "battery.h"
+#    include "bat_level_animation.h"
+#    include "lpm.h"
+#    include "keychron_wireless_common.h"
+#    include "keychron_task.h"
+#endif
+#include "keychron_common.h"
+
+bool firstDisconnect = true;
+
+static uint32_t pairing_key_timer;
+static uint8_t  host_idx = 0;
+
+bool process_record_keychron_wireless(uint16_t keycode, keyrecord_t *record) {
+    static uint8_t host_idx;
+
+    switch (keycode) {
+        case BT_HST1 ... BT_HST3:
+            if (get_transport() == TRANSPORT_BLUETOOTH) {
+                if (record->event.pressed) {
+                    host_idx = keycode - BT_HST1 + 1;
+
+                    pairing_key_timer = timer_read32();
+                    wireless_connect_ex(host_idx, 0);
+                } else {
+                    host_idx          = 0;
+                    pairing_key_timer = 0;
+                }
+            }
+            break;
+        case P2P4G:
+            if (get_transport() == TRANSPORT_P2P4) {
+                if (record->event.pressed) {
+                    host_idx = P24G_INDEX;
+
+                    pairing_key_timer = timer_read32();
+                } else {
+                    host_idx          = 0;
+                    pairing_key_timer = 0;
+                }
+            }
+            break;
+#if (defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)) && defined(BAT_LEVEL_LED_LIST)
+        case BAT_LVL:
+            if ((get_transport() & TRANSPORT_WIRELESS) && !usb_power_connected()) {
+                bat_level_animiation_start(battery_get_percentage());
+            }
+            break;
+#endif
+
+        default:
+            break;
+    }
+
+    return true;
+}
+
+void lkbt51_param_init(void) {
+    /* Set bluetooth device name */
+    lkbt51_set_local_name(PRODUCT);
+    wait_ms(3);
+    // clang-format off
+    /* Set bluetooth parameters */
+    module_param_t param = {.event_mode             = 0x02,
+                            .connected_idle_timeout = 7200,
+                            .pairing_timeout        = 180,
+                            .pairing_mode           = 0,
+                            .reconnect_timeout      = 5,
+                            .report_rate            = 90,
+                            .vendor_id_source       = 1,
+                            .verndor_id             = 0x3434, // Must be 0x3434
+                            .product_id             = PRODUCT_ID};
+    // clang-format on
+    lkbt51_set_param(&param);
+}
+
+void wireless_enter_reset_kb(uint8_t reason) {
+    lkbt51_param_init();
+}
+
+void wireless_enter_disconnected_kb(uint8_t host_idx) {
+    /* CKBT51 bluetooth module boot time is slower, it enters disconnected after boot,
+       so we place initialization here. */
+    if (firstDisconnect && timer_read32() < 1000) {
+        lkbt51_param_init();
+        if (get_transport() == TRANSPORT_BLUETOOTH) wireless_connect();
+        firstDisconnect = false;
+    }
+}
+
+void keychron_wireless_common_task(void) {
+    if (pairing_key_timer) {
+        if (timer_elapsed32(pairing_key_timer) > 2000) {
+            pairing_key_timer = 0;
+            wireless_pairing_ex(host_idx, NULL);
+        }
+    }
+}
+
+void wireless_pre_task(void) {
+    static uint8_t  mode = 0;
+    static uint32_t time = 0;
+
+    if (time == 0) {
+        if ((readPin(BT_MODE_SELECT_PIN) << 1 | readPin(P2P4_MODE_SELECT_PIN)) != mode) {
+            mode = readPin(BT_MODE_SELECT_PIN) << 1 | readPin(P2P4_MODE_SELECT_PIN);
+            time = timer_read32();
+        }
+    }
+
+    if ((time && timer_elapsed32(time) > 100) || get_transport() == TRANSPORT_NONE) {
+        if ((readPin(BT_MODE_SELECT_PIN) << 1 | readPin(P2P4_MODE_SELECT_PIN)) == mode) {
+            time = 0;
+
+            switch (mode) {
+                case 0x01:
+                    set_transport(TRANSPORT_BLUETOOTH);
+                    break;
+                case 0x02:
+                    set_transport(TRANSPORT_P2P4);
+                    break;
+                case 0x03:
+                    set_transport(TRANSPORT_USB);
+                    break;
+                default:
+                    break;
+            }
+        } else {
+            mode = readPin(BT_MODE_SELECT_PIN) << 1 | readPin(P2P4_MODE_SELECT_PIN);
+            time = timer_read32();
+        }
+    }
+}

keyboards/keychron/common/wireless/keychron_wireless_common.h

@@ -14,12 +14,13 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#pragma once
+#include "stdint.h"
+#ifdef VIA_ENABLE
+#    include "via.h"
+#endif
+#include "quantum_keycodes.h"
 
-/* RGB Matrix Configuration */
-#define DRIVER_1_LED_TOTAL 45
-#define DRIVER_2_LED_TOTAL 37
-#define RGB_MATRIX_LED_COUNT (DRIVER_1_LED_TOTAL + DRIVER_2_LED_TOTAL)
+void lkbt51_param_init(void);
 
-/* Enable caps-lock LED */
-#define CAPS_LOCK_LED_INDEX 45
+bool process_record_keychron_wireless(uint16_t keycode, keyrecord_t *record);
+void keychron_wireless_common_task(void);

keyboards/keychron/common/wireless/lkbt51.c

@@ -0,0 +1,867 @@
+/* Copyright 2023 @ Keychron (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "quantum.h"
+#include "lkbt51.h"
+#include "wireless.h"
+#include "wireless_event_type.h"
+#include "battery.h"
+#include "raw_hid.h"
+#include "report_buffer.h"
+#include "factory_test.h"
+
+extern void factory_test_send(uint8_t* payload, uint8_t length);
+
+#    ifndef RAW_EPSIZE
+#        define RAW_EPSIZE 32
+#    endif
+
+#ifndef SPI_SCK_PIN
+#    define SPI_SCK_PIN A5
+#endif
+#ifndef SPI_MISO_PIN
+#    define SPI_MISO_PIN A6
+#endif
+#ifndef SPI_MOSI_PIN
+#    define SPI_MOSI_PIN A7
+#endif
+
+#ifndef SPI_CLK_PAL_MODE
+#    define SPI_CLK_PAL_MODE 5
+#endif
+#ifndef SPI_MISO_PAL_MODE
+#    define SPI_MISO_PAL_MODE 5
+#endif
+#ifndef SPI_MOSI_PAL_MODE
+#    define SPI_MOSI_PAL_MODE 5
+#endif
+
+#ifndef LKBT51_INT_INPUT_PIN
+#    error "LKBT51_INT_INPUT_PIN is not defined"
+#endif
+
+#ifndef LKBT51_TX_RETRY_COUNT
+#    define LKBT51_TX_RETRY_COUNT 3
+#endif
+
+// clang-format off
+enum {
+    /* HID Report  */
+    LKBT51_CMD_SEND_KB       = 0x11,
+    LKBT51_CMD_SEND_KB_NKRO  = 0x12,
+    LKBT51_CMD_SEND_CONSUMER = 0x13,
+    LKBT51_CMD_SEND_SYSTEM   = 0x14,
+    LKBT51_CMD_SEND_FN       = 0x15, // Not used currently
+    LKBT51_CMD_SEND_MOUSE    = 0x16,
+    LKBT51_CMD_SEND_BOOT_KB  = 0x17,
+    /* Bluetooth connections */
+    LKBT51_CMD_PAIRING        = 0x21,
+    LKBT51_CMD_CONNECT        = 0x22,
+    LKBT51_CMD_DISCONNECT     = 0x23,
+    LKBT51_CMD_SWITCH_HOST    = 0x24,
+    LKBT51_CMD_READ_STATE_REG = 0x25,
+    /* Battery */
+    LKBT51_CMD_BATTERY_MANAGE = 0x31,
+    LKBT51_CMD_UPDATE_BAT_LVL = 0x32,
+    LKBT51_CMD_UPDATE_BAT_STATE = 0x33,
+    /* Set/get parameters */
+    LKBT51_CMD_GET_MODULE_INFO = 0x40,
+    LKBT51_CMD_SET_CONFIG      = 0x41,
+    LKBT51_CMD_GET_CONFIG      = 0x42,
+    LKBT51_CMD_SET_BDA         = 0x43,
+    LKBT51_CMD_GET_BDA         = 0x44,
+    LKBT51_CMD_SET_NAME        = 0x45,
+    LKBT51_CMD_GET_NAME        = 0x46,
+    LKBT51_CMD_WRTE_CSTM_DATA  = 0x49,
+    /* DFU */
+    LKBT51_CMD_GET_DFU_VER      = 0x60,
+    LKBT51_CMD_HAND_SHAKE_TOKEN = 0x61,
+    LKBT51_CMD_START_DFU        = 0x62,
+    LKBT51_CMD_SEND_FW_DATA     = 0x63,
+    LKBT51_CMD_VERIFY_CRC32     = 0x64,
+    LKBT51_CMD_SWITCH_FW        = 0x65,
+    /* Factory test */
+    LKBT51_CMD_FACTORY_RESET = 0x71,
+    LKBT51_CMD_IO_TEST       = 0x72,
+    LKBT51_CMD_RADIO_TEST    = 0x73,
+    /* Event */
+    LKBT51_EVT_LKBT51_CMD_RECEIVED = 0xA1,
+    LKBT51_EVT_OTA_RSP             = 0xA3,
+    LKBT51_CONNECTION_EVT_ACK      = 0xA4,
+};
+
+enum {
+    LKBT51_EVT_ACK           = 0xA1,
+    LKBT51_EVT_QUERY_RSP     = 0xA2,
+    LKBT51_EVT_RESET         = 0xB0,
+    LKBT51_EVT_LE_CONNECTION = 0xB1,
+    LKBT51_EVT_HOST_TYPE     = 0xB2,
+    LKBT51_EVT_CONNECTION    = 0xB3,
+    LKBT51_EVT_HID_EVENT     = 0xB4,
+    LKBT51_EVT_BATTERY       = 0xB5,
+};
+
+enum {
+    LKBT51_CONNECTED = 0x20,
+    LKBT51_DISCOVERABLE = 0x21,
+    LKBT51_RECONNECTING = 0x22,
+    LKBT51_DISCONNECTED = 0x23,
+    LKBT51_PINCODE_ENTRY = 0x24,
+    LKBT51_EXIT_PINCODE_ENTRY = 0x25,
+    LKBT51_SLEEP = 0x26
+};
+
+enum {
+    ACK_SUCCESS = 0x00,
+    ACK_CHECKSUM_ERROR,
+    ACK_FIFO_HALF_WARNING,
+    ACK_FIFO_FULL_ERROR,
+};
+
+enum{
+    LK_EVT_MSK_CONNECTION = 0x01 << 0,
+    LK_EVT_MSK_LED = 0x01 << 1,
+    LK_EVT_MSK_BATT = 0x01 << 2,
+    LK_EVT_MSK_RESET = 0x01 << 3,
+    LK_EVT_MSK_RPT_INTERVAL = 0x01 << 4,
+    LK_EVT_MSK_MD = 0x01 << 7,
+};
+
+// clang-format on
+
+static uint8_t  payload[PACKET_MAX_LEN];
+static uint8_t  reg_offset          = 0xFF;
+static uint8_t  expect_len          = 22;
+static uint16_t connection_interval = 1;
+static uint32_t wake_time;
+
+// clang-format off
+wt_func_t wireless_transport = {
+    lkbt51_init,
+    lkbt51_connect,
+    lkbt51_become_discoverable,
+    lkbt51_disconnect,
+    lkbt51_send_keyboard,
+    lkbt51_send_nkro,
+    lkbt51_send_consumer,
+    lkbt51_send_system,
+    lkbt51_send_mouse,
+    lkbt51_update_bat_lvl,
+    lkbt51_task
+};
+// clang-format on
+
+/* Init SPI */
+const SPIConfig spicfg = {
+    .circular = false,
+    .slave    = false,
+    .data_cb  = NULL,
+    .error_cb = NULL,
+    .ssport   = PAL_PORT(BLUETOOTH_INT_OUTPUT_PIN),
+    .sspad    = PAL_PAD(BLUETOOTH_INT_OUTPUT_PIN),
+    .cr1      = SPI_CR1_MSTR | SPI_CR1_BR_1 | SPI_CR1_BR_0,
+    .cr2      = 0U,
+};
+
+void lkbt51_init(bool wakeup_from_low_power_mode) {
+#ifdef LKBT51_RESET_PIN
+    if (!wakeup_from_low_power_mode) {
+        setPinOutput(LKBT51_RESET_PIN);
+        writePinLow(LKBT51_RESET_PIN);
+        wait_ms(1);
+        writePinHigh(LKBT51_RESET_PIN);
+    }
+#endif
+
+#if (HAL_USE_SPI == TRUE)
+    if (WT_DRIVER.state == SPI_UNINIT) {
+        setPinOutput(SPI_SCK_PIN);
+        writePinHigh(SPI_SCK_PIN);
+
+        palSetLineMode(SPI_SCK_PIN, PAL_MODE_ALTERNATE(SPI_CLK_PAL_MODE));
+        palSetLineMode(SPI_MISO_PIN, PAL_MODE_ALTERNATE(SPI_MISO_PAL_MODE));
+        palSetLineMode(SPI_MOSI_PIN, PAL_MODE_ALTERNATE(SPI_MOSI_PAL_MODE));
+
+        if (wakeup_from_low_power_mode) {
+            spiInit();
+            return;
+        }
+
+        spiInit();
+    }
+#endif
+
+    setPinOutput(BLUETOOTH_INT_OUTPUT_PIN);
+    writePinHigh(BLUETOOTH_INT_OUTPUT_PIN);
+
+    setPinInputHigh(LKBT51_INT_INPUT_PIN);
+}
+
+static inline void lkbt51_wake(void) {
+    if (timer_elapsed32(wake_time) > 3000) {
+        wake_time = timer_read32();
+
+        palWriteLine(BLUETOOTH_INT_OUTPUT_PIN, 0);
+        wait_ms(10);
+        palWriteLine(BLUETOOTH_INT_OUTPUT_PIN, 1);
+        wait_ms(300);
+    }
+}
+
+void lkbt51_send_protocol_ver(uint16_t ver) {
+    uint8_t pkt[PACKET_MAX_LEN] = {0};
+    memset(pkt, 0, PACKET_MAX_LEN);
+
+    uint8_t i = 0;
+
+    pkt[i++] = 0x84;
+    pkt[i++] = 0x7e;
+    pkt[i++] = 0x00;
+    pkt[i++] = 0x00;
+    pkt[i++] = 0xAA;
+    pkt[i++] = 0x54;
+    pkt[i++] = ver & 0xFF;
+    pkt[i++] = (ver >> 8) & 0xFF;
+    pkt[i++] = (uint8_t)(~0x54);
+    pkt[i++] = (uint8_t)(~0xAA);
+
+#if HAL_USE_SPI
+    expect_len = 10;
+    spiStart(&WT_DRIVER, &spicfg);
+    spiSelect(&WT_DRIVER);
+    spiSend(&WT_DRIVER, i, pkt);
+    spiUnselectI(&WT_DRIVER);
+    spiStop(&WT_DRIVER);
+#endif
+}
+
+void lkbt51_send_cmd(uint8_t* payload, uint8_t len, bool ack_enable, bool retry) {
+    static uint8_t sn = 0;
+    uint8_t        i;
+    uint8_t        pkt[PACKET_MAX_LEN] = {0};
+    memset(pkt, 0, PACKET_MAX_LEN);
+
+    if (!retry) ++sn;
+    if (sn == 0) ++sn;
+
+    uint16_t checksum = 0;
+    for (i = 0; i < len; i++)
+        checksum += payload[i];
+
+    i        = 0;
+    pkt[i++] = 0x84;
+    pkt[i++] = 0x7e;
+    pkt[i++] = 0x00;
+    pkt[i++] = 0x00;
+    pkt[i++] = 0xAA;
+    pkt[i++] = ack_enable ? 0x56 : 0x55;
+    pkt[i++] = len + 2;
+    pkt[i++] = ~(len + 2) & 0xFF;
+    pkt[i++] = sn;
+
+    memcpy(pkt + i, payload, len);
+    i += len;
+    pkt[i++] = checksum & 0xFF;
+    pkt[i++] = (checksum >> 8) & 0xFF;
+#if HAL_USE_SPI
+    if ((payload[0] & 0xF0) == 0x60)
+        expect_len = 64;
+    else
+        expect_len = 64;
+
+    spiStart(&WT_DRIVER, &spicfg);
+    spiSelect(&WT_DRIVER);
+    spiSend(&WT_DRIVER, i, pkt);
+    spiUnselectI(&WT_DRIVER);
+    spiStop(&WT_DRIVER);
+#endif
+}
+
+void lkbt51_read(uint8_t* payload, uint8_t len) {
+    uint8_t i;
+    uint8_t pkt[PACKET_MAX_LEN] = {0};
+    memset(pkt, 0, PACKET_MAX_LEN);
+
+    i        = 0;
+    pkt[i++] = 0x84;
+    pkt[i++] = 0x7f;
+    pkt[i++] = 0x00;
+    pkt[i++] = 0x80;
+
+    i += len;
+
+#if HAL_USE_SPI
+    spiStart(&WT_DRIVER, &spicfg);
+    spiSelect(&WT_DRIVER);
+    spiExchange(&WT_DRIVER, i, pkt, payload);
+    spiUnselect(&WT_DRIVER);
+    spiStop(&WT_DRIVER);
+#endif
+}
+
+void lkbt51_send_keyboard(uint8_t* report) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = LKBT51_CMD_SEND_KB;
+    memcpy(payload + i, report, 8);
+    i += 8;
+
+    lkbt51_send_cmd(payload, i, true, false);
+}
+
+void lkbt51_send_nkro(uint8_t* report) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = LKBT51_CMD_SEND_KB_NKRO;
+    memcpy(payload + i, report, 20); // NKRO report lenght is limited to 20 bytes
+    i += 20;
+
+    lkbt51_send_cmd(payload, i, true, false);
+}
+
+void lkbt51_send_consumer(uint16_t report) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = LKBT51_CMD_SEND_CONSUMER;
+    payload[i++] = report & 0xFF;
+    payload[i++] = ((report) >> 8) & 0xFF;
+    i += 4; // QMK doesn't send multiple consumer reports, just skip 2nd and 3rd consumer reports
+
+    lkbt51_send_cmd(payload, i, true, false);
+}
+
+void lkbt51_send_system(uint16_t report) {
+    uint8_t hid_usage = report & 0xFF;
+
+    if (hid_usage < 0x81 || hid_usage > 0x83) return;
+
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = LKBT51_CMD_SEND_SYSTEM;
+    payload[i++] = 0x01 << (hid_usage - 0x81);
+
+    lkbt51_send_cmd(payload, i, true, false);
+}
+
+void lkbt51_send_mouse(uint8_t* report) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = LKBT51_CMD_SEND_MOUSE;            // Cmd type
+    payload[i++] = report[1];                        // Button
+    payload[i++] = report[2];                        // X
+    payload[i++] = (report[2] & 0x80) ? 0xff : 0x00; // ckbt51 use 16bit report, set high byte
+    payload[i++] = report[3];                        // Y
+    payload[i++] = (report[3] & 0x80) ? 0xff : 0x00; // ckbt51 use 16bit report, set high byte
+    payload[i++] = report[4];                        // V wheel
+    payload[i++] = report[5];                        // H wheel
+
+    lkbt51_send_cmd(payload, i, false, false);
+}
+
+/* Send ack to connection event, wireless module will retry 2 times if no ack received */
+void lkbt51_send_conn_evt_ack(void) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = LKBT51_CONNECTION_EVT_ACK;
+
+    lkbt51_send_cmd(payload, i, false, false);
+}
+
+void lkbt51_become_discoverable(uint8_t host_idx, void* param) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    pairing_param_t default_pairing_param = {0, 0, PAIRING_MODE_LESC_OR_SSP, BT_MODE_CLASSIC, 0, NULL};
+
+    if (param == NULL) {
+        param = &default_pairing_param;
+    }
+    pairing_param_t* p = (pairing_param_t*)param;
+
+    payload[i++] = LKBT51_CMD_PAIRING; // Cmd type
+    payload[i++] = host_idx;           // Host Index
+    payload[i++] = p->timeout & 0xFF;  // Timeout
+    payload[i++] = (p->timeout >> 8) & 0xFF;
+    payload[i++] = p->pairingMode;
+    payload[i++] = p->BRorLE;  // BR/LE
+    payload[i++] = p->txPower; // LE TX POWER
+    if (p->leName) {
+        memcpy(&payload[i], p->leName, strlen(p->leName));
+        i += strlen(p->leName);
+    }
+
+    lkbt51_wake();
+    lkbt51_send_cmd(payload, i, true, false);
+}
+
+/* Timeout : 2 ~ 255 seconds */
+void lkbt51_connect(uint8_t hostIndex, uint16_t timeout) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = LKBT51_CMD_CONNECT;
+    payload[i++] = hostIndex;      // Host index
+    payload[i++] = timeout & 0xFF; // Timeout
+    payload[i++] = (timeout >> 8) & 0xFF;
+
+    lkbt51_wake();
+    lkbt51_send_cmd(payload, i, true, false);
+}
+
+void lkbt51_disconnect(void) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = LKBT51_CMD_DISCONNECT;
+    payload[i++] = 0; // Sleep mode
+
+    spiSelect(&SPID1);
+    wait_ms(30);
+    // spiUnselect(&SPID1);
+    wait_ms(70);
+
+    lkbt51_send_cmd(payload, i, true, false);
+}
+
+void lkbt51_switch_host(uint8_t hostIndex) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = LKBT51_CMD_SWITCH_HOST;
+    payload[i++] = hostIndex;
+
+    lkbt51_send_cmd(payload, i, true, false);
+}
+
+void lkbt51_read_state_reg(uint8_t reg, uint8_t len) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = LKBT51_CMD_READ_STATE_REG;
+    payload[i++] = reg_offset = reg;
+    payload[i++]              = len;
+
+    // TODO
+    lkbt51_send_cmd(payload, i, false, false);
+}
+
+void lkbt51_update_bat_lvl(uint8_t bat_lvl) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = LKBT51_CMD_UPDATE_BAT_LVL;
+    payload[i++] = bat_lvl;
+    lkbt51_send_cmd(payload, i, false, false);
+}
+
+void lkbt51_update_bat_state(uint8_t bat_state) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = LKBT51_CMD_UPDATE_BAT_STATE;
+    payload[i++] = bat_state;
+    lkbt51_send_cmd(payload, i, false, false);
+}
+
+void lkbt51_get_info(module_info_t* info) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = LKBT51_CMD_GET_MODULE_INFO;
+    lkbt51_send_cmd(payload, i, false, false);
+}
+
+void lkbt51_set_param(module_param_t* param) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = LKBT51_CMD_SET_CONFIG;
+    memcpy(payload + i, param, sizeof(module_param_t));
+    i += sizeof(module_param_t);
+
+    lkbt51_send_cmd(payload, i, false, false);
+}
+
+void lkbt51_get_param(module_param_t* param) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = LKBT51_CMD_GET_CONFIG;
+
+    lkbt51_send_cmd(payload, i, false, false);
+}
+
+void lkbt51_set_local_name(const char* name) {
+    uint8_t i   = 0;
+    uint8_t len = strlen(name);
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = LKBT51_CMD_SET_NAME;
+    memcpy(payload + i, name, len);
+    i += len;
+    lkbt51_send_cmd(payload, i, false, false);
+}
+
+void lkbt51_get_local_name(void) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = LKBT51_CMD_GET_NAME;
+
+    lkbt51_send_cmd(payload, i, false, false);
+}
+
+void lkbt51_factory_reset(uint8_t p2p4g_clr_msk) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = LKBT51_CMD_FACTORY_RESET;
+    payload[i++] = p2p4g_clr_msk;
+
+    lkbt51_wake();
+    lkbt51_send_cmd(payload, i, false, false);
+}
+
+void lkbt51_int_pin_test(bool enable) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+    payload[i++] = LKBT51_CMD_IO_TEST;
+    payload[i++] = enable;
+
+    lkbt51_send_cmd(payload, i, false, false);
+}
+
+void lkbt51_radio_test(uint8_t channel) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+    payload[i++] = LKBT51_CMD_RADIO_TEST;
+    payload[i++] = channel;
+    payload[i++] = 0;
+
+    lkbt51_send_cmd(payload, i, false, false);
+}
+
+bool lkbt51_read_customize_data(uint8_t* data, uint8_t len) {
+    uint8_t i;
+    uint8_t buf[20] = {0};
+
+    i        = 0;
+    buf[i++] = 0x84;
+    buf[i++] = 0x7a;
+    buf[i++] = 0x00;
+    buf[i++] = 0x80;
+
+#if HAL_USE_SPI
+    spiStart(&WT_DRIVER, &spicfg);
+    spiSelect(&WT_DRIVER);
+    spiExchange(&WT_DRIVER, 20, buf, payload);
+    uint16_t state = buf[5] | (buf[6] << 8);
+    if (state == 0x9527) spiExchange(&WT_DRIVER, len, data, payload);
+    spiUnselect(&WT_DRIVER);
+    spiStop(&WT_DRIVER);
+#endif
+
+    return true;
+}
+
+void lkbt51_write_customize_data(uint8_t* data, uint8_t len) {
+    uint8_t i;
+    uint8_t pkt[PACKET_MAX_LEN] = {0};
+
+    i        = 0;
+    pkt[i++] = 0x84;
+    pkt[i++] = 0x7a;
+    pkt[i++] = 0x00;
+    pkt[i++] = 0x00;
+
+#if HAL_USE_SPI
+    spiStart(&WT_DRIVER, &spicfg);
+    spiSelect(&WT_DRIVER);
+    spiSend(&WT_DRIVER, i, pkt);
+    spiSend(&WT_DRIVER, len, data);
+    spiUnselectI(&WT_DRIVER);
+    spiStop(&WT_DRIVER);
+#endif
+
+    i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+    payload[i++] = LKBT51_CMD_WRTE_CSTM_DATA;
+
+    lkbt51_send_cmd(payload, i, false, false);
+}
+#ifdef RAW_ENABLE
+void lkbt51_dfu_tx(uint8_t rsp, uint8_t* data, uint8_t len, uint8_t sn) {
+    uint16_t checksum = 0;
+    uint8_t buf[RAW_EPSIZE] = {0};
+    uint8_t i               = 0;
+
+    buf[i++] = 0x03;
+    buf[i++] = 0xAA;
+    buf[i++] = 0x57;
+    buf[i++] = len;
+    buf[i++] = ~len;
+    buf[i++] = sn;
+    buf[i++] = rsp;
+    memcpy(&buf[i], data, len);
+    i += len;
+
+    for (uint8_t k = 0; k < i; k++)
+        checksum += buf[i];
+
+    raw_hid_send(buf, RAW_EPSIZE);
+
+    if (len > 25) {
+        i = 0;
+        memset(buf, 0, RAW_EPSIZE);
+        buf[i++] = 0x03;
+        memcpy(&buf[i], data + 25, len - 25);
+        i = i + len - 25;
+        raw_hid_send(buf, RAW_EPSIZE);
+    }
+}
+#endif
+void lkbt51_dfu_rx(uint8_t* data, uint8_t length) {
+    if (data[0] == 0xAA && (data[1] == 0x55 || data[1] == 0x56) && data[2] == (~data[3] & 0xFF)) {
+        uint16_t checksum    = 0;
+        uint8_t  payload_len = data[2];
+
+        /* Check payload_len validity */
+        if (payload_len > RAW_EPSIZE - PACKECT_HEADER_LEN) return;
+
+        uint8_t* payload = &data[PACKECT_HEADER_LEN];
+
+        for (uint8_t i = 0; i < payload_len - 2; i++) {
+            checksum += payload[i];
+        }
+
+        /* Verify checksum */
+        if ((checksum & 0xFF) != payload[payload_len - 2] || checksum >> 8 != payload[payload_len - 1]) return;
+        static uint8_t sn = 0;
+
+        bool retry = true;
+        if (sn != data[4]) {
+            sn    = data[4];
+            retry = false;
+        }
+
+        if ((payload[0] & 0xF0) == 0x60) {
+            lkbt51_wake();
+            lkbt51_send_cmd(payload, payload_len - 2, data[1] == 0x56, retry);
+        }
+    }
+}
+
+static void ack_handler(uint8_t* data, uint8_t len) {
+    switch (data[1]) {
+        case LKBT51_CMD_SEND_KB:
+        case LKBT51_CMD_SEND_KB_NKRO:
+        case LKBT51_CMD_SEND_CONSUMER:
+        case LKBT51_CMD_SEND_SYSTEM:
+        case LKBT51_CMD_SEND_MOUSE:
+            switch (data[2]) {
+                case ACK_SUCCESS:
+                    report_buffer_set_retry(0);
+                    report_buffer_set_inverval(connection_interval);
+                    break;
+                case ACK_FIFO_HALF_WARNING:
+                    report_buffer_set_retry(0);
+                    report_buffer_set_inverval(connection_interval + 5);
+                    break;
+                case ACK_FIFO_FULL_ERROR:
+                    report_buffer_set_inverval(connection_interval + 10);
+                    break;
+            }
+            break;
+        default:
+            break;
+    }
+}
+
+static void query_rsp_handler(uint8_t* data, uint8_t len) {
+    if (data[2]) return;
+
+    switch (data[1]) {
+        case LKBT51_CMD_IO_TEST:
+            factory_test_send(data, len);
+            break;
+        default:
+            break;
+    }
+}
+
+static void lkbt51_event_handler(uint8_t evt_type, uint8_t* data, uint8_t len, uint8_t sn) {
+    wireless_event_t event = {0};
+
+    switch (evt_type) {
+        case LKBT51_EVT_ACK:
+            ack_handler(data, len);
+            break;
+        case LKBT51_EVT_RESET:
+            kc_printf("LKBT51_EVT_RESET\n");
+            event.evt_type      = EVT_RESET;
+            event.params.reason = data[0];
+            break;
+        case LKBT51_EVT_LE_CONNECTION:
+            kc_printf("LKBT51_EVT_LE_CONNECTION\n");
+            break;
+        case LKBT51_EVT_HOST_TYPE:
+            kc_printf("LKBT51_EVT_HOST_TYPE\n");
+            break;
+        case LKBT51_EVT_HID_EVENT:
+            kc_printf("LKBT51_EVT_HID_EVENT\n");
+            event.evt_type   = EVT_HID_INDICATOR;
+            event.params.led = data[0];
+            break;
+        case LKBT51_EVT_QUERY_RSP:
+            kc_printf("LKBT51_EVT_QUERY_RSP\n\r");
+            query_rsp_handler(data, len);
+            break;
+        case LKBT51_EVT_OTA_RSP:
+#ifdef RAW_ENABLE
+            kc_printf("LKBT51_EVT_OTA_RSP\n");
+            lkbt51_dfu_tx(LKBT51_EVT_OTA_RSP, data, len, sn);
+#endif
+            break;
+        default:
+            kc_printf("Unknown event!!!\n");
+            break;
+    }
+
+    if (event.evt_type) wireless_event_enqueue(event);
+}
+
+void lkbt51_task(void) {
+#define VALID_DATA_START_INDEX 4
+#define BUFFER_SIZE 64
+
+    static bool    wait_for_new_pkt = true;
+    static uint8_t len              = 0xff;
+    static uint8_t sn               = 0;
+
+    if (readPin(LKBT51_INT_INPUT_PIN) == 0) {
+        uint8_t buf[BUFFER_SIZE] = {0};
+        lkbt51_read(buf, expect_len);
+
+        uint8_t* pbuf = buf + VALID_DATA_START_INDEX;
+
+        if (pbuf[0] == 0xAA && pbuf[1] == 0x54 && pbuf[4] == (uint8_t)(~0x54) && pbuf[5] == (uint8_t)(~0xAA)) {
+            uint16_t protol_ver = pbuf[3] << 8 | pbuf[2];
+            kc_printf("protol_ver: %x\n\r", protol_ver);
+            (void)protol_ver;
+        } else if (pbuf[0] == 0xAA) {
+            wireless_event_t event    = {0};
+            uint8_t          evt_mask = pbuf[1];
+
+            if (evt_mask & LK_EVT_MSK_RESET) {
+                event.evt_type      = EVT_RESET;
+                event.params.reason = pbuf[2];
+                wireless_event_enqueue(event);
+            }
+
+            if (evt_mask & LK_EVT_MSK_CONNECTION) {
+                lkbt51_send_conn_evt_ack();
+                switch (pbuf[2]) {
+                    case LKBT51_CONNECTED:
+                        event.evt_type = EVT_CONNECTED;
+                        break;
+                    case LKBT51_DISCOVERABLE:
+                        event.evt_type = EVT_DISCOVERABLE;
+                        break;
+                    case LKBT51_RECONNECTING:
+                        event.evt_type = EVT_RECONNECTING;
+                        break;
+                    case LKBT51_DISCONNECTED:
+                        event.evt_type = EVT_DISCONNECTED;
+                        break;
+                    case LKBT51_PINCODE_ENTRY:
+                        event.evt_type = EVT_BT_PINCODE_ENTRY;
+                        break;
+                    case LKBT51_EXIT_PINCODE_ENTRY:
+                        event.evt_type = EVT_EXIT_BT_PINCODE_ENTRY;
+                        break;
+                    case LKBT51_SLEEP:
+                        event.evt_type = EVT_SLEEP;
+                        break;
+                }
+                event.params.hostIndex = pbuf[3];
+
+                wireless_event_enqueue(event);
+            }
+
+            if (evt_mask & LK_EVT_MSK_LED) {
+                memset(&event, 0, sizeof(event));
+                event.evt_type   = EVT_HID_INDICATOR;
+                event.params.led = pbuf[4];
+                wireless_event_enqueue(event);
+            }
+
+            if (evt_mask & LK_EVT_MSK_RPT_INTERVAL) {
+                uint32_t interval;
+                if (pbuf[8] & 0x80) {
+                    interval = (pbuf[8] & 0x7F) * 1250;
+                } else {
+                    interval = (pbuf[8] & 0x7F) * 125;
+                }
+
+                connection_interval = interval / 1000;
+                if (connection_interval > 7) connection_interval /= 3;
+
+                memset(&event, 0, sizeof(event));
+                event.evt_type        = EVT_CONECTION_INTERVAL;
+                event.params.interval = connection_interval;
+                wireless_event_enqueue(event);
+            }
+
+            if (evt_mask & LK_EVT_MSK_BATT) {
+                battery_calculate_voltage(true, pbuf[6] << 8 | pbuf[5]);
+            }
+        }
+
+        pbuf = buf;
+        if (wait_for_new_pkt) {
+            for (uint8_t i = 10; i < BUFFER_SIZE - 5; i++) {
+                if (buf[i] == 0xAA && buf[i + 1] == 0x57     // Packet Head
+                    && (~buf[i + 2] & 0xFF) == buf[i + 3]) { // Check wheather len is valid
+                    len              = buf[i + 2];
+                    sn               = buf[i + 4];
+                    pbuf             = &buf[i + 5];
+                    wait_for_new_pkt = false;
+                }
+            }
+        }
+
+        if (!wait_for_new_pkt && BUFFER_SIZE - 5 >= len) {
+            wait_for_new_pkt = true;
+
+            uint16_t checksum = 0;
+            for (int i = 0; i < len - 2; i++) {
+                checksum += pbuf[i];
+            }
+
+            if ((checksum & 0xff) == pbuf[len - 2] && ((checksum >> 8) & 0xff) == pbuf[len - 1]) {
+                lkbt51_event_handler(pbuf[0], pbuf + 1, len - 3, sn);
+            } else {
+                // TODO: Error handle
+            }
+        }
+    }
+}

keyboards/keychron/common/wireless/lkbt51.h

@@ -0,0 +1,131 @@
+/* Copyright 2023 @ Keychron (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "stdint.h"
+#include "hal.h"
+
+#ifndef WT_DRIVER
+#    define WT_DRIVER SPID1
+#endif
+
+// Error checking
+#if HAL_USE_SPI == FALSE
+#    error "Please enable SPI to use LKBT51"
+#endif
+
+#if !STM32_SPI_USE_SPI1 && !STM32_SPI_USE_SPI2 && !STM32_SPI_USE_SPI3
+#    error "WT driver activated but no SPI peripheral assigned"
+#endif
+
+#define PACKECT_HEADER_LEN 5
+#define BDA_LEN 6
+#define PACKET_MAX_LEN 64
+#define P24G_INDEX 24
+
+enum {
+    PAIRING_MODE_DEFAULT = 0x00,
+    PAIRING_MODE_JUST_WORK,
+    PAIRING_MODE_PASSKEY_ENTRY,
+    PAIRING_MODE_LESC_OR_SSP,
+    PAIRING_MODE_INVALID,
+};
+
+enum {
+    BT_MODE_DEFAUL,
+    BT_MODE_CLASSIC,
+    BT_MODE_LE,
+    BT_MODE_INVALID,
+};
+
+typedef struct {
+    uint8_t     hostIndex;
+    uint16_t    timeout;     /* Pairing timeout, valid value range from 30 to 3600 seconds, 0 for default */
+    uint8_t     pairingMode; /* 0: default, 1: Just Works, 2: Passkey Entry */
+    uint8_t     BRorLE;      /* Only available for dual mode module. Keep 0 for single mode module */
+    uint8_t     txPower;     /* Only available for BLE module */
+    const char* leName;      /* Only available for BLE module */
+} pairing_param_t;
+
+typedef struct {
+    uint8_t  type;
+    uint16_t full_votage;
+    uint16_t empty_voltage;
+    uint16_t shutdown_voltage;
+} battery_param_t;
+
+typedef struct {
+    uint8_t  model_name[11];
+    uint8_t  mode;
+    uint8_t  bluetooth_version;
+    uint8_t  firmware_version[11];
+    uint8_t  hardware_version[11];
+    uint16_t cmd_set_verson;
+} __attribute__((packed)) module_info_t;
+
+typedef struct {
+    uint8_t  event_mode; /* Must be 0x02 */
+    uint16_t connected_idle_timeout;
+    uint16_t pairing_timeout;   /* Range: 30 ~ 3600 second, 0 for default */
+    uint8_t  pairing_mode;      /* 0: default, 1: Just Works, 2: Passkey Entry */
+    uint16_t reconnect_timeout; /* 0: default, 0xFF: Unlimited time, 2 ~ 254 seconds */
+    uint8_t  report_rate;       /* 90 or 133 */
+    uint8_t  rsvd1;
+    uint8_t  rsvd2;
+    uint8_t  vendor_id_source; /* 0: From Bluetooth SIG, 1: From USB-IF */
+    uint16_t verndor_id;       /* No effect, the vendor ID is 0x3434 */
+    uint16_t product_id;
+    /* Below parametes is only available for BLE module  */
+    uint16_t le_connection_interval_min;
+    uint16_t le_connection_interval_max;
+    uint16_t le_connection_interval_timeout;
+} __attribute__((packed)) module_param_t;
+
+void lkbt51_init(bool wakeup_from_low_power_mode);
+void lkbt51_send_protocol_ver(uint16_t ver);
+
+void lkbt51_send_cmd(uint8_t* payload, uint8_t len, bool ack_enable, bool retry);
+
+void lkbt51_send_keyboard(uint8_t* report);
+void lkbt51_send_nkro(uint8_t* report);
+void lkbt51_send_consumer(uint16_t report);
+void lkbt51_send_system(uint16_t report);
+void lkbt51_send_mouse(uint8_t* report);
+
+void lkbt51_become_discoverable(uint8_t host_idx, void* param);
+void lkbt51_connect(uint8_t hostIndex, uint16_t timeout);
+void lkbt51_disconnect(void);
+void lkbt51_switch_host(uint8_t hostIndex);
+void lkbt51_read_state_reg(uint8_t reg, uint8_t len);
+
+void lkbt51_update_bat_lvl(uint8_t bat_lvl);
+void lkbt51_update_bat_state(uint8_t bat_state);
+
+void lkbt51_get_info(module_info_t* info);
+void lkbt51_set_param(module_param_t* param);
+void lkbt51_get_param(module_param_t* param);
+void lkbt51_set_local_name(const char* name);
+void lkbt51_get_local_name(void);
+
+void lkbt51_factory_reset(uint8_t p2p4g_clr_msk);
+void lkbt51_int_pin_test(bool enable);
+void lkbt51_dfu_rx(uint8_t* data, uint8_t length);
+void lkbt51_radio_test(uint8_t channel);
+void lkbt51_write_customize_data(uint8_t* data, uint8_t len);
+bool lkbt51_read_customize_data(uint8_t* data, uint8_t len);
+
+void lkbt51_task(void);

keyboards/keychron/common/wireless/lpm.c

@@ -0,0 +1,277 @@
+/* Copyright 2022~2023 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+/******************************************************************************
+ *
+ *  Filename:      lpm.c
+ *
+ *  Description:   Contains low power mode implementation
+ *
+ ******************************************************************************/
+
+#include "quantum.h"
+#if defined(PROTOCOL_CHIBIOS)
+#    include <usb_main.h>
+#endif
+#include "debounce.h"
+#include "wireless.h"
+#include "indicator.h"
+#include "lpm.h"
+#include "transport.h"
+#include "battery.h"
+#include "report_buffer.h"
+#include "keychron_common.h"
+
+extern matrix_row_t matrix[MATRIX_ROWS];
+extern wt_func_t    wireless_transport;
+
+static uint32_t lpm_timer_buffer;
+static bool     lpm_time_up = false;
+#ifndef OPTICAL_SWITCH
+static matrix_row_t empty_matrix[MATRIX_ROWS] = {0};
+#endif
+
+pin_t pins_row[MATRIX_ROWS] = MATRIX_ROW_PINS;
+pin_t pins_col[MATRIX_COLS] = MATRIX_COL_PINS;
+;
+
+__attribute__((weak)) void select_all_cols(void) {
+    for (uint8_t i = 0; i < MATRIX_COLS; i++) {
+        setPinOutput(pins_col[i]);
+        writePinLow(pins_col[i]);
+    }
+}
+
+void lpm_init(void) {
+#ifdef USB_POWER_SENSE_PIN
+#    if (USB_POWER_CONNECTED_LEVEL == 0)
+    setPinInputHigh(USB_POWER_SENSE_PIN);
+#    else
+    setPinInputLow(USB_POWER_SENSE_PIN);
+#    endif
+#endif
+    lpm_timer_reset();
+}
+
+inline void lpm_timer_reset(void) {
+    lpm_time_up      = false;
+    lpm_timer_buffer = timer_read32();
+}
+
+void lpm_timer_stop(void) {
+    lpm_time_up      = false;
+    lpm_timer_buffer = 0;
+}
+
+static inline bool lpm_any_matrix_action(void) {
+#ifdef OPTICAL_SWITCH
+    bool any_key = false;
+    for (uint8_t i = 0; i < MATRIX_ROWS; i++)
+        if (matrix_get_row(i) != 0) {
+            any_key = true;
+        }
+    return any_key;
+#else
+    return memcmp(matrix, empty_matrix, sizeof(empty_matrix));
+#endif
+}
+
+/* Implement of entering low power mode and wakeup varies per mcu or platform */
+__attribute__((weak)) void enter_power_mode(pm_t mode) {}
+
+__attribute__((weak)) bool usb_power_connected(void) {
+#ifdef USB_POWER_SENSE_PIN
+    return readPin(USB_POWER_SENSE_PIN) == USB_POWER_CONNECTED_LEVEL;
+#else
+    return true;
+#endif
+}
+
+__attribute__((weak)) bool lpm_is_kb_idle(void) {
+    return true;
+}
+
+__attribute__((weak)) bool lpm_set(pm_t mode) {
+    return false;
+}
+
+bool pre_enter_low_power_mode(pm_t mode) {
+#if defined(KEEP_USB_CONNECTION_IN_WIRELESS_MODE)
+    /* Don't enter low power mode if attached to the host */
+    if (mode > PM_SLEEP && usb_power_connected()) return false;
+#endif
+
+    if (!lpm_set(mode)) return false;
+
+#if defined(KEEP_USB_CONNECTION_IN_WIRELESS_MODE)
+    /* Usb unit is actived and running, stop and disconnect first */
+    usbStop(&USBD1);
+    usbDisconnectBus(&USBD1);
+
+    /* Isolate USB to save power.*/
+    // PWR->CR2 &= ~PWR_CR2_USV; /*PWR_CR2_USV is available on STM32L4x2xx and STM32L4x3xx devices only. */
+#endif
+
+    palEnableLineEvent(LKBT51_INT_INPUT_PIN, PAL_EVENT_MODE_FALLING_EDGE);
+#ifdef USB_POWER_SENSE_PIN
+    palEnableLineEvent(USB_POWER_SENSE_PIN, PAL_EVENT_MODE_BOTH_EDGES);
+#endif
+#ifdef P2P4_MODE_SELECT_PIN
+    palEnableLineEvent(P2P4_MODE_SELECT_PIN, PAL_EVENT_MODE_BOTH_EDGES);
+#endif
+#ifdef BT_MODE_SELECT_PIN
+    palEnableLineEvent(BT_MODE_SELECT_PIN, PAL_EVENT_MODE_BOTH_EDGES);
+#endif
+
+#ifdef OPTICAL_SWITCH
+
+    for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
+        if (pins_row[x] != NO_PIN) {
+            writePinLow(pins_row[x]);
+        }
+    }
+
+    for (uint8_t x = 0; x < MATRIX_COLS; x++) {
+        if (pins_col[x] != NO_PIN) {
+            setPinInputLow(pins_col[x]);
+        }
+    }
+#else
+
+    /* Enable key matrix wake up */
+    for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
+        if (pins_row[x] != NO_PIN) {
+            palEnableLineEvent(pins_row[x], PAL_EVENT_MODE_BOTH_EDGES);
+        }
+    }
+#endif
+    select_all_cols();
+
+#if (HAL_USE_SPI == TRUE)
+    palSetLineMode(SPI_SCK_PIN, PAL_MODE_INPUT_PULLDOWN);
+    palSetLineMode(SPI_MISO_PIN, PAL_MODE_INPUT_PULLDOWN);
+    palSetLineMode(SPI_MOSI_PIN, PAL_MODE_INPUT_PULLDOWN);
+#endif
+    palSetLineMode(A12, PAL_MODE_INPUT_PULLDOWN);
+    palSetLineMode(A11, PAL_MODE_INPUT_PULLDOWN);
+
+#if defined(DIP_SWITCH_PINS)
+#    define NUMBER_OF_DIP_SWITCHES (sizeof(dip_switch_pad) / sizeof(pin_t))
+    static pin_t dip_switch_pad[] = DIP_SWITCH_PINS;
+
+    for (uint8_t i = 0; i < NUMBER_OF_DIP_SWITCHES; i++) {
+        setPinInputLow(dip_switch_pad[i]);
+    }
+#endif
+    battery_stop();
+
+    return true;
+}
+
+static inline void lpm_wakeup(void) {
+    palSetLineMode(A11, PAL_STM32_OTYPE_PUSHPULL | PAL_STM32_OSPEED_HIGHEST | PAL_STM32_PUPDR_FLOATING | PAL_MODE_ALTERNATE(10U));
+    palSetLineMode(A12, PAL_STM32_OTYPE_PUSHPULL | PAL_STM32_OSPEED_HIGHEST | PAL_STM32_PUPDR_FLOATING | PAL_MODE_ALTERNATE(10U));
+
+#if (HAL_USE_SPI == TRUE)
+    palSetLineMode(SPI_SCK_PIN, PAL_MODE_ALTERNATE(5));
+    palSetLineMode(SPI_MISO_PIN, PAL_MODE_ALTERNATE(5));
+    palSetLineMode(SPI_MOSI_PIN, PAL_MODE_ALTERNATE(5));
+#endif
+
+    halInit();
+
+#ifdef ENCODER_ENABLE
+    encoder_cb_init();
+#endif
+
+    if (wireless_transport.init) wireless_transport.init(true);
+    battery_init();
+
+    /* Disable all wake up pins */
+    for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
+        if (pins_row[x] != NO_PIN) {
+            palDisableLineEvent(pins_row[x]);
+        }
+    }
+
+    palDisableLineEvent(LKBT51_INT_INPUT_PIN);
+#ifdef P2P4_MODE_SELECT_PIN
+    palDisableLineEvent(P2P4_MODE_SELECT_PIN);
+#endif
+#ifdef BT_MODE_SELECT_PIN
+    palDisableLineEvent(BT_MODE_SELECT_PIN);
+#endif
+#ifdef USB_POWER_SENSE_PIN
+    palDisableLineEvent(USB_POWER_SENSE_PIN);
+
+#    if defined(KEEP_USB_CONNECTION_IN_WIRELESS_MODE)
+    if (usb_power_connected()) {
+        usb_event_queue_init();
+        init_usb_driver(&USB_DRIVER);
+    }
+#    endif
+
+#endif
+
+#if defined(DIP_SWITCH_PINS)
+    dip_switch_init();
+    dip_switch_read(true);
+#endif
+
+    /* Call debounce_free() to avoiding memory leak of debounce_counters as debounce_init()
+    invoked in matrix_init() alloc new memory to debounce_counters */
+    debounce_free();
+    matrix_init();
+}
+
+void lpm_task(void) {
+    if (!lpm_time_up && sync_timer_elapsed32(lpm_timer_buffer) > RUN_MODE_PROCESS_TIME) {
+        lpm_time_up      = true;
+        lpm_timer_buffer = 0;
+    }
+
+    if (usb_power_connected() && USBD1.state == USB_STOP) {
+        usb_event_queue_init();
+        init_usb_driver(&USB_DRIVER);
+    }
+
+    if ((get_transport() == TRANSPORT_BLUETOOTH || get_transport() == TRANSPORT_P2P4) && lpm_time_up && !indicator_is_running() && lpm_is_kb_idle()) {
+#if defined(LED_MATRIX_ENABLE) || defined(RGB_MATRIX_ENABLE)
+        if (
+#    ifdef LED_MATRIX_ENABLE
+            !led_matrix_is_enabled() ||
+            (led_matrix_is_enabled() && led_matrix_is_driver_shutdown())
+#    endif
+#    ifdef RGB_MATRIX_ENABLE
+                !rgb_matrix_is_enabled() ||
+            (rgb_matrix_is_enabled() && rgb_matrix_is_driver_shutdown())
+#    endif
+        )
+#endif
+        {
+            if (!lpm_any_matrix_action()) {
+                if (pre_enter_low_power_mode(LOW_POWER_MODE)) {
+                    enter_power_mode(LOW_POWER_MODE);
+
+                    lpm_wakeup();
+                    lpm_timer_reset();
+                    report_buffer_init();
+                    lpm_set(PM_RUN);
+                }
+            }
+        }
+    }
+}

keyboards/keychron/common/wireless/lpm.h

@@ -1,4 +1,4 @@
-/* Copyright 2021 @ Grayson Carr
+/* Copyright 2023 @ lokher (https://www.keychron.com)
  *
  * 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
@@ -16,10 +16,21 @@
 
 #pragma once
 
-/* RGB Matrix Configuration */
-#ifdef RGB_MATRIX_ENABLE
-#    define RGB_DISABLE_WHEN_USB_SUSPENDED
-#    define CAPS_LOCK_INDICATOR_COLOR RGB_RED
-#    define CAPS_LOCK_INDICATOR_LIGHT_ALPHAS
-#    define FN_LAYER_TRANSPARENT_KEYS_OFF
+#ifndef RUN_MODE_PROCESS_TIME
+#    define RUN_MODE_PROCESS_TIME 1000
 #endif
+
+typedef enum {
+    PM_RUN,
+    PM_SLEEP,
+    PM_STOP,
+    PM_STANDBY,
+} pm_t;
+
+void lpm_init(void);
+void lpm_timer_reset(void);
+void lpm_timer_stop(void);
+bool usb_power_connected(void);
+bool lpm_is_kb_idle(void);
+void enter_power_mode(pm_t mode);
+void lpm_task(void);

keyboards/keychron/common/wireless/lpm_stm32f401.c

@@ -0,0 +1,114 @@
+/* Copyright 2023 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+/******************************************************************************
+ *
+ *  Filename:      lpm_stm32f401.c
+ *
+ *  Description:   Contains low power mode implementation
+ *
+ ******************************************************************************/
+
+#include "quantum.h"
+#include <usb_main.h>
+#include "wireless.h"
+#include "lpm.h"
+#include "lpm_stm32f401.h"
+#include "config.h"
+
+static pm_t power_mode = PM_RUN;
+
+bool lpm_set(pm_t mode) {
+    bool ret = true;
+
+    switch (mode) {
+        case PM_SLEEP:
+            /* Wake source: Any interrupt or event */
+            if (power_mode != PM_RUN)
+                ret = false;
+            else
+                SCB->SCR &= ~SCB_SCR_SLEEPDEEP_Msk;
+            break;
+
+        case PM_STOP:
+            /* Wake source: Reset pin, all I/Os, BOR, PVD, PVM, RTC, LCD, IWDG,
+               COMPx, USARTx, LPUART1, I2Cx, LPTIMx, USB, SWPMI */
+            if (power_mode != PM_RUN)
+                ret = false;
+            else {
+                SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk;
+                PWR->CR |=
+#if STOP_MODE_MAIN_REGULATOR_LOW_VOLTAGE
+                    PWR_CR_MRLVDS |
+#endif
+#if STOP_MODE_LOW_POWER_REGULATOR_LOW_VOLTAG
+                    PWR_CR_LPLVDS |
+#endif
+#if STOP_MODE_FLASH_POWER_DOWN
+                    PWR_CR_FPDS |
+#endif
+#if STOP_MODE_LOW_POWER_DEEPSLEEP
+                    PWR_CR_LPDS |
+#endif
+                    0;
+            }
+            break;
+
+        case PM_STANDBY:
+            if (power_mode != PM_RUN)
+                ret = false;
+            else {
+                SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk;
+            }
+            break;
+
+        default:
+            break;
+    }
+    power_mode = mode;
+
+    return ret;
+}
+
+void enter_power_mode(pm_t mode) {
+#if STM32_HSE_ENABLED
+    /* Switch to HSI */
+    RCC->CFGR = (RCC->CFGR & (~STM32_SW_MASK)) | STM32_SW_HSI;
+    while ((RCC->CFGR & RCC_CFGR_SWS) != (STM32_SW_HSI << 2))
+        ;
+
+    /* Set HSE off  */
+    RCC->CR &= ~RCC_CR_HSEON;
+    while ((RCC->CR & RCC_CR_HSERDY))
+        ;
+
+    /* To avoid power consumption of floating GPIO */
+    palSetLineMode(H0, PAL_MODE_INPUT_PULLDOWN);
+    palSetLineMode(H1, PAL_MODE_INPUT_PULLDOWN);
+#endif
+
+    __WFI();
+
+    SCB->SCR &= ~SCB_SCR_SLEEPDEEP_Msk;
+
+    writePinLow(BLUETOOTH_INT_OUTPUT_PIN);
+    stm32_clock_init();
+    writePinHigh(BLUETOOTH_INT_OUTPUT_PIN);
+}
+
+void usb_power_connect(void) {}
+
+void usb_power_disconnect(void) {}

keyboards/keychron/common/wireless/lpm_stm32f401.h

@@ -1,4 +1,4 @@
-/* Copyright 2023 @ Keychron (https://www.keychron.com)
+/* Copyright 2023 @ lokher (https://www.keychron.com)
  *
  * 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
@@ -16,16 +16,18 @@
 
 #pragma once
 
-/* RGB Matrix Driver Configuration */
-#define SNLED27351_I2C_ADDRESS_1 SNLED27351_I2C_ADDRESS_VDDIO
+#ifndef STOP_MODE_MAIN_REGULATOR_LOW_VOLTAGE
+#    define STOP_MODE_MAIN_REGULATOR_LOW_VOLTAGE TRUE
+#endif
 
-/* RGB Matrix Configuration */
-#define RGB_MATRIX_LED_COUNT 26
+#ifndef STOP_MODE_LOW_POWER_REGULATOR_LOW_VOLTAG
+#    define STOP_MODE_LOW_POWER_REGULATOR_LOW_VOLTAG TRUE
+#endif
 
-#define SNLED27351_PHASE_CHANNEL SNLED27351_SCAN_PHASE_9_CHANNEL
+#ifndef STOP_MODE_FLASH_POWER_DOWN
+#    define STOP_MODE_FLASH_POWER_DOWN TRUE
+#endif
 
-/* Encoder Configuration*/
-#define ENCODER_DEFAULT_POS 0x3
-
-/* Enable num-lock LED */
-#define NUM_LOCK_LED_INDEX 5
+#ifndef STOP_MODE_LOW_POWER_DEEPSLEEP
+#    define STOP_MODE_LOW_POWER_DEEPSLEEP TRUE
+#endif

keyboards/keychron/common/wireless/report_buffer.c

@@ -0,0 +1,148 @@
+/* Copyright 2023 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "quantum.h"
+#include "report_buffer.h"
+#include "wireless.h"
+#include "lpm.h"
+
+/* The report buffer is mainly used to fix key press lost issue of macro
+ * when wireless module fifo isn't large enough. The maximun macro
+ * string length is determined by this queue size, and should be
+ * REPORT_BUFFER_QUEUE_SIZE devided by 2 since each character is implemented
+ * by sending a key pressing then a key releasing report.
+ * Please note that it cosume sizeof(report_buffer_t)  * REPORT_BUFFER_QUEUE_SIZE
+ * bytes RAM, with default setting, used RAM size is
+ *        sizeof(report_buffer_t) * 256 = 34* 256  =  8704 bytes
+ */
+#ifndef REPORT_BUFFER_QUEUE_SIZE
+#    define REPORT_BUFFER_QUEUE_SIZE 256
+#endif
+
+extern wt_func_t wireless_transport;
+
+/* report_interval value should be less than bluetooth connection interval because
+ * it takes some time for communicating between mcu and bluetooth module. Carefully
+ * set this value to feed the bt module so that we don't lost the key report nor lost
+ * the anchor point of bluetooth interval. The bluetooth connection interval varies
+ * if BLE is used, invoke report_buffer_set_inverval() to update the value
+ */
+uint8_t report_interval = DEFAULT_2P4G_REPORT_INVERVAL_MS;
+
+static uint32_t report_timer_buffer = 0;
+uint32_t        retry_time_buffer   = 0;
+report_buffer_t report_buffer_queue[REPORT_BUFFER_QUEUE_SIZE];
+uint16_t        report_buffer_queue_head;
+uint16_t        report_buffer_queue_tail;
+report_buffer_t kb_rpt;
+uint8_t         retry = 0;
+
+void report_buffer_task(void);
+
+void report_buffer_init(void) {
+    // Initialise the report queue
+    memset(&report_buffer_queue, 0, sizeof(report_buffer_queue));
+    report_buffer_queue_head = 0;
+    report_buffer_queue_tail = 0;
+    retry                    = 0;
+    report_timer_buffer      = timer_read32();
+
+#ifdef KEYCHRON_CALLBACK_ENABLE
+    register_keychron_task(report_buffer_task, true);
+#endif
+}
+
+bool report_buffer_enqueue(report_buffer_t *report) {
+    uint16_t next = (report_buffer_queue_head + 1) % REPORT_BUFFER_QUEUE_SIZE;
+    if (next == report_buffer_queue_tail) {
+        return false;
+    }
+
+    report_buffer_queue[report_buffer_queue_head] = *report;
+    report_buffer_queue_head                      = next;
+    return true;
+}
+
+inline bool report_buffer_dequeue(report_buffer_t *report) {
+    if (report_buffer_queue_head == report_buffer_queue_tail) {
+        return false;
+    }
+
+    *report                  = report_buffer_queue[report_buffer_queue_tail];
+    report_buffer_queue_tail = (report_buffer_queue_tail + 1) % REPORT_BUFFER_QUEUE_SIZE;
+    return true;
+}
+
+bool report_buffer_is_empty() {
+    return report_buffer_queue_head == report_buffer_queue_tail;
+}
+
+void report_buffer_update_timer(void) {
+    report_timer_buffer = timer_read32();
+}
+
+bool report_buffer_next_inverval(void) {
+    return timer_elapsed32(report_timer_buffer) > report_interval;
+}
+
+void report_buffer_set_inverval(uint8_t interval) {
+    // OG_TRACE("report_buffer_set_inverval: %d\n\r", interval);
+    report_interval = interval;
+}
+
+uint8_t report_buffer_get_retry(void) {
+    return retry;
+}
+
+void report_buffer_set_retry(uint8_t times) {
+    retry = times;
+}
+
+void report_buffer_task(void) {
+    if (wireless_get_state() == WT_CONNECTED && (!report_buffer_is_empty() || retry) && report_buffer_next_inverval()) {
+        bool pending_data = false;
+
+        if (!retry) {
+            if (report_buffer_dequeue(&kb_rpt) && kb_rpt.type != REPORT_TYPE_NONE) {
+                if (timer_read32() > 2) {
+                    pending_data      = true;
+                    retry             = RETPORT_RETRY_COUNT;
+                    retry_time_buffer = timer_read32();
+                }
+            }
+        } else {
+            if (timer_elapsed32(retry_time_buffer) > 2) {
+                pending_data = true;
+                --retry;
+                retry_time_buffer = timer_read32();
+            }
+        }
+
+        if (pending_data) {
+#if defined(NKRO_ENABLE) && defined(WIRELESS_NKRO_ENABLE)
+            if (kb_rpt.type == REPORT_TYPE_NKRO && wireless_transport.send_nkro) {
+                wireless_transport.send_nkro(&kb_rpt.nkro.mods);
+            } else if (kb_rpt.type == REPORT_TYPE_KB && wireless_transport.send_keyboard)
+                wireless_transport.send_keyboard(&kb_rpt.keyboard.mods);
+#else
+            if (kb_rpt.type == REPORT_TYPE_KB && wireless_transport.send_keyboard) wireless_transport.send_keyboard(&kb_rpt.keyboard.mods);
+#endif
+            if (kb_rpt.type == REPORT_TYPE_CONSUMER && wireless_transport.send_consumer) wireless_transport.send_consumer(kb_rpt.consumer);
+            report_timer_buffer = timer_read32();
+            lpm_timer_reset();
+        }
+    }
+}

keyboards/keychron/common/wireless/report_buffer.h

@@ -0,0 +1,61 @@
+/* Copyright 2022~2023 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "report.h"
+
+/* Default report interval value */
+#ifndef DEFAULT_BLE_REPORT_INVERVAL_MS
+#    define DEFAULT_BLE_REPORT_INVERVAL_MS 3
+#endif
+
+/* Default report interval value */
+#ifndef DEFAULT_2P4G_REPORT_INVERVAL_MS
+#    define DEFAULT_2P4G_REPORT_INVERVAL_MS 1
+#endif
+
+/* Default report interval value */
+#ifndef RETPORT_RETRY_COUNT
+#    define RETPORT_RETRY_COUNT 30
+#endif
+
+enum {
+    REPORT_TYPE_NONE,
+    REPORT_TYPE_KB,
+    REPORT_TYPE_NKRO,
+    REPORT_TYPE_CONSUMER,
+};
+
+typedef struct {
+    uint8_t type;
+    union {
+        report_keyboard_t keyboard;
+        report_nkro_t     nkro;
+        uint16_t          consumer;
+    };
+} report_buffer_t;
+
+void    report_buffer_init(void);
+bool    report_buffer_enqueue(report_buffer_t *report);
+bool    report_buffer_dequeue(report_buffer_t *report);
+bool    report_buffer_is_empty(void);
+void    report_buffer_update_timer(void);
+bool    report_buffer_next_inverval(void);
+void    report_buffer_set_inverval(uint8_t interval);
+uint8_t report_buffer_get_retry(void);
+void    report_buffer_set_retry(uint8_t times);
+void    report_buffer_task(void);

keyboards/keychron/common/wireless/rtc_timer.c

@@ -0,0 +1,43 @@
+/* Copyright 2023 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "hal.h"
+
+#if (HAL_USE_RTC)
+
+#    include "rtc_timer.h"
+
+void rtc_timer_init(void) {
+    rtc_timer_clear();
+}
+
+void rtc_timer_clear(void) {
+    RTCDateTime tm = {0, 0, 0, 0, 0, 0};
+    rtcSetTime(&RTCD1, &tm);
+}
+
+uint32_t rtc_timer_read_ms(void) {
+    RTCDateTime tm;
+    rtcGetTime(&RTCD1, &tm);
+
+    return tm.millisecond;
+}
+
+uint32_t rtc_timer_elapsed_ms(uint32_t last) {
+    return TIMER_DIFF_32(rtc_timer_read_ms(), last);
+}
+
+#endif

keyboards/keychron/common/wireless/rtc_timer.h

@@ -1,4 +1,4 @@
-/* Copyright 2021 Jakub Horak (@kubahorak)
+/* Copyright 2023 @ lokher (https://www.keychron.com)
  *
  * 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
@@ -16,10 +16,20 @@
 
 #pragma once
 
-#ifdef RGB_MATRIX_ENABLE
-/* from rev_0100/keymaps/gtg465x */
-#    define RGB_DISABLE_WHEN_USB_SUSPENDED
-#    define CAPS_LOCK_INDICATOR_COLOR RGB_RED
-#    define CAPS_LOCK_INDICATOR_LIGHT_ALPHAS
-#    define FN_LAYER_TRANSPARENT_KEYS_OFF
+#include "timer.h"
+#include <stdint.h>
+
+#define RTC_MAX_TIME (24 * 3600 * 1000) // Set to 1 day
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void     rtc_timer_init(void);
+void     rtc_timer_clear(void);
+uint32_t rtc_timer_read_ms(void);
+uint32_t rtc_timer_elapsed_ms(uint32_t last);
+
+#ifdef __cplusplus
+}
 #endif

keyboards/keychron/common/wireless/transport.c

@@ -0,0 +1,272 @@
+/* Copyright 2022~2023 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "quantum.h"
+#include "wireless.h"
+#include "indicator.h"
+#include "lpm.h"
+#include "mousekey.h"
+#if defined(PROTOCOL_CHIBIOS)
+#    include <usb_main.h>
+#endif
+#include "transport.h"
+#include "lkbt51.h"
+
+#ifndef REINIT_LED_DRIVER
+#    define REINIT_LED_DRIVER 0
+#endif
+
+#if defined(PROTOCOL_CHIBIOS)
+extern host_driver_t chibios_driver;
+#endif
+extern host_driver_t   wireless_driver;
+extern keymap_config_t keymap_config;
+extern wt_func_t       wireless_transport;
+
+static transport_t transport = TRANSPORT_NONE;
+
+#ifdef NKRO_ENABLE
+nkro_t nkro = {false, false};
+#endif
+
+static void transport_changed(transport_t new_transport);
+
+__attribute__((weak)) void bt_transport_enable(bool enable) {
+    if (enable) {
+        // if (host_get_driver() != &wireless_driver) {
+        host_set_driver(&wireless_driver);
+
+        /* Disconnect and reconnect to sync the wireless state
+         * TODO: query wireless state to sync
+         */
+        wireless_disconnect();
+
+        uint32_t t = timer_read32();
+        while (timer_elapsed32(t) < 50) {
+            wireless_transport.task();
+        }
+        // wireless_connect();
+        wireless_connect_ex(30, 0);
+        // TODO: Clear USB report
+        //}
+    } else {
+        indicator_stop();
+
+        if (wireless_get_state() == WT_CONNECTED && transport == TRANSPORT_BLUETOOTH) {
+            report_keyboard_t empty_report = {0};
+            wireless_driver.send_keyboard(&empty_report);
+        }
+    }
+}
+
+__attribute__((weak)) void p24g_transport_enable(bool enable) {
+    if (enable) {
+        // if (host_get_driver() != &wireless_driver) {
+        host_set_driver(&wireless_driver);
+
+        /* Disconnect and reconnect to sync the wireless state
+         * TODO: query bluetooth state to sync
+         */
+        wireless_disconnect();
+
+        uint32_t t = timer_read32();
+        while (timer_elapsed32(t) < 50) {
+            wireless_transport.task();
+        }
+        wireless_connect_ex(P24G_INDEX, 0);
+        // wireless_connect();
+        //  TODO: Clear USB report
+        //}
+    } else {
+        indicator_stop();
+
+        if (wireless_get_state() == WT_CONNECTED && transport == TRANSPORT_P2P4) {
+            report_keyboard_t empty_report = {0};
+            wireless_driver.send_keyboard(&empty_report);
+        }
+    }
+}
+
+__attribute__((weak)) void usb_power_connect(void) {}
+__attribute__((weak)) void usb_power_disconnect(void) {}
+
+__attribute__((weak)) void usb_transport_enable(bool enable) {
+    if (enable) {
+        if (host_get_driver() != &chibios_driver) {
+#if !defined(KEEP_USB_CONNECTION_IN_WIRELESS_MODE)
+            usb_power_connect();
+            usb_start(&USBD1);
+#endif
+            host_set_driver(&chibios_driver);
+        }
+    } else {
+        if (USB_DRIVER.state == USB_ACTIVE) {
+            report_keyboard_t empty_report = {0};
+            chibios_driver.send_keyboard(&empty_report);
+        }
+
+#if !defined(KEEP_USB_CONNECTION_IN_WIRELESS_MODE)
+        usbStop(&USBD1);
+        usbDisconnectBus(&USBD1);
+        usb_power_disconnect();
+#endif
+    }
+}
+
+void set_transport(transport_t new_transport) {
+    if (transport != new_transport) {
+        if (transport == TRANSPORT_USB || ((transport != TRANSPORT_USB) && wireless_get_state() == WT_CONNECTED)) clear_keyboard();
+
+        transport = new_transport;
+
+        switch (transport) {
+            case TRANSPORT_USB:
+                usb_transport_enable(true);
+                bt_transport_enable(false);
+                wait_ms(5);
+                p24g_transport_enable(false);
+                wireless_disconnect();
+                lpm_timer_stop();
+#ifdef NKRO_ENABLE
+#    if defined(WIRELESS_NKRO_ENABLE)
+                nkro.bluetooth = keymap_config.nkro;
+#    endif
+                keymap_config.nkro = nkro.usb;
+#endif
+                break;
+
+            case TRANSPORT_BLUETOOTH:
+                p24g_transport_enable(false);
+                wait_ms(1);
+                bt_transport_enable(true);
+                usb_transport_enable(false);
+                lpm_timer_reset();
+#if defined(NKRO_ENABLE)
+                nkro.usb = keymap_config.nkro;
+#    if defined(WIRELESS_NKRO_ENABLE)
+                keymap_config.nkro = nkro.bluetooth;
+#    else
+                keymap_config.nkro = FALSE;
+#    endif
+#endif
+                break;
+
+            case TRANSPORT_P2P4:
+                bt_transport_enable(false);
+                wait_ms(1);
+                p24g_transport_enable(true);
+                usb_transport_enable(false);
+                lpm_timer_reset();
+#if defined(NKRO_ENABLE)
+                nkro.usb = keymap_config.nkro;
+#    if defined(WIRELESS_NKRO_ENABLE)
+                keymap_config.nkro = nkro.bluetooth;
+#    else
+                keymap_config.nkro = FALSE;
+#    endif
+#endif
+                break;
+
+            default:
+                break;
+        }
+
+        transport_changed(transport);
+    }
+}
+
+transport_t get_transport(void) {
+    return transport;
+}
+
+#if (REINIT_LED_DRIVER)
+/* Changing transport may cause bronw-out reset of led driver
+ * withoug MCU reset, which lead backlight to not work,
+ * reinit the led driver workgound this issue */
+static void reinit_led_drvier(void) {
+    /* Wait circuit to discharge for a while */
+    systime_t start = chVTGetSystemTime();
+    while (chTimeI2MS(chVTTimeElapsedSinceX(start)) < 100) {
+    };
+
+#    ifdef LED_MATRIX_ENABLE
+    led_matrix_init();
+#    endif
+#    ifdef RGB_MATRIX_ENABLE
+    rgb_matrix_init();
+#    endif
+}
+#endif
+
+void transport_changed(transport_t new_transport) {
+    kc_printf("transport_changed %d\n\r", new_transport);
+    indicator_init();
+
+#if (REINIT_LED_DRIVER)
+    reinit_led_drvier();
+#endif
+
+#if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_TIMEOUT)
+#    if (RGB_MATRIX_TIMEOUT > 0)
+    rgb_matrix_disable_timeout_set(RGB_MATRIX_TIMEOUT_INFINITE);
+    rgb_matrix_disable_time_reset();
+#    endif
+#endif
+#if defined(LED_MATRIX_ENABLE) && defined(LED_MATRIX_TIMEOUT)
+#    if (LED_MATRIX_TIMEOUT > 0)
+    led_matrix_disable_timeout_set(LED_MATRIX_TIMEOUT_INFINITE);
+    led_matrix_disable_time_reset();
+#    endif
+#endif
+}
+
+void usb_remote_wakeup(void) {
+    if (USB_DRIVER.state == USB_SUSPENDED) {
+        while (USB_DRIVER.state == USB_SUSPENDED) {
+            /* Do this in the suspended state */
+            suspend_power_down(); // on AVR this deep sleeps for 15ms
+            /* Remote wakeup */
+            if (suspend_wakeup_condition()) {
+                usbWakeupHost(&USB_DRIVER);
+                wait_ms(300);
+#ifdef MOUSEKEY_ENABLE
+                // Wiggle to wakeup
+                mousekey_on(KC_MS_LEFT);
+                mousekey_send();
+                wait_ms(10);
+                mousekey_on(KC_MS_RIGHT);
+                mousekey_send();
+                wait_ms(10);
+                mousekey_off((KC_MS_RIGHT));
+                mousekey_send();
+#else
+                set_mods(0x02);
+                send_keyboard_report();
+                wait_ms(10);
+                del_mods(0x02);
+                send_keyboard_report();
+#endif
+            }
+        }
+        /* Woken up */
+        // variables has been already cleared by the wakeup hook
+        send_keyboard_report();
+#ifdef MOUSEKEY_ENABLE
+        mousekey_send();
+#endif /* MOUSEKEY_ENABLE */
+        usb_event_queue_task();
+    }
+}

keyboards/keychron/common/wireless/transport.h

@@ -1,4 +1,4 @@
-/* Copyright 2022 @ Teimor Epstein
+/* Copyright 2022~2023 @ lokher (https://www.keychron.com)
  *
  * 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
@@ -13,26 +13,30 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 #pragma once
 
-#include QMK_KEYBOARD_H
-
 typedef enum {
-    TD_NONE,
-    TD_UNKNOWN,
-    TD_SINGLE_TAP,
-    TD_SINGLE_HOLD,
-    TD_DOUBLE_TAP,
-    TD_DOUBLE_HOLD,
-    TD_DOUBLE_SINGLE_TAP,  // Send two single taps
-    TD_TRIPLE_TAP,
-    TD_TRIPLE_HOLD,
-    TD_TRIPLE_SINGLE_TAP  // Send three single tap
-} td_state_t;
+    TRANSPORT_NONE,
+    TRANSPORT_USB       = 0x01 << 0,
+    TRANSPORT_BLUETOOTH = 0x01 << 1,
+    TRANSPORT_P2P4      = 0x01 << 2,
+    TRANSPORT_MAX,
+} transport_t;
 
+#ifdef NKRO_ENABLE
 typedef struct {
-    bool       is_press_action;
-    td_state_t state;
-} td_tap_t;
+    bool usb : 1;
+    bool bluetooth : 1;
+} nkro_t;
+#endif
 
-td_state_t current_dance(tap_dance_state_t *state);
+#define TRANSPORT_WIRELESS (TRANSPORT_BLUETOOTH | TRANSPORT_P2P4)
+
+void        set_transport(transport_t new_transport);
+transport_t get_transport(void);
+
+void usb_power_connect(void);
+void usb_power_disconnect(void);
+void usb_transport_enable(bool enable);
+void usb_remote_wakeup(void);

keyboards/keychron/common/wireless/wireless.c

@@ -0,0 +1,556 @@
+/* Copyright 2023 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "quantum.h"
+#include "wireless.h"
+#include "report_buffer.h"
+#include "lpm.h"
+#include "battery.h"
+#include "indicator.h"
+#include "transport.h"
+#include "rtc_timer.h"
+#include "keychron_wireless_common.h"
+#include "keychron_task.h"
+
+extern uint8_t         pairing_indication;
+extern host_driver_t   chibios_driver;
+extern report_buffer_t kb_rpt;
+extern uint32_t        retry_time_buffer;
+extern uint8_t         retry;
+
+#ifdef NKRO_ENABLE
+extern nkro_t nkro;
+#endif
+
+static uint8_t host_index = 0;
+static uint8_t led_state  = 0;
+
+extern wt_func_t  wireless_transport;
+static wt_state_t wireless_state           = WT_RESET;
+static bool       pincodeEntry             = false;
+uint8_t           wireless_report_protocol = true;
+
+/* declarations */
+uint8_t wreless_keyboard_leds(void);
+void    wireless_send_keyboard(report_keyboard_t *report);
+void    wireless_send_nkro(report_nkro_t *report);
+void    wireless_send_mouse(report_mouse_t *report);
+void    wireless_send_extra(report_extra_t *report);
+bool    process_record_wireless(uint16_t keycode, keyrecord_t *record);
+
+/* host struct */
+host_driver_t wireless_driver = {wreless_keyboard_leds, wireless_send_keyboard, wireless_send_nkro, wireless_send_mouse, wireless_send_extra};
+
+#define WT_EVENT_QUEUE_SIZE 16
+wireless_event_t wireless_event_queue[WT_EVENT_QUEUE_SIZE];
+uint8_t          wireless_event_queue_head;
+uint8_t          wireless_event_queue_tail;
+
+void wireless_event_queue_init(void) {
+    // Initialise the event queue
+    memset(&wireless_event_queue, 0, sizeof(wireless_event_queue));
+    wireless_event_queue_head = 0;
+    wireless_event_queue_tail = 0;
+}
+
+bool wireless_event_enqueue(wireless_event_t event) {
+    uint8_t next = (wireless_event_queue_head + 1) % WT_EVENT_QUEUE_SIZE;
+    if (next == wireless_event_queue_tail) {
+        /* Override the first report */
+        wireless_event_queue_tail = (wireless_event_queue_tail + 1) % WT_EVENT_QUEUE_SIZE;
+    }
+    wireless_event_queue[wireless_event_queue_head] = event;
+    wireless_event_queue_head                       = next;
+    return true;
+}
+
+static inline bool wireless_event_dequeue(wireless_event_t *event) {
+    if (wireless_event_queue_head == wireless_event_queue_tail) {
+        return false;
+    }
+    *event                    = wireless_event_queue[wireless_event_queue_tail];
+    wireless_event_queue_tail = (wireless_event_queue_tail + 1) % WT_EVENT_QUEUE_SIZE;
+    return true;
+}
+
+/*
+ * Bluetooth init.
+ */
+void wireless_init(void) {
+    wireless_state = WT_INITIALIZED;
+
+    wireless_event_queue_init();
+#ifndef DISABLE_REPORT_BUFFER
+    report_buffer_init();
+#endif
+    indicator_init();
+#ifdef BLUETOOTH_INT_INPUT_PIN
+    setPinInputHigh(BLUETOOTH_INT_INPUT_PIN);
+#endif
+
+    battery_init();
+    lpm_init();
+#if HAL_USE_RTC
+    rtc_timer_init();
+#endif
+#ifdef NKRO_ENABLE
+    keymap_config.raw = eeconfig_read_keymap();
+    nkro.usb          = keymap_config.nkro;
+#    ifdef WIRELESS_NKRO_ENABLE
+    nkro.bluetooth = keymap_config.nkro;
+#    endif
+#endif
+#ifdef KEYCHRON_CALLBACK_ENABLE
+    register_wt_tasks();
+    register_record_process(process_record_wireless, false);
+#endif
+}
+
+/*
+ * Bluetooth trasponrt init. Bluetooth module driver shall use this function to register a callback
+ * to its implementation.
+ */
+void wireless_set_transport(wt_func_t *transport) {
+    if (transport) memcpy(&wireless_transport, transport, sizeof(wt_func_t));
+}
+
+/*
+ * Enter pairing with current host index
+ */
+void wireless_pairing(void) {
+    if (battery_is_critical_low()) return;
+
+    wireless_pairing_ex(0, NULL);
+    wireless_state = WT_PARING;
+}
+
+/*
+ * Enter pairing with specified host index and param
+ */
+void wireless_pairing_ex(uint8_t host_idx, void *param) {
+    kc_printf("wireless_pairing_ex %d\n\r", host_idx);
+    if (battery_is_critical_low()) return;
+
+    if (wireless_transport.pairing_ex) wireless_transport.pairing_ex(host_idx, param);
+    wireless_state = WT_PARING;
+
+    host_index = host_idx;
+}
+
+/*
+ * Initiate connection request to paired host
+ */
+void wireless_connect(void) {
+    /*  Work around empty report after wakeup, which leads to reconneect/disconnected loop */
+    if (battery_is_critical_low() || timer_read32() == 0) return;
+
+    if (wireless_state == WT_RECONNECTING && !indicator_is_running()) {
+        indicator_set(wireless_state, host_index);
+    }
+    wireless_transport.connect_ex(0, 0);
+    wireless_state = WT_RECONNECTING;
+}
+
+/*
+ * Initiate connection request to paired host with argument
+ */
+void wireless_connect_ex(uint8_t host_idx, uint16_t timeout) {
+    kc_printf("wireless_connect_ex %d\n\r", host_idx);
+    if (battery_is_critical_low()) return;
+
+    if (host_idx != 0) {
+        /* Do nothing when trying to connect to current connected host*/
+        if (host_index == host_idx && wireless_state == WT_CONNECTED) return;
+
+        host_index = host_idx;
+        led_state  = 0;
+    }
+    wireless_transport.connect_ex(host_idx, timeout);
+    wireless_state = WT_RECONNECTING;
+}
+
+/* Initiate a disconnection */
+void wireless_disconnect(void) {
+    kc_printf("wireless_disconnect\n\r");
+    if (wireless_transport.disconnect) wireless_transport.disconnect();
+}
+
+/* Called when the BT device is reset. */
+static void wireless_enter_reset(uint8_t reason) {
+    kc_printf("wireless_enter_reset\n\r");
+    wireless_state = WT_RESET;
+    wireless_enter_reset_kb(reason);
+}
+
+/* Enters discoverable state. Upon entering this state we perform the following actions:
+ *   - change state to WT_PARING
+ *   - set pairing indication
+ */
+static void wireless_enter_discoverable(uint8_t host_idx) {
+    kc_printf("wireless_enter_discoverable: %d\n\r", host_idx);
+    host_index = host_idx;
+
+    wireless_state = WT_PARING;
+    indicator_set(wireless_state, host_idx);
+    wireless_enter_discoverable_kb(host_idx);
+}
+
+/*
+ * Enters reconnecting state. Upon entering this state we perform the following actions:
+ *   - change state to RECONNECTING
+ *   - set reconnect indication
+ */
+static void wireless_enter_reconnecting(uint8_t host_idx) {
+    host_index = host_idx;
+
+    kc_printf("wireless_reconnecting %d\n\r", host_idx);
+    wireless_state = WT_RECONNECTING;
+    indicator_set(wireless_state, host_idx);
+    wireless_enter_reconnecting_kb(host_idx);
+}
+
+/* Enters connected state. Upon entering this state we perform the following actions:
+ *   - change state to CONNECTED
+ *   - set connected indication
+ *   - enable NKRO if it is support
+ */
+static void wireless_enter_connected(uint8_t host_idx) {
+    kc_printf("wireless_connected %d\n\r", host_idx);
+
+    wireless_state = WT_CONNECTED;
+    indicator_set(wireless_state, host_idx);
+    host_index = host_idx;
+
+    clear_keyboard();
+
+    /* Enable NKRO since it may be disabled in pin code entry */
+#if defined(NKRO_ENABLE) && defined(WIRELESS_NKRO_ENABLE)
+    keymap_config.nkro = nkro.bluetooth;
+#else
+    keymap_config.nkro = false;
+#endif
+
+    wireless_enter_connected_kb(host_idx);
+#ifdef BAT_LOW_LED_PIN
+    if (battery_is_empty()) {
+        indicator_battery_low_enable(true);
+    }
+#endif
+    if (wireless_transport.update_bat_level) wireless_transport.update_bat_level(battery_get_percentage());
+}
+
+/* Enters disconnected state. Upon entering this state we perform the following actions:
+ *   - change state to DISCONNECTED
+ *   - set disconnected indication
+ */
+static void wireless_enter_disconnected(uint8_t host_idx) {
+    kc_printf("wireless_disconnected %d\n\r", host_idx);
+
+    uint8_t previous_state = wireless_state;
+    led_state              = 0;
+    led_update_kb((led_t)led_state);
+
+    wireless_state = WT_DISCONNECTED;
+
+    if (previous_state == WT_CONNECTED) {
+        lpm_timer_reset();
+        indicator_set(WT_SUSPEND, host_idx);
+    } else
+        indicator_set(wireless_state, host_idx);
+
+#ifndef DISABLE_REPORT_BUFFER
+    report_buffer_init();
+#endif
+    retry = 0;
+    wireless_enter_disconnected_kb(host_idx);
+#ifdef BAT_LOW_LED_PIN
+    indicator_battery_low_enable(false);
+#endif
+#if defined(LOW_BAT_IND_INDEX)
+    indicator_battery_low_backlit_enable(false);
+#endif
+}
+
+/* Enter pin code entry state. */
+static void wireless_enter_bluetooth_pin_code_entry(void) {
+#if defined(NKRO_ENABLE)
+    keymap_config.nkro = FALSE;
+#endif
+    pincodeEntry = true;
+    wireless_enter_bluetooth_pin_code_entry_kb();
+}
+
+/* Exit pin code entry state. */
+static void wireless_exit_bluetooth_pin_code_entry(void) {
+#if defined(NKRO_ENABLE)
+    keymap_config.nkro = true;
+#endif
+    pincodeEntry = false;
+    wireless_exit_bluetooth_pin_code_entry_kb();
+}
+
+/* Enters disconnected state. Upon entering this state we perform the following actions:
+ *   - change state to DISCONNECTED
+ *   - set disconnected indication
+ */
+static void wireless_enter_sleep(void) {
+    kc_printf("wireless_enter_sleep %d\n\r", wireless_state);
+
+    led_state = 0;
+    if (wireless_state == WT_PARING) {
+        wireless_state = WT_SUSPEND;
+        kc_printf("WT_SUSPEND\n\r");
+
+        wireless_enter_sleep_kb();
+        indicator_set(wireless_state, 0);
+#ifdef BAT_LOW_LED_PIN
+        indicator_battery_low_enable(false);
+#endif
+#if defined(LOW_BAT_IND_INDEX)
+        indicator_battery_low_backlit_enable(false);
+#endif
+    }
+}
+
+__attribute__((weak)) void wireless_enter_reset_kb(uint8_t reason) {}
+__attribute__((weak)) void wireless_enter_discoverable_kb(uint8_t host_idx) {}
+__attribute__((weak)) void wireless_enter_reconnecting_kb(uint8_t host_idx) {}
+__attribute__((weak)) void wireless_enter_connected_kb(uint8_t host_idx) {}
+__attribute__((weak)) void wireless_enter_disconnected_kb(uint8_t host_idx) {}
+__attribute__((weak)) void wireless_enter_bluetooth_pin_code_entry_kb(void) {}
+__attribute__((weak)) void wireless_exit_bluetooth_pin_code_entry_kb(void) {}
+__attribute__((weak)) void wireless_enter_sleep_kb(void) {}
+
+/*  */
+static void wireless_hid_set_protocol(bool report_protocol) {
+    wireless_report_protocol = false;
+}
+
+uint8_t wreless_keyboard_leds(void) {
+    if (wireless_state == WT_CONNECTED) {
+        return led_state;
+    }
+
+    return 0;
+}
+
+extern keymap_config_t keymap_config;
+
+void wireless_send_keyboard(report_keyboard_t *report) {
+    if (battery_is_critical_low()) return;
+
+    if (wireless_state == WT_PARING && !pincodeEntry) return;
+
+    if (wireless_state == WT_CONNECTED || (wireless_state == WT_PARING && pincodeEntry)) {
+        if (wireless_transport.send_keyboard) {
+#ifndef DISABLE_REPORT_BUFFER
+            report_buffer_t report_buffer;
+            report_buffer.type = REPORT_TYPE_KB;
+            memcpy(&report_buffer.keyboard, report, sizeof(report_keyboard_t));
+            report_buffer_enqueue(&report_buffer);
+#else
+            wireless_transport.send_keyboard(&report->mods);
+#endif
+        }
+    } else if (wireless_state != WT_RESET) {
+        wireless_connect();
+    }
+}
+
+void wireless_send_nkro(report_nkro_t *report) {
+    if (battery_is_critical_low()) return;
+
+    if (wireless_state == WT_PARING && !pincodeEntry) return;
+
+    if (wireless_state == WT_CONNECTED || (wireless_state == WT_PARING && pincodeEntry)) {
+        if (wireless_transport.send_nkro) {
+#ifndef DISABLE_REPORT_BUFFER
+
+            report_buffer_t report_buffer;
+            report_buffer.type = REPORT_TYPE_NKRO;
+            memcpy(&report_buffer.nkro, report, sizeof(report_nkro_t));
+            report_buffer_enqueue(&report_buffer);
+
+            wireless_transport.send_nkro(&report->mods);
+#else
+            wireless_transport.send_nkro(&report->mods);
+#endif
+        }
+    } else if (wireless_state != WT_RESET) {
+        wireless_connect();
+    }
+}
+
+void wireless_send_mouse(report_mouse_t *report) {
+    if (battery_is_critical_low()) return;
+
+    if (wireless_state == WT_CONNECTED) {
+        if (wireless_transport.send_mouse) wireless_transport.send_mouse((uint8_t *)report);
+    } else if (wireless_state != WT_RESET) {
+        wireless_connect();
+    }
+}
+
+void wireless_send_system(uint16_t data) {
+    if (wireless_state == WT_CONNECTED) {
+        if (wireless_transport.send_system) wireless_transport.send_system(data);
+    } else if (wireless_state != WT_RESET) {
+        wireless_connect();
+    }
+}
+
+void wireless_send_consumer(uint16_t data) {
+    if (wireless_state == WT_CONNECTED) {
+#ifndef DISABLE_REPORT_BUFFER
+        if (report_buffer_is_empty() && report_buffer_next_inverval()) {
+            if (wireless_transport.send_consumer) wireless_transport.send_consumer(data);
+            report_buffer_update_timer();
+        } else {
+            report_buffer_t report_buffer;
+            report_buffer.type     = REPORT_TYPE_CONSUMER;
+            report_buffer.consumer = data;
+            report_buffer_enqueue(&report_buffer);
+        }
+#else
+        if (wireless_transport.send_consumer) wireless_transport.send_consumer(data);
+#endif
+    } else if (wireless_state != WT_RESET) {
+        wireless_connect();
+    }
+}
+
+void wireless_send_extra(report_extra_t *report) {
+    if (battery_is_critical_low()) return;
+
+    if (report->report_id == REPORT_ID_SYSTEM) {
+        wireless_send_system(report->usage);
+    } else if (report->report_id == REPORT_ID_CONSUMER) {
+        wireless_send_consumer(report->usage);
+    }
+}
+
+void wireless_low_battery_shutdown(void) {
+#ifdef BAT_LOW_LED_PIN
+    indicator_battery_low_enable(false);
+#endif
+#if defined(LOW_BAT_IND_INDEX)
+    indicator_battery_low_backlit_enable(false);
+#endif
+
+    report_buffer_init();
+    clear_keyboard(); //
+    wait_ms(50);      // wait a while for bt module to free buffer by sending report
+
+    // Release all keys by sending empty reports
+    if (keymap_config.nkro) {
+        report_nkro_t empty_nkro_report;
+        memset(&empty_nkro_report, 0, sizeof(empty_nkro_report));
+        wireless_transport.send_nkro(&empty_nkro_report.mods);
+    } else {
+        report_keyboard_t empty_report;
+        memset(&empty_report, 0, sizeof(empty_report));
+        wireless_transport.send_keyboard(&empty_report.mods);
+    }
+    wait_ms(10);
+    wireless_transport.send_consumer(0);
+    wait_ms(10);
+    report_mouse_t empty_mouse_report;
+    memset(&empty_mouse_report, 0, sizeof(empty_mouse_report));
+    wireless_transport.send_mouse((uint8_t *)&empty_mouse_report);
+    wait_ms(300); // Wait for bt module to send all buffered report
+
+    wireless_disconnect();
+}
+
+void wireless_event_task(void) {
+    wireless_event_t event;
+    while (wireless_event_dequeue(&event)) {
+        switch (event.evt_type) {
+            case EVT_RESET:
+                wireless_enter_reset(event.params.reason);
+                break;
+            case EVT_CONNECTED:
+                wireless_enter_connected(event.params.hostIndex);
+                break;
+            case EVT_DISCOVERABLE:
+                wireless_enter_discoverable(event.params.hostIndex);
+                break;
+            case EVT_RECONNECTING:
+                wireless_enter_reconnecting(event.params.hostIndex);
+                break;
+            case EVT_DISCONNECTED:
+                wireless_enter_disconnected(event.params.hostIndex);
+                break;
+            case EVT_BT_PINCODE_ENTRY:
+                wireless_enter_bluetooth_pin_code_entry();
+                break;
+            case EVT_EXIT_BT_PINCODE_ENTRY:
+                wireless_exit_bluetooth_pin_code_entry();
+                break;
+            case EVT_SLEEP:
+                wireless_enter_sleep();
+                break;
+            case EVT_HID_INDICATOR:
+                led_state = event.params.led;
+                break;
+            case EVT_HID_SET_PROTOCOL:
+                wireless_hid_set_protocol(event.params.protocol);
+                break;
+            case EVT_CONECTION_INTERVAL:
+                report_buffer_set_inverval(event.params.interval);
+                break;
+            default:
+                break;
+        }
+    }
+}
+
+void wireless_task(void) {
+    wireless_transport.task();
+    wireless_event_task();
+#ifndef DISABLE_REPORT_BUFFER
+    report_buffer_task();
+#endif
+    indicator_task();
+    keychron_wireless_common_task();
+    battery_task();
+    lpm_task();
+}
+
+wt_state_t wireless_get_state(void) {
+    return wireless_state;
+};
+
+bool process_record_wireless(uint16_t keycode, keyrecord_t *record) {
+    if (get_transport() & TRANSPORT_WIRELESS) {
+        lpm_timer_reset();
+
+#if defined(BAT_LOW_LED_PIN) || defined(LOW_BAT_IND_INDEX)
+        if (battery_is_empty() && wireless_get_state() == WT_CONNECTED && record->event.pressed) {
+#    if defined(BAT_LOW_LED_PIN)
+            indicator_battery_low_enable(true);
+#    endif
+#    if defined(LOW_BAT_IND_INDEX)
+            indicator_battery_low_backlit_enable(true);
+#    endif
+        }
+#endif
+    }
+
+    if (!process_record_keychron_wireless(keycode, record)) return false;
+
+    return true;
+}

keyboards/keychron/common/wireless/wireless.h

@@ -0,0 +1,101 @@
+/* Copyright 2023 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "wireless_event_type.h"
+#include "action.h"
+
+#ifdef KC_DEBUG
+#define kc_printf   dprintf
+#else
+#define kc_printf(format,...)
+#endif
+
+/* Low power mode */
+#ifndef LOW_POWER_MODE
+#    define LOW_POWER_MODE PM_STOP
+#endif
+
+/* Wake pin used for blueooth module/controller to wake up MCU in low power mode*/
+#ifndef BLUETOOTH_INT_INPUT_PIN
+#    define WAKE_PIN A5
+#endif
+
+// clang-format off
+/* Type of an enumeration of the possible wireless transport state.*/
+typedef enum {
+    WT_RESET,
+    WT_INITIALIZED,   // 1
+    WT_DISCONNECTED,  // 2
+    WT_CONNECTED,     // 3
+    WT_PARING,        // 4
+    WT_RECONNECTING,  // 5
+    WT_SUSPEND
+} wt_state_t;
+
+//extern event_listener_t wireless_driver;
+
+typedef struct {
+    void (*init)(bool);
+    void (*connect_ex)(uint8_t, uint16_t);
+    void (*pairing_ex)(uint8_t, void *);
+    void (*disconnect)(void);
+    void (*send_keyboard)(uint8_t *);
+    void (*send_nkro)(uint8_t *);
+    void (*send_consumer)(uint16_t);
+    void (*send_system)(uint16_t);
+    void (*send_mouse)(uint8_t *);
+    void (*update_bat_level)(uint8_t);
+    void (*task)(void);
+} wt_func_t;
+// clang-format on
+
+extern void register_wt_tasks(void);
+
+void wireless_init(void);
+void wireless_set_transport(wt_func_t *transport);
+void wireless(void);
+
+bool wireless_event_enqueue(wireless_event_t event);
+
+void wireless_connect(void);
+void wireless_connect_ex(uint8_t host_idx, uint16_t timeout);
+void wireless_disconnect(void);
+
+void wireless_pairing(void);
+void wireless_pairing_ex(uint8_t host_idx, void *param);
+//bool bluetooth_is_activated(void);
+
+void wireless_enter_reset_kb(uint8_t reason);
+void wireless_enter_discoverable_kb(uint8_t host_idx);
+void wireless_enter_reconnecting_kb(uint8_t host_idx);
+void wireless_enter_connected_kb(uint8_t host_idx);
+void wireless_enter_disconnected_kb(uint8_t host_idx);
+void wireless_enter_bluetooth_pin_code_entry_kb(void);
+void wireless_exit_bluetooth_pin_code_entry_kb(void);
+void wireless_enter_sleep_kb(void);
+
+void              wireless_task(void);
+void              wireless_pre_task(void);
+void              wireless_post_task(void);
+wt_state_t wireless_get_state(void);
+
+void wireless_low_battery_shutdown(void);
+
+bool process_record_wireless(uint16_t keycode, keyrecord_t *record);
+
+

keyboards/keychron/common/wireless/wireless.mk

@@ -0,0 +1,21 @@
+OPT_DEFS += -DLK_WIRELESS_ENABLE
+OPT_DEFS += -DNO_USB_STARTUP_CHECK
+OPT_DEFS += -DCORTEX_ENABLE_WFI_IDLE=TRUE
+
+WIRELESS_DIR = common/wireless
+SRC += \
+     $(WIRELESS_DIR)/wireless.c \
+     $(WIRELESS_DIR)/report_buffer.c \
+     $(WIRELESS_DIR)/lkbt51.c \
+     $(WIRELESS_DIR)/indicator.c \
+     $(WIRELESS_DIR)/wireless_main.c \
+     $(WIRELESS_DIR)/transport.c \
+     $(WIRELESS_DIR)/lpm.c \
+     $(WIRELESS_DIR)/lpm_stm32f401.c \
+     $(WIRELESS_DIR)/battery.c \
+     $(WIRELESS_DIR)/bat_level_animation.c \
+     $(WIRELESS_DIR)/rtc_timer.c \
+     $(WIRELESS_DIR)/keychron_wireless_common.c
+
+VPATH += $(TOP_DIR)/keyboards/keychron/$(WIRELESS_DIR)
+

keyboards/keychron/common/wireless/wireless_config.h

@@ -1,4 +1,4 @@
-/* Copyright 2022 @ Keychron (https://www.keychron.com)
+/* Copyright 2023 @ lokher (https://www.keychron.com)
  *
  * 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
@@ -16,15 +16,21 @@
 
 #pragma once
 
-/* We use a pin with a stronger pull resistor than the internal MCU pins */
-// #define MATRIX_UNSELECT_DRIVE_HIGH
+#include "config.h"
 
-/* RGB Matrix Configuration */
-#define RGB_MATRIX_LED_COUNT 87
+//
+#ifndef BT_HOST_DEVICES_COUNT
+#    define BT_HOST_DEVICES_COUNT 3
+#endif
 
-#define SNLED27351_CURRENT_TUNE \
-    { 0x9D, 0x9D, 0x44, 0x9D, 0x9D, 0x44, 0x9D, 0x9D, 0x44, 0x9D, 0x9D, 0x44 }
+#define P2P4G_HOST_DEVICES_COUNT 1
 
-/* Enable CapsLcok LED */
-#define CAPS_LOCK_LED_INDEX 50
+//  Uint: Second
+#ifndef DISCONNECTED_BACKLIGHT_OFF_DELAY_TIME
+#    define DISCONNECTED_BACKLIGHT_OFF_DELAY_TIME 40
+#endif
 
+//  Uint: Second, the timer restarts on key activities.
+#ifndef CONNECTED_BACKLIGHT_OFF_DELAY_TIME
+#    define CONNECTED_BACKLIGHT_OFF_DELAY_TIME 600
+#endif

keyboards/keychron/common/wireless/wireless_event_type.h

@@ -0,0 +1,44 @@
+/* Copyright 2023 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+/* Type of an enumeration of the possible wireless events.*/
+typedef enum {
+    EVT_NONE = 0,
+    EVT_RESET,
+    EVT_DISCOVERABLE,
+    EVT_RECONNECTING,
+    EVT_CONNECTED,
+    EVT_DISCONNECTED,
+    EVT_BT_PINCODE_ENTRY,
+    EVT_EXIT_BT_PINCODE_ENTRY,
+    EVT_SLEEP,
+    EVT_HID_SET_PROTOCOL,
+    EVT_HID_INDICATOR,
+    EVT_CONECTION_INTERVAL,
+} event_type_t;
+
+typedef struct {
+    event_type_t evt_type; /*The type of the event. */
+    union {
+        uint8_t reason;    /* Parameters to WT_RESET event */
+        uint8_t hostIndex; /* Parameters to connection event from EVT_DISCOVERABLE to EVT_DISCONECTED */
+        uint8_t led;       /* Parameters to EVT_HID_INDICATOR event */
+        uint8_t protocol;  /* Parameters to EVT_HID_SET_PROTOCOL event */
+        uint8_t interval;  /* Parameters to EVT_CONECTION_INTERVAL event */
+    } params;
+} wireless_event_t;

keyboards/keychron/common/wireless/wireless_main.c

@@ -0,0 +1,42 @@
+/* Copyright 2023 @ lokher (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "quantum.h"
+#include "wireless.h"
+#include "transport.h"
+#include "factory_test.h"
+#include "keychron_task.h"
+
+__attribute__((weak)) void wireless_pre_task(void) {}
+__attribute__((weak)) void wireless_post_task(void) {}
+
+bool wireless_tasks(void) {
+    wireless_pre_task();
+    wireless_task();
+    wireless_post_task();
+
+    /* usb_remote_wakeup() should be invoked last so that we have chance
+     * to switch to wireless after start-up when usb is not connected
+     */
+    if (get_transport() == TRANSPORT_USB) usb_remote_wakeup();
+    return true;
+}
+
+#ifdef KEYCHRON_CALLBACK_ENABLE
+void register_wt_tasks(void) {
+    register_keychron_task(wireless_tasks, true);
+}
+#endif

keyboards/keychron/k10_pro/ansi/rgb/config.h

@@ -0,0 +1,56 @@
+/* Copyright 2023 @ Keychron (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#ifdef RGB_MATRIX_ENABLE
+/* RGB Matrix driver configuration */
+#    define DRIVER_COUNT 2
+#    define DRIVER_ADDR_1 0b1110111
+#    define DRIVER_ADDR_2 0b1110100
+
+/* RGB Matrix configuration */
+#    define RGB_MATRIX_LED_COUNT 108
+
+/* Set to infinit, which is use in USB mode by default */
+#    define RGB_MATRIX_TIMEOUT RGB_MATRIX_TIMEOUT_INFINITE
+
+/* Allow shutdown of led driver to save power */
+#    define RGB_MATRIX_DRIVER_SHUTDOWN_ENABLE
+/* Turn off backlight on low brightness to save power */
+#    define RGB_MATRIX_BRIGHTNESS_TURN_OFF_VAL 32
+
+/* Indication led */
+#    define CAPS_LOCK_INDEX 62
+#    define NUM_LOCK_INDEX 37
+
+#    ifdef VIA_ENABLE
+#        define VIA_QMK_RGBLIGHT_ENABLE
+#    endif
+
+/* RGB Matrix Animation modes. Explicitly enabled
+ * For full list of effects, see:
+ * https://docs.qmk.fm/#/feature_rgb_matrix?id=rgb-matrix-effects
+ */
+
+#    define RGB_MATRIX_KEYPRESSES
+#    define RGB_MATRIX_FRAMEBUFFER_EFFECTS
+
+/* Set LED driver current */
+#    define SNLED27351_CURRENT_TUNE \
+        { 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30 }
+
+#endif

keyboards/keychron/k10_pro/ansi/rgb/info.json

@@ -0,0 +1,150 @@
+{
+    "usb": {
+    	"pid": "0x02A0",
+    	"device_version": "1.0.0"
+    },
+    "features": {
+        "rgb_matrix": true
+    },
+    "rgb_matrix": {
+        "driver": "snled27351",
+        "animations": {
+            "breathing": true,
+            "band_spiral_val": true,
+            "cycle_all": true,
+            "cycle_left_right": true,
+            "cycle_up_down": true,
+            "rainbow_moving_chevron": true,
+            "cycle_out_in": true,
+            "cycle_out_in_dual": true,
+            "cycle_pinwheel": true,
+            "cycle_spiral": true,
+            "dual_beacon": true,
+            "rainbow_beacon": true,
+            "jellybean_raindrops": true,
+            "pixel_rain": true,
+            "typing_heatmap": true,
+            "digital_rain": true,
+            "solid_reactive_simple": true,
+            "solid_reactive_multiwide": true,
+            "solid_reactive_multinexus": true,
+            "splash": true,
+            "solid_splash": true
+        },
+        "layout": [
+            {"matrix":[0,0],  "flags":1, "x":0,   "y":0},
+            {"matrix":[0,1],  "flags":1, "x":20,  "y":0},
+            {"matrix":[0,2],  "flags":1, "x":31,  "y":0},
+            {"matrix":[0,3],  "flags":1, "x":42,  "y":0},
+            {"matrix":[0,4],  "flags":1, "x":52,  "y":0},
+            {"matrix":[0,5],  "flags":1, "x":67,  "y":0},
+            {"matrix":[0,6],  "flags":1, "x":78,  "y":0},
+            {"matrix":[0,7],  "flags":1, "x":88,  "y":0},
+            {"matrix":[0,8],  "flags":1, "x":98,  "y":0},
+            {"matrix":[0,9],  "flags":1, "x":114, "y":0},
+            {"matrix":[0,10], "flags":1, "x":125, "y":0},
+            {"matrix":[0,11], "flags":1, "x":135, "y":0},
+            {"matrix":[0,12], "flags":1, "x":145, "y":0},
+            {"matrix":[0,14], "flags":1, "x":158, "y":0},
+            {"matrix":[0,15], "flags":1, "x":169, "y":0},
+            {"matrix":[0,16], "flags":1, "x":179, "y":0},
+            {"matrix":[0,17], "flags":4, "x":192, "y":0},
+            {"matrix":[0,18], "flags":4, "x":203, "y":0},
+            {"matrix":[0,19], "flags":4, "x":213, "y":0},
+            {"matrix":[0,20], "flags":4, "x":224, "y":0},
+
+            {"matrix":[1,0],  "flags":1, "x":0,   "y":15},
+            {"matrix":[1,1],  "flags":8, "x":10,  "y":15},
+            {"matrix":[1,2],  "flags":8, "x":20,  "y":15},
+            {"matrix":[1,3],  "flags":8, "x":31,  "y":15},
+            {"matrix":[1,4],  "flags":4, "x":41,  "y":15},
+            {"matrix":[1,5],  "flags":4, "x":52,  "y":15},
+            {"matrix":[1,6],  "flags":4, "x":62,  "y":15},
+            {"matrix":[1,7],  "flags":4, "x":72,  "y":15},
+            {"matrix":[1,8],  "flags":4, "x":83,  "y":15},
+            {"matrix":[1,9],  "flags":4, "x":93,  "y":15},
+            {"matrix":[1,10], "flags":4, "x":104, "y":15},
+            {"matrix":[1,11], "flags":4, "x":114, "y":15},
+            {"matrix":[1,12], "flags":4, "x":124, "y":15},
+            {"matrix":[1,13], "flags":1, "x":140, "y":15},
+            {"matrix":[1,14], "flags":1, "x":158, "y":15},
+            {"matrix":[1,15], "flags":1, "x":169, "y":15},
+            {"matrix":[1,16], "flags":1, "x":180, "y":15},
+            {"matrix":[1,17], "flags":8, "x":192, "y":15},
+            {"matrix":[1,18], "flags":4, "x":203, "y":15},
+            {"matrix":[1,19], "flags":4, "x":213, "y":15},
+            {"matrix":[1,20], "flags":4, "x":224, "y":15},
+
+            {"matrix":[2,0],  "flags":1, "x":2,   "y":28},
+            {"matrix":[2,1],  "flags":4, "x":15,  "y":28},
+            {"matrix":[2,2],  "flags":4, "x":26,  "y":28},
+            {"matrix":[2,3],  "flags":4, "x":36,  "y":28},
+            {"matrix":[2,4],  "flags":4, "x":46,  "y":28},
+            {"matrix":[2,5],  "flags":4, "x":57,  "y":28},
+            {"matrix":[2,6],  "flags":4, "x":67,  "y":28},
+            {"matrix":[2,7],  "flags":4, "x":78,  "y":28},
+            {"matrix":[2,8],  "flags":4, "x":88,  "y":28},
+            {"matrix":[2,9],  "flags":4, "x":98,  "y":28},
+            {"matrix":[2,10], "flags":4, "x":109, "y":28},
+            {"matrix":[2,11], "flags":4, "x":119, "y":28},
+            {"matrix":[2,12], "flags":4, "x":130, "y":28},
+            {"matrix":[2,13], "flags":1, "x":143, "y":28},
+            {"matrix":[2,14], "flags":1, "x":158, "y":28},
+            {"matrix":[2,15], "flags":1, "x":169, "y":28},
+            {"matrix":[2,16], "flags":1, "x":179, "y":28},
+            {"matrix":[2,17], "flags":4, "x":192, "y":28},
+            {"matrix":[2,18], "flags":4, "x":203, "y":28},
+            {"matrix":[2,19], "flags":4, "x":213, "y":28},
+            {"matrix":[2,20], "flags":4, "x":224, "y":28},
+
+            {"matrix":[3,0],  "flags":8, "x":3,   "y":39},
+            {"matrix":[3,1],  "flags":4, "x":18,  "y":39},
+            {"matrix":[3,2],  "flags":4, "x":28,  "y":39},
+            {"matrix":[3,3],  "flags":4, "x":39,  "y":39},
+            {"matrix":[3,4],  "flags":4, "x":49,  "y":39},
+            {"matrix":[3,5],  "flags":4, "x":59,  "y":39},
+            {"matrix":[3,6],  "flags":4, "x":70,  "y":39},
+            {"matrix":[3,7],  "flags":4, "x":80,  "y":39},
+            {"matrix":[3,8],  "flags":4, "x":91,  "y":39},
+            {"matrix":[3,9],  "flags":4, "x":101, "y":39},
+            {"matrix":[3,10], "flags":4, "x":111, "y":39},
+            {"matrix":[3,11], "flags":4, "x":122, "y":39},
+            {"matrix":[3,13], "flags":4, "x":139, "y":39},
+            {"matrix":[3,17], "flags":4, "x":192, "y":39},
+            {"matrix":[3,18], "flags":4, "x":203, "y":39},
+            {"matrix":[3,19], "flags":4, "x":213, "y":39},
+
+            {"matrix":[4,0],  "flags":1, "x":6,   "y":52},
+            {"matrix":[4,2],  "flags":4, "x":23,  "y":52},
+            {"matrix":[4,3],  "flags":4, "x":33,  "y":52},
+            {"matrix":[4,4],  "flags":4, "x":44,  "y":52},
+            {"matrix":[4,5],  "flags":4, "x":54,  "y":52},
+            {"matrix":[4,6],  "flags":4, "x":65,  "y":52},
+            {"matrix":[4,7],  "flags":4, "x":75,  "y":52},
+            {"matrix":[4,8],  "flags":4, "x":85,  "y":52},
+            {"matrix":[4,9],  "flags":4, "x":96,  "y":52},
+            {"matrix":[4,10], "flags":4, "x":106, "y":52},
+            {"matrix":[4,11], "flags":4, "x":117, "y":52},
+            {"matrix":[4,13], "flags":1, "x":136, "y":52},
+            {"matrix":[4,15], "flags":1, "x":169, "y":52},
+            {"matrix":[4,17], "flags":4, "x":192, "y":52},
+            {"matrix":[4,18], "flags":4, "x":203, "y":52},
+            {"matrix":[4,19], "flags":4, "x":213, "y":52},
+            {"matrix":[4,20], "flags":4, "x":224, "y":58},
+
+            {"matrix":[5,0],  "flags":1, "x":1,   "y":64},
+            {"matrix":[5,1],  "flags":1, "x":14,  "y":64},
+            {"matrix":[5,2],  "flags":1, "x":27,  "y":64},
+            {"matrix":[5,6],  "flags":4, "x":66,  "y":64},
+            {"matrix":[5,10], "flags":1, "x":105, "y":64},
+            {"matrix":[5,11], "flags":1, "x":118, "y":64},
+            {"matrix":[5,12], "flags":1, "x":131, "y":64},
+            {"matrix":[5,13], "flags":1, "x":144, "y":64},
+            {"matrix":[5,14], "flags":1, "x":158, "y":64},
+            {"matrix":[5,15], "flags":1, "x":169, "y":64},
+            {"matrix":[5,16], "flags":1, "x":179, "y":64},
+            {"matrix":[5,17], "flags":4, "x":197, "y":64},
+            {"matrix":[5,19], "flags":4, "x":213, "y":64}
+        ]
+    }
+}

keyboards/keychron/k10_pro/ansi/rgb/keymaps/default/keymap.c

@@ -15,60 +15,42 @@
  */
 
 #include QMK_KEYBOARD_H
-#include "keychron_common.h"
 
-// clang-format off
-
-enum layers{
+enum layers {
     MAC_BASE,
     MAC_FN,
     WIN_BASE,
-    WIN_FN
+    WIN_FN,
 };
 
+// clang-format off
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-    [MAC_BASE] = LAYOUT(
-        KC_ESC,             KC_BRID,  KC_BRIU,  KC_MCTL,  KC_LPAD,  RGB_VAD,  RGB_VAI,  KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_MUTE,  KC_VOLD,    KC_VOLU,  KC_SNAP,  KC_SIRI,  RGB_MOD,
+    [MAC_BASE] = LAYOUT_ansi_108(
+        KC_ESC,             KC_BRID,  KC_BRIU,  KC_MCTL,  KC_LPAD,  RGB_VAD,  RGB_VAI,  KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_MUTE,  KC_VOLD,    KC_VOLU,  KC_SNAP,  KC_SIRI,  RGB_MOD,  KC_F13,   KC_F14,   KC_F15,   KC_F16,
         KC_GRV,   KC_1,     KC_2,     KC_3,     KC_4,     KC_5,     KC_6,     KC_7,     KC_8,     KC_9,     KC_0,     KC_MINS,  KC_EQL,     KC_BSPC,  KC_INS,   KC_HOME,  KC_PGUP,  KC_NUM,   KC_PSLS,  KC_PAST,  KC_PMNS,
         KC_TAB,   KC_Q,     KC_W,     KC_E,     KC_R,     KC_T,     KC_Y,     KC_U,     KC_I,     KC_O,     KC_P,     KC_LBRC,  KC_RBRC,    KC_BSLS,  KC_DEL,   KC_END,   KC_PGDN,  KC_P7,    KC_P8,    KC_P9,    KC_PPLS,
         KC_CAPS,  KC_A,     KC_S,     KC_D,     KC_F,     KC_G,     KC_H,     KC_J,     KC_K,     KC_L,     KC_SCLN,  KC_QUOT,              KC_ENT,                                 KC_P4,    KC_P5,    KC_P6,
         KC_LSFT,            KC_Z,     KC_X,     KC_C,     KC_V,     KC_B,     KC_N,     KC_M,     KC_COMM,  KC_DOT,   KC_SLSH,              KC_RSFT,            KC_UP,              KC_P1,    KC_P2,    KC_P3,    KC_PENT,
-        KC_LCTL,  KC_LOPTN, KC_LCMMD,                               KC_SPC,                                 KC_RCMMD, KC_ROPTN, MO(MAC_FN), KC_RCTL,  KC_LEFT,  KC_DOWN,  KC_RGHT,  KC_P0,              KC_PDOT         ),
-
-    [MAC_FN] = LAYOUT(
-        _______,            KC_F1,    KC_F2,    KC_F3,    KC_F4,    KC_F5,    KC_F6,    KC_F7,    KC_F8,    KC_F9,    KC_F10,   KC_F11,     KC_F12,   _______,  _______,  RGB_TOG,
-        _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,
+        KC_LCTL,  KC_LOPTN, KC_LCMMD,                               KC_SPC,                                 KC_RCMMD, KC_ROPTN, MO(MAC_FN), KC_RCTL,  KC_LEFT,  KC_DOWN,  KC_RGHT,  KC_P0,              KC_PDOT          ),
+    [MAC_FN] = LAYOUT_ansi_108(
+        _______,            KC_F1,    KC_F2,    KC_F3,    KC_F4,    KC_F5,    KC_F6,    KC_F7,    KC_F8,    KC_F9,    KC_F10,   KC_F11,     KC_F12,   _______,  _______,  RGB_TOG,  _______,  _______,  _______,  _______,
+        _______,  BT_HST1,  BT_HST2,  BT_HST3,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,
         RGB_TOG,  RGB_MOD,  RGB_VAI,  RGB_HUI,  RGB_SAI,  RGB_SPI,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,
         _______,  RGB_RMOD, RGB_VAD,  RGB_HUD,  RGB_SAD,  RGB_SPD,  _______,  _______,  _______,  _______,  _______,  _______,              _______,                                _______,  _______,  _______,
-        _______,            _______,  _______,  _______,  _______,  _______,  NK_TOGG,  _______,  _______,  _______,  _______,              _______,            _______,            _______,  _______,  _______,  _______,
-        _______,  _______,  _______,                                _______,                                _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,            _______         ),
-
-    [WIN_BASE] = LAYOUT(
-        KC_ESC,             KC_F1,    KC_F2,    KC_F3,    KC_F4,    KC_F5,    KC_F6,    KC_F7,    KC_F8,    KC_F9,    KC_F10,   KC_F11,     KC_F12,   KC_PSCR,  KC_CRTA,  RGB_MOD,
+        _______,            _______,  _______,  _______,  _______,  BAT_LVL,  NK_TOGG,  _______,  _______,  _______,  _______,              _______,            _______,            _______,  _______,  _______,  _______,
+        _______,  _______,  _______,                                _______,                                _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,            _______          ),
+    [WIN_BASE] = LAYOUT_ansi_108(
+        KC_ESC,             KC_F1,    KC_F2,    KC_F3,    KC_F4,    KC_F5,    KC_F6,    KC_F7,    KC_F8,    KC_F9,    KC_F10,   KC_F11,     KC_F12,   KC_PSCR,  KC_CTANA, RGB_MOD,  _______,  _______,  _______,  _______,
         KC_GRV,   KC_1,     KC_2,     KC_3,     KC_4,     KC_5,     KC_6,     KC_7,     KC_8,     KC_9,     KC_0,     KC_MINS,  KC_EQL,     KC_BSPC,  KC_INS,   KC_HOME,  KC_PGUP,  KC_NUM,   KC_PSLS,  KC_PAST,  KC_PMNS,
         KC_TAB,   KC_Q,     KC_W,     KC_E,     KC_R,     KC_T,     KC_Y,     KC_U,     KC_I,     KC_O,     KC_P,     KC_LBRC,  KC_RBRC,    KC_BSLS,  KC_DEL,   KC_END,   KC_PGDN,  KC_P7,    KC_P8,    KC_P9,    KC_PPLS,
         KC_CAPS,  KC_A,     KC_S,     KC_D,     KC_F,     KC_G,     KC_H,     KC_J,     KC_K,     KC_L,     KC_SCLN,  KC_QUOT,              KC_ENT,                                 KC_P4,    KC_P5,    KC_P6,
         KC_LSFT,            KC_Z,     KC_X,     KC_C,     KC_V,     KC_B,     KC_N,     KC_M,     KC_COMM,  KC_DOT,   KC_SLSH,              KC_RSFT,            KC_UP,              KC_P1,    KC_P2,    KC_P3,    KC_PENT,
         KC_LCTL,  KC_LWIN,  KC_LALT,                                KC_SPC,                                 KC_RALT,  KC_RWIN,  MO(WIN_FN), KC_RCTL,  KC_LEFT,  KC_DOWN,  KC_RGHT,  KC_P0,              KC_PDOT         ),
-
-    [WIN_FN] = LAYOUT(
-        _______,            KC_BRID,  KC_BRIU,  KC_TASK,  KC_FLXP,  RGB_VAD,  RGB_VAI,  KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_MUTE,  KC_VOLD,    KC_VOLU,  _______,  _______,  RGB_TOG,
-        _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,
+    [WIN_FN] = LAYOUT_ansi_108(
+        _______,              KC_BRID,  KC_BRIU,  KC_TASK,  KC_FILE,  RGB_VAD,  RGB_VAI,  KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_MUTE,  KC_VOLD,    KC_VOLU,  _______,  _______,  RGB_TOG,  _______,  _______,  _______,  _______,
+        _______,  BT_HST1,  BT_HST2,  BT_HST3,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,
         RGB_TOG,  RGB_MOD,  RGB_VAI,  RGB_HUI,  RGB_SAI,  RGB_SPI,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,
         _______,  RGB_RMOD, RGB_VAD,  RGB_HUD,  RGB_SAD,  RGB_SPD,  _______,  _______,  _______,  _______,  _______,  _______,              _______,                                _______,  _______,  _______,
-        _______,            _______,  _______,  _______,  _______,  _______,  NK_TOGG,  _______,  _______,  _______,  _______,              _______,            _______,            _______,  _______,  _______,  _______,
-        _______,  _______,  _______,                                _______,                                _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,            _______         ),
+        _______,            _______,  _______,  _______,  _______,  BAT_LVL,  NK_TOGG,  _______,  _______,  _______,  _______,              _______,            _______,            _______,  _______,  _______,  _______,
+        _______,  _______,  _______,                                _______,                                _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,            _______          )
 };
-
-// clang-format on
-
-void housekeeping_task_user(void) {
-    housekeeping_task_keychron();
-}
-
-bool process_record_user(uint16_t keycode, keyrecord_t *record) {
-    if (!process_record_keychron(keycode, record)) {
-        return false;
-    }
-    return true;
-}

keyboards/keychron/k10_pro/ansi/rgb/keymaps/via/keymap.c

@@ -15,57 +15,43 @@
  */
 
 #include QMK_KEYBOARD_H
-#include "keychron_common.h"
+
+enum layers {
+    MAC_BASE,
+    MAC_FN,
+    WIN_BASE,
+    WIN_FN,
+};
 
 // clang-format off
-
-enum layers{
-  MAC_BASE,
-  MAC_FN,
-  WIN_BASE,
-  WIN_FN
-};
-
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     [MAC_BASE] = LAYOUT_ansi_108(
-        KC_ESC,             KC_BRID,  KC_BRIU,  KC_MCTL,  KC_LPAD,  RGB_VAD,  RGB_VAI,  KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_MUTE,  KC_VOLD,    KC_VOLU,  KC_SNAP,  KC_SIRI,  RGB_MOD,  KC_F13,   KC_F14,   KC_F15,   KC_F16,
+        KC_ESC,             KC_BRID,  KC_BRIU,  KC_MICT,  KC_LAPA,  RGB_VAD,  RGB_VAI,  KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_MUTE,  KC_VOLD,    KC_VOLU,  KC_SNAP,  KC_SIRI,  RGB_MOD,  KC_F13,   KC_F14,   KC_F15,   KC_F16,
         KC_GRV,   KC_1,     KC_2,     KC_3,     KC_4,     KC_5,     KC_6,     KC_7,     KC_8,     KC_9,     KC_0,     KC_MINS,  KC_EQL,     KC_BSPC,  KC_INS,   KC_HOME,  KC_PGUP,  KC_NUM,   KC_PSLS,  KC_PAST,  KC_PMNS,
-        KC_TAB,   KC_Q,     KC_W,     KC_E,     KC_R,     KC_T,     KC_Y,     KC_U,     KC_I,     KC_O,     KC_P,     KC_LBRC,  KC_RBRC,    KC_BSLS,  KC_DEL,   KC_END,   KC_PGDN,  KC_P7,    KC_P8,    KC_P9,
-        KC_CAPS,  KC_A,     KC_S,     KC_D,     KC_F,     KC_G,     KC_H,     KC_J,     KC_K,     KC_L,     KC_SCLN,  KC_QUOT,              KC_ENT,                                 KC_P4,    KC_P5,    KC_P6,    KC_PPLS,
-        KC_LSFT,            KC_Z,     KC_X,     KC_C,     KC_V,     KC_B,     KC_N,     KC_M,     KC_COMM,  KC_DOT,   KC_SLSH,              KC_RSFT,            KC_UP,              KC_P1,    KC_P2,    KC_P3,
-        KC_LCTL,  KC_LOPTN, KC_LCMMD,                               KC_SPC,                                 KC_RCMMD, KC_ROPTN, MO(MAC_FN), KC_RCTL,  KC_LEFT,  KC_DOWN,  KC_RGHT,  KC_P0,              KC_PDOT,  KC_PENT),
+        KC_TAB,   KC_Q,     KC_W,     KC_E,     KC_R,     KC_T,     KC_Y,     KC_U,     KC_I,     KC_O,     KC_P,     KC_LBRC,  KC_RBRC,    KC_BSLS,  KC_DEL,   KC_END,   KC_PGDN,  KC_P7,    KC_P8,    KC_P9,    KC_PPLS,
+        KC_CAPS,  KC_A,     KC_S,     KC_D,     KC_F,     KC_G,     KC_H,     KC_J,     KC_K,     KC_L,     KC_SCLN,  KC_QUOT,              KC_ENT,                                 KC_P4,    KC_P5,    KC_P6,
+        KC_LSFT,            KC_Z,     KC_X,     KC_C,     KC_V,     KC_B,     KC_N,     KC_M,     KC_COMM,  KC_DOT,   KC_SLSH,              KC_RSFT,            KC_UP,              KC_P1,    KC_P2,    KC_P3,    KC_PENT,
+        KC_LCTL,  KC_LOPTN, KC_LCMMD,                               KC_SPC,                                 KC_RCMMD, KC_ROPTN, MO(MAC_FN), KC_RCTL,  KC_LEFT,  KC_DOWN,  KC_RGHT,  KC_P0,              KC_PDOT          ),
     [MAC_FN] = LAYOUT_ansi_108(
         _______,            KC_F1,    KC_F2,    KC_F3,    KC_F4,    KC_F5,    KC_F6,    KC_F7,    KC_F8,    KC_F9,    KC_F10,   KC_F11,     KC_F12,   _______,  _______,  RGB_TOG,  _______,  _______,  _______,  _______,
-        _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,
-        RGB_TOG,  RGB_MOD,  RGB_VAI,  RGB_HUI,  RGB_SAI,  RGB_SPI,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,
-        _______,  RGB_RMOD, RGB_VAD,  RGB_HUD,  RGB_SAD,  RGB_SPD,  _______,  _______,  _______,  _______,  _______,  _______,              _______,                                _______,  _______,  _______,  _______,
-        _______,            _______,  _______,  _______,  _______,  _______,  NK_TOGG,  _______,  _______,  _______,  _______,              _______,            _______,            _______,  _______,  _______,
-        _______,  _______,  _______,                                _______,                                _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,            _______,  _______),
+        _______,  BT_HST1,  BT_HST2,  BT_HST3,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,
+        RGB_TOG,  RGB_MOD,  RGB_VAI,  RGB_HUI,  RGB_SAI,  RGB_SPI,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,
+        _______,  RGB_RMOD, RGB_VAD,  RGB_HUD,  RGB_SAD,  RGB_SPD,  _______,  _______,  _______,  _______,  _______,  _______,              _______,                                _______,  _______,  _______,
+        _______,            _______,  _______,  _______,  _______,  BAT_LVL,  NK_TOGG,  _______,  _______,  _______,  _______,              _______,            _______,            _______,  _______,  _______,  _______,
+        _______,  _______,  _______,                                _______,                                _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,            _______          ),
     [WIN_BASE] = LAYOUT_ansi_108(
-        KC_ESC,             KC_F1,    KC_F2,    KC_F3,    KC_F4,    KC_F5,    KC_F6,    KC_F7,    KC_F8,    KC_F9,    KC_F10,   KC_F11,     KC_F12,   KC_PSCR,  KC_CRTA,  RGB_MOD,  _______,  _______,  _______,  _______,
+        KC_ESC,             KC_F1,    KC_F2,    KC_F3,    KC_F4,    KC_F5,    KC_F6,    KC_F7,    KC_F8,    KC_F9,    KC_F10,   KC_F11,     KC_F12,   KC_PSCR,  KC_CTANA, RGB_MOD,  _______,  _______,  _______,  _______,
         KC_GRV,   KC_1,     KC_2,     KC_3,     KC_4,     KC_5,     KC_6,     KC_7,     KC_8,     KC_9,     KC_0,     KC_MINS,  KC_EQL,     KC_BSPC,  KC_INS,   KC_HOME,  KC_PGUP,  KC_NUM,   KC_PSLS,  KC_PAST,  KC_PMNS,
-        KC_TAB,   KC_Q,     KC_W,     KC_E,     KC_R,     KC_T,     KC_Y,     KC_U,     KC_I,     KC_O,     KC_P,     KC_LBRC,  KC_RBRC,    KC_BSLS,  KC_DEL,   KC_END,   KC_PGDN,  KC_P7,    KC_P8,    KC_P9,
-        KC_CAPS,  KC_A,     KC_S,     KC_D,     KC_F,     KC_G,     KC_H,     KC_J,     KC_K,     KC_L,     KC_SCLN,  KC_QUOT,              KC_ENT,                                 KC_P4,    KC_P5,    KC_P6,    KC_PPLS,
-        KC_LSFT,            KC_Z,     KC_X,     KC_C,     KC_V,     KC_B,     KC_N,     KC_M,     KC_COMM,  KC_DOT,   KC_SLSH,              KC_RSFT,            KC_UP,              KC_P1,    KC_P2,    KC_P3,
-        KC_LCTL,  KC_LWIN,  KC_LALT,                                KC_SPC,                                 KC_RALT,  KC_RWIN,  MO(WIN_FN), KC_RCTL,  KC_LEFT,  KC_DOWN,  KC_RGHT,  KC_P0,              KC_PDOT,  KC_PENT),
+        KC_TAB,   KC_Q,     KC_W,     KC_E,     KC_R,     KC_T,     KC_Y,     KC_U,     KC_I,     KC_O,     KC_P,     KC_LBRC,  KC_RBRC,    KC_BSLS,  KC_DEL,   KC_END,   KC_PGDN,  KC_P7,    KC_P8,    KC_P9,    KC_PPLS,
+        KC_CAPS,  KC_A,     KC_S,     KC_D,     KC_F,     KC_G,     KC_H,     KC_J,     KC_K,     KC_L,     KC_SCLN,  KC_QUOT,              KC_ENT,                                 KC_P4,    KC_P5,    KC_P6,
+        KC_LSFT,            KC_Z,     KC_X,     KC_C,     KC_V,     KC_B,     KC_N,     KC_M,     KC_COMM,  KC_DOT,   KC_SLSH,              KC_RSFT,            KC_UP,              KC_P1,    KC_P2,    KC_P3,    KC_PENT,
+        KC_LCTL,  KC_LWIN,  KC_LALT,                                KC_SPC,                                 KC_RALT,  KC_RWIN,  MO(WIN_FN), KC_RCTL,  KC_LEFT,  KC_DOWN,  KC_RGHT,  KC_P0,              KC_PDOT         ),
     [WIN_FN] = LAYOUT_ansi_108(
-        _______,            KC_BRID,  KC_BRIU,  KC_TASK,  KC_FLXP,  RGB_VAD,  RGB_VAI,  KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_MUTE,  KC_VOLD,    KC_VOLU,  _______,  _______,  RGB_TOG,  _______,  _______,  _______,  _______,
-        _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,
-        RGB_TOG,  RGB_MOD,  RGB_VAI,  RGB_HUI,  RGB_SAI,  RGB_SPI,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,
-        _______,  RGB_RMOD, RGB_VAD,  RGB_HUD,  RGB_SAD,  RGB_SPD,  _______,  _______,  _______,  _______,  _______,  _______,              _______,                                _______,  _______,  _______,  _______,
-        _______,            _______,  _______,  _______,  _______,  _______,  NK_TOGG,  _______,  _______,  _______,  _______,              _______,            _______,            _______,  _______,  _______,
-        _______,  _______,  _______,                                _______,                                _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,            _______,  _______),
+        _______,              KC_BRID,  KC_BRIU,  KC_TASK,  KC_FILE,  RGB_VAD,  RGB_VAI,  KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_MUTE,  KC_VOLD,    KC_VOLU,  _______,  _______,  RGB_TOG,  _______,  _______,  _______,  _______,
+        _______,  BT_HST1,  BT_HST2,  BT_HST3,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,
+        RGB_TOG,  RGB_MOD,  RGB_VAI,  RGB_HUI,  RGB_SAI,  RGB_SPI,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,
+        _______,  RGB_RMOD, RGB_VAD,  RGB_HUD,  RGB_SAD,  RGB_SPD,  _______,  _______,  _______,  _______,  _______,  _______,              _______,                                _______,  _______,  _______,
+        _______,            _______,  _______,  _______,  _______,  BAT_LVL,  NK_TOGG,  _______,  _______,  _______,  _______,              _______,            _______,            _______,  _______,  _______,  _______,
+        _______,  _______,  _______,                                _______,                                _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,            _______          )
 };
 
-// clang-format on
-
-bool process_record_user(uint16_t keycode, keyrecord_t *record) {
-    if (!process_record_keychron(keycode, record)) {
-        return false;
-    }
-    return true;
-}
-
-void housekeeping_task_user(void) {
-    housekeeping_task_keychron();
-}

keyboards/keychron/k10_pro/ansi/rgb/rgb.c

@@ -0,0 +1,171 @@
+/* Copyright 2021 @ Keychron (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "quantum.h"
+
+// clang-format off
+#ifdef RGB_MATRIX_ENABLE
+const snled27351_led_t g_snled27351_leds[RGB_MATRIX_LED_COUNT] = {
+/* Refer to CKLED manual for these locations
+ *   driver
+ *   |  R location
+ *   |  |       G location
+ *   |  |       |       B location
+ *   |  |       |       | */
+   {0, I_1,     G_1,    H_1},
+   {0, I_2,     G_2,    H_2},
+   {0, I_3,     G_3,    H_3},
+   {0, I_4,     G_4,    H_4},
+   {0, I_5,     G_5,    H_5},
+   {0, I_6,     G_6,    H_6},
+   {0, I_7,     G_7,    H_7},
+   {0, I_8,     G_8,    H_8},
+   {0, I_9,     G_9,    H_9},
+   {0, I_10,    G_10,   H_10},
+   {0, I_11,    G_11,   H_11},
+   {0, I_12,    G_12,   H_12},
+   {0, I_13,    G_13,   H_13},
+   {0, I_15,    G_15,   H_15},
+   {0, I_16,    G_16,   H_16},
+   {0, L_5,     J_5,    K_5},
+   {0, L_6,     J_6,    K_6},
+   {0, L_7,     J_7,    K_7},
+   {0, L_8,     J_8,    K_8},
+   {0, L_4,     J_4,    K_4},
+
+   {0, C_1,     A_1,    B_1},
+   {0, C_2,     A_2,    B_2},
+   {0, C_3,     A_3,    B_3},
+   {0, C_4,     A_4,    B_4},
+   {0, C_5,     A_5,    B_5},
+   {0, C_6,     A_6,    B_6},
+   {0, C_7,     A_7,    B_7},
+   {0, C_8,     A_8,    B_8},
+   {0, C_9,     A_9,    B_9},
+   {0, C_10,    A_10,   B_10},
+   {0, C_11,    A_11,   B_11},
+   {0, C_12,    A_12,   B_12},
+   {0, C_13,    A_13,   B_13},
+   {0, C_14,    A_14,   B_14},
+   {0, C_15,    A_15,   B_15},
+   {0, C_16,    A_16,   B_16},
+   {0, L_9,     J_9,    K_9},
+   {0, L_10,    J_10,   K_10},
+   {0, L_11,    J_11,   K_11},
+   {0, L_12,    J_12,   K_12},
+   {0, L_13,    J_13,   K_13},
+
+   {0, F_1,     D_1,    E_1},
+   {0, F_2,     D_2,    E_2},
+   {0, F_3,     D_3,    E_3},
+   {0, F_4,     D_4,    E_4},
+   {0, F_5,     D_5,    E_5},
+   {0, F_6,     D_6,    E_6},
+   {0, F_7,     D_7,    E_7},
+   {0, F_8,     D_8,    E_8},
+   {0, F_9,     D_9,    E_9},
+   {0, F_10,    D_10,   E_10},
+   {0, F_11,    D_11,   E_11},
+   {0, F_12,    D_12,   E_12},
+   {0, F_13,    D_13,   E_13},
+   {0, F_14,    D_14,   E_14},
+   {0, F_15,    D_15,   E_15},
+   {0, F_16,    D_16,   E_16},
+   {0, L_14,    J_14,   K_14},
+   {0, L_15,    J_15,   K_15},
+   {0, L_16,    J_16,   K_16},
+   {1, F_1,     D_1,    E_1},
+   {1, F_2,     D_2,    E_2},
+
+   {1, C_16,    A_16,   B_16},
+   {1, C_15,    A_15,   B_15},
+   {1, C_14,    A_14,   B_14},
+   {1, C_13,    A_13,   B_13},
+   {1, C_12,    A_12,   B_12},
+   {1, C_11,    A_11,   B_11},
+   {1, C_10,    A_10,   B_10},
+   {1, C_9,     A_9,    B_9},
+   {1, C_8,     A_8,    B_8},
+   {1, C_7,     A_7,    B_7},
+   {1, C_6,     A_6,    B_6},
+   {1, C_5,     A_5,    B_5},
+   {1, C_3,     A_3,    B_3},
+   {1, F_3,     D_3,    E_3},
+   {1, F_4,     D_4,    E_4},
+   {1, F_5,     D_5,    E_5},
+
+   {1, I_16,    G_16,   H_16},
+   {1, I_14,    G_14,   H_14},
+   {1, I_13,    G_13,   H_13},
+   {1, I_12,    G_12,   H_12},
+   {1, I_11,    G_11,   H_11},
+   {1, I_10,    G_10,   H_10},
+   {1, I_9,     G_9,    H_9},
+   {1, I_8,     G_8,    H_8},
+   {1, I_7,     G_7,    H_7},
+   {1, I_6,     G_6,    H_6},
+   {1, I_5,     G_5,    H_5},
+   {1, I_3,     G_3,    H_3},
+   {1, I_1,     G_1,    H_1},
+   {1, F_6,     D_6,    E_6},
+   {1, F_7,     D_7,    E_7},
+   {1, F_8,     D_8,    E_8},
+   {1, F_9,     D_9,    E_9},
+
+   {1, L_16,    J_16,   K_16},
+   {1, L_15,    J_15,   K_15},
+   {1, L_14,    J_14,   K_14},
+   {1, L_10,    J_10,   K_10},
+   {1, L_6,     J_6,    K_6},
+   {1, L_5,     J_5,    K_5},
+   {1, L_4,     J_4,    K_4},
+   {1, L_3,     J_3,    K_3},
+   {1, L_2,     J_2,    K_2},
+   {1, L_1,     J_1,    K_1},
+   {1, F_10,    D_10,   E_10},
+   {1, F_11,    D_11,   E_11},
+   {1, F_12,    D_12,   E_12},
+};
+
+led_config_t g_led_config = {
+	{
+		{ 0,      1,      2,      3,      4,      5,      6,      7,      8,      9,      10,     11,     12,     NO_LED, 13,     14,     15,     16,     17,     18,     19 },
+        { 20,     21,     22,     23,     24,     25,     26,     27,     28,     29,     30,     31,     32,     33,     34,     35,     36,     37,     38,     39,     40 },
+        { 41,     42,     43,     44,     45,     46,     47,     48,     49,     50,     51,     52,     53,     54,     55,     56,     57,     58,     59,     60,     61 },
+        { 62,     63,     64,     65,     66,     67,     68,     69,     70,     71,     72,     73,     NO_LED, 74,     NO_LED, NO_LED, NO_LED, 75,     76,     77,     NO_LED },
+        { 78,     NO_LED, 79,     80,     81,     82,     83,     84,     85,     86,     87,     88,     NO_LED, 89,     NO_LED, 90,     NO_LED, 91,     92,     93,     94 },
+        { 95,     96,     97,     NO_LED, NO_LED, NO_LED, 98,     NO_LED, NO_LED, NO_LED, 99,     100,    101,    102,    103,    104,    105,    106,    NO_LED, 107,    NO_LED }
+    },
+    {
+        {0, 0}, {20, 0}, {31, 0}, {41, 0}, {52, 0}, {67, 0}, {78, 0}, {88, 0}, {98, 0}, {114,  0}, {124,  0}, {135,  0}, {145,  0},            {158,  0}, {169,  0}, {179,  0}, {192,  0}, {203,  0}, {213,  0}, {224,  0},
+        {0,15}, {10,15}, {20,15}, {31,15}, {41,15}, {52,15}, {62,15}, {72,15}, {83,15}, { 93, 15}, {104, 15}, {114, 15}, {124, 15}, {140, 15}, {158, 15}, {169, 15}, {179, 15}, {192, 15}, {203, 15}, {213, 15}, {224, 15},
+        {2,28}, {15,28}, {26,28}, {36,28}, {46,28}, {57,28}, {67,28}, {78,28}, {88,28}, { 98, 28}, {109, 28}, {119, 28}, {130, 28}, {143, 28}, {158, 28}, {169, 28}, {179, 28}, {192, 28}, {203, 28}, {213, 28}, {224, 28},
+        {3,39}, {18,39}, {28,39}, {39,39}, {49,39}, {59,39}, {70,39}, {80,39}, {91,39}, {101, 39}, {111, 39}, {122, 39},            {139, 39},                                  {192, 39}, {203, 39}, {213, 39}, 
+        {6,52},          {23,52}, {33,52}, {44,52}, {54,52}, {65,52}, {75,52}, {85,52}, { 96, 52}, {106, 52}, {117, 52},            {136, 52},            {169, 52},            {192, 52}, {203, 52}, {213, 52}, {224, 52},
+        {1,64}, {14,64}, {27,64},                            {66,64},                              {105, 64}, {118, 64}, {131, 64}, {144, 64}, {158, 64}, {169, 64}, {179, 64}, {197, 64},            {213, 64},
+
+    },
+    {
+        4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,        4,   4,   4,   4,   4,   4,   4,
+        4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,
+        4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,
+        4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,        4,                  4,   4,   4, 
+        4,        4,   4,   4,   4,   4,   4,   4,   4,   4,   4,        4,        4,        4,   4,   4,   4,
+        4,   4,   4,                  4,                  4,   4,   4,   4,   4,   4,   4,   4,        4,
+
+    }
+};
+#endif

keyboards/keychron/k10_pro/ansi/rgb/rules.mk

@@ -0,0 +1 @@
+# This file intentionally blank

keyboards/keychron/k10_pro/ansi/white/config.h

@@ -0,0 +1,51 @@
+/* Copyright 2023 @ Keychron (https://www.keychron.com)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#ifdef LED_MATRIX_ENABLE
+/* LED matrix driver configuration */
+#    define DRIVER_COUNT 1
+#    define DRIVER_ADDR_1 0b1110100
+
+/* LED matrix configuration */
+#    define LED_MATRIX_LED_COUNT 108
+
+/* Set to infinit, which is use in USB mode by default */
+#    define LED_MATRIX_TIMEOUT LED_MATRIX_TIMEOUT_INFINITE
+/* Allow shutdown of led driver to save power */
+#    define LED_MATRIX_DRIVER_SHUTDOWN_ENABLE
+/* Turn off backlight on low brightness to save power */
+#    define LED_MATRIX_BRIGHTNESS_TURN_OFF_VAL 32
+
+/* Indicatoon led */
+#    define CAPS_LOCK_INDEX 62
+#    define NUM_LOCK_INDEX 37
+
+/* LED Matrix Animation modes. Explicitly enabled
+ * For full list of effects, see:
+ * https://docs.qmk.fm/#/feature_led_matrix?id=led-matrix-effects
+ */
+#    define LED_MATRIX_KEYPRESSES
+
+/* Use first 8 channels of LED driver */
+#    define PHASE_CHANNEL MSKPHASE_8CHANNEL
+
+/* Set LED driver current */
+#    define SNLED27351_CURRENT_TUNE \
+        { 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60 }
+
+#endif

keyboards/keychron/k10_pro/ansi/white/info.json

@@ -0,0 +1,145 @@
+{
+    "usb": {
+    	"pid": "0x02A3",
+    	"device_version": "1.0.0"
+    },
+    "features": {
+        "led_matrix": true
+    },
+    "led_matrix": {
+        "driver": "snled27351",
+        "animations": {
+            "none": true,
+            "solid": true,
+            "breathing": true,
+            "band_pinwheel": true,
+            "band_spiral": true,
+            "cycle_left_right": true,
+            "cycle_up_down": true,
+            "cycle_out_in": true,
+            "dual_beacon": true,
+            "solid_reactive_simple": true,
+            "solid_reactive_multiwide": true,
+            "solid_reactive_multinexus": true,
+            "solid_splash": true,
+            "wave_left_right": true,
+            "wave_up_down": true,
+            "effect_max": true
+        },
+        "layout": [
+            {"matrix":[0,0],  "flags":1, "x":0,   "y":0},
+            {"matrix":[0,1],  "flags":1, "x":20,  "y":0},
+            {"matrix":[0,2],  "flags":1, "x":31,  "y":0},
+            {"matrix":[0,3],  "flags":1, "x":42,  "y":0},
+            {"matrix":[0,4],  "flags":1, "x":52,  "y":0},
+            {"matrix":[0,5],  "flags":1, "x":67,  "y":0},
+            {"matrix":[0,6],  "flags":1, "x":78,  "y":0},
+            {"matrix":[0,7],  "flags":1, "x":88,  "y":0},
+            {"matrix":[0,8],  "flags":1, "x":98,  "y":0},
+            {"matrix":[0,9],  "flags":1, "x":114, "y":0},
+            {"matrix":[0,10], "flags":1, "x":125, "y":0},
+            {"matrix":[0,11], "flags":1, "x":135, "y":0},
+            {"matrix":[0,12], "flags":1, "x":145, "y":0},
+            {"matrix":[0,14], "flags":1, "x":158, "y":0},
+            {"matrix":[0,15], "flags":1, "x":169, "y":0},
+            {"matrix":[0,16], "flags":1, "x":179, "y":0},
+            {"matrix":[0,17], "flags":4, "x":192, "y":0},
+            {"matrix":[0,18], "flags":4, "x":203, "y":0},
+            {"matrix":[0,19], "flags":4, "x":213, "y":0},
+            {"matrix":[0,20], "flags":4, "x":224, "y":0},
+
+            {"matrix":[1,0],  "flags":1, "x":0,   "y":15},
+            {"matrix":[1,1],  "flags":8, "x":10,  "y":15},
+            {"matrix":[1,2],  "flags":8, "x":20,  "y":15},
+            {"matrix":[1,3],  "flags":8, "x":31,  "y":15},
+            {"matrix":[1,4],  "flags":4, "x":41,  "y":15},
+            {"matrix":[1,5],  "flags":4, "x":52,  "y":15},
+            {"matrix":[1,6],  "flags":4, "x":62,  "y":15},
+            {"matrix":[1,7],  "flags":4, "x":72,  "y":15},
+            {"matrix":[1,8],  "flags":4, "x":83,  "y":15},
+            {"matrix":[1,9],  "flags":4, "x":93,  "y":15},
+            {"matrix":[1,10], "flags":4, "x":104, "y":15},
+            {"matrix":[1,11], "flags":4, "x":114, "y":15},
+            {"matrix":[1,12], "flags":4, "x":124, "y":15},
+            {"matrix":[1,13], "flags":1, "x":140, "y":15},
+            {"matrix":[1,14], "flags":1, "x":158, "y":15},
+            {"matrix":[1,15], "flags":1, "x":169, "y":15},
+            {"matrix":[1,16], "flags":1, "x":180, "y":15},
+            {"matrix":[1,17], "flags":8, "x":192, "y":15},
+            {"matrix":[1,18], "flags":4, "x":203, "y":15},
+            {"matrix":[1,19], "flags":4, "x":213, "y":15},
+            {"matrix":[1,20], "flags":4, "x":224, "y":15},
+
+            {"matrix":[2,0],  "flags":1, "x":2,   "y":28},
+            {"matrix":[2,1],  "flags":4, "x":15,  "y":28},
+            {"matrix":[2,2],  "flags":4, "x":26,  "y":28},
+            {"matrix":[2,3],  "flags":4, "x":36,  "y":28},
+            {"matrix":[2,4],  "flags":4, "x":46,  "y":28},
+            {"matrix":[2,5],  "flags":4, "x":57,  "y":28},
+            {"matrix":[2,6],  "flags":4, "x":67,  "y":28},
+            {"matrix":[2,7],  "flags":4, "x":78,  "y":28},
+            {"matrix":[2,8],  "flags":4, "x":88,  "y":28},
+            {"matrix":[2,9],  "flags":4, "x":98,  "y":28},
+            {"matrix":[2,10], "flags":4, "x":109, "y":28},
+            {"matrix":[2,11], "flags":4, "x":119, "y":28},
+            {"matrix":[2,12], "flags":4, "x":130, "y":28},
+            {"matrix":[2,13], "flags":1, "x":143, "y":28},
+            {"matrix":[2,14], "flags":1, "x":158, "y":28},
+            {"matrix":[2,15], "flags":1, "x":169, "y":28},
+            {"matrix":[2,16], "flags":1, "x":179, "y":28},
+            {"matrix":[2,17], "flags":4, "x":192, "y":28},
+            {"matrix":[2,18], "flags":4, "x":203, "y":28},
+            {"matrix":[2,19], "flags":4, "x":213, "y":28},
+            {"matrix":[2,20], "flags":4, "x":224, "y":28},
+
+            {"matrix":[3,0],  "flags":8, "x":3,   "y":39},
+            {"matrix":[3,1],  "flags":4, "x":18,  "y":39},
+            {"matrix":[3,2],  "flags":4, "x":28,  "y":39},
+            {"matrix":[3,3],  "flags":4, "x":39,  "y":39},
+            {"matrix":[3,4],  "flags":4, "x":49,  "y":39},
+            {"matrix":[3,5],  "flags":4, "x":59,  "y":39},
+            {"matrix":[3,6],  "flags":4, "x":70,  "y":39},
+            {"matrix":[3,7],  "flags":4, "x":80,  "y":39},
+            {"matrix":[3,8],  "flags":4, "x":91,  "y":39},
+            {"matrix":[3,9],  "flags":4, "x":101, "y":39},
+            {"matrix":[3,10], "flags":4, "x":111, "y":39},
+            {"matrix":[3,11], "flags":4, "x":122, "y":39},
+            {"matrix":[3,13], "flags":4, "x":139, "y":39},
+            {"matrix":[3,17], "flags":4, "x":192, "y":39},
+            {"matrix":[3,18], "flags":4, "x":203, "y":39},
+            {"matrix":[3,19], "flags":4, "x":213, "y":39},
+
+            {"matrix":[4,0],  "flags":1, "x":6,   "y":52},
+            {"matrix":[4,2],  "flags":4, "x":23,  "y":52},
+            {"matrix":[4,3],  "flags":4, "x":33,  "y":52},
+            {"matrix":[4,4],  "flags":4, "x":44,  "y":52},
+            {"matrix":[4,5],  "flags":4, "x":54,  "y":52},
+            {"matrix":[4,6],  "flags":4, "x":65,  "y":52},
+            {"matrix":[4,7],  "flags":4, "x":75,  "y":52},
+            {"matrix":[4,8],  "flags":4, "x":85,  "y":52},
+            {"matrix":[4,9],  "flags":4, "x":96,  "y":52},
+            {"matrix":[4,10], "flags":4, "x":106, "y":52},
+            {"matrix":[4,11], "flags":4, "x":117, "y":52},
+            {"matrix":[4,13], "flags":1, "x":136, "y":52},
+            {"matrix":[4,15], "flags":1, "x":169, "y":52},
+            {"matrix":[4,17], "flags":4, "x":192, "y":52},
+            {"matrix":[4,18], "flags":4, "x":203, "y":52},
+            {"matrix":[4,19], "flags":4, "x":213, "y":52},
+            {"matrix":[4,20], "flags":4, "x":224, "y":58},
+
+            {"matrix":[5,0],  "flags":1, "x":1,   "y":64},
+            {"matrix":[5,1],  "flags":1, "x":14,  "y":64},
+            {"matrix":[5,2],  "flags":1, "x":27,  "y":64},
+            {"matrix":[5,6],  "flags":4, "x":66,  "y":64},
+            {"matrix":[5,10], "flags":1, "x":105, "y":64},
+            {"matrix":[5,11], "flags":1, "x":118, "y":64},
+            {"matrix":[5,12], "flags":1, "x":131, "y":64},
+            {"matrix":[5,13], "flags":1, "x":144, "y":64},
+            {"matrix":[5,14], "flags":1, "x":158, "y":64},
+            {"matrix":[5,15], "flags":1, "x":169, "y":64},
+            {"matrix":[5,16], "flags":1, "x":179, "y":64},
+            {"matrix":[5,17], "flags":4, "x":197, "y":64},
+            {"matrix":[5,19], "flags":4, "x":213, "y":64}
+        ]
+    }
+}

keyboards/keychron/k10_pro/ansi/white/keymaps/default/keymap.c

@@ -15,58 +15,42 @@
  */
 
 #include QMK_KEYBOARD_H
-#include "keychron_common.h"
 
 enum layers{
-    MAC_BASE,
-    MAC_FN,
-    WIN_BASE,
-    WIN_FN
+  MAC_BASE,
+  MAC_FN,
+  WIN_BASE,
+  WIN_FN,
 };
 
+// clang-format off
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-    [MAC_BASE] = LAYOUT(
-        KC_ESC,             KC_BRID,  KC_BRIU,  KC_MCTL,  KC_LPAD,  BL_DOWN,  BL_UP,    KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_MUTE,  KC_VOLD,    KC_VOLU,  KC_SNAP,  KC_SIRI,  BL_STEP,
+    [MAC_BASE] = LAYOUT_ansi_108(
+        KC_ESC,             KC_BRID,  KC_BRIU,  KC_MCTL,  KC_LPAD,  BL_DOWN,  BL_UP,    KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_MUTE,  KC_VOLD,    KC_VOLU,  KC_SNAP,  KC_SIRI,  BL_STEP,  KC_F13,   KC_F14,   KC_F15,   KC_F16,
         KC_GRV,   KC_1,     KC_2,     KC_3,     KC_4,     KC_5,     KC_6,     KC_7,     KC_8,     KC_9,     KC_0,     KC_MINS,  KC_EQL,     KC_BSPC,  KC_INS,   KC_HOME,  KC_PGUP,  KC_NUM,   KC_PSLS,  KC_PAST,  KC_PMNS,
         KC_TAB,   KC_Q,     KC_W,     KC_E,     KC_R,     KC_T,     KC_Y,     KC_U,     KC_I,     KC_O,     KC_P,     KC_LBRC,  KC_RBRC,    KC_BSLS,  KC_DEL,   KC_END,   KC_PGDN,  KC_P7,    KC_P8,    KC_P9,    KC_PPLS,
         KC_CAPS,  KC_A,     KC_S,     KC_D,     KC_F,     KC_G,     KC_H,     KC_J,     KC_K,     KC_L,     KC_SCLN,  KC_QUOT,              KC_ENT,                                 KC_P4,    KC_P5,    KC_P6,
         KC_LSFT,            KC_Z,     KC_X,     KC_C,     KC_V,     KC_B,     KC_N,     KC_M,     KC_COMM,  KC_DOT,   KC_SLSH,              KC_RSFT,            KC_UP,              KC_P1,    KC_P2,    KC_P3,    KC_PENT,
-        KC_LCTL,  KC_LOPTN, KC_LCMMD,                               KC_SPC,                                 KC_RCMMD, KC_ROPTN, MO(MAC_FN), KC_RCTL,  KC_LEFT,  KC_DOWN,  KC_RGHT,  KC_P0,              KC_PDOT         ),
-
-    [MAC_FN] = LAYOUT(
-        _______,            KC_F1,    KC_F2,    KC_F3,    KC_F4,    KC_F5,    KC_F6,    KC_F7,    KC_F8,    KC_F9,    KC_F10,   KC_F11,     KC_F12,   _______,  _______,  BL_TOGG,
-        _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,
-        BL_TOGG,  BL_STEP,  BL_UP,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,
-        _______,  _______,  BL_DOWN,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,              _______,                                _______,  _______,  _______,
-        _______,            _______,  _______,  _______,  _______,  _______,  NK_TOGG,  _______,  _______,  _______,  _______,              _______,            _______,            _______,  _______,  _______,  _______,
-        _______,  _______,  _______,                                _______,                                _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,            _______         ),
-
-    [WIN_BASE] = LAYOUT(
-        KC_ESC,             KC_F1,    KC_F2,    KC_F3,    KC_F4,    KC_F5,    KC_F6,    KC_F7,    KC_F8,    KC_F9,    KC_F10,   KC_F11,     KC_F12,   KC_PSCR,  KC_CRTA,  BL_STEP,
+        KC_LCTL,  KC_LOPTN, KC_LCMMD,                               KC_SPC,                                 KC_RCMMD, KC_ROPTN, MO(MAC_FN), KC_RCTL,  KC_LEFT,  KC_DOWN,  KC_RGHT,  KC_P0,              KC_PDOT          ),
+    [MAC_FN] = LAYOUT_ansi_108(
+        _______,            KC_F1,    KC_F2,    KC_F3,    KC_F4,    KC_F5,    KC_F6,    KC_F7,    KC_F8,    KC_F9,    KC_F10,   KC_F11,     KC_F12,   _______,  _______,  BL_TOGG,  _______,  _______,  _______,  _______,
+        _______,  BT_HST1,  BT_HST2,  BT_HST3,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,
+        BL_TOGG,  BL_STEP,  BL_UP,    KC_TRNS,  KC_TRNS,  KC_TRNS,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,
+        _______,  KC_TRNS,  BL_DOWN,  KC_TRNS,  KC_TRNS,  KC_TRNS,  _______,  _______,  _______,  _______,  _______,  _______,              _______,                                _______,  _______,  _______,
+        _______,            _______,  _______,  _______,  _______,  BAT_LVL,  NK_TOGG,  _______,  _______,  _______,  _______,              _______,            _______,            _______,  _______,  _______,  _______,
+        _______,  _______,  _______,                                _______,                                _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,            _______          ),
+    [WIN_BASE] = LAYOUT_ansi_108(
+        KC_ESC,             KC_F1,    KC_F2,    KC_F3,    KC_F4,    KC_F5,    KC_F6,    KC_F7,    KC_F8,    KC_F9,    KC_F10,   KC_F11,     KC_F12,   KC_PSCR,  KC_CTANA, BL_STEP,  _______,  _______,  _______,  _______,
         KC_GRV,   KC_1,     KC_2,     KC_3,     KC_4,     KC_5,     KC_6,     KC_7,     KC_8,     KC_9,     KC_0,     KC_MINS,  KC_EQL,     KC_BSPC,  KC_INS,   KC_HOME,  KC_PGUP,  KC_NUM,   KC_PSLS,  KC_PAST,  KC_PMNS,
         KC_TAB,   KC_Q,     KC_W,     KC_E,     KC_R,     KC_T,     KC_Y,     KC_U,     KC_I,     KC_O,     KC_P,     KC_LBRC,  KC_RBRC,    KC_BSLS,  KC_DEL,   KC_END,   KC_PGDN,  KC_P7,    KC_P8,    KC_P9,    KC_PPLS,
         KC_CAPS,  KC_A,     KC_S,     KC_D,     KC_F,     KC_G,     KC_H,     KC_J,     KC_K,     KC_L,     KC_SCLN,  KC_QUOT,              KC_ENT,                                 KC_P4,    KC_P5,    KC_P6,
         KC_LSFT,            KC_Z,     KC_X,     KC_C,     KC_V,     KC_B,     KC_N,     KC_M,     KC_COMM,  KC_DOT,   KC_SLSH,              KC_RSFT,            KC_UP,              KC_P1,    KC_P2,    KC_P3,    KC_PENT,
         KC_LCTL,  KC_LWIN,  KC_LALT,                                KC_SPC,                                 KC_RALT,  KC_RWIN,  MO(WIN_FN), KC_RCTL,  KC_LEFT,  KC_DOWN,  KC_RGHT,  KC_P0,              KC_PDOT         ),
-
-    [WIN_FN] = LAYOUT(
-        _______,            KC_BRID,  KC_BRIU,  KC_TASK,  KC_FLXP,  BL_DOWN,  BL_UP,    KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_MUTE,  KC_VOLD,    KC_VOLU,  _______,  _______,  BL_TOGG,
-        _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,
-        BL_TOGG,  BL_STEP,  BL_UP,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,
-        _______,  _______,  BL_DOWN,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,              _______,                                _______,  _______,  _______,
-        _______,            _______,  _______,  _______,  _______,  _______,  NK_TOGG,  _______,  _______,  _______,  _______,              _______,            _______,            _______,  _______,  _______,  _______,
-        _______,  _______,  _______,                                _______,                                _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,            _______         ),
+    [WIN_FN] = LAYOUT_ansi_108(
+        _______,            KC_BRID,  KC_BRIU,  KC_TASK,  KC_FILE,  BL_DOWN,  BL_UP,    KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_MUTE,  KC_VOLD,    KC_VOLU,  _______,  _______,  BL_TOGG,  _______,  _______,  _______,  _______,
+        _______,  BT_HST1,  BT_HST2,  BT_HST3,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,
+        BL_TOGG,  BL_STEP,  BL_UP,    KC_TRNS,  KC_TRNS,  KC_TRNS,  _______,  _______,  _______,  _______,  _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,  _______,  _______,  _______,
+        _______,  KC_TRNS,  BL_DOWN,  KC_TRNS,  KC_TRNS,  KC_TRNS,  _______,  _______,  _______,  _______,  _______,  _______,              _______,                                _______,  _______,  _______,
+        _______,            _______,  _______,  _______,  _______,  BAT_LVL,  NK_TOGG,  _______,  _______,  _______,  _______,              _______,            _______,            _______,  _______,  _______,  _______,
+        _______,  _______,  _______,                                _______,                                _______,  _______,  _______,    _______,  _______,  _______,  _______,  _______,            _______          )
 };
-
-// clang-format on
-
-void housekeeping_task_user(void) {
-    housekeeping_task_keychron();
-}
-
-bool process_record_user(uint16_t keycode, keyrecord_t *record) {
-    if (!process_record_keychron(keycode, record)) {
-        return false;
-    }
-    return true;
-}