tgrosinger/zmk
1
0
Fork 0
Code Actions Packages

lint: add (void) parameter to pass -Wstrict-prototypes

Browse Source 
Note there was one place where a non-strict prototype was actually being used
with an argument, in `zmk_hog_init`. In this case, the actual argument type was
added instead.
This commit is contained in:
Chris Andreae 2023-12-18 22:16:19 +09:00 committed by Pete Johanson
parent 5257cde1f5
commit 7a5155f36e
28 changed files with 117 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
app/include/zmk/activity.h
View File

@ -8,4 +8,4 @@
enum zmk_activity_state { ZMK_ACTIVITY_ACTIVE, ZMK_ACTIVITY_IDLE, ZMK_ACTIVITY_SLEEP };
enum zmk_activity_state zmk_activity_get_state();
enum zmk_activity_state zmk_activity_get_state(void);

12
app/include/zmk/backlight.h
View File

@ -6,12 +6,12 @@
#pragma once
int zmk_backlight_on();
int zmk_backlight_off();
int zmk_backlight_toggle();
bool zmk_backlight_is_on();
int zmk_backlight_on(void);
int zmk_backlight_off(void);
int zmk_backlight_toggle(void);
bool zmk_backlight_is_on(void);
int zmk_backlight_set_brt(uint8_t brightness);
uint8_t zmk_backlight_get_brt();
uint8_t zmk_backlight_get_brt(void);
uint8_t zmk_backlight_calc_brt(int direction);
uint8_t zmk_backlight_calc_brt_cycle();
uint8_t zmk_backlight_calc_brt_cycle(void);

2
app/include/zmk/battery.h
View File

@ -6,4 +6,4 @@
#pragma once
uint8_t zmk_battery_state_of_charge();
uint8_t zmk_battery_state_of_charge(void);

20
app/include/zmk/ble.h
View File

@ -20,21 +20,21 @@
#define ZMK_BLE_PROFILE_COUNT CONFIG_BT_MAX_PAIRED
#endif
int zmk_ble_clear_bonds();
int zmk_ble_prof_next();
int zmk_ble_prof_prev();
int zmk_ble_clear_bonds(void);
int zmk_ble_prof_next(void);
int zmk_ble_prof_prev(void);
int zmk_ble_prof_select(uint8_t index);
int zmk_ble_clear_all_bonds();
int zmk_ble_clear_all_bonds(void);
int zmk_ble_prof_disconnect(uint8_t index);
int zmk_ble_active_profile_index();
int zmk_ble_active_profile_index(void);
int zmk_ble_profile_index(const bt_addr_le_t *addr);
bt_addr_le_t *zmk_ble_active_profile_addr();
bool zmk_ble_active_profile_is_open();
bool zmk_ble_active_profile_is_connected();
char *zmk_ble_active_profile_name();
bt_addr_le_t *zmk_ble_active_profile_addr(void);
bool zmk_ble_active_profile_is_open(void);
bool zmk_ble_active_profile_is_connected(void);
char *zmk_ble_active_profile_name(void);
int zmk_ble_unpair_all();
int zmk_ble_unpair_all(void);
#if IS_ENABLED(CONFIG_ZMK_SPLIT_ROLE_CENTRAL)
int zmk_ble_put_peripheral_addr(const bt_addr_le_t *addr);

6
app/include/zmk/display.h
View File

