Add K8 pro

builddefs/common_features.mk

@@ -202,6 +202,12 @@ else
         COMMON_VPATH += $(PLATFORM_PATH)/$(PLATFORM_KEY)/$(DRIVER_DIR)/eeprom
         SRC += eeprom_driver.c
         SRC += eeprom_stm32_L0_L1.c
+      else ifneq ($(filter $(MCU_SERIES),STM32L4xx),)
+        OPT_DEFS += -DEEPROM_DRIVER -DEEPROM_STM32_L4
+        COMMON_VPATH += $(DRIVER_PATH)/eeprom
+        SRC += eeprom_driver.c
+        SRC += $(PLATFORM_COMMON_DIR)/eeprom_stm32_l4.c
+        SRC += $(PLATFORM_COMMON_DIR)/flash_stm32.c
       else ifneq ($(filter $(MCU_SERIES),KL2x K20x),)
         # Teensy EEPROM implementations
         OPT_DEFS += -DEEPROM_TEENSY
@@ -275,7 +281,7 @@ ifeq ($(strip $(RGBLIGHT_ENABLE)), yes)
 endif
 
 LED_MATRIX_ENABLE ?= no
-VALID_LED_MATRIX_TYPES := IS31FL3731 IS31FL3742A IS31FL3743A IS31FL3745 IS31FL3746A custom
+VALID_LED_MATRIX_TYPES := IS31FL3731 IS31FL3742A IS31FL3743A IS31FL3745 IS31FL3746A CKLED2001 custom
 # TODO: IS31FL3733 IS31FL3737 IS31FL3741
 
 ifeq ($(strip $(LED_MATRIX_ENABLE)), yes)
@@ -331,6 +337,13 @@ endif
         QUANTUM_LIB_SRC += i2c_master.c
     endif
 
+	ifeq ($(strip $(LED_MATRIX_DRIVER)), CKLED2001)
+        OPT_DEFS += -DCKLED2001 -DSTM32_I2C -DHAL_USE_I2C=TRUE
+        COMMON_VPATH += $(DRIVER_PATH)/led
+        SRC += ckled2001-simple.c
+        QUANTUM_LIB_SRC += i2c_master.c
+    endif
+
 endif
 
 RGB_MATRIX_ENABLE ?= no

drivers/eeprom/eeprom_driver.h

@@ -18,5 +18,5 @@
 
 #include "eeprom.h"
 
-void eeprom_driver_init(void);
+uint16_t eeprom_driver_init(void);
 void eeprom_driver_erase(void);

drivers/led/ckled2001-simple.c

@@ -0,0 +1,218 @@
+/* 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 "ckled2001-simple.h"
+#include "i2c_master.h"
+#include "wait.h"
+
+#ifndef CKLED2001_TIMEOUT
+#    define CKLED2001_TIMEOUT 100
+#endif
+
+#ifndef CKLED2001_PERSISTENCE
+#    define CKLED2001_PERSISTENCE 0
+#endif
+
+#ifndef PHASE_CHANNEL
+#    define PHASE_CHANNEL MSKPHASE_12CHANNEL
+#endif
+
+#ifndef CKLED2001_CURRENT_TUNE
+#    define CKLED2001_CURRENT_TUNE \
+        { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }
+#endif
+
+// Transfer buffer for TWITransmitData()
+uint8_t g_twi_transfer_buffer[20];
+
+// These buffers match the CKLED2001 PWM registers.
+// The control buffers match the PG0 LED On/Off registers.
+// Storing them like this is optimal for I2C transfers to the registers.
+// We could optimize this and take out the unused registers from these
+// buffers and the transfers in CKLED2001_write_pwm_buffer() but it's
+// probably not worth the extra complexity.
+uint8_t g_pwm_buffer[DRIVER_COUNT][192];
+bool    g_pwm_buffer_update_required[DRIVER_COUNT] = {false};
+
+uint8_t g_led_control_registers[DRIVER_COUNT][24]             = {0};
+bool    g_led_control_registers_update_required[DRIVER_COUNT] = {false};
+
+bool CKLED2001_write_register(uint8_t addr, uint8_t reg, uint8_t data) {
+    // If the transaction fails function returns false.
+    g_twi_transfer_buffer[0] = reg;
+    g_twi_transfer_buffer[1] = data;
+
+#if CKLED2001_PERSISTENCE > 0
+    for (uint8_t i = 0; i < CKLED2001_PERSISTENCE; i++) {
+        if (i2c_transmit(addr << 1, g_twi_transfer_buffer, 2, CKLED2001_TIMEOUT) != 0) {
+            return false;
+        }
+    }
+#else
+    if (i2c_transmit(addr << 1, g_twi_transfer_buffer, 2, CKLED2001_TIMEOUT) != 0) {
+        return false;
+    }
+#endif
+    return true;
+}
+
+bool CKLED2001_write_pwm_buffer(uint8_t addr, uint8_t *pwm_buffer) {
+    // Assumes PG1 is already selected.
+    // If any of the transactions fails function returns false.
+    // Transmit PWM registers in 12 transfers of 16 bytes.
+    // g_twi_transfer_buffer[] is 20 bytes
+
+    // Iterate over the pwm_buffer contents at 16 byte intervals.
+    for (int i = 0; i < 192; i += 16) {
+        g_twi_transfer_buffer[0] = i;
+        // Copy the data from i to i+15.
+        // Device will auto-increment register for data after the first byte
+        // Thus this sets registers 0x00-0x0F, 0x10-0x1F, etc. in one transfer.
+        for (int j = 0; j < 16; j++) {
+            g_twi_transfer_buffer[1 + j] = pwm_buffer[i + j];
+        }
+
+#if CKLED2001_PERSISTENCE > 0
+        for (uint8_t i = 0; i < CKLED2001_PERSISTENCE; i++) {
+            if (i2c_transmit(addr << 1, g_twi_transfer_buffer, 17, CKLED2001_TIMEOUT) != 0) {
+                return false;
+            }
+        }
+#else
+        if (i2c_transmit(addr << 1, g_twi_transfer_buffer, 17, CKLED2001_TIMEOUT) != 0) {
+            return false;
+        }
+#endif
+    }
+    return true;
+}
+
+void CKLED2001_init(uint8_t addr) {
+    // Select to function page
+    CKLED2001_write_register(addr, CONFIGURE_CMD_PAGE, FUNCTION_PAGE);
+    // Setting LED driver to shutdown mode
+    CKLED2001_write_register(addr, CONFIGURATION_REG, MSKSW_SHUT_DOWN_MODE);
+    // Setting internal channel pulldown/pullup
+    CKLED2001_write_register(addr, PDU_REG, MSKSET_CA_CB_CHANNEL);
+    // Select number of scan phase
+    CKLED2001_write_register(addr, SCAN_PHASE_REG, PHASE_CHANNEL);
+    // Setting PWM Delay Phase
+    CKLED2001_write_register(addr, SLEW_RATE_CONTROL_MODE1_REG, MSKPWM_DELAY_PHASE_ENABLE);
+    // Setting Driving/Sinking Channel Slew Rate
+    CKLED2001_write_register(addr, SLEW_RATE_CONTROL_MODE2_REG, MSKDRIVING_SINKING_CHHANNEL_SLEWRATE_ENABLE);
+    // Setting Iref
+    CKLED2001_write_register(addr, SOFTWARE_SLEEP_REG, MSKSLEEP_DISABLE);
+    // Set LED CONTROL PAGE (Page 0)
+    CKLED2001_write_register(addr, CONFIGURE_CMD_PAGE, LED_CONTROL_PAGE);
+    for (int i = 0; i < LED_CONTROL_ON_OFF_LENGTH; i++) {
+        CKLED2001_write_register(addr, i, 0x00);
+    }
+
+    // Set PWM PAGE (Page 1)
+    CKLED2001_write_register(addr, CONFIGURE_CMD_PAGE, LED_PWM_PAGE);
+    for (int i = 0; i < LED_CURRENT_TUNE_LENGTH; i++) {
+        CKLED2001_write_register(addr, i, 0x00);
+    }
+
+    // Set CURRENT PAGE (Page 4)
+    uint8_t current_tuen_reg_list[LED_CURRENT_TUNE_LENGTH] = CKLED2001_CURRENT_TUNE;
+    CKLED2001_write_register(addr, CONFIGURE_CMD_PAGE, CURRENT_TUNE_PAGE);
+    for (int i = 0; i < LED_CURRENT_TUNE_LENGTH; i++) {
+        CKLED2001_write_register(addr, i, current_tuen_reg_list[i]);
+    }
+
+    // Enable LEDs ON/OFF
+    CKLED2001_write_register(addr, CONFIGURE_CMD_PAGE, LED_CONTROL_PAGE);
+    for (int i = 0; i < LED_CONTROL_ON_OFF_LENGTH; i++) {
+        CKLED2001_write_register(addr, i, 0xFF);
+    }
+
+    // Select to function page
+    CKLED2001_write_register(addr, CONFIGURE_CMD_PAGE, FUNCTION_PAGE);
+    // Setting LED driver to normal mode
+    CKLED2001_write_register(addr, CONFIGURATION_REG, MSKSW_NORMAL_MODE);
+}
+
+void CKLED2001_set_value(int index, uint8_t value) {
+    ckled2001_led led;
+    if (index >= 0 && index < DRIVER_LED_TOTAL) {
+        memcpy_P(&led, (&g_ckled2001_leds[index]), sizeof(led));
+
+        g_pwm_buffer[led.driver][led.v]          = value;
+        g_pwm_buffer_update_required[led.driver] = true;
+    }
+}
+
+void CKLED2001_set_value_all(uint8_t value) {
+    for (int i = 0; i < DRIVER_LED_TOTAL; i++) {
+        CKLED2001_set_value(i, value);
+    }
+}
+
+void CKLED2001_set_led_control_register(uint8_t index, bool value) {
+    ckled2001_led led;
+    memcpy_P(&led, (&g_ckled2001_leds[index]), sizeof(led));
+
+    uint8_t control_register = led.v / 8;
+    uint8_t bit_value        = led.v % 8;
+
+    if (value) {
+        g_led_control_registers[led.driver][control_register] |= (1 << bit_value);
+    } else {
+        g_led_control_registers[led.driver][control_register] &= ~(1 << bit_value);
+    }
+
+    g_led_control_registers_update_required[led.driver] = true;
+}
+
+void CKLED2001_update_pwm_buffers(uint8_t addr, uint8_t index) {
+    if (g_pwm_buffer_update_required[index]) {
+        CKLED2001_write_register(addr, CONFIGURE_CMD_PAGE, LED_PWM_PAGE);
+
+        // If any of the transactions fail we risk writing dirty PG0,
+        // refresh page 0 just in case.
+        if (!CKLED2001_write_pwm_buffer(addr, g_pwm_buffer[index])) {
+            g_led_control_registers_update_required[index] = true;
+        }
+    }
+    g_pwm_buffer_update_required[index] = false;
+}
+
+void CKLED2001_update_led_control_registers(uint8_t addr, uint8_t index) {
+    if (g_led_control_registers_update_required[index]) {
+        CKLED2001_write_register(addr, CONFIGURE_CMD_PAGE, LED_CONTROL_PAGE);
+        for (int i = 0; i < 24; i++) {
+            CKLED2001_write_register(addr, i, g_led_control_registers[index][i]);
+        }
+    }
+    g_led_control_registers_update_required[index] = false;
+}
+
+void CKLED2001_sw_return_normal(uint8_t addr) {
+    // Select to function page
+    CKLED2001_write_register(addr, CONFIGURE_CMD_PAGE, FUNCTION_PAGE);
+    // Setting LED driver to normal mode
+    CKLED2001_write_register(addr, CONFIGURATION_REG, MSKSW_NORMAL_MODE);
+}
+
+void CKLED2001_sw_shutdown(uint8_t addr) {
+    // Select to function page
+    CKLED2001_write_register(addr, CONFIGURE_CMD_PAGE, FUNCTION_PAGE);
+    // Setting LED driver to shutdown mode
+    CKLED2001_write_register(addr, CONFIGURATION_REG, MSKSW_SHUT_DOWN_MODE);
+    // Write SW Sleep Register
+    CKLED2001_write_register(addr, SOFTWARE_SLEEP_REG, MSKSLEEP_ENABLE);
+}

drivers/led/ckled2001-simple.h

@@ -0,0 +1,337 @@
+/* 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>
+#include <stdbool.h>
+#include "progmem.h"
+
+typedef struct ckled2001_led {
+    uint8_t driver : 2;
+    uint8_t v;
+} __attribute__((packed)) ckled2001_led;
+
+extern const ckled2001_led PROGMEM g_ckled2001_leds[DRIVER_LED_TOTAL];
+
+void CKLED2001_init(uint8_t addr);
+bool CKLED2001_write_register(uint8_t addr, uint8_t reg, uint8_t data);
+bool CKLED2001_write_pwm_buffer(uint8_t addr, uint8_t *pwm_buffer);
+
+void CKLED2001_set_value(int index, uint8_t value);
+void CKLED2001_set_value_all(uint8_t value);
+
+void CKLED2001_set_led_control_register(uint8_t index, bool value);
+
+// This should not be called from an interrupt
+// (eg. from a timer interrupt).
+// Call this while idle (in between matrix scans).
+// If the buffer is dirty, it will update the driver with the buffer.
+void CKLED2001_update_pwm_buffers(uint8_t addr, uint8_t index);
+void CKLED2001_update_led_control_registers(uint8_t addr, uint8_t index);
+
+void CKLED2001_sw_return_normal(uint8_t addr);
+void CKLED2001_sw_shutdown(uint8_t addr);
+
+// Registers Page Define
+#define CONFIGURE_CMD_PAGE 0xFD
+#define LED_CONTROL_PAGE 0x00
+#define LED_PWM_PAGE 0x01
+#define FUNCTION_PAGE 0x03
+#define CURRENT_TUNE_PAGE 0x04
+
+// Function Register: address 0x00
+#define CONFIGURATION_REG 0x00
+#define MSKSW_SHUT_DOWN_MODE (0x0 << 0)
+#define MSKSW_NORMAL_MODE (0x1 << 0)
+
+#define DRIVER_ID_REG 0x11
+#define CKLED2001_ID 0x8A
+
+#define PDU_REG 0x13
+#define MSKSET_CA_CB_CHANNEL 0xAA
+#define MSKCLR_CA_CB_CHANNEL 0x00
+
+#define SCAN_PHASE_REG 0x14
+#define MSKPHASE_12CHANNEL 0x00
+#define MSKPHASE_11CHANNEL 0x01
+#define MSKPHASE_10CHANNEL 0x02
+#define MSKPHASE_9CHANNEL 0x03
+#define MSKPHASE_8CHANNEL 0x04
+#define MSKPHASE_7CHANNEL 0x05
+#define MSKPHASE_6CHANNEL 0x06
+#define MSKPHASE_5CHANNEL 0x07
+#define MSKPHASE_4CHANNEL 0x08
+#define MSKPHASE_3CHANNEL 0x09
+#define MSKPHASE_2CHANNEL 0x0A
+#define MSKPHASE_1CHANNEL 0x0B
+
+#define SLEW_RATE_CONTROL_MODE1_REG 0x15
+#define MSKPWM_DELAY_PHASE_ENABLE 0x04
+#define MSKPWM_DELAY_PHASE_DISABLE 0x00
+
+#define SLEW_RATE_CONTROL_MODE2_REG 0x16
+#define MSKDRIVING_SINKING_CHHANNEL_SLEWRATE_ENABLE 0xC0
+#define MSKDRIVING_SINKING_CHHANNEL_SLEWRATE_DISABLE 0x00
+
+#define OPEN_SHORT_ENABLE_REG 0x17
+#define MSKOPEN_DETECTION_ENABLE (0x01 << 7)
+#define MSKOPEN_DETECTION_DISABLE (0x00)
+
+#define MSKSHORT_DETECTION_ENABLE (0x01 << 6)
+#define MSKSHORT_DETECTION_DISABLE (0x00)
+
+#define OPEN_SHORT_DUTY_REG 0x18
+#define OPEN_SHORT_FLAG_REG 0x19
+
+#define MSKOPEN_DETECTION_INTERRUPT_ENABLE (0x01 << 7)
+#define MSKOPEN_DETECTION_INTERRUPT_DISABLE (0x00)
+
+#define MSKSHORT_DETECTION_INTERRUPT_ENABLE (0x01 << 6)
+#define MSKSHORT_DETECTION_INTERRUPT_DISABLE (0x00)
+
+#define SOFTWARE_SLEEP_REG 0x1A
+#define MSKSLEEP_ENABLE 0x02
+#define MSKSLEEP_DISABLE 0x00
+
+// LED Control Registers
+#define LED_CONTROL_ON_OFF_FIRST_ADDR 0x0
+#define LED_CONTROL_ON_OFF_LAST_ADDR 0x17
+#define LED_CONTROL_ON_OFF_LENGTH ((LED_CONTROL_ON_OFF_LAST_ADDR - LED_CONTROL_ON_OFF_FIRST_ADDR) + 1)
+
+#define LED_CONTROL_OPEN_FIRST_ADDR 0x18
+#define LED_CONTROL_OPEN_LAST_ADDR 0x2F
+#define LED_CONTROL_OPEN_LENGTH ((LED_CONTROL_OPEN_LAST_ADDR - LED_CONTROL_OPEN_FIRST_ADDR) + 1)
+
+#define LED_CONTROL_SHORT_FIRST_ADDR 0x30
+#define LED_CONTROL_SHORT_LAST_ADDR 0x47
+#define LED_CONTROL_SHORT_LENGTH ((LED_CONTROL_SHORT_LAST_ADDR - LED_CONTROL_SHORT_FIRST_ADDR) + 1)
+
+#define LED_CONTROL_PAGE_LENGTH 0x48
+
+// LED Control Registers
+#define LED_PWM_FIRST_ADDR 0x00
+#define LED_PWM_LAST_ADDR 0xBF
+#define LED_PWM_LENGTH 0xC0
+
+// Current Tune Registers
+#define LED_CURRENT_TUNE_FIRST_ADDR 0x00
+#define LED_CURRENT_TUNE_LAST_ADDR 0x0B
+#define LED_CURRENT_TUNE_LENGTH 0x0C
+
+#define A_1 0x00
+#define A_2 0x01
+#define A_3 0x02
+#define A_4 0x03
+#define A_5 0x04
+#define A_6 0x05
+#define A_7 0x06
+#define A_8 0x07
+#define A_9 0x08
+#define A_10 0x09
+#define A_11 0x0A
+#define A_12 0x0B
+#define A_13 0x0C
+#define A_14 0x0D
+#define A_15 0x0E
+#define A_16 0x0F
+
+#define B_1 0x10
+#define B_2 0x11
+#define B_3 0x12
+#define B_4 0x13
+#define B_5 0x14
+#define B_6 0x15
+#define B_7 0x16
+#define B_8 0x17
+#define B_9 0x18
+#define B_10 0x19
+#define B_11 0x1A
+#define B_12 0x1B
+#define B_13 0x1C
+#define B_14 0x1D
+#define B_15 0x1E
+#define B_16 0x1F
+
+#define C_1 0x20
+#define C_2 0x21
+#define C_3 0x22
+#define C_4 0x23
+#define C_5 0x24
+#define C_6 0x25
+#define C_7 0x26
+#define C_8 0x27
+#define C_9 0x28
+#define C_10 0x29
+#define C_11 0x2A
+#define C_12 0x2B
+#define C_13 0x2C
+#define C_14 0x2D
+#define C_15 0x2E
+#define C_16 0x2F
+
+#define D_1 0x30
+#define D_2 0x31
+#define D_3 0x32
+#define D_4 0x33
+#define D_5 0x34
+#define D_6 0x35
+#define D_7 0x36
+#define D_8 0x37
+#define D_9 0x38
+#define D_10 0x39
+#define D_11 0x3A
+#define D_12 0x3B
+#define D_13 0x3C
+#define D_14 0x3D
+#define D_15 0x3E
+#define D_16 0x3F
+
+#define E_1 0x40
+#define E_2 0x41
+#define E_3 0x42
+#define E_4 0x43
+#define E_5 0x44
+#define E_6 0x45
+#define E_7 0x46
+#define E_8 0x47
+#define E_9 0x48
+#define E_10 0x49
+#define E_11 0x4A
+#define E_12 0x4B
+#define E_13 0x4C
+#define E_14 0x4D
+#define E_15 0x4E
+#define E_16 0x4F
+
+#define F_1 0x50
+#define F_2 0x51
+#define F_3 0x52
+#define F_4 0x53
+#define F_5 0x54
+#define F_6 0x55
+#define F_7 0x56
+#define F_8 0x57
+#define F_9 0x58
+#define F_10 0x59
+#define F_11 0x5A
+#define F_12 0x5B
+#define F_13 0x5C
+#define F_14 0x5D
+#define F_15 0x5E
+#define F_16 0x5F
+
+#define G_1 0x60
+#define G_2 0x61
+#define G_3 0x62
+#define G_4 0x63
+#define G_5 0x64
+#define G_6 0x65
+#define G_7 0x66
+#define G_8 0x67
+#define G_9 0x68
+#define G_10 0x69
+#define G_11 0x6A
+#define G_12 0x6B
+#define G_13 0x6C
+#define G_14 0x6D
+#define G_15 0x6E
+#define G_16 0x6F
+
+#define H_1 0x70
+#define H_2 0x71
+#define H_3 0x72
+#define H_4 0x73
+#define H_5 0x74
+#define H_6 0x75
+#define H_7 0x76
+#define H_8 0x77
+#define H_9 0x78
+#define H_10 0x79
+#define H_11 0x7A
+#define H_12 0x7B
+#define H_13 0x7C
+#define H_14 0x7D
+#define H_15 0x7E
+#define H_16 0x7F
+
+#define I_1 0x80
+#define I_2 0x81
+#define I_3 0x82
+#define I_4 0x83
+#define I_5 0x84
+#define I_6 0x85
+#define I_7 0x86
+#define I_8 0x87
+#define I_9 0x88
+#define I_10 0x89
+#define I_11 0x8A
+#define I_12 0x8B
+#define I_13 0x8C
+#define I_14 0x8D
+#define I_15 0x8E
+#define I_16 0x8F
+
+#define J_1 0x90
+#define J_2 0x91
+#define J_3 0x92
+#define J_4 0x93
+#define J_5 0x94
+#define J_6 0x95
+#define J_7 0x96
+#define J_8 0x97
+#define J_9 0x98
+#define J_10 0x99
+#define J_11 0x9A
+#define J_12 0x9B
+#define J_13 0x9C
+#define J_14 0x9D
+#define J_15 0x9E
+#define J_16 0x9F
+
+#define K_1 0xA0
+#define K_2 0xA1
+#define K_3 0xA2
+#define K_4 0xA3
+#define K_5 0xA4
+#define K_6 0xA5
+#define K_7 0xA6
+#define K_8 0xA7
+#define K_9 0xA8
+#define K_10 0xA9
+#define K_11 0xAA
+#define K_12 0xAB
+#define K_13 0xAC
+#define K_14 0xAD
+#define K_15 0xAE
+#define K_16 0xAF
+
+#define L_1 0xB0
+#define L_2 0xB1
+#define L_3 0xB2
+#define L_4 0xB3
+#define L_5 0xB4
+#define L_6 0xB5
+#define L_7 0xB6
+#define L_8 0xB7
+#define L_9 0xB8
+#define L_10 0xB9
+#define L_11 0xBA
+#define L_12 0xBB
+#define L_13 0xBC
+#define L_14 0xBD
+#define L_15 0xBE
+#define L_16 0xBF

drivers/led/ckled2001.c

@@ -30,6 +30,10 @@
 #    define PHASE_CHANNEL MSKPHASE_12CHANNEL
 #endif
 
+#ifndef CKLED2001_CURRENT_TUNE
+#   define CKLED2001_CURRENT_TUNE   {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}
+#endif
+
 // Transfer buffer for TWITransmitData()
 uint8_t g_twi_transfer_buffer[20];
 
@@ -123,18 +127,10 @@ void CKLED2001_init(uint8_t addr) {
     }
 
     // Set CURRENT PAGE (Page 4)
+    uint8_t current_tuen_reg_list[LED_CURRENT_TUNE_LENGTH] = CKLED2001_CURRENT_TUNE;
     CKLED2001_write_register(addr, CONFIGURE_CMD_PAGE, CURRENT_TUNE_PAGE);
     for (int i = 0; i < LED_CURRENT_TUNE_LENGTH; i++) {
-        switch (i) {
-            case 2:
-            case 5:
-            case 8:
-            case 11:
-                CKLED2001_write_register(addr, i, 0xA0);
-                break;
-            default:
-                CKLED2001_write_register(addr, i, 0xFF);
-        }
+        CKLED2001_write_register(addr, i, current_tuen_reg_list[i]);
     }
 
     // Enable LEDs ON/OFF
@@ -220,18 +216,20 @@ void CKLED2001_update_led_control_registers(uint8_t addr, uint8_t index) {
     g_led_control_registers_update_required[index] = false;
 }
 
-void CKLED2001_return_normal(uint8_t addr) {
+void CKLED2001_sw_return_normal(uint8_t addr) {
     // Select to function page
     CKLED2001_write_register(addr, CONFIGURE_CMD_PAGE, FUNCTION_PAGE);
     // Setting LED driver to normal mode
     CKLED2001_write_register(addr, CONFIGURATION_REG, MSKSW_NORMAL_MODE);
 }
 
-void CKLED2001_shutdown(uint8_t addr) {
+void CKLED2001_sw_shutdown(uint8_t addr) {
     // Select to function page
     CKLED2001_write_register(addr, CONFIGURE_CMD_PAGE, FUNCTION_PAGE);
     // Setting LED driver to shutdown mode
     CKLED2001_write_register(addr, CONFIGURATION_REG, MSKSW_SHUT_DOWN_MODE);
     // Write SW Sleep Register
     CKLED2001_write_register(addr, SOFTWARE_SLEEP_REG, MSKSLEEP_ENABLE);
-}
+}    
+
+

drivers/led/ckled2001.h

@@ -45,8 +45,8 @@ void CKLED2001_set_led_control_register(uint8_t index, bool red, bool green, boo
 void CKLED2001_update_pwm_buffers(uint8_t addr, uint8_t index);
 void CKLED2001_update_led_control_registers(uint8_t addr, uint8_t index);
 
-void CKLED2001_return_normal(uint8_t addr);
-void CKLED2001_shutdown(uint8_t addr);
+void CKLED2001_sw_return_normal(uint8_t addr);
+void CKLED2001_sw_shutdown(uint8_t addr);
 
 // Registers Page Define
 #define CONFIGURE_CMD_PAGE 0xFD

keyboards/keychron/bluetooth/bat_level_animation.c

@@ -0,0 +1,128 @@
+
+#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
+
+#ifndef BAT_LEVEL_GROWING_INTERVAL
+#    define BAT_LEVEL_GROWING_INTERVAL 150
+#endif
+
+#ifndef BAT_LEVEL_ON_INTERVAL
+#    define BAT_LEVEL_ON_INTERVAL 3000
+#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;
+static uint32_t bat_lvl_ani_timer_buffer;
+static uint8_t  bat_percentage;
+static uint8_t  cur_percentage;
+static uint8_t  bat_lvl_led_list[10] = BAT_LEVEL_LED_LIST;
+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
+    for (uint8_t i = 0; i <= DRIVER_LED_TOTAL; 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
+    for (uint8_t i = 0; i <= DRIVER_LED_TOTAL; 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;
+            if (indicator_config.value == 0 && indicator_is_backlit_enabled_eeprom()) {
+                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

@@ -0,0 +1,23 @@
+/* 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
+
+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,107 @@
+/* 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"
+
+#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;
+
+void battery_init(void) {
+    bat_monitor_timer_buffer = 0;
+    bat_state                = BAT_NOT_CHARGING;
+}
+__attribute__((weak)) void battery_measure(void) {}
+
+/* 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) indicator_battery_low_enable(true);
+        }
+    } else if (bat_empty <= BATTERY_EMPTY_COUNT) {
+        bat_empty = BATTERY_EMPTY_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;
+    }
+}
+
+void battery_task(void) {
+    if (get_transport() == TRANSPORT_BLUETOOTH && bluetooth_get_state() == BLUETOOTH_CONNECTED) {
+        if (sync_timer_elapsed32(bat_monitor_timer_buffer) > VOLTAGE_MEASURE_INTERVAL) {
+            battery_check_empty();
+            battery_check_critical_low();
+
+            bat_monitor_timer_buffer = sync_timer_read32();
+            battery_measure();
+        }
+    }
+
+    if ((bat_empty || critical_low) && usb_power_connected()) {
+        bat_empty    = false;
+        critical_low = false;
+        indicator_battery_low_enable(false);
+    }
+}

keyboards/keychron/bluetooth/battery.h

@@ -0,0 +1,51 @@
+/* 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
+
+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);
+
+void battery_task(void);

keyboards/keychron/bluetooth/bluetooth.c

@@ -0,0 +1,432 @@
+/* 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 "report_buffer.h"
+#include "lpm.h"
+#include "battery.h"
+#include "indicator.h"
+#include "transport.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;
+
+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_mouse(report_mouse_t *report);
+void    bluetooth_send_system(uint16_t data);
+void    bluetooth_send_consumer(uint16_t data);
+/* host struct */
+host_driver_t bluetooth_driver = {bluetooth_keyboard_leds, bluetooth_send_keyboard, bluetooth_send_mouse, bluetooth_send_system, bluetooth_send_consumer};
+
+#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();
+}
+
+/*
+ * 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 = true;
+#else
+    keymap_config.nkro = false;
+#endif
+
+    bluetooth_enter_connected_kb(host_idx);
+
+    if (battery_is_empty()) indicator_battery_low_enable(true);
+}
+
+/* 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);
+    indicator_battery_low_enable(false);
+}
+
+
+/* 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 defined(NKRO_ENABLE)
+        if (bluetooth_report_protocol && keymap_config.nkro) {
+            if (bluetooth_transport.send_nkro) {
+#        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_NKRO;
+                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_nkro(&report->nkro.mods);
+#        endif
+            }
+        } else
+#    endif
+        {
+            //#ifdef KEYBOARD_SHARED_EP
+            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_KB;
+                    memcpy(&report_buffer.keyboard, report, sizeof(report_keyboard_t));
+                    report_buffer_enqueue(&report_buffer);
+                }
+#    else
+                bluetooth_transport.send_keyboard(&report->mods);
+#    endif
+            }
+            //#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_low_battery_shutdown(void) {
+    indicator_battery_low_enable(false);
+    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_PINCODE_ENTRY:
+                bluetooth_enter_pin_code_entry();
+                break;
+            case EVT_EXIT_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;
+};
+
+bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
+    if (get_transport() == TRANSPORT_BLUETOOTH) {
+        lpm_timer_reset();
+    }
+
+    return process_record_user(keycode, record);
+}

keyboards/keychron/bluetooth/bluetooth.h

@@ -0,0 +1,85 @@
+/* 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"
+
+/* 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);
+

keyboards/keychron/bluetooth/bluetooth.mk

@@ -0,0 +1,14 @@
+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 
+VPATH += $(TOP_DIR)/keyboards/keychron/$(BLUETOOTH_DIR)

keyboards/keychron/bluetooth/bluetooth_config.h

@@ -0,0 +1,32 @@
+/* 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"
+
+//  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_PINCODE_ENTRY,
+    EVT_EXIT_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,575 @@
+/* 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 "ckbt51.h"
+#include "bluetooth.h"
+#include "battery.h"
+#include "raw_hid.h"
+#include "report_buffer.h"
+
+#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,
+    /* 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, 
+    NULL, 
+    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(&BT_DRIVER, &config);
+
+        return;
+    }
+
+    sdStart(&BT_DRIVER, &config);
+    palSetPadMode(BT_DRIVER_UART_TX_BANK, BT_DRIVER_UART_TX, PAL_MODE_ALTERNATE(BT_DRIVER_UART_TX_PAL_MODE));
+    palSetPadMode(BT_DRIVER_UART_RX_BANK, BT_DRIVER_UART_RX, PAL_MODE_ALTERNATE(BT_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) {
+    static uint8_t sn = 1;
+    uint8_t        i;
+    uint8_t        pkt[PACKET_MAX_LEN] = {0};
+    memset(pkt, 0, PACKET_MAX_LEN);
+
+    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(&BT_DRIVER, pkt, i);
+
+    if (sn == 0) sn = 1;
+}
+
+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);
+}
+
+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);
+}
+
+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);
+}
+
+void ckbt51_send_system(uint16_t report) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = CKBT51_CMD_SEND_SYSTEM;
+    payload[i++] = report & 0xFF;
+
+    ckbt51_send_cmd(payload, i, true);
+}
+
+/* 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);
+}
+
+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);
+}
+
+/* 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);
+}
+
+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);
+}
+
+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);
+}
+
+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);
+}
+
+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);
+}
+
+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, 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);
+}
+
+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, false);
+}
+
+void ckbt51_get_local_name(char* name) {
+    uint8_t i = 0;
+    memset(payload, 0, PACKET_MAX_LEN);
+
+    payload[i++] = CKBT51_CMD_GET_NAME;
+
+    ckbt51_send_cmd(payload, i, 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);
+}
+
+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);
+}
+
+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;
+
+        if ((payload[0] & 0xF0) == 0x60) {
+            ckbt51_send_cmd(payload, payload_len - 2, data[1] == 0x56);
+        }
+    }
+}
+
+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: 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_PINCODE_ENTRY;
+                    break;
+                case CKBT51_EXIT_PINCODE_ENTRY:
+                    event.evt_type = EVT_EXIT_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 && BT_DRIVER.iqueue.q_counter >= PACKECT_HEADER_LEN) {
+        uint8_t buf[32] = {0};
+
+        if (wait_for_new_pkt) {
+            if (sdGet(&BT_DRIVER) == 0xAA && sdGet(&BT_DRIVER) == 0x57) {
+                for (uint8_t i = 0; i < 3; i++) {
+                    buf[i] = sdGet(&BT_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 && BT_DRIVER.iqueue.q_counter >= len) {
+        uint8_t buf[32] = {0};
+
+        for (uint8_t i = 0; i < len; i++) {
+            buf[i] = sdGetTimeout(&BT_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 - 2, sn);
+        } else {
+            // TODO: Error handle
+        }
+    }
+}

keyboards/keychron/bluetooth/ckbt51.h

@@ -0,0 +1,155 @@
+/* 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 BT_DRIVER_UART_BANK
+#    define BT_DRIVER_UART_TX_BANK BT_DRIVER_UART_BANK
+#    define BT_DRIVER_UART_RX_BANK BT_DRIVER_UART_BANK
+#endif
+
+#ifndef BT_DRIVER_UART_TX_BANK
+#    define BT_DRIVER_UART_TX_BANK GPIOA
+#endif
+
+#ifndef BT_DRIVER_UART_RX_BANK
+#    define BT_DRIVER_UART_RX_BANK GPIOA
+#endif
+
+#ifndef BT_DRIVER_UART_TX
+#    define BT_DRIVER_UART_TX 2
+#endif
+
+#ifndef BT_DRIVER_UART_RX
+#    define BT_DRIVER_UART_RX 3
+#endif
+
+#ifndef BT_DRIVER
+#    define BT_DRIVER SD2
+#endif
+
+#ifdef USE_GPIOV1
+#    ifndef BT_DRIVER_UART_TX_PAL_MODE
+#        define BT_DRIVER_UART_TX_PAL_MODE PAL_MODE_STM32_ALTERNATE_PUSHPULL
+#    endif
+#    ifndef BT_DRIVER_UART_RX_PAL_MODE
+#        define BT_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 BT_DRIVER_UART_TX_PAL_MODE
+#        define BT_DRIVER_UART_TX_PAL_MODE 7
+#    endif
+#    ifndef BT_DRIVER_UART_RX_PAL_MODE
+#        define BT_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);
+
+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_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(char* name);
+
+void ckbt51_factory_reset(void);
+void ckbt51_int_pin_test(bool enable);
+void ckbt51_dfu_rx(uint8_t* data, uint8_t length);
+
+void ckbt51_task(void);
+

keyboards/keychron/bluetooth/factory_test.c

@@ -0,0 +1,320 @@
+/* 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 "ckbt51.h"
+#include "raw_hid.h"
+#include "transport.h"
+#include "battery.h"
+#include "via.h"
+#include "indicator.h"
+#include "lpm.h"
+
+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_RIGHT          = 0x01 << 3,
+    KEY_PRESS_HOME           = 0x01 << 4,
+    KEY_PRESS_FACTORY_RESET  = KEY_PRESS_FN | KEY_PRESS_J | KEY_PRESS_Z,
+    KEY_PRESS_BACKLIGTH_TEST = KEY_PRESS_FN | KEY_PRESS_RIGHT | KEY_PRESS_HOME,
+};
+
+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,
+};
+
+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 = sync_timer_read32() | 1;
+}
+
+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 = sync_timer_read32() | 1;
+            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 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 && sync_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 = sync_timer_read32() | 1;
+        }
+    }
+}
+
+void process_record_factory_reset(uint16_t keycode, keyrecord_t *record) {
+    switch (keycode) {
+        case MO(1): /* fall through */
+        case MO(2):
+        case MO(3):
+        case MO(4):
+            if (record->event.pressed) {
+                factory_reset_state |= KEY_PRESS_FN;
+            } else {
+                factory_reset_state &= ~KEY_PRESS_FN;
+                factory_reset_timer = 0;
+            }
+            break;
+        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;
+        case KC_RIGHT:
+            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_RIGHT;
+                    if (factory_reset_state == 0x19) factory_timer_start();
+                }
+            } else {
+                factory_reset_state &= ~KEY_PRESS_RIGHT;
+                factory_reset_timer = 0;
+            }
+            break;
+        case KC_HOME:
+            if (record->event.pressed) {
+                if (backlight_test_mode) {
+                    backlight_test_mode = BACKLIGHT_TEST_OFF;
+                } else {
+                    factory_reset_state |= KEY_PRESS_HOME;
+                    if (factory_reset_state == 0x19) factory_timer_start();
+                }
+            } else {
+                factory_reset_state &= ~KEY_PRESS_HOME;
+                factory_reset_timer = 0;
+            }
+            break;
+    }
+}
+
+#ifdef LED_MATRIX_ENABLE
+void led_matrix_indicators_advanced_user(uint8_t led_min, uint8_t led_max) {
+    if (factory_reset_ind_state) {
+        for (uint8_t i = led_min; i <= led_max; i++) {
+            led_matrix_set_value(i, factory_reset_ind_state % 2 ? 0 : 255);
+        }
+    }
+}
+#endif
+
+#ifdef RGB_MATRIX_ENABLE
+void rgb_matrix_indicators_advanced_user(uint8_t led_min, uint8_t led_max) {
+    if (factory_reset_ind_state) {
+        for (uint8_t i = led_min; i <= led_max; i++) {
+            rgb_matrix_set_color(i, factory_reset_ind_state % 2 ? 0 : 255, 0, 0);
+        }
+    } else if (backlight_test_mode) {
+        switch (backlight_test_mode) {
+            case BACKLIGHT_TEST_WHITE:
+                for (uint8_t i = led_min; i <= led_max; i++) {
+                    rgb_matrix_set_color(i, 255, 255, 255);
+                }
+                break;
+            case BACKLIGHT_TEST_RED:
+                for (uint8_t i = led_min; i <= led_max; i++) {
+                    rgb_matrix_set_color(i, 255, 0, 0);
+                }
+                break;
+            case BACKLIGHT_TEST_GREEN:
+                for (uint8_t i = led_min; i <= led_max; i++) {
+                    rgb_matrix_set_color(i, 0, 255, 0);
+                }
+                break;
+            case BACKLIGHT_TEST_BLUE:
+                for (uint8_t i = led_min; i <= led_max; i++) {
+                    rgb_matrix_set_color(i, 0, 0, 255);
+                }
+                break;
+        }
+    }
+}
+#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;
+
+        uint8_t payload[32];
+        uint8_t len = 0;
+
+        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;
+            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;
+#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
+        }
+    }
+}
+
+bool dip_switch_update_user(uint8_t index, bool active) {
+    if (report_os_sw_state) {
+        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,434 @@
+/* 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"
+#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"
+#endif
+
+#ifdef LED_MATRIX_ENABLE
+#    define DECIDE_TIME(t, duration) (duration == 0 ? LED_DISABLE_TIME_INFINITE : ((t > duration) ? t : duration))
+#endif
+#ifdef RGB_MATRIX_ENABLE
+#    define DECIDE_TIME(t, duration) (duration == 0 ? RGB_DISABLE_TIME_INFINITE : ((t > duration) ? t : duration))
+#endif
+
+#define LED_ON 0x80
+
+#define INDICATOR_SET(s)                               \
+    indicator_config.type      = s##_config.type;      \
+    indicator_config.on_time   = s##_config.on_time;   \
+    indicator_config.off_time  = s##_config.off_time;  \
+    indicator_config.duration  = s##_config.duration;  \
+    indicator_config.highlight = s##_config.highlight; \
+    indicator_config.elapsed   = 0;
+
+indicator_config_t pairing_config      = INDICATOR_CONFIG_PARING;
+indicator_config_t connected_config    = INDICATOR_CONFIG_CONNECTD;
+indicator_config_t reconnecting_config = INDICATOR_CONFIG_RECONNECTING;
+indicator_config_t disconnected_config = INDICATOR_CONFIG_DISCONNECTED;
+
+enum {
+    BACKLIGHT_OFF            = 0x00,
+    BACKLIGHT_ON_CONNECTED   = 0x01,
+    BACKLIGHT_ON_UNCONNECTED = 0x02,
+};
+
+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;
+static uint32_t          battery_low_indicator = 0;
+
+#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
+
+void indicator_init(void) {
+#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) {
+#    ifdef LED_MATRIX_ENABLE
+    if (!led_matrix_is_enabled()) {
+        led_matrix_enable_noeeprom();
+    }
+#    endif
+#    ifdef RGB_MATRIX_ENABLE
+    if (!rgb_matrix_is_enabled()) {
+        rgb_matrix_enable_noeeprom();
+    }
+#    endif
+}
+
+void indicator_disable(void) {
+#    ifdef LED_MATRIX_ENABLE
+    led_matrix_disable_noeeprom();
+#    endif
+#    ifdef RGB_MATRIX_ENABLE
+    rgb_matrix_disable_noeeprom();
+#    endif
+}
+
+void indicator_set_backlit_timeout(uint32_t time) {
+#    ifdef LED_MATRIX_ENABLE
+    led_matrix_disable_timeout_set(time);
+#    endif
+#    ifdef RGB_MATRIX_ENABLE
+    rgb_matrix_disable_timeout_set(time);
+#    endif
+}
+
+static inline void indicator_reset_backlit_time(void) {
+#    ifdef LED_MATRIX_ENABLE
+    led_matrix_disable_time_reset();
+#    endif
+#    ifdef RGB_MATRIX_ENABLE
+    rgb_matrix_disable_time_reset();
+#    endif
+}
+
+bool indicator_is_enabled(void) {
+#    ifdef LED_MATRIX_ENABLE
+    return led_matrix_is_enabled();
+#    endif
+#    ifdef RGB_MATRIX_ENABLE
+    return rgb_matrix_is_enabled();
+#    endif
+}
+
+bool indicator_is_backlit_enabled_eeprom(void) {
+#    ifdef LED_MATRIX_ENABLE
+    return led_matrix_is_enabled_eeprom();
+#    endif
+#    ifdef RGB_MATRIX_ENABLE
+    return rgb_matrix_is_enabled_eeprom();
+#    endif
+    return false;
+}
+
+#endif
+
+bool indicator_is_running(void) { return !!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;
+    }
+
+    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;
+#ifdef LED_MATRIX_ENABLE
+        led_matrix_indicators_kb();
+#endif
+#ifdef RGB_MATRIX_ENABLE
+        rgb_matrix_indicators_kb();
+#endif
+        indicator_config.value = 0;
+    }
+
+#ifdef HOST_LED_PIN_LIST
+    if (indicator_config.value && (indicator_config.value & 0x80)) {
+        writePin(host_led_pin_list[indicator_config.value & 0x0F], HOST_LED_PIN_ON_STATE);
+    } else {
+        writePin(host_led_pin_list[indicator_config.value & 0x0F], !HOST_LED_PIN_ON_STATE);
+    }
+#endif
+
+    if (indicator_config.value == 0 && !indicator_is_backlit_enabled_eeprom()) {
+        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:
+            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;
+
+    if (indicator_is_backlit_enabled_eeprom()) {
+        indicator_enable();
+    } else {
+        indicator_disable();
+    }
+}
+
+void indicator_battery_low_enable(bool enable) {
+    battery_low_indicator = enable ? (sync_timer_read32() | 1) : 0;
+#ifdef BAT_LOW_LED_PIN
+    if (!enable) writePin(BAT_LOW_LED_PIN, !BAT_LOW_LED_PIN_ON_STATE);
+#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();
+    }
+
+    if (battery_low_indicator && sync_timer_elapsed32(battery_low_indicator) > LOW_BAT_ON_OFF_DURATION) {
+#ifdef BAT_LOW_LED_PIN
+        togglePin(BAT_LOW_LED_PIN);
+#endif
+        battery_low_indicator = sync_timer_read32() | 1;
+    }
+}
+
+#ifdef LED_MATRIX_ENABLE
+void led_matrix_indicators_kb(void) {
+    if (get_transport() == TRANSPORT_BLUETOOTH) {
+        if (battery_is_critical_low()) {
+            /* Prevent backlight flash caused by key activities */
+            led_matrix_set_value_all(0);
+            return;
+        }
+
+        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) {
+                led_matrix_set_value_all(0);
+            } else if (last_host_index != host_index) {
+                led_matrix_set_value(host_led_matrix_list[last_host_index - 1], 0);
+                last_host_index = host_index;
+            }
+
+            if (indicator_config.value & 0x80)
+                led_matrix_set_value(host_led_matrix_list[host_index - 1], 255);
+            else
+                led_matrix_set_value(host_led_matrix_list[host_index - 1], 0);
+        }
+#    if defined(DIM_CAPS_LOCK) && defined(CAPS_LOCK_INDEX)
+        else if (host_keyboard_led_state().caps_lock) {
+            led_matrix_set_value(CAPS_LOCK_INDEX, 0);
+        }
+#    endif
+    }
+}
+#endif
+
+#ifdef RGB_MATRIX_ENABLE
+void rgb_matrix_indicators_kb(void) {
+    {
+        if (battery_is_critical_low()) {
+            /* Prevent backlight flash caused by key activities */
+            rgb_matrix_set_color_all(0, 0, 0);
+            return;
+        }
+
+        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) {
+                rgb_matrix_set_color_all(0, 0, 0);
+            } else if (last_host_index != host_index) {
+                rgb_matrix_set_color(host_led_matrix_list[last_host_index - 1], 0, 0, 0);
+                last_host_index = host_index;
+            }
+
+            if (indicator_config.value & 0x80) {
+                rgb_matrix_set_color(host_led_matrix_list[host_index - 1], 0, 0, 255);
+            } else {
+                rgb_matrix_set_color(host_led_matrix_list[host_index - 1], 0, 0, 0);
+            }
+        }
+#    if defined(DIM_CAPS_LOCK) && defined(CAPS_LOCK_INDEX)
+        else if (host_keyboard_led_state().caps_lock) {
+            rgb_matrix_set_color(CAPS_LOCK_INDEX, 0, 0, 0);
+        }
+#    endif
+    }
+}
+#endif

