drv/counter: refactor driver interface

This reworks the counter driver to be more like the recent PWM and LED
drivers.

The contiki process and register/unregister callbacks are removed and
replaced with a simple init function.

Author: dlech

lib/pbio/doc/doxygen.conf

@@ -2108,6 +2108,7 @@ PREDEFINED = \
     PBIO_CONFIG_LIGHT=1 \
     PBIO_CONFIG_LIGHTGRID=1 \
     PBIO_CONFIG_ENABLE_SYS \
+    PBDRV_CONFIG_COUNTER=1 \
     PBDRV_CONFIG_LED=1
     PBDRV_CONFIG_PWM=1
     PBDRV_CONFIG_RESET=1

lib/pbio/drv/core.c

@@ -7,11 +7,14 @@
 #include <pbdrv/led.h>
 #include <pbdrv/pwm.h>
 
+#include "counter/counter.h"
+
 /** Initializes all enabled drivers. */
 void pbdrv_init() {
     clock_init();
     process_init();
     pbdrv_battery_init();
+    pbdrv_counter_init();
     pbdrv_led_init();
     pbdrv_pwm_init();
 }

lib/pbio/drv/counter/counter.h

@@ -4,35 +4,35 @@
 #ifndef _PBDRV_COUNTER_COUNTER_H_
 #define _PBDRV_COUNTER_COUNTER_H_
 
-#include <stdbool.h>
 #include <stdint.h>
 
 #include <pbdrv/config.h>
 #include <pbdrv/counter.h>
 #include <pbio/error.h>
 
-struct _pbdrv_counter_dev_t {
+typedef struct {
     pbio_error_t (*get_count)(pbdrv_counter_dev_t *dev, int32_t *count);
     pbio_error_t (*get_abs_count)(pbdrv_counter_dev_t *dev, int32_t *count);
     pbio_error_t (*get_rate)(pbdrv_counter_dev_t *dev, int32_t *rate);
-    bool initalized;
-};
+} pbdrv_counter_funcs_t;
 
-typedef struct {
-    pbio_error_t (*init)();
-    pbio_error_t (*exit)();
-} pbdrv_counter_drv_t;
+struct _pbdrv_counter_dev_t {
+    /** Platform-specific data. */
+    const void *pdata;
+    /** Driver-specific callback functions. */
+    const pbdrv_counter_funcs_t *funcs;
+    /** Private instance-specific state. */
+    void *priv;
+};
 
 #if PBDRV_CONFIG_COUNTER
-pbio_error_t pbdrv_counter_register(uint8_t id, pbdrv_counter_dev_t *dev);
-pbio_error_t pbdrv_counter_unregister(pbdrv_counter_dev_t *dev);
+
+void pbdrv_counter_init();
+
 #else // PBDRV_CONFIG_COUNTER
-static inline pbio_error_t pbdrv_counter_register(uint8_t id, pbdrv_counter_dev_t *dev) {
-    return PBIO_ERROR_NOT_SUPPORTED;
-}
-static inline pbio_error_t pbdrv_counter_unregister(pbdrv_counter_dev_t *dev) {
-    return PBIO_ERROR_NOT_SUPPORTED;
-}
+
+#define pbdrv_counter_init()
+
 #endif // PBDRV_CONFIG_COUNTER
 
 #endif // _PBDRV_COUNTER_COUNTER_H_

lib/pbio/drv/counter/counter_core.c

@@ -5,66 +5,51 @@
 
 #if PBDRV_CONFIG_COUNTER
 
-#include <assert.h>
-#include <stdbool.h>
-#include <stdio.h>
-
-#include <contiki.h>
+#include <stdint.h>
 
 #include <pbdrv/counter.h>
 #include <pbio/error.h>
-#include "counter.h"
-#include "counter_nxt.h"
+
+#include "../src/uartdev.h"
 #include "counter_ev3dev_stretch_iio.h"
+#include "counter_nxt.h"
 #include "counter_stm32f0_gpio_quad_enc.h"
+#include "counter.h"
 
