pwarren/zmk_mf68
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

refactor(app): replace struct device * with const struct device *

Browse source 
Replaced with RegExp: /(?<!const )(struct device \*)/g

See: https://docs.zephyrproject.org/latest/releases/release-notes-2.4.html
PR: #467
This commit is contained in:
innovaker 2020-12-10 19:31:51 +00:00 committed by Pete Johanson
parent 1411092a7b
commit 00ca0d2f1c
41 changed files with 172 additions and 163 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
app/boards/arm/dz60rgb/pinmux.c
View file

@ -56,7 +56,7 @@ static const struct pin_config pinconf[] = {
#endif #endif
}; };
static int pinmux_stm32_init(struct device *port) { static int pinmux_stm32_init(const struct device *port) {
ARG_UNUSED(port); ARG_UNUSED(port);
stm32_setup_pins(pinconf, ARRAY_SIZE(pinconf)); stm32_setup_pins(pinconf, ARRAY_SIZE(pinconf));

4
app/boards/arm/nrfmicro/pinmux.c
View file

@ -11,11 +11,11 @@
#include <sys/sys_io.h> #include <sys/sys_io.h>
#include <devicetree.h> #include <devicetree.h>
static int pinmux_nrfmicro_init(struct device *port) { static int pinmux_nrfmicro_init(const struct device *port) {
ARG_UNUSED(port); ARG_UNUSED(port);
#if CONFIG_BOARD_NRFMICRO_13 #if CONFIG_BOARD_NRFMICRO_13
struct device *p0 = device_get_binding("GPIO_0"); const struct device *p0 = device_get_binding("GPIO_0");
#if CONFIG_BOARD_NRFMICRO_CHARGER #if CONFIG_BOARD_NRFMICRO_CHARGER
gpio_pin_configure(p0, 5, GPIO_OUTPUT); gpio_pin_configure(p0, 5, GPIO_OUTPUT);
gpio_pin_set(p0, 5, 0); gpio_pin_set(p0, 5, 0);

2
app/boards/arm/planck/pinmux.c
View file

@ -56,7 +56,7 @@ static const struct pin_config pinconf[] = {
#endif /* CONFIG_CAN_1 */ #endif /* CONFIG_CAN_1 */
}; };
static int pinmux_stm32_init(struct device *port) { static int pinmux_stm32_init(const struct device *port) {
ARG_UNUSED(port); ARG_UNUSED(port);
stm32_setup_pins(pinconf, ARRAY_SIZE(pinconf)); stm32_setup_pins(pinconf, ARRAY_SIZE(pinconf));

2
app/boards/arm/proton_c/pinmux.c
View file

@ -56,7 +56,7 @@ static const struct pin_config pinconf[] = {
#endif #endif
}; };
static int pinmux_stm32_init(struct device *port) { static int pinmux_stm32_init(const struct device *port) {
ARG_UNUSED(port); ARG_UNUSED(port);
stm32_setup_pins(pinconf, ARRAY_SIZE(pinconf)); stm32_setup_pins(pinconf, ARRAY_SIZE(pinconf));

16
app/drivers/kscan/kscan_composite.c
View file

@ -34,10 +34,10 @@ struct kscan_composite_config {};
struct kscan_composite_data { struct kscan_composite_data {
kscan_callback_t callback; kscan_callback_t callback;
struct device *dev; const struct device *dev;
}; };
static int kscan_composite_enable_callback(struct device *dev) { static int kscan_composite_enable_callback(const struct device *dev) {
for (int i = 0; i < ARRAY_SIZE(kscan_composite_children); i++) { for (int i = 0; i < ARRAY_SIZE(kscan_composite_children); i++) {
const struct kscan_composite_child_config *cfg = &kscan_composite_children[i]; const struct kscan_composite_child_config *cfg = &kscan_composite_children[i];
@ -46,7 +46,7 @@ static int kscan_composite_enable_callback(struct device *dev) {
return 0; return 0;
} }
static int kscan_composite_disable_callback(struct device *dev) { static int kscan_composite_disable_callback(const struct device *dev) {
for (int i = 0; i < ARRAY_SIZE(kscan_composite_children); i++) { for (int i = 0; i < ARRAY_SIZE(kscan_composite_children); i++) {
const struct kscan_composite_child_config *cfg = &kscan_composite_children[i]; const struct kscan_composite_child_config *cfg = &kscan_composite_children[i];
@ -55,10 +55,10 @@ static int kscan_composite_disable_callback(struct device *dev) {
return 0; return 0;
} }
static void kscan_composite_child_callback(struct device *child_dev, uint32_t row, uint32_t column, static void kscan_composite_child_callback(const struct device *child_dev, uint32_t row,
bool pressed) { uint32_t column, bool pressed) {
// TODO: Ideally we can get this passed into our callback! // TODO: Ideally we can get this passed into our callback!
struct device *dev = device_get_binding(DT_INST_LABEL(0)); const struct device *dev = device_get_binding(DT_INST_LABEL(0));
struct kscan_composite_data *data = dev->data; struct kscan_composite_data *data = dev->data;
for (int i = 0; i < ARRAY_SIZE(kscan_composite_children); i++) { for (int i = 0; i < ARRAY_SIZE(kscan_composite_children); i++) {
@ -72,7 +72,7 @@ static void kscan_composite_child_callback(struct device *child_dev, uint32_t ro
} }
} }
static int kscan_composite_configure(struct device *dev, kscan_callback_t callback) { static int kscan_composite_configure(const struct device *dev, kscan_callback_t callback) {
struct kscan_composite_data *data = dev->data; struct kscan_composite_data *data = dev->data;
if (!callback) { if (!callback) {
@ -90,7 +90,7 @@ static int kscan_composite_configure(struct device *dev, kscan_callback_t callba
return 0; return 0;
} }
static int kscan_composite_init(struct device *dev) { static int kscan_composite_init(const struct device *dev) {
struct kscan_composite_data *data = dev->data; struct kscan_composite_data *data = dev->data;
data->dev = dev; data->dev = dev;

35
app/drivers/kscan/kscan_gpio_demux.c
View file

@ -49,7 +49,7 @@ struct kscan_gpio_item_config {
struct kscan_gpio_irq_callback_##n { \ struct kscan_gpio_irq_callback_##n { \
struct CHECK_DEBOUNCE_CFG(n, (k_work), (k_delayed_work)) * work; \ struct CHECK_DEBOUNCE_CFG(n, (k_work), (k_delayed_work)) * work; \
struct gpio_callback callback; \ struct gpio_callback callback; \
struct device *dev; \ const struct device *dev; \
}; \ }; \
\ \
struct kscan_gpio_config_##n { \ struct kscan_gpio_config_##n { \
@ -62,30 +62,31 @@ struct kscan_gpio_item_config {
struct k_timer poll_timer; \ struct k_timer poll_timer; \
struct CHECK_DEBOUNCE_CFG(n, (k_work), (k_delayed_work)) work; \ struct CHECK_DEBOUNCE_CFG(n, (k_work), (k_delayed_work)) work; \
bool matrix_state[INST_MATRIX_INPUTS(n)][INST_MATRIX_OUTPUTS(n)]; \ bool matrix_state[INST_MATRIX_INPUTS(n)][INST_MATRIX_OUTPUTS(n)]; \
struct device *rows[INST_MATRIX_INPUTS(n)]; \ const struct device *rows[INST_MATRIX_INPUTS(n)]; \
struct device *cols[INST_MATRIX_OUTPUTS(n)]; \ const struct device *cols[INST_MATRIX_OUTPUTS(n)]; \
struct device *dev; \ const struct device *dev; \
}; \ }; \
/* IO/GPIO SETUP */ \ /* IO/GPIO SETUP */ \
/* gpio_input_devices are PHYSICAL IO devices */ \ /* gpio_input_devices are PHYSICAL IO devices */ \
static struct device **kscan_gpio_input_devices_##n(struct device *dev) { \ static const struct device **kscan_gpio_input_devices_##n(const struct device *dev) { \
struct kscan_gpio_data_##n *data = dev->data; \ struct kscan_gpio_data_##n *data = dev->data; \
return data->rows; \ return data->rows; \
} \ } \
\ \
static const struct kscan_gpio_item_config *kscan_gpio_input_configs_##n(struct device *dev) { \ static const struct kscan_gpio_item_config *kscan_gpio_input_configs_##n( \
const struct device *dev) { \
const struct kscan_gpio_config_##n *cfg = dev->config; \ const struct kscan_gpio_config_##n *cfg = dev->config; \
return cfg->rows; \ return cfg->rows; \
} \ } \
\ \
/* gpio_output_devices are PHYSICAL IO devices */ \ /* gpio_output_devices are PHYSICAL IO devices */ \
static struct device **kscan_gpio_output_devices_##n(struct device *dev) { \ static const struct device **kscan_gpio_output_devices_##n(const struct device *dev) { \
struct kscan_gpio_data_##n *data = dev->data; \ struct kscan_gpio_data_##n *data = dev->data; \
return data->cols; \ return data->cols; \
} \ } \
\ \
static const struct kscan_gpio_item_config *kscan_gpio_output_configs_##n( \ static const struct kscan_gpio_item_config *kscan_gpio_output_configs_##n( \
struct device *dev) { \ const struct device *dev) { \
const struct kscan_gpio_config_##n *cfg = dev->config; \ const struct kscan_gpio_config_##n *cfg = dev->config; \
/* If row2col, rows = outputs & cols = inputs */ \ /* If row2col, rows = outputs & cols = inputs */ \
return cfg->cols; \ return cfg->cols; \
@ -99,7 +100,7 @@ struct kscan_gpio_item_config {
\ \
/* Read the state of the input GPIOs */ \ /* Read the state of the input GPIOs */ \
/* This is the core matrix_scan func */ \ /* This is the core matrix_scan func */ \
static int kscan_gpio_read_##n(struct device *dev) { \ static int kscan_gpio_read_##n(const struct device *dev) { \
bool submit_follow_up_read = false; \ bool submit_follow_up_read = false; \
struct kscan_gpio_data_##n *data = dev->data; \ struct kscan_gpio_data_##n *data = dev->data; \
static bool read_state[INST_MATRIX_INPUTS(n)][INST_MATRIX_OUTPUTS(n)]; \ static bool read_state[INST_MATRIX_INPUTS(n)][INST_MATRIX_OUTPUTS(n)]; \
@ -107,7 +108,7 @@ struct kscan_gpio_item_config {
/* Iterate over bits and set GPIOs accordingly */ \ /* Iterate over bits and set GPIOs accordingly */ \
for (uint8_t bit = 0; bit < INST_DEMUX_GPIOS(n); bit++) { \ for (uint8_t bit = 0; bit < INST_DEMUX_GPIOS(n); bit++) { \
uint8_t state = (o & (0b1 << bit)) >> bit; \ uint8_t state = (o & (0b1 << bit)) >> bit; \
struct device *out_dev = kscan_gpio_output_devices_##n(dev)[bit]; \ const struct device *out_dev = kscan_gpio_output_devices_##n(dev)[bit]; \
const struct kscan_gpio_item_config *out_cfg = \ const struct kscan_gpio_item_config *out_cfg = \
&kscan_gpio_output_configs_##n(dev)[bit]; \ &kscan_gpio_output_configs_##n(dev)[bit]; \
gpio_pin_set(out_dev, out_cfg->pin, state); \ gpio_pin_set(out_dev, out_cfg->pin, state); \
@ -115,7 +116,7 @@ struct kscan_gpio_item_config {
\ \
for (int i = 0; i < INST_MATRIX_INPUTS(n); i++) { \ for (int i = 0; i < INST_MATRIX_INPUTS(n); i++) { \
/* Get the input device (port) */ \ /* Get the input device (port) */ \
struct device *in_dev = kscan_gpio_input_devices_##n(dev)[i]; \ const struct device *in_dev = kscan_gpio_input_devices_##n(dev)[i]; \
/* Get the input device config (pin) */ \ /* Get the input device config (pin) */ \
const struct kscan_gpio_item_config *in_cfg = \ const struct kscan_gpio_item_config *in_cfg = \
&kscan_gpio_input_configs_##n(dev)[i]; \ &kscan_gpio_input_configs_##n(dev)[i]; \
@ -151,7 +152,7 @@ struct kscan_gpio_item_config {
.rows = {[INST_MATRIX_INPUTS(n) - 1] = NULL}, .cols = {[INST_DEMUX_GPIOS(n) - 1] = NULL}}; \ .rows = {[INST_MATRIX_INPUTS(n) - 1] = NULL}, .cols = {[INST_DEMUX_GPIOS(n) - 1] = NULL}}; \
\ \
/* KSCAN API configure function */ \ /* KSCAN API configure function */ \
static int kscan_gpio_configure_##n(struct device *dev, kscan_callback_t callback) { \ static int kscan_gpio_configure_##n(const struct device *dev, kscan_callback_t callback) { \
LOG_DBG("KSCAN API configure"); \ LOG_DBG("KSCAN API configure"); \
struct kscan_gpio_data_##n *data = dev->data; \ struct kscan_gpio_data_##n *data = dev->data; \
if (!callback) { \ if (!callback) { \
@ -163,7 +164,7 @@ struct kscan_gpio_item_config {
}; \ }; \
\ \
/* KSCAN API enable function */ \ /* KSCAN API enable function */ \
static int kscan_gpio_enable_##n(struct device *dev) { \ static int kscan_gpio_enable_##n(const struct device *dev) { \
LOG_DBG("KSCAN API enable"); \ LOG_DBG("KSCAN API enable"); \
struct kscan_gpio_data_##n *data = dev->data; \ struct kscan_gpio_data_##n *data = dev->data; \
/* TODO: we might want a follow up to hook into the sleep state hooks in Zephyr, */ \ /* TODO: we might want a follow up to hook into the sleep state hooks in Zephyr, */ \
@ -173,7 +174,7 @@ struct kscan_gpio_item_config {
}; \ }; \
\ \
/* KSCAN API disable function */ \ /* KSCAN API disable function */ \
static int kscan_gpio_disable_##n(struct device *dev) { \ static int kscan_gpio_disable_##n(const struct device *dev) { \
LOG_DBG("KSCAN API disable"); \ LOG_DBG("KSCAN API disable"); \
struct kscan_gpio_data_##n *data = dev->data; \ struct kscan_gpio_data_##n *data = dev->data; \
k_timer_stop(&data->poll_timer); \ k_timer_stop(&data->poll_timer); \
@ -181,12 +182,12 @@ struct kscan_gpio_item_config {
}; \ }; \
\ \
/* GPIO init function*/ \ /* GPIO init function*/ \
static int kscan_gpio_init_##n(struct device *dev) { \ static int kscan_gpio_init_##n(const struct device *dev) { \
LOG_DBG("KSCAN GPIO init"); \ LOG_DBG("KSCAN GPIO init"); \
struct kscan_gpio_data_##n *data = dev->data; \ struct kscan_gpio_data_##n *data = dev->data; \
int err; \ int err; \
/* configure input devices*/ \ /* configure input devices*/ \
struct device **input_devices = kscan_gpio_input_devices_##n(dev); \ const struct device **input_devices = kscan_gpio_input_devices_##n(dev); \
for (int i = 0; i < INST_MATRIX_INPUTS(n); i++) { \ for (int i = 0; i < INST_MATRIX_INPUTS(n); i++) { \
const struct kscan_gpio_item_config *in_cfg = &kscan_gpio_input_configs_##n(dev)[i]; \ const struct kscan_gpio_item_config *in_cfg = &kscan_gpio_input_configs_##n(dev)[i]; \
input_devices[i] = device_get_binding(in_cfg->label); \ input_devices[i] = device_get_binding(in_cfg->label); \
@ -207,7 +208,7 @@ struct kscan_gpio_item_config {
} \ } \
} \ } \
/* configure output devices*/ \ /* configure output devices*/ \
struct device **output_devices = kscan_gpio_output_devices_##n(dev); \ const struct device **output_devices = kscan_gpio_output_devices_##n(dev); \
for (int o = 0; o < INST_DEMUX_GPIOS(n); o++) { \ for (int o = 0; o < INST_DEMUX_GPIOS(n); o++) { \
const struct kscan_gpio_item_config *out_cfg = &kscan_gpio_output_configs_##n(dev)[o]; \ const struct kscan_gpio_item_config *out_cfg = &kscan_gpio_output_configs_##n(dev)[o]; \
output_devices[o] = device_get_binding(out_cfg->label); \ output_devices[o] = device_get_binding(out_cfg->label); \

36
app/drivers/kscan/kscan_gpio_direct.c
View file

@ -38,17 +38,17 @@ struct kscan_gpio_data {
#endif /* defined(CONFIG_ZMK_KSCAN_DIRECT_POLLING) */ #endif /* defined(CONFIG_ZMK_KSCAN_DIRECT_POLLING) */
kscan_callback_t callback; kscan_callback_t callback;
union work_reference work; union work_reference work;
struct device *dev; const struct device *dev;
uint32_t pin_state; uint32_t pin_state;
struct device *inputs[]; const struct device *inputs[];
}; };
static struct device **kscan_gpio_input_devices(struct device *dev) { static const struct device **kscan_gpio_input_devices(const struct device *dev) {
struct kscan_gpio_data *data = dev->data; struct kscan_gpio_data *data = dev->data;
return data->inputs; return data->inputs;
} }
static const struct kscan_gpio_item_config *kscan_gpio_input_configs(struct device *dev) { static const struct kscan_gpio_item_config *kscan_gpio_input_configs(const struct device *dev) {
const struct kscan_gpio_config *cfg = dev->config; const struct kscan_gpio_config *cfg = dev->config;
return cfg->inputs; return cfg->inputs;
} }
@ -65,19 +65,19 @@ static void kscan_gpio_direct_queue_read(union work_reference *work, uint8_t deb
#if !defined(CONFIG_ZMK_KSCAN_DIRECT_POLLING) #if !defined(CONFIG_ZMK_KSCAN_DIRECT_POLLING)
struct kscan_gpio_irq_callback { struct kscan_gpio_irq_callback {
struct device *dev; const struct device *dev;
union work_reference *work; union work_reference *work;
uint8_t debounce_period; uint8_t debounce_period;
struct gpio_callback callback; struct gpio_callback callback;
}; };
static int kscan_gpio_config_interrupts(struct device *dev, gpio_flags_t flags) { static int kscan_gpio_config_interrupts(const struct device *dev, gpio_flags_t flags) {
const struct kscan_gpio_config *cfg = dev->config; const struct kscan_gpio_config *cfg = dev->config;
struct device **devices = kscan_gpio_input_devices(dev); const struct device **devices = kscan_gpio_input_devices(dev);
const struct kscan_gpio_item_config *configs = kscan_gpio_input_configs(dev); const struct kscan_gpio_item_config *configs = kscan_gpio_input_configs(dev);
for (int i = 0; i < cfg->num_of_inputs; i++) { for (int i = 0; i < cfg->num_of_inputs; i++) {
struct device *dev = devices[i]; const struct device *dev = devices[i];
const struct kscan_gpio_item_config *cfg = &configs[i]; const struct kscan_gpio_item_config *cfg = &configs[i];
int err = gpio_pin_interrupt_configure(dev, cfg->pin, flags); int err = gpio_pin_interrupt_configure(dev, cfg->pin, flags);
@ -91,14 +91,14 @@ static int kscan_gpio_config_interrupts(struct device *dev, gpio_flags_t flags)
return 0; return 0;
} }
static int kscan_gpio_direct_enable(struct device *dev) { static int kscan_gpio_direct_enable(const struct device *dev) {
return kscan_gpio_config_interrupts(dev, GPIO_INT_LEVEL_ACTIVE); return kscan_gpio_config_interrupts(dev, GPIO_INT_LEVEL_ACTIVE);
} }
static int kscan_gpio_direct_disable(struct device *dev) { static int kscan_gpio_direct_disable(const struct device *dev) {
return kscan_gpio_config_interrupts(dev, GPIO_INT_DISABLE); return kscan_gpio_config_interrupts(dev, GPIO_INT_DISABLE);
} }
static void kscan_gpio_irq_callback_handler(struct device *dev, struct gpio_callback *cb, static void kscan_gpio_irq_callback_handler(const struct device *dev, struct gpio_callback *cb,
gpio_port_pins_t pin) { gpio_port_pins_t pin) {
struct kscan_gpio_irq_callback *data = struct kscan_gpio_irq_callback *data =
CONTAINER_OF(cb, struct kscan_gpio_irq_callback, callback); CONTAINER_OF(cb, struct kscan_gpio_irq_callback, callback);
@ -115,12 +115,12 @@ static void kscan_gpio_timer_handler(struct k_timer *timer) {
kscan_gpio_direct_queue_read(&data->work, 0); kscan_gpio_direct_queue_read(&data->work, 0);
} }
static int kscan_gpio_direct_enable(struct device *dev) { static int kscan_gpio_direct_enable(const struct device *dev) {
struct kscan_gpio_data *data = dev->data; struct kscan_gpio_data *data = dev->data;
k_timer_start(&data->poll_timer, K_MSEC(10), K_MSEC(10)); k_timer_start(&data->poll_timer, K_MSEC(10), K_MSEC(10));
return 0; return 0;
} }
static int kscan_gpio_direct_disable(struct device *dev) { static int kscan_gpio_direct_disable(const struct device *dev) {
struct kscan_gpio_data *data = dev->data; struct kscan_gpio_data *data = dev->data;
k_timer_stop(&data->poll_timer); k_timer_stop(&data->poll_timer);
return 0; return 0;
@ -128,7 +128,7 @@ static int kscan_gpio_direct_disable(struct device *dev) {
#endif /* defined(CONFIG_ZMK_KSCAN_DIRECT_POLLING) */ #endif /* defined(CONFIG_ZMK_KSCAN_DIRECT_POLLING) */
static int kscan_gpio_direct_configure(struct device *dev, kscan_callback_t callback) { static int kscan_gpio_direct_configure(const struct device *dev, kscan_callback_t callback) {
struct kscan_gpio_data *data = dev->data; struct kscan_gpio_data *data = dev->data;
if (!callback) { if (!callback) {
return -EINVAL; return -EINVAL;
@ -137,13 +137,13 @@ static int kscan_gpio_direct_configure(struct device *dev, kscan_callback_t call
return 0; return 0;
} }
static int kscan_gpio_read(struct device *dev) { static int kscan_gpio_read(const struct device *dev) {
struct kscan_gpio_data *data = dev->data; struct kscan_gpio_data *data = dev->data;
const struct kscan_gpio_config *cfg = dev->config; const struct kscan_gpio_config *cfg = dev->config;
uint32_t read_state = data->pin_state; uint32_t read_state = data->pin_state;
bool submit_follow_up_read = false; bool submit_follow_up_read = false;
for (int i = 0; i < cfg->num_of_inputs; i++) { for (int i = 0; i < cfg->num_of_inputs; i++) {
struct device *in_dev = kscan_gpio_input_devices(dev)[i]; const struct device *in_dev = kscan_gpio_input_devices(dev)[i];
const struct kscan_gpio_item_config *in_cfg = &kscan_gpio_input_configs(dev)[i]; const struct kscan_gpio_item_config *in_cfg = &kscan_gpio_input_configs(dev)[i];
WRITE_BIT(read_state, i, gpio_pin_get(in_dev, in_cfg->pin) > 0); WRITE_BIT(read_state, i, gpio_pin_get(in_dev, in_cfg->pin) > 0);
} }
@ -194,11 +194,11 @@ static const struct kscan_driver_api gpio_driver_api = {
(static struct kscan_gpio_irq_callback irq_callbacks_##n[INST_INPUT_LEN(n)];), ()) \ (static struct kscan_gpio_irq_callback irq_callbacks_##n[INST_INPUT_LEN(n)];), ()) \
static struct kscan_gpio_data kscan_gpio_data_##n = { \ static struct kscan_gpio_data kscan_gpio_data_##n = { \
.inputs = {[INST_INPUT_LEN(n) - 1] = NULL}}; \ .inputs = {[INST_INPUT_LEN(n) - 1] = NULL}}; \
static int kscan_gpio_init_##n(struct device *dev) { \ static int kscan_gpio_init_##n(const struct device *dev) { \
struct kscan_gpio_data *data = dev->data; \ struct kscan_gpio_data *data = dev->data; \
const struct kscan_gpio_config *cfg = dev->config; \ const struct kscan_gpio_config *cfg = dev->config; \
int err; \ int err; \
struct device **input_devices = kscan_gpio_input_devices(dev); \ const struct device **input_devices = kscan_gpio_input_devices(dev); \
for (int i = 0; i < cfg->num_of_inputs; i++) { \ for (int i = 0; i < cfg->num_of_inputs; i++) { \
const struct kscan_gpio_item_config *in_cfg = &kscan_gpio_input_configs(dev)[i]; \ const struct kscan_gpio_item_config *in_cfg = &kscan_gpio_input_configs(dev)[i]; \
input_devices[i] = device_get_binding(in_cfg->label); \ input_devices[i] = device_get_binding(in_cfg->label); \

51
app/drivers/kscan/kscan_gpio_matrix.c
View file

@ -32,11 +32,11 @@ struct kscan_gpio_item_config {
#define _KSCAN_GPIO_COL_CFG_INIT(idx, n) _KSCAN_GPIO_ITEM_CFG_INIT(n, col_gpios, idx) #define _KSCAN_GPIO_COL_CFG_INIT(idx, n) _KSCAN_GPIO_ITEM_CFG_INIT(n, col_gpios, idx)
#if !defined(CONFIG_ZMK_KSCAN_MATRIX_POLLING) #if !defined(CONFIG_ZMK_KSCAN_MATRIX_POLLING)
static int kscan_gpio_config_interrupts(struct device **devices, static int kscan_gpio_config_interrupts(const struct device **devices,
const struct kscan_gpio_item_config *configs, size_t len, const struct kscan_gpio_item_config *configs, size_t len,
gpio_flags_t flags) { gpio_flags_t flags) {
for (int i = 0; i < len; i++) { for (int i = 0; i < len; i++) {
struct device *dev = devices[i]; const struct device *dev = devices[i];
const struct kscan_gpio_item_config *cfg = &configs[i]; const struct kscan_gpio_item_config *cfg = &configs[i];
int err = gpio_pin_interrupt_configure(dev, cfg->pin, flags); int err = gpio_pin_interrupt_configure(dev, cfg->pin, flags);
@ -64,7 +64,7 @@ static int kscan_gpio_config_interrupts(struct device **devices,
struct kscan_gpio_irq_callback_##n { \ struct kscan_gpio_irq_callback_##n { \
struct COND_CODE_0(DT_INST_PROP(n, debounce_period), (k_work), (k_delayed_work)) * work; \ struct COND_CODE_0(DT_INST_PROP(n, debounce_period), (k_work), (k_delayed_work)) * work; \
struct gpio_callback callback; \ struct gpio_callback callback; \
struct device *dev; \ const struct device *dev; \
}; \ }; \
static struct kscan_gpio_irq_callback_##n irq_callbacks_##n[INST_INPUT_LEN(n)]; \ static struct kscan_gpio_irq_callback_##n irq_callbacks_##n[INST_INPUT_LEN(n)]; \
struct kscan_gpio_config_##n { \ struct kscan_gpio_config_##n { \
@ -76,46 +76,47 @@ static int kscan_gpio_config_interrupts(struct device **devices,
COND_CODE_1(CONFIG_ZMK_KSCAN_MATRIX_POLLING, (struct k_timer poll_timer;), ()) \ COND_CODE_1(CONFIG_ZMK_KSCAN_MATRIX_POLLING, (struct k_timer poll_timer;), ()) \
struct COND_CODE_0(DT_INST_PROP(n, debounce_period), (k_work), (k_delayed_work)) work; \ struct COND_CODE_0(DT_INST_PROP(n, debounce_period), (k_work), (k_delayed_work)) work; \
bool matrix_state[INST_MATRIX_ROWS(n)][INST_MATRIX_COLS(n)]; \ bool matrix_state[INST_MATRIX_ROWS(n)][INST_MATRIX_COLS(n)]; \
struct device *rows[INST_MATRIX_ROWS(n)]; \ const struct device *rows[INST_MATRIX_ROWS(n)]; \
struct device *cols[INST_MATRIX_COLS(n)]; \ const struct device *cols[INST_MATRIX_COLS(n)]; \
struct device *dev; \ const struct device *dev; \
}; \ }; \
static struct device **kscan_gpio_input_devices_##n(struct device *dev) { \ static const struct device **kscan_gpio_input_devices_##n(const struct device *dev) { \
struct kscan_gpio_data_##n *data = dev->data; \ struct kscan_gpio_data_##n *data = dev->data; \
return (COND_CODE_0(DT_ENUM_IDX(DT_DRV_INST(n), diode_direction), (data->cols), \ return (COND_CODE_0(DT_ENUM_IDX(DT_DRV_INST(n), diode_direction), (data->cols), \
(data->rows))); \ (data->rows))); \
} \ } \
static const struct kscan_gpio_item_config *kscan_gpio_input_configs_##n(struct device *dev) { \ static const struct kscan_gpio_item_config *kscan_gpio_input_configs_##n( \
const struct device *dev) { \
const struct kscan_gpio_config_##n *cfg = dev->config; \ const struct kscan_gpio_config_##n *cfg = dev->config; \
return (( \ return (( \
COND_CODE_0(DT_ENUM_IDX(DT_DRV_INST(n), diode_direction), (cfg->cols), (cfg->rows)))); \ COND_CODE_0(DT_ENUM_IDX(DT_DRV_INST(n), diode_direction), (cfg->cols), (cfg->rows)))); \
} \ } \
static struct device **kscan_gpio_output_devices_##n(struct device *dev) { \ static const struct device **kscan_gpio_output_devices_##n(const struct device *dev) { \
struct kscan_gpio_data_##n *data = dev->data; \ struct kscan_gpio_data_##n *data = dev->data; \
return (COND_CODE_0(DT_ENUM_IDX(DT_DRV_INST(n), diode_direction), (data->rows), \ return (COND_CODE_0(DT_ENUM_IDX(DT_DRV_INST(n), diode_direction), (data->rows), \
(data->cols))); \ (data->cols))); \
} \ } \
static const struct kscan_gpio_item_config *kscan_gpio_output_configs_##n( \ static const struct kscan_gpio_item_config *kscan_gpio_output_configs_##n( \
struct device *dev) { \ const struct device *dev) { \
const struct kscan_gpio_config_##n *cfg = dev->config; \ const struct kscan_gpio_config_##n *cfg = dev->config; \
return ( \ return ( \
COND_CODE_0(DT_ENUM_IDX(DT_DRV_INST(n), diode_direction), (cfg->rows), (cfg->cols))); \ COND_CODE_0(DT_ENUM_IDX(DT_DRV_INST(n), diode_direction), (cfg->rows), (cfg->cols))); \
} \ } \
COND_CODE_1(CONFIG_ZMK_KSCAN_MATRIX_POLLING, (), \ COND_CODE_1(CONFIG_ZMK_KSCAN_MATRIX_POLLING, (), \
( \ ( \
static int kscan_gpio_enable_interrupts_##n(struct device *dev) { \ static int kscan_gpio_enable_interrupts_##n(const struct device *dev) { \
return kscan_gpio_config_interrupts( \ return kscan_gpio_config_interrupts( \
kscan_gpio_input_devices_##n(dev), kscan_gpio_input_configs_##n(dev), \ kscan_gpio_input_devices_##n(dev), kscan_gpio_input_configs_##n(dev), \
INST_INPUT_LEN(n), GPIO_INT_LEVEL_ACTIVE); \ INST_INPUT_LEN(n), GPIO_INT_LEVEL_ACTIVE); \
} static int kscan_gpio_disable_interrupts_##n(struct device *dev) { \ } static int kscan_gpio_disable_interrupts_##n(const struct device *dev) { \
return kscan_gpio_config_interrupts(kscan_gpio_input_devices_##n(dev), \ return kscan_gpio_config_interrupts(kscan_gpio_input_devices_##n(dev), \
kscan_gpio_input_configs_##n(dev), \ kscan_gpio_input_configs_##n(dev), \
INST_INPUT_LEN(n), GPIO_INT_DISABLE); \ INST_INPUT_LEN(n), GPIO_INT_DISABLE); \
})) \ })) \
static void kscan_gpio_set_output_state_##n(struct device *dev, int value) { \ static void kscan_gpio_set_output_state_##n(const struct device *dev, int value) { \
int err; \ int err; \
for (int i = 0; i < INST_OUTPUT_LEN(n); i++) { \ for (int i = 0; i < INST_OUTPUT_LEN(n); i++) { \
struct device *in_dev = kscan_gpio_output_devices_##n(dev)[i]; \ const struct device *in_dev = kscan_gpio_output_devices_##n(dev)[i]; \
const struct kscan_gpio_item_config *cfg = &kscan_gpio_output_configs_##n(dev)[i]; \ const struct kscan_gpio_item_config *cfg = &kscan_gpio_output_configs_##n(dev)[i]; \
if ((err = gpio_pin_set(in_dev, cfg->pin, value))) { \ if ((err = gpio_pin_set(in_dev, cfg->pin, value))) { \
LOG_DBG("FAILED TO SET OUTPUT %d to %d", cfg->pin, err); \ LOG_DBG("FAILED TO SET OUTPUT %d to %d", cfg->pin, err); \
@ -130,7 +131,7 @@ static int kscan_gpio_config_interrupts(struct device **devices,
[COND_CODE_0(DT_ENUM_IDX(DT_DRV_INST(n), diode_direction), (input_index), \ [COND_CODE_0(DT_ENUM_IDX(DT_DRV_INST(n), diode_direction), (input_index), \
(output_index))] = value; \ (output_index))] = value; \
} \ } \
static int kscan_gpio_read_##n(struct device *dev) { \ static int kscan_gpio_read_##n(const struct device *dev) { \
bool submit_follow_up_read = false; \ bool submit_follow_up_read = false; \
struct kscan_gpio_data_##n *data = dev->data; \ struct kscan_gpio_data_##n *data = dev->data; \
static bool read_state[INST_MATRIX_ROWS(n)][INST_MATRIX_COLS(n)]; \ static bool read_state[INST_MATRIX_ROWS(n)][INST_MATRIX_COLS(n)]; \
@ -139,11 +140,11 @@ static int kscan_gpio_config_interrupts(struct device **devices,
/* to get pressed state for each matrix cell. */ \ /* to get pressed state for each matrix cell. */ \
kscan_gpio_set_output_state_##n(dev, 0); \ kscan_gpio_set_output_state_##n(dev, 0); \
for (int o = 0; o < INST_OUTPUT_LEN(n); o++) { \ for (int o = 0; o < INST_OUTPUT_LEN(n); o++) { \
struct device *out_dev = kscan_gpio_output_devices_##n(dev)[o]; \ const struct device *out_dev = kscan_gpio_output_devices_##n(dev)[o]; \
const struct kscan_gpio_item_config *out_cfg = &kscan_gpio_output_configs_##n(dev)[o]; \ const struct kscan_gpio_item_config *out_cfg = &kscan_gpio_output_configs_##n(dev)[o]; \
gpio_pin_set(out_dev, out_cfg->pin, 1); \ gpio_pin_set(out_dev, out_cfg->pin, 1); \
for (int i = 0; i < INST_INPUT_LEN(n); i++) { \ for (int i = 0; i < INST_INPUT_LEN(n); i++) { \
struct device *in_dev = kscan_gpio_input_devices_##n(dev)[i]; \ const struct device *in_dev = kscan_gpio_input_devices_##n(dev)[i]; \
const struct kscan_gpio_item_config *in_cfg = \ const struct kscan_gpio_item_config *in_cfg = \
&kscan_gpio_input_configs_##n(dev)[i]; \ &kscan_gpio_input_configs_##n(dev)[i]; \
kscan_gpio_set_matrix_state_##n(read_state, i, o, \ kscan_gpio_set_matrix_state_##n(read_state, i, o, \
@ -181,8 +182,8 @@ static int kscan_gpio_config_interrupts(struct device **devices,
struct kscan_gpio_data_##n *data = CONTAINER_OF(work, struct kscan_gpio_data_##n, work); \ struct kscan_gpio_data_##n *data = CONTAINER_OF(work, struct kscan_gpio_data_##n, work); \
kscan_gpio_read_##n(data->dev); \ kscan_gpio_read_##n(data->dev); \
} \ } \
static void kscan_gpio_irq_callback_handler_##n(struct device *dev, struct gpio_callback *cb, \ static void kscan_gpio_irq_callback_handler_##n( \
gpio_port_pins_t pin) { \ const struct device *dev, struct gpio_callback *cb, gpio_port_pins_t pin) { \
struct kscan_gpio_irq_callback_##n *data = \ struct kscan_gpio_irq_callback_##n *data = \
CONTAINER_OF(cb, struct kscan_gpio_irq_callback_##n, callback); \ CONTAINER_OF(cb, struct kscan_gpio_irq_callback_##n, callback); \
COND_CODE_1(CONFIG_ZMK_KSCAN_MATRIX_POLLING, (), \ COND_CODE_1(CONFIG_ZMK_KSCAN_MATRIX_POLLING, (), \
@ -196,7 +197,7 @@ static int kscan_gpio_config_interrupts(struct device **devices,
\ \
static struct kscan_gpio_data_##n kscan_gpio_data_##n = { \ static struct kscan_gpio_data_##n kscan_gpio_data_##n = { \
.rows = {[INST_MATRIX_ROWS(n) - 1] = NULL}, .cols = {[INST_MATRIX_COLS(n) - 1] = NULL}}; \ .rows = {[INST_MATRIX_ROWS(n) - 1] = NULL}, .cols = {[INST_MATRIX_COLS(n) - 1] = NULL}}; \
static int kscan_gpio_configure_##n(struct device *dev, kscan_callback_t callback) { \ static int kscan_gpio_configure_##n(const struct device *dev, kscan_callback_t callback) { \
struct kscan_gpio_data_##n *data = dev->data; \ struct kscan_gpio_data_##n *data = dev->data; \
if (!callback) { \ if (!callback) { \
return -EINVAL; \ return -EINVAL; \
@ -205,14 +206,14 @@ static int kscan_gpio_config_interrupts(struct device **devices,
LOG_DBG("Configured GPIO %d", n); \ LOG_DBG("Configured GPIO %d", n); \
return 0; \ return 0; \
}; \ }; \
static int kscan_gpio_enable_##n(struct device *dev) { \ static int kscan_gpio_enable_##n(const struct device *dev) { \
COND_CODE_1(CONFIG_ZMK_KSCAN_MATRIX_POLLING, \ COND_CODE_1(CONFIG_ZMK_KSCAN_MATRIX_POLLING, \
(struct kscan_gpio_data_##n *data = dev->data; \ (struct kscan_gpio_data_##n *data = dev->data; \
k_timer_start(&data->poll_timer, K_MSEC(10), K_MSEC(10)); return 0;), \ k_timer_start(&data->poll_timer, K_MSEC(10), K_MSEC(10)); return 0;), \
(int err = kscan_gpio_enable_interrupts_##n(dev); \ (int err = kscan_gpio_enable_interrupts_##n(dev); \
if (err) { return err; } return kscan_gpio_read_##n(dev);)) \ if (err) { return err; } return kscan_gpio_read_##n(dev);)) \
}; \ }; \
static int kscan_gpio_disable_##n(struct device *dev) { \ static int kscan_gpio_disable_##n(const struct device *dev) { \
COND_CODE_1(CONFIG_ZMK_KSCAN_MATRIX_POLLING, \ COND_CODE_1(CONFIG_ZMK_KSCAN_MATRIX_POLLING, \
(struct kscan_gpio_data_##n *data = dev->data; \ (struct kscan_gpio_data_##n *data = dev->data; \
k_timer_stop(&data->poll_timer); return 0;), \ k_timer_stop(&data->poll_timer); return 0;), \
@ -225,10 +226,10 @@ static int kscan_gpio_config_interrupts(struct device **devices,
k_work_submit(&data->work.work); \ k_work_submit(&data->work.work); \
}), \ }), \
()) \ ()) \
static int kscan_gpio_init_##n(struct device *dev) { \ static int kscan_gpio_init_##n(const struct device *dev) { \
struct kscan_gpio_data_##n *data = dev->data; \ struct kscan_gpio_data_##n *data = dev->data; \
int err; \ int err; \
struct device **input_devices = kscan_gpio_input_devices_##n(dev); \ const struct device **input_devices = kscan_gpio_input_devices_##n(dev); \
for (int i = 0; i < INST_INPUT_LEN(n); i++) { \ for (int i = 0; i < INST_INPUT_LEN(n); i++) { \
const struct kscan_gpio_item_config *in_cfg = &kscan_gpio_input_configs_##n(dev)[i]; \ const struct kscan_gpio_item_config *in_cfg = &kscan_gpio_input_configs_##n(dev)[i]; \
input_devices[i] = device_get_binding(in_cfg->label); \ input_devices[i] = device_get_binding(in_cfg->label); \
@ -253,7 +254,7 @@ static int kscan_gpio_config_interrupts(struct device **devices,
return err; \ return err; \
} \ } \
} \ } \
struct device **output_devices = kscan_gpio_output_devices_##n(dev); \ const struct device **output_devices = kscan_gpio_output_devices_##n(dev); \
for (int o = 0; o < INST_OUTPUT_LEN(n); o++) { \ for (int o = 0; o < INST_OUTPUT_LEN(n); o++) { \
const struct kscan_gpio_item_config *out_cfg = &kscan_gpio_output_configs_##n(dev)[o]; \ const struct kscan_gpio_item_config *out_cfg = &kscan_gpio_output_configs_##n(dev)[o]; \
output_devices[o] = device_get_binding(out_cfg->label); \ output_devices[o] = device_get_binding(out_cfg->label); \

12
app/drivers/kscan/kscan_mock.c
View file

@ -20,17 +20,17 @@ struct kscan_mock_data {
uint32_t event_index; uint32_t event_index;
struct k_delayed_work work; struct k_delayed_work work;
struct device *dev; const struct device *dev;
}; };
static int kscan_mock_disable_callback(struct device *dev) { static int kscan_mock_disable_callback(const struct device *dev) {
struct kscan_mock_data *data = dev->data; struct kscan_mock_data *data = dev->data;
k_delayed_work_cancel(&data->work); k_delayed_work_cancel(&data->work);
return 0; return 0;
} }
static int kscan_mock_configure(struct device *dev, kscan_callback_t callback) { static int kscan_mock_configure(const struct device *dev, kscan_callback_t callback) {
struct kscan_mock_data *data = dev->data; struct kscan_mock_data *data = dev->data;
if (!callback) { if (!callback) {
@ -48,7 +48,7 @@ static int kscan_mock_configure(struct device *dev, kscan_callback_t callback) {
uint32_t events[DT_INST_PROP_LEN(n, events)]; \ uint32_t events[DT_INST_PROP_LEN(n, events)]; \
bool exit_after; \ bool exit_after; \
}; \ }; \
static void kscan_mock_schedule_next_event_##n(struct device *dev) { \ static void kscan_mock_schedule_next_event_##n(const struct device *dev) { \
struct kscan_mock_data *data = dev->data; \ struct kscan_mock_data *data = dev->data; \
const struct kscan_mock_config_##n *cfg = dev->config; \ const struct kscan_mock_config_##n *cfg = dev->config; \
if (data->event_index < DT_INST_PROP_LEN(n, events)) { \ if (data->event_index < DT_INST_PROP_LEN(n, events)) { \
@ -70,13 +70,13 @@ static int kscan_mock_configure(struct device *dev, kscan_callback_t callback) {
kscan_mock_schedule_next_event_##n(data->dev); \ kscan_mock_schedule_next_event_##n(data->dev); \
data->event_index++; \ data->event_index++; \
} \ } \
static int kscan_mock_init_##n(struct device *dev) { \ static int kscan_mock_init_##n(const struct device *dev) { \
struct kscan_mock_data *data = dev->data; \ struct kscan_mock_data *data = dev->data; \
data->dev = dev; \ data->dev = dev; \
k_delayed_work_init(&data->work, kscan_mock_work_handler_##n); \ k_delayed_work_init(&data->work, kscan_mock_work_handler_##n); \
return 0; \ return 0; \
} \ } \
static int kscan_mock_enable_callback_##n(struct device *dev) { \ static int kscan_mock_enable_callback_##n(const struct device *dev) { \
kscan_mock_schedule_next_event_##n(dev); \ kscan_mock_schedule_next_event_##n(dev); \
return 0; \ return 0; \
} \ } \

11
app/drivers/sensor/battery_voltage_divider/battery_voltage_divider.c
View file

@ -33,8 +33,8 @@ struct bvd_config {
}; };
struct bvd_data { struct bvd_data {
struct device *adc; const struct device *adc;
struct device *gpio; const struct device *gpio;
struct adc_channel_cfg acc; struct adc_channel_cfg acc;
struct adc_sequence as; struct adc_sequence as;
uint16_t adc_raw; uint16_t adc_raw;
@ -55,7 +55,7 @@ static uint8_t lithium_ion_mv_to_pct(int16_t bat_mv) {
return bat_mv * 2 / 15 - 459; return bat_mv * 2 / 15 - 459;
} }
static int bvd_sample_fetch(struct device *dev, enum sensor_channel chan) { static int bvd_sample_fetch(const struct device *dev, enum sensor_channel chan) {
struct bvd_data *drv_data = dev->data; struct bvd_data *drv_data = dev->data;
const struct bvd_config *drv_cfg = dev->config; const struct bvd_config *drv_cfg = dev->config;
struct adc_sequence *as = &drv_data->as; struct adc_sequence *as = &drv_data->as;
@ -113,7 +113,8 @@ static int bvd_sample_fetch(struct device *dev, enum sensor_channel chan) {
return rc; return rc;
} }
static int bvd_channel_get(struct device *dev, enum sensor_channel chan, struct sensor_value *val) { static int bvd_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val) {
struct bvd_data *drv_data = dev->data; struct bvd_data *drv_data = dev->data;
switch (chan) { switch (chan) {
@ -139,7 +140,7 @@ static const struct sensor_driver_api bvd_api = {
.channel_get = bvd_channel_get, .channel_get = bvd_channel_get,
}; };
static int bvd_init(struct device *dev) { static int bvd_init(const struct device *dev) {
struct bvd_data *drv_data = dev->data; struct bvd_data *drv_data = dev->data;
const struct bvd_config *drv_cfg = dev->config; const struct bvd_config *drv_cfg = dev->config;

8
app/drivers/sensor/ec11/ec11.c
View file

@ -18,7 +18,7 @@
LOG_MODULE_REGISTER(EC11, CONFIG_SENSOR_LOG_LEVEL); LOG_MODULE_REGISTER(EC11, CONFIG_SENSOR_LOG_LEVEL);
static int ec11_get_ab_state(struct device *dev) { static int ec11_get_ab_state(const struct device *dev) {
struct ec11_data *drv_data = dev->data; struct ec11_data *drv_data = dev->data;
const struct ec11_config *drv_cfg = dev->config; const struct ec11_config *drv_cfg = dev->config;
@ -26,7 +26,7 @@ static int ec11_get_ab_state(struct device *dev) {
gpio_pin_get(drv_data->b, drv_cfg->b_pin); gpio_pin_get(drv_data->b, drv_cfg->b_pin);
} }
static int ec11_sample_fetch(struct device *dev, enum sensor_channel chan) { static int ec11_sample_fetch(const struct device *dev, enum sensor_channel chan) {
struct ec11_data *drv_data = dev->data; struct ec11_data *drv_data = dev->data;
const struct ec11_config *drv_cfg = dev->config; const struct ec11_config *drv_cfg = dev->config;
uint8_t val; uint8_t val;
@ -68,7 +68,7 @@ static int ec11_sample_fetch(struct device *dev, enum sensor_channel chan) {
return 0; return 0;
} }
static int ec11_channel_get(struct device *dev, enum sensor_channel chan, static int ec11_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val) { struct sensor_value *val) {
struct ec11_data *drv_data = dev->data; struct ec11_data *drv_data = dev->data;
@ -90,7 +90,7 @@ static const struct sensor_driver_api ec11_driver_api = {
.channel_get = ec11_channel_get, .channel_get = ec11_channel_get,
}; };
int ec11_init(struct device *dev) { int ec11_init(const struct device *dev) {
struct ec11_data *drv_data = dev->data; struct ec11_data *drv_data = dev->data;
const struct ec11_config *drv_cfg = dev->config; const struct ec11_config *drv_cfg = dev->config;

10
app/drivers/sensor/ec11/ec11.h
View file

@ -23,8 +23,8 @@ struct ec11_config {
}; };
struct ec11_data { struct ec11_data {
struct device *a; const struct device *a;
struct device *b; const struct device *b;
uint8_t ab_state; uint8_t ab_state;
int8_t pulses; int8_t pulses;
int8_t ticks; int8_t ticks;
@ -33,7 +33,7 @@ struct ec11_data {
#ifdef CONFIG_EC11_TRIGGER #ifdef CONFIG_EC11_TRIGGER
struct gpio_callback a_gpio_cb; struct gpio_callback a_gpio_cb;
struct gpio_callback b_gpio_cb; struct gpio_callback b_gpio_cb;
struct device *dev; const struct device *dev;
sensor_trigger_handler_t handler; sensor_trigger_handler_t handler;
const struct sensor_trigger *trigger; const struct sensor_trigger *trigger;
@ -51,8 +51,8 @@ struct ec11_data {
#ifdef CONFIG_EC11_TRIGGER #ifdef CONFIG_EC11_TRIGGER
int ec11_trigger_set(struct device *dev, const struct sensor_trigger *trig, int ec11_trigger_set(const struct device *dev, const struct sensor_trigger *trig,
sensor_trigger_handler_t handler); sensor_trigger_handler_t handler);
int ec11_init_interrupt(struct device *dev); int ec11_init_interrupt(const struct device *dev);
#endif #endif

16
app/drivers/sensor/ec11/ec11_trigger.c
View file

@ -19,7 +19,7 @@ extern struct ec11_data ec11_driver;
#include <logging/log.h> #include <logging/log.h>
LOG_MODULE_DECLARE(EC11, CONFIG_SENSOR_LOG_LEVEL); LOG_MODULE_DECLARE(EC11, CONFIG_SENSOR_LOG_LEVEL);
static inline void setup_int(struct device *dev, bool enable) { static inline void setup_int(const struct device *dev, bool enable) {
struct ec11_data *data = dev->data; struct ec11_data *data = dev->data;
const struct ec11_config *cfg = dev->config; const struct ec11_config *cfg = dev->config;
@ -36,7 +36,8 @@ static inline void setup_int(struct device *dev, bool enable) {
} }
} }
static void ec11_a_gpio_callback(struct device *dev, struct gpio_callback *cb, uint32_t pins) { static void ec11_a_gpio_callback(const struct device *dev, struct gpio_callback *cb,
uint32_t pins) {
struct ec11_data *drv_data = CONTAINER_OF(cb, struct ec11_data, a_gpio_cb); struct ec11_data *drv_data = CONTAINER_OF(cb, struct ec11_data, a_gpio_cb);
LOG_DBG(""); LOG_DBG("");
@ -50,7 +51,8 @@ static void ec11_a_gpio_callback(struct device *dev, struct gpio_callback *cb, u
#endif #endif
} }
static void ec11_b_gpio_callback(struct device *dev, struct gpio_callback *cb, uint32_t pins) { static void ec11_b_gpio_callback(const struct device *dev, struct gpio_callback *cb,
uint32_t pins) {
struct ec11_data *drv_data = CONTAINER_OF(cb, struct ec11_data, b_gpio_cb); struct ec11_data *drv_data = CONTAINER_OF(cb, struct ec11_data, b_gpio_cb);
LOG_DBG(""); LOG_DBG("");
@ -65,7 +67,7 @@ static void ec11_b_gpio_callback(struct device *dev, struct gpio_callback *cb, u
} }
static void ec11_thread_cb(void *arg) { static void ec11_thread_cb(void *arg) {
struct device *dev = arg; const struct device *dev = arg;
struct ec11_data *drv_data = dev->data; struct ec11_data *drv_data = dev->data;
drv_data->handler(dev, drv_data->trigger); drv_data->handler(dev, drv_data->trigger);
@ -75,7 +77,7 @@ static void ec11_thread_cb(void *arg) {
#ifdef CONFIG_EC11_TRIGGER_OWN_THREAD #ifdef CONFIG_EC11_TRIGGER_OWN_THREAD
static void ec11_thread(int dev_ptr, int unused) { static void ec11_thread(int dev_ptr, int unused) {
struct device *dev = INT_TO_POINTER(dev_ptr); const struct device *dev = INT_TO_POINTER(dev_ptr);
struct ec11_data *drv_data = dev->data; struct ec11_data *drv_data = dev->data;
ARG_UNUSED(unused); ARG_UNUSED(unused);
@ -97,7 +99,7 @@ static void ec11_work_cb(struct k_work *work) {
} }
#endif #endif
int ec11_trigger_set(struct device *dev, const struct sensor_trigger *trig, int ec11_trigger_set(const struct device *dev, const struct sensor_trigger *trig,
sensor_trigger_handler_t handler) { sensor_trigger_handler_t handler) {
struct ec11_data *drv_data = dev->data; struct ec11_data *drv_data = dev->data;
@ -113,7 +115,7 @@ int ec11_trigger_set(struct device *dev, const struct sensor_trigger *trig,
return 0; return 0;
} }
int ec11_init_interrupt(struct device *dev) { int ec11_init_interrupt(const struct device *dev) {
struct ec11_data *drv_data = dev->data; struct ec11_data *drv_data = dev->data;
const struct ec11_config *drv_cfg = dev->config; const struct ec11_config *drv_cfg = dev->config;

14
app/include/drivers/behavior.h
View file

@ -23,7 +23,8 @@
typedef int (*behavior_keymap_binding_callback_t)(struct zmk_behavior_binding *binding, typedef int (*behavior_keymap_binding_callback_t)(struct zmk_behavior_binding *binding,
struct zmk_behavior_binding_event event); struct zmk_behavior_binding_event event);
typedef int (*behavior_sensor_keymap_binding_callback_t)(struct zmk_behavior_binding *binding, typedef int (*behavior_sensor_keymap_binding_callback_t)(struct zmk_behavior_binding *binding,
struct device *sensor, int64_t timestamp); const struct device *sensor,
int64_t timestamp);
__subsystem struct behavior_driver_api { __subsystem struct behavior_driver_api {
behavior_keymap_binding_callback_t binding_pressed; behavior_keymap_binding_callback_t binding_pressed;
@ -48,7 +49,7 @@ __syscall int behavior_keymap_binding_pressed(struct zmk_behavior_binding *bindi
static inline int z_impl_behavior_keymap_binding_pressed(struct zmk_behavior_binding *binding, static inline int z_impl_behavior_keymap_binding_pressed(struct zmk_behavior_binding *binding,
struct zmk_behavior_binding_event event) { struct zmk_behavior_binding_event event) {
struct device *dev = device_get_binding(binding->behavior_dev); const struct device *dev = device_get_binding(binding->behavior_dev);
const struct behavior_driver_api *api = (const struct behavior_driver_api *)dev->api; const struct behavior_driver_api *api = (const struct behavior_driver_api *)dev->api;
if (api->binding_pressed == NULL) { if (api->binding_pressed == NULL) {
@ -71,7 +72,7 @@ __syscall int behavior_keymap_binding_released(struct zmk_behavior_binding *bind
static inline int z_impl_behavior_keymap_binding_released(struct zmk_behavior_binding *binding, static inline int z_impl_behavior_keymap_binding_released(struct zmk_behavior_binding *binding,
struct zmk_behavior_binding_event event) { struct zmk_behavior_binding_event event) {
struct device *dev = device_get_binding(binding->behavior_dev); const struct device *dev = device_get_binding(binding->behavior_dev);
const struct behavior_driver_api *api = (const struct behavior_driver_api *)dev->api; const struct behavior_driver_api *api = (const struct behavior_driver_api *)dev->api;
if (api->binding_released == NULL) { if (api->binding_released == NULL) {
@ -92,12 +93,13 @@ static inline int z_impl_behavior_keymap_binding_released(struct zmk_behavior_bi
* @retval Negative errno code if failure. * @retval Negative errno code if failure.
*/ */
__syscall int behavior_sensor_keymap_binding_triggered(struct zmk_behavior_binding *binding, __syscall int behavior_sensor_keymap_binding_triggered(struct zmk_behavior_binding *binding,
struct device *sensor, int64_t timestamp); const struct device *sensor,
int64_t timestamp);
static inline int static inline int
z_impl_behavior_sensor_keymap_binding_triggered(struct zmk_behavior_binding *binding, z_impl_behavior_sensor_keymap_binding_triggered(struct zmk_behavior_binding *binding,
struct device *sensor, int64_t timestamp) { const struct device *sensor, int64_t timestamp) {
struct device *dev = device_get_binding(binding->behavior_dev); const struct device *dev = device_get_binding(binding->behavior_dev);
const struct behavior_driver_api *api = (const struct behavior_driver_api *)dev->api; const struct behavior_driver_api *api = (const struct behavior_driver_api *)dev->api;
if (api->sensor_binding_triggered == NULL) { if (api->sensor_binding_triggered == NULL) {

18
app/include/drivers/ext_power.h
View file

@ -22,9 +22,9 @@ extern "C" {
* (Internal use only.) * (Internal use only.)
*/ */
typedef int (*ext_power_enable_t)(struct device *dev); typedef int (*ext_power_enable_t)(const struct device *dev);
typedef int (*ext_power_disable_t)(struct device *dev); typedef int (*ext_power_disable_t)(const struct device *dev);
typedef int (*ext_power_get_t)(struct device *dev); typedef int (*ext_power_get_t)(const struct device *dev);
__subsystem struct ext_power_api { __subsystem struct ext_power_api {
ext_power_enable_t enable; ext_power_enable_t enable;
@ -42,9 +42,9 @@ __subsystem struct ext_power_api {
* @retval 0 If successful. * @retval 0 If successful.
* @retval Negative errno code if failure. * @retval Negative errno code if failure.
*/ */
__syscall int ext_power_enable(struct device *dev); __syscall int ext_power_enable(const struct device *dev);
static inline int z_impl_ext_power_enable(struct device *dev) { static inline int z_impl_ext_power_enable(const struct device *dev) {
const struct ext_power_api *api = (const struct ext_power_api *)dev->api; const struct ext_power_api *api = (const struct ext_power_api *)dev->api;
if (api->enable == NULL) { if (api->enable == NULL) {
@ -61,9 +61,9 @@ static inline int z_impl_ext_power_enable(struct device *dev) {
* @retval 0 If successful. * @retval 0 If successful.
* @retval Negative errno code if failure. * @retval Negative errno code if failure.
*/ */
__syscall int ext_power_disable(struct device *dev); __syscall int ext_power_disable(const struct device *dev);
static inline int z_impl_ext_power_disable(struct device *dev) { static inline int z_impl_ext_power_disable(const struct device *dev) {
const struct ext_power_api *api = (const struct ext_power_api *)dev->api; const struct ext_power_api *api = (const struct ext_power_api *)dev->api;
if (api->disable == NULL) { if (api->disable == NULL) {
@ -81,9 +81,9 @@ static inline int z_impl_ext_power_disable(struct device *dev) {
* @retval 1 if ext power is enabled. * @retval 1 if ext power is enabled.
* @retval Negative errno code if failure. * @retval Negative errno code if failure.
*/ */
__syscall int ext_power_get(struct device *dev); __syscall int ext_power_get(const struct device *dev);
static inline int z_impl_ext_power_get(struct device *dev) { static inline int z_impl_ext_power_get(const struct device *dev) {
const struct ext_power_api *api = (const struct ext_power_api *)dev->api; const struct ext_power_api *api = (const struct ext_power_api *)dev->api;
if (api->get == NULL) { if (api->get == NULL) {

2
app/include/zmk/events/sensor-event.h
View file

@ -13,7 +13,7 @@
struct sensor_event { struct sensor_event {
struct zmk_event_header header; struct zmk_event_header header;
uint8_t sensor_number; uint8_t sensor_number;
struct device *sensor; const struct device *sensor;
int64_t timestamp; int64_t timestamp;
}; };

6
app/src/battery.c
View file

@ -17,9 +17,9 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
#include <zmk/event-manager.h> #include <zmk/event-manager.h>
#include <zmk/events/battery-state-changed.h> #include <zmk/events/battery-state-changed.h>
struct device *battery; const struct device *battery;
static int zmk_battery_update(struct device *battery) { static int zmk_battery_update(const struct device *battery) {
struct sensor_value state_of_charge; struct sensor_value state_of_charge;
int rc = sensor_sample_fetch_chan(battery, SENSOR_CHAN_GAUGE_STATE_OF_CHARGE); int rc = sensor_sample_fetch_chan(battery, SENSOR_CHAN_GAUGE_STATE_OF_CHARGE);
@ -64,7 +64,7 @@ static void zmk_battery_timer(struct k_timer *timer) { k_work_submit(&battery_wo
K_TIMER_DEFINE(battery_timer, zmk_battery_timer, NULL); K_TIMER_DEFINE(battery_timer, zmk_battery_timer, NULL);
static int zmk_battery_init(struct device *_arg) { static int zmk_battery_init(const struct device *_arg) {
battery = device_get_binding("BATTERY"); battery = device_get_binding("BATTERY");
if (battery == NULL) { if (battery == NULL) {

2
app/src/behaviors/behavior_bt.c
View file

@ -35,7 +35,7 @@ static int on_keymap_binding_pressed(struct zmk_behavior_binding *binding,
return -ENOTSUP; return -ENOTSUP;
} }
static int behavior_bt_init(struct device *dev) { return 0; }; static int behavior_bt_init(const struct device *dev) { return 0; };
static int on_keymap_binding_released(struct zmk_behavior_binding *binding, static int on_keymap_binding_released(struct zmk_behavior_binding *binding,
struct zmk_behavior_binding_event event) { struct zmk_behavior_binding_event event) {

4
app/src/behaviors/behavior_ext_power.c
View file

@ -18,7 +18,7 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
static int on_keymap_binding_pressed(struct zmk_behavior_binding *binding, static int on_keymap_binding_pressed(struct zmk_behavior_binding *binding,
struct zmk_behavior_binding_event event) { struct zmk_behavior_binding_event event) {
struct device *ext_power = device_get_binding("EXT_POWER"); const struct device *ext_power = device_get_binding("EXT_POWER");
if (ext_power == NULL) { if (ext_power == NULL) {
LOG_ERR("Unable to retrieve ext_power device: %d", binding->param1); LOG_ERR("Unable to retrieve ext_power device: %d", binding->param1);
return -EIO; return -EIO;
@ -46,7 +46,7 @@ static int on_keymap_binding_released(struct zmk_behavior_binding *binding,
return 0; return 0;
} }
static int behavior_ext_power_init(struct device *dev) { return 0; }; static int behavior_ext_power_init(const struct device *dev) { return 0; };
static const struct behavior_driver_api behavior_ext_power_driver_api = { static const struct behavior_driver_api behavior_ext_power_driver_api = {
.binding_pressed = on_keymap_binding_pressed, .binding_pressed = on_keymap_binding_pressed,

4
app/src/behaviors/behavior_hold_tap.c
View file

@ -304,7 +304,7 @@ static void decide_hold_tap(struct active_hold_tap *hold_tap, enum decision_mome
static int on_hold_tap_binding_pressed(struct zmk_behavior_binding *binding, static int on_hold_tap_binding_pressed(struct zmk_behavior_binding *binding,
struct zmk_behavior_binding_event event) { struct zmk_behavior_binding_event event) {
struct device *dev = device_get_binding(binding->behavior_dev); const struct device *dev = device_get_binding(binding->behavior_dev);
const struct behavior_hold_tap_config *cfg = dev->config; const struct behavior_hold_tap_config *cfg = dev->config;
if (undecided_hold_tap != NULL) { if (undecided_hold_tap != NULL) {
@ -479,7 +479,7 @@ void behavior_hold_tap_timer_work_handler(struct k_work *item) {
} }
} }
static int behavior_hold_tap_init(struct device *dev) { static int behavior_hold_tap_init(const struct device *dev) {
static bool init_first_run = true; static bool init_first_run = true;
if (init_first_run) { if (init_first_run) {

2
app/src/behaviors/behavior_key_press.c
View file

@ -16,7 +16,7 @@
LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL); LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
static int behavior_key_press_init(struct device *dev) { return 0; }; static int behavior_key_press_init(const struct device *dev) { return 0; };
static int on_keymap_binding_pressed(struct zmk_behavior_binding *binding, static int on_keymap_binding_pressed(struct zmk_behavior_binding *binding,
struct zmk_behavior_binding_event event) { struct zmk_behavior_binding_event event) {

2
app/src/behaviors/behavior_momentary_layer.c
View file

@ -18,7 +18,7 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
struct behavior_mo_config {}; struct behavior_mo_config {};
struct behavior_mo_data {}; struct behavior_mo_data {};
static int behavior_mo_init(struct device *dev) { return 0; }; static int behavior_mo_init(const struct device *dev) { return 0; };
static int mo_keymap_binding_pressed(struct zmk_behavior_binding *binding, static int mo_keymap_binding_pressed(struct zmk_behavior_binding *binding,
struct zmk_behavior_binding_event event) { struct zmk_behavior_binding_event event) {

2
app/src/behaviors/behavior_none.c
View file

@ -18,7 +18,7 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
struct behavior_none_config {}; struct behavior_none_config {};
struct behavior_none_data {}; struct behavior_none_data {};
static int behavior_none_init(struct device *dev) { return 0; }; static int behavior_none_init(const struct device *dev) { return 0; };
static int on_keymap_binding_pressed(struct zmk_behavior_binding *binding, static int on_keymap_binding_pressed(struct zmk_behavior_binding *binding,
struct zmk_behavior_binding_event event) { struct zmk_behavior_binding_event event) {

2
app/src/behaviors/behavior_outputs.c
View file

@ -34,7 +34,7 @@ static int on_keymap_binding_pressed(struct zmk_behavior_binding *binding,
return -ENOTSUP; return -ENOTSUP;
} }
static int behavior_out_init(struct device *dev) { return 0; } static int behavior_out_init(const struct device *dev) { return 0; }
static const struct behavior_driver_api behavior_outputs_driver_api = { static const struct behavior_driver_api behavior_outputs_driver_api = {
.binding_pressed = on_keymap_binding_pressed, .binding_pressed = on_keymap_binding_pressed,

4
app/src/behaviors/behavior_reset.c
View file

@ -19,11 +19,11 @@ struct behavior_reset_config {
int type; int type;
}; };
static int behavior_reset_init(struct device *dev) { return 0; }; static int behavior_reset_init(const struct device *dev) { return 0; };
static int on_keymap_binding_pressed(struct zmk_behavior_binding *binding, static int on_keymap_binding_pressed(struct zmk_behavior_binding *binding,
struct zmk_behavior_binding_event event) { struct zmk_behavior_binding_event event) {
struct device *dev = device_get_binding(binding->behavior_dev); const struct device *dev = device_get_binding(binding->behavior_dev);
const struct behavior_reset_config *cfg = dev->config; const struct behavior_reset_config *cfg = dev->config;
// TODO: Correct magic code for going into DFU? // TODO: Correct magic code for going into DFU?

2
app/src/behaviors/behavior_rgb_underglow.c
View file

@ -16,7 +16,7 @@
LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL); LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
static int behavior_rgb_underglow_init(struct device *dev) { return 0; } static int behavior_rgb_underglow_init(const struct device *dev) { return 0; }
static int on_keymap_binding_pressed(struct zmk_behavior_binding *binding, static int on_keymap_binding_pressed(struct zmk_behavior_binding *binding,
struct zmk_behavior_binding_event event) { struct zmk_behavior_binding_event event) {

6
app/src/behaviors/behavior_sensor_rotate_key_press.c
View file

@ -16,10 +16,10 @@
LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL); LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
static int behavior_sensor_rotate_key_press_init(struct device *dev) { return 0; }; static int behavior_sensor_rotate_key_press_init(const struct device *dev) { return 0; };
static int on_sensor_binding_triggered(struct zmk_behavior_binding *binding, struct device *sensor, static int on_sensor_binding_triggered(struct zmk_behavior_binding *binding,
int64_t timestamp) { const struct device *sensor, int64_t timestamp) {
struct sensor_value value; struct sensor_value value;
int err; int err;
uint32_t keycode; uint32_t keycode;

4
app/src/behaviors/behavior_sticky_key.c
View file

@ -127,7 +127,7 @@ static int stop_timer(struct active_sticky_key *sticky_key) {
static int on_sticky_key_binding_pressed(struct zmk_behavior_binding *binding, static int on_sticky_key_binding_pressed(struct zmk_behavior_binding *binding,
struct zmk_behavior_binding_event event) { struct zmk_behavior_binding_event event) {
struct device *dev = device_get_binding(binding->behavior_dev); const struct device *dev = device_get_binding(binding->behavior_dev);
const struct behavior_sticky_key_config *cfg = dev->config; const struct behavior_sticky_key_config *cfg = dev->config;
struct active_sticky_key *sticky_key; struct active_sticky_key *sticky_key;
sticky_key = find_sticky_key(event.position); sticky_key = find_sticky_key(event.position);
@ -242,7 +242,7 @@ void behavior_sticky_key_timer_handler(struct k_work *item) {
} }
} }
static int behavior_sticky_key_init(struct device *dev) { static int behavior_sticky_key_init(const struct device *dev) {
static bool init_first_run = true; static bool init_first_run = true;
if (init_first_run) { if (init_first_run) {
for (int i = 0; i < ZMK_BHV_STICKY_KEY_MAX_HELD; i++) { for (int i = 0; i < ZMK_BHV_STICKY_KEY_MAX_HELD; i++) {

2
app/src/behaviors/behavior_toggle_layer.c
View file

@ -18,7 +18,7 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
struct behavior_tog_config {}; struct behavior_tog_config {};
struct behavior_tog_data {}; struct behavior_tog_data {};
static int behavior_tog_init(struct device *dev) { return 0; }; static int behavior_tog_init(const struct device *dev) { return 0; };
static int tog_keymap_binding_pressed(struct zmk_behavior_binding *binding, static int tog_keymap_binding_pressed(struct zmk_behavior_binding *binding,
struct zmk_behavior_binding_event event) { struct zmk_behavior_binding_event event) {

2
app/src/behaviors/behavior_transparent.c
View file

@ -18,7 +18,7 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
struct behavior_transparent_config {}; struct behavior_transparent_config {};
struct behavior_transparent_data {}; struct behavior_transparent_data {};
static int behavior_transparent_init(struct device *dev) { return 0; }; static int behavior_transparent_init(const struct device *dev) { return 0; };
static int on_keymap_binding_pressed(struct zmk_behavior_binding *binding, static int on_keymap_binding_pressed(struct zmk_behavior_binding *binding,
struct zmk_behavior_binding_event event) { struct zmk_behavior_binding_event event) {

2
app/src/ble.c
View file

@ -509,7 +509,7 @@ static void zmk_ble_ready(int err) {
update_advertising(); update_advertising();
} }
static int zmk_ble_init(struct device *_arg) { static int zmk_ble_init(const struct device *_arg) {
int err = bt_enable(NULL); int err = bt_enable(NULL);
if (err) { if (err) {

2
app/src/display/main.c
View file

@ -18,7 +18,7 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
#define ZMK_DISPLAY_NAME CONFIG_LVGL_DISPLAY_DEV_NAME #define ZMK_DISPLAY_NAME CONFIG_LVGL_DISPLAY_DEV_NAME
static struct device *display; static const struct device *display;
static lv_obj_t *screen; static lv_obj_t *screen;

2
app/src/endpoints.c
View file

@ -156,7 +156,7 @@ static int endpoints_handle_set(const char *name, size_t len, settings_read_cb r
struct settings_handler endpoints_handler = {.name = "endpoints", .h_set = endpoints_handle_set}; struct settings_handler endpoints_handler = {.name = "endpoints", .h_set = endpoints_handle_set};
#endif /* IS_ENABLED(CONFIG_SETTINGS) */ #endif /* IS_ENABLED(CONFIG_SETTINGS) */
static int zmk_endpoints_init(struct device *_arg) { static int zmk_endpoints_init(const struct device *_arg) {
#if IS_ENABLED(CONFIG_SETTINGS) #if IS_ENABLED(CONFIG_SETTINGS)
settings_subsys_init(); settings_subsys_init();

14
app/src/ext_power_generic.c
View file

@ -26,7 +26,7 @@ struct ext_power_generic_config {
}; };
struct ext_power_generic_data { struct ext_power_generic_data {
struct device *gpio; const struct device *gpio;
bool status; bool status;
#if IS_ENABLED(CONFIG_SETTINGS) #if IS_ENABLED(CONFIG_SETTINGS)
bool settings_init; bool settings_init;
@ -36,7 +36,7 @@ struct ext_power_generic_data {
#if IS_ENABLED(CONFIG_SETTINGS) #if IS_ENABLED(CONFIG_SETTINGS)
static void ext_power_save_state_work(struct k_work *work) { static void ext_power_save_state_work(struct k_work *work) {
char setting_path[40]; char setting_path[40];
struct device *ext_power = device_get_binding(DT_INST_LABEL(0)); const struct device *ext_power = device_get_binding(DT_INST_LABEL(0));
struct ext_power_generic_data *data = ext_power->data; struct ext_power_generic_data *data = ext_power->data;
snprintf(setting_path, 40, "ext_power/state/%s", DT_INST_LABEL(0)); snprintf(setting_path, 40, "ext_power/state/%s", DT_INST_LABEL(0));
@ -55,7 +55,7 @@ int ext_power_save_state() {
#endif #endif
} }
static int ext_power_generic_enable(struct device *dev) { static int ext_power_generic_enable(const struct device *dev) {
struct ext_power_generic_data *data = dev->data; struct ext_power_generic_data *data = dev->data;
const struct ext_power_generic_config *config = dev->config; const struct ext_power_generic_config *config = dev->config;
@ -67,7 +67,7 @@ static int ext_power_generic_enable(struct device *dev) {
return ext_power_save_state(); return ext_power_save_state();
} }
static int ext_power_generic_disable(struct device *dev) { static int ext_power_generic_disable(const struct device *dev) {
struct ext_power_generic_data *data = dev->data; struct ext_power_generic_data *data = dev->data;
const struct ext_power_generic_config *config = dev->config; const struct ext_power_generic_config *config = dev->config;
@ -79,7 +79,7 @@ static int ext_power_generic_disable(struct device *dev) {
return ext_power_save_state(); return ext_power_save_state();
} }
static int ext_power_generic_get(struct device *dev) { static int ext_power_generic_get(const struct device *dev) {
struct ext_power_generic_data *data = dev->data; struct ext_power_generic_data *data = dev->data;
return data->status; return data->status;
} }
@ -91,7 +91,7 @@ static int ext_power_settings_set(const char *name, size_t len, settings_read_cb
int rc; int rc;
if (settings_name_steq(name, DT_INST_LABEL(0), &next) && !next) { if (settings_name_steq(name, DT_INST_LABEL(0), &next) && !next) {
struct device *ext_power = device_get_binding(DT_INST_LABEL(0)); const struct device *ext_power = device_get_binding(DT_INST_LABEL(0));
struct ext_power_generic_data *data = ext_power->data; struct ext_power_generic_data *data = ext_power->data;
if (len != sizeof(data->status)) { if (len != sizeof(data->status)) {
@ -124,7 +124,7 @@ struct settings_handler ext_power_conf = {.name = "ext_power/state",
.h_set = ext_power_settings_set}; .h_set = ext_power_settings_set};
#endif #endif
static int ext_power_generic_init(struct device *dev) { static int ext_power_generic_init(const struct device *dev) {
struct ext_power_generic_data *data = dev->data; struct ext_power_generic_data *data = dev->data;
const struct ext_power_generic_config *config = dev->config; const struct ext_power_generic_config *config = dev->config;

7
app/src/keymap.c
View file

@ -121,7 +121,7 @@ bool is_active_layer(uint8_t layer, zmk_keymap_layers_state layer_state) {
int zmk_keymap_apply_position_state(int layer, uint32_t position, bool pressed, int64_t timestamp) { int zmk_keymap_apply_position_state(int layer, uint32_t position, bool pressed, int64_t timestamp) {
struct zmk_behavior_binding *binding = &zmk_keymap[layer][position]; struct zmk_behavior_binding *binding = &zmk_keymap[layer][position];
struct device *behavior; const struct device *behavior;
struct zmk_behavior_binding_event event = { struct zmk_behavior_binding_event event = {
.layer = layer, .layer = layer,
.position = position, .position = position,
@ -168,13 +168,14 @@ int zmk_keymap_position_state_changed(uint32_t position, bool pressed, int64_t t
} }
#if ZMK_KEYMAP_HAS_SENSORS #if ZMK_KEYMAP_HAS_SENSORS
int zmk_keymap_sensor_triggered(uint8_t sensor_number, struct device *sensor, int64_t timestamp) { int zmk_keymap_sensor_triggered(uint8_t sensor_number, const struct device *sensor,
int64_t timestamp) {
for (int layer = ZMK_KEYMAP_LAYERS_LEN - 1; layer >= _zmk_keymap_layer_default; layer--) { for (int layer = ZMK_KEYMAP_LAYERS_LEN - 1; layer >= _zmk_keymap_layer_default; layer--) {
if (((_zmk_keymap_layer_state & BIT(layer)) == BIT(layer) || if (((_zmk_keymap_layer_state & BIT(layer)) == BIT(layer) ||
layer == _zmk_keymap_layer_default) && layer == _zmk_keymap_layer_default) &&
zmk_sensor_keymap[layer] != NULL) { zmk_sensor_keymap[layer] != NULL) {
struct zmk_behavior_binding *binding = &zmk_sensor_keymap[layer][sensor_number]; struct zmk_behavior_binding *binding = &zmk_sensor_keymap[layer][sensor_number];
struct device *behavior; const struct device *behavior;
int ret; int ret;
LOG_DBG("layer: %d sensor_number: %d, binding name: %s", layer, sensor_number, LOG_DBG("layer: %d sensor_number: %d, binding name: %s", layer, sensor_number,

5
app/src/kscan.c
View file

@ -30,7 +30,8 @@ struct zmk_kscan_msg_processor {
K_MSGQ_DEFINE(zmk_kscan_msgq, sizeof(struct zmk_kscan_event), CONFIG_ZMK_KSCAN_EVENT_QUEUE_SIZE, 4); K_MSGQ_DEFINE(zmk_kscan_msgq, sizeof(struct zmk_kscan_event), CONFIG_ZMK_KSCAN_EVENT_QUEUE_SIZE, 4);
static void zmk_kscan_callback(struct device *dev, uint32_t row, uint32_t column, bool pressed) { static void zmk_kscan_callback(const struct device *dev, uint32_t row, uint32_t column,
bool pressed) {
struct zmk_kscan_event ev = { struct zmk_kscan_event ev = {
.row = row, .row = row,
.column = column, .column = column,
@ -58,7 +59,7 @@ void zmk_kscan_process_msgq(struct k_work *item) {
} }
int zmk_kscan_init(char *name) { int zmk_kscan_init(char *name) {
struct device *dev = device_get_binding(name); const struct device *dev = device_get_binding(name);
if (dev == NULL) { if (dev == NULL) {
LOG_ERR("Failed to get the KSCAN device"); LOG_ERR("Failed to get the KSCAN device");
return -EINVAL; return -EINVAL;

6
app/src/rgb_underglow.c
View file

@ -46,14 +46,14 @@ struct rgb_underglow_state {
bool on; bool on;
}; };
static struct device *led_strip; static const struct device *led_strip;
static struct led_rgb pixels[STRIP_NUM_PIXELS]; static struct led_rgb pixels[STRIP_NUM_PIXELS];
static struct rgb_underglow_state state; static struct rgb_underglow_state state;
#if IS_ENABLED(CONFIG_ZMK_RGB_UNDERGLOW_EXT_POWER) #if IS_ENABLED(CONFIG_ZMK_RGB_UNDERGLOW_EXT_POWER)
static struct device *ext_power; static const struct device *ext_power;
#endif #endif
static struct led_rgb hsb_to_rgb(struct led_hsb hsb) { static struct led_rgb hsb_to_rgb(struct led_hsb hsb) {
@ -238,7 +238,7 @@ static void zmk_rgb_underglow_save_state_work() {
static struct k_delayed_work underglow_save_work; static struct k_delayed_work underglow_save_work;
#endif #endif
static int zmk_rgb_underglow_init(struct device *_arg) { static int zmk_rgb_underglow_init(const struct device *_arg) {
led_strip = device_get_binding(STRIP_LABEL); led_strip = device_get_binding(STRIP_LABEL);
if (led_strip) { if (led_strip) {
LOG_INF("Found LED strip device %s", STRIP_LABEL); LOG_INF("Found LED strip device %s", STRIP_LABEL);

6
app/src/sensors.c
View file

@ -20,7 +20,7 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
struct sensors_data_item { struct sensors_data_item {
uint8_t sensor_number; uint8_t sensor_number;
struct device *dev; const struct device *dev;
struct sensor_trigger trigger; struct sensor_trigger trigger;
}; };
@ -32,7 +32,7 @@ struct sensors_data_item {
static struct sensors_data_item sensors[] = {UTIL_LISTIFY(ZMK_KEYMAP_SENSORS_LEN, SENSOR_ITEM, 0)}; static struct sensors_data_item sensors[] = {UTIL_LISTIFY(ZMK_KEYMAP_SENSORS_LEN, SENSOR_ITEM, 0)};
static void zmk_sensors_trigger_handler(struct device *dev, struct sensor_trigger *trigger) { static void zmk_sensors_trigger_handler(const struct device *dev, struct sensor_trigger *trigger) {
int err; int err;
struct sensors_data_item *item = CONTAINER_OF(trigger, struct sensors_data_item, trigger); struct sensors_data_item *item = CONTAINER_OF(trigger, struct sensors_data_item, trigger);
struct sensor_event *event; struct sensor_event *event;
@ -72,7 +72,7 @@ static void zmk_sensors_init_item(const char *node, uint8_t i, uint8_t abs_i) {
COND_CODE_1(DT_NODE_HAS_STATUS(ZMK_KEYMAP_SENSORS_BY_IDX(idx), okay), \ COND_CODE_1(DT_NODE_HAS_STATUS(ZMK_KEYMAP_SENSORS_BY_IDX(idx), okay), \
(_SENSOR_INIT(ZMK_KEYMAP_SENSORS_BY_IDX(idx))), (absolute_index++;)) (_SENSOR_INIT(ZMK_KEYMAP_SENSORS_BY_IDX(idx))), (absolute_index++;))
static int zmk_sensors_init(struct device *_arg) { static int zmk_sensors_init(const struct device *_arg) {
int local_index = 0; int local_index = 0;
int absolute_index = 0; int absolute_index = 0;

2
app/src/settings.c
View file

@ -3,6 +3,6 @@
#include <kernel.h> #include <kernel.h>
#include <settings/settings.h> #include <settings/settings.h>
static int zmk_settings_init(struct device *_arg) { return settings_load(); } static int zmk_settings_init(const struct device *_arg) { return settings_load(); }
SYS_INIT(zmk_settings_init, APPLICATION, CONFIG_APPLICATION_INIT_PRIORITY); SYS_INIT(zmk_settings_init, APPLICATION, CONFIG_APPLICATION_INIT_PRIORITY);

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

@ -315,7 +315,7 @@ static struct bt_conn_cb conn_callbacks = {
.disconnected = split_central_disconnected, .disconnected = split_central_disconnected,
}; };
int zmk_split_bt_central_init(struct device *_arg) { int zmk_split_bt_central_init(const struct device *_arg) {
bt_conn_cb_register(&conn_callbacks); bt_conn_cb_register(&conn_callbacks);
return start_scan(); return start_scan();

4
app/src/usb.c
View file

@ -21,7 +21,7 @@ static enum usb_dc_status_code usb_status = USB_DC_UNKNOWN;
#ifdef CONFIG_ZMK_USB #ifdef CONFIG_ZMK_USB
static struct device *hid_dev; static const struct device *hid_dev;
static K_SEM_DEFINE(hid_sem, 1, 1); static K_SEM_DEFINE(hid_sem, 1, 1);
@ -83,7 +83,7 @@ void usb_status_cb(enum usb_dc_status_code status, const uint8_t *params) {
raise_usb_status_changed_event(); raise_usb_status_changed_event();
}; };
static int zmk_usb_init(struct device *_arg) { static int zmk_usb_init(const struct device *_arg) {
int usb_enable_ret; int usb_enable_ret;
#ifdef CONFIG_ZMK_USB #ifdef CONFIG_ZMK_USB