keyboards/keychron/bluetooth/indicator.h

@@ -0,0 +1,89 @@
+/* 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
+
+#ifndef LOW_BAT_ON_OFF_DURATION
+#    define LOW_BAT_ON_OFF_DURATION 1000
+#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);
+bool indicator_is_backlit_enabled_eeprom(void);
+bool indicator_is_running(void);
+
+void indicator_battery_low_enable(bool enable);
+
+void indicator_task(void);

keyboards/keychron/bluetooth/lpm.c

@@ -0,0 +1,88 @@
+/* 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
+    setPinInputHigh(USB_POWER_SENSE_PIN);
+#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())
+
+        enter_power_mode(LOW_POWER_MODE);
+}

keyboards/keychron/bluetooth/lpm.h

@@ -0,0 +1,31 @@
+/* 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,339 @@
+/* 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"
+
+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 HAL_USE_RTC
+    nvicEnableVector(STM32_EXTI20_NUMBER, 13);
+
+    PWR->CR3 |= PWR_CR3_EIWF;
+
+    RTCWakeup wakeupspec;
+    wakeupspec.wutr = 0x040014;
+    rtcSTM32SetPeriodicWakeup(&RTCD1, &wakeupspec);
+#endif
+
+#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) {
+    stm32_clock_fast_init();
+    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;
+
+#if defined(KEEP_USB_CONNECTION_IN_BLUETOOTH_MODE)
+    /* Remove USB isolation.*/
+    PWR->CR2 |= PWR_CR2_USV; /* PWR_CR2_USV is available on STM32L4x2xx and STM32L4x3xx devices only. */
+    usb_start(&USBD1);
+#endif
+
+    /* 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);
+    palDisableLineEvent(USB_POWER_SENSE_PIN);
+
+#if defined(DIP_SWITCH_PINS)
+    dip_switch_init();
+    dip_switch_read(true);
+#endif
+
+#if HAL_USE_RTC
+    rtcSTM32SetPeriodicWakeup(&RTCD1, NULL);
+    nvicDisableVector(STM32_EXTI20_NUMBER);
+#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();
+    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
+ * uart data coming when wakeup pin interrupt of MCU  is triggerred.
+ * Here we reduce clock init time to 100us.
+ */
+inline void stm32_clock_fast_init(void) {
+#if !STM32_NO_INIT
+    /* Core voltage setup.*/
+    PWR->CR1 = STM32_VOS;
+    while ((PWR->SR2 & PWR_SR2_VOSF) != 0) /* Wait until regulator is      */
+        ;                                  /* stable.                      */
+
+#    if STM32_HSI16_ENABLED  // 10.7us
+    /* HSI activation.*/
+    RCC->CR |= RCC_CR_HSION;
+    while ((RCC->CR & RCC_CR_HSIRDY) == 0)
+        ; /* Wait until HSI16 is stable.  */
+#    endif
+
+#    if STM32_CLOCK_HAS_HSI48  // 13us
+#        if STM32_HSI48_ENABLED
+    /* HSI activation.*/
+    RCC->CRRCR |= RCC_CRRCR_HSI48ON;
+    while ((RCC->CRRCR & RCC_CRRCR_HSI48RDY) == 0)
+        ; /* Wait until HSI48 is stable.  */
+#        endif
+#    endif
+
+#    if STM32_ACTIVATE_PLL || STM32_ACTIVATE_PLLSAI1 || STM32_ACTIVATE_PLLSAI2
+        /* PLLM and PLLSRC are common to all PLLs.*/
+#        if defined(STM32L496xx) || defined(STM32L4A6xx)
+    RCC->PLLCFGR = STM32_PLLPDIV | STM32_PLLR | STM32_PLLREN | STM32_PLLQ | STM32_PLLQEN | STM32_PLLP | STM32_PLLPEN | STM32_PLLN | STM32_PLLM | STM32_PLLSRC;
+#        else
+    RCC->PLLCFGR = STM32_PLLR | STM32_PLLREN | STM32_PLLQ | STM32_PLLQEN | STM32_PLLP | STM32_PLLPEN | STM32_PLLN | STM32_PLLM | STM32_PLLSRC;
+#        endif
+#    endif
+
+#    if STM32_ACTIVATE_PLL
+    /* PLL activation.*/
+    RCC->CR |= RCC_CR_PLLON;
+
+    /* Waiting for PLL lock.*/
+    while ((RCC->CR & RCC_CR_PLLRDY) == 0)
+        ;
+#    endif
+
+    /* 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 */
+
+    /* SYSCFG clock enabled here because it is a multi-functional unit shared
+       among multiple drivers.*/
+    rccEnableAPB2(RCC_APB2ENR_SYSCFGEN, true);
+}

keyboards/keychron/bluetooth/lpm_stm32l432.h

@@ -0,0 +1,19 @@
+/* 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
+
+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 256
+#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];
+uint8_t         report_buffer_queue_head;
+uint8_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) {
+    uint8_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.keyboard.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,50 @@
+/* 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;
+        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/transport.c

@@ -0,0 +1,182 @@
+
+#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
+
+#ifdef NKRO_ENABLE
+typedef struct {
+    bool usb : 1;
+    bool bluetooth : 1;
+} nkro_t;
+#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
+static 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_DISABLE_TIMEOUT)
+#    if (RGB_DISABLE_TIMEOUT > 0)
+    rgb_matrix_disable_timeout_set(RGB_DISABLE_TIME_INFINITE);
+    rgb_matrix_disable_time_reset();
+#    endif
+#endif
+#if defined(LED_MATRIX_ENABLE) && defined(LED_DISABLE_TIMEOUT)
+#    if (LED_DISABLE_TIMEOUT > 0)
+    led_matrix_disable_timeout_set(LED_DISABLE_TIME_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);
+                usb_wakeup(&USB_DRIVER);
+            }
+        }
+        /* Woken up */
+        // variables has been already cleared by the wakeup hook
+        send_keyboard_report();
+    }
+}

keyboards/keychron/bluetooth/transport.h

