ceres-sees-all/qmk
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 2

Merge remote-tracking branch 'origin/master' into develop

Browse source
This commit is contained in:
QMK Bot 2025-11-30 19:25:52 +00:00
commit ee60542bd6
92 changed files with 307 additions and 348 deletions
Download patch file Download diff file Expand all files Collapse all files

12
quantum/action_code.h
View file

@ -167,11 +167,11 @@ enum mods_codes {
MODS_TAP_TOGGLE = 0x01,
};
#define ACTION_KEY(key) ACTION(ACT_MODS, (key))
#define ACTION_MODS(mods) ACTION(ACT_MODS, ((mods)&0x1f) << 8 | 0)
#define ACTION_MODS_KEY(mods, key) ACTION(ACT_MODS, ((mods)&0x1f) << 8 | (key))
#define ACTION_MODS_TAP_KEY(mods, key) ACTION(ACT_MODS_TAP, ((mods)&0x1f) << 8 | (key))
#define ACTION_MODS_ONESHOT(mods) ACTION(ACT_MODS_TAP, ((mods)&0x1f) << 8 | MODS_ONESHOT)
#define ACTION_MODS_TAP_TOGGLE(mods) ACTION(ACT_MODS_TAP, ((mods)&0x1f) << 8 | MODS_TAP_TOGGLE)
#define ACTION_MODS(mods) ACTION(ACT_MODS, ((mods) & 0x1f) << 8 | 0)
#define ACTION_MODS_KEY(mods, key) ACTION(ACT_MODS, ((mods) & 0x1f) << 8 | (key))
#define ACTION_MODS_TAP_KEY(mods, key) ACTION(ACT_MODS_TAP, ((mods) & 0x1f) << 8 | (key))
#define ACTION_MODS_ONESHOT(mods) ACTION(ACT_MODS_TAP, ((mods) & 0x1f) << 8 | MODS_ONESHOT)
#define ACTION_MODS_TAP_TOGGLE(mods) ACTION(ACT_MODS_TAP, ((mods) & 0x1f) << 8 | MODS_TAP_TOGGLE)
/** \brief Other Keys
*/
@ -210,7 +210,7 @@ enum layer_param_tap_op {
OP_SET_CLEAR,
OP_ONESHOT,
};
#define ACTION_LAYER_BITOP(op, part, bits, on) ACTION(ACT_LAYER, (op) << 10 | (on) << 8 | (part) << 5 | ((bits)&0x1f))
#define ACTION_LAYER_BITOP(op, part, bits, on) ACTION(ACT_LAYER, (op) << 10 | (on) << 8 | (part) << 5 | ((bits) & 0x1f))
#define ACTION_LAYER_TAP(layer, key) ACTION(ACT_LAYER_TAP, (layer) << 8 | (key))
/* Default Layer */
#define ACTION_DEFAULT_LAYER_SET(layer) ACTION_DEFAULT_LAYER_BIT_SET((layer) / 4, 1 << ((layer) % 4))

38
quantum/action_tapping.c
View file