@ -10,10 +10,10 @@
#pragma once
struct k_work_q *zmk_display_work_q();
struct k_work_q *zmk_display_work_q(void);
bool zmk_display_is_initialized();
int zmk_display_init();
bool zmk_display_is_initialized(void);
int zmk_display_init(void);
/**
* @brief Macro to define a ZMK event listener that handles the thread safety of fetching

16
app/include/zmk/hid.h
View File

@ -252,7 +252,7 @@ struct zmk_hid_mouse_report {
#endif // IS_ENABLED(CONFIG_ZMK_MOUSE)
zmk_mod_flags_t zmk_hid_get_explicit_mods();
zmk_mod_flags_t zmk_hid_get_explicit_mods(void);
int zmk_hid_register_mod(zmk_mod_t modifier);
int zmk_hid_unregister_mod(zmk_mod_t modifier);
bool zmk_hid_mod_is_pressed(zmk_mod_t modifier);
@ -260,18 +260,18 @@ bool zmk_hid_mod_is_pressed(zmk_mod_t modifier);
int zmk_hid_register_mods(zmk_mod_flags_t explicit_modifiers);
int zmk_hid_unregister_mods(zmk_mod_flags_t explicit_modifiers);
int zmk_hid_implicit_modifiers_press(zmk_mod_flags_t implicit_modifiers);
int zmk_hid_implicit_modifiers_release();
int zmk_hid_implicit_modifiers_release(void);
int zmk_hid_masked_modifiers_set(zmk_mod_flags_t masked_modifiers);
int zmk_hid_masked_modifiers_clear();
int zmk_hid_masked_modifiers_clear(void);
int zmk_hid_keyboard_press(zmk_key_t key);
int zmk_hid_keyboard_release(zmk_key_t key);
void zmk_hid_keyboard_clear();
void zmk_hid_keyboard_clear(void);
bool zmk_hid_keyboard_is_pressed(zmk_key_t key);
int zmk_hid_consumer_press(zmk_key_t key);
int zmk_hid_consumer_release(zmk_key_t key);
void zmk_hid_consumer_clear();
void zmk_hid_consumer_clear(void);
bool zmk_hid_consumer_is_pressed(zmk_key_t key);
int zmk_hid_press(uint32_t usage);
@ -283,11 +283,11 @@ int zmk_hid_mouse_button_press(zmk_mouse_button_t button);
int zmk_hid_mouse_button_release(zmk_mouse_button_t button);
int zmk_hid_mouse_buttons_press(zmk_mouse_button_flags_t buttons);
int zmk_hid_mouse_buttons_release(zmk_mouse_button_flags_t buttons);
void zmk_hid_mouse_clear();
void zmk_hid_mouse_clear(void);
#endif // IS_ENABLED(CONFIG_ZMK_MOUSE)
struct zmk_hid_keyboard_report *zmk_hid_get_keyboard_report();
struct zmk_hid_consumer_report *zmk_hid_get_consumer_report();
struct zmk_hid_keyboard_report *zmk_hid_get_keyboard_report(void);
struct zmk_hid_consumer_report *zmk_hid_get_consumer_report(void);
#if IS_ENABLED(CONFIG_ZMK_USB_BOOT)
zmk_hid_boot_report_t *zmk_hid_get_boot_report();

2
app/include/zmk/hog.h
View File

@ -9,7 +9,7 @@
#include <zmk/keys.h>
#include <zmk/hid.h>
int zmk_hog_init();
int zmk_hog_init(const struct device *_arg);
int zmk_hog_send_keyboard_report(struct zmk_hid_keyboard_report_body *body);
int zmk_hog_send_consumer_report(struct zmk_hid_consumer_report_body *body);

6
app/include/zmk/keymap.h
View File

@ -14,10 +14,10 @@
typedef uint32_t zmk_keymap_layers_state_t;
uint8_t zmk_keymap_layer_default();
zmk_keymap_layers_state_t zmk_keymap_layer_state();
uint8_t zmk_keymap_layer_default(void);
zmk_keymap_layers_state_t zmk_keymap_layer_state(void);
bool zmk_keymap_layer_active(uint8_t layer);
uint8_t zmk_keymap_highest_layer_active();
uint8_t zmk_keymap_highest_layer_active(void);
int zmk_keymap_layer_activate(uint8_t layer);
int zmk_keymap_layer_deactivate(uint8_t layer);
int zmk_keymap_layer_toggle(uint8_t layer);

6
app/include/zmk/rgb_underglow.h
View File

@ -12,10 +12,10 @@ struct zmk_led_hsb {
uint8_t b;
};
int zmk_rgb_underglow_toggle();
int zmk_rgb_underglow_toggle(void);
int zmk_rgb_underglow_get_state(bool *state);
int zmk_rgb_underglow_on();
int zmk_rgb_underglow_off();
int zmk_rgb_underglow_on(void);
int zmk_rgb_underglow_off(void);
int zmk_rgb_underglow_cycle_effect(int direction);
int zmk_rgb_underglow_calc_effect(int direction);
int zmk_rgb_underglow_select_effect(int effect);

12
app/include/zmk/usb.h
View File

@ -18,8 +18,12 @@ enum zmk_usb_conn_state {
ZMK_USB_CONN_HID,
};
enum usb_dc_status_code zmk_usb_get_status();
enum zmk_usb_conn_state zmk_usb_get_conn_state();
enum usb_dc_status_code zmk_usb_get_status(void);
enum zmk_usb_conn_state zmk_usb_get_conn_state(void);
static inline bool zmk_usb_is_powered() { return zmk_usb_get_conn_state() != ZMK_USB_CONN_NONE; }
static inline bool zmk_usb_is_hid_ready() { return zmk_usb_get_conn_state() == ZMK_USB_CONN_HID; }
static inline bool zmk_usb_is_powered(void) {
return zmk_usb_get_conn_state() != ZMK_USB_CONN_NONE;
}
static inline bool zmk_usb_is_hid_ready(void) {
return zmk_usb_get_conn_state() == ZMK_USB_CONN_HID;
}

6
app/include/zmk/usb_hid.h
View File

@ -8,9 +8,9 @@
#include <stdint.h>
int zmk_usb_hid_send_keyboard_report();
int zmk_usb_hid_send_consumer_report();
int zmk_usb_hid_send_keyboard_report(void);
int zmk_usb_hid_send_consumer_report(void);
#if IS_ENABLED(CONFIG_ZMK_MOUSE)
int zmk_usb_hid_send_mouse_report();
int zmk_usb_hid_send_mouse_report(void);
#endif // IS_ENABLED(CONFIG_ZMK_MOUSE)
void zmk_usb_hid_set_protocol(uint8_t protocol);

2
app/include/zmk/workqueue.h
View File

@ -1 +1 @@
struct k_work_q *zmk_workqueue_lowprio_work_q();
struct k_work_q *zmk_workqueue_lowprio_work_q(void);

10
app/src/activity.c
View File

@ -24,7 +24,7 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
#include <zmk/usb.h>
#endif
bool is_usb_power_present() {
bool is_usb_power_present(void) {
#if IS_ENABLED(CONFIG_USB_DEVICE_STACK)
return zmk_usb_is_powered();
#else
@ -42,7 +42,7 @@ static uint32_t activity_last_uptime;
#define MAX_SLEEP_MS CONFIG_ZMK_IDLE_SLEEP_TIMEOUT
#endif
int raise_event() {
int raise_event(void) {
return ZMK_EVENT_RAISE(new_zmk_activity_state_changed(
(struct zmk_activity_state_changed){.state = activity_state}));
}
@ -55,7 +55,7 @@ int set_state(enum zmk_activity_state state) {
return raise_event();
}
enum zmk_activity_state zmk_activity_get_state() { return activity_state; }
enum zmk_activity_state zmk_activity_get_state(void) { return activity_state; }
int activity_event_listener(const zmk_event_t *eh) {
activity_last_uptime = k_uptime_get();
@ -80,11 +80,11 @@ void activity_work_handler(struct k_work *work) {
K_WORK_DEFINE(activity_work, activity_work_handler);
void activity_expiry_function() { k_work_submit(&activity_work); }
void activity_expiry_function(void) { k_work_submit(&activity_work); }
K_TIMER_DEFINE(activity_timer, activity_expiry_function, NULL);
int activity_init() {
int activity_init(void) {
activity_last_uptime = k_uptime_get();
k_timer_start(&activity_timer, K_SECONDS(1), K_SECONDS(1));

16
app/src/backlight.c
View File

@ -42,7 +42,7 @@ struct backlight_state {
static struct backlight_state state = {.brightness = CONFIG_ZMK_BACKLIGHT_BRT_START,
.on = IS_ENABLED(CONFIG_ZMK_BACKLIGHT_ON_START)};
static int zmk_backlight_update() {
static int zmk_backlight_update(void) {
uint8_t brt = zmk_backlight_get_brt();
LOG_DBG("Update backlight brightness: %d%%", brt);
@ -98,7 +98,7 @@ static int zmk_backlight_init(const struct device *_arg) {
return zmk_backlight_update();
}
static int zmk_backlight_update_and_save() {
static int zmk_backlight_update_and_save(void) {
int rc = zmk_backlight_update();
if (rc != 0) {
return rc;
@ -112,20 +112,20 @@ static int zmk_backlight_update_and_save() {
#endif
}
int zmk_backlight_on() {
int zmk_backlight_on(void) {
state.brightness = MAX(state.brightness, CONFIG_ZMK_BACKLIGHT_BRT_STEP);
state.on = true;
return zmk_backlight_update_and_save();
}
int zmk_backlight_off() {
int zmk_backlight_off(void) {
state.on = false;
return zmk_backlight_update_and_save();
}
int zmk_backlight_toggle() { return state.on ? zmk_backlight_off() : zmk_backlight_on(); }
int zmk_backlight_toggle(void) { return state.on ? zmk_backlight_off() : zmk_backlight_on(); }
bool zmk_backlight_is_on() { return state.on; }
bool zmk_backlight_is_on(void) { return state.on; }
int zmk_backlight_set_brt(uint8_t brightness) {
state.brightness = MIN(brightness, BRT_MAX);
@ -133,14 +133,14 @@ int zmk_backlight_set_brt(uint8_t brightness) {
return zmk_backlight_update_and_save();
}
uint8_t zmk_backlight_get_brt() { return state.on ? state.brightness : 0; }
uint8_t zmk_backlight_get_brt(void) { return state.on ? state.brightness : 0; }
uint8_t zmk_backlight_calc_brt(int direction) {
int brt = state.brightness + (direction * CONFIG_ZMK_BACKLIGHT_BRT_STEP);
return CLAMP(brt, 0, BRT_MAX);
}
uint8_t zmk_backlight_calc_brt_cycle() {
uint8_t zmk_backlight_calc_brt_cycle(void) {
if (state.brightness == BRT_MAX) {
return 0;
} else {

2
app/src/battery.c
View File

@ -24,7 +24,7 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
static uint8_t last_state_of_charge = 0;
uint8_t zmk_battery_state_of_charge() { return last_state_of_charge; }
uint8_t zmk_battery_state_of_charge(void) { return last_state_of_charge; }
#if DT_HAS_CHOSEN(zmk_battery)
static const struct device *const battery = DEVICE_DT_GET(DT_CHOSEN(zmk_battery));

24
app/src/ble.c
View File

@ -82,7 +82,7 @@ static bt_addr_le_t peripheral_addrs[ZMK_SPLIT_BLE_PERIPHERAL_COUNT];
#endif /* IS_ENABLED(CONFIG_ZMK_SPLIT_ROLE_CENTRAL) */
static void raise_profile_changed_event() {
static void raise_profile_changed_event(void) {
ZMK_EVENT_RAISE(new_zmk_ble_active_profile_changed((struct zmk_ble_active_profile_changed){
.index = active_profile, .profile = &profiles[active_profile]}));
}
@ -93,7 +93,7 @@ static void raise_profile_changed_event_callback(struct k_work *work) {
K_WORK_DEFINE(raise_profile_changed_event_work, raise_profile_changed_event_callback);
bool zmk_ble_active_profile_is_open() {
bool zmk_ble_active_profile_is_open(void) {
return !bt_addr_le_cmp(&profiles[active_profile].peer, BT_ADDR_LE_ANY);
}
@ -112,7 +112,7 @@ void set_profile_address(uint8_t index, const bt_addr_le_t *addr) {
k_work_submit(&raise_profile_changed_event_work);
}
bool zmk_ble_active_profile_is_connected() {
bool zmk_ble_active_profile_is_connected(void) {
struct bt_conn *conn;
struct bt_conn_info info;
bt_addr_le_t *addr = zmk_ble_active_profile_addr();
@ -161,7 +161,7 @@ bool zmk_ble_active_profile_is_connected() {
} \
advertising_status = ZMK_ADV_CONN;
int update_advertising() {
int update_advertising(void) {
int err = 0;
bt_addr_le_t *addr;
struct bt_conn *conn;
@ -210,7 +210,7 @@ static void update_advertising_callback(struct k_work *work) { update_advertisin
K_WORK_DEFINE(update_advertising_work, update_advertising_callback);
int zmk_ble_clear_bonds() {
int zmk_ble_clear_bonds(void) {
LOG_DBG("");
if (bt_addr_le_cmp(&profiles[active_profile].peer, BT_ADDR_LE_ANY)) {
@ -224,7 +224,7 @@ int zmk_ble_clear_bonds() {
return 0;
};
int zmk_ble_clear_all_bonds() {
int zmk_ble_clear_all_bonds(void) {
LOG_DBG("zmk_ble_clear_all_bonds()");
// Unpair all profiles
@ -241,7 +241,7 @@ int zmk_ble_clear_all_bonds() {
return 0;
};
int zmk_ble_active_profile_index() { return active_profile; }
int zmk_ble_active_profile_index(void) { return active_profile; }
int zmk_ble_profile_index(const bt_addr_le_t *addr) {
for (int i = 0; i < ZMK_BLE_PROFILE_COUNT; i++) {
@ -260,7 +260,7 @@ static void ble_save_profile_work(struct k_work *work) {
static struct k_work_delayable ble_save_work;
#endif
static int ble_save_profile() {
static int ble_save_profile(void) {
#if IS_ENABLED(CONFIG_SETTINGS)
return k_work_reschedule(&ble_save_work, K_MSEC(CONFIG_ZMK_SETTINGS_SAVE_DEBOUNCE));
#else
@ -288,12 +288,12 @@ int zmk_ble_prof_select(uint8_t index) {
return 0;
};
int zmk_ble_prof_next() {
int zmk_ble_prof_next(void) {
LOG_DBG("");
return zmk_ble_prof_select((active_profile + 1) % ZMK_BLE_PROFILE_COUNT);
};
int zmk_ble_prof_prev() {
int zmk_ble_prof_prev(void) {
LOG_DBG("");
return zmk_ble_prof_select((active_profile + ZMK_BLE_PROFILE_COUNT - 1) %
ZMK_BLE_PROFILE_COUNT);
@ -320,9 +320,9 @@ int zmk_ble_prof_disconnect(uint8_t index) {
return result;
}
bt_addr_le_t *zmk_ble_active_profile_addr() { return &profiles[active_profile].peer; }
bt_addr_le_t *zmk_ble_active_profile_addr(void) { return &profiles[active_profile].peer; }
char *zmk_ble_active_profile_name() { return profiles[active_profile].name; }
char *zmk_ble_active_profile_name(void) { return profiles[active_profile].name; }
#if IS_ENABLED(CONFIG_ZMK_SPLIT_ROLE_CENTRAL)

2
app/src/endpoints.c
View File

@ -322,7 +322,7 @@ static int zmk_endpoints_init(const struct device *_arg) {
return 0;
}
static void disconnect_current_endpoint() {
static void disconnect_current_endpoint(void) {
zmk_hid_keyboard_clear();
zmk_hid_consumer_clear();
#if IS_ENABLED(CONFIG_ZMK_MOUSE)

2
app/src/ext_power_generic.c
View File

@ -46,7 +46,7 @@ static void ext_power_save_state_work(struct k_work *work) {
static struct k_work_delayable ext_power_save_work;
#endif
int ext_power_save_state() {
int ext_power_save_state(void) {
#if IS_ENABLED(CONFIG_SETTINGS)
int ret = k_work_reschedule(&ext_power_save_work, K_MSEC(CONFIG_ZMK_SETTINGS_SAVE_DEBOUNCE));
return MIN(ret, 0);

26
app/src/hid.c
View File

@ -47,7 +47,7 @@ static zmk_mod_flags_t masked_modifiers = 0;
#define GET_MODIFIERS (keyboard_report.body.modifiers)
zmk_mod_flags_t zmk_hid_get_explicit_mods() { return explicit_modifiers; }
zmk_mod_flags_t zmk_hid_get_explicit_mods(void) { return explicit_modifiers; }
int zmk_hid_register_mod(zmk_mod_t modifier) {
explicit_modifier_counts[modifier]++;
@ -117,7 +117,7 @@ static zmk_hid_boot_report_t *boot_report_rollover(uint8_t modifiers) {
#define TOGGLE_KEYBOARD(code, val) WRITE_BIT(keyboard_report.body.keys[code / 8], code % 8, val)
#if IS_ENABLED(CONFIG_ZMK_USB_BOOT)
zmk_hid_boot_report_t *zmk_hid_get_boot_report() {
zmk_hid_boot_report_t *zmk_hid_get_boot_report(void) {
if (keys_held > HID_BOOT_KEY_LEN) {
return boot_report_rollover(keyboard_report.body.modifiers);
}
@ -187,7 +187,7 @@ static inline bool check_keyboard_usage(zmk_key_t usage) {
}
#if IS_ENABLED(CONFIG_ZMK_USB_BOOT)
zmk_hid_boot_report_t *zmk_hid_get_boot_report() {
zmk_hid_boot_report_t *zmk_hid_get_boot_report(void) {
if (keys_held > HID_BOOT_KEY_LEN) {
return boot_report_rollover(keyboard_report.body.modifiers);
}
@ -268,7 +268,7 @@ int zmk_hid_implicit_modifiers_press(zmk_mod_flags_t new_implicit_modifiers) {
return current == GET_MODIFIERS ? 0 : 1;
}
int zmk_hid_implicit_modifiers_release() {
int zmk_hid_implicit_modifiers_release(void) {
implicit_modifiers = 0;
zmk_mod_flags_t current = GET_MODIFIERS;
SET_MODIFIERS(explicit_modifiers);
@ -282,7 +282,7 @@ int zmk_hid_masked_modifiers_set(zmk_mod_flags_t new_masked_modifiers) {
return current == GET_MODIFIERS ? 0 : 1;
}
int zmk_hid_masked_modifiers_clear() {
int zmk_hid_masked_modifiers_clear(void) {
masked_modifiers = 0;
zmk_mod_flags_t current = GET_MODIFIERS;
SET_MODIFIERS(explicit_modifiers);
@ -312,7 +312,9 @@ bool zmk_hid_keyboard_is_pressed(zmk_key_t code) {
return check_keyboard_usage(code);
}
void zmk_hid_keyboard_clear() { memset(&keyboard_report.body, 0, sizeof(keyboard_report.body)); }
void zmk_hid_keyboard_clear(void) {
memset(&keyboard_report.body, 0, sizeof(keyboard_report.body));
}
int zmk_hid_consumer_press(zmk_key_t code) {
TOGGLE_CONSUMER(0U, code);
@ -324,7 +326,9 @@ int zmk_hid_consumer_release(zmk_key_t code) {
return 0;
};
void zmk_hid_consumer_clear() { memset(&consumer_report.body, 0, sizeof(consumer_report.body)); }
void zmk_hid_consumer_clear(void) {
memset(&consumer_report.body, 0, sizeof(consumer_report.body));
}
bool zmk_hid_consumer_is_pressed(zmk_key_t key) {
for (int idx = 0; idx < CONFIG_ZMK_HID_CONSUMER_REPORT_SIZE; idx++) {
@ -426,21 +430,21 @@ int zmk_hid_mouse_buttons_release(zmk_mouse_button_flags_t buttons) {
}
return 0;
}
void zmk_hid_mouse_clear() { memset(&mouse_report.body, 0, sizeof(mouse_report.body)); }
void zmk_hid_mouse_clear(void) { memset(&mouse_report.body, 0, sizeof(mouse_report.body)); }
#endif // IS_ENABLED(CONFIG_ZMK_MOUSE)
struct zmk_hid_keyboard_report *zmk_hid_get_keyboard_report() {
struct zmk_hid_keyboard_report *zmk_hid_get_keyboard_report(void) {
return &keyboard_report;
}
struct zmk_hid_consumer_report *zmk_hid_get_consumer_report() {
struct zmk_hid_consumer_report *zmk_hid_get_consumer_report(void) {
return &consumer_report;
}
#if IS_ENABLED(CONFIG_ZMK_MOUSE)
struct zmk_hid_mouse_report *zmk_hid_get_mouse_report() {
struct zmk_hid_mouse_report *zmk_hid_get_mouse_report(void) {
return &mouse_report;
}

2
app/src/hog.c
View File

@ -220,7 +220,7 @@ BT_GATT_SERVICE_DEFINE(
BT_GATT_CHARACTERISTIC(BT_UUID_HIDS_CTRL_POINT, BT_GATT_CHRC_WRITE_WITHOUT_RESP,
BT_GATT_PERM_WRITE, NULL, write_ctrl_point, &ctrl_point));
struct bt_conn *destination_connection() {
struct bt_conn *destination_connection(void) {
struct bt_conn *conn;
bt_addr_le_t *addr = zmk_ble_active_profile_addr();
LOG_DBG("Address pointer %p", addr);

6
app/src/keymap.c
View File

@ -96,9 +96,9 @@ static inline int set_layer_state(uint8_t layer, bool state) {
return 0;
}
uint8_t zmk_keymap_layer_default() { return _zmk_keymap_layer_default; }
uint8_t zmk_keymap_layer_default(void) { return _zmk_keymap_layer_default; }
zmk_keymap_layers_state_t zmk_keymap_layer_state() { return _zmk_keymap_layer_state; }
zmk_keymap_layers_state_t zmk_keymap_layer_state(void) { return _zmk_keymap_layer_state; }
bool zmk_keymap_layer_active_with_state(uint8_t layer, zmk_keymap_layers_state_t state_to_test) {
// The default layer is assumed to be ALWAYS ACTIVE so we include an || here to ensure nobody
@ -110,7 +110,7 @@ bool zmk_keymap_layer_active(uint8_t layer) {
return zmk_keymap_layer_active_with_state(layer, _zmk_keymap_layer_state);
};
uint8_t zmk_keymap_highest_layer_active() {
uint8_t zmk_keymap_highest_layer_active(void) {
for (uint8_t layer = ZMK_KEYMAP_LAYERS_LEN - 1; layer > 0; layer--) {
if (zmk_keymap_layer_active(layer)) {
return layer;

18
app/src/rgb_underglow.c
View File

@ -130,13 +130,13 @@ static struct led_rgb hsb_to_rgb(struct zmk_led_hsb hsb) {
return rgb;
}
static void zmk_rgb_underglow_effect_solid() {
static void zmk_rgb_underglow_effect_solid(void) {
for (int i = 0; i < STRIP_NUM_PIXELS; i++) {
pixels[i] = hsb_to_rgb(hsb_scale_min_max(state.color));
}
}
static void zmk_rgb_underglow_effect_breathe() {
static void zmk_rgb_underglow_effect_breathe(void) {
for (int i = 0; i < STRIP_NUM_PIXELS; i++) {
struct zmk_led_hsb hsb = state.color;
hsb.b = abs(state.animation_step - 1200) / 12;
@ -151,7 +151,7 @@ static void zmk_rgb_underglow_effect_breathe() {
}
}
static void zmk_rgb_underglow_effect_spectrum() {
static void zmk_rgb_underglow_effect_spectrum(void) {
for (int i = 0; i < STRIP_NUM_PIXELS; i++) {
struct zmk_led_hsb hsb = state.color;
hsb.h = state.animation_step;
@ -163,7 +163,7 @@ static void zmk_rgb_underglow_effect_spectrum() {
state.animation_step = state.animation_step % HUE_MAX;
}
static void zmk_rgb_underglow_effect_swirl() {
static void zmk_rgb_underglow_effect_swirl(void) {
for (int i = 0; i < STRIP_NUM_PIXELS; i++) {
struct zmk_led_hsb hsb = state.color;
hsb.h = (HUE_MAX / STRIP_NUM_PIXELS * i + state.animation_step) % HUE_MAX;
@ -232,7 +232,7 @@ static int rgb_settings_set(const char *name, size_t len, settings_read_cb read_
struct settings_handler rgb_conf = {.name = "rgb/underglow", .h_set = rgb_settings_set};
static void zmk_rgb_underglow_save_state_work() {
static void zmk_rgb_underglow_save_state_work(void) {
settings_save_one("rgb/underglow/state", &state, sizeof(state));
}
@ -286,7 +286,7 @@ static int zmk_rgb_underglow_init(const struct device *_arg) {
return 0;
}
int zmk_rgb_underglow_save_state() {
int zmk_rgb_underglow_save_state(void) {
#if IS_ENABLED(CONFIG_SETTINGS)
int ret = k_work_reschedule(&underglow_save_work, K_MSEC(CONFIG_ZMK_SETTINGS_SAVE_DEBOUNCE));
return MIN(ret, 0);
@ -303,7 +303,7 @@ int zmk_rgb_underglow_get_state(bool *on_off) {
return 0;
}
int zmk_rgb_underglow_on() {
int zmk_rgb_underglow_on(void) {
if (!led_strip)
return -ENODEV;
@ -333,7 +333,7 @@ static void zmk_rgb_underglow_off_handler(struct k_work *work) {
K_WORK_DEFINE(underglow_off_work, zmk_rgb_underglow_off_handler);
int zmk_rgb_underglow_off() {
int zmk_rgb_underglow_off(void) {
if (!led_strip)
return -ENODEV;
@ -376,7 +376,7 @@ int zmk_rgb_underglow_cycle_effect(int direction) {
return zmk_rgb_underglow_select_effect(zmk_rgb_underglow_calc_effect(direction));
}
int zmk_rgb_underglow_toggle() {
int zmk_rgb_underglow_toggle(void) {
return state.on ? zmk_rgb_underglow_off() : zmk_rgb_underglow_on();
}

2
app/src/split/bluetooth/central.c
View File

@ -561,7 +561,7 @@ static void split_central_process_connection(struct bt_conn *conn) {
start_scanning();
}
static int stop_scanning() {
static int stop_scanning(void) {
LOG_DBG("Stopping peripheral scanning");
is_scanning = false;

4
app/src/split/bluetooth/peripheral.c
View File

@ -142,9 +142,9 @@ static struct bt_conn_auth_info_cb zmk_peripheral_ble_auth_info_cb = {
.pairing_complete = auth_pairing_complete,
};
bool zmk_split_bt_peripheral_is_connected() { return is_connected; }
bool zmk_split_bt_peripheral_is_connected(void) { return is_connected; }
bool zmk_split_bt_peripheral_is_bonded() { return is_bonded; }
bool zmk_split_bt_peripheral_is_bonded(void) { return is_bonded; }
static int zmk_peripheral_ble_init(const struct device *_arg) {
int err = bt_enable(NULL);

4
app/src/usb.c
View File

@ -28,9 +28,9 @@ static void raise_usb_status_changed_event(struct k_work *_work) {
K_WORK_DEFINE(usb_status_notifier_work, raise_usb_status_changed_event);
enum usb_dc_status_code zmk_usb_get_status() { return usb_status; }
enum usb_dc_status_code zmk_usb_get_status(void) { return usb_status; }
enum zmk_usb_conn_state zmk_usb_get_conn_state() {
enum zmk_usb_conn_state zmk_usb_get_conn_state(void) {
LOG_DBG("state: %d", usb_status);
switch (usb_status) {
case USB_DC_SUSPEND:

4
app/src/usb_hid.c
View File

@ -147,13 +147,13 @@ static int zmk_usb_hid_send_report(const uint8_t *report, size_t len) {
}
}
int zmk_usb_hid_send_keyboard_report() {
int zmk_usb_hid_send_keyboard_report(void) {
size_t len;
uint8_t *report = get_keyboard_report(&len);
return zmk_usb_hid_send_report(report, len);
}
int zmk_usb_hid_send_consumer_report() {
int zmk_usb_hid_send_consumer_report(void) {
#if IS_ENABLED(CONFIG_ZMK_USB_BOOT)
if (hid_protocol == HID_PROTOCOL_BOOT) {
return -ENOTSUP;

4
app/src/workqueue.c
View File

@ -13,11 +13,11 @@ K_THREAD_STACK_DEFINE(lowprio_q_stack, CONFIG_ZMK_LOW_PRIORITY_THREAD_STACK_SIZE
static struct k_work_q lowprio_work_q;
struct k_work_q *zmk_workqueue_lowprio_work_q() {
struct k_work_q *zmk_workqueue_lowprio_work_q(void) {
return &lowprio_work_q;
}
static int workqueue_init() {
static int workqueue_init(void) {
static const struct k_work_queue_config queue_config = {.name = "Low Priority Work Queue"};
k_work_queue_start(&lowprio_work_q, lowprio_q_stack, K_THREAD_STACK_SIZEOF(lowprio_q_stack),
CONFIG_ZMK_LOW_PRIORITY_THREAD_PRIORITY, &queue_config);

6
app/src/wpm.c
View File

@ -32,7 +32,7 @@ static uint8_t last_wpm_state;
static uint8_t wpm_update_counter;
static uint32_t key_pressed_count;
int zmk_wpm_get_state() { return wpm_state; }
int zmk_wpm_get_state(void) { return wpm_state; }
int wpm_event_listener(const zmk_event_t *eh) {
const struct zmk_keycode_state_changed *ev = as_zmk_keycode_state_changed(eh);
@ -68,11 +68,11 @@ void wpm_work_handler(struct k_work *work) {
K_WORK_DEFINE(wpm_work, wpm_work_handler);
void wpm_expiry_function() { k_work_submit(&wpm_work); }
void wpm_expiry_function(void) { k_work_submit(&wpm_work); }
K_TIMER_DEFINE(wpm_timer, wpm_expiry_function, NULL);
int wpm_init() {
int wpm_init(void) {
wpm_state = 0;
wpm_update_counter = 0;
k_timer_start(&wpm_timer, K_SECONDS(WPM_UPDATE_INTERVAL_SECONDS),