@@ -0,0 +1,32 @@
+/* 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
+
+typedef enum {
+    TRANSPORT_NONE,
+    TRANSPORT_USB,
+    TRANSPORT_BLUETOOTH,
+} transport_t;
+
+void        set_transport(transport_t new_transport);
+transport_t get_transport(void);
+
+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/k8_pro/ansi/info.json

@@ -0,0 +1,103 @@
+{
+    "keyboard_name": "Keychron K8 Pro",
+    "url": "https://github.com/Keychron",
+    "maintainer": "lokher",
+    "layouts": {
+        "LAYOUT_ansi_87": {
+            "layout": [
+                {"label":"Esc", "x":0, "y":0},
+                {"label":"F1", "x":2, "y":0},
+                {"label":"F2", "x":3, "y":0},
+                {"label":"F3", "x":4, "y":0},
+                {"label":"F4", "x":5, "y":0},
+                {"label":"F5", "x":6.5, "y":0},
+                {"label":"F5", "x":7.5, "y":0},
+                {"label":"F7", "x":8.5, "y":0},
+                {"label":"F8", "x":9.5, "y":0},
+                {"label":"F9", "x":11, "y":0},
+                {"label":"F10", "x":12, "y":0},
+                {"label":"F11", "x":13, "y":0},
+                {"label":"F12", "x":14, "y":0},
+                {"label":"Print", "x":15.25, "y":0},
+                {"label":"Cortana", "x":16.25, "y":0},
+                {"label":"Light", "x":17.25, "y":0},
+
+                {"label":"`~", "x":0, "y":1.25},
+                {"label":"1!", "x":1, "y":1.25},
+                {"label":"2@", "x":2, "y":1.25},
+                {"label":"3#", "x":3, "y":1.25},
+                {"label":"4$", "x":4, "y":1.25},
+                {"label":"5%", "x":5, "y":1.25},
+                {"label":"6^", "x":6, "y":1.25},
+                {"label":"7&", "x":7, "y":1.25},
+                {"label":"8*", "x":8, "y":1.25},
+                {"label":"9(", "x":9, "y":1.25},
+                {"label":"0)", "x":10, "y":1.25},
+                {"label":"-_", "x":11, "y":1.25},
+                {"label":"=+", "x":12, "y":1.25},
+                {"label":"Backspace", "x":13, "y":1.25, "w":2},
+                {"label":"Insert", "x":15.25, "y":1.25},
+                {"label":"Home", "x":16.25, "y":1.25},
+                {"label":"Page Up", "x":17.25, "y":1.25},
+
+                {"label":"Tab", "x":0, "y":2.25, "w":1.5},
+                {"label":"Q", "x":1.5, "y":2.25},
+                {"label":"W", "x":2.5, "y":2.25},
+                {"label":"E", "x":3.5, "y":2.25},
+                {"label":"R", "x":4.5, "y":2.25},
+                {"label":"T", "x":5.5, "y":2.25},
+                {"label":"Y", "x":6.5, "y":2.25},
+                {"label":"U", "x":7.5, "y":2.25},
+                {"label":"I", "x":8.5, "y":2.25},
+                {"label":"O", "x":9.5, "y":2.25},
+                {"label":"P", "x":10.5, "y":2.25},
+                {"label":"[{", "x":11.5, "y":2.25},
+                {"label":"]}", "x":12.5, "y":2.25},
+                {"label":"\\|", "x":13.5, "y":2.25, "w":1.5},
+                {"label":"Delete", "x":15.25, "y":2.25},
+                {"label":"End", "x":16.25, "y":2.25},
+                {"label":"Page Down", "x":17.25, "y":2.25},
+
+                {"label":"Caps Lock", "x":0, "y":3.25, "w":1.75},
+                {"label":"A", "x":1.75, "y":3.25},
+                {"label":"S", "x":2.75, "y":3.25},
+                {"label":"D", "x":3.75, "y":3.25},
+                {"label":"F", "x":4.75, "y":3.25},
+                {"label":"G", "x":5.75, "y":3.25},
+                {"label":"H", "x":6.75, "y":3.25},
+                {"label":"J", "x":7.75, "y":3.25},
+                {"label":"K", "x":8.75, "y":3.25},
+                {"label":"L", "x":9.75, "y":3.25},
+                {"label":";:", "x":10.75, "y":3.25},
+                {"label":"'\"", "x":11.75, "y":3.25},
+                {"label":"Enter", "x":12.75, "y":3.25, "w":2.25},
+
+                {"label":"Left Shift", "x":0, "y":4.25, "w":2.25},
+                {"label":"Z", "x":2.25, "y":4.25},
+                {"label":"X", "x":3.25, "y":4.25},
+                {"label":"C", "x":4.25, "y":4.25},
+                {"label":"V", "x":5.25, "y":4.25},
+                {"label":"B", "x":6.25, "y":4.25},
+                {"label":"N", "x":7.25, "y":4.25},
+                {"label":"M", "x":8.25, "y":4.25},
+                {"label":",<", "x":9.25, "y":4.25},
+                {"label":".>", "x":10.25, "y":4.25},
+                {"label":"/?", "x":11.25, "y":4.25},
+                {"label":"Right Shift", "x":12.25, "y":4.25, "w":2.75},
+                {"label":"Up", "x":16.25, "y":4.25},
+
+                {"label":"Left Ctrl", "x":0, "y":5.25, "w":1.25},
+                {"label":"Left Win", "x":1.25, "y":5.25, "w":1.25},
+                {"label":"Left Alt", "x":2.5, "y":5.25, "w":1.25},
+                {"label":"Space", "x":3.75, "y":5.25, "w":6.25},
+                {"label":"Right Alt", "x":10, "y":5.25, "w":1.25},
+                {"label":"Right Win", "x":11.25, "y":5.25, "w":1.25},
+                {"label":"Fn", "x":12.5, "y":5.25, "w":1.25},
+                {"label":"Right Ctrl", "x":13.75, "y":5.25, "w":1.25},
+                {"label":"Left", "x":15.25, "y":5.25},
+                {"label":"Down", "x":16.25, "y":5.25},
+                {"label":"Right", "x":17.25, "y":5.25}
+            ]
+        }
+    }
+}

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

@@ -0,0 +1,78 @@
+/* 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/>.
+ */
+
+
+#define PRODUCT_ID      0x0280
+#define DEVICE_VER      0x0101
+
+#ifdef RGB_MATRIX_ENABLE
+/* RGB Matrix driver configuration */
+#    define DRIVER_COUNT 2
+
+#    define DRIVER_ADDR_1 0b1110111
+#    define DRIVER_ADDR_2 0b1110100
+#    define DRIVER_1_LED_TOTAL 47
+#    define DRIVER_2_LED_TOTAL 40
+#    define DRIVER_LED_TOTAL (DRIVER_1_LED_TOTAL + DRIVER_2_LED_TOTAL)
+
+/* Set to infinit, which is use in USB mode by default */
+#define RGB_DISABLE_TIMEOUT RGB_DISABLE_TIME_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
+
+#    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
+#    define ENABLE_RGB_MATRIX_BREATHING
+#    define ENABLE_RGB_MATRIX_BAND_SPIRAL_VAL
+#    define ENABLE_RGB_MATRIX_CYCLE_ALL
+#    define ENABLE_RGB_MATRIX_CYCLE_LEFT_RIGHT
+#    define ENABLE_RGB_MATRIX_CYCLE_UP_DOWN
+#    define ENABLE_RGB_MATRIX_RAINBOW_MOVING_CHEVRON
+#    define ENABLE_RGB_MATRIX_CYCLE_OUT_IN
+#    define ENABLE_RGB_MATRIX_CYCLE_OUT_IN_DUAL
+#    define ENABLE_RGB_MATRIX_CYCLE_PINWHEEL
+#    define ENABLE_RGB_MATRIX_CYCLE_SPIRAL
+#    define ENABLE_RGB_MATRIX_DUAL_BEACON
+#    define ENABLE_RGB_MATRIX_RAINBOW_BEACON
+#    define ENABLE_RGB_MATRIX_JELLYBEAN_RAINDROPS
+#    define ENABLE_RGB_MATRIX_PIXEL_RAIN
+
+/* enabled only if RGB_MATRIX_FRAMEBUFFER_EFFECTS is defined */
+#    define ENABLE_RGB_MATRIX_TYPING_HEATMAP
+#    define ENABLE_RGB_MATRIX_DIGITAL_RAIN
+
+/*  enabled only of RGB_MATRIX_KEYPRESSES or RGB_MATRIX_KEYRELEASES is defined*/
+#    define ENABLE_RGB_MATRIX_SOLID_REACTIVE_SIMPLE
+#    define ENABLE_RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE
+#    define ENABLE_RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS
+#    define ENABLE_RGB_MATRIX_SPLASH
+#    define ENABLE_RGB_MATRIX_SOLID_SPLASH
+
+/* Set LED driver current */
+#define CKLED2001_CURRENT_TUNE   {0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38}
+
+#endif

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

