~ruther/qmk_firmware

7d1194de01ea94f065bd5176607b4d66279ef51b — James Young 4 years ago e628051
run: qmk cformat --core-only
M drivers/chibios/analog.c => drivers/chibios/analog.c +1 -1
@@ 123,7 123,7 @@ static ADCConversionGroup adcConversionGroup = {
    .smpr  = ADC_SAMPLING_RATE,
#elif defined(USE_ADCV2)
#    if !defined(STM32F1XX)
    .cr2   = ADC_CR2_SWSTART,  // F103 seem very unhappy with, F401 seems very unhappy without...
    .cr2 = ADC_CR2_SWSTART,  // F103 seem very unhappy with, F401 seems very unhappy without...
#    endif
    .smpr2 = ADC_SMPR2_SMP_AN0(ADC_SAMPLING_RATE) | ADC_SMPR2_SMP_AN1(ADC_SAMPLING_RATE) | ADC_SMPR2_SMP_AN2(ADC_SAMPLING_RATE) | ADC_SMPR2_SMP_AN3(ADC_SAMPLING_RATE) | ADC_SMPR2_SMP_AN4(ADC_SAMPLING_RATE) | ADC_SMPR2_SMP_AN5(ADC_SAMPLING_RATE) | ADC_SMPR2_SMP_AN6(ADC_SAMPLING_RATE) | ADC_SMPR2_SMP_AN7(ADC_SAMPLING_RATE) | ADC_SMPR2_SMP_AN8(ADC_SAMPLING_RATE) | ADC_SMPR2_SMP_AN9(ADC_SAMPLING_RATE),
    .smpr1 = ADC_SMPR1_SMP_AN10(ADC_SAMPLING_RATE) | ADC_SMPR1_SMP_AN11(ADC_SAMPLING_RATE) | ADC_SMPR1_SMP_AN12(ADC_SAMPLING_RATE) | ADC_SMPR1_SMP_AN13(ADC_SAMPLING_RATE) | ADC_SMPR1_SMP_AN14(ADC_SAMPLING_RATE) | ADC_SMPR1_SMP_AN15(ADC_SAMPLING_RATE),

M drivers/chibios/serial_usart.h => drivers/chibios/serial_usart.h +16 -4
@@ 40,13 40,25 @@
#endif

#if defined(USART1_REMAP)
#    define USART_REMAP do { (AFIO->MAPR |= AFIO_MAPR_USART1_REMAP); } while(0)
#    define USART_REMAP                             \
        do {                                        \
            (AFIO->MAPR |= AFIO_MAPR_USART1_REMAP); \
        } while (0)
#elif defined(USART2_REMAP)
#    define USART_REMAP do { (AFIO->MAPR |= AFIO_MAPR_USART2_REMAP); } while(0)
#    define USART_REMAP                             \
        do {                                        \
            (AFIO->MAPR |= AFIO_MAPR_USART2_REMAP); \
        } while (0)
#elif defined(USART3_PARTIALREMAP)
#    define USART_REMAP do { (AFIO->MAPR |= AFIO_MAPR_USART3_REMAP_PARTIALREMAP); } while(0)
#    define USART_REMAP                                          \
        do {                                                     \
            (AFIO->MAPR |= AFIO_MAPR_USART3_REMAP_PARTIALREMAP); \
        } while (0)
#elif defined(USART3_FULLREMAP)
#    define USART_REMAP do { (AFIO->MAPR |= AFIO_MAPR_USART3_REMAP_FULLREMAP); } while(0)
#    define USART_REMAP                                       \
        do {                                                  \
            (AFIO->MAPR |= AFIO_MAPR_USART3_REMAP_FULLREMAP); \
        } while (0)
#endif

#ifndef SELECT_SOFT_SERIAL_SPEED

M quantum/led_matrix_animations/alpha_mods_anim.h => quantum/led_matrix_animations/alpha_mods_anim.h +1 -1
@@ 21,4 21,4 @@ bool ALPHAS_MODS(effect_params_t* params) {
}

#    endif  // LED_MATRIX_CUSTOM_EFFECT_IMPLS
#endif      // DISABLE_LED_MATRIX_ALPHAS_MODS
#endif  // DISABLE_LED_MATRIX_ALPHAS_MODS

M quantum/led_matrix_animations/band_anim.h => quantum/led_matrix_animations/band_anim.h +2 -4
@@ 7,9 7,7 @@ static uint8_t BAND_math(uint8_t val, uint8_t i, uint8_t time) {
    return scale8(v < 0 ? 0 : v, val);
}

bool BAND(effect_params_t* params) {
    return effect_runner_i(params, &BAND_math);
}
bool BAND(effect_params_t* params) { return effect_runner_i(params, &BAND_math); }

#    endif  // LED_MATRIX_CUSTOM_EFFECT_IMPLS
#endif      // DISABLE_LED_MATRIX_BAND
#endif  // DISABLE_LED_MATRIX_BAND

M quantum/led_matrix_animations/band_pinwheel_anim.h => quantum/led_matrix_animations/band_pinwheel_anim.h +3 -7
@@ 2,13 2,9 @@
LED_MATRIX_EFFECT(BAND_PINWHEEL)
#    ifdef LED_MATRIX_CUSTOM_EFFECT_IMPLS

static uint8_t BAND_PINWHEEL_math(uint8_t val, int16_t dx, int16_t dy, uint8_t time) {
    return scale8(val - time - atan2_8(dy, dx) * 3, val);
}
static uint8_t BAND_PINWHEEL_math(uint8_t val, int16_t dx, int16_t dy, uint8_t time) { return scale8(val - time - atan2_8(dy, dx) * 3, val); }

bool BAND_PINWHEEL(effect_params_t* params) {
    return effect_runner_dx_dy(params, &BAND_PINWHEEL_math);
}
bool BAND_PINWHEEL(effect_params_t* params) { return effect_runner_dx_dy(params, &BAND_PINWHEEL_math); }

#    endif  // LED_MATRIX_CUSTOM_EFFECT_IMPLS
#endif      // DISABLE_LED_MATRIX_BAND_PINWHEEL
#endif  // DISABLE_LED_MATRIX_BAND_PINWHEEL

M quantum/led_matrix_animations/band_spiral_anim.h => quantum/led_matrix_animations/band_spiral_anim.h +3 -7
@@ 2,13 2,9 @@
LED_MATRIX_EFFECT(BAND_SPIRAL)
#    ifdef LED_MATRIX_CUSTOM_EFFECT_IMPLS

static uint8_t BAND_SPIRAL_math(uint8_t val, int16_t dx, int16_t dy, uint8_t dist, uint8_t time) {
    return scale8(val + dist - time - atan2_8(dy, dx), val);
}
static uint8_t BAND_SPIRAL_math(uint8_t val, int16_t dx, int16_t dy, uint8_t dist, uint8_t time) { return scale8(val + dist - time - atan2_8(dy, dx), val); }

bool BAND_SPIRAL(effect_params_t* params) {
    return effect_runner_dx_dy_dist(params, &BAND_SPIRAL_math);
}
bool BAND_SPIRAL(effect_params_t* params) { return effect_runner_dx_dy_dist(params, &BAND_SPIRAL_math); }

#    endif  // LED_MATRIX_CUSTOM_EFFECT_IMPLS
#endif      // DISABLE_LED_MATRIX_BAND_SPIRAL
#endif  // DISABLE_LED_MATRIX_BAND_SPIRAL

M quantum/led_matrix_animations/breathing_anim.h => quantum/led_matrix_animations/breathing_anim.h +1 -1
@@ 16,4 16,4 @@ bool BREATHING(effect_params_t* params) {
}

#    endif  // LED_MATRIX_CUSTOM_EFFECT_IMPLS
#endif      // DISABLE_LED_MATRIX_BREATHING
#endif  // DISABLE_LED_MATRIX_BREATHING

M quantum/led_matrix_animations/cycle_left_right_anim.h => quantum/led_matrix_animations/cycle_left_right_anim.h +3 -7
@@ 2,13 2,9 @@
LED_MATRIX_EFFECT(CYCLE_LEFT_RIGHT)
#    ifdef LED_MATRIX_CUSTOM_EFFECT_IMPLS

static uint8_t CYCLE_LEFT_RIGHT_math(uint8_t val, uint8_t i, uint8_t time) {
    return scale8(g_led_config.point[i].x - time, val);
}
static uint8_t CYCLE_LEFT_RIGHT_math(uint8_t val, uint8_t i, uint8_t time) { return scale8(g_led_config.point[i].x - time, val); }

bool CYCLE_LEFT_RIGHT(effect_params_t* params) {
    return effect_runner_i(params, &CYCLE_LEFT_RIGHT_math);
}
bool CYCLE_LEFT_RIGHT(effect_params_t* params) { return effect_runner_i(params, &CYCLE_LEFT_RIGHT_math); }

#    endif  // LED_MATRIX_CUSTOM_EFFECT_IMPLS
#endif      // DISABLE_LED_MATRIX_CYCLE_LEFT_RIGHT
#endif  // DISABLE_LED_MATRIX_CYCLE_LEFT_RIGHT

M quantum/led_matrix_animations/cycle_out_in_anim.h => quantum/led_matrix_animations/cycle_out_in_anim.h +3 -7
@@ 2,13 2,9 @@
LED_MATRIX_EFFECT(CYCLE_OUT_IN)
#    ifdef LED_MATRIX_CUSTOM_EFFECT_IMPLS

static uint8_t CYCLE_OUT_IN_math(uint8_t val, int16_t dx, int16_t dy, uint8_t dist, uint8_t time) {
    return scale8(3 * dist / 2 + time, val);
}
static uint8_t CYCLE_OUT_IN_math(uint8_t val, int16_t dx, int16_t dy, uint8_t dist, uint8_t time) { return scale8(3 * dist / 2 + time, val); }

bool CYCLE_OUT_IN(effect_params_t* params) {
    return effect_runner_dx_dy_dist(params, &CYCLE_OUT_IN_math);
}
bool CYCLE_OUT_IN(effect_params_t* params) { return effect_runner_dx_dy_dist(params, &CYCLE_OUT_IN_math); }

#    endif  // LED_MATRIX_CUSTOM_EFFECT_IMPLS
#endif      // DISABLE_LED_MATRIX_CYCLE_OUT_IN
#endif  // DISABLE_LED_MATRIX_CYCLE_OUT_IN

M quantum/led_matrix_animations/cycle_up_down_anim.h => quantum/led_matrix_animations/cycle_up_down_anim.h +3 -7
@@ 2,13 2,9 @@
LED_MATRIX_EFFECT(CYCLE_UP_DOWN)
#    ifdef LED_MATRIX_CUSTOM_EFFECT_IMPLS

static uint8_t CYCLE_UP_DOWN_math(uint8_t val, uint8_t i, uint8_t time) {
    return scale8(g_led_config.point[i].y - time, val);
}
static uint8_t CYCLE_UP_DOWN_math(uint8_t val, uint8_t i, uint8_t time) { return scale8(g_led_config.point[i].y - time, val); }

bool CYCLE_UP_DOWN(effect_params_t* params) {
    return effect_runner_i(params, &CYCLE_UP_DOWN_math);
}
bool CYCLE_UP_DOWN(effect_params_t* params) { return effect_runner_i(params, &CYCLE_UP_DOWN_math); }

#    endif  // LED_MATRIX_CUSTOM_EFFECT_IMPLS
#endif      // DISABLE_LED_MATRIX_CYCLE_UP_DOWN
#endif  // DISABLE_LED_MATRIX_CYCLE_UP_DOWN

M quantum/led_matrix_animations/dual_beacon_anim.h => quantum/led_matrix_animations/dual_beacon_anim.h +3 -7
@@ 2,13 2,9 @@
LED_MATRIX_EFFECT(DUAL_BEACON)
#    ifdef LED_MATRIX_CUSTOM_EFFECT_IMPLS

static uint8_t DUAL_BEACON_math(uint8_t val, int8_t sin, int8_t cos, uint8_t i, uint8_t time) {
    return scale8(((g_led_config.point[i].y - k_led_matrix_center.y) * cos + (g_led_config.point[i].x - k_led_matrix_center.x) * sin) / 128, val);
}
static uint8_t DUAL_BEACON_math(uint8_t val, int8_t sin, int8_t cos, uint8_t i, uint8_t time) { return scale8(((g_led_config.point[i].y - k_led_matrix_center.y) * cos + (g_led_config.point[i].x - k_led_matrix_center.x) * sin) / 128, val); }

bool DUAL_BEACON(effect_params_t* params) {
    return effect_runner_sin_cos_i(params, &DUAL_BEACON_math);
}
bool DUAL_BEACON(effect_params_t* params) { return effect_runner_sin_cos_i(params, &DUAL_BEACON_math); }

#    endif  // LED_MATRIX_CUSTOM_EFFECT_IMPLS
#endif      // DISABLE_LED_MATRIX_DUAL_BEACON
#endif  // DISABLE_LED_MATRIX_DUAL_BEACON

M quantum/led_matrix_animations/solid_reactive_cross.h => quantum/led_matrix_animations/solid_reactive_cross.h +4 -8
@@ 23,17 23,13 @@ static uint8_t SOLID_REACTIVE_CROSS_math(uint8_t val, int16_t dx, int16_t dy, ui
}

#            ifndef DISABLE_LED_MATRIX_SOLID_REACTIVE_CROSS
bool SOLID_REACTIVE_CROSS(effect_params_t* params) {
    return effect_runner_reactive_splash(qsub8(g_last_hit_tracker.count, 1), params, &SOLID_REACTIVE_CROSS_math);
}
bool SOLID_REACTIVE_CROSS(effect_params_t* params) { return effect_runner_reactive_splash(qsub8(g_last_hit_tracker.count, 1), params, &SOLID_REACTIVE_CROSS_math); }
#            endif

#            ifndef DISABLE_LED_MATRIX_SOLID_REACTIVE_MULTICROSS
bool SOLID_REACTIVE_MULTICROSS(effect_params_t* params) {
    return effect_runner_reactive_splash(0, params, &SOLID_REACTIVE_CROSS_math);
}
bool SOLID_REACTIVE_MULTICROSS(effect_params_t* params) { return effect_runner_reactive_splash(0, params, &SOLID_REACTIVE_CROSS_math); }
#            endif

#        endif  // LED_MATRIX_CUSTOM_EFFECT_IMPLS
#    endif      // !defined(DISABLE_LED_MATRIX_SOLID_REACTIVE_CROSS) || !defined(DISABLE_LED_MATRIX_SOLID_REACTIVE_MULTICROSS)
#endif          // LED_MATRIX_KEYREACTIVE_ENABLED
#    endif  // !defined(DISABLE_LED_MATRIX_SOLID_REACTIVE_CROSS) || !defined(DISABLE_LED_MATRIX_SOLID_REACTIVE_MULTICROSS)
#endif  // LED_MATRIX_KEYREACTIVE_ENABLED

M quantum/led_matrix_animations/solid_reactive_nexus.h => quantum/led_matrix_animations/solid_reactive_nexus.h +4 -8
@@ 20,17 20,13 @@ static uint8_t SOLID_REACTIVE_NEXUS_math(uint8_t val, int16_t dx, int16_t dy, ui
}

#            ifndef DISABLE_LED_MATRIX_SOLID_REACTIVE_NEXUS
bool SOLID_REACTIVE_NEXUS(effect_params_t* params) {
    return effect_runner_reactive_splash(qsub8(g_last_hit_tracker.count, 1), params, &SOLID_REACTIVE_NEXUS_math);
}
bool SOLID_REACTIVE_NEXUS(effect_params_t* params) { return effect_runner_reactive_splash(qsub8(g_last_hit_tracker.count, 1), params, &SOLID_REACTIVE_NEXUS_math); }
#            endif

#            ifndef DISABLE_LED_MATRIX_SOLID_REACTIVE_MULTINEXUS
bool SOLID_REACTIVE_MULTINEXUS(effect_params_t* params) {
    return effect_runner_reactive_splash(0, params, &SOLID_REACTIVE_NEXUS_math);
}
bool SOLID_REACTIVE_MULTINEXUS(effect_params_t* params) { return effect_runner_reactive_splash(0, params, &SOLID_REACTIVE_NEXUS_math); }
#            endif

#        endif  // LED_MATRIX_CUSTOM_EFFECT_IMPLS
#    endif      // !defined(DISABLE_LED_MATRIX_SOLID_REACTIVE_NEXUS) || !defined(DISABLE_LED_MATRIX_SOLID_REACTIVE_MULTINEXUS)
#endif          // LED_MATRIX_KEYREACTIVE_ENABLED
#    endif  // !defined(DISABLE_LED_MATRIX_SOLID_REACTIVE_NEXUS) || !defined(DISABLE_LED_MATRIX_SOLID_REACTIVE_MULTINEXUS)
#endif  // LED_MATRIX_KEYREACTIVE_ENABLED

M quantum/led_matrix_animations/solid_reactive_simple_anim.h => quantum/led_matrix_animations/solid_reactive_simple_anim.h +4 -8
@@ 3,14 3,10 @@
LED_MATRIX_EFFECT(SOLID_REACTIVE_SIMPLE)
#        ifdef LED_MATRIX_CUSTOM_EFFECT_IMPLS

static uint8_t SOLID_REACTIVE_SIMPLE_math(uint8_t val, uint16_t offset) {
    return scale8(255 - offset, val);
}
static uint8_t SOLID_REACTIVE_SIMPLE_math(uint8_t val, uint16_t offset) { return scale8(255 - offset, val); }

bool SOLID_REACTIVE_SIMPLE(effect_params_t* params) {
    return effect_runner_reactive(params, &SOLID_REACTIVE_SIMPLE_math);
}
bool SOLID_REACTIVE_SIMPLE(effect_params_t* params) { return effect_runner_reactive(params, &SOLID_REACTIVE_SIMPLE_math); }

#        endif  // LED_MATRIX_CUSTOM_EFFECT_IMPLS
#    endif      // DISABLE_LED_MATRIX_SOLID_REACTIVE_SIMPLE
#endif          // LED_MATRIX_KEYREACTIVE_ENABLED
#    endif  // DISABLE_LED_MATRIX_SOLID_REACTIVE_SIMPLE
#endif  // LED_MATRIX_KEYREACTIVE_ENABLED

M quantum/led_matrix_animations/solid_reactive_wide.h => quantum/led_matrix_animations/solid_reactive_wide.h +4 -8
@@ 18,17 18,13 @@ static uint8_t SOLID_REACTIVE_WIDE_math(uint8_t val, int16_t dx, int16_t dy, uin
}

#            ifndef DISABLE_LED_MATRIX_SOLID_REACTIVE_WIDE
bool SOLID_REACTIVE_WIDE(effect_params_t* params) {
    return effect_runner_reactive_splash(qsub8(g_last_hit_tracker.count, 1), params, &SOLID_REACTIVE_WIDE_math);
}
bool SOLID_REACTIVE_WIDE(effect_params_t* params) { return effect_runner_reactive_splash(qsub8(g_last_hit_tracker.count, 1), params, &SOLID_REACTIVE_WIDE_math); }
#            endif

#            ifndef DISABLE_LED_MATRIX_SOLID_REACTIVE_MULTIWIDE
bool SOLID_REACTIVE_MULTIWIDE(effect_params_t* params) {
    return effect_runner_reactive_splash(0, params, &SOLID_REACTIVE_WIDE_math);
}
bool SOLID_REACTIVE_MULTIWIDE(effect_params_t* params) { return effect_runner_reactive_splash(0, params, &SOLID_REACTIVE_WIDE_math); }
#            endif

#        endif  // LED_MATRIX_CUSTOM_EFFECT_IMPLS
#    endif      // !defined(DISABLE_LED_MATRIX_SOLID_REACTIVE_WIDE) || !defined(DISABLE_LED_MATRIX_SOLID_REACTIVE_MULTIWIDE)
#endif          // LED_MATRIX_KEYREACTIVE_ENABLED
#    endif  // !defined(DISABLE_LED_MATRIX_SOLID_REACTIVE_WIDE) || !defined(DISABLE_LED_MATRIX_SOLID_REACTIVE_MULTIWIDE)
#endif  // LED_MATRIX_KEYREACTIVE_ENABLED

M quantum/led_matrix_animations/solid_splash_anim.h => quantum/led_matrix_animations/solid_splash_anim.h +4 -8
@@ 18,17 18,13 @@ uint8_t SOLID_SPLASH_math(uint8_t val, int16_t dx, int16_t dy, uint8_t dist, uin
}

#            ifndef DISABLE_LED_MATRIX_SOLID_SPLASH
bool SOLID_SPLASH(effect_params_t* params) {
    return effect_runner_reactive_splash(qsub8(g_last_hit_tracker.count, 1), params, &SOLID_SPLASH_math);
}
bool SOLID_SPLASH(effect_params_t* params) { return effect_runner_reactive_splash(qsub8(g_last_hit_tracker.count, 1), params, &SOLID_SPLASH_math); }
#            endif

#            ifndef DISABLE_LED_MATRIX_SOLID_MULTISPLASH
bool SOLID_MULTISPLASH(effect_params_t* params) {
    return effect_runner_reactive_splash(0, params, &SOLID_SPLASH_math);
}
bool SOLID_MULTISPLASH(effect_params_t* params) { return effect_runner_reactive_splash(0, params, &SOLID_SPLASH_math); }
#            endif

#        endif  // LED_MATRIX_CUSTOM_EFFECT_IMPLS
#    endif      // !defined(DISABLE_LED_MATRIX_SPLASH) && !defined(DISABLE_LED_MATRIX_MULTISPLASH)
#endif          // LED_MATRIX_KEYREACTIVE_ENABLED
#    endif  // !defined(DISABLE_LED_MATRIX_SPLASH) && !defined(DISABLE_LED_MATRIX_MULTISPLASH)
#endif  // LED_MATRIX_KEYREACTIVE_ENABLED

M quantum/led_matrix_animations/wave_left_right_anim.h => quantum/led_matrix_animations/wave_left_right_anim.h +3 -7
@@ 2,13 2,9 @@
LED_MATRIX_EFFECT(WAVE_LEFT_RIGHT)
#    ifdef LED_MATRIX_CUSTOM_EFFECT_IMPLS

static uint8_t WAVE_LEFT_RIGHT_math(uint8_t val, uint8_t i, uint8_t time) {
    return scale8(sin8(g_led_config.point[i].x - time), val);
}
static uint8_t WAVE_LEFT_RIGHT_math(uint8_t val, uint8_t i, uint8_t time) { return scale8(sin8(g_led_config.point[i].x - time), val); }

bool WAVE_LEFT_RIGHT(effect_params_t* params) {
    return effect_runner_i(params, &WAVE_LEFT_RIGHT_math);
}
bool WAVE_LEFT_RIGHT(effect_params_t* params) { return effect_runner_i(params, &WAVE_LEFT_RIGHT_math); }

#    endif  // LED_MATRIX_CUSTOM_EFFECT_IMPLS
#endif      // DISABLE_LED_MATRIX_WAVE_LEFT_RIGHT
#endif  // DISABLE_LED_MATRIX_WAVE_LEFT_RIGHT

M quantum/led_matrix_animations/wave_up_down_anim.h => quantum/led_matrix_animations/wave_up_down_anim.h +3 -7
@@ 2,13 2,9 @@
LED_MATRIX_EFFECT(WAVE_UP_DOWN)
#    ifdef LED_MATRIX_CUSTOM_EFFECT_IMPLS

static uint8_t WAVE_UP_DOWN_math(uint8_t val, uint8_t i, uint8_t time) {
    return scale8(sin8(g_led_config.point[i].y - time), val);
}
static uint8_t WAVE_UP_DOWN_math(uint8_t val, uint8_t i, uint8_t time) { return scale8(sin8(g_led_config.point[i].y - time), val); }

bool WAVE_UP_DOWN(effect_params_t* params) {
    return effect_runner_i(params, &WAVE_UP_DOWN_math);
}
bool WAVE_UP_DOWN(effect_params_t* params) { return effect_runner_i(params, &WAVE_UP_DOWN_math); }

#    endif  // LED_MATRIX_CUSTOM_EFFECT_IMPLS
#endif      // DISABLE_LED_MATRIX_WAVE_UP_DOWN
#endif  // DISABLE_LED_MATRIX_WAVE_UP_DOWN

M quantum/led_matrix_drivers.c => quantum/led_matrix_drivers.c +1 -1
@@ 145,7 145,7 @@ const led_matrix_driver_t led_matrix_driver = {
    .set_value     = IS31FL3731_set_value,
    .set_value_all = IS31FL3731_set_value_all,
#    else
    .set_value     = IS31FL3733_set_value,
    .set_value = IS31FL3733_set_value,
    .set_value_all = IS31FL3733_set_value_all,
#    endif
};

M quantum/quantum_keycodes.h => quantum/quantum_keycodes.h +6 -6
@@ 760,12 760,12 @@ enum quantum_keycodes {
#define CMD_T(kc) LCMD_T(kc)
#define WIN_T(kc) LWIN_T(kc)

#define C_S_T(kc) MT(MOD_LCTL | MOD_LSFT, kc)                         // Left Control + Shift e.g. for gnome-terminal
#define MEH_T(kc) MT(MOD_LCTL | MOD_LSFT | MOD_LALT, kc)              // Meh is a less hyper version of the Hyper key -- doesn't include GUI, so just Left Control + Shift + Alt
#define LCAG_T(kc) MT(MOD_LCTL | MOD_LALT | MOD_LGUI, kc)             // Left Control + Alt + GUI
#define RCAG_T(kc) MT(MOD_RCTL | MOD_RALT | MOD_RGUI, kc)             // Right Control + Alt + GUI
#define C_S_T(kc) MT(MOD_LCTL | MOD_LSFT, kc)  // Left Control + Shift e.g. for gnome-terminal
#define MEH_T(kc) MT(MOD_LCTL | MOD_LSFT | MOD_LALT, kc)  // Meh is a less hyper version of the Hyper key -- doesn't include GUI, so just Left Control + Shift + Alt
#define LCAG_T(kc) MT(MOD_LCTL | MOD_LALT | MOD_LGUI, kc)  // Left Control + Alt + GUI
#define RCAG_T(kc) MT(MOD_RCTL | MOD_RALT | MOD_RGUI, kc)  // Right Control + Alt + GUI
#define HYPR_T(kc) MT(MOD_LCTL | MOD_LSFT | MOD_LALT | MOD_LGUI, kc)  // see http://brettterpstra.com/2012/12/08/a-useful-caps-lock-key/
#define SGUI_T(kc) MT(MOD_LGUI | MOD_LSFT, kc)                        // Left Shift + GUI
#define SGUI_T(kc) MT(MOD_LGUI | MOD_LSFT, kc)  // Left Shift + GUI
#define SCMD_T(kc) SGUI_T(kc)
#define SWIN_T(kc) SGUI_T(kc)
#define LCA_T(kc) MT(MOD_LCTL | MOD_LALT, kc)  // Left Control + Alt


@@ 792,7 792,7 @@ enum quantum_keycodes {

#define UC_M_MA UNICODE_MODE_MAC
#define UNICODE_MODE_OSX UNICODE_MODE_MAC  // Deprecated alias
#define UC_M_OS UNICODE_MODE_MAC           // Deprecated alias
#define UC_M_OS UNICODE_MODE_MAC  // Deprecated alias
#define UC_M_LN UNICODE_MODE_LNX
#define UC_M_WI UNICODE_MODE_WIN
#define UC_M_BS UNICODE_MODE_BSD

M quantum/rgb_matrix_drivers.c => quantum/rgb_matrix_drivers.c +3 -3
@@ 146,9 146,9 @@ static void flush(void) {
}

const rgb_matrix_driver_t rgb_matrix_driver = {
    .init          = init,
    .flush         = flush,
    .set_color     = IS31FL3733_set_color,
    .init = init,
    .flush = flush,
    .set_color = IS31FL3733_set_color,
    .set_color_all = IS31FL3733_set_color_all,
};
#    elif defined(IS31FL3737)

M quantum/rgblight.c => quantum/rgblight.c +3 -5
@@ 727,13 727,11 @@ static uint16_t       _repeat_timer;
static uint8_t        _times_remaining;
static uint16_t       _dur;

void rgblight_blink_layer(uint8_t layer, uint16_t duration_ms) {
    rgblight_blink_layer_repeat(layer, duration_ms, 1);
}
void rgblight_blink_layer(uint8_t layer, uint16_t duration_ms) { rgblight_blink_layer_repeat(layer, duration_ms, 1); }

void rgblight_blink_layer_repeat(uint8_t layer, uint16_t duration_ms, uint8_t times) {
    _times_remaining = times * 2;
    _dur = duration_ms;
    _dur             = duration_ms;

    rgblight_set_layer_state(layer, true);
    _times_remaining--;


@@ 892,7 890,7 @@ void rgblight_update_sync(rgblight_syncinfo_t *syncinfo, bool write_to_eeprom) {
        animation_status.restart = true;
    }
#        endif /* RGBLIGHT_SPLIT_NO_ANIMATION_SYNC */
#    endif     /* RGBLIGHT_USE_TIMER */
#    endif /* RGBLIGHT_USE_TIMER */
}
#endif /* RGBLIGHT_SPLIT */


M quantum/split_common/transport.c => quantum/split_common/transport.c +17 -17
@@ 240,38 240,38 @@ typedef struct _Serial_s2m_buffer_t {
    matrix_row_t smatrix[ROWS_PER_HAND];

#    ifdef ENCODER_ENABLE
    uint8_t      encoder_state[NUMBER_OF_ENCODERS];
    uint8_t encoder_state[NUMBER_OF_ENCODERS];
#    endif

} Serial_s2m_buffer_t;

typedef struct _Serial_m2s_buffer_t {
#    ifdef SPLIT_MODS_ENABLE
    uint8_t        real_mods;
    uint8_t        weak_mods;
    uint8_t real_mods;
    uint8_t weak_mods;
#        ifndef NO_ACTION_ONESHOT
    uint8_t        oneshot_mods;
    uint8_t oneshot_mods;
#        endif
#    endif
#    ifndef DISABLE_SYNC_TIMER
    uint32_t       sync_timer;
    uint32_t sync_timer;
#    endif
#    ifdef SPLIT_TRANSPORT_MIRROR
    matrix_row_t   mmatrix[ROWS_PER_HAND];
    matrix_row_t mmatrix[ROWS_PER_HAND];
#    endif
#    ifdef BACKLIGHT_ENABLE
    uint8_t        backlight_level;
    uint8_t backlight_level;
#    endif
#    ifdef WPM_ENABLE
    uint8_t        current_wpm;
    uint8_t current_wpm;
#    endif
#    if defined(LED_MATRIX_ENABLE) && defined(LED_MATRIX_SPLIT)
    led_eeconfig_t led_matrix;
    bool           led_suspend_state;
#    endif
#    if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_SPLIT)
    rgb_config_t   rgb_matrix;
    bool           rgb_suspend_state;
    rgb_config_t rgb_matrix;
    bool         rgb_suspend_state;
#    endif
} Serial_m2s_buffer_t;



@@ 363,7 363,7 @@ bool transport_master(matrix_row_t master_matrix[], matrix_row_t slave_matrix[])

    // TODO:  if MATRIX_COLS > 8 change to unpack()
    for (int i = 0; i < ROWS_PER_HAND; ++i) {
        slave_matrix[i]              = serial_s2m_buffer.smatrix[i];
        slave_matrix[i] = serial_s2m_buffer.smatrix[i];
#    ifdef SPLIT_TRANSPORT_MIRROR
        serial_m2s_buffer.mmatrix[i] = master_matrix[i];
#    endif


@@ 380,14 380,14 @@ bool transport_master(matrix_row_t master_matrix[], matrix_row_t slave_matrix[])

#    ifdef WPM_ENABLE
    // Write wpm to slave
    serial_m2s_buffer.current_wpm       = get_current_wpm();
    serial_m2s_buffer.current_wpm = get_current_wpm();
#    endif

#    ifdef SPLIT_MODS_ENABLE
    serial_m2s_buffer.real_mods         = get_mods();
    serial_m2s_buffer.weak_mods         = get_weak_mods();
    serial_m2s_buffer.real_mods = get_mods();
    serial_m2s_buffer.weak_mods = get_weak_mods();
#        ifndef NO_ACTION_ONESHOT
    serial_m2s_buffer.oneshot_mods      = get_oneshot_mods();
    serial_m2s_buffer.oneshot_mods = get_oneshot_mods();
#        endif
#    endif



@@ 401,7 401,7 @@ bool transport_master(matrix_row_t master_matrix[], matrix_row_t slave_matrix[])
#    endif

#    ifndef DISABLE_SYNC_TIMER
    serial_m2s_buffer.sync_timer        = sync_timer_read32() + SYNC_TIMER_OFFSET;
    serial_m2s_buffer.sync_timer = sync_timer_read32() + SYNC_TIMER_OFFSET;
#    endif
    return true;
}


@@ 416,7 416,7 @@ void transport_slave(matrix_row_t master_matrix[], matrix_row_t slave_matrix[]) 
    for (int i = 0; i < ROWS_PER_HAND; ++i) {
        serial_s2m_buffer.smatrix[i] = slave_matrix[i];
#    ifdef SPLIT_TRANSPORT_MIRROR
        master_matrix[i]             = serial_m2s_buffer.mmatrix[i];
        master_matrix[i] = serial_m2s_buffer.mmatrix[i];
#    endif
    }
#    ifdef BACKLIGHT_ENABLE

M tmk_core/common/action.c => tmk_core/common/action.c +38 -45
@@ 773,10 773,9 @@ void register_code(uint8_t code) {
    }
#endif

    else if
        IS_KEY(code) {
            // TODO: should push command_proc out of this block?
            if (command_proc(code)) return;
    else if IS_KEY (code) {
        // TODO: should push command_proc out of this block?
        if (command_proc(code)) return;

#ifndef NO_ACTION_ONESHOT
/* TODO: remove


@@ 793,35 792,33 @@ void register_code(uint8_t code) {
        } else
*/
#endif
            {
                // Force a new key press if the key is already pressed
                // without this, keys with the same keycode, but different
                // modifiers will be reported incorrectly, see issue #1708
                if (is_key_pressed(keyboard_report, code)) {
                    del_key(code);
                    send_keyboard_report();
                }
                add_key(code);
        {
            // Force a new key press if the key is already pressed
            // without this, keys with the same keycode, but different
            // modifiers will be reported incorrectly, see issue #1708
            if (is_key_pressed(keyboard_report, code)) {
                del_key(code);
                send_keyboard_report();
            }
        }
    else if
        IS_MOD(code) {
            add_mods(MOD_BIT(code));
            add_key(code);
            send_keyboard_report();
        }
    } else if IS_MOD (code) {
        add_mods(MOD_BIT(code));
        send_keyboard_report();
    }
#ifdef EXTRAKEY_ENABLE
    else if
        IS_SYSTEM(code) { host_system_send(KEYCODE2SYSTEM(code)); }
    else if
        IS_CONSUMER(code) { host_consumer_send(KEYCODE2CONSUMER(code)); }
    else if IS_SYSTEM (code) {
        host_system_send(KEYCODE2SYSTEM(code));
    } else if IS_CONSUMER (code) {
        host_consumer_send(KEYCODE2CONSUMER(code));
    }
#endif
#ifdef MOUSEKEY_ENABLE
    else if
        IS_MOUSEKEY(code) {
            mousekey_on(code);
            mousekey_send();
        }
    else if IS_MOUSEKEY (code) {
        mousekey_on(code);
        mousekey_send();
    }
#endif
}



@@ 866,26 863,22 @@ void unregister_code(uint8_t code) {
    }
#endif

    else if
        IS_KEY(code) {
            del_key(code);
            send_keyboard_report();
        }
    else if
        IS_MOD(code) {
            del_mods(MOD_BIT(code));
            send_keyboard_report();
        }
    else if
        IS_SYSTEM(code) { host_system_send(0); }
    else if
        IS_CONSUMER(code) { host_consumer_send(0); }
    else if IS_KEY (code) {
        del_key(code);
        send_keyboard_report();
    } else if IS_MOD (code) {
        del_mods(MOD_BIT(code));
        send_keyboard_report();
    } else if IS_SYSTEM (code) {
        host_system_send(0);
    } else if IS_CONSUMER (code) {
        host_consumer_send(0);
    }
#ifdef MOUSEKEY_ENABLE
    else if
        IS_MOUSEKEY(code) {
            mousekey_off(code);
            mousekey_send();
        }
    else if IS_MOUSEKEY (code) {
        mousekey_off(code);
        mousekey_send();
    }
#endif
}


M tmk_core/common/action.h => tmk_core/common/action.h +1 -1
@@ 77,7 77,7 @@ extern bool disable_action_cache;

/* Code for handling one-handed key modifiers. */
#ifdef SWAP_HANDS_ENABLE
extern bool           swap_hands;
extern bool                   swap_hands;
extern const keypos_t PROGMEM hand_swap_config[MATRIX_ROWS][MATRIX_COLS];
#    if (MATRIX_COLS <= 8)
typedef uint8_t swap_state_row_t;

M tmk_core/common/chibios/sleep_led.c => tmk_core/common/chibios/sleep_led.c +2 -2
@@ 65,7 65,7 @@ void sleep_led_timer_callback(void) {

/* LPTMR clock options */
#    define LPTMR_CLOCK_MCGIRCLK 0 /* 4MHz clock */
#    define LPTMR_CLOCK_LPO 1      /* 1kHz clock */
#    define LPTMR_CLOCK_LPO 1 /* 1kHz clock */
#    define LPTMR_CLOCK_ERCLK32K 2 /* external 32kHz crystal */
#    define LPTMR_CLOCK_OSCERCLK 3 /* output from OSC */



@@ 121,7 121,7 @@ void sleep_led_init(void) {
    MCG->C2 |= MCG_C2_IRCS;  // fast (4MHz) internal ref clock
#        if defined(KL27)    // divide the 8MHz IRC by 2, to have the same MCGIRCLK speed as others
    MCG->MC |= MCG_MC_LIRC_DIV2_DIV2;
#        endif                  /* KL27 */
#        endif /* KL27 */
    MCG->C1 |= MCG_C1_IRCLKEN;  // enable internal ref clock
    //  to work in stop mode, also MCG_C1_IREFSTEN
    //  Divide 4MHz by 2^N (N=6) => 62500 irqs/sec =>

M tmk_core/common/keyboard.h => tmk_core/common/keyboard.h +3 -3
@@ 70,9 70,9 @@ void keyboard_pre_init_user(void);
void keyboard_post_init_kb(void);
void keyboard_post_init_user(void);

void housekeeping_task(void); // To be executed by the main loop in each backend TMK protocol
void housekeeping_task_kb(void); // To be overridden by keyboard-level code
void housekeeping_task_user(void); // To be overridden by user/keymap-level code
void housekeeping_task(void);       // To be executed by the main loop in each backend TMK protocol
void housekeeping_task_kb(void);    // To be overridden by keyboard-level code
void housekeeping_task_user(void);  // To be overridden by user/keymap-level code

uint32_t last_input_activity_time(void);     // Timestamp of the last matrix or encoder activity
uint32_t last_input_activity_elapsed(void);  // Number of milliseconds since the last matrix or encoder activity