@ -474,28 +474,28 @@ bool process_tapping(keyrecord_t *keyp) {
&& !(MAYBE_RETRO_SHIFTING(event, keyp) && get_auto_shifted_key(get_record_keycode(keyp, false), keyp))
# endif
) {
// Settle the tapping key as *held*, since
// HOLD_ON_OTHER_KEY_PRESS is enabled for this key.
ac_dprintf("Tapping: End. No tap. Interfered by pressed key\n");
process_record(&tapping_key);
// Settle the tapping key as *held*, since
// HOLD_ON_OTHER_KEY_PRESS is enabled for this key.
ac_dprintf("Tapping: End. No tap. Interfered by pressed key\n");
process_record(&tapping_key);
# if defined(CHORDAL_HOLD)
if (waiting_buffer_tail != waiting_buffer_head && is_tap_record(&waiting_buffer[waiting_buffer_tail])) {
tapping_key = waiting_buffer[waiting_buffer_tail];
// Pop tail from the queue.
waiting_buffer_tail = (waiting_buffer_tail + 1) % WAITING_BUFFER_SIZE;
debug_waiting_buffer();
} else
if (waiting_buffer_tail != waiting_buffer_head && is_tap_record(&waiting_buffer[waiting_buffer_tail])) {
tapping_key = waiting_buffer[waiting_buffer_tail];
// Pop tail from the queue.
waiting_buffer_tail = (waiting_buffer_tail + 1) % WAITING_BUFFER_SIZE;
debug_waiting_buffer();
} else
# endif // CHORDAL_HOLD
{
tapping_key = (keyrecord_t){0};
}
debug_tapping_key();
# if defined(CHORDAL_HOLD)
waiting_buffer_process_regular();
# endif // CHORDAL_HOLD
{
tapping_key = (keyrecord_t){0};
}
debug_tapping_key();
# if defined(CHORDAL_HOLD)
waiting_buffer_process_regular();
# endif // CHORDAL_HOLD
}
}
// enqueue
return false;
@ -946,7 +946,7 @@ static uint8_t waiting_buffer_find_chordal_hold_tap(void) {
uint16_t prev_keycode = get_record_keycode(&tapping_key, false);
uint8_t first_tap = WAITING_BUFFER_SIZE;
for (uint8_t i = waiting_buffer_tail; i != waiting_buffer_head; i = (i + 1) % WAITING_BUFFER_SIZE) {
keyrecord_t * cur = &waiting_buffer[i];
keyrecord_t *cur = &waiting_buffer[i];
const uint16_t cur_keycode = get_record_keycode(cur, false);
if (!cur->event.pressed || !is_mt_or_lt(prev_keycode)) {
break;

3
quantum/action_util.h
View file

@ -135,8 +135,7 @@ void clear_oneshot_swaphands(void);
void neutralize_flashing_modifiers(uint8_t active_mods);
#endif
#ifndef MODS_TO_NEUTRALIZE
# define MODS_TO_NEUTRALIZE \
{ MOD_BIT(KC_LEFT_ALT), MOD_BIT(KC_LEFT_GUI) }
# define MODS_TO_NEUTRALIZE {MOD_BIT(KC_LEFT_ALT), MOD_BIT(KC_LEFT_GUI)}
#endif
#ifdef __cplusplus

6
quantum/audio/musical_notes.h
View file

@ -21,12 +21,10 @@
// in beats-per-minute
#endif
#define SONG(notes...) \
{ notes }
#define SONG(notes...) {notes}
// Note Types
#define MUSICAL_NOTE(note, duration) \
{ (NOTE##note), duration }
#define MUSICAL_NOTE(note, duration) {(NOTE##note), duration}
#define BREVE_NOTE(note) MUSICAL_NOTE(note, 128)
#define WHOLE_NOTE(note) MUSICAL_NOTE(note, 64)

4
quantum/backlight/backlight_driver_common.c
View file

@ -16,7 +16,9 @@ static const pin_t backlight_pins[] = BACKLIGHT_PINS;
# define FOR_EACH_LED(x) \
for (uint8_t i = 0; i < BACKLIGHT_LED_COUNT; i++) { \
pin_t backlight_pin = backlight_pins[i]; \
{ x } \
{ \
x \
} \
}
#else
// we support only one backlight pin

2
quantum/command.c
View file

@ -629,7 +629,7 @@ static void mousekey_console_help(void) {
bool mousekey_console(uint8_t code) {
static uint8_t param = 0;
static uint8_t *pp = NULL;
static char * desc = NULL;
static char *desc = NULL;
# if defined(NO_PRINT) || defined(USER_PRINT) /* -Wunused-parameter */
(void)desc;

2
quantum/deferred_exec.h
View file

@ -78,7 +78,7 @@ typedef struct deferred_executor_t {
deferred_token token;
uint32_t trigger_time;
deferred_exec_callback callback;
void * cb_arg;
void *cb_arg;
} deferred_executor_t;
/**

3
quantum/dip_switch.h
View file

@ -49,7 +49,6 @@ void dip_switch_task(void);
#ifdef DIP_SWITCH_MAP_ENABLE
# define NUM_DIP_STATES 2
# define DIP_SWITCH_OFF_ON(off, on) \
{ (off), (on) }
# define DIP_SWITCH_OFF_ON(off, on) {(off), (on)}
extern const uint16_t dip_switch_map[NUM_DIP_SWITCHES][NUM_DIP_STATES];
#endif // DIP_SWITCH_MAP_ENABLE

3
quantum/encoder.h
View file

@ -111,8 +111,7 @@ void encoder_signal_queue_drain(void);
# ifdef ENCODER_MAP_ENABLE
# define NUM_DIRECTIONS 2
# define ENCODER_CCW_CW(ccw, cw) \
{ (cw), (ccw) }
# define ENCODER_CCW_CW(ccw, cw) {(cw), (ccw)}
extern const uint16_t encoder_map[][NUM_ENCODERS][NUM_DIRECTIONS];
# endif // ENCODER_MAP_ENABLE

6
quantum/encoder/tests/config_mock.h
View file

@ -7,10 +7,8 @@
#define MATRIX_COLS 1
/* Here, "pins" from 0 to 31 are allowed. */
#define ENCODER_A_PINS \
{ 0 }
#define ENCODER_B_PINS \
{ 1 }
#define ENCODER_A_PINS {0}
#define ENCODER_B_PINS {1}
#ifdef __cplusplus
extern "C" {

12
quantum/encoder/tests/config_mock_split_left_eq_right.h
View file

@ -7,14 +7,10 @@
#define MATRIX_COLS 1
/* Here, "pins" from 0 to 31 are allowed. */
#define ENCODER_A_PINS \
{ 0, 2 }
#define ENCODER_B_PINS \
{ 1, 3 }
#define ENCODER_A_PINS_RIGHT \
{ 4, 6 }
#define ENCODER_B_PINS_RIGHT \
{ 5, 7 }
#define ENCODER_A_PINS {0, 2}
#define ENCODER_B_PINS {1, 3}
#define ENCODER_A_PINS_RIGHT {4, 6}
#define ENCODER_B_PINS_RIGHT {5, 7}
#ifdef __cplusplus
extern "C" {

12
quantum/encoder/tests/config_mock_split_left_gt_right.h
View file

@ -7,14 +7,10 @@
#define MATRIX_COLS 1
/* Here, "pins" from 0 to 31 are allowed. */
#define ENCODER_A_PINS \
{ 0, 2, 4 }
#define ENCODER_B_PINS \
{ 1, 3, 5 }
#define ENCODER_A_PINS_RIGHT \
{ 6, 8 }
#define ENCODER_B_PINS_RIGHT \
{ 7, 9 }
#define ENCODER_A_PINS {0, 2, 4}
#define ENCODER_B_PINS {1, 3, 5}
#define ENCODER_A_PINS_RIGHT {6, 8}
#define ENCODER_B_PINS_RIGHT {7, 9}
#ifdef __cplusplus
extern "C" {

12
quantum/encoder/tests/config_mock_split_left_lt_right.h
View file

@ -7,14 +7,10 @@
#define MATRIX_COLS 1
/* Here, "pins" from 0 to 31 are allowed. */
#define ENCODER_A_PINS \
{ 0, 2 }
#define ENCODER_B_PINS \
{ 1, 3 }
#define ENCODER_A_PINS_RIGHT \
{ 4, 6, 8 }
#define ENCODER_B_PINS_RIGHT \
{ 5, 7, 9 }
#define ENCODER_A_PINS {0, 2}
#define ENCODER_B_PINS {1, 3}
#define ENCODER_A_PINS_RIGHT {4, 6, 8}
#define ENCODER_B_PINS_RIGHT {5, 7, 9}
#ifdef __cplusplus
extern "C" {

12
quantum/encoder/tests/config_mock_split_no_left.h
View file

@ -8,13 +8,13 @@
/* Here, "pins" from 0 to 31 are allowed. */
#define ENCODER_A_PINS \
{}
{ \
}
#define ENCODER_B_PINS \
{}
#define ENCODER_A_PINS_RIGHT \
{ 0, 2 }
#define ENCODER_B_PINS_RIGHT \
{ 1, 3 }
{ \
}
#define ENCODER_A_PINS_RIGHT {0, 2}
#define ENCODER_B_PINS_RIGHT {1, 3}
#ifdef __cplusplus
extern "C" {

12
quantum/encoder/tests/config_mock_split_no_right.h
View file

@ -7,14 +7,14 @@
#define MATRIX_COLS 1
/* Here, "pins" from 0 to 31 are allowed. */
#define ENCODER_A_PINS \
{ 0, 2 }
#define ENCODER_B_PINS \
{ 1, 3 }
#define ENCODER_A_PINS {0, 2}
#define ENCODER_B_PINS {1, 3}
#define ENCODER_A_PINS_RIGHT \
{}
{ \
}
#define ENCODER_B_PINS_RIGHT \
{}
{ \
}
#ifdef __cplusplus
extern "C" {

12
quantum/encoder/tests/config_mock_split_role.h
View file

@ -7,14 +7,10 @@
#define MATRIX_COLS 1
/* Here, "pins" from 0 to 31 are allowed. */
#define ENCODER_A_PINS \
{ 0, 2 }
#define ENCODER_B_PINS \
{ 1, 3 }
#define ENCODER_A_PINS_RIGHT \
{ 4, 6 }
#define ENCODER_B_PINS_RIGHT \
{ 5, 7 }
#define ENCODER_A_PINS {0, 2}
#define ENCODER_B_PINS {1, 3}
#define ENCODER_A_PINS_RIGHT {4, 6}
#define ENCODER_B_PINS_RIGHT {5, 7}
#ifdef __cplusplus
extern "C" {

6
quantum/joystick.h
View file

@ -64,10 +64,8 @@
// configure on input_pin of the joystick_axes array entry to NO_PIN
// to prevent it from being read from the ADC. This allows outputting forged axis value.
#define JOYSTICK_AXIS_VIRTUAL \
{ NO_PIN, 0, JOYSTICK_MAX_VALUE / 2, JOYSTICK_MAX_VALUE }
#define JOYSTICK_AXIS_IN(INPUT_PIN, LOW, REST, HIGH) \
{ INPUT_PIN, LOW, REST, HIGH }
#define JOYSTICK_AXIS_VIRTUAL {NO_PIN, 0, JOYSTICK_MAX_VALUE / 2, JOYSTICK_MAX_VALUE}
#define JOYSTICK_AXIS_IN(INPUT_PIN, LOW, REST, HIGH) {INPUT_PIN, LOW, REST, HIGH}
typedef struct {
pin_t input_pin;

2
quantum/keycode.h
View file

@ -34,7 +34,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define IS_MOUSEKEY_WHEEL(code) (QK_MOUSE_WHEEL_UP <= (code) && (code) <= QK_MOUSE_WHEEL_RIGHT)
#define IS_MOUSEKEY_ACCEL(code) (QK_MOUSE_ACCELERATION_0 <= (code) && (code) <= QK_MOUSE_ACCELERATION_2)
#define MOD_BIT(code) (1 << ((code)&0x07))
#define MOD_BIT(code) (1 << ((code) & 0x07))
// clang-format off

2
quantum/matrix.c
View file

@ -54,7 +54,7 @@ static SPLIT_MUTABLE pin_t direct_pins[MATRIX_ROWS_PER_HAND][MATRIX_COLS] = DIRE
static SPLIT_MUTABLE_ROW pin_t row_pins[MATRIX_ROWS_PER_HAND] = MATRIX_ROW_PINS;
# endif // MATRIX_ROW_PINS
# ifdef MATRIX_COL_PINS
static SPLIT_MUTABLE_COL pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static SPLIT_MUTABLE_COL pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
# endif // MATRIX_COL_PINS
#endif

2
quantum/mousekey.c
View file

@ -502,7 +502,7 @@ void mousekey_off(uint8_t code) {
enum { mkspd_unmod, mkspd_0, mkspd_1, mkspd_2, mkspd_COUNT };
# ifndef MK_MOMENTARY_ACCEL
static uint8_t mk_speed = mkspd_1;
static uint8_t mk_speed = mkspd_1;
# else
static uint8_t mk_speed = mkspd_unmod;
static uint8_t mkspd_DEFAULT = mkspd_unmod;

12
quantum/nvm/eeprom/nvm_dynamic_keymap.c
View file

@ -124,7 +124,7 @@ void nvm_dynamic_keymap_update_encoder(uint8_t layer, uint8_t encoder_id, bool c
void nvm_dynamic_keymap_read_buffer(uint32_t offset, uint32_t size, uint8_t *data) {
uint32_t dynamic_keymap_eeprom_size = DYNAMIC_KEYMAP_LAYER_COUNT * MATRIX_ROWS * MATRIX_COLS * 2;
void * source = (void *)(uintptr_t)(DYNAMIC_KEYMAP_EEPROM_ADDR + offset);
void *source = (void *)(uintptr_t)(DYNAMIC_KEYMAP_EEPROM_ADDR + offset);
uint8_t *target = data;
for (uint32_t i = 0; i < size; i++) {
if (offset + i < dynamic_keymap_eeprom_size) {
@ -139,7 +139,7 @@ void nvm_dynamic_keymap_read_buffer(uint32_t offset, uint32_t size, uint8_t *dat
void nvm_dynamic_keymap_update_buffer(uint32_t offset, uint32_t size, uint8_t *data) {
uint32_t dynamic_keymap_eeprom_size = DYNAMIC_KEYMAP_LAYER_COUNT * MATRIX_ROWS * MATRIX_COLS * 2;
void * target = (void *)(uintptr_t)(DYNAMIC_KEYMAP_EEPROM_ADDR + offset);
void *target = (void *)(uintptr_t)(DYNAMIC_KEYMAP_EEPROM_ADDR + offset);
uint8_t *source = data;
for (uint32_t i = 0; i < size; i++) {
if (offset + i < dynamic_keymap_eeprom_size) {
@ -155,7 +155,7 @@ uint32_t nvm_dynamic_keymap_macro_size(void) {
}
void nvm_dynamic_keymap_macro_read_buffer(uint32_t offset, uint32_t size, uint8_t *data) {
void * source = (void *)(uintptr_t)(DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR + offset);
void *source = (void *)(uintptr_t)(DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR + offset);
uint8_t *target = data;
for (uint16_t i = 0; i < size; i++) {
if (offset + i < DYNAMIC_KEYMAP_MACRO_EEPROM_SIZE) {
@ -169,7 +169,7 @@ void nvm_dynamic_keymap_macro_read_buffer(uint32_t offset, uint32_t size, uint8_
}
void nvm_dynamic_keymap_macro_update_buffer(uint32_t offset, uint32_t size, uint8_t *data) {
void * target = (void *)(uintptr_t)(DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR + offset);
void *target = (void *)(uintptr_t)(DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR + offset);
uint8_t *source = data;
for (uint16_t i = 0; i < size; i++) {
if (offset + i < DYNAMIC_KEYMAP_MACRO_EEPROM_SIZE) {
@ -181,8 +181,8 @@ void nvm_dynamic_keymap_macro_update_buffer(uint32_t offset, uint32_t size, uint
}
void nvm_dynamic_keymap_macro_reset(void) {
void * start = (void *)(uintptr_t)(DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR);
void * end = (void *)(uintptr_t)(DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR + DYNAMIC_KEYMAP_MACRO_EEPROM_SIZE);
void *start = (void *)(uintptr_t)(DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR);
void *end = (void *)(uintptr_t)(DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR + DYNAMIC_KEYMAP_MACRO_EEPROM_SIZE);
long remaining = end - start;
uint8_t dummy[16] = {0};
for (int i = 0; i < DYNAMIC_KEYMAP_MACRO_EEPROM_SIZE; i += sizeof(dummy)) {

8
quantum/nvm/eeprom/nvm_eeconfig.c
View file

@ -246,8 +246,8 @@ uint32_t nvm_eeconfig_update_kb_datablock(const void *data, uint32_t offset, uin
void nvm_eeconfig_init_kb_datablock(void) {
eeprom_update_dword(EECONFIG_KEYBOARD, (EECONFIG_KB_DATA_VERSION));
void * start = (void *)(uintptr_t)(EECONFIG_KB_DATABLOCK);
void * end = (void *)(uintptr_t)(EECONFIG_KB_DATABLOCK + EECONFIG_KB_DATA_SIZE);
void *start = (void *)(uintptr_t)(EECONFIG_KB_DATABLOCK);
void *end = (void *)(uintptr_t)(EECONFIG_KB_DATABLOCK + EECONFIG_KB_DATA_SIZE);
long remaining = end - start;
uint8_t dummy[16] = {0};
for (int i = 0; i < EECONFIG_KB_DATA_SIZE; i += sizeof(dummy)) {
@ -290,8 +290,8 @@ uint32_t nvm_eeconfig_update_user_datablock(const void *data, uint32_t offset, u
void nvm_eeconfig_init_user_datablock(void) {
eeprom_update_dword(EECONFIG_USER, (EECONFIG_USER_DATA_VERSION));
void * start = (void *)(uintptr_t)(EECONFIG_USER_DATABLOCK);
void * end = (void *)(uintptr_t)(EECONFIG_USER_DATABLOCK + EECONFIG_USER_DATA_SIZE);
void *start = (void *)(uintptr_t)(EECONFIG_USER_DATABLOCK);
void *end = (void *)(uintptr_t)(EECONFIG_USER_DATABLOCK + EECONFIG_USER_DATA_SIZE);
long remaining = end - start;
uint8_t dummy[16] = {0};
for (int i = 0; i < EECONFIG_USER_DATA_SIZE; i += sizeof(dummy)) {

6
quantum/painter/lvgl/qp_lvgl.c
View file

@ -17,7 +17,7 @@ static deferred_executor_t lvgl_executors[2] = {0}; // For lv_tick_inc and lv_ta
static lvgl_state_t lvgl_states[2] = {0}; // For lv_tick_inc and lv_task_handler
painter_device_t selected_display = NULL;
void * color_buffer = NULL;
void *color_buffer = NULL;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Quantum Painter LVGL Integration Internal: qp_lvgl_flush
@ -33,7 +33,7 @@ void qp_lvgl_flush(lv_disp_drv_t *disp, const lv_area_t *area, lv_color_t *color
}
static uint32_t tick_task_callback(uint32_t trigger_time, void *cb_arg) {
lvgl_state_t * state = (lvgl_state_t *)cb_arg;
lvgl_state_t *state = (lvgl_state_t *)cb_arg;
static uint32_t last_tick = 0;
switch (state->fnc_id) {
case 0: {
@ -97,7 +97,7 @@ bool qp_lvgl_attach(painter_device_t device) {
static lv_disp_draw_buf_t draw_buf;
// Allocate a buffer for 1/10 screen size
const size_t count_required = driver->panel_width * driver->panel_height / 10;
void * new_color_buffer = realloc(color_buffer, sizeof(lv_color_t) * count_required);
void *new_color_buffer = realloc(color_buffer, sizeof(lv_color_t) * count_required);
if (!new_color_buffer) {
qp_dprintf("qp_lvgl_attach: fail (could not set up memory buffer)\n");
qp_lvgl_detach();

4
quantum/painter/qp_comms.c
View file

@ -50,7 +50,7 @@ uint32_t qp_comms_send(painter_device_t device, const void *data, uint32_t byte_
// Comms APIs that use a D/C pin
bool qp_comms_command(painter_device_t device, uint8_t cmd) {
painter_driver_t * driver = (painter_driver_t *)device;
painter_driver_t *driver = (painter_driver_t *)device;
painter_comms_with_command_vtable_t *comms_vtable = (painter_comms_with_command_vtable_t *)driver->comms_vtable;
return comms_vtable->send_command(device, cmd);
}
@ -66,7 +66,7 @@ uint32_t qp_comms_command_databuf(painter_device_t device, uint8_t cmd, const vo
}
bool qp_comms_bulk_command_sequence(painter_device_t device, const uint8_t *sequence, size_t sequence_len) {
painter_driver_t * driver = (painter_driver_t *)device;
painter_driver_t *driver = (painter_driver_t *)device;
painter_comms_with_command_vtable_t *comms_vtable = (painter_comms_with_command_vtable_t *)driver->comms_vtable;
return comms_vtable->bulk_command_sequence(device, sequence, sequence_len);
}

4
quantum/painter/qp_draw_text.c
View file

@ -343,14 +343,14 @@ typedef struct code_point_iter_drawglyph_state_t {
int16_t xpos;
int16_t ypos;
qp_internal_byte_input_callback input_callback;
qp_internal_byte_input_state_t * input_state;
qp_internal_byte_input_state_t *input_state;
qp_internal_pixel_output_state_t *output_state;
} code_point_iter_drawglyph_state_t;
// Codepoint handler callback: drawing
static inline bool qp_font_code_point_handler_drawglyph(qff_font_handle_t *qff_font, uint32_t code_point, uint8_t width, uint8_t height, void *cb_arg) {
code_point_iter_drawglyph_state_t *state = (code_point_iter_drawglyph_state_t *)cb_arg;
painter_driver_t * driver = (painter_driver_t *)state->device;
painter_driver_t *driver = (painter_driver_t *)state->device;
// Reset the input state's RLE mode -- the stream should already be correctly positioned by qp_iterate_code_points()
state->input_state->rle.mode = MARKER_BYTE; // ignored if not using RLE

2
quantum/painter/qp_internal_driver.h
View file

@ -60,7 +60,7 @@ typedef struct painter_comms_with_command_vtable_t {
typedef struct painter_driver_t {
const painter_driver_vtable_t *driver_vtable;
const painter_comms_vtable_t * comms_vtable;
const painter_comms_vtable_t *comms_vtable;
// Flag signifying if validation was successful
bool validate_ok;

4
quantum/painter/qp_stream.h
View file

@ -62,7 +62,7 @@ typedef struct qp_stream_t {
typedef struct qp_memory_stream_t {
qp_stream_t base;
uint8_t * buffer;
uint8_t *buffer;
int32_t length;
int32_t position;
bool is_eof;
@ -77,7 +77,7 @@ qp_memory_stream_t qp_make_memory_stream(void *buffer, int32_t length);
typedef struct qp_file_stream_t {
qp_stream_t base;
FILE * file;
FILE *file;
} qp_file_stream_t;
qp_file_stream_t qp_make_file_stream(FILE *f);

2
quantum/process_keycode/process_autocorrect.c
View file

@ -309,7 +309,7 @@ bool process_autocorrect(uint16_t keycode, keyrecord_t *record) {
if (code & 128) { // A typo was found! Apply autocorrect.
const uint8_t backspaces = (code & 63) + !record->event.pressed;
const char * changes = (const char *)(autocorrect_data + state + 1);
const char *changes = (const char *)(autocorrect_data + state + 1);
/* Gather info about the typo'd word
*

14
quantum/process_keycode/process_combo.c
View file

@ -225,7 +225,7 @@ static inline void dump_key_buffer(void) {
key_buffer_next = key_buffer_i + 1;
queued_record_t *qrecord = &key_buffer[key_buffer_i];
keyrecord_t * record = &qrecord->record;
keyrecord_t *record = &qrecord->record;
if (IS_NOEVENT(record->event)) {
continue;
@ -318,14 +318,14 @@ void apply_combo(uint16_t combo_index, combo_t *combo) {
#if defined(EXTRA_EXTRA_LONG_COMBOS)
uint32_t state = 0;
#elif defined(EXTRA_LONG_COMBOS)
uint16_t state = 0;
uint16_t state = 0;
#else
uint8_t state = 0;
#endif
for (uint8_t key_buffer_i = 0; key_buffer_i < key_buffer_size; key_buffer_i++) {
queued_record_t *qrecord = &key_buffer[key_buffer_i];
keyrecord_t * record = &qrecord->record;
keyrecord_t *record = &qrecord->record;
uint16_t keycode = qrecord->keycode;
uint8_t key_count = 0;
@ -365,7 +365,7 @@ static inline void apply_combos(void) {
// Apply all buffered normal combos.
for (uint8_t i = combo_buffer_read; i != combo_buffer_write; INCREMENT_MOD(i)) {
queued_combo_t *buffered_combo = &combo_buffer[i];
combo_t * combo = combo_get(buffered_combo->combo_index);
combo_t *combo = combo_get(buffered_combo->combo_index);
#ifdef COMBO_MUST_TAP_PER_COMBO
if (get_combo_must_tap(buffered_combo->combo_index, combo)) {
@ -470,7 +470,7 @@ static combo_key_action_t process_single_combo(combo_t *combo, uint16_t keycode,
combo_t *drop = NULL;
for (uint8_t combo_buffer_i = combo_buffer_read; combo_buffer_i != combo_buffer_write; INCREMENT_MOD(combo_buffer_i)) {
queued_combo_t *qcombo = &combo_buffer[combo_buffer_i];
combo_t * buffered_combo = combo_get(qcombo->combo_index);
combo_t *buffered_combo = combo_get(qcombo->combo_index);
if ((drop = overlaps(buffered_combo, combo))) {
DISABLE_COMBO(drop);
@ -578,8 +578,8 @@ bool process_combo(uint16_t keycode, keyrecord_t *record) {
/* Only check keycodes from one layer. */
keycode = keymap_key_to_keycode(COMBO_ONLY_FROM_LAYER, record->event.key);
#else
uint8_t highest_layer = get_highest_layer(layer_state | default_layer_state);
uint8_t ref_layer = combo_ref_from_layer(highest_layer);
uint8_t highest_layer = get_highest_layer(layer_state | default_layer_state);
uint8_t ref_layer = combo_ref_from_layer(highest_layer);
if (ref_layer != highest_layer) {
keycode = keymap_key_to_keycode(ref_layer, record->event.key);
}

10
quantum/process_keycode/process_combo.h
View file

@ -45,8 +45,8 @@ typedef struct combo_t {
#ifdef EXTRA_SHORT_COMBOS
uint8_t state;
#else
bool disabled;
bool active;
bool disabled;
bool active;
# if defined(EXTRA_EXTRA_LONG_COMBOS)
uint32_t state;
# elif defined(EXTRA_LONG_COMBOS)
@ -57,10 +57,8 @@ typedef struct combo_t {
#endif
} combo_t;
#define COMBO(ck, ca) \
{ .keys = &(ck)[0], .keycode = (ca) }
#define COMBO_ACTION(ck) \
{ .keys = &(ck)[0] }
#define COMBO(ck, ca) {.keys = &(ck)[0], .keycode = (ca)}
#define COMBO_ACTION(ck) {.keys = &(ck)[0]}
#define COMBO_END 0
#ifndef COMBO_TERM

2
quantum/process_keycode/process_key_lock.c
View file

@ -20,7 +20,7 @@
#define BV_64(shift) (((uint64_t)1) << (shift))
#define GET_KEY_ARRAY(code) (((code) < 0x40) ? key_state[0] : ((code) < 0x80) ? key_state[1] : ((code) < 0xC0) ? key_state[2] : key_state[3])
#define GET_CODE_INDEX(code) (((code) < 0x40) ? (code) : ((code) < 0x80) ? (code)-0x40 : ((code) < 0xC0) ? (code)-0x80 : (code)-0xC0)
#define GET_CODE_INDEX(code) (((code) < 0x40) ? (code) : ((code) < 0x80) ? (code) - 0x40 : ((code) < 0xC0) ? (code) - 0x80 : (code) - 0xC0)
#define KEY_STATE(code) (GET_KEY_ARRAY(code) & BV_64(GET_CODE_INDEX(code))) == BV_64(GET_CODE_INDEX(code))
#define SET_KEY_ARRAY_STATE(code, val) \
do { \

3
quantum/process_keycode/process_key_override.c
View file

@ -39,7 +39,8 @@
# define key_override_printf dprintf
#else
# define key_override_printf(str, ...) \
{}
{ \
}
#endif
// Helpers

38
quantum/process_keycode/process_tap_dance.h
View file

@ -58,23 +58,41 @@ typedef struct {
void (*layer_function)(uint8_t);
} tap_dance_dual_role_t;
#define ACTION_TAP_DANCE_DOUBLE(kc1, kc2) \
{ .fn = {tap_dance_pair_on_each_tap, tap_dance_pair_finished, tap_dance_pair_reset, NULL}, .user_data = (void *)&((tap_dance_pair_t){kc1, kc2}), }
#define ACTION_TAP_DANCE_DOUBLE(kc1, kc2) \
{ \
.fn = {tap_dance_pair_on_each_tap, tap_dance_pair_finished, tap_dance_pair_reset, NULL}, \
.user_data = (void *)&((tap_dance_pair_t){kc1, kc2}), \
}
#define ACTION_TAP_DANCE_LAYER_MOVE(kc, layer) \
{ .fn = {tap_dance_dual_role_on_each_tap, tap_dance_dual_role_finished, tap_dance_dual_role_reset, NULL}, .user_data = (void *)&((tap_dance_dual_role_t){kc, layer, layer_move}), }
#define ACTION_TAP_DANCE_LAYER_MOVE(kc, layer) \
{ \
.fn = {tap_dance_dual_role_on_each_tap, tap_dance_dual_role_finished, tap_dance_dual_role_reset, NULL}, \
.user_data = (void *)&((tap_dance_dual_role_t){kc, layer, layer_move}), \
}
#define ACTION_TAP_DANCE_LAYER_TOGGLE(kc, layer) \
{ .fn = {NULL, tap_dance_dual_role_finished, tap_dance_dual_role_reset, NULL}, .user_data = (void *)&((tap_dance_dual_role_t){kc, layer, layer_invert}), }
#define ACTION_TAP_DANCE_LAYER_TOGGLE(kc, layer) \
{ \
.fn = {NULL, tap_dance_dual_role_finished, tap_dance_dual_role_reset, NULL}, \
.user_data = (void *)&((tap_dance_dual_role_t){kc, layer, layer_invert}), \
}
#define ACTION_TAP_DANCE_FN(user_fn) \
{ .fn = {NULL, user_fn, NULL, NULL}, .user_data = NULL, }
#define ACTION_TAP_DANCE_FN(user_fn) \
{ \
.fn = {NULL, user_fn, NULL, NULL}, \
.user_data = NULL, \
}
#define ACTION_TAP_DANCE_FN_ADVANCED(user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset) \
{ .fn = {user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset, NULL}, .user_data = NULL, }
{ \
.fn = {user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset, NULL}, \
.user_data = NULL, \
}
#define ACTION_TAP_DANCE_FN_ADVANCED_WITH_RELEASE(user_fn_on_each_tap, user_fn_on_each_release, user_fn_on_dance_finished, user_fn_on_dance_reset) \
{ .fn = {user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset, user_fn_on_each_release}, .user_data = NULL, }
{ \
.fn = {user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset, user_fn_on_each_release}, \
.user_data = NULL, \
}
#define TD_INDEX(code) QK_TAP_DANCE_GET_INDEX(code)
#define TAP_DANCE_KEYCODE(state) TD(((tap_dance_action_t *)state) - tap_dance_actions)

64
quantum/quantum_keycodes.h
View file

@ -39,7 +39,7 @@
// Generic decoding for the whole QK_MODS range
#define QK_MODS_GET_MODS(kc) (((kc) >> 8) & 0x1F)
#define QK_MODS_GET_BASIC_KEYCODE(kc) ((kc)&0xFF)
#define QK_MODS_GET_BASIC_KEYCODE(kc) ((kc) & 0xFF)
// Modified keycodes
#define LCTL(kc) (QK_LCTL | (kc))
@ -90,37 +90,37 @@
#define MEH(kc) (QK_LCTL | QK_LSFT | QK_LALT | (kc))
// GOTO layer - 32 layer max
#define TO(layer) (QK_TO | ((layer)&0x1F))
#define QK_TO_GET_LAYER(kc) ((kc)&0x1F)
#define TO(layer) (QK_TO | ((layer) & 0x1F))
#define QK_TO_GET_LAYER(kc) ((kc) & 0x1F)
// Momentary switch layer - 32 layer max
#define MO(layer) (QK_MOMENTARY | ((layer)&0x1F))
#define QK_MOMENTARY_GET_LAYER(kc) ((kc)&0x1F)
#define MO(layer) (QK_MOMENTARY | ((layer) & 0x1F))
#define QK_MOMENTARY_GET_LAYER(kc) ((kc) & 0x1F)
// Set default layer - 32 layer max
#define DF(layer) (QK_DEF_LAYER | ((layer)&0x1F))
#define QK_DEF_LAYER_GET_LAYER(kc) ((kc)&0x1F)
#define DF(layer) (QK_DEF_LAYER | ((layer) & 0x1F))
#define QK_DEF_LAYER_GET_LAYER(kc) ((kc) & 0x1F)
// Set persistent default layer - 32 layer max
#define PDF(layer) (QK_PERSISTENT_DEF_LAYER | ((layer)&0x1F))
#define QK_PERSISTENT_DEF_LAYER_GET_LAYER(kc) ((kc)&0x1F)
#define PDF(layer) (QK_PERSISTENT_DEF_LAYER | ((layer) & 0x1F))
#define QK_PERSISTENT_DEF_LAYER_GET_LAYER(kc) ((kc) & 0x1F)
// Toggle to layer - 32 layer max
#define TG(layer) (QK_TOGGLE_LAYER | ((layer)&0x1F))
#define QK_TOGGLE_LAYER_GET_LAYER(kc) ((kc)&0x1F)
#define TG(layer) (QK_TOGGLE_LAYER | ((layer) & 0x1F))
#define QK_TOGGLE_LAYER_GET_LAYER(kc) ((kc) & 0x1F)
// One-shot layer - 32 layer max
#define OSL(layer) (QK_ONE_SHOT_LAYER | ((layer)&0x1F))
#define QK_ONE_SHOT_LAYER_GET_LAYER(kc) ((kc)&0x1F)
#define OSL(layer) (QK_ONE_SHOT_LAYER | ((layer) & 0x1F))
#define QK_ONE_SHOT_LAYER_GET_LAYER(kc) ((kc) & 0x1F)
// L-ayer M-od: Momentary switch layer with modifiers active - 16 layer max
#define LM(layer, mod) (QK_LAYER_MOD | (((layer)&0xF) << 5) | ((mod)&0x1F))
#define LM(layer, mod) (QK_LAYER_MOD | (((layer) & 0xF) << 5) | ((mod) & 0x1F))
#define QK_LAYER_MOD_GET_LAYER(kc) (((kc) >> 5) & 0xF)
#define QK_LAYER_MOD_GET_MODS(kc) ((kc)&0x1F)
#define QK_LAYER_MOD_GET_MODS(kc) ((kc) & 0x1F)
// One-shot mod
#define OSM(mod) (QK_ONE_SHOT_MOD | ((mod)&0x1F))
#define QK_ONE_SHOT_MOD_GET_MODS(kc) ((kc)&0x1F)
#define OSM(mod) (QK_ONE_SHOT_MOD | ((mod) & 0x1F))
#define QK_ONE_SHOT_MOD_GET_MODS(kc) ((kc) & 0x1F)
#define OS_LCTL OSM(MOD_LCTL)
#define OS_LSFT OSM(MOD_LSFT)
@ -158,18 +158,18 @@
#define OS_HYPR OSM(MOD_LCTL | MOD_LSFT | MOD_LALT | MOD_LGUI)
// Layer tap-toggle - 32 layer max
#define TT(layer) (QK_LAYER_TAP_TOGGLE | ((layer)&0x1F))
#define QK_LAYER_TAP_TOGGLE_GET_LAYER(kc) ((kc)&0x1F)
#define TT(layer) (QK_LAYER_TAP_TOGGLE | ((layer) & 0x1F))
#define QK_LAYER_TAP_TOGGLE_GET_LAYER(kc) ((kc) & 0x1F)
// L-ayer, T-ap - 256 keycode max, 16 layer max
#define LT(layer, kc) (QK_LAYER_TAP | (((layer)&0xF) << 8) | ((kc)&0xFF))
#define LT(layer, kc) (QK_LAYER_TAP | (((layer) & 0xF) << 8) | ((kc) & 0xFF))
#define QK_LAYER_TAP_GET_LAYER(kc) (((kc) >> 8) & 0xF)
#define QK_LAYER_TAP_GET_TAP_KEYCODE(kc) ((kc)&0xFF)
#define QK_LAYER_TAP_GET_TAP_KEYCODE(kc) ((kc) & 0xFF)
// M-od, T-ap - 256 keycode max
#define MT(mod, kc) (QK_MOD_TAP | (((mod)&0x1F) << 8) | ((kc)&0xFF))
#define MT(mod, kc) (QK_MOD_TAP | (((mod) & 0x1F) << 8) | ((kc) & 0xFF))
#define QK_MOD_TAP_GET_MODS(kc) (((kc) >> 8) & 0x1F)
#define QK_MOD_TAP_GET_TAP_KEYCODE(kc) ((kc)&0xFF)
#define QK_MOD_TAP_GET_TAP_KEYCODE(kc) ((kc) & 0xFF)
// Mod-Tap shortcuts
#define LCTL_T(kc) MT(MOD_LCTL, kc)
@ -230,23 +230,23 @@
// Unicode aliases
// UNICODE_ENABLE - Allows Unicode input up to 0x7FFF
#define UC(c) (QK_UNICODE | (c))
#define QK_UNICODE_GET_CODE_POINT(kc) ((kc)&0x7FFF)
#define QK_UNICODE_GET_CODE_POINT(kc) ((kc) & 0x7FFF)
// UNICODEMAP_ENABLE - Allows Unicode input up to 0x10FFFF, requires unicode_map
#define UM(i) (QK_UNICODEMAP | ((i)&0x3FFF))
#define QK_UNICODEMAP_GET_INDEX(kc) ((kc)&0x3FFF)
#define UM(i) (QK_UNICODEMAP | ((i) & 0x3FFF))
#define QK_UNICODEMAP_GET_INDEX(kc) ((kc) & 0x3FFF)
#define UP(i, j) (QK_UNICODEMAP_PAIR | ((i)&0x7F) | (((j)&0x7F) << 7)) // 127 max i and j
#define QK_UNICODEMAP_PAIR_GET_UNSHIFTED_INDEX(kc) ((kc)&0x7F)
#define UP(i, j) (QK_UNICODEMAP_PAIR | ((i) & 0x7F) | (((j) & 0x7F) << 7)) // 127 max i and j
#define QK_UNICODEMAP_PAIR_GET_UNSHIFTED_INDEX(kc) ((kc) & 0x7F)
#define QK_UNICODEMAP_PAIR_GET_SHIFTED_INDEX(kc) (((kc) >> 7) & 0x7F)
// Swap Hands
#define SH_T(kc) (QK_SWAP_HANDS | ((kc)&0xFF))
#define QK_SWAP_HANDS_GET_TAP_KEYCODE(kc) ((kc)&0xFF)
#define SH_T(kc) (QK_SWAP_HANDS | ((kc) & 0xFF))
#define QK_SWAP_HANDS_GET_TAP_KEYCODE(kc) ((kc) & 0xFF)
// Tap dance
#define TD(i) (QK_TAP_DANCE | ((i)&0xFF))
#define QK_TAP_DANCE_GET_INDEX(kc) ((kc)&0xFF)
#define TD(i) (QK_TAP_DANCE | ((i) & 0xFF))
#define QK_TAP_DANCE_GET_INDEX(kc) ((kc) & 0xFF)
// MIDI aliases
#define MIDI_TONE_MIN QK_MIDI_NOTE_C_0

2
quantum/rgblight/rgblight.c
View file

@ -1381,7 +1381,7 @@ void rgblight_effect_twinkle(animation_status_t *anim) {
for (uint8_t i = 0; i < rgblight_ranges.effect_num_leds; i++) {
TwinkleState *t = &(led_twinkle_state[i]);
hsv_t * c = &(t->hsv);
hsv_t *c = &(t->hsv);
if (!random_color) {
c->h = rgblight_config.hue;

9
quantum/rgblight/rgblight.h
View file

@ -186,8 +186,7 @@ typedef struct {
# define RGBLIGHT_USE_TIMER
# define RGBLIGHT_END_SEGMENT_INDEX (255)
# define RGBLIGHT_END_SEGMENTS \
{ RGBLIGHT_END_SEGMENT_INDEX, 0, 0, 0 }
# define RGBLIGHT_END_SEGMENTS {RGBLIGHT_END_SEGMENT_INDEX, 0, 0, 0}
# ifndef RGBLIGHT_MAX_LAYERS
# define RGBLIGHT_MAX_LAYERS 8
# endif
@ -202,10 +201,8 @@ typedef uint32_t rgblight_layer_mask_t;
# else
# error invalid RGBLIGHT_MAX_LAYERS value (must be <= 32)
# endif
# define RGBLIGHT_LAYER_SEGMENTS(...) \
{ __VA_ARGS__, RGBLIGHT_END_SEGMENTS }
# define RGBLIGHT_LAYERS_LIST(...) \
{ __VA_ARGS__, NULL }
# define RGBLIGHT_LAYER_SEGMENTS(...) {__VA_ARGS__, RGBLIGHT_END_SEGMENTS}
# define RGBLIGHT_LAYERS_LIST(...) {__VA_ARGS__, NULL}
// Get/set enabled rgblight layers
void rgblight_set_layer_state(uint8_t layer, bool enabled);

5
quantum/secure.c
View file

@ -14,10 +14,7 @@
#endif
#ifndef SECURE_UNLOCK_SEQUENCE
# define SECURE_UNLOCK_SEQUENCE \
{ \
{ 0, 0 } \
}
# define SECURE_UNLOCK_SEQUENCE {{0, 0}}
#endif
static secure_status_t secure_status = SECURE_LOCKED;

2
quantum/split_common/split_util.c
View file

@ -167,7 +167,7 @@ __attribute__((weak)) bool is_keyboard_left_impl(void) {
# pragma message "Faking EE_HANDS for right hand"
const bool should_be_left = false;
# endif
bool is_left = eeconfig_read_handedness();
bool is_left = eeconfig_read_handedness();
if (is_left != should_be_left) {
eeconfig_update_handedness(should_be_left);
}

9
quantum/split_common/transactions.c
View file

@ -73,16 +73,13 @@
#define sizeof_member(type, member) sizeof(((type *)NULL)->member)
#define trans_initiator2target_initializer_cb(member, cb) \
{ sizeof_member(split_shared_memory_t, member), offsetof(split_shared_memory_t, member), 0, 0, cb }
#define trans_initiator2target_initializer_cb(member, cb) {sizeof_member(split_shared_memory_t, member), offsetof(split_shared_memory_t, member), 0, 0, cb}
#define trans_initiator2target_initializer(member) trans_initiator2target_initializer_cb(member, NULL)
#define trans_target2initiator_initializer_cb(member, cb) \
{ 0, 0, sizeof_member(split_shared_memory_t, member), offsetof(split_shared_memory_t, member), cb }
#define trans_target2initiator_initializer_cb(member, cb) {0, 0, sizeof_member(split_shared_memory_t, member), offsetof(split_shared_memory_t, member), cb}
#define trans_target2initiator_initializer(member) trans_target2initiator_initializer_cb(member, NULL)
#define trans_initiator2target_cb(cb) \
{ 0, 0, 0, 0, cb }
#define trans_initiator2target_cb(cb) {0, 0, 0, 0, cb}
#define transport_write(id, data, length) transport_execute_transaction(id, data, length, NULL, 0)
#define transport_read(id, data, length) transport_execute_transaction(id, NULL, 0, data, length)

2
quantum/util.h
View file

@ -24,7 +24,7 @@
* @brief Computes the rounded up result of a division of two integers at
* compile time.
*/
# define CEILING(dividend, divisor) (((dividend) + (divisor)-1) / (divisor))
# define CEILING(dividend, divisor) (((dividend) + (divisor) - 1) / (divisor))
#endif
#if !defined(IS_ARRAY)

4
quantum/via.c
View file

@ -68,7 +68,7 @@
// Can be called in an overriding via_init_kb() to test if keyboard level code usage of
// EEPROM is invalid and use/save defaults.
bool via_eeprom_is_valid(void) {
char * p = QMK_BUILDDATE; // e.g. "2019-11-05-11:29:54"
char *p = QMK_BUILDDATE; // e.g. "2019-11-05-11:29:54"
uint8_t magic0 = ((p[2] & 0x0F) << 4) | (p[3] & 0x0F);
uint8_t magic1 = ((p[5] & 0x0F) << 4) | (p[6] & 0x0F);
uint8_t magic2 = ((p[8] & 0x0F) << 4) | (p[9] & 0x0F);
@ -85,7 +85,7 @@ bool via_eeprom_is_valid(void) {
// Keyboard level code (eg. via_init_kb()) should not call this
void via_eeprom_set_valid(bool valid) {
if (valid) {
char * p = QMK_BUILDDATE; // e.g. "2019-11-05-11:29:54"
char *p = QMK_BUILDDATE; // e.g. "2019-11-05-11:29:54"
uint8_t magic0 = ((p[2] & 0x0F) << 4) | (p[3] & 0x0F);
uint8_t magic1 = ((p[5] & 0x0F) << 4) | (p[6] & 0x0F);
uint8_t magic2 = ((p[8] & 0x0F) << 4) | (p[9] & 0x0F);

6
quantum/wear_leveling/wear_leveling.c
View file

@ -358,7 +358,7 @@ static wear_leveling_status_t wear_leveling_append_raw(backing_store_int_t value
* @return true if consolidation occurred
*/
static wear_leveling_status_t wear_leveling_write_raw_multibyte(uint32_t address, const void *value, size_t length) {
const uint8_t * p = value;
const uint8_t *p = value;
write_log_entry_t log = LOG_ENTRY_MAKE_MULTIBYTE(address, length);
for (size_t i = 0; i < length; ++i) {
log.raw8[3 + i] = p[i];
@ -415,7 +415,7 @@ static wear_leveling_status_t wear_leveling_write_raw_multibyte(uint32_t address
* Handles the actual writing of logical data into the write log section of the backing store.
*/
static wear_leveling_status_t wear_leveling_write_raw(uint32_t address, const void *value, size_t length) {
const uint8_t * p = value;
const uint8_t *p = value;
size_t remaining = length;
wear_leveling_status_t status = WEAR_LEVELING_SUCCESS;
while (remaining > 0) {
@ -555,7 +555,7 @@ static wear_leveling_status_t wear_leveling_playback_log(void) {
if (!ok) {
wl_dprintf("Failed to load from backing store, skipping playback of write log\n");
cancel_playback = true;
status = WEAR_LEVELING_FAILED;
status = WEAR_LEVELING_FAILED;
break;
}
address += (BACKING_STORE_WRITE_SIZE);