-PROCESS(pbdrv_counter_process, "counter driver");
-
-static pbdrv_counter_dev_t *pbdrv_counters[PBDRV_CONFIG_COUNTER_NUM_DEV];
-
-pbio_error_t pbdrv_counter_register(uint8_t id, pbdrv_counter_dev_t *dev) {
-    if (id >= PBDRV_CONFIG_COUNTER_NUM_DEV) {
-        return PBIO_ERROR_INVALID_ARG;
-    }
-
-    assert(pbdrv_counters[id] == NULL);
-
-    pbdrv_counters[id] = dev;
-
-    return PBIO_SUCCESS;
-}
-
-pbio_error_t pbdrv_counter_unregister(pbdrv_counter_dev_t *dev) {
-    for (int i = 0; i < PBDRV_CONFIG_COUNTER_NUM_DEV; i++) {
-        if (pbdrv_counters[i] == dev) {
-            pbdrv_counters[i] = NULL;
-            return PBIO_SUCCESS;
-        }
-    }
+static pbdrv_counter_dev_t pbdrv_counter_devs[PBDRV_CONFIG_COUNTER_NUM_DEV];
 
-    return PBIO_ERROR_INVALID_ARG;
+void pbdrv_counter_init() {
+    pbdrv_counter_ev3dev_stretch_iio_init(pbdrv_counter_devs);
+    pbdrv_counter_nxt_init(pbdrv_counter_devs);
+    pbdrv_counter_stm32f0_gpio_quad_enc_init(pbdrv_counter_devs);
+    pbio_uartdev_counter_init(pbdrv_counter_devs);
 }
 
-pbio_error_t pbdrv_counter_get(uint8_t id, pbdrv_counter_dev_t **dev) {
+pbio_error_t pbdrv_counter_get_dev(uint8_t id, pbdrv_counter_dev_t **dev) {
     if (id >= PBDRV_CONFIG_COUNTER_NUM_DEV) {
-        return PBIO_ERROR_INVALID_ARG;
+        return PBIO_ERROR_NO_DEV;
     }
 
-    if (pbdrv_counters[id] == NULL || !pbdrv_counters[id]->initalized) {
+    *dev = &pbdrv_counter_devs[id];
+
+    if ((*dev)->funcs == NULL) {
+        // has not been intialized yet
         return PBIO_ERROR_AGAIN;
     }
 
-    *dev = pbdrv_counters[id];
-
     return PBIO_SUCCESS;
 }
 
+/**
+ * Gets the absolute count if the counter supports it.
+ * @param [in]  dev     Pointer to the counter device
+ * @param [out] count   Returns the count on success
+ * @return              ::PBIO_SUCCESS on success, ::PBIO_ERROR_NO_DEV if the
+ *                      counter has not been initialized, ::PBIO_ERROR_NOT_SUPPORTED
+ *                      if this counter does not support reading the absolute count.
+ */
 pbio_error_t pbdrv_counter_get_count(pbdrv_counter_dev_t *dev, int32_t *count) {
-    if (!dev->initalized) {
-        return PBIO_ERROR_NO_DEV;
-    }
-
-    return dev->get_count(dev, count);
+    return dev->funcs->get_count(dev, count);
 }
 
 /**
@@ -76,57 +61,23 @@ pbio_error_t pbdrv_counter_get_count(pbdrv_counter_dev_t *dev, int32_t *count) {
  *                      if this counter does not support reading the absolute count.
  */
 pbio_error_t pbdrv_counter_get_abs_count(pbdrv_counter_dev_t *dev, int32_t *count) {
-    if (!dev->initalized) {
-        return PBIO_ERROR_NO_DEV;
-    }
-
-    if (!dev->get_abs_count) {
+    if (!dev->funcs->get_abs_count) {
         return PBIO_ERROR_NOT_SUPPORTED;
     }
 
-    return dev->get_abs_count(dev, count);
+    return dev->funcs->get_abs_count(dev, count);
 }
 
+/**
+ * Gets the counter rate in counts per second.
+ * @param [in]  dev     Pointer to the counter device
+ * @param [out] rate    Returns the rate on success
+ * @return              ::PBIO_SUCCESS on success, ::PBIO_ERROR_NO_DEV if the
+ *                      counter has not been initialized, ::PBIO_ERROR_NOT_SUPPORTED
+ *                      if this counter does not support reading the rate.
+ */
 pbio_error_t pbdrv_counter_get_rate(pbdrv_counter_dev_t *dev, int32_t *rate) {
-    if (!dev->initalized) {
-        return PBIO_ERROR_NO_DEV;
-    }
-
-    return dev->get_rate(dev, rate);
-}
-
-static void pbdrv_counter_process_exit() {
-    #if PBDRV_CONFIG_COUNTER_NXT
-    pbdrv_counter_nxt_drv.exit();
-    #endif
-    #if PBDRV_CONFIG_COUNTER_EV3DEV_STRETCH_IIO
-    pbdrv_counter_ev3dev_stretch_iio_drv.exit();
-    #endif
-    #if PBDRV_CONFIG_COUNTER_STM32F0_GPIO_QUAD_ENC
-    pbdrv_counter_stm32f0_gpio_quad_enc_drv.exit();
-    #endif
-}
-
-PROCESS_THREAD(pbdrv_counter_process, ev, data) {
-    PROCESS_EXITHANDLER(pbdrv_counter_process_exit());
-
-    PROCESS_BEGIN();
-
-    #if PBDRV_CONFIG_COUNTER_NXT
-    pbdrv_counter_nxt_drv.init();
-    #endif
-    #if PBDRV_CONFIG_COUNTER_EV3DEV_STRETCH_IIO
-    pbdrv_counter_ev3dev_stretch_iio_drv.init();
-    #endif
-    #if PBDRV_CONFIG_COUNTER_STM32F0_GPIO_QUAD_ENC
-    pbdrv_counter_stm32f0_gpio_quad_enc_drv.init();
-    #endif
-
-    while (true) {
-        PROCESS_WAIT_EVENT();
-    }
-
-    PROCESS_END();
+    return dev->funcs->get_rate(dev, rate);
 }
 
 #endif // PBDRV_CONFIG_COUNTER

lib/pbio/drv/counter/counter_ev3dev_stretch_iio.c

@@ -26,60 +26,64 @@
 #endif
 
 typedef struct {
-    pbdrv_counter_dev_t dev;
+    pbdrv_counter_dev_t *dev;
     FILE *count;
     FILE *rate;
 } private_data_t;
 
 static private_data_t private_data[PBDRV_CONFIG_COUNTER_EV3DEV_STRETCH_IIO_NUM_DEV];
 
 static pbio_error_t pbdrv_counter_ev3dev_stretch_iio_get_count(pbdrv_counter_dev_t *dev, int32_t *count) {
-    private_data_t *data = PBIO_CONTAINER_OF(dev, private_data_t, dev);
+    private_data_t *priv = dev->priv;
 
-    if (!data->count) {
+    if (!priv->count) {
         return PBIO_ERROR_NO_DEV;
     }
 
-    if (fseek(data->count, 0, SEEK_SET) == -1) {
+    if (fseek(priv->count, 0, SEEK_SET) == -1) {
         return PBIO_ERROR_IO;
     }
 
-    if (fscanf(data->count, "%d", count) == EOF) {
+    if (fscanf(priv->count, "%d", count) == EOF) {
         return PBIO_ERROR_IO;
     }
 
     return PBIO_SUCCESS;
 }
 
 static pbio_error_t pbdrv_counter_ev3dev_stretch_iio_get_rate(pbdrv_counter_dev_t *dev, int32_t *rate) {
-    private_data_t *data = PBIO_CONTAINER_OF(dev, private_data_t, dev);
+    private_data_t *priv = dev->priv;
 
-    if (!data->rate) {
+    if (!priv->rate) {
         return PBIO_ERROR_NO_DEV;
     }
 
-    if (fseek(data->rate, 0, SEEK_SET) == -1) {
+    if (fseek(priv->rate, 0, SEEK_SET) == -1) {
         return PBIO_ERROR_IO;
     }
 
-    if (fscanf(data->rate, "%d", rate) == EOF) {
+    if (fscanf(priv->rate, "%d", rate) == EOF) {
         return PBIO_ERROR_IO;
     }
 
     return PBIO_SUCCESS;
 }
 
-static pbio_error_t counter_ev3dev_stretch_iio_init() {
+static const pbdrv_counter_funcs_t pbdrv_counter_ev3dev_stretch_iio_funcs = {
+    .get_count = pbdrv_counter_ev3dev_stretch_iio_get_count,
+    .get_rate = pbdrv_counter_ev3dev_stretch_iio_get_rate,
+};
+
+void pbdrv_counter_ev3dev_stretch_iio_init(pbdrv_counter_dev_t *devs) {
     char buf[256];
     struct udev *udev;
     struct udev_enumerate *enumerate;
     struct udev_list_entry *entry;
-    pbio_error_t err = PBIO_ERROR_FAILED;
 
     udev = udev_new();
     if (!udev) {
         dbg_err("Failed to get udev context");
-        return err;
+        return;
     }
 
     enumerate = udev_enumerate_new(udev);
@@ -111,64 +115,39 @@ static pbio_error_t counter_ev3dev_stretch_iio_init() {
 
 
     for (size_t i = 0; i < PBIO_ARRAY_SIZE(private_data); i++) {
-        private_data_t *data = &private_data[i];
+        private_data_t *priv = &private_data[i];
 
         snprintf(buf, sizeof(buf), "%s/in_count%d_raw", udev_list_entry_get_name(entry), (int)i);
-        data->count = fopen(buf, "r");
-        if (!data->count) {
+        priv->count = fopen(buf, "r");
+        if (!priv->count) {
             dbg_err("failed to open count attribute");
             continue;
         }
 
-        setbuf(data->count, NULL);
+        setbuf(priv->count, NULL);
 
         snprintf(buf, sizeof(buf), "%s/in_frequency%d_input", udev_list_entry_get_name(entry), (int)i);
-        data->rate = fopen(buf, "r");
-        if (!data->rate) {
+        priv->rate = fopen(buf, "r");
+        if (!priv->rate) {
             dbg_err("failed to open rate attribute");
             continue;
         }
 
-        setbuf(data->rate, NULL);
-
-        data->dev.get_count = pbdrv_counter_ev3dev_stretch_iio_get_count;
-        data->dev.get_rate = pbdrv_counter_ev3dev_stretch_iio_get_rate;
-        data->dev.initalized = true;
+        setbuf(priv->rate, NULL);
 
         // FIXME: assuming that these are the only counter devices
         // counter_id should be passed from platform data instead
-        pbdrv_counter_register(i, &data->dev);
+        _Static_assert(PBDRV_CONFIG_COUNTER_EV3DEV_STRETCH_IIO_NUM_DEV == PBDRV_CONFIG_COUNTER_NUM_DEV,
+            "need to fix counter_ev3dev_stretch_iio implementation to allow other counter devices");
+        priv->dev = &devs[i];
+        priv->dev->funcs = &pbdrv_counter_ev3dev_stretch_iio_funcs;
+        priv->dev->priv = priv;
     }
 
-    err = PBIO_SUCCESS;
-
 free_enumerate:
     udev_enumerate_unref(enumerate);
 free_udev:
     udev_unref(udev);
-
-    return err;
 }
 
-static pbio_error_t counter_ev3dev_stretch_iio_exit() {
-    for (size_t i = 0; i < PBIO_ARRAY_SIZE(private_data); i++) {
-        private_data_t *data = &private_data[i];
-
-        data->dev.initalized = false;
-        if (data->count) {
-            fclose(data->count);
-        }
-        if (data->rate) {
-            fclose(data->rate);
-        }
-        pbdrv_counter_unregister(&data->dev);
-    }
-    return PBIO_SUCCESS;
-}
-
-const pbdrv_counter_drv_t pbdrv_counter_ev3dev_stretch_iio_drv = {
-    .init = counter_ev3dev_stretch_iio_init,
-    .exit = counter_ev3dev_stretch_iio_exit,
-};
-
 #endif // PBDRV_CONFIG_COUNTER_EV3DEV_STRETCH_IIO