@@ -0,0 +1,59 @@
+/* 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 QMK_KEYBOARD_H
+
+enum layers{
+  MAC_BASE,
+  MAC_FN,
+  WIN_BASE,
+  WIN_FN
+};
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+[MAC_BASE] = LAYOUT_ansi_87( 
+     KC_ESC,   KC_BRID,  KC_BRIU,  KC_MCTL,  KC_LNPD,  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_ansi_87( 
+     KC_TRNS,  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_TRNS,  KC_TRNS,  RGB_TOG,
+     KC_TRNS,  BT_HST1,  BT_HST2,  BT_HST3,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+     RGB_TOG,  RGB_MOD,  RGB_VAI,  RGB_HUI,  RGB_SAI,  RGB_SPI,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+     KC_TRNS,  RGB_RMOD, RGB_VAD,  RGB_HUD,  RGB_SAD,  RGB_SPD,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,           
+     KC_TRNS,            KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  BAT_LVL,  NK_TOGG,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,            KC_TRNS,   
+     KC_TRNS,  KC_TRNS,  KC_TRNS,                                KC_TRNS,                                KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS),
+
+[WIN_BASE] = LAYOUT_ansi_87( 
+     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_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_LGUI,  KC_LALT,                                KC_SPC,                                 KC_RALT,  KC_RGUI, MO(WIN_FN),KC_RCTL,  KC_LEFT,  KC_DOWN,  KC_RGHT),
+
+[WIN_FN] = LAYOUT_ansi_87( 
+     KC_TRNS,  KC_BRID,  KC_BRIU,  KC_TASK,  KC_FILE,  RGB_VAD,  RGB_VAI,  KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_MUTE,  KC_VOLD,  KC_VOLU,            KC_TRNS,  KC_TRNS,  RGB_TOG,
+     KC_TRNS,  BT_HST1,  BT_HST2,  BT_HST3,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+     RGB_TOG,  RGB_MOD,  RGB_VAI,  RGB_HUI,  RGB_SAI,  RGB_SPI,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+     KC_TRNS,  RGB_RMOD, RGB_VAD,  RGB_HUD,  RGB_SAD,  RGB_SPD,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,           
+     KC_TRNS,            KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  BAT_LVL,  NK_TOGG,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,            KC_TRNS,   
+     KC_TRNS,  KC_TRNS,  KC_TRNS,                                KC_TRNS,                                KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS)
+    
+};

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

@@ -0,0 +1,59 @@
+/* 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 QMK_KEYBOARD_H
+
+enum layers{
+  MAC_BASE,
+  MAC_FN,
+  WIN_BASE,
+  WIN_FN
+};
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+[MAC_BASE] = LAYOUT_ansi_87( 
+     KC_ESC,   KC_BRID,  KC_BRIU,  KC_MCTL,  KC_LNPD,  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_ansi_87( 
+     KC_TRNS,  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_TRNS,  KC_TRNS,  RGB_TOG,
+     KC_TRNS,  BT_HST1,  BT_HST2,  BT_HST3,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+     RGB_TOG,  RGB_MOD,  RGB_VAI,  RGB_HUI,  RGB_SAI,  RGB_SPI,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+     KC_TRNS,  RGB_RMOD, RGB_VAD,  RGB_HUD,  RGB_SAD,  RGB_SPD,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,           
+     KC_TRNS,            KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  BAT_LVL,  NK_TOGG,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,            KC_TRNS,   
+     KC_TRNS,  KC_TRNS,  KC_TRNS,                                KC_TRNS,                                KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS),
+
+[WIN_BASE] = LAYOUT_ansi_87( 
+     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_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_LGUI,  KC_LALT,                                KC_SPC,                                 KC_RALT,  KC_RGUI, MO(WIN_FN),KC_RCTL,  KC_LEFT,  KC_DOWN,  KC_RGHT),
+
+[WIN_FN] = LAYOUT_ansi_87( 
+     KC_TRNS,  KC_BRID,  KC_BRIU,  KC_TASK,  KC_FILE,  RGB_VAD,  RGB_VAI,  KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_MUTE,  KC_VOLD,  KC_VOLU,            KC_TRNS,  KC_TRNS,  RGB_TOG,
+     KC_TRNS,  BT_HST1,  BT_HST2,  BT_HST3,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+     RGB_TOG,  RGB_MOD,  RGB_VAI,  RGB_HUI,  RGB_SAI,  RGB_SPI,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+     KC_TRNS,  RGB_RMOD, RGB_VAD,  RGB_HUD,  RGB_SAD,  RGB_SPD,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,           
+     KC_TRNS,            KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  BAT_LVL,  NK_TOGG,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,            KC_TRNS,   
+     KC_TRNS,  KC_TRNS,  KC_TRNS,                                KC_TRNS,                                KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS)
+
+};

keyboards/keychron/k8_pro/ansi/rgb/keymaps/via/rules.mk

@@ -0,0 +1 @@
+VIA_ENABLE = yes

keyboards/keychron/k8_pro/ansi/rgb/rgb.c

@@ -0,0 +1,148 @@
+/* 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"
+
+#ifdef RGB_MATRIX_ENABLE
+const ckled2001_led g_ckled2001_leds[DRIVER_LED_TOTAL] = {
+/* Refer to IS31 manual for these locations
+ *   driver
+ *   |  R location
+ *   |  |       G location
+ *   |  |       |       B location
+ *   |  |       |       | */
+    {0, I_1,    G_1,    H_1},
+    {0, G_2,    H_2,    I_2},
+    {0, H_3,    I_3,    G_3},
+    {0, I_4,    G_4,    H_4},
+    {0, G_5,    H_5,    I_5},
+    {0, H_6,    I_6,    G_6},
+    {0, I_7,    G_7,    H_7},
+    {0, G_8,    H_8,    I_8},
+    {0, H_9,    I_9,    G_9},
+    {0, I_10,   G_10,   H_10},
+    {0, G_11,   H_11,   I_11},
+    {0, H_12,   I_12,   G_12},
+    {0, I_13,   G_13,   H_13},
+    {0, H_15,   I_15,   G_15},
+    {0, I_16,   G_16,   H_16},
+    {1, A_2,    B_2,    C_2,},
+    
+    {0, C_1,    A_1,    B_1},
+    {0, A_2,    B_2,    C_2},
+    {0, B_3,    C_3,    A_3},
+    {0, C_4,    A_4,    B_4},
+    {0, A_5,    B_5,    C_5},
+    {0, B_6,    C_6,    A_6},
+    {0, C_7,    A_7,    B_7},
+    {0, A_8,    B_8,    C_8},
+    {0, B_9,    C_9,    A_9},
+    {0, C_10,   A_10,   B_10},
+    {0, A_11,   B_11,   C_11},
+    {0, B_12,   C_12,   A_12},
+    {0, C_13,   A_13,   B_13},
+    {0, A_14,   B_14,   C_14},
+    {0, B_15,   C_15,   A_15},
+    {0, C_16,   A_16,   B_16},
+    {1, G_2,    H_2,    I_2},
+
+    {0, F_1,    D_1,    E_1},
+    {0, D_2,    E_2,    F_2},
+    {0, E_3,    F_3,    D_3},
+    {0, F_4,    D_4,    E_4},
+    {0, D_5,    E_5,    F_5},
+    {0, E_6,    F_6,    D_6},
+    {0, F_7,    D_7,    E_7},
+    {0, D_8,    E_8,    F_8},
+    {0, E_9,    F_9,    D_9},
+    {0, F_10,   D_10,   E_10},
+    {0, D_11,   E_11,   F_11},
+    {0, E_12,   F_12,   D_12},
+    {0, F_13,   D_13,   E_13},
+    {0, D_14,   E_14,   F_14},
+    {0, E_15,   F_15,   D_15},
+    {0, F_16,   D_16,   E_16},
+    {1, A_1,    B_1,    C_1},
+
+    {1, C_16,   A_16,   B_16},
+    {1, A_15,   B_15,   C_15},
+    {1, B_14,   C_14,   A_14},
+    {1, C_13,   A_13,   B_13},
+    {1, A_12,   B_12,   C_12},
+    {1, B_11,   C_11,   A_11},
+    {1, C_10,   A_10,   B_10},
+    {1, A_9,    B_9,    C_9},
+    {1, B_8,    C_8,    A_8},
+    {1, C_7,    A_7,    B_7},
+    {1, A_6,    B_6,    C_6},
+    {1, B_5,    C_5,    A_5},
+    {1, A_3,    B_3,    C_3},
+
+    {1, I_16,   G_16,   H_16},
+    {1, H_14,   I_14,   G_14},
+    {1, I_13,   G_13,   H_13},
+    {1, G_12,   H_12,   I_12},
+    {1, H_11,   I_11,   G_11},
+    {1, I_10,   G_10,   H_10},
+    {1, G_9,    H_9,    I_9},
+    {1, H_8,    I_8,    G_8},
+    {1, I_7,    G_7,    H_7},
+    {1, G_6,    H_6,    I_6},
+    {1, H_5,    I_5,    G_5},
+    {1, G_3,    H_3,    I_3},
+    {1, I_1,    G_1,    H_1},
+
+    {1, F_16,   D_16,   E_16},
+    {1, D_15,   E_15,   F_15},
+    {1, E_14,   F_14,   D_14},
+    {1, F_10,   D_10,   E_10},
+    {1, D_6,    E_6,    F_6},
+    {1, E_5,    F_5,    D_5},
+    {1, F_4,    D_4,    E_4},
+    {1, D_3,    E_3,    F_3},
+    {1, E_2,    F_2,    D_2},
+    {1, F_1,    D_1,    E_1},
+    {1, A_4,    B_4,    C_4}
+};
+
+
+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,     NO_LED, 62,     NO_LED, NO_LED, NO_LED },
+		{  63,     NO_LED, 64,     65,     66,     67,     68,     69,     70,     71,     72,     73,     NO_LED, 74,     NO_LED, 75,     NO_LED },
+		{  76,     77,     78,     NO_LED, NO_LED, NO_LED, 79,     NO_LED, NO_LED, NO_LED, 80,     81,     82,     83,     84,     85,     86}
+	},
+	{
+        {0, 0},          {25, 0}, {38, 0}, {51, 0}, {64, 0}, {84, 0}, { 97, 0}, {110, 0}, {123, 0}, {142, 0}, {155, 0}, {168, 0}, {181, 0}, {198, 0}, {211, 0}, {224, 0},
+        {0,14}, {12,14}, {25,14}, {38,14}, {51,14}, {64,14}, {77,14}, { 90,14}, {103,14}, {116,14}, {129,14}, {142,14}, {155,14}, {175,14}, {198,14}, {211,14}, {224,14},
+        {3,26}, {19,26}, {32,26}, {45,26}, {58,26}, {71,26}, {84,26}, { 97,26}, {110,26}, {123,26}, {136,26}, {149,26}, {162,26}, {178,26}, {198,26}, {211,26}, {224,26},
+        {4,39}, {22,39}, {35,39}, {48,39}, {61,39}, {74,39}, {87,39}, {100,39}, {113,39}, {126,39}, {139,39}, {152,39},           {173,39},
+        {8,51}, {29,51}, {42,51}, {55,51}, {68,51}, {81,51}, {94,51}, {107,51}, {120,51}, {132,51}, {145,51},                     {170,51},           {211,51},
+        {1,64}, {17,64}, {34,64},                            {82,64},                               {131,64}, {147,64}, {163,64}, {180,64}, {198,64}, {211,64}, {224,64}
+    },
+	{
+        4,    4,    4,    4,    4,    4,    4,    4,    4,    4,    4,    4,    4,          4,    4,    4,
+        4,    8,    8,    8,    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/k8_pro/ansi/rgb/rules.mk

@@ -0,0 +1,3 @@
+RGB_MATRIX_ENABLE = yes
+RGB_MATRIX_DRIVER = CKLED2001
+

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

@@ -0,0 +1,64 @@
+/* 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/>.
+ */
+
+
+#define PRODUCT_ID      0x0283
+#define DEVICE_VER      0x0101
+
+#ifdef LED_MATRIX_ENABLE
+/* LED matrix driver configuration */
+#    define DRIVER_COUNT 1
+#    define DRIVER_ADDR_1 0b1110100
+#    define DRIVER_LED_TOTAL 87
+
+/* Set to infinit, which is use in USB mode by default */
+#define LED_DISABLE_TIMEOUT LED_DISABLE_TIME_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
+
+/* 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
+
+#    define ENABLE_LED_MATRIX_NONE
+#    define ENABLE_LED_MATRIX_SOLID
+#    define ENABLE_LED_MATRIX_BREATHING
+#    define ENABLE_LED_MATRIX_BAND_PINWHEEL
+#    define ENABLE_LED_MATRIX_BAND_SPIRAL
+#    define ENABLE_LED_MATRIX_CYCLE_LEFT_RIGHT
+#    define ENABLE_LED_MATRIX_CYCLE_UP_DOWN
+#    define ENABLE_LED_MATRIX_CYCLE_OUT_IN
+#    define ENABLE_LED_MATRIX_DUAL_BEACON
+#    define ENABLE_LED_MATRIX_SOLID_REACTIVE_SIMPLE
+#    define ENABLE_LED_MATRIX_SOLID_REACTIVE_MULTIWIDE
+#    define ENABLE_LED_MATRIX_SOLID_REACTIVE_MULTINEXUS
+#    define ENABLE_LED_MATRIX_SOLID_SPLASH
+#    define ENABLE_LED_MATRIX_WAVE_LEFT_RIGHT
+#    define ENABLE_LED_MATRIX_WAVE_UP_DOWN
+#    define ENABLE_LED_MATRIX_EFFECT_MAX
+
+/* Use first 6 channels of LED driver */
+#define PHASE_CHANNEL MSKPHASE_6CHANNEL
+
+/* Set LED driver current */
+#define CKLED2001_CURRENT_TUNE  { 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60 }
+
+
+#endif

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

@@ -0,0 +1,59 @@
+/* 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 QMK_KEYBOARD_H
+
+enum layers{
+  MAC_BASE,
+  MAC_FN,
+  WIN_BASE,
+  WIN_FN
+};
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+[MAC_BASE] = LAYOUT_ansi_87( 
+     KC_ESC,   KC_BRID,  KC_BRIU,  KC_MCTL,  KC_LNPD,  BL_DEC,   BL_INC,   KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_MUTE,  KC_VOLD,  KC_VOLU,           KC_SNAP,   KC_SIRI,  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_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_ansi_87( 
+     KC_TRNS,  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_TRNS,  KC_TRNS,  BL_TOGG,
+     KC_TRNS,  BT_HST1,  BT_HST2,  BT_HST3,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+     BL_TOGG,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+     KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,           
+     KC_TRNS,            KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  BAT_LVL,  NK_TOGG,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,            KC_TRNS,   
+     KC_TRNS,  KC_TRNS,  KC_TRNS,                                KC_TRNS,                                KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS),
+
+[WIN_BASE] = LAYOUT_ansi_87( 
+     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_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_LGUI,  KC_LALT,                                KC_SPC,                                 KC_RALT,  KC_RGUI, MO(WIN_FN),KC_RCTL,  KC_LEFT,  KC_DOWN,  KC_RGHT),
+
+[WIN_FN] = LAYOUT_ansi_87( 
+     KC_TRNS,  KC_BRID,  KC_BRIU,  KC_TASK,  KC_FILE,  BL_DEC,   BL_INC,   KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_MUTE,  KC_VOLD,  KC_VOLU,            KC_TRNS,  KC_TRNS,  BL_TOGG,
+     KC_TRNS,  BT_HST1,  BT_HST2,  BT_HST3,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+     BL_TOGG,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+     KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,           
+     KC_TRNS,            KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  BAT_LVL,  NK_TOGG,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,            KC_TRNS,   
+     KC_TRNS,  KC_TRNS,  KC_TRNS,                                KC_TRNS,                                KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS)
+    
+};

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

@@ -0,0 +1,59 @@
+/* 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 QMK_KEYBOARD_H
+
+enum layers{
+  MAC_BASE,
+  MAC_FN,
+  WIN_BASE,
+  WIN_FN
+};
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+[MAC_BASE] = LAYOUT_ansi_87( 
+     KC_ESC,   KC_BRID,  KC_BRIU,  KC_MCTL,  KC_LNPD,  BL_DEC,   BL_INC,   KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_MUTE,  KC_VOLD,  KC_VOLU,           KC_SNAP,   KC_SIRI,  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_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_ansi_87( 
+     KC_TRNS,  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_TRNS,  KC_TRNS,  BL_TOGG,
+     KC_TRNS,  BT_HST1,  BT_HST2,  BT_HST3,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+     BL_TOGG,  BL_STEP,  BL_INC,   KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+     KC_TRNS,  KC_TRNS,  BL_DEC,   KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,           
+     KC_TRNS,            KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  BAT_LVL,  NK_TOGG,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,            KC_TRNS,   
+     KC_TRNS,  KC_TRNS,  KC_TRNS,                                KC_TRNS,                                KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS),
+
+[WIN_BASE] = LAYOUT_ansi_87( 
+     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_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_LGUI,  KC_LALT,                                KC_SPC,                                 KC_RALT,  KC_RGUI, MO(WIN_FN),KC_RCTL,  KC_LEFT,  KC_DOWN,  KC_RGHT),
+
+[WIN_FN] = LAYOUT_ansi_87( 
+     KC_TRNS,  KC_BRID,  KC_BRIU,  KC_TASK,  KC_FILE,  BL_DEC,   BL_INC,   KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_MUTE,  KC_VOLD,  KC_VOLU,            KC_TRNS,  KC_TRNS,  BL_TOGG,
+     KC_TRNS,  BT_HST1,  BT_HST2,  BT_HST3,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+     BL_TOGG,  BL_STEP,  BL_INC,   KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+     KC_TRNS,  KC_TRNS,  BL_DEC,   KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,           
+     KC_TRNS,            KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  BAT_LVL,  NK_TOGG,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,            KC_TRNS,   
+     KC_TRNS,  KC_TRNS,  KC_TRNS,                                KC_TRNS,                                KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS)
+    
+};

keyboards/keychron/k8_pro/ansi/white/keymaps/via/rules.mk

@@ -0,0 +1 @@
+VIA_ENABLE = yes

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

@@ -0,0 +1,2 @@
+LED_MATRIX_ENABLE = yes
+LED_MATRIX_DRIVER = CKLED2001

keyboards/keychron/k8_pro/ansi/white/white.c

@@ -0,0 +1,147 @@
+/* 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"
+
+#ifdef LED_MATRIX_ENABLE
+const ckled2001_led g_ckled2001_leds[DRIVER_LED_TOTAL] = {
+/* Refer to IS31 manual for these locations
+ *   driver
+ *   |  LED address
+ *   |  | */
+    {0, A_16},
+    {0, A_15},
+    {0, A_14},
+    {0, A_13},
+    {0, A_12},
+    {0, A_11},
+    {0, A_10},
+    {0, A_9},
+    {0, A_8},
+    {0, A_7},
+    {0, A_6},
+    {0, A_5},
+    {0, A_4},
+    {0, A_2},
+    {0, A_1},
+    {0, D_2},
+
+    {0, B_16},
+    {0, B_15},
+    {0, B_14},
+    {0, B_13},
+    {0, B_12},
+    {0, B_11},
+    {0, B_10},
+    {0, B_9},
+    {0, B_8},
+    {0, B_7},
+    {0, B_6},
+    {0, B_5},
+    {0, B_4},
+    {0, B_3},
+    {0, B_2},
+    {0, B_1},
+    {0, E_2},
+
+    {0, C_16},
+    {0, C_15},
+    {0, C_14},
+    {0, C_13},
+    {0, C_12},
+    {0, C_11},
+    {0, C_10},
+    {0, C_9},
+    {0, C_8},
+    {0, C_7},
+    {0, C_6},
+    {0, C_5},
+    {0, C_4},
+    {0, C_3},
+    {0, C_2},
+    {0, C_1},
+    {0, D_1},
+
+    {0, D_16},
+    {0, D_15},
+    {0, D_14},
+    {0, D_13},
+    {0, D_12},
+    {0, D_11},
+    {0, D_10},
+    {0, D_9},
+    {0, D_8},
+    {0, D_7},
+    {0, D_6},
+    {0, D_5},
+    {0, D_3},
+
+    {0, E_16},
+    {0, E_14},
+    {0, E_13},
+    {0, E_12},
+    {0, E_11},
+    {0, E_10},
+    {0, E_9},
+    {0, E_8},
+    {0, E_7},
+    {0, E_6},
+    {0, E_5},
+    {0, E_3},
+    {0, E_1},
+
+    {0, F_16},
+    {0, F_15},
+    {0, F_14},
+    {0, F_10},
+    {0, F_6},
+    {0, F_5},
+    {0, F_4},
+    {0, F_3},
+    {0, F_2},
+    {0, F_1}, 
+    {0, D_4},
+};
+
+
+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,     NO_LED, 62,     NO_LED, NO_LED, NO_LED },
+		{  63,     NO_LED, 64,     65,     66,     67,     68,     69,     70,     71,     72,     73,     NO_LED, 74,     NO_LED, 75,     NO_LED },
+		{  76,     77,     78,     NO_LED, NO_LED, NO_LED, 79,     NO_LED, NO_LED, NO_LED, 80,     81,     82,     83,     84,     85,     86}
+	},
+	{
+        {0, 0},          {25, 0}, {38, 0}, {51, 0}, {64, 0}, {84, 0}, { 97, 0}, {110, 0}, {123, 0}, {142, 0}, {155, 0}, {168, 0}, {181, 0}, {198, 0}, {211, 0}, {224, 0},
+        {0,14}, {12,14}, {25,14}, {38,14}, {51,14}, {64,14}, {77,14}, { 90,14}, {103,14}, {116,14}, {129,14}, {142,14}, {155,14}, {175,14}, {198,14}, {211,14}, {224,14},
+        {3,26}, {19,26}, {32,26}, {45,26}, {58,26}, {71,26}, {84,26}, { 97,26}, {110,26}, {123,26}, {136,26}, {149,26}, {162,26}, {178,26}, {198,26}, {211,26}, {224,26},
+        {4,39}, {22,39}, {35,39}, {48,39}, {61,39}, {74,39}, {87,39}, {100,39}, {113,39}, {126,39}, {139,39}, {152,39},           {173,39},
+        {8,51}, {29,51}, {42,51}, {55,51}, {68,51}, {81,51}, {94,51}, {107,51}, {120,51}, {132,51}, {145,51},                     {170,51},           {211,51},
+        {1,64}, {17,64}, {34,64},                            {82,64},                               {131,64}, {147,64}, {163,64}, {180,64}, {198,64}, {211,64}, {224,64}
+    },
+	{
+        4,    4,    4,    4,    4,    4,    4,    4,    4,    4,    4,    4,    4,          4,    4,    4,
+        4,    8,    8,    8,    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/k8_pro/config.h

@@ -0,0 +1,106 @@
+/* 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
+
+/* USB Device descriptor parameter */
+#define VENDOR_ID 0x3434
+#define MANUFACTURER Keychron
+#define PRODUCT Keychron K8 Pro
+
+/* key matrix size */
+#define MATRIX_ROWS 6
+#define MATRIX_COLS 17
+
+/* Key matrix pins */
+#define MATRIX_ROW_PINS \
+    { B5, B4, B3, A15, A14, A13 }
+#define MATRIX_COL_PINS \
+    { B0, NO_PIN, NO_PIN, NO_PIN, NO_PIN, NO_PIN, NO_PIN, NO_PIN, NO_PIN, NO_PIN, NO_PIN, NO_PIN, NO_PIN, NO_PIN, NO_PIN, NO_PIN, NO_PIN }
+
+/* COL2ROW or ROW2COL */
+#define DIODE_DIRECTION ROW2COL
+
+/* Turn off effects when suspended */
+#define RGB_DISABLE_WHEN_USB_SUSPENDED
+
+/* Set 0 if debouncing isn't needed */
+#define DEBOUNCE 5
+
+/* DIP switch for Mac/win OS switch */
+#define DIP_SWITCH_PINS \
+    { A8 }
+
+/* Caps lock LED Pin */
+#define LED_CAPS_LOCK_PIN A7
+#define LED_PIN_ON_STATE 1
+
+#ifdef BLUETOOTH_ENABLE
+/* Hardware configuration */
+#    define USB_BT_MODE_SELECT_PIN A10
+
+#    define CKBT51_RESET_PIN A9
+#    define CKBT51_INT_INPUT_PIN A5
+#    define BLUETOOTH_INT_INPUT_PIN A6
+
+#    define USB_POWER_SENSE_PIN B1
+#    define USB_POWER_CONNECTED_LEVEL 0
+
+#    define BAT_LOW_LED_PIN A4
+#    define BAT_LOW_LED_PIN_ON_STATE 1
+
+#    define HOST_DEVICES_COUNT 3
+
+#    define HOST_LED_PIN_LIST \
+        { H3, H3, H3 }
+#    define HOST_LED_PIN_ON_STATE 1
+
+#    if defined(RGB_MATRIX_ENABLE) || defined(LED_MATRIX_ENABLE)
+
+#        define LED_DRIVER_SHUTDOWN_PIN C14
+
+#        define HOST_LED_MATRIX_LIST \
+            { 17, 18, 19 }
+
+#        define BAT_LEVEL_LED_LIST \
+            { 17, 18, 19, 20, 21, 22, 23, 24, 25, 26 }
+
+/* Backlit disable timeout when keyboard is disconnected(unit: second) */
+#        define DISCONNECTED_BACKLIGHT_DISABLE_TIMEOUT 40
+
+/* Backlit disable timeout when keyboard is connected(unit: second) */
+#        define CONNECTED_BACKLIGHT_DISABLE_TIMEOUT 600
+#    endif
+
+/* Keep USB connection in blueooth mode */
+#    define KEEP_USB_CONNECTION_IN_BLUETOOTH_MODE
+
+/* Enable bluetooth NKRO */
+#    define BLUETOOTH_NKRO_ENABLE
+
+/* Raw hid command for factory test and bluetooth DFU */
+#   define RAW_HID_CMD 0xAA ... 0xAB
+#else
+/* Raw hid command for factory test */
+#   define RAW_HID_CMD 0xAB
+#endif
+
+/* Emulated EEPROM configuration */
+#define FEE_DENSITY_BYTES FEE_PAGE_SIZE
+#define DYNAMIC_KEYMAP_EEPROM_MAX_ADDR  2047
+
+
+//#define NO_PRINT

keyboards/keychron/k8_pro/halconf.h

@@ -0,0 +1,27 @@
+/* Copyright 2020 QMK
+ *
+ * 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 HAL_USE_I2C TRUE
+
+#ifdef BLUETOOTH_ENABLE
+#    define PAL_USE_CALLBACKS TRUE
+#    define HAL_USE_SERIAL TRUE
+#endif
+
+#include_next <halconf.h>
+

keyboards/keychron/k8_pro/iso/info.json

@@ -0,0 +1,104 @@
+{
+    "keyboard_name": "Keychron K8 Pro",
+    "url": "https://github.com/Keychron",
+    "maintainer": "lokher",
+    "layouts": {
+        "LAYOUT_iso_88": {
+            "layout": [
+                {"label":"Esc", "x":0, "y":0},
+                {"label":"F1", "x":2, "y":0},
+                {"label":"F2", "x":3, "y":0},
+                {"label":"F3", "x":4, "y":0},
+                {"label":"F4", "x":5, "y":0},
+                {"label":"F5", "x":6.5, "y":0},
+                {"label":"F5", "x":7.5, "y":0},
+                {"label":"F7", "x":8.5, "y":0},
+                {"label":"F8", "x":9.5, "y":0},
+                {"label":"F9", "x":11, "y":0},
+                {"label":"F10", "x":12, "y":0},
+                {"label":"F11", "x":13, "y":0},
+                {"label":"F12", "x":14, "y":0},
+                {"label":"Print", "x":15.25, "y":0},
+                {"label":"Cortana", "x":16.25, "y":0},
+                {"label":"Light", "x":17.25, "y":0},
+
+                {"label":"`~", "x":0, "y":1.25},
+                {"label":"1!", "x":1, "y":1.25},
+                {"label":"2@", "x":2, "y":1.25},
+                {"label":"3#", "x":3, "y":1.25},
+                {"label":"4$", "x":4, "y":1.25},
+                {"label":"5%", "x":5, "y":1.25},
+                {"label":"6^", "x":6, "y":1.25},
+                {"label":"7&", "x":7, "y":1.25},
+                {"label":"8*", "x":8, "y":1.25},
+                {"label":"9(", "x":9, "y":1.25},
+                {"label":"0)", "x":10, "y":1.25},
+                {"label":"-_", "x":11, "y":1.25},
+                {"label":"=+", "x":12, "y":1.25},
+                {"label":"Backspace", "x":13, "y":1.25, "w":2},
+                {"label":"Insert", "x":15.25, "y":1.25},
+                {"label":"Home", "x":16.25, "y":1.25},
+                {"label":"Page Up", "x":17.25, "y":1.25},
+
+                {"label":"Tab", "x":0, "y":2.25, "w":1.5},
+                {"label":"Q", "x":1.5, "y":2.25},
+                {"label":"W", "x":2.5, "y":2.25},
+                {"label":"E", "x":3.5, "y":2.25},
+                {"label":"R", "x":4.5, "y":2.25},
+                {"label":"T", "x":5.5, "y":2.25},
+                {"label":"Y", "x":6.5, "y":2.25},
+                {"label":"U", "x":7.5, "y":2.25},
+                {"label":"I", "x":8.5, "y":2.25},
+                {"label":"O", "x":9.5, "y":2.25},
+                {"label":"P", "x":10.5, "y":2.25},
+                {"label":"[{", "x":11.5, "y":2.25},
+                {"label":"]}", "x":12.5, "y":2.25},
+                {"label":"Delete", "x":15.25, "y":2.25},
+                {"label":"End", "x":16.25, "y":2.25},
+                {"label":"Page Down", "x":17.25, "y":2.25},
+
+                {"label":"Caps Lock", "x":0, "y":3.25, "w":1.75},
+                {"label":"A", "x":1.75, "y":3.25},
+                {"label":"S", "x":2.75, "y":3.25},
+                {"label":"D", "x":3.75, "y":3.25},
+                {"label":"F", "x":4.75, "y":3.25},
+                {"label":"G", "x":5.75, "y":3.25},
+                {"label":"H", "x":6.75, "y":3.25},
+                {"label":"J", "x":7.75, "y":3.25},
+                {"label":"K", "x":8.75, "y":3.25},
+                {"label":"L", "x":9.75, "y":3.25},
+                {"label":";:", "x":10.75, "y":3.25},
+                {"label":"'\"", "x":11.75, "y":3.25},
+                {"label":"#~", "x":12.75, "y":3.25},
+                {"label":"Enter", "x":13.75, "y":2.25, "w":1.25, "h":2},
+
+                {"label":"Left Shift", "x":0, "y":4.25, "w":1.25},
+                {"label":"\\|", "x":1.25, "y":4.25},
+                {"label":"Z", "x":2.25, "y":4.25},
+                {"label":"X", "x":3.25, "y":4.25},
+                {"label":"C", "x":4.25, "y":4.25},
+                {"label":"V", "x":5.25, "y":4.25},
+                {"label":"B", "x":6.25, "y":4.25},
+                {"label":"N", "x":7.25, "y":4.25},
+                {"label":"M", "x":8.25, "y":4.25},
+                {"label":",<", "x":9.25, "y":4.25},
+                {"label":".>", "x":10.25, "y":4.25},
+                {"label":"/?", "x":11.25, "y":4.25},
+                {"label":"Right Shift", "x":12.25, "y":4.25, "w":2.75},
+                {"label":"Up", "x":16.25, "y":4.25},
+
+                {"label":"Left Ctrl", "x":0, "y":5.25, "w":1.25},
+                {"label":"Left Win", "x":1.25, "y":5.25, "w":1.25},
+                {"label":"Left Alt", "x":2.5, "y":5.25, "w":1.25},
+                {"label":"Space", "x":3.75, "y":5.25, "w":6.25},
+                {"label":"Right Alt", "x":10, "y":5.25, "w":1.25},
+                {"label":"Right Win", "x":11.25, "y":5.25, "w":1.25},
+                {"label":"Fn", "x":12.5, "y":5.25, "w":1.25},
+                {"label":"Right Ctrl", "x":13.75, "y":5.25, "w":1.25},
+                {"label":"Left", "x":15.25, "y":5.25},
+                {"label":"Down", "x":16.25, "y":5.25},
+                {"label":"Right", "x":17.25, "y":5.25}
+            ]
+        }
+    }
+}

keyboards/keychron/k8_pro/iso/rgb/config.h

@@ -0,0 +1,78 @@
+/* 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/>.
+ */
+
+
+#define PRODUCT_ID      0x0281
+#define DEVICE_VER      0x0101
+
+#ifdef RGB_MATRIX_ENABLE
+/* RGB Matrix driver configuration */
+#    define DRIVER_COUNT 2
+
+#    define DRIVER_ADDR_1 0b1110111
+#    define DRIVER_ADDR_2 0b1110100
+#    define DRIVER_1_LED_TOTAL 47
+#    define DRIVER_2_LED_TOTAL 41
+#    define DRIVER_LED_TOTAL (DRIVER_1_LED_TOTAL + DRIVER_2_LED_TOTAL)
+
+/* Set to infinit, which is use in USB mode by default */
+#define RGB_DISABLE_TIMEOUT RGB_DISABLE_TIME_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
+
+#    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
+#    define ENABLE_RGB_MATRIX_BREATHING
+#    define ENABLE_RGB_MATRIX_BAND_SPIRAL_VAL
+#    define ENABLE_RGB_MATRIX_CYCLE_ALL
+#    define ENABLE_RGB_MATRIX_CYCLE_LEFT_RIGHT
+#    define ENABLE_RGB_MATRIX_CYCLE_UP_DOWN
+#    define ENABLE_RGB_MATRIX_RAINBOW_MOVING_CHEVRON
+#    define ENABLE_RGB_MATRIX_CYCLE_OUT_IN
+#    define ENABLE_RGB_MATRIX_CYCLE_OUT_IN_DUAL
+#    define ENABLE_RGB_MATRIX_CYCLE_PINWHEEL
+#    define ENABLE_RGB_MATRIX_CYCLE_SPIRAL
+#    define ENABLE_RGB_MATRIX_DUAL_BEACON
+#    define ENABLE_RGB_MATRIX_RAINBOW_BEACON
+#    define ENABLE_RGB_MATRIX_JELLYBEAN_RAINDROPS
+#    define ENABLE_RGB_MATRIX_PIXEL_RAIN
+
+/* enabled only if RGB_MATRIX_FRAMEBUFFER_EFFECTS is defined */
+#    define ENABLE_RGB_MATRIX_TYPING_HEATMAP
+#    define ENABLE_RGB_MATRIX_DIGITAL_RAIN
+
+/*  enabled only of RGB_MATRIX_KEYPRESSES or RGB_MATRIX_KEYRELEASES is defined*/
+#    define ENABLE_RGB_MATRIX_SOLID_REACTIVE_SIMPLE
+#    define ENABLE_RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE
+#    define ENABLE_RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS
+#    define ENABLE_RGB_MATRIX_SPLASH
+#    define ENABLE_RGB_MATRIX_SOLID_SPLASH
+
+/* Set LED driver current */
+#define CKLED2001_CURRENT_TUNE   {0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38}
+
+#endif

keyboards/keychron/k8_pro/iso/rgb/keymaps/default/keymap.c

@@ -0,0 +1,59 @@
+/* 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 QMK_KEYBOARD_H
+
+enum layers{
+  MAC_BASE,
+  MAC_FN,
+  WIN_BASE,
+  WIN_FN
+};
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+[MAC_BASE] = LAYOUT_iso_88(
+     KC_ESC,   KC_BRID,  KC_BRIU,  KC_MCTL,  KC_LNPD,  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_NUBS,  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_iso_88(
+     KC_TRNS,  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_TRNS,  KC_TRNS,  RGB_TOG,
+     KC_TRNS,  BT_HST1,  BT_HST2,  BT_HST3,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+     RGB_TOG,  RGB_MOD,  RGB_VAI,  RGB_HUI,  RGB_SAI,  RGB_SPI,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+     KC_TRNS,  RGB_RMOD, RGB_VAD,  RGB_HUD,  RGB_SAD,  RGB_SPD,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,
+     KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  BAT_LVL,  NK_TOGG,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,            KC_TRNS,
+     KC_TRNS,  KC_TRNS,  KC_TRNS,                                KC_TRNS,                                KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS),
+
+[WIN_BASE] = LAYOUT_iso_88(
+     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_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_NUBS,  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_LGUI,  KC_LALT,                                KC_SPC,                                 KC_RALT,  KC_RGUI, MO(WIN_FN),KC_RCTL,  KC_LEFT,  KC_DOWN,  KC_RGHT),
+
+[WIN_FN] = LAYOUT_iso_88(
+     KC_TRNS,  KC_BRID,  KC_BRIU,  KC_TASK,  KC_FILE,  RGB_VAD,  RGB_VAI,  KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_MUTE,  KC_VOLD,  KC_VOLU,            KC_TRNS,  KC_TRNS,  RGB_TOG,
+     KC_TRNS,  BT_HST1,  BT_HST2,  BT_HST3,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+     RGB_TOG,  RGB_MOD,  RGB_VAI,  RGB_HUI,  RGB_SAI,  RGB_SPI,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+     KC_TRNS,  RGB_RMOD, RGB_VAD,  RGB_HUD,  RGB_SAD,  RGB_SPD,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,
+     KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  BAT_LVL,  NK_TOGG,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,            KC_TRNS,
+     KC_TRNS,  KC_TRNS,  KC_TRNS,                                KC_TRNS,                                KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS)
+
+};

keyboards/keychron/k8_pro/iso/rgb/keymaps/via/keymap.c

@@ -0,0 +1,59 @@
+/* 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 QMK_KEYBOARD_H
+
+enum layers{
+  MAC_BASE,
+  MAC_FN,
+  WIN_BASE,
+  WIN_FN
+};
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+[MAC_BASE] = LAYOUT_iso_88(
+     KC_ESC,   KC_BRID,  KC_BRIU,  KC_MCTL,  KC_LNPD,  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_NUBS,  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_iso_88(
+     KC_TRNS,  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_TRNS,  KC_TRNS,  RGB_TOG,
+     KC_TRNS,  BT_HST1,  BT_HST2,  BT_HST3,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+     RGB_TOG,  RGB_MOD,  RGB_VAI,  RGB_HUI,  RGB_SAI,  RGB_SPI,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+     KC_TRNS,  RGB_RMOD, RGB_VAD,  RGB_HUD,  RGB_SAD,  RGB_SPD,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,
+     KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  BAT_LVL,  NK_TOGG,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,            KC_TRNS,
+     KC_TRNS,  KC_TRNS,  KC_TRNS,                                KC_TRNS,                                KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS),
+
+[WIN_BASE] = LAYOUT_iso_88(
+     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_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_NUBS,  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_LGUI,  KC_LALT,                                KC_SPC,                                 KC_RALT,  KC_RGUI, MO(WIN_FN),KC_RCTL,  KC_LEFT,  KC_DOWN,  KC_RGHT),
+
+[WIN_FN] = LAYOUT_iso_88(
+     KC_TRNS,  KC_BRID,  KC_BRIU,  KC_TASK,  KC_FILE,  RGB_VAD,  RGB_VAI,  KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_MUTE,  KC_VOLD,  KC_VOLU,            KC_TRNS,  KC_TRNS,  RGB_TOG,
+     KC_TRNS,  BT_HST1,  BT_HST2,  BT_HST3,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+     RGB_TOG,  RGB_MOD,  RGB_VAI,  RGB_HUI,  RGB_SAI,  RGB_SPI,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+     KC_TRNS,  RGB_RMOD, RGB_VAD,  RGB_HUD,  RGB_SAD,  RGB_SPD,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,
+     KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  BAT_LVL,  NK_TOGG,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,            KC_TRNS,
+     KC_TRNS,  KC_TRNS,  KC_TRNS,                                KC_TRNS,                                KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS)
+
+};

keyboards/keychron/k8_pro/iso/rgb/keymaps/via/rules.mk

@@ -0,0 +1 @@
+VIA_ENABLE = yes

keyboards/keychron/k8_pro/iso/rgb/rgb.c

@@ -0,0 +1,149 @@
+/* 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"
+
+#ifdef RGB_MATRIX_ENABLE
+const ckled2001_led g_ckled2001_leds[DRIVER_LED_TOTAL] = {
+/* Refer to IS31 manual for these locations
+ *   driver
+ *   |  R location
+ *   |  |       G location
+ *   |  |       |       B location
+ *   |  |       |       | */
+    {0, I_1,    G_1,    H_1},
+    {0, G_2,    H_2,    I_2},
+    {0, H_3,    I_3,    G_3},
+    {0, I_4,    G_4,    H_4},
+    {0, G_5,    H_5,    I_5},
+    {0, H_6,    I_6,    G_6},
+    {0, I_7,    G_7,    H_7},
+    {0, G_8,    H_8,    I_8},
+    {0, H_9,    I_9,    G_9},
+    {0, I_10,   G_10,   H_10},
+    {0, G_11,   H_11,   I_11},
+    {0, H_12,   I_12,   G_12},
+    {0, I_13,   G_13,   H_13},
+    {0, H_15,   I_15,   G_15},
+    {0, I_16,   G_16,   H_16},
+    {1, A_2,    B_2,    C_2,},
+    
+    {0, C_1,    A_1,    B_1},
+    {0, A_2,    B_2,    C_2},
+    {0, B_3,    C_3,    A_3},
+    {0, C_4,    A_4,    B_4},
+    {0, A_5,    B_5,    C_5},
+    {0, B_6,    C_6,    A_6},
+    {0, C_7,    A_7,    B_7},
+    {0, A_8,    B_8,    C_8},
+    {0, B_9,    C_9,    A_9},
+    {0, C_10,   A_10,   B_10},
+    {0, A_11,   B_11,   C_11},
+    {0, B_12,   C_12,   A_12},
+    {0, C_13,   A_13,   B_13},
+    {0, A_14,   B_14,   C_14},
+    {0, B_15,   C_15,   A_15},
+    {0, C_16,   A_16,   B_16},
+    {1, G_2,    H_2,    I_2},
+
+    {0, F_1,    D_1,    E_1},
+    {0, D_2,    E_2,    F_2},
+    {0, E_3,    F_3,    D_3},
+    {0, F_4,    D_4,    E_4},
+    {0, D_5,    E_5,    F_5},
+    {0, E_6,    F_6,    D_6},
+    {0, F_7,    D_7,    E_7},
+    {0, D_8,    E_8,    F_8},
+    {0, E_9,    F_9,    D_9},
+    {0, F_10,   D_10,   E_10},
+    {0, D_11,   E_11,   F_11},
+    {0, E_12,   F_12,   D_12},
+    {0, F_13,   D_13,   E_13},
+    {0, D_14,   E_14,   F_14},
+    {0, E_15,   F_15,   D_15},
+    {0, F_16,   D_16,   E_16},
+    {1, A_1,    B_1,    C_1},
+
+    {1, C_16,   A_16,   B_16},
+    {1, A_15,   B_15,   C_15},
+    {1, B_14,   C_14,   A_14},
+    {1, C_13,   A_13,   B_13},
+    {1, A_12,   B_12,   C_12},
+    {1, B_11,   C_11,   A_11},
+    {1, C_10,   A_10,   B_10},
+    {1, A_9,    B_9,    C_9},
+    {1, B_8,    C_8,    A_8},
+    {1, C_7,    A_7,    B_7},
+    {1, A_6,    B_6,    C_6},
+    {1, B_5,    C_5,    A_5},
+    {1, A_3,    B_3,    C_3},
+
+    {1, I_16,   G_16,   H_16},
+    {1, G_15,   H_15,   I_15},	
+    {1, H_14,   I_14,   G_14},
+    {1, I_13,   G_13,   H_13},
+    {1, G_12,   H_12,   I_12},
+    {1, H_11,   I_11,   G_11},
+    {1, I_10,   G_10,   H_10},
+    {1, G_9,    H_9,    I_9},
+    {1, H_8,    I_8,    G_8},
+    {1, I_7,    G_7,    H_7},
+    {1, G_6,    H_6,    I_6},
+    {1, H_5,    I_5,    G_5},
+    {1, G_3,    H_3,    I_3},
+    {1, I_1,    G_1,    H_1},
+
+    {1, F_16,   D_16,   E_16},
+    {1, D_15,   E_15,   F_15},
+    {1, E_14,   F_14,   D_14},
+    {1, F_10,   D_10,   E_10},
+    {1, D_6,    E_6,    F_6},
+    {1, E_5,    F_5,    D_5},
+    {1, F_4,    D_4,    E_4},
+    {1, D_3,    E_3,    F_3},
+    {1, E_2,    F_2,    D_2},
+    {1, F_1,    D_1,    E_1},
+    {1, A_4,    B_4,    C_4}
+};
+
+
+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,     NO_LED, 62,     NO_LED, NO_LED, NO_LED },
+		{  63,     64,     65,     66,     67,     68,     69,     70,     71,     72,     73,     74,     NO_LED, 75,     NO_LED, 76,     NO_LED },
+        {  77,     78,     79,     NO_LED, NO_LED, NO_LED, 80,     NO_LED, NO_LED, NO_LED, 81,     82,     83,     84,     85,     86,     87}
+	},
+	{
+        {0, 0},          {25, 0}, {38, 0}, {51, 0}, {64, 0}, {84, 0}, { 97, 0}, {110, 0}, {123, 0}, {142, 0}, {155, 0}, {168, 0}, {181, 0}, {198, 0}, {211, 0}, {224, 0},
+        {0,14}, {12,14}, {25,14}, {38,14}, {51,14}, {64,14}, {77,14}, { 90,14}, {103,14}, {116,14}, {129,14}, {142,14}, {155,14}, {175,14}, {198,14}, {211,14}, {224,14},
+        {3,26}, {19,26}, {32,26}, {45,26}, {58,26}, {71,26}, {84,26}, { 97,26}, {110,26}, {123,26}, {136,26}, {149,26}, {162,26}, {178,26}, {198,26}, {211,26}, {224,26},
+        {4,39}, {22,39}, {35,39}, {48,39}, {61,39}, {74,39}, {87,39}, {100,39}, {113,39}, {126,39}, {139,39}, {152,39},           {173,39},
+        {0,51}, {16,51}, {29,51}, {42,51}, {55,51}, {68,51}, {81,51}, {94,51},  {107,51}, {120,51}, {132,51}, {145,51},           {170,51},           {211,51},
+        {1,64}, {17,64}, {34,64},                            {82,64},                               {131,64}, {147,64}, {163,64}, {180,64}, {198,64}, {211,64}, {224,64}
+    },
+	{
+        4,    4,    4,    4,    4,    4,    4,    4,    4,    4,    4,    4,    4,          4,    4,    4,
+        4,    8,    8,    8,    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/k8_pro/iso/rgb/rules.mk

@@ -0,0 +1,3 @@
+RGB_MATRIX_ENABLE = yes
+RGB_MATRIX_DRIVER = CKLED2001
+

keyboards/keychron/k8_pro/iso/white/config.h

@@ -0,0 +1,63 @@
+/* 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/>.
+ */
+
+
+#define PRODUCT_ID      0x0284
+#define DEVICE_VER      0x0101
+
+#ifdef LED_MATRIX_ENABLE
+/* LED matrix driver configuration */
+#    define DRIVER_COUNT 1
+#    define DRIVER_ADDR_1 0b1110100
+#    define DRIVER_LED_TOTAL 88
+
+/* Set to infinit, which is use in USB mode by default */
+#define LED_DISABLE_TIMEOUT LED_DISABLE_TIME_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
+
+/* 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
+
+#    define ENABLE_LED_MATRIX_NONE
+#    define ENABLE_LED_MATRIX_SOLID
+#    define ENABLE_LED_MATRIX_BREATHING
+#    define ENABLE_LED_MATRIX_BAND_PINWHEEL
+#    define ENABLE_LED_MATRIX_BAND_SPIRAL
+#    define ENABLE_LED_MATRIX_CYCLE_LEFT_RIGHT
+#    define ENABLE_LED_MATRIX_CYCLE_UP_DOWN
+#    define ENABLE_LED_MATRIX_CYCLE_OUT_IN
+#    define ENABLE_LED_MATRIX_DUAL_BEACON
+#    define ENABLE_LED_MATRIX_SOLID_REACTIVE_SIMPLE
+#    define ENABLE_LED_MATRIX_SOLID_REACTIVE_MULTIWIDE
+#    define ENABLE_LED_MATRIX_SOLID_REACTIVE_MULTINEXUS
+#    define ENABLE_LED_MATRIX_SOLID_SPLASH
+#    define ENABLE_LED_MATRIX_WAVE_LEFT_RIGHT
+#    define ENABLE_LED_MATRIX_WAVE_UP_DOWN
+#    define ENABLE_LED_MATRIX_EFFECT_MAX
+
+/* Use first 6 channels of LED driver */
+#define PHASE_CHANNEL MSKPHASE_6CHANNEL
+
+/* Set LED driver current */
+#define CKLED2001_CURRENT_TUNE  { 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60 }
+
+#endif

keyboards/keychron/k8_pro/iso/white/keymaps/default/keymap.c

@@ -0,0 +1,59 @@
+/* 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 QMK_KEYBOARD_H
+
+enum layers{
+  MAC_BASE,
+  MAC_FN,
+  WIN_BASE,
+  WIN_FN
+};
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+[MAC_BASE] = LAYOUT_iso_88(
+     KC_ESC,   KC_BRID,  KC_BRIU,  KC_MCTL,  KC_LNPD,  BL_DEC,   BL_INC,   KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_MUTE,  KC_VOLD,  KC_VOLU,           KC_SNAP,   KC_SIRI,  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_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_NUBS,  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_iso_88(
+     KC_TRNS,  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_TRNS,  KC_TRNS,  BL_TOGG,
+     KC_TRNS,  BT_HST1,  BT_HST2,  BT_HST3,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+     BL_TOGG,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+     KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,
+     KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  BAT_LVL,  NK_TOGG,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,            KC_TRNS,
+     KC_TRNS,  KC_TRNS,  KC_TRNS,                                KC_TRNS,                                KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS),
+
+[WIN_BASE] = LAYOUT_iso_88(
+     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_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_NUBS,  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_LGUI,  KC_LALT,                                KC_SPC,                                 KC_RALT,  KC_RGUI, MO(WIN_FN),KC_RCTL,  KC_LEFT,  KC_DOWN,  KC_RGHT),
+
+[WIN_FN] = LAYOUT_iso_88(
+     KC_TRNS,  KC_BRID,  KC_BRIU,  KC_TASK,  KC_FILE,  BL_DEC,   BL_INC,   KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_MUTE,  KC_VOLD,  KC_VOLU,            KC_TRNS,  KC_TRNS,  BL_TOGG,
+     KC_TRNS,  BT_HST1,  BT_HST2,  BT_HST3,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+     BL_TOGG,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+     KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,
+     KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  BAT_LVL,  NK_TOGG,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,            KC_TRNS,
+     KC_TRNS,  KC_TRNS,  KC_TRNS,                                KC_TRNS,                                KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS)
+
+};

keyboards/keychron/k8_pro/iso/white/keymaps/via/keymap.c

@@ -0,0 +1,59 @@
+/* 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 QMK_KEYBOARD_H
+
+enum layers{
+  MAC_BASE,
+  MAC_FN,
+  WIN_BASE,
+  WIN_FN
+};
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+[MAC_BASE] = LAYOUT_iso_88(
+     KC_ESC,   KC_BRID,  KC_BRIU,  KC_MCTL,  KC_LNPD,  BL_DEC,   BL_INC,   KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_MUTE,  KC_VOLD,  KC_VOLU,           KC_SNAP,   KC_SIRI,  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_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_NUBS,  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_iso_88(
+     KC_TRNS,  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_TRNS,  KC_TRNS,  BL_TOGG,
+     KC_TRNS,  BT_HST1,  BT_HST2,  BT_HST3,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+     BL_TOGG,  BL_STEP,  BL_INC,   KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+     KC_TRNS,  KC_TRNS,  BL_DEC,   KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,
+     KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  BAT_LVL,  NK_TOGG,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,            KC_TRNS,
+     KC_TRNS,  KC_TRNS,  KC_TRNS,                                KC_TRNS,                                KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS),
+
+[WIN_BASE] = LAYOUT_iso_88(
+     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_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_NUBS,  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_LGUI,  KC_LALT,                                KC_SPC,                                 KC_RALT,  KC_RGUI, MO(WIN_FN),KC_RCTL,  KC_LEFT,  KC_DOWN,  KC_RGHT),
+
+[WIN_FN] = LAYOUT_iso_88(
+     KC_TRNS,  KC_BRID,  KC_BRIU,  KC_TASK,  KC_FILE,  BL_DEC,   BL_INC,   KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_MUTE,  KC_VOLD,  KC_VOLU,            KC_TRNS,  KC_TRNS,  BL_TOGG,
+     KC_TRNS,  BT_HST1,  BT_HST2,  BT_HST3,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+     BL_TOGG,  BL_STEP,  BL_INC,   KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,
+     KC_TRNS,  KC_TRNS,  BL_DEC,   KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,
+     KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  BAT_LVL,  NK_TOGG,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,            KC_TRNS,            KC_TRNS,
+     KC_TRNS,  KC_TRNS,  KC_TRNS,                                KC_TRNS,                                KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS)
+
+};

keyboards/keychron/k8_pro/iso/white/keymaps/via/rules.mk

@@ -0,0 +1 @@
+VIA_ENABLE = yes

keyboards/keychron/k8_pro/iso/white/rules.mk

@@ -0,0 +1,2 @@
+LED_MATRIX_ENABLE = yes
+LED_MATRIX_DRIVER = CKLED2001

keyboards/keychron/k8_pro/iso/white/white.c

@@ -0,0 +1,148 @@
+/* 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"
+
+#ifdef LED_MATRIX_ENABLE
+const ckled2001_led g_ckled2001_leds[DRIVER_LED_TOTAL] = {
+/* Refer to IS31 manual for these locations
+ *   driver
+ *   |  LED address
+ *   |  | */
+    {0, A_16}, 
+    {0, A_15}, 
+    {0, A_14}, 
+    {0, A_13}, 
+    {0, A_12}, 
+    {0, A_11}, 
+    {0, A_10}, 
+    {0, A_9}, 
+    {0, A_8}, 
+    {0, A_7}, 
+    {0, A_6}, 
+    {0, A_5}, 
+    {0, A_4},
+    {0, A_2},  
+    {0, A_1},  
+    {0, D_2},
+
+    {0, B_16}, 
+    {0, B_15}, 
+    {0, B_14}, 
+    {0, B_13}, 
+    {0, B_12}, 
+    {0, B_11}, 
+    {0, B_10}, 
+    {0, B_9}, 
+    {0, B_8}, 
+    {0, B_7}, 
+    {0, B_6}, 
+    {0, B_5}, 
+    {0, B_4}, 
+    {0, B_3}, 
+    {0, B_2}, 
+    {0, B_1}, 
+    {0, E_2},
+
+    {0, C_16}, 
+    {0, C_15}, 
+    {0, C_14}, 
+    {0, C_13}, 
+    {0, C_12}, 
+    {0, C_11}, 
+    {0, C_10}, 
+    {0, C_9}, 
+    {0, C_8}, 
+    {0, C_7}, 
+    {0, C_6}, 
+    {0, C_5}, 
+    {0, C_4}, 
+    {0, C_3}, 
+    {0, C_2}, 
+    {0, C_1}, 
+    {0, D_1},
+
+    {0, D_16},
+    {0, D_15},
+    {0, D_14},
+    {0, D_13},
+    {0, D_12},
+    {0, D_11},
+    {0, D_10},
+    {0, D_9},
+    {0, D_8},
+    {0, D_7},
+    {0, D_6},
+    {0, D_5},
+    {0, D_3},
+
+    {0, E_16},
+    {0, E_15},
+    {0, E_14},
+    {0, E_13},
+    {0, E_12},
+    {0, E_11},
+    {0, E_10},
+    {0, E_9},
+    {0, E_8},
+    {0, E_7},
+    {0, E_6},
+    {0, E_5},
+    {0, E_3},
+    {0, E_1},
+
+    {0, F_16},
+    {0, F_15},
+    {0, F_14},
+
+    {0, F_10},
+    {0, F_6},
+    {0, F_5},
+    {0, F_4},
+    {0, F_3},
+    {0, F_2},
+    {0, F_1}, 
+    {0, D_4},
+};
+
+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,     NO_LED, 62,     NO_LED, NO_LED, NO_LED },
+		{  63,     64,     65,     66,     67,     68,     69,     70,     71,     72,     73,     74,     NO_LED, 75,     NO_LED, 76,     NO_LED },
+        {  77,     78,     79,     NO_LED, NO_LED, NO_LED, 80,     NO_LED, NO_LED, NO_LED, 81,     82,     83,     84,     85,     86,     87}
+	},
+	{
+        {0, 0},          {25, 0}, {38, 0}, {51, 0}, {64, 0}, {84, 0}, { 97, 0}, {110, 0}, {123, 0}, {142, 0}, {155, 0}, {168, 0}, {181, 0}, {198, 0}, {211, 0}, {224, 0},
+        {0,14}, {12,14}, {25,14}, {38,14}, {51,14}, {64,14}, {77,14}, { 90,14}, {103,14}, {116,14}, {129,14}, {142,14}, {155,14}, {175,14}, {198,14}, {211,14}, {224,14},
+        {3,26}, {19,26}, {32,26}, {45,26}, {58,26}, {71,26}, {84,26}, { 97,26}, {110,26}, {123,26}, {136,26}, {149,26}, {162,26}, {178,26}, {198,26}, {211,26}, {224,26},
+        {4,39}, {22,39}, {35,39}, {48,39}, {61,39}, {74,39}, {87,39}, {100,39}, {113,39}, {126,39}, {139,39}, {152,39},           {173,39},
+        {0,51}, {16,51}, {29,51}, {42,51}, {55,51}, {68,51}, {81,51}, {94,51},  {107,51}, {120,51}, {132,51}, {145,51},           {170,51},           {211,51},
+        {1,64}, {17,64}, {34,64},                            {82,64},                               {131,64}, {147,64}, {163,64}, {180,64}, {198,64}, {211,64}, {224,64}
+    },
+	{
+        4,    4,    4,    4,    4,    4,    4,    4,    4,    4,    4,    4,    4,          4,    4,    4,
+        4,    8,    8,    8,    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/k8_pro/k8_pro.c

@@ -0,0 +1,297 @@
+/* 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 "k8_pro.h"
+#ifdef BLUETOOTH_ENABLE
+#    include "ckbt51.h"
+#    include "bluetooth.h"
+#    include "indicator.h"
+#    include "transport.h"
+#    include "battery.h"
+#    include "bat_level_animation.h"
+#    include "lpm.h"
+#endif
+
+#ifdef ENABLE_FACTORY_TEST
+#    include "factory_test.h"
+#endif
+
+#define POWER_ON_LED_DURATION 3000
+
+typedef struct PACKED {
+    uint8_t len;
+    uint8_t keycode[3];
+} key_combination_t;
+
+static uint32_t power_on_indicator_timer_buffer;
+static uint32_t siri_timer_buffer = 0;
+static uint8_t  mac_keycode[4]    = {KC_LOPT, KC_ROPT, KC_LCMD, KC_RCMD};
+
+key_combination_t key_comb_list[4] = {
+    {2, {KC_LWIN, KC_TAB}},        // Task (win)
+    {2, {KC_LWIN, KC_E}},          // Files (win)
+    {3, {KC_LSFT, KC_LGUI, KC_4}}, // Snapshot (mac)
+    {2, {KC_LWIN, KC_C}}           // Cortana (win)
+};
+
+#ifdef BLUETOOTH_ENABLE
+bool firstDisconnect = true;
+bool                   bt_factory_reset = false;
+static virtual_timer_t pairing_key_timer;
+extern uint8_t         g_pwm_buffer[DRIVER_COUNT][192];
+
+static void pairing_key_timer_cb(void *arg) {
+    bluetooth_pairing_ex(*(uint8_t *)arg, NULL);
+}
+#endif
+
+bool dip_switch_update_kb(uint8_t index, bool active) {
+    if (index == 0) {
+        default_layer_set(1UL << (active ? 2 : 0));
+    }
+    dip_switch_update_user(index, active);
+
+    return true;
+}
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+    static uint8_t host_idx = 0;
+
+    switch (keycode) {
+        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_MCTL:
+            /* Mission Control */
+            host_consumer_send(record->event.pressed ? 0x29F : 0);
+            return false; // Skip all further processing of this key
+        case KC_LNPD:
+            /* Lanuchpad */
+            host_consumer_send(record->event.pressed ? 0x2A0 : 0);
+            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
+        case KC_SIRI:
+            if (record->event.pressed && siri_timer_buffer == 0) {
+                register_code(KC_LGUI);
+                register_code(KC_SPACE);
+                siri_timer_buffer = sync_timer_read32() | 1;
+            }
+            return false; // Skip all further processing of this key
+#ifdef BLUETOOTH_ENABLE
+        case BT_HST1 ... BT_HST3:
+            if (record->event.pressed) {
+                host_idx = keycode + BT_HST1 + 1;
+                chVTSet(&pairing_key_timer, TIME_MS2I(2000), (vtfunc_t)pairing_key_timer_cb, &host_idx);
+                bluetooth_connect_ex(host_idx, 0);
+            } else {
+                host_idx = 0;
+                chVTReset(&pairing_key_timer);
+            }
+            break;
+        case BAT_LVL:
+            if (get_transport() == TRANSPORT_BLUETOOTH && !usb_power_connected()) {
+                bat_level_animiation_start(battery_get_percentage());
+            }
+            break;
+#endif
+        default:
+#ifdef FACTORY_RESET_CHECK
+            FACTORY_RESET_CHECK(keycode, record);
+#endif
+            break;
+    }
+    return true;
+}
+
+void keyboard_post_init_user(void) {
+    dip_switch_read(true);
+
+#ifdef BLUETOOTH_ENABLE
+    /* Currently we don't use this reset pin */
+    palSetLineMode(CKBT51_RESET_PIN, PAL_MODE_UNCONNECTED);
+
+    /* IMPORTANT: DO NOT enable internal pull-up resistor
+     * as there is an external pull-down resistor.
+     */
+    palSetLineMode(USB_BT_MODE_SELECT_PIN, PAL_MODE_INPUT);
+
+    ckbt51_init(false);
+    bluetooth_init();
+#    endif
+
+    power_on_indicator_timer_buffer = sync_timer_read32() | 1;
+    writePin(BAT_LOW_LED_PIN, BAT_LOW_LED_PIN_ON_STATE);
+    writePin(LED_CAPS_LOCK_PIN, LED_PIN_ON_STATE);
+#ifdef BLUETOOTH_ENABLE
+    writePin(H3, HOST_LED_PIN_ON_STATE);
+#    endif
+}
+
+void matrix_scan_user(void) {
+    if (power_on_indicator_timer_buffer) {
+        if (sync_timer_elapsed32(power_on_indicator_timer_buffer) > POWER_ON_LED_DURATION) {
+            power_on_indicator_timer_buffer = 0;
+
+            writePin(BAT_LOW_LED_PIN, !BAT_LOW_LED_PIN_ON_STATE);
+            writePin(H3, !HOST_LED_PIN_ON_STATE);
+            if (!host_keyboard_led_state().caps_lock) writePin(LED_CAPS_LOCK_PIN, !LED_PIN_ON_STATE);
+        } else {
+            writePin(BAT_LOW_LED_PIN, BAT_LOW_LED_PIN_ON_STATE);
+            writePin(H3, HOST_LED_PIN_ON_STATE);
+            writePin(LED_CAPS_LOCK_PIN, LED_PIN_ON_STATE);
+        }
+    }
+
+    if (siri_timer_buffer && sync_timer_elapsed32(siri_timer_buffer) > 500) {
+        siri_timer_buffer = 0;
+        unregister_code(KC_LGUI);
+        unregister_code(KC_SPACE);
+    }
+
+#ifdef FACTORY_RESET_TASK
+    FACTORY_RESET_TASK();
+#    endif
+}
+
+#ifdef BLUETOOTH_ENABLE
+static void ckbt51_param_init(void) {
+    /* Set bluetooth device name */
+    ckbt51_set_local_name(STR(PRODUCT));
+    /* 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             = 0, // Must be 0x3434
+                            .product_id             = PRODUCT_ID};
+    ckbt51_set_param(&param);
+}
+
+void bluetooth_enter_disconnected_kb(uint8_t host_idx) {
+    if (bt_factory_reset) {
+        bt_factory_reset = false;
+        ckbt51_param_init();
+    }
+    /* CKBT51 bluetooth module boot time is slower, it enters disconnected after boot,
+       so we place initialization here. */
+    if (firstDisconnect && sync_timer_read32() < 1000 && get_transport() == TRANSPORT_BLUETOOTH) {
+        ckbt51_param_init();
+        bluetooth_connect();
+        firstDisconnect = false;
+    }
+}
+
+void bluetooth_pre_task(void) {
+    static uint8_t mode = 1;
+
+    if (readPin(USB_BT_MODE_SELECT_PIN) != mode) {
+        if (readPin(USB_BT_MODE_SELECT_PIN) != mode) {
+            mode = readPin(USB_BT_MODE_SELECT_PIN);
+            set_transport(mode == 0 ? TRANSPORT_BLUETOOTH : TRANSPORT_USB);
+        }
+    }
+}
+
+void battery_measure(void) {
+#    ifdef LED_MATRIX_ENABLE
+    if (led_matrix_is_enabled()) {
+        ckbt51_read_state_reg(0x05, 0x02);
+        return;
+    }
+#    endif
+#    ifdef RGB_MATRIX_ENABLE
+    if (rgb_matrix_is_enabled()) {
+        ckbt51_read_state_reg(0x05, 0x02);
+        return;
+    }
+#    endif
+}
+#endif
+
+void battery_calculte_voltage(uint16_t value) {
+    uint16_t voltage = ((uint32_t)value) * 2246 / 1000;
+
+#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 += (30 * totalBuf / DRIVER_LED_TOTAL / 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 = 60 * totalBuf / DRIVER_LED_TOTAL / 255 / 3;
+        voltage += compensation;
+    }
+#endif
+    battery_set_voltage(voltage);
+}
+
+void raw_hid_receive_kb(uint8_t *data, uint8_t length) {
+    switch (data[0]) {
+#ifdef BLUETOOTH_ENABLE
+        case 0xAA:
+            ckbt51_dfu_rx(data, length);
+            break;
+#endif
+#ifdef ENABLE_FACTORY_TEST
+        case 0xAB:
+            factory_test_rx(data, length);
+            break;
+#endif
+    }
+}
+
+#if !defined(VIA_ENABLE)
+void raw_hid_receive(uint8_t *data, uint8_t length) {
+    switch (data[0]) {
+        case RAW_HID_CMD:
+            raw_hid_receive_kb(data, length);
+            break;
+    }
+}
+#endif

keyboards/keychron/k8_pro/k8_pro.h

@@ -0,0 +1,99 @@
+/* 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 "quantum.h"
+#ifdef VIA_ENABLE
+#    include "via.h"
+#endif
+
+#define ___ KC_NO
+
+#ifdef VIA_ENABLE
+#    define USER_START USER00
+#else
+#    define USER_START SAFE_RANGE
+#endif
+
+enum {
+    KC_LOPTN = USER_START,
+    KC_ROPTN,
+    KC_LCMMD,
+    KC_RCMMD,
+    KC_MCTL,
+    KC_LNPD,
+    KC_TASK,
+    KC_FILE,
+    KC_SNAP,
+    KC_CTANA,
+    KC_SIRI,
+#ifdef BLUETOOTH_ENABLE
+    BT_HST1,
+    BT_HST2,
+    BT_HST3,
+#endif
+    BAT_LVL,
+};
+
+
+#define LAYOUT_ansi_87( \
+	K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C,      K0E, K0F, K0G, \
+	K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, K1D, K1E, K1F, K1G, \
+	K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, K2C, K2D, K2E, K2F, K2G, \
+	K30, K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B,      K3D,                \
+	K40,      K42, K43, K44, K45, K46, K47, K48, K49, K4A, K4B,      K4D,      K4F,      \
+	K50, K51, K52,                K56,                K5A, K5B, K5C, K5D, K5E, K5F, K5G  \
+) { \
+	{ K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, ___, K0E, K0F, K0G }, \
+	{ K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, K1D, K1E, K1F, K1G }, \
+	{ K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, K2C, K2D, K2E, K2F, K2G }, \
+	{ K30, K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, ___, K3D, ___, ___, ___ }, \
+	{ K40, ___, K42, K43, K44, K45, K46, K47, K48, K49, K4A, K4B, ___, K4D, ___, K4F, ___ }, \
+	{ K50, K51, K52, ___, ___, ___, K56, ___, ___, ___, K5A, K5B, K5C, K5D, K5E, K5F, K5G }  \
+}
+
+#define LAYOUT_iso_88( \
+	K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C,      K0E, K0F, K0G, \
+	K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, K1D, K1E, K1F, K1G, \
+	K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, K2C, K2D, K2E, K2F, K2G, \
+	K30, K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B,      K3D,                \
+	K40, K41, K42, K43, K44, K45, K46, K47, K48, K49, K4A, K4B,      K4D,      K4F,      \
+	K50, K51, K52,                K56,                K5A, K5B, K5C, K5D, K5E, K5F, K5G  \
+) { \
+	{ K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, ___, K0E, K0F, K0G }, \
+	{ K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, K1D, K1E, K1F, K1G }, \
+	{ K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, K2C, K3D, K2E, K2F, K2G }, \
+	{ K30, K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, ___, K2D, ___, ___, ___ }, \
+	{ K40, K41, K42, K43, K44, K45, K46, K47, K48, K49, K4A, K4B, ___, K4D, ___, K4F, ___ }, \
+	{ K50, K51, K52, ___, ___, ___, K56, ___, ___, ___, K5A, K5B, K5C, K5D, K5E, K5F, K5G }  \
+}
+
+#define LAYOUT_jis_91( \
+	K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C,            K0E, K0F, K0G, \
+	K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, K1D, K0D,  K1E, K1F, K1G, \
+	K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, K2C, K2D,       K2E, K2F, K2G, \
+	K30, K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B,      K3D,                      \
+	K40,      K42, K43, K44, K45, K46, K47, K48, K49, K4A, K4B, K4C, K4D,            K4F,      \
+	K50, K51, K52, K53,           K56,           K59, K5A, K5B, K5C, K5D,       K5E, K5F, K5G  \
+) { \
+	{ K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, K0D, K0E, K0F, K0G }, \
+	{ K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, K1D, K1E, K1F, K1G }, \
+	{ K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, K2C, K3D, K2E, K2F, K2G }, \
+	{ K30, K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, ___, K2D, ___, ___, ___ }, \
+	{ K40, ___, K42, K43, K44, K45, K46, K47, K48, K49, K4A, K4B, K4C, K4D, ___, K4F, ___ }, \
+	{ K50, K51, K52, K53, ___, ___, K56, ___, ___, K59, K5A, K5B, K5C, K5D, K5E, K5F, K5G }  \
+}

keyboards/keychron/k8_pro/matrix.c

@@ -0,0 +1,173 @@
+/* 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 "q1_bluetooth.h"
+#include "stdint.h"
+#include "hal.h"
+#include "gpio.h"
+#include "quantum.h"
+
+#define HC595_STCP A0
+#define HC595_SHCP A1
+#define HC595_DS C15
+
+pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
+pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
+
+static inline void HC595_delay(uint16_t n) {
+    while (n-- > 0) {
+        asm volatile("nop" ::: "memory");
+    };
+}
+
+static void HC595_output(uint16_t data) {
+    uint8_t i;
+    uint8_t n = 1;
+
+    for (i = 16; i > 0; i--) {
+        writePinLow(HC595_SHCP);
+
+        if (data & 0x8000)
+            writePinHigh(HC595_DS);
+        else
+            writePinLow(HC595_DS);
+
+        data <<= 1;
+
+        HC595_delay(n);
+
+        writePinHigh(HC595_SHCP);
+        HC595_delay(n);
+    }
+
+    HC595_delay(n);
+    writePinLow(HC595_STCP);
+    HC595_delay(n);
+    writePinHigh(HC595_STCP);
+}
+
+static inline void setPinOutput_writeLow(pin_t pin) {
+    ATOMIC_BLOCK_FORCEON {
+        setPinOutput(pin);
+        writePinLow(pin);
+    }
+}
+
+static inline void setPinInputHigh_atomic(pin_t pin) {
+    ATOMIC_BLOCK_FORCEON {
+        setPinInputHigh(pin);
+    }
+}
+
+static inline uint8_t readMatrixPin(pin_t pin) {
+    if (pin != NO_PIN) {
+        return readPin(pin);
+    } else {
+        return 1;
+    }
+}
+
+static bool select_col(uint8_t col) {
+    pin_t pin = col_pins[col];
+
+    if (col < 1) {
+        if (pin != NO_PIN) {
+            setPinOutput_writeLow(pin);
+            return true;
+        }
+    } else {
+        HC595_output(~(0x01 << (col - 1)));
+        return true;
+    }
+    return false;
+}
+
+static void unselect_col(uint8_t col) {
+    pin_t pin = col_pins[col];
+
+    if (col < 1) {
+        if (pin != NO_PIN) {
+            setPinInputHigh_atomic(pin);
+        }
+    } else {
+        // HC595_output(0x01 << (col - 1));
+        if (col >= MATRIX_COLS - 1) HC595_output(0xFFFF);
+    }
+}
+
+static void unselect_cols(void) {
+    if (col_pins[0] != NO_PIN) setPinInputHigh_atomic(col_pins[0]);
+    HC595_output(0xFFFF);
+}
+
+void select_all_cols(void) {
+    if (col_pins[0] != NO_PIN) setPinOutput_writeLow(col_pins[0]);
+    HC595_output(0x0000);
+}
+
+void matrix_read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col) {
+
+    // Select col
+    if (!select_col(current_col)) { // select col
+        return;                     // skip NO_PIN col
+    }
+
+    HC595_delay(100);
+
+    // 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] |= (MATRIX_ROW_SHIFTER << current_col);
+            // key_pressed = true;
+        } else {
+            // Pin HI, clear col bit
+            current_matrix[row_index] &= ~(MATRIX_ROW_SHIFTER << current_col);
+        }
+    }
+
+    unselect_col(current_col);
+    HC595_delay(100);
+}
+
+void matrix_init_custom(void) {
+    for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
+        if (row_pins[x] != NO_PIN) {
+            setPinInputHigh_atomic(row_pins[x]);
+        }
+    }
+    setPinOutput(HC595_DS);
+    setPinOutput(HC595_STCP);
+    setPinOutput(HC595_SHCP);
+    unselect_cols();
+}
+
+bool matrix_scan_custom(matrix_row_t current_matrix[]) {
+    bool matrix_has_changed = false;
+
+    matrix_row_t curr_matrix[MATRIX_ROWS] = {0};
+
+    // Set col, read rows
+    for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++) {
+        matrix_read_rows_on_col(curr_matrix, current_col);
+    }
+
+    matrix_has_changed = memcmp(current_matrix, curr_matrix, sizeof(curr_matrix)) != 0;
+    if (matrix_has_changed) memcpy(current_matrix, curr_matrix, sizeof(curr_matrix));
+
+    return matrix_has_changed;
+}

keyboards/keychron/k8_pro/mcuconf.h

@@ -0,0 +1,37 @@
+/* Copyright 2020 QMK
+ *
+ * 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_next <mcuconf.h>
+
+/* Set HCLK to 48 MHz as tradeoff of USB lowest clockand and 
+ * lower power comsumption for bluetooth. Will use dynamic 
+ * clock when STM32L4 is supported in ChibiOS */
+#undef STM32_PLLM_VALUE
+#define STM32_PLLM_VALUE 2
+
+#undef STM32_PLLN_VALUE
+#define STM32_PLLN_VALUE 12
+
+#undef STM32_I2C_USE_I2C1
+#define STM32_I2C_USE_I2C1 TRUE
+
+#ifdef BLUETOOTH_ENABLE
+#    undef STM32_SERIAL_USE_USART2
+#    define STM32_SERIAL_USE_USART2 TRUE
+#endif

