chore: Fix some accidental formatting issues.

1 files changed, 32 insertions, 37 deletions

diff --git a/app/drivers/zephyr/kscan_gpio_matrix.c b/app/drivers/zephyr/kscan_gpio_matrix.c
index 5fa618b..62008e3 100644
--- a/app/drivers/zephyr/kscan_gpio_matrix.c
+++ b/app/drivers/zephyr/kscan_gpio_matrix.c
@@ -72,7 +72,7 @@ static int kscan_gpio_config_interrupts(struct device **devices,
     };                                                                                             \
     struct kscan_gpio_data_##n {                                                                   \
         kscan_callback_t callback;                                                                 \
-        COND_CODE_0(CONFIG_ZMK_KSCAN_MATRIX_POLLING, (), (struct k_timer poll_timer;))                    \
+        COND_CODE_0(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;     \
         bool matrix_state[INST_MATRIX_ROWS(n)][INST_MATRIX_COLS(n)];                               \
         struct device *rows[INST_MATRIX_ROWS(n)];                                                  \
@@ -100,17 +100,18 @@ static int kscan_gpio_config_interrupts(struct device **devices,
         return (                                                                                   \
             COND_CODE_0(DT_ENUM_IDX(DT_DRV_INST(n), diode_direction), (cfg->rows), (cfg->cols)));  \
     }                                                                                              \
-    COND_CODE_0(CONFIG_ZMK_KSCAN_MATRIX_POLLING,                                                          \
-        (static int kscan_gpio_enable_interrupts_##n(struct device *dev) {                         \
-            return kscan_gpio_config_interrupts(kscan_gpio_input_devices_##n(dev),                 \
-                                            kscan_gpio_input_configs_##n(dev), INST_INPUT_LEN(n),  \
-                                            GPIO_INT_DEBOUNCE | GPIO_INT_EDGE_BOTH);               \
-         }                                                                                         \
-         static int kscan_gpio_disable_interrupts_##n(struct device *dev) {                        \
-            return kscan_gpio_config_interrupts(kscan_gpio_input_devices_##n(dev),                 \
-                                            kscan_gpio_input_configs_##n(dev), INST_INPUT_LEN(n),  \
-                                            GPIO_INT_DISABLE);                                     \
-         }), ())                                                                                   \
+    COND_CODE_0(CONFIG_ZMK_KSCAN_MATRIX_POLLING,                                                   \
+                (                                                                                  \
+                    static int kscan_gpio_enable_interrupts_##n(struct device *dev) {              \
+                        return kscan_gpio_config_interrupts(                                       \
+                            kscan_gpio_input_devices_##n(dev), kscan_gpio_input_configs_##n(dev),  \
+                            INST_INPUT_LEN(n), GPIO_INT_DEBOUNCE | GPIO_INT_EDGE_BOTH);            \
+                    } static int kscan_gpio_disable_interrupts_##n(struct device *dev) {           \
+                        return kscan_gpio_config_interrupts(kscan_gpio_input_devices_##n(dev),     \
+                                                            kscan_gpio_input_configs_##n(dev),     \
+                                                            INST_INPUT_LEN(n), GPIO_INT_DISABLE);  \
+                    }),                                                                            \
+                ())                                                                                \
     static void kscan_gpio_set_output_state_##n(struct device *dev, int value) {                   \
         for (int i = 0; i < INST_OUTPUT_LEN(n); i++) {                                             \
             struct device *in_dev = kscan_gpio_output_devices_##n(dev)[i];                         \
@@ -133,8 +134,8 @@ static int kscan_gpio_config_interrupts(struct device **devices,
         /* Disable our interrupts temporarily while we scan, to avoid       */                     \
         /* re-entry while we iterate columns and set them active one by one */                     \
         /* to get pressed state for each matrix cell.                       */                     \
-        COND_CODE_0(CONFIG_ZMK_KSCAN_MATRIX_POLLING,                                                      \
-            (kscan_gpio_disable_interrupts_##n(dev);),())                                          \
+        COND_CODE_0(CONFIG_ZMK_KSCAN_MATRIX_POLLING, (kscan_gpio_disable_interrupts_##n(dev);),    \
+                    ())                                                                            \
         kscan_gpio_set_output_state_##n(dev, 0);                                                   \
         for (int o = 0; o < INST_OUTPUT_LEN(n); o++) {                                             \
             struct device *out_dev = kscan_gpio_output_devices_##n(dev)[o];                        \
@@ -152,8 +153,7 @@ static int kscan_gpio_config_interrupts(struct device **devices,
         /* Set all our outputs as active again. */                                                 \
         kscan_gpio_set_output_state_##n(dev, 1);                                                   \
         /*Re-enable interrupts so that they can be triggered again for future press/release*/      \
-        COND_CODE_0(CONFIG_ZMK_KSCAN_MATRIX_POLLING,                                                      \
-            (kscan_gpio_enable_interrupts_##n(dev);), ())                                         \
+        COND_CODE_0(CONFIG_ZMK_KSCAN_MATRIX_POLLING, (kscan_gpio_enable_interrupts_##n(dev);), ()) \
         for (int r = 0; r < INST_MATRIX_ROWS(n); r++) {                                            \
             for (int c = 0; c < INST_MATRIX_COLS(n); c++) {                                        \
                 bool pressed = read_state[r][c];                                                   \
@@ -201,29 +201,24 @@ static int kscan_gpio_config_interrupts(struct device **devices,
         return 0;                                                                                  \
     };                                                                                             \
     static int kscan_gpio_enable_##n(struct device *dev) {                                         \
-        COND_CODE_0(CONFIG_ZMK_KSCAN_MATRIX_POLLING,                                                      \
-        (int err = kscan_gpio_enable_interrupts_##n(dev);                                          \
-         if (err) {                                                                                \
-             return err;                                                                           \
-         }                                                                                         \
-         return kscan_gpio_read_##n(dev);),                                                        \
-        (struct kscan_gpio_data_##n *data = dev->driver_data;                                      \
-         k_timer_start(&data->poll_timer, K_MSEC(10), K_MSEC(10));                                 \
-         return 0;))                                                                               \
+        COND_CODE_0(CONFIG_ZMK_KSCAN_MATRIX_POLLING,                                               \
+                    (int err = kscan_gpio_enable_interrupts_##n(dev);                              \
+                     if (err) { return err; } return kscan_gpio_read_##n(dev);),                   \
+                    (struct kscan_gpio_data_##n *data = dev->driver_data;                          \
+                     k_timer_start(&data->poll_timer, K_MSEC(10), K_MSEC(10)); return 0;))         \
     };                                                                                             \
     static int kscan_gpio_disable_##n(struct device *dev) {                                        \
-        COND_CODE_0(CONFIG_ZMK_KSCAN_MATRIX_POLLING,                                                      \
-            (return kscan_gpio_disable_interrupts_##n(dev);),                                      \
-            (struct kscan_gpio_data_##n *data = dev->driver_data;                                  \
-             k_timer_stop(&data->poll_timer);                                                      \
-             return 0;))                                                                           \
+        COND_CODE_0(CONFIG_ZMK_KSCAN_MATRIX_POLLING,                                               \
+                    (return kscan_gpio_disable_interrupts_##n(dev);),                              \
+                    (struct kscan_gpio_data_##n *data = dev->driver_data;                          \
+                     k_timer_stop(&data->poll_timer); return 0;))                                  \
     };                                                                                             \
-    COND_CODE_0(CONFIG_ZMK_KSCAN_MATRIX_POLLING, (),                                                      \
-        (static void kscan_gpio_timer_handler(struct k_timer *timer) {                             \
-             struct kscan_gpio_data_##n *data =                                                    \
-                         CONTAINER_OF(timer, struct kscan_gpio_data_##n, poll_timer);              \
-             k_work_submit(&data->work.work);                                                      \
-         }))                                                                                       \
+    COND_CODE_0(CONFIG_ZMK_KSCAN_MATRIX_POLLING, (),                                               \
+                (static void kscan_gpio_timer_handler(struct k_timer *timer) {                     \
+                    struct kscan_gpio_data_##n *data =                                             \
+                        CONTAINER_OF(timer, struct kscan_gpio_data_##n, poll_timer);               \
+                    k_work_submit(&data->work.work);                                               \
+                }))                                                                                \
     static int kscan_gpio_init_##n(struct device *dev) {                                           \
         struct kscan_gpio_data_##n *data = dev->driver_data;                                       \
         int err;                                                                                   \
@@ -268,7 +263,7 @@ static int kscan_gpio_config_interrupts(struct device **devices,
             }                                                                                      \
         }                                                                                          \
         data->dev = dev;                                                                           \
-        COND_CODE_0(CONFIG_ZMK_KSCAN_MATRIX_POLLING, (),                                                  \
+        COND_CODE_0(CONFIG_ZMK_KSCAN_MATRIX_POLLING, (),                                           \
                     (k_timer_init(&data->poll_timer, kscan_gpio_timer_handler, NULL);))            \
         (COND_CODE_0(DT_INST_PROP(n, debounce_period), (k_work_init), (k_delayed_work_init)))(     \
             &data->work, kscan_gpio_work_handler_##n);                                             \