Fix preprocessor flag issues for pull request.

2 files changed, 20 insertions, 19 deletions

diff --git a/app/drivers/zephyr/kscan_gpio_direct.c b/app/drivers/zephyr/kscan_gpio_direct.c
index 7ba3399..c3414fb 100644
--- a/app/drivers/zephyr/kscan_gpio_direct.c
+++ b/app/drivers/zephyr/kscan_gpio_direct.c
@@ -33,9 +33,9 @@ struct kscan_gpio_config {
 };
 
 struct kscan_gpio_data {
-#if defined(ZMK_KSCAN_DIRECT_POLLING)
+#if defined(CONFIG_ZMK_KSCAN_DIRECT_POLLING)
     struct k_timer poll_timer;
-#endif /* defined(ZMK_KSCAN_DIRECT_POLLING) */
+#endif /* defined(CONFIG_ZMK_KSCAN_DIRECT_POLLING) */
     kscan_callback_t callback;
     union work_reference work;
     struct device *dev;
@@ -53,7 +53,7 @@ static const struct kscan_gpio_item_config *kscan_gpio_input_configs(struct devi
     return cfg->inputs;
 }
 
-#if !defined(ZMK_KSCAN_DIRECT_POLLING)
+#if !defined(CONFIG_ZMK_KSCAN_DIRECT_POLLING)
 
 struct kscan_gpio_irq_callback {
     union work_reference *work;
@@ -101,7 +101,7 @@ static void kscan_gpio_irq_callback_handler(struct device *dev, struct gpio_call
     }
 }
 
-#else /* !defined(ZMK_KSCAN_DIRECT_POLLING) */
+#else /* !defined(CONFIG_ZMK_KSCAN_DIRECT_POLLING) */
 
 static void kscan_gpio_timer_handler(struct k_timer *timer) {
     struct kscan_gpio_data *data = CONTAINER_OF(timer, struct kscan_gpio_data, poll_timer);
@@ -120,7 +120,7 @@ static int kscan_gpio_direct_disable(struct device *dev) {
     return 0;
 }
 
-#endif /* defined(ZMK_KSCAN_DIRECT_POLLING) */
+#endif /* defined(CONFIG_ZMK_KSCAN_DIRECT_POLLING) */
 
 static int kscan_gpio_direct_configure(struct device *dev, kscan_callback_t callback) {
     struct kscan_gpio_data *data = dev->driver_data;
@@ -173,7 +173,7 @@ static const struct kscan_driver_api gpio_driver_api = {
 #define INST_INPUT_LEN(n) DT_INST_PROP_LEN(n, input_gpios)
 
 #define GPIO_INST_INIT(n)                                                                          \
-    COND_CODE_0(ZMK_KSCAN_DIRECT_POLLING,                                                     \
+    COND_CODE_0(CONFIG_ZMK_KSCAN_DIRECT_POLLING,                                                     \
                 (static struct kscan_gpio_irq_callback irq_callbacks_##n[INST_INPUT_LEN(n)];), ()) \
     static struct kscan_gpio_data kscan_gpio_data_##n = {                                          \
         .inputs = {[INST_INPUT_LEN(n) - 1] = NULL}};                                               \
@@ -195,7 +195,7 @@ static const struct kscan_driver_api gpio_driver_api = {
                 return err;                                                                        \
             }                                                                                      \
             COND_CODE_0(                                                                           \
-                ZMK_KSCAN_DIRECT_POLLING,                                                     \
+                CONFIG_ZMK_KSCAN_DIRECT_POLLING,                                                     \
                 (irq_callbacks_##n[i].work = &data->work;                                          \
                  irq_callbacks_##n[i].debounce_period = cfg->debounce_period;                      \
                  gpio_init_callback(&irq_callbacks_##n[i].callback,                                \
@@ -208,7 +208,7 @@ static const struct kscan_driver_api gpio_driver_api = {
                 ())                                                                                \
         }                                                                                          \
         data->dev = dev;                                                                           \
-        COND_CODE_1(ZMK_KSCAN_DIRECT_POLLING,                                                 \
+        COND_CODE_1(CONFIG_ZMK_KSCAN_DIRECT_POLLING,                                                 \
                     (k_timer_init(&data->poll_timer, kscan_gpio_timer_handler, NULL);), ())        \
         if (cfg->debounce_period > 0) {                                                            \
             k_delayed_work_init(&data->work.delayed, kscan_gpio_work_handler);                     \
diff --git a/app/drivers/zephyr/kscan_gpio_matrix.c b/app/drivers/zephyr/kscan_gpio_matrix.c
index e581d33..b940c6d 100644
--- a/app/drivers/zephyr/kscan_gpio_matrix.c
+++ b/app/drivers/zephyr/kscan_gpio_matrix.c
@@ -31,8 +31,8 @@ struct kscan_gpio_item_config {
 #define _KSCAN_GPIO_ROW_CFG_INIT(idx, n) _KSCAN_GPIO_ITEM_CFG_INIT(n, row_gpios, idx)
 #define _KSCAN_GPIO_COL_CFG_INIT(idx, n) _KSCAN_GPIO_ITEM_CFG_INIT(n, col_gpios, idx)
 
-COND_CODE_0(ZMK_KSCAN_MATRIX_POLLING,
-(static int kscan_gpio_config_interrupts(struct device **devices,
+#ifdef CONFIG_ZMK_KSCAN_MATRIX_POLLING
+static int kscan_gpio_config_interrupts(struct device **devices,
                                         const struct kscan_gpio_item_config *configs, size_t len,
                                         gpio_flags_t flags) {
     for (int i = 0; i < len; i++) {
@@ -48,7 +48,8 @@ COND_CODE_0(ZMK_KSCAN_MATRIX_POLLING,
     }
 
     return 0;
-}), ())
+}
+#endif
 
 #define INST_MATRIX_ROWS(n) DT_INST_PROP_LEN(n, row_gpios)
 #define INST_MATRIX_COLS(n) DT_INST_PROP_LEN(n, col_gpios)
@@ -71,7 +72,7 @@ COND_CODE_0(ZMK_KSCAN_MATRIX_POLLING,
     };                                                                                             \
     struct kscan_gpio_data_##n {                                                                   \
         kscan_callback_t callback;                                                                 \
-        COND_CODE_0(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)];                                                  \
@@ -99,7 +100,7 @@ COND_CODE_0(ZMK_KSCAN_MATRIX_POLLING,
         return (                                                                                   \
             COND_CODE_0(DT_ENUM_IDX(DT_DRV_INST(n), diode_direction), (cfg->rows), (cfg->cols)));  \
     }                                                                                              \
-    COND_CODE_0(ZMK_KSCAN_MATRIX_POLLING,                                                          \
+    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),  \
@@ -132,7 +133,7 @@ COND_CODE_0(ZMK_KSCAN_MATRIX_POLLING,
         /* 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(ZMK_KSCAN_MATRIX_POLLING,                                                      \
+        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++) {                                             \
@@ -151,7 +152,7 @@ COND_CODE_0(ZMK_KSCAN_MATRIX_POLLING,
         /* 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(ZMK_KSCAN_MATRIX_POLLING,                                                      \
+        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++) {                                        \
@@ -200,7 +201,7 @@ COND_CODE_0(ZMK_KSCAN_MATRIX_POLLING,
         return 0;                                                                                  \
     };                                                                                             \
     static int kscan_gpio_enable_##n(struct device *dev) {                                         \
-        COND_CODE_0(ZMK_KSCAN_MATRIX_POLLING,                                                      \
+        COND_CODE_0(CONFIG_ZMK_KSCAN_MATRIX_POLLING,                                                      \
         (int err = kscan_gpio_enable_interrupts_##n(dev);                                          \
          if (err) {                                                                                \
              return err;                                                                           \
@@ -211,13 +212,13 @@ COND_CODE_0(ZMK_KSCAN_MATRIX_POLLING,
          return 0;))                                                                               \
     };                                                                                             \
     static int kscan_gpio_disable_##n(struct device *dev) {                                        \
-        COND_CODE_0(ZMK_KSCAN_MATRIX_POLLING,                                                      \
+        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(ZMK_KSCAN_MATRIX_POLLING, (),                                                      \
+    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);              \
@@ -267,7 +268,7 @@ COND_CODE_0(ZMK_KSCAN_MATRIX_POLLING,
             }                                                                                      \
         }                                                                                          \
         data->dev = dev;                                                                           \
-        COND_CODE_0(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);                                             \