keyboards/keychron/k8_pro/readme.md

@@ -0,0 +1,21 @@
+# Keychron K8 Pro
+
+![Keychron K8 Pro](https://cdn.shopify.com/s/files/1/0059/0630/1017/t/5/assets/keychronk8proqmkviawirelessmechanicalkeyboardformacwindowsosaprofilepbtkeycapspcbscrewinstabilizerwithhotswappablegaterongpromechanicalswitchcompatiblewithmxcherrypandakailhwithrgbbacklightaluminumframe-1645094681965.jpg)
+
+A customizable 87 keys TKL keyboard.
+
+* Keyboard Maintainer: [Keychron](https://github.com/keychron)
+* Hardware Supported: Keychron K8 Pro
+* Hardware Availability: [Keychron K8 Pro QMK/VIA Wireless Mechanical Keyboard](https://www.keychron.com/products/keychron-k8-pro-qmk-via-wireless-mechanical-keyboard)
+
+Make example for this keyboard (after setting up your build environment):
+
+    make keychron/k8_pro/ansi/rgb:default
+
+Flashing example for this keyboard:
+
+    make keychron/k8_pro/ansi/rgb:default:flash
+
+**Reset Key**: Connect the USB cable, toggle mode switch to "Off", hold down the *Esc* key or reset button underneath space bar, then toggle then switch to "Cable".
+
+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/k8_pro/rules.mk

@@ -0,0 +1,36 @@
+# MCU name
+MCU = STM32L432
+ 
+# Bootloader selection
+BOOTLOADER = stm32-dfu
+
+# Build Options
+#   change yes to no to disable
+#
+BOOTMAGIC_ENABLE = yes      # Enable boot magic
+MOUSEKEY_ENABLE = yes       # Mouse keys
+EXTRAKEY_ENABLE = yes       # Audio control and System control
+CONSOLE_ENABLE = yes         # Console for debug
+COMMAND_ENABLE = no         # Commands for debug and configuration
+# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
+SLEEP_LED_ENABLE = no       # Breathing sleep LED during USB suspend
+# if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
+NKRO_ENABLE = yes           # USB Nkey Rollover
+BACKLIGHT_ENABLE = no       # Enable keyboard backlight functionality
+RGBLIGHT_ENABLE = no        # Enable keyboard RGB underglow
+BLUETOOTH_ENABLE = yes       # Enable Bluetooth with
+BLUETOOTH_DRIVER = custom
+AUDIO_ENABLE = no           # Audio output on port C6
+DIP_SWITCH_ENABLE = yes
+RAW_ENABLE = yes
+
+# Enter lower-power sleep mode when on the ChibiOS idle thread
+OPT_DEFS += -DCORTEX_ENABLE_WFI_IDLE=TRUE
+OPT_DEFS += -DNO_USB_STARTUP_CHECK -DENABLE_FACTORY_TEST
+
+CUSTOM_MATRIX = lite
+SRC += matrix.c
+
+include keyboards/keychron/bluetooth/bluetooth.mk
+
+

platforms/chibios/eeprom_stm32_defs.h

@@ -17,6 +17,9 @@
 
 #include <hal.h>
 
+#define __PRINT_MACRO(x) #x
+#define PRINT_MARCO(x) #x"=" __PRINT_MACRO(x)
+
 #if !defined(FEE_PAGE_SIZE) || !defined(FEE_PAGE_COUNT)
 #    if defined(STM32F103xB) || defined(STM32F042x6) || defined(GD32VF103C8) || defined(GD32VF103CB)
 #        ifndef FEE_PAGE_SIZE
@@ -25,7 +28,7 @@
 #        ifndef FEE_PAGE_COUNT
 #            define FEE_PAGE_COUNT 2 // How many pages are used
 #        endif
-#    elif defined(STM32F103xE) || defined(STM32F303xC) || defined(STM32F303xE) || defined(STM32F072xB) || defined(STM32F070xB)
+#    elif defined(STM32F103xE) || defined(STM32F303xC) || defined(STM32F303xE) || defined(STM32F072xB) || defined(STM32F070xB) || defined(STM32L432xx)
 #        ifndef FEE_PAGE_SIZE
 #            define FEE_PAGE_SIZE 0x800 // Page size = 2KByte
 #        endif
@@ -47,7 +50,7 @@
 #        define FEE_MCU_FLASH_SIZE 32 // Size in Kb
 #    elif defined(GD32VF103C8)
 #        define FEE_MCU_FLASH_SIZE 64 // Size in Kb
-#    elif defined(STM32F103xB) || defined(STM32F072xB) || defined(STM32F070xB) || defined(GD32VF103CB)
+#    elif defined(STM32F103xB) || defined(STM32F072xB) || defined(STM32F070xB) || defined(GD32VF103CB) || defined(STM32L432xx)
 #        define FEE_MCU_FLASH_SIZE 128 // Size in Kb
 #    elif defined(STM32F303xC) || defined(STM32F401xC)
 #        define FEE_MCU_FLASH_SIZE 256 // Size in Kb

platforms/chibios/eeprom_stm32_l4.c

@@ -0,0 +1,598 @@
+/*
+ * This software is experimental and a work in progress.
+ * Under no circumstances should these files be used in relation to any critical system(s).
+ * Use of these files is at your own risk.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+ * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * This files are free to use from http://engsta.com/stm32-flash-memory-eeprom-emulator/ by
+ * Artur F.
+ *
+ * Modifications for QMK and STM32L432 by lalalademaxiya1 & lokher
+ *
+ * TODO: Add ECC correction interrupt handler.
+ */
+
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include "flash_stm32.h"
+#include "eeprom_stm32_defs.h"
+#include "eeprom_stm32_l4.h"
+#include "print.h"
+/*
+ * We emulate eeprom by writing a snapshot compacted view of eeprom contents,
+ * followed by a write log of any change since that snapshot:
+ *
+ * === SIMULATED EEPROM CONTENTS ===
+ *
+ * ┌─ Compacted─┬─ Write Log ──┐
+ * │............│[DWord][DWord]│
+ * │FFFF....FFFF│[DWord][DWord]│
+ * │FFFFFFFFFFFF│[DWord][DWord]│
+ * │....FFFFFFFF│[DWord][DWord]│
+ * ├────────────┼──────────────┤
+ * └──PAGE_BASE │              │
+ *    PAGE_LAST─┴─WRITE_BASE   │
+ *                WRITE_LAST ──┘
+ *
+ * Compacted contents are the 1's complement of the actual EEPROM contents.
+ * e.g. An 'FFFF' represents a '0000' value.
+ *
+ * The size of the 'compacted' area is equal to the size of the 'emulated' eeprom.
+ * The size of the compacted-area and write log are configurable, and the combined
+ * size of Compacted + WriteLog is a multiple FEE_PAGE_SIZE, which is MCU dependent.
+ * Simulated Eeprom contents are located at the end of available flash space.
+ *
+ * The following configuration defines can be set:
+ *
+ * FEE_PAGE_COUNT   # Total number of pages to use for eeprom simulation (Compact + Write log)
+ * FEE_DENSITY_BYTES   # Size of simulated eeprom. (Defaults to one pages of FEE_PAGE_COUNT)
+ * NOTE: The current implementation does not include page swapping,
+ * and FEE_DENSITY_BYTES will consume that amount of RAM as a cached view of actual EEPROM contents.
+ *
+ * The maximum size of FEE_DENSITY_BYTES is currently 8192. The write log size equals
+ * FEE_PAGE_COUNT * FEE_PAGE_SIZE - FEE_DENSITY_BYTES.
+ * The larger the write log, the less frequently the compacted area needs to be rewritten.
+ *
+ *
+ * *** General Algorithm ***
+ *
+ * During initialization:
+ * The contents of the Compacted-flash area are loaded and the 1's complement value
+ * is cached into memory (e.g. 0xFFFF in Flash represents 0x0000 in cache).
+ * Write log entries are processed until a 0xFFFF is reached.
+ * Each log entry updates 1/2/4 byte(s) in the cache.
+ *
+ * During reads:
+ * EEPROM contents are given back directly from the cache in memory.
+ *
+ * During writes:
+ * The contents of the cache is updated first.
+ * If the Compacted-flash area corresponding to the write address is unprogrammed, the 1's complement of the value is written directly into Compacted-flash
+ * Otherwise:
+ * If the write log is full, erase both the Compacted-flash area and the Write log, then write cached contents to the Compacted-flash area.
+ * Otherwise a Write log entry is constructed and appended to the next free position in the Write log.
+ *
+ *
+ * *** Write Log Structure ***
+ *
+ * Each log entry compose of double word (2 x 32-bit) due to the minimum program size of STM32L432 flash.
+ *
+ * === WRITE LOG ENTRY FORMATS ===
+ *
+ * ╔══════════ Byte-Entry ═════════╗
+ * ║ 00 01 XX XX   ║ FF FF FF YY   ║
+ * ║ └─┬─┘ └─┬─┘   ║          └┘   ║
+ * ║  Len  Address ║       ~Value  ║
+ * ╚═══════════════╩═══════════════╝
+ *
+ * ╔══════════ Word-Entry ═════════╗
+ * ║ 00 02 XX XX   ║ FF FF YY YY   ║
+ * ║ └─┬─┘ └─┬─┘   ║       └─┬─┘   ║
+ * ║  Len  Address ║      ~Value   ║
+ * ╚═══════════════╩═══════════════╝
+ *
+ * ╔══════════ DWord-Entry  ═══════╗
+ * ║ 00 04 XX XX   ║  FF FF FF FF  ║
+ * ║ └─┬─┘ └─┬─┘   ║  └───┬────┘   ║
+ * ║  Len  Address ║   ~Value      ║
+ * ╚═══════════════╩═══════════════╝
+ *
+ */
+
+#include "eeprom_stm32_defs.h"
+#if !defined(FEE_PAGE_SIZE) || !defined(FEE_PAGE_COUNT) || !defined(FEE_MCU_FLASH_SIZE) || !defined(FEE_PAGE_BASE_ADDRESS)
+#    error "not implemented."
+#endif
+
+/* These bits indicate that the length of data which was wrote to log space */
+#define FEE_BYTE_FLAG 0x00010000
+#define FEE_WORD_FLAG 0x00020000
+#define FEE_DWORD_FLAG 0x00040000
+
+/* Flash byte value after erase */
+#define FEE_EMPTY_BYTE ((uint8_t)0xFF)
+/* Flash double byte value after erase */
+#define FEE_EMPTY_DBYTE ((uint16_t)0xFFFF)
+/* Flash word value after erase */
+#define FEE_EMPTY_WORD ((uint32_t)0xFFFFFFFF)
+/* Flash double word value after erase */
+#define FEE_EMPTY_DWORD ((uint64_t)0xFFFFFFFFFFFFFFFF)
+
+/* Size of combined compacted eeprom and write log pages */
+#define FEE_DENSITY_MAX_SIZE (FEE_PAGE_COUNT * FEE_PAGE_SIZE)
+
+#ifndef FEE_MCU_FLASH_SIZE_IGNORE_CHECK /* *TODO: Get rid of this check */
+#    if FEE_DENSITY_MAX_SIZE > (FEE_MCU_FLASH_SIZE * 1024)
+#        pragma message STR(FEE_DENSITY_MAX_SIZE) " > " STR(FEE_MCU_FLASH_SIZE * 1024)
+#        error emulated eeprom: FEE_DENSITY_MAX_SIZE is greater than available flash size
+#    endif
+#endif
+
+/* Size of emulated eeprom */
+#ifdef FEE_DENSITY_BYTES
+#    if (FEE_DENSITY_BYTES > FEE_DENSITY_MAX_SIZE)
+#        pragma message STR(FEE_DENSITY_BYTES) " > " STR(FEE_DENSITY_MAX_SIZE)
+#        error emulated eeprom: FEE_DENSITY_BYTES exceeds FEE_DENSITY_MAX_SIZE
+#    endif
+#    if (FEE_DENSITY_BYTES == FEE_DENSITY_MAX_SIZE)
+#        pragma message STR(FEE_DENSITY_BYTES) " == " STR(FEE_DENSITY_MAX_SIZE)
+#        warning emulated eeprom: FEE_DENSITY_BYTES leaves no room for a write log.  This will greatly increase the flash wear rate!
+#    endif
+#    if FEE_DENSITY_BYTES > FEE_ADDRESS_MAX_SIZE
+#        pragma message STR(FEE_DENSITY_BYTES) " > " STR(FEE_ADDRESS_MAX_SIZE)
+#        error emulated eeprom: FEE_DENSITY_BYTES is greater than FEE_ADDRESS_MAX_SIZE allows
+#    endif
+#    if ((FEE_DENSITY_BYTES) % 8) != 0
+#        error emulated eeprom: FEE_DENSITY_BYTES must be a multiple of 8
+#    endif
+#else
+/* Default to one page of allocated space used for emulated eeprom, 3 pages for write log */
+#    define FEE_DENSITY_BYTES FEE_PAGE_SIZE
+#endif
+
+/* Size of write log */
+#ifdef FEE_WRITE_LOG_BYTES
+#    if ((FEE_DENSITY_BYTES + FEE_WRITE_LOG_BYTES) > FEE_DENSITY_MAX_SIZE)
+#        pragma message STR(FEE_DENSITY_BYTES) " + " STR(FEE_WRITE_LOG_BYTES) " > " STR(FEE_DENSITY_MAX_SIZE)
+#        error emulated eeprom: FEE_WRITE_LOG_BYTES exceeds remaining FEE_DENSITY_MAX_SIZE
+#    endif
+#    if ((FEE_WRITE_LOG_BYTES) % 8) != 0
+#        error emulated eeprom: FEE_WRITE_LOG_BYTES must be a multiple of 8
+#    endif
+#else
+/* Default to use all remaining space */
+#    define FEE_WRITE_LOG_BYTES (FEE_PAGE_COUNT * FEE_PAGE_SIZE - FEE_DENSITY_BYTES)
+#endif
+
+/* In-memory contents of emulated eeprom for faster access */
+/* *TODO: Implement page swapping */
+static uint64_t DWordBuf[FEE_DENSITY_BYTES / 8];
+static uint8_t *DataBuf = (uint8_t *)DWordBuf;
+
+/* Pointer to the first available slot within the write log */
+static uint32_t *empty_slot;
+/* ECC error flag, set in NMI when 2 bits ECC error is detected */
+static bool eccd;
+
+/* Start of the emulated eeprom compacted flash area */
+#define FEE_COMPACTED_BASE_ADDRESS FEE_PAGE_BASE_ADDRESS
+/* End of the emulated eeprom compacted flash area */
+#define FEE_COMPACTED_LAST_ADDRESS (FEE_COMPACTED_BASE_ADDRESS + FEE_DENSITY_BYTES)
+/* Start of the emulated eeprom write log */
+#define FEE_WRITE_LOG_BASE_ADDRESS FEE_COMPACTED_LAST_ADDRESS
+/* End of the emulated eeprom write log */
+#define FEE_WRITE_LOG_LAST_ADDRESS (FEE_WRITE_LOG_BASE_ADDRESS + FEE_WRITE_LOG_BYTES)
+
+uint16_t EEPROM_Init(void) {
+    eccd = false;
+
+    /* Load emulated eeprom contents from compacted flash into memory */
+    uint32_t *src  = (uint32_t *)FEE_COMPACTED_BASE_ADDRESS;
+    uint32_t *dest = (uint32_t *)DataBuf;
+    for (; src < (uint32_t *)FEE_COMPACTED_LAST_ADDRESS; ++src, ++dest) {
+        *dest = ~*src;
+    }
+
+    /* Replay write log */
+    uint32_t *log_addr;
+    for (log_addr = (uint32_t *)FEE_WRITE_LOG_BASE_ADDRESS; log_addr < (uint32_t *)FEE_WRITE_LOG_LAST_ADDRESS; log_addr += 2) {
+        uint32_t address = *log_addr;
+
+        uint32_t data = ~*(log_addr + 1);
+
+        /* Break loop if ECC error is detected */
+        if (eccd) break;
+
+        if (address == FEE_EMPTY_WORD) {
+            break;
+        }
+        /* Check if value is in bytes */
+        else if ((address & FEE_BYTE_FLAG) == FEE_BYTE_FLAG) {
+            uint8_t  value = (uint8_t)(data & 0xFF);
+            uint16_t addr  = (uint16_t)address;
+            DataBuf[addr]  = value;
+        }
+        /* Check if value is in words */
+        else if ((address & FEE_WORD_FLAG) == FEE_WORD_FLAG) {
+            uint16_t value                = (uint16_t)(data & 0xFFFF);
+            uint16_t addr                 = (uint16_t)address;
+            *(uint16_t *)(&DataBuf[addr]) = value;
+        }
+        /* Check if value is in double words */
+        else if ((address & FEE_DWORD_FLAG) == FEE_DWORD_FLAG) {
+            uint32_t value                = data;
+            uint16_t addr                 = (uint16_t)address;
+            *(uint32_t *)(&DataBuf[addr]) = value;
+        }
+    }
+
+    empty_slot = log_addr;
+
+    /* Give more chance for NMI interrupt */
+    asm("nop");
+
+    /* Reset eeprom data if ECC error is detected*/
+    if (eccd) return 0;
+
+    return FEE_DENSITY_BYTES;
+}
+
+/* Clear flash contents (doesn't touch in-memory DataBuf) */
+static void eeprom_clear(void) {
+    FLASH_Unlock();
+
+    for (uint16_t page_num = 0; page_num < FEE_PAGE_COUNT; ++page_num) {
+        FLASH_ErasePage(FEE_PAGE_BASE_ADDRESS + (page_num * FEE_PAGE_SIZE));
+    }
+
+    FLASH_Lock();
+
+    empty_slot = (uint32_t *)FEE_WRITE_LOG_BASE_ADDRESS;
+}
+
+/* Erase emulated eeprom */
+void EEPROM_Erase(void) {
+    /* Erase compacted pages and write log */
+    eeprom_clear();
+    /* re-initialize to reset DataBuf */
+    EEPROM_Init();
+}
+
+/* Compact write log */
+static uint8_t eeprom_compact(void) {
+    /* Erase compacted pages and write log */
+    eeprom_clear();
+
+    FLASH_Unlock();
+
+    FLASH_Status final_status = FLASH_COMPLETE;
+
+    /* Write emulated eeprom contents from memory to compacted flash */
+    uint64_t *src  = (uint64_t *)DataBuf;
+    uint32_t  dest = FEE_COMPACTED_BASE_ADDRESS;
+    uint64_t  value;
+    for (; dest < FEE_COMPACTED_LAST_ADDRESS; ++src, dest += 8) {
+        value = *src;
+        if (value) {
+            FLASH_Status status = FLASH_ProgramDoubleWord(dest, ~value);
+            if (status != FLASH_COMPLETE) final_status = status;
+        }
+    }
+
+    FLASH_Lock();
+
+    return final_status;
+}
+
+static uint8_t eeprom_write_direct_entry(uint16_t Address) {
+    /* Check if we can just write this directly to the compacted flash area */
+    uint32_t directAddress = FEE_COMPACTED_BASE_ADDRESS + (Address & 0xFFF8);
+
+    /* Write the value directly to the compacted area without a log entry */
+    if (*(uint64_t *)directAddress == FEE_EMPTY_DWORD) {
+        /* Write the value directly to the compacted area without a log entry */
+        uint64_t value = ~*(uint64_t *)(&DataBuf[Address & 0xFFF8]);
+
+        /* Early exit if a write isn't needed */
+        if (value == FEE_EMPTY_DWORD) return FLASH_COMPLETE;
+
+        FLASH_Unlock();
+
+        /* write to flash */
+        FLASH_Status status = FLASH_ProgramDoubleWord(directAddress, value);
+
+        FLASH_Lock();
+
+        return status;
+    }
+    return 0;
+}
+
+static void blank_check(uint32_t Address) {
+    /* Align address to 64 bit */
+    Address &= (~0x07);
+
+    /* Check if target address is blank */
+    if (*(uint64_t *)(Address) != 0xFFFFFFFFFFFFFFFF) {
+        if ((Address & (FEE_PAGE_SIZE - 1)) == 0) {
+            /* Erase current page if first byte is not empty */
+            FLASH_Unlock();
+            FLASH_ErasePage(Address);
+            FLASH_Lock();
+        } else {
+            /* Compact data if we encounter non empty target address after page head */
+            eeprom_compact();
+        }
+    }
+}
+
+static uint8_t eeprom_write_log_byte_entry(uint16_t Address) {
+    /* if we can't find an empty spot, we must compact emulated eeprom */
+    if (empty_slot >= (uint32_t *)FEE_WRITE_LOG_LAST_ADDRESS) {
+        /* compact the write log into the compacted flash area */
+        return eeprom_compact();
+    }
+
+    blank_check((uint32_t)empty_slot);
+
+    FLASH_Unlock();
+
+    /* Pack address and value into the same word */
+    uint64_t value = (((uint64_t)(~DataBuf[Address])) << 32) | (FEE_BYTE_FLAG) | Address;
+
+    /* write to flash */
+    FLASH_Status status = FLASH_ProgramDoubleWord((uint32_t)empty_slot, value);
+
+    empty_slot += 2;
+
+    FLASH_Lock();
+
+    return status;
+}
+
+static uint8_t eeprom_write_log_word_entry(uint16_t Address) {
+    /* if we can't find an empty spot, we must compact emulated eeprom */
+    if (empty_slot >= (uint32_t *)FEE_WRITE_LOG_LAST_ADDRESS) {
+        /* compact the write log into the compacted flash area */
+        return eeprom_compact();
+    }
+
+    blank_check((uint32_t)empty_slot);
+
+    FLASH_Unlock();
+
+    /* Pack address and value into the same word */
+    uint64_t value = (((uint64_t)(~(*(uint16_t *)&DataBuf[Address]))) << 32) | (FEE_WORD_FLAG) | Address;
+
+    /* write to flash */
+    FLASH_Status status = FLASH_ProgramDoubleWord((uint32_t)empty_slot, value);
+
+    empty_slot += 2;
+
+    FLASH_Lock();
+
+    return status;
+}
+
+static uint8_t eeprom_write_log_dword_entry(uint16_t Address) {
+    /* if we can't find an empty spot, we must compact emulated eeprom */
+    if (empty_slot >= (uint32_t *)FEE_WRITE_LOG_LAST_ADDRESS) {
+        /* compact the write log into the compacted flash area */
+        return eeprom_compact();
+    }
+
+    blank_check((uint32_t)empty_slot);
+
+    FLASH_Unlock();
+
+    /* Pack address and value into the same word */
+    uint64_t value = (((uint64_t)(~(*(uint32_t *)&DataBuf[Address]))) << 32) | (FEE_DWORD_FLAG) | Address;
+
+    /* write to flash */
+    FLASH_Status status = FLASH_ProgramDoubleWord((uint32_t)empty_slot, value);
+
+    empty_slot += 2;
+
+    FLASH_Lock();
+
+    return status;
+}
+
+uint8_t EEPROM_WriteDataByte(uint16_t Address, uint8_t DataByte) {
+    /* if the address is out-of-bounds, do nothing */
+    if (Address >= (FEE_DENSITY_BYTES)) {
+        return FLASH_BAD_ADDRESS;
+    }
+
+    /* if the value is the same, don't bother writing it */
+    if (DataBuf[Address] == DataByte) {
+        return 0;
+    }
+
+    /* keep DataBuf cache in sync */
+    DataBuf[Address] = DataByte;
+
+    /* perform the write into flash memory */
+    /* First, attempt to write directly into the compacted flash area */
+    FLASH_Status status = eeprom_write_direct_entry(Address);
+
+    if (!status) {
+        status = eeprom_write_log_byte_entry(Address);
+    }
+
+    return status;
+}
+
+uint8_t EEPROM_WriteDataWord(uint16_t Address, uint16_t DataWord) {
+    /* if the address is out-of-bounds, do nothing */
+    if (Address >= (FEE_DENSITY_BYTES - 1)) {
+        return FLASH_BAD_ADDRESS;
+    }
+
+    /* if the value is the same, don't bother writing it */
+    if (*(uint16_t *)&DataBuf[Address] == DataWord) {
+        return 0;
+    }
+
+    /* keep DataBuf cache in sync */
+    *(uint16_t *)(&DataBuf[Address]) = DataWord;
+
+    /* perform the write into flash memory */
+    /* First, attempt to write directly into the compacted flash area */
+    FLASH_Status status = eeprom_write_direct_entry(Address);
+
+    if (!status) {
+        status = eeprom_write_log_word_entry(Address);
+    }
+
+    return status;
+}
+
+uint8_t EEPROM_WriteDataDWord(uint16_t Address, uint32_t DataDWord) {
+    /* if the address is out-of-bounds, do nothing */
+    if (Address >= (FEE_DENSITY_BYTES - 3)) {
+        return FLASH_BAD_ADDRESS;
+    }
+
+    /* if the value is the same, don't bother writing it */
+    if (*(uint32_t *)&DataBuf[Address] == DataDWord) {
+        return 0;
+    }
+
+    /* keep DataBuf cache in sync */
+    *(uint32_t *)&DataBuf[Address] = DataDWord;
+
+    /* perform the write into flash memory */
+    /* First, attempt to write directly into the compacted flash area */
+    FLASH_Status status = eeprom_write_direct_entry(Address);
+
+    if (!status) {
+        status = eeprom_write_log_dword_entry(Address);
+    }
+
+    return status;
+}
+
+uint8_t EEPROM_ReadDataByte(uint16_t Address) {
+    uint8_t DataByte = 0xFF;
+
+    if (Address < FEE_DENSITY_BYTES) {
+        DataByte = DataBuf[Address];
+    }
+
+    return DataByte;
+}
+
+uint16_t EEPROM_ReadDataWord(uint16_t Address) {
+    uint16_t DataWord = 0xFFFF;
+
+    if (Address < FEE_DENSITY_BYTES - 1) {
+        /* Check word alignment */
+        if (Address % 2) {
+            DataWord = DataBuf[Address] | (DataBuf[Address + 1] << 8);
+        } else {
+            DataWord = *(uint16_t *)(&DataBuf[Address]);
+        }
+    }
+
+    return DataWord;
+}
+
+/*****************************************************************************
+ *  Bind to eeprom_driver.c
+ *******************************************************************************/
+uint16_t eeprom_driver_init(void) {
+    return EEPROM_Init();
+}
+
+void eeprom_driver_erase(void) {
+    EEPROM_Erase();
+}
+
+void eeprom_read_block(void *buf, const void *addr, size_t len) {
+    const uint8_t *src  = (const uint8_t *)addr;
+    uint8_t *      dest = (uint8_t *)buf;
+
+    /* Check word alignment */
+    if (len && (uint32_t)src % 2) {
+        /* Read the unaligned first byte */
+        *dest++ = EEPROM_ReadDataByte((const uintptr_t)((uint16_t *)src));
+        --len;
+    }
+
+    uint16_t value;
+    bool     aligned = ((uint32_t)dest % 2 == 0);
+    while (len > 1) {
+        value = EEPROM_ReadDataWord((const uintptr_t)((uint16_t *)src));
+        if (aligned) {
+            *(uint16_t *)dest = value;
+            dest += 2;
+        } else {
+            *dest++ = value;
+            *dest++ = value >> 8;
+        }
+        src += 2;
+        len -= 2;
+    }
+    if (len) {
+        *dest = EEPROM_ReadDataByte((const uintptr_t)src);
+    }
+}
+
+void eeprom_write_block(const void *buf, void *addr, size_t len) {
+    uint8_t *      dest = (uint8_t *)addr;
+    const uint8_t *src  = (const uint8_t *)buf;
+    uint8_t        write_len;
+
+    while (len > 0) {
+        /* Check and try to write double word fisrt */
+        if ((uintptr_t)dest % 4 == 0 && len >= 4) {
+            uint32_t dwvalue;
+            bool     dwaligned = ((uint32_t)src % 4 == 0);
+
+            if (dwaligned) {
+                dwvalue = *(uint32_t *)src;
+            } else {
+                dwvalue = *(uint8_t *)src | (*(uint8_t *)(src + 1) << 8) | (*(uint8_t *)(src + 2) << 16) | (*(uint8_t *)(src + 3) << 24);
+            }
+            EEPROM_WriteDataDWord((uintptr_t)((uint16_t *)dest), dwvalue);
+            write_len = 4;
+        }
+        /* Check and try to write word */
+        else if ((uintptr_t)dest % 2 == 0 && len >= 2) {
+            uint16_t wvalue;
+            bool     waligned = ((uintptr_t)src % 2 == 0);
+
+            if (waligned) {
+                wvalue = *(uint16_t *)src;
+            } else {
+                wvalue = *(uint8_t *)src | (*(uint8_t *)(src + 1) << 8);
+            }
+            EEPROM_WriteDataWord((uintptr_t)((uint16_t *)dest), wvalue);
+            write_len = 2;
+        } else {
+            /* Write the unaligned or single byte */
+            EEPROM_WriteDataByte((uintptr_t)dest, *src);
+            write_len = 1;
+        }
+
+        dest += write_len;
+        src += write_len;
+        len -= write_len;
+    }
+}
+
+void NMI_Handler(void) {
+    if (FLASH->ECCR & FLASH_ECCR_ECCD) {
+        /* Clear ECCD error NMI */
+        FLASH->ECCR = FLASH_ECCR_ECCD;
+        eccd        = true;
+    }
+}

platforms/chibios/eeprom_stm32_l4.h

@@ -0,0 +1,34 @@
+/*
+ * This software is experimental and a work in progress.
+ * Under no circumstances should these files be used in relation to any critical system(s).
+ * Use of these files is at your own risk.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+ * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * This files are free to use from http://engsta.com/stm32-flash-memory-eeprom-emulator/ by
+ * Artur F.
+ *
+ * Modifications for QMK and STM32L432 by lalalademaxiya1 & lokher
+ *
+ * To add a new MCU, please provide the flash page size and the total flash size in Kb.
+ * The number of available pages must be at least two. Only one page for the total EEPROM size.
+ * It is recommend to set the number of log page to 3~5 times of data page for better wear leveling.
+ *
+ */
+
+#pragma once
+
+typedef unsigned long long uint64_t;
+
+uint16_t EEPROM_Init(void);
+void     EEPROM_Erase(void);
+uint8_t  EEPROM_WriteDataByte(uint16_t Address, uint8_t DataByte);
+uint8_t  EEPROM_WriteDataWord(uint16_t Address, uint16_t DataWord);
+uint8_t  EEPROM_WriteDataDWord(uint16_t Address, uint32_t DataDWord);
+uint8_t  EEPROM_ReadDataByte(uint16_t Address);
+uint16_t EEPROM_ReadDataWord(uint16_t Address);

platforms/chibios/flash_stm32.c

@@ -51,6 +51,15 @@ static uint8_t ADDR2PAGE(uint32_t Page_Address) {
 }
 #endif
 
+#if defined(STM32L4XX)
+#    define FLASH_SR_PGERR (FLASH_SR_PROGERR | FLASH_SR_PGAERR | FLASH_SR_SIZERR | FLASH_SR_PGSERR)
+#    define FLASH_OBR_OPTERR FLASH_SR_OPERR
+#    define FLASH_KEY1 0x45670123U
+#    define FLASH_KEY2 0xCDEF89ABU
+
+static uint32_t ADDR2PAGE(uint32_t Page_Address) { return (Page_Address - FLASH_BASE) / 0x800; }
+#endif
+
 /* Delay definition */
 #define EraseTimeout ((uint32_t)0x00000FFF)
 #define ProgramTimeout ((uint32_t)0x0000001F)
@@ -128,6 +137,9 @@ FLASH_Status FLASH_ErasePage(uint32_t Page_Address) {
 #if defined(FLASH_CR_SNB)
         FLASH->CR &= ~FLASH_CR_SNB;
         FLASH->CR |= FLASH_CR_SER | (ADDR2PAGE(Page_Address) << FLASH_CR_SNB_Pos);
+#elif defined(FLASH_CR_PNB)
+        FLASH->CR &= ~FLASH_CR_PNB;
+        FLASH->CR |= FLASH_CR_PER | (ADDR2PAGE(Page_Address) << FLASH_CR_PNB_Pos);
 #else
         FLASH->CR |= FLASH_CR_PER;
         FLASH->AR = Page_Address;
@@ -140,6 +152,8 @@ FLASH_Status FLASH_ErasePage(uint32_t Page_Address) {
             /* if the erase operation is completed, disable the configured Bits */
 #if defined(FLASH_CR_SNB)
             FLASH->CR &= ~(FLASH_CR_SER | FLASH_CR_SNB);
+#elif defined(FLASH_CR_PNB)
+            FLASH->CR &= ~(FLASH_CR_PER | FLASH_CR_PNB);
 #else
             FLASH->CR &= ~FLASH_CR_PER;
 #endif
@@ -150,6 +164,46 @@ FLASH_Status FLASH_ErasePage(uint32_t Page_Address) {
     return status;
 }
 
+#if defined(STM32L4XX)
+/**
+ * @brief  Programs double words at a specified address.
+ * @param  Address: specifies the address to be programmed.
+ * @param  Data: specifies the data to be programmed.
+ * @retval FLASH Status: The returned value can be: FLASH_ERROR_PG,
+ *   FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT.
+ */
+FLASH_Status FLASH_ProgramDoubleWord(uint32_t Address, uint64_t Data) {
+    FLASH_Status status = FLASH_BAD_ADDRESS;
+
+    if (IS_FLASH_ADDRESS(Address)) {
+        /* Wait for last operation to be completed */
+        status = FLASH_WaitForLastOperation(ProgramTimeout);
+        if (status == FLASH_COMPLETE) {
+            /* if the previous operation is completed, proceed to program the new data */
+            /* disable data cache first */
+            FLASH->ACR &= ~FLASH_ACR_DCEN;
+            FLASH->CR |= FLASH_CR_PG;
+            *(__IO uint32_t*)Address = (uint32_t)Data;
+            __ISB();
+            *(__IO uint32_t*)(Address + 4U) = (uint32_t)(Data >> 32);
+            /* Wait for last operation to be completed */
+            status = FLASH_WaitForLastOperation(ProgramTimeout);
+            if (status != FLASH_TIMEOUT) {
+                /* if the program operation is completed, disable the PG Bit */
+                FLASH->CR &= ~FLASH_CR_PG;
+            }
+            FLASH->SR = (FLASH_SR_EOP | FLASH_SR_PGERR | FLASH_SR_WRPERR);
+            /* reset data cache */
+            FLASH->ACR |= FLASH_ACR_DCRST;
+            FLASH->ACR &= ~FLASH_ACR_DCRST;
+            /* enable data cache */
+            FLASH->ACR |= FLASH_ACR_DCEN;
+        }
+    }
+    return status;
+}
+
+#else
 /**
  * @brief  Programs a half word at a specified address.
  * @param  Address: specifies the address to be programmed.
@@ -183,6 +237,7 @@ FLASH_Status FLASH_ProgramHalfWord(uint32_t Address, uint16_t Data) {
     }
     return status;
 }
+#endif
 
 /**
  * @brief  Unlocks the FLASH Program Erase Controller.

platforms/chibios/flash_stm32.h

@@ -35,6 +35,7 @@ typedef enum { FLASH_BUSY = 1, FLASH_ERROR_PG, FLASH_ERROR_WRP, FLASH_ERROR_OPT,
 FLASH_Status FLASH_WaitForLastOperation(uint32_t Timeout);
 FLASH_Status FLASH_ErasePage(uint32_t Page_Address);
 FLASH_Status FLASH_ProgramHalfWord(uint32_t Address, uint16_t Data);
+FLASH_Status FLASH_ProgramDoubleWord(uint32_t Address, uint64_t Data);
 
 void FLASH_Unlock(void);
 void FLASH_Lock(void);

platforms/eeprom.h

@@ -39,6 +39,9 @@ void     eeprom_update_block(const void *__src, void *__dst, size_t __n);
 #elif defined(EEPROM_STM32_L0_L1)
 #    include "eeprom_stm32_L0_L1.h"
 #    define TOTAL_EEPROM_BYTE_COUNT (STM32_ONBOARD_EEPROM_SIZE)
+#elif defined(EEPROM_STM32_L4)
+#    include "eeprom_stm32_defs.h"
+#    define TOTAL_EEPROM_BYTE_COUNT (FEE_DENSITY_BYTES)
 #elif defined(EEPROM_TEENSY)
 #    include "eeprom_teensy.h"
 #    define TOTAL_EEPROM_BYTE_COUNT (EEPROM_SIZE)

quantum/keyboard.c

@@ -257,7 +257,10 @@ __attribute__((weak)) void keyboard_post_init_kb(void) {
 void keyboard_setup(void) {
     print_set_sendchar(sendchar);
 #ifdef EEPROM_DRIVER
-    eeprom_driver_init();
+    if (!eeprom_driver_init()) {
+        eeconfig_init();
+        eeprom_driver_init();
+    }
 #endif
     matrix_setup();
     keyboard_pre_init_kb();

quantum/led_matrix/led_matrix.c

@@ -98,6 +98,10 @@ last_hit_t g_last_hit_tracker;
 #endif // LED_MATRIX_KEYREACTIVE_ENABLED
 
 // internals
+#ifdef LED_MATRIX_DRIVER_SHUTDOWN_ENABLE
+static bool            driver_shutdown   = false;
+#endif
+static uint8_t         led_enable_eeprom = false;
 static bool            suspend_state     = false;
 static uint8_t         led_last_enable   = UINT8_MAX;
 static uint8_t         led_last_effect   = UINT8_MAX;
@@ -105,7 +109,8 @@ static effect_params_t led_effect_params = {0, LED_FLAG_ALL, false};
 static led_task_states led_task_state    = SYNCING;
 #if LED_DISABLE_TIMEOUT > 0
 static uint32_t led_anykey_timer;
-#endif // LED_DISABLE_TIMEOUT > 0
+static uint32_t led_disable_timeout = LED_DISABLE_TIMEOUT;
+#endif  // LED_DISABLE_TIMEOUT > 0
 
 // double buffers
 static uint32_t led_timer_buffer;
@@ -227,12 +232,22 @@ void process_led_matrix(uint8_t row, uint8_t col, bool pressed) {
 #endif // defined(LED_MATRIX_FRAMEBUFFER_EFFECTS) && defined(ENABLE_LED_MATRIX_TYPING_HEATMAP)
 }
 
+void led_matrix_none_indicators(void) {
+    led_matrix_none_indicators_kb();
+    led_matrix_none_indicators_user();
+}
+
+__attribute__((weak)) void led_matrix_none_indicators_kb(void) {}
+
+__attribute__((weak)) void led_matrix_none_indicators_user(void) {}
+
 static bool led_matrix_none(effect_params_t *params) {
     if (!params->init) {
         return false;
     }
 
     led_matrix_set_value_all(0);
+    led_matrix_none_indicators();
     return false;
 }
 
@@ -343,10 +358,24 @@ static void led_task_flush(uint8_t effect) {
     // update last trackers after the first full render so we can init over several frames
     led_last_effect = effect;
     led_last_enable = led_matrix_eeconfig.enable;
+#ifdef LED_MATRIX_DRIVER_SHUTDOWN_ENABLE
+    // exit from shutdown to if neccesary
+    if (driver_shutdown)  {
+        led_matrix_driver.exit_shutdown();
+        driver_shutdown = false;
+    }
+#endif  
 
     // update pwm buffers
     led_matrix_update_pwm_buffers();
 
+#ifdef LED_MATRIX_DRIVER_SHUTDOWN_ENABLE
+    // shutdown if neccesary
+    if (effect == LED_MATRIX_NONE && !driver_shutdown && led_matrix_driver_allow_shutdown()) {  
+        led_matrix_driver_shutdown();
+    }
+#endif  
+
     // next task
     led_task_state = SYNCING;
 }
@@ -358,8 +387,8 @@ void led_matrix_task(void) {
     // while suspended and just do a software shutdown. This is a cheap hack for now.
     bool suspend_backlight = suspend_state ||
 #if LED_DISABLE_TIMEOUT > 0
-                             (led_anykey_timer > (uint32_t)LED_DISABLE_TIMEOUT) ||
-#endif // LED_DISABLE_TIMEOUT > 0
+                             (led_anykey_timer > led_disable_timeout) ||
+#endif  // LED_DISABLE_TIMEOUT > 0
                              false;
 
     uint8_t effect = suspend_backlight || !led_matrix_eeconfig.enable ? 0 : led_matrix_eeconfig.mode;
@@ -384,6 +413,11 @@ void led_matrix_task(void) {
     }
 }
 
+static inline void led_enable_state_backup(void) {
+    dprintf("led_enable_state_backup\n");
+    led_enable_eeprom = led_matrix_eeconfig.enable;
+}
+
 void led_matrix_indicators(void) {
     led_matrix_indicators_kb();
     led_matrix_indicators_user();
@@ -417,6 +451,9 @@ __attribute__((weak)) void led_matrix_indicators_advanced_user(uint8_t led_min,
 
 void led_matrix_init(void) {
     led_matrix_driver.init();
+#ifdef LED_MATRIX_DRIVER_SHUTDOWN_ENABLE
+    driver_shutdown = false;
+#endif 
 
 #ifdef LED_MATRIX_KEYREACTIVE_ENABLED
     g_last_hit_tracker.count = 0;
@@ -441,6 +478,7 @@ void led_matrix_init(void) {
         dprintf("led_matrix_init_drivers led_matrix_eeconfig.mode = 0. Write default values to EEPROM.\n");
         eeconfig_update_led_matrix_default();
     }
+    led_enable_state_backup();
     eeconfig_debug_led_matrix(); // display current eeprom values
 }
 
@@ -462,6 +500,7 @@ void led_matrix_toggle_eeprom_helper(bool write_to_eeprom) {
     led_matrix_eeconfig.enable ^= 1;
     led_task_state = STARTING;
     eeconfig_flag_led_matrix(write_to_eeprom);
+    if (write_to_eeprom) led_enable_state_backup();
     dprintf("led matrix toggle [%s]: led_matrix_eeconfig.enable = %u\n", (write_to_eeprom) ? "EEPROM" : "NOEEPROM", led_matrix_eeconfig.enable);
 }
 void led_matrix_toggle_noeeprom(void) {
@@ -474,6 +513,7 @@ void led_matrix_toggle(void) {
 void led_matrix_enable(void) {
     led_matrix_enable_noeeprom();
     eeconfig_flag_led_matrix(true);
+    led_enable_state_backup();
 }
 
 void led_matrix_enable_noeeprom(void) {
@@ -484,6 +524,7 @@ void led_matrix_enable_noeeprom(void) {
 void led_matrix_disable(void) {
     led_matrix_disable_noeeprom();
     eeconfig_flag_led_matrix(true);
+    led_enable_state_backup();
 }
 
 void led_matrix_disable_noeeprom(void) {
@@ -495,6 +536,11 @@ uint8_t led_matrix_is_enabled(void) {
     return led_matrix_eeconfig.enable;
 }
 
+
+uint8_t led_matrix_is_enabled_eeprom(void) { 
+    return led_enable_eeprom; 
+}
+
 void led_matrix_mode_eeprom_helper(uint8_t mode, bool write_to_eeprom) {
     if (!led_matrix_eeconfig.enable) {
         return;
@@ -563,6 +609,12 @@ uint8_t led_matrix_get_val(void) {
 }
 
 void led_matrix_increase_val_helper(bool write_to_eeprom) {
+#ifdef LED_MATRIX_BRIGHTNESS_TURN_OFF_VAL
+    if (!led_matrix_eeconfig.enable) {
+        dprintf("increase_val to enable");
+        led_matrix_toggle_eeprom_helper(write_to_eeprom);
+    }
+#endif
     led_matrix_set_val_eeprom_helper(qadd8(led_matrix_eeconfig.val, LED_MATRIX_VAL_STEP), write_to_eeprom);
 }
 void led_matrix_increase_val_noeeprom(void) {
@@ -580,6 +632,12 @@ void led_matrix_decrease_val_noeeprom(void) {
 }
 void led_matrix_decrease_val(void) {
     led_matrix_decrease_val_helper(true);
+#ifdef LED_MATRIX_BRIGHTNESS_TURN_OFF_VAL
+    if (led_matrix_eeconfig.enable && led_matrix_eeconfig.val <= LED_MATRIX_BRIGHTNESS_TURN_OFF_VAL) {
+        dprintf("decrease_val to disable\n");
+        led_matrix_toggle_eeprom_helper(true);
+    }
+#endif
 }
 
 void led_matrix_set_speed_eeprom_helper(uint8_t speed, bool write_to_eeprom) {
@@ -625,3 +683,25 @@ led_flags_t led_matrix_get_flags(void) {
 void led_matrix_set_flags(led_flags_t flags) {
     led_matrix_eeconfig.flags = flags;
 }
+
+#if LED_DISABLE_TIMEOUT > 0
+void led_matrix_disable_timeout_set(uint32_t timeout) { 
+    led_disable_timeout = timeout; 
+}
+void led_matrix_disable_time_reset(void){ 
+    led_anykey_timer = 0; 
+}
+#endif
+
+#ifdef LED_MATRIX_DRIVER_SHUTDOWN_ENABLE
+void led_matrix_driver_shutdown(void) { 
+    led_matrix_driver.shutdown();
+    driver_shutdown = true;
+};
+
+bool led_matrix_is_driver_shutdown(void) { 
+    return driver_shutdown; 
+}
+
+__attribute__((weak)) bool led_matrix_driver_allow_shutdown(void) { return true; };
+#endif

quantum/led_matrix/led_matrix.h

@@ -33,6 +33,9 @@
 #ifdef IS31FL3733
 #    include "is31fl3733-simple.h"
 #endif
+#ifdef CKLED2001
+#    include "ckled2001-simple.h"
+#endif
 
 #ifndef LED_MATRIX_LED_FLUSH_LIMIT
 #    define LED_MATRIX_LED_FLUSH_LIMIT 16
@@ -75,6 +78,8 @@
 #define LED_MATRIX_TEST_LED_FLAGS() \
     if (!HAS_ANY_FLAGS(g_led_config.flags[i], params->flags)) continue
 
+#define LED_DISABLE_TIME_INFINITE   (UINT32_MAX)
+
 enum led_matrix_effects {
     LED_MATRIX_NONE = 0,
 
@@ -114,6 +119,9 @@ void process_led_matrix(uint8_t row, uint8_t col, bool pressed);
 
 void led_matrix_task(void);
 
+void led_matrix_none_indicators_kb(void);
+void led_matrix_none_indicators_user(void);
+
 // This runs after another backlight effect and replaces
 // values already set
 void led_matrix_indicators(void);
@@ -135,6 +143,7 @@ void        led_matrix_enable_noeeprom(void);
 void        led_matrix_disable(void);
 void        led_matrix_disable_noeeprom(void);
 uint8_t     led_matrix_is_enabled(void);
+uint8_t     led_matrix_is_enabled_eeprom(void);
 void        led_matrix_mode(uint8_t mode);
 void        led_matrix_mode_noeeprom(uint8_t mode);
 uint8_t     led_matrix_get_mode(void);
@@ -158,6 +167,19 @@ void        led_matrix_decrease_speed(void);
 void        led_matrix_decrease_speed_noeeprom(void);
 led_flags_t led_matrix_get_flags(void);
 void        led_matrix_set_flags(led_flags_t flags);
+#ifdef LED_DISABLE_TIMEOUT
+#   if LED_DISABLE_TIMEOUT > 0
+void        led_matrix_disable_timeout_set(uint32_t timeout);
+void        led_matrix_disable_time_reset(void);
+#   endif
+#endif
+
+#ifdef LED_MATRIX_DRIVER_SHUTDOWN_ENABLE
+void        led_matrix_driver_shutdown(void);
+bool        led_matrix_is_driver_shutdown(void);
+bool        led_matrix_driver_allow_shutdown(void);
+#endif
+
 
 typedef struct {
     /* Perform any initialisation required for the other driver functions to work. */
@@ -169,6 +191,12 @@ typedef struct {
     void (*set_value_all)(uint8_t value);
     /* Flush any buffered changes to the hardware. */
     void (*flush)(void);
+#ifdef LED_MATRIX_DRIVER_SHUTDOWN_ENABLE
+    /* Shutdown the driver. */
+    void (*shutdown)(void);
+    /* Exit from shutdown state. */
+    void (*exit_shutdown)(void);
+#endif
 } led_matrix_driver_t;
 
 static inline bool led_matrix_check_finished_leds(uint8_t led_idx) {

quantum/led_matrix/led_matrix_drivers.c

@@ -25,7 +25,7 @@
  * in their own files.
  */
 
-#if defined(IS31FL3731) || defined(IS31FL3733) || defined(IS31FLCOMMON)
+#if defined(IS31FL3731) || defined(IS31FL3733) || defined(IS31FLCOMMON) || defined(CKLED2001)
 #    include "i2c_master.h"
 
 static void init(void) {
@@ -78,6 +78,23 @@ static void init(void) {
 #                endif
 #            endif
 #        endif
+
+#    elif defined(CKLED2001)
+#        if defined(LED_DRIVER_SHUTDOWN_PIN)
+    setPinOutput(LED_DRIVER_SHUTDOWN_PIN);
+    writePinHigh(LED_DRIVER_SHUTDOWN_PIN);
+#        endif
+
+    CKLED2001_init(DRIVER_ADDR_1);
+#        if defined(DRIVER_ADDR_2)
+    CKLED2001_init(DRIVER_ADDR_2);
+#            if defined(DRIVER_ADDR_3)
+    CKLED2001_init(DRIVER_ADDR_3);
+#                if defined(DRIVER_ADDR_4)
+    CKLED2001_init(DRIVER_ADDR_4);
+#                endif
+#            endif
+#        endif
 #    endif
 
     for (int index = 0; index < DRIVER_LED_TOTAL; index++) {
@@ -87,6 +104,8 @@ static void init(void) {
         IS31FL3733_set_led_control_register(index, true);
 #    elif defined(IS31FLCOMMON)
         IS31FL_simple_set_scaling_buffer(index, true);
+#    elif defined(CKLED2001)
+        CKLED2001_set_led_control_register(index, true);
 #    endif
     }
 
@@ -129,6 +148,18 @@ static void init(void) {
 #                endif
 #            endif
 #        endif
+
+#    elif defined(CKLED2001)
+    CKLED2001_update_led_control_registers(DRIVER_ADDR_1, 0);
+#        if defined(DRIVER_ADDR_2)
+    CKLED2001_update_led_control_registers(DRIVER_ADDR_2, 1);
+#            if defined(DRIVER_ADDR_3)
+    CKLED2001_update_led_control_registers(DRIVER_ADDR_3, 2);
+#                if defined(DRIVER_ADDR_4)
+    CKLED2001_update_led_control_registers(DRIVER_ADDR_4, 3);
+#                endif
+#            endif
+#        endif
 #    endif
 }
 
@@ -194,5 +225,66 @@ const led_matrix_driver_t led_matrix_driver = {
     .set_value = IS31FL_simple_set_brightness,
     .set_value_all = IS31FL_simple_set_brigntness_all,
 };
+
+#    elif defined(CKLED2001)
+static void flush(void) {
+    CKLED2001_update_pwm_buffers(DRIVER_ADDR_1, 0);
+#        if defined(DRIVER_ADDR_2)
+    CKLED2001_update_pwm_buffers(DRIVER_ADDR_2, 1);
+#            if defined(DRIVER_ADDR_3)
+    CKLED2001_update_pwm_buffers(DRIVER_ADDR_3, 2);
+#                if defined(DRIVER_ADDR_4)
+    CKLED2001_update_pwm_buffers(DRIVER_ADDR_4, 3);
+#                endif
+#            endif
+#        endif
+}
+
+#        if defined(LED_MATRIX_DRIVER_SHUTDOWN_ENABLE)
+static void shutdown(void) {
+#       if defined(LED_DRIVER_SHUTDOWN_PIN)
+    writePinLow(LED_DRIVER_SHUTDOWN_PIN);
+#       else
+    CKLED2001_sw_shutdown(DRIVER_ADDR_1);
+#           if defined(DRIVER_ADDR_2)
+    CKLED2001_sw_shutdown(DRIVER_ADDR_2);
+#               if defined(DRIVER_ADDR_3)
+    CKLED2001_sw_shutdown(DRIVER_ADDR_3);
+#                   if defined(DRIVER_ADDR_4)
+    CKLED2001_sw_shutdown(DRIVER_ADDR_4);
+#                   endif
+#               endif
+#           endif
+#       endif    
+}
+
+static void exit_shutdown(void) {
+#       if defined(LED_DRIVER_SHUTDOWN_PIN)
+    writePinHigh(LED_DRIVER_SHUTDOWN_PIN);
+#       else
+    CKLED2001_sw_return_normal(DRIVER_ADDR_1);
+#           if defined(DRIVER_ADDR_2)
+    CKLED2001_sw_return_normal(DRIVER_ADDR_2);
+#               if defined(DRIVER_ADDR_3)
+    CKLED2001_sw_return_normal(DRIVER_ADDR_3);
+#                   if defined(DRIVER_ADDR_4)
+    CKLED2001_sw_return_normal(DRIVER_ADDR_4);
+#                   endif
+#               endif
+#           endif
+#       endif 
+}
+#       endif
+
+const led_matrix_driver_t led_matrix_driver = {
+    .init = init,
+    .flush = flush,
+    .set_value = CKLED2001_set_value,
+    .set_value_all = CKLED2001_set_value_all,
+#        if defined(LED_MATRIX_DRIVER_SHUTDOWN_ENABLE)
+    .shutdown = shutdown,
+    .exit_shutdown = exit_shutdown
+#        endif
+};
 #    endif
 #endif

quantum/rgb_matrix/rgb_matrix.c

@@ -121,6 +121,10 @@ last_hit_t g_last_hit_tracker;
 #endif // RGB_MATRIX_KEYREACTIVE_ENABLED
 
 // internals
+#ifdef RGB_MATRIX_DRIVER_SHUTDOWN_ENABLE
+static bool            driver_shutdown   = false;
+#endif
+static uint8_t         rgb_enable_eeprom = false;
 static bool            suspend_state     = false;
 static uint8_t         rgb_last_enable   = UINT8_MAX;
 static uint8_t         rgb_last_effect   = UINT8_MAX;
@@ -128,7 +132,8 @@ static effect_params_t rgb_effect_params = {0, LED_FLAG_ALL, false};
 static rgb_task_states rgb_task_state    = SYNCING;
 #if RGB_DISABLE_TIMEOUT > 0
 static uint32_t rgb_anykey_timer;
-#endif // RGB_DISABLE_TIMEOUT > 0
+static uint32_t rgb_disable_timeout = RGB_DISABLE_TIMEOUT;
+#endif  // RGB_DISABLE_TIMEOUT > 0
 
 // double buffers
 static uint32_t rgb_timer_buffer;
@@ -279,12 +284,22 @@ void rgb_matrix_test(void) {
     }
 }
 
+void rgb_matrix_none_indicators(void) {
+    rgb_matrix_none_indicators_kb();
+    rgb_matrix_none_indicators_user();
+}
+
+__attribute__((weak)) void rgb_matrix_none_indicators_kb(void) {}
+
+__attribute__((weak)) void rgb_matrix_none_indicators_user(void) {}
+
 static bool rgb_matrix_none(effect_params_t *params) {
     if (!params->init) {
         return false;
     }
 
     rgb_matrix_set_color_all(0, 0, 0);
+    rgb_matrix_none_indicators();
     return false;
 }
 
@@ -398,9 +413,21 @@ static void rgb_task_flush(uint8_t effect) {
     // update last trackers after the first full render so we can init over several frames
     rgb_last_effect = effect;
     rgb_last_enable = rgb_matrix_config.enable;
-
+#ifdef RGB_MATRIX_DRIVER_SHUTDOWN_ENABLE
+    // exit from shutdown to if neccesary
+    if (driver_shutdown)  {
+        rgb_matrix_driver.exit_shutdown();
+        driver_shutdown = false;
+    }
+#endif                        
     // update pwm buffers
     rgb_matrix_update_pwm_buffers();
+#ifdef RGB_MATRIX_DRIVER_SHUTDOWN_ENABLE
+    // shutdown to if neccesary
+    if (effect == RGB_MATRIX_NONE && !driver_shutdown && rgb_matrix_driver_allow_shutdown()) {
+        rgb_matrix_driver_shutdown();
+    }
+#endif  
 
     // next task
     rgb_task_state = SYNCING;
@@ -413,7 +440,7 @@ void rgb_matrix_task(void) {
     // while suspended and just do a software shutdown. This is a cheap hack for now.
     bool suspend_backlight = suspend_state ||
 #if RGB_DISABLE_TIMEOUT > 0
-                             (rgb_anykey_timer > (uint32_t)RGB_DISABLE_TIMEOUT) ||
+                             (rgb_anykey_timer > rgb_disable_timeout) ||
 #endif // RGB_DISABLE_TIMEOUT > 0
                              false;
 
@@ -439,6 +466,11 @@ void rgb_matrix_task(void) {
     }
 }
 
+static inline void rgb_enable_state_backup(void) {
+    dprintf("rgb_enable_state_backup\n");
+    rgb_enable_eeprom = rgb_matrix_config.enable;
+}
+
 void rgb_matrix_indicators(void) {
     rgb_matrix_indicators_kb();
     rgb_matrix_indicators_user();
@@ -472,6 +504,9 @@ __attribute__((weak)) void rgb_matrix_indicators_advanced_user(uint8_t led_min,
 
 void rgb_matrix_init(void) {
     rgb_matrix_driver.init();
+#ifdef RGB_MATRIX_DRIVER_SHUTDOWN_ENABLE
+    driver_shutdown = false;
+#endif 
 
 #ifdef RGB_MATRIX_KEYREACTIVE_ENABLED
     g_last_hit_tracker.count = 0;
@@ -496,6 +531,7 @@ void rgb_matrix_init(void) {
         dprintf("rgb_matrix_init_drivers rgb_matrix_config.mode = 0. Write default values to EEPROM.\n");
         eeconfig_update_rgb_matrix_default();
     }
+    rgb_enable_state_backup();
     eeconfig_debug_rgb_matrix(); // display current eeprom values
 }
 
@@ -517,6 +553,7 @@ void rgb_matrix_toggle_eeprom_helper(bool write_to_eeprom) {
     rgb_matrix_config.enable ^= 1;
     rgb_task_state = STARTING;
     eeconfig_flag_rgb_matrix(write_to_eeprom);
+    if (write_to_eeprom) rgb_enable_state_backup();
     dprintf("rgb matrix toggle [%s]: rgb_matrix_config.enable = %u\n", (write_to_eeprom) ? "EEPROM" : "NOEEPROM", rgb_matrix_config.enable);
 }
 void rgb_matrix_toggle_noeeprom(void) {
@@ -529,6 +566,7 @@ void rgb_matrix_toggle(void) {
 void rgb_matrix_enable(void) {
     rgb_matrix_enable_noeeprom();
     eeconfig_flag_rgb_matrix(true);
+    rgb_enable_state_backup();
 }
 
 void rgb_matrix_enable_noeeprom(void) {
@@ -539,6 +577,7 @@ void rgb_matrix_enable_noeeprom(void) {
 void rgb_matrix_disable(void) {
     rgb_matrix_disable_noeeprom();
     eeconfig_flag_rgb_matrix(true);
+	rgb_enable_state_backup();
 }
 
 void rgb_matrix_disable_noeeprom(void) {
@@ -550,6 +589,10 @@ uint8_t rgb_matrix_is_enabled(void) {
     return rgb_matrix_config.enable;
 }
 
+uint8_t rgb_matrix_is_enabled_eeprom(void) {
+    return rgb_enable_eeprom; 
+}
+
 void rgb_matrix_mode_eeprom_helper(uint8_t mode, bool write_to_eeprom) {
     if (!rgb_matrix_config.enable) {
         return;
@@ -669,6 +712,12 @@ void rgb_matrix_decrease_sat(void) {
 }
 
 void rgb_matrix_increase_val_helper(bool write_to_eeprom) {
+#ifdef RGB_MATRIX_BRIGHTNESS_TURN_OFF_VAL
+    if (!rgb_matrix_config.enable)  {
+        dprintf("increase_val to enable");
+        rgb_matrix_toggle_eeprom_helper(write_to_eeprom);
+    }
+#endif
     rgb_matrix_sethsv_eeprom_helper(rgb_matrix_config.hsv.h, rgb_matrix_config.hsv.s, qadd8(rgb_matrix_config.hsv.v, RGB_MATRIX_VAL_STEP), write_to_eeprom);
 }
 void rgb_matrix_increase_val_noeeprom(void) {
@@ -680,6 +729,12 @@ void rgb_matrix_increase_val(void) {
 
 void rgb_matrix_decrease_val_helper(bool write_to_eeprom) {
     rgb_matrix_sethsv_eeprom_helper(rgb_matrix_config.hsv.h, rgb_matrix_config.hsv.s, qsub8(rgb_matrix_config.hsv.v, RGB_MATRIX_VAL_STEP), write_to_eeprom);
+#ifdef RGB_MATRIX_BRIGHTNESS_TURN_OFF_VAL
+    if (rgb_matrix_config.enable && rgb_matrix_config.hsv.v <= RGB_MATRIX_BRIGHTNESS_TURN_OFF_VAL) {
+        dprintf("decrease_val to disable\n");
+        rgb_matrix_toggle_eeprom_helper(write_to_eeprom);
+    }
+#endif
 }
 void rgb_matrix_decrease_val_noeeprom(void) {
     rgb_matrix_decrease_val_helper(false);
@@ -731,3 +786,22 @@ led_flags_t rgb_matrix_get_flags(void) {
 void rgb_matrix_set_flags(led_flags_t flags) {
     rgb_matrix_config.flags = flags;
 }
+
+
+#if RGB_DISABLE_TIMEOUT > 0
+void rgb_matrix_disable_timeout_set(uint32_t timeout) { 
+    rgb_disable_timeout = timeout; 
+}
+void rgb_matrix_disable_time_reset(void){ rgb_anykey_timer = 0; }
+#endif
+
+#ifdef RGB_MATRIX_DRIVER_SHUTDOWN_ENABLE
+void rgb_matrix_driver_shutdown(void) { 
+    rgb_matrix_driver.shutdown();
+    driver_shutdown = true;
+};
+
+bool rgb_matrix_is_driver_shutdown(void) { return driver_shutdown; }
+
+__attribute__((weak)) bool rgb_matrix_driver_allow_shutdown(void) { return true; };
+#endif

quantum/rgb_matrix/rgb_matrix.h

@@ -88,6 +88,8 @@
 #define RGB_MATRIX_TEST_LED_FLAGS() \
     if (!HAS_ANY_FLAGS(g_led_config.flags[i], params->flags)) continue
 
+#define RGB_DISABLE_TIME_INFINITE   (UINT32_MAX)
+
 enum rgb_matrix_effects {
     RGB_MATRIX_NONE = 0,
 
@@ -126,6 +128,9 @@ void process_rgb_matrix(uint8_t row, uint8_t col, bool pressed);
 
 void rgb_matrix_task(void);
 
+void rgb_matrix_none_indicators_kb(void);
+void rgb_matrix_none_indicators_user(void);
+
 // This runs after another backlight effect and replaces
 // colors already set
 void rgb_matrix_indicators(void);
@@ -149,6 +154,7 @@ void        rgb_matrix_enable_noeeprom(void);
 void        rgb_matrix_disable(void);
 void        rgb_matrix_disable_noeeprom(void);
 uint8_t     rgb_matrix_is_enabled(void);
+uint8_t     rgb_matrix_is_enabled_eeprom(void);
 void        rgb_matrix_mode(uint8_t mode);
 void        rgb_matrix_mode_noeeprom(uint8_t mode);
 uint8_t     rgb_matrix_get_mode(void);
@@ -183,6 +189,17 @@ void        rgb_matrix_decrease_speed(void);
 void        rgb_matrix_decrease_speed_noeeprom(void);
 led_flags_t rgb_matrix_get_flags(void);
 void        rgb_matrix_set_flags(led_flags_t flags);
+#ifdef RGB_DISABLE_TIMEOUT
+#   if RGB_DISABLE_TIMEOUT > 0
+void        rgb_matrix_disable_timeout_set(uint32_t timeout);
+void        rgb_matrix_disable_time_reset(void);
+#   endif   
+#endif
+#ifdef RGB_MATRIX_DRIVER_SHUTDOWN_ENABLE
+void        rgb_matrix_driver_shutdown(void);
+bool        rgb_matrix_is_driver_shutdown(void);
+bool        rgb_matrix_driver_allow_shutdown(void);
+#endif
 
 #ifndef RGBLIGHT_ENABLE
 #    define eeconfig_update_rgblight_current eeconfig_update_rgb_matrix
@@ -237,6 +254,12 @@ typedef struct {
     void (*set_color_all)(uint8_t r, uint8_t g, uint8_t b);
     /* Flush any buffered changes to the hardware. */
     void (*flush)(void);
+#ifdef RGB_MATRIX_DRIVER_SHUTDOWN_ENABLE
+    /* Shutdown the driver. */
+    void (*shutdown)(void);
+    /* Exit from shutdown state. */
+    void (*exit_shutdown)(void);
+#endif
 } rgb_matrix_driver_t;
 
 static inline bool rgb_matrix_check_finished_leds(uint8_t led_idx) {

quantum/rgb_matrix/rgb_matrix_drivers.c

@@ -94,6 +94,11 @@ static void init(void) {
 #        endif
 
 #    elif defined(CKLED2001)
+#        if defined(LED_DRIVER_SHUTDOWN_PIN)
+    setPinOutput(LED_DRIVER_SHUTDOWN_PIN);
+    writePinHigh(LED_DRIVER_SHUTDOWN_PIN);
+#        endif
+
     CKLED2001_init(DRIVER_ADDR_1);
 #        if defined(DRIVER_ADDR_2)
     CKLED2001_init(DRIVER_ADDR_2);
@@ -295,11 +300,51 @@ static void flush(void) {
 #        endif
 }
 
+#        if defined(RGB_MATRIX_DRIVER_SHUTDOWN_ENABLE)
+static void shutdown(void) {
+#           if defined(LED_DRIVER_SHUTDOWN_PIN)
+    writePinLow(LED_DRIVER_SHUTDOWN_PIN);
+#           else
+    CKLED2001_sw_shutdown(DRIVER_ADDR_1);
+#               if defined(DRIVER_ADDR_2)
+    CKLED2001_sw_shutdown(DRIVER_ADDR_2);
+#                   if defined(DRIVER_ADDR_3)
+    CKLED2001_sw_shutdown(DRIVER_ADDR_3);
+#                       if defined(DRIVER_ADDR_4)
+    CKLED2001_sw_shutdown(DRIVER_ADDR_4);
+#                       endif
+#                   endif
+#               endif
+#           endif    
+}
+
+static void exit_shutdown(void) {
+#           if defined(LED_DRIVER_SHUTDOWN_PIN)
+    writePinHigh(LED_DRIVER_SHUTDOWN_PIN);
+#           else
+    CKLED2001_sw_return_normal(DRIVER_ADDR_1);
+#               if defined(DRIVER_ADDR_2)
+    CKLED2001_sw_return_normal(DRIVER_ADDR_2);
+#                   if defined(DRIVER_ADDR_3)
+    CKLED2001_sw_return_normal(DRIVER_ADDR_3);
+#                       if defined(DRIVER_ADDR_4)
+    CKLED2001_sw_return_normal(DRIVER_ADDR_4);
+#                       endif
+#                   endif
+#               endif
+#           endif 
+}
+#       endif
+
 const rgb_matrix_driver_t rgb_matrix_driver = {
     .init = init,
     .flush = flush,
     .set_color = CKLED2001_set_color,
     .set_color_all = CKLED2001_set_color_all,
+#        if defined(RGB_MATRIX_DRIVER_SHUTDOWN_ENABLE)
+    .shutdown = shutdown,
+    .exit_shutdown = exit_shutdown
+#        endif
 };
 #    endif
 

quantum/via.c

@@ -396,6 +396,12 @@ void raw_hid_receive(uint8_t *data, uint8_t length) {
             dynamic_keymap_set_buffer(offset, size, &command_data[3]);
             break;
         }
+#ifdef RAW_HID_CMD
+        case RAW_HID_CMD: {
+            raw_hid_receive_kb(data, length);
+            return;
+        }
+#endif
         default: {
             // The command ID is not known
             // Return the unhandled state

tmk_core/protocol.mk

@@ -48,8 +48,6 @@ endif
 ifeq ($(strip $(NKRO_ENABLE)), yes)
     ifeq ($(PROTOCOL), VUSB)
         $(info NKRO is not currently supported on V-USB, and has been disabled.)
-    else ifeq ($(strip $(BLUETOOTH_ENABLE)), yes)
-        $(info NKRO is not currently supported with Bluetooth, and has been disabled.)
     else
         TMK_COMMON_DEFS += -DNKRO_ENABLE
         SHARED_EP_ENABLE = yes

tmk_core/protocol/chibios/chibios.c

@@ -192,7 +192,7 @@ void protocol_pre_task(void) {
             /* Remote wakeup */
             if (suspend_wakeup_condition()) {
                 usbWakeupHost(&USB_DRIVER);
-                restart_usb_driver(&USB_DRIVER);
+                usb_wakeup(&USB_DRIVER);
             }
         }
         /* Woken up */

tmk_core/protocol/chibios/usb_driver.c

@@ -408,7 +408,7 @@ void qmkusbDataTransmitted(USBDriver *usbp, usbep_t ep) {
            size. Otherwise the recipient may expect more data coming soon and
            not return buffered data to app. See section 5.8.3 Bulk Transfer
            Packet Size Constraints of the USB Specification document.*/
-        if (!qmkusbp->config->fixed_size) {
+        if (!qmkusbp->config->fixed_size && (usbp->epc[ep]->ep_mode & USB_EP_MODE_TYPE) == USB_EP_MODE_TYPE_BULK) {
             usbStartTransmitI(usbp, ep, usbp->setup, 0);
         }
 

tmk_core/protocol/chibios/usb_main.c

@@ -639,8 +639,7 @@ static bool usb_request_hook_cb(USBDriver *usbp) {
                         if ((usbp->setup[4] == KEYBOARD_INTERFACE) && (usbp->setup[5] == 0)) { /* wIndex */
                             keyboard_protocol = ((usbp->setup[2]) != 0x00);                    /* LSB(wValue) */
 #ifdef NKRO_ENABLE
-                            keymap_config.nkro = !!keyboard_protocol;
-                            if (!keymap_config.nkro && keyboard_idle) {
+                            if (!keyboard_protocol && keyboard_idle) {
 #else  /* NKRO_ENABLE */
                             if (keyboard_idle) {
 #endif /* NKRO_ENABLE */
@@ -745,20 +744,23 @@ void init_usb_driver(USBDriver *usbp) {
     chVTObjectInit(&keyboard_idle_timer);
 }
 
-__attribute__((weak)) void restart_usb_driver(USBDriver *usbp) {
-    usbStop(usbp);
-    usbDisconnectBus(usbp);
+__attribute__((weak)) void usb_wakeup(USBDriver *usbp) {
+#if STM32_USB_USE_OTG1 || STM32_USB_USE_OTG1
+    stm32_otg_t *otgp = usbp->otg;
 
-#if USB_SUSPEND_WAKEUP_DELAY > 0
-    // Some hubs, kvm switches, and monitors do
-    // weird things, with USB device state bouncing
-    // around wildly on wakeup, yielding race
-    // conditions that can corrupt the keyboard state.
-    //
-    // Pause for a while to let things settle...
-    wait_ms(USB_SUSPEND_WAKEUP_DELAY);
+    osalSysLock();
+    /* If clocks are gated off, turn them back on (may be the case if
+     coming out of suspend mode).*/
+    if (otgp->PCGCCTL & (PCGCCTL_STPPCLK | PCGCCTL_GATEHCLK)) {
+        /* Set to zero to un-gate the USB core clocks.*/
+        otgp->PCGCCTL &= ~(PCGCCTL_STPPCLK | PCGCCTL_GATEHCLK);
+    }
+    _usb_wakeup(usbp);
+    osalSysUnlock();
 #endif
+}
 
+__attribute__((weak)) void usb_start(USBDriver *usbp) {
     usbStart(usbp, &usbcfg);
     usbConnectBus(usbp);
 }

tmk_core/protocol/chibios/usb_main.h

@@ -34,8 +34,11 @@
 /* Initialize the USB driver and bus */
 void init_usb_driver(USBDriver *usbp);
 
-/* Restart the USB driver and bus */
-void restart_usb_driver(USBDriver *usbp);
+/* Wakeup the USB driver */
+void usb_wakeup(USBDriver *usbp);
+
+/* Start the USB driver */
+void usb_start(USBDriver *usbp);
 
 /* ---------------
  * USB Event queue

tmk_core/protocol/host.h

@@ -35,6 +35,7 @@ extern "C" {
 
 extern uint8_t keyboard_idle;
 extern uint8_t keyboard_protocol;
+extern uint8_t bluetooth_report_protocol;
 
 /* host driver */
 void           host_set_driver(host_driver_t *driver);

tmk_core/protocol/report.c

@@ -20,6 +20,9 @@
 #include "debug.h"
 #include "util.h"
 #include <string.h>
+#ifdef BLUETOOTH_ENABLE
+#include "transport.h"
+#endif
 
 #ifdef RING_BUFFERED_6KRO_REPORT_ENABLE
 #    define RO_ADD(a, b) ((a + b) % KEYBOARD_REPORT_KEYS)
@@ -40,7 +43,14 @@ uint8_t has_anykey(report_keyboard_t* keyboard_report) {
     uint8_t* p   = keyboard_report->keys;
     uint8_t  lp  = sizeof(keyboard_report->keys);
 #ifdef NKRO_ENABLE
+#ifdef  BLUETOOTH_ENABLE
+    if ((((get_transport() == TRANSPORT_USB) && keyboard_protocol) ||
+          ((get_transport() == TRANSPORT_BLUETOOTH) && bluetooth_report_protocol)) 
+          && keymap_config.nkro) {
+#else
     if (keyboard_protocol && keymap_config.nkro) {
+#endif
+
         p  = keyboard_report->nkro.bits;
         lp = sizeof(keyboard_report->nkro.bits);
     }
@@ -57,7 +67,13 @@ uint8_t has_anykey(report_keyboard_t* keyboard_report) {
  */
 uint8_t get_first_key(report_keyboard_t* keyboard_report) {
 #ifdef NKRO_ENABLE
+#ifdef  BLUETOOTH_ENABLE
+    if ((((get_transport() == TRANSPORT_USB) && keyboard_protocol) ||
+          ((get_transport() == TRANSPORT_BLUETOOTH) && bluetooth_report_protocol)) 
+          && keymap_config.nkro) {
+#else
     if (keyboard_protocol && keymap_config.nkro) {
+#endif
         uint8_t i = 0;
         for (; i < KEYBOARD_REPORT_BITS && !keyboard_report->nkro.bits[i]; i++)
             ;
@@ -88,7 +104,13 @@ bool is_key_pressed(report_keyboard_t* keyboard_report, uint8_t key) {
         return false;
     }
 #ifdef NKRO_ENABLE
+#ifdef  BLUETOOTH_ENABLE
+    if ((((get_transport() == TRANSPORT_USB) && keyboard_protocol) ||
+          ((get_transport() == TRANSPORT_BLUETOOTH) && bluetooth_report_protocol)) 
+          && keymap_config.nkro) {
+#else
     if (keyboard_protocol && keymap_config.nkro) {
+#endif
         if ((key >> 3) < KEYBOARD_REPORT_BITS) {
             return keyboard_report->nkro.bits[key >> 3] & 1 << (key & 7);
         } else {
@@ -242,7 +264,13 @@ void del_key_bit(report_keyboard_t* keyboard_report, uint8_t code) {
  */
 void add_key_to_report(report_keyboard_t* keyboard_report, uint8_t key) {
 #ifdef NKRO_ENABLE
+#ifdef  BLUETOOTH_ENABLE
+    if ((((get_transport() == TRANSPORT_USB) && keyboard_protocol) ||
+          ((get_transport() == TRANSPORT_BLUETOOTH) && bluetooth_report_protocol)) 
+          && keymap_config.nkro) {
+#else
     if (keyboard_protocol && keymap_config.nkro) {
+#endif
         add_key_bit(keyboard_report, key);
         return;
     }
@@ -256,7 +284,13 @@ void add_key_to_report(report_keyboard_t* keyboard_report, uint8_t key) {
  */
 void del_key_from_report(report_keyboard_t* keyboard_report, uint8_t key) {
 #ifdef NKRO_ENABLE
+#ifdef  BLUETOOTH_ENABLE
+    if ((((get_transport() == TRANSPORT_USB) && keyboard_protocol) ||
+          ((get_transport() == TRANSPORT_BLUETOOTH) && bluetooth_report_protocol)) 
+          && keymap_config.nkro) {
+#else
     if (keyboard_protocol && keymap_config.nkro) {
+#endif
         del_key_bit(keyboard_report, key);
         return;
     }
@@ -271,7 +305,13 @@ void del_key_from_report(report_keyboard_t* keyboard_report, uint8_t key) {
 void clear_keys_from_report(report_keyboard_t* keyboard_report) {
     // not clear mods
 #ifdef NKRO_ENABLE
+#ifdef  BLUETOOTH_ENABLE
+    if ((((get_transport() == TRANSPORT_USB) && keyboard_protocol) ||
+          ((get_transport() == TRANSPORT_BLUETOOTH) && bluetooth_report_protocol)) 
+          && keymap_config.nkro) {
+#else
     if (keyboard_protocol && keymap_config.nkro) {
+#endif
         memset(keyboard_report->nkro.bits, 0, sizeof(keyboard_report->nkro.bits));
         return;
     }