esp32/machine_timer.c: Add find free timer id.

``id`` of -2 selects the ``id`` of a free timer.
Check the timer `id` range.
Check if the timer is already in use.

Signed-off-by: IhorNehrutsa <[email protected]>

Author: IhorNehrutsa

docs/library/machine.Timer.rst

@@ -31,6 +31,7 @@ Constructors
 
    Construct a new timer object of the given ``id``. ``id`` of -1 constructs a
    virtual timer (if supported by a board).
+   ``id`` of -2 selects the ``id`` of a free timer (Supported at ESP32 port).
    ``id`` shall not be passed as a keyword argument.
 
    See ``init`` for parameters of initialisation.

ports/esp32/machine_timer.c

@@ -30,69 +30,96 @@
 #include <stdint.h>
 #include <stdio.h>
 
+#include "py/mphal.h"
 #include "py/obj.h"
 #include "py/runtime.h"
 #include "modmachine.h"
-#include "mphalport.h"
 
 #include "hal/timer_hal.h"
 #include "hal/timer_ll.h"
 #include "soc/timer_periph.h"
+#include "esp_private/esp_clk_tree_common.h"
+#include "esp_private/periph_ctrl.h"
+#include "machine_timer.h"
 
+#define TIMER_CLK_SRC GPTIMER_CLK_SRC_DEFAULT
 #define TIMER_DIVIDER  8
 
-// TIMER_BASE_CLK is normally 80MHz. TIMER_DIVIDER ought to divide this exactly
-#define TIMER_SCALE    (APB_CLK_FREQ / TIMER_DIVIDER)
-
 #define TIMER_FLAGS    0
 
-typedef struct _machine_timer_obj_t {
-    mp_obj_base_t base;
-
-    timer_hal_context_t hal_context;
-    mp_uint_t group;
-    mp_uint_t index;
-
-    mp_uint_t repeat;
-    // ESP32 timers are 64-bit
-    uint64_t period;
-
-    mp_obj_t callback;
-
-    intr_handle_t handle;
-
-    struct _machine_timer_obj_t *next;
-} machine_timer_obj_t;
-
 const mp_obj_type_t machine_timer_type;
 
-STATIC void machine_timer_disable(machine_timer_obj_t *self);
-STATIC mp_obj_t machine_timer_init_helper(machine_timer_obj_t *self, mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+static mp_obj_t machine_timer_init_helper(machine_timer_obj_t *self, mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+static mp_obj_t machine_timer_deinit(mp_obj_t self_in);
+
+uint32_t machine_timer_freq_hz(void) {
+    // The timer source clock is APB or a fixed PLL (depending on chip), both constant frequency.
+    uint32_t freq;
+    check_esp_err(esp_clk_tree_src_get_freq_hz(TIMER_CLK_SRC, ESP_CLK_TREE_SRC_FREQ_PRECISION_CACHED, &freq));
+    assert(freq % TIMER_DIVIDER == 0); // Source clock should divide evenly into TIMER_DIVIDER
+    return freq / TIMER_DIVIDER;
+}
 
 void machine_timer_deinit_all(void) {
     // Disable, deallocate and remove all timers from list
     machine_timer_obj_t **t = &MP_STATE_PORT(machine_timer_obj_head);
     while (*t != NULL) {
-        machine_timer_disable(*t);
+        machine_timer_deinit(*t);
         machine_timer_obj_t *next = (*t)->next;
         m_del_obj(machine_timer_obj_t, *t);
         *t = next;
     }
 }
 
-STATIC void machine_timer_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+static void machine_timer_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
     machine_timer_obj_t *self = self_in;
     qstr mode = self->repeat ? MP_QSTR_PERIODIC : MP_QSTR_ONE_SHOT;
-    uint64_t period = self->period / (TIMER_SCALE / 1000); // convert to ms
+    uint64_t period = self->period / (machine_timer_freq_hz() / 1000); // convert to ms
+    #if SOC_TIMER_GROUP_TIMERS_PER_GROUP == 1
+    mp_printf(print, "Timer(%u, mode=%q, period=%lu)", self->group, mode, period);
+    #else
     mp_printf(print, "Timer(%u, mode=%q, period=%lu)", (self->group << 1) | self->index, mode, period);
+    #endif
 }
 
-STATIC mp_obj_t machine_timer_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
-    mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);
-    mp_uint_t group = (mp_obj_get_int(args[0]) >> 1) & 1;
-    mp_uint_t index = mp_obj_get_int(args[0]) & 1;
+static bool find_free_timer(mp_int_t *group, mp_int_t *index) {
+    // from highest to lowest id
+    for (*group = SOC_TIMER_GROUPS - 1; *group >= 0; --(*group)) {
+        for (*index = SOC_TIMER_GROUP_TIMERS_PER_GROUP - 1; *index >= 0; --(*index)) {
+            bool free = true;
+            // Check whether the timer is already initialized, if so skip it
+            for (machine_timer_obj_t *t = MP_STATE_PORT(machine_timer_obj_head); t; t = t->next) {
+                if (t->group == *group && t->index == *index) {
+                    free = false;
+                    break;
+                }
+            }
+            if (free) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+machine_timer_obj_t *machine_timer_create(mp_int_t timer) {
 
     machine_timer_obj_t *self = NULL;
+    mp_int_t group;
+    mp_int_t index;
+    if (timer == -2) {
+        if (!find_free_timer(&group, &index)) {
+            mp_raise_msg_varg(&mp_type_RuntimeError, MP_ERROR_TEXT("out of Timers:%d"), SOC_TIMER_GROUP_TOTAL_TIMERS);
+        }
+    } else {
+        #if SOC_TIMER_GROUP_TIMERS_PER_GROUP == 1
+        group = timer & 1;
+        index = 0;
+        #else
+        group = (timer >> 1) & 1;
+        index = timer & 1;
+        #endif
+    }
 
     // Check whether the timer is already initialized, if so use it
     for (machine_timer_obj_t *t = MP_STATE_PORT(machine_timer_obj_head); t; t = t->next) {
@@ -106,11 +133,24 @@ STATIC mp_obj_t machine_timer_make_new(const mp_obj_type_t *type, size_t n_args,
         self = mp_obj_malloc(machine_timer_obj_t, &machine_timer_type);
         self->group = group;
         self->index = index;
+        self->handle = NULL;
 
         // Add the timer to the linked-list of timers
         self->next = MP_STATE_PORT(machine_timer_obj_head);
         MP_STATE_PORT(machine_timer_obj_head) = self;
     }
+    return self;
+}
+
+static mp_obj_t machine_timer_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+    mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);
+
+    // Create the new timer.
+    mp_int_t timer_number = mp_obj_get_int(args[0]);
+    if (timer_number >= SOC_TIMER_GROUP_TOTAL_TIMERS) {
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid Timer number"));
+    }
+    machine_timer_obj_t *self = machine_timer_create(timer_number);
 
     if (n_args > 1 || n_kw > 0) {
         mp_map_t kw_args;
@@ -121,24 +161,23 @@ STATIC mp_obj_t machine_timer_make_new(const mp_obj_type_t *type, size_t n_args,
     return self;
 }
 
-STATIC void machine_timer_disable(machine_timer_obj_t *self) {
+void machine_timer_disable(machine_timer_obj_t *self) {
     if (self->hal_context.dev != NULL) {
         // Disable the counter and alarm.
         timer_ll_enable_counter(self->hal_context.dev, self->index, false);
         timer_ll_enable_alarm(self->hal_context.dev, self->index, false);
     }
 
     if (self->handle) {
-        // Free the interrupt handler.
-        esp_intr_free(self->handle);
-        self->handle = NULL;
+        // Disable the interrupt
+        ESP_ERROR_CHECK(esp_intr_disable(self->handle));
     }
 
     // We let the disabled timer stay in the list, as it might be
     // referenced elsewhere
 }
 
-STATIC void machine_timer_isr(void *self_in) {
+static void machine_timer_isr(void *self_in) {
     machine_timer_obj_t *self = self_in;
 
     uint32_t intr_status = timer_ll_get_intr_status(self->hal_context.dev);
@@ -148,27 +187,53 @@ STATIC void machine_timer_isr(void *self_in) {
         if (self->repeat) {
             timer_ll_enable_alarm(self->hal_context.dev, self->index, true);
         }
-        mp_sched_schedule(self->callback, self);
-        mp_hal_wake_main_task_from_isr();
+        self->handler(self);
     }
 }
 
-STATIC void machine_timer_enable(machine_timer_obj_t *self) {
+static void machine_timer_isr_handler(machine_timer_obj_t *self) {
+    mp_sched_schedule(self->callback, self);
+    mp_hal_wake_main_task_from_isr();
+}
+
+void machine_timer_enable(machine_timer_obj_t *self) {
     // Initialise the timer.
     timer_hal_init(&self->hal_context, self->group, self->index);
+
+    PERIPH_RCC_ACQUIRE_ATOMIC(timer_group_periph_signals.groups[self->index].module, ref_count) {
+        if (ref_count == 0) {
+            timer_ll_enable_bus_clock(self->index, true);
+            timer_ll_reset_register(self->index);
+        }
+    }
+
     timer_ll_enable_counter(self->hal_context.dev, self->index, false);
-    timer_ll_set_clock_source(self->hal_context.dev, self->index, GPTIMER_CLK_SRC_APB);
+    esp_clk_tree_enable_src(TIMER_CLK_SRC, true);
+    #if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 5, 0)
+    timer_ll_set_clock_source(self->hal_context.dev, self->index, TIMER_CLK_SRC);
+    timer_ll_enable_clock(self->hal_context.dev, self->index, true);
+    #else
+    timer_ll_set_clock_source(self->group, self->index, TIMER_CLK_SRC);
+    timer_ll_enable_clock(self->group, self->index, true);
+    #endif
     timer_ll_set_clock_prescale(self->hal_context.dev, self->index, TIMER_DIVIDER);
     timer_hal_set_counter_value(&self->hal_context, 0);
     timer_ll_set_count_direction(self->hal_context.dev, self->index, GPTIMER_COUNT_UP);
 
     // Allocate and enable the alarm interrupt.
     timer_ll_enable_intr(self->hal_context.dev, TIMER_LL_EVENT_ALARM(self->index), false);
     timer_ll_clear_intr_status(self->hal_context.dev, TIMER_LL_EVENT_ALARM(self->index));
-    ESP_ERROR_CHECK(
-        esp_intr_alloc(timer_group_periph_signals.groups[self->group].timer_irq_id[self->index],
-            TIMER_FLAGS, machine_timer_isr, self, &self->handle)
-        );
+    if (self->handle) {
+        ESP_ERROR_CHECK(esp_intr_enable(self->handle));
+    } else {
+        ESP_ERROR_CHECK(esp_intr_alloc(
+            timer_group_periph_signals.groups[self->group].timer_irq_id[self->index],
+            TIMER_FLAGS,
+            machine_timer_isr,
+            self,
+            &self->handle
+            ));
+    }
     timer_ll_enable_intr(self->hal_context.dev, TIMER_LL_EVENT_ALARM(self->index), true);
 
     // Enable the alarm to trigger at the given period.
@@ -183,13 +248,14 @@ STATIC void machine_timer_enable(machine_timer_obj_t *self) {
     timer_ll_enable_counter(self->hal_context.dev, self->index, true);
 }
 
-STATIC mp_obj_t machine_timer_init_helper(machine_timer_obj_t *self, mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+static mp_obj_t machine_timer_init_helper(machine_timer_obj_t *self, mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     enum {
         ARG_mode,
         ARG_callback,
         ARG_period,
         ARG_tick_hz,
         ARG_freq,
+        ARG_hard,
     };
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_mode,         MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 1} },
@@ -201,63 +267,77 @@ STATIC mp_obj_t machine_timer_init_helper(machine_timer_obj_t *self, mp_uint_t n
         #else
         { MP_QSTR_freq,         MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0xffffffff} },
         #endif
+        { MP_QSTR_hard,         MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = false} },
     };
 
     machine_timer_disable(self);
 
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
+    if (args[ARG_hard].u_bool) {
+        mp_raise_ValueError(MP_ERROR_TEXT("hard Timers are not implemented"));
+    }
+
     #if MICROPY_PY_BUILTINS_FLOAT
     if (args[ARG_freq].u_obj != mp_const_none) {
-        self->period = (uint64_t)(TIMER_SCALE / mp_obj_get_float(args[ARG_freq].u_obj));
+        self->period = (uint64_t)(machine_timer_freq_hz() / mp_obj_get_float(args[ARG_freq].u_obj));
     }
     #else
     if (args[ARG_freq].u_int != 0xffffffff) {
         self->period = TIMER_SCALE / ((uint64_t)args[ARG_freq].u_int);
     }
     #endif
     else {
-        self->period = (((uint64_t)args[ARG_period].u_int) * TIMER_SCALE) / args[ARG_tick_hz].u_int;
+        self->period = (((uint64_t)args[ARG_period].u_int) * machine_timer_freq_hz()) / args[ARG_tick_hz].u_int;
     }
 
     self->repeat = args[ARG_mode].u_int;
+    self->handler = machine_timer_isr_handler;
     self->callback = args[ARG_callback].u_obj;
-    self->handle = NULL;
 
     machine_timer_enable(self);
 
     return mp_const_none;
 }
 
-STATIC mp_obj_t machine_timer_deinit(mp_obj_t self_in) {
-    machine_timer_disable(self_in);
+static mp_obj_t machine_timer_deinit(mp_obj_t self_in) {
+    machine_timer_obj_t *self = self_in;
+
+    machine_timer_disable(self);
+    if (self->handle) {
+        ESP_ERROR_CHECK(esp_intr_free(self->handle));
+        self->handle = NULL;
+    }
 
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_timer_deinit_obj, machine_timer_deinit);
+static MP_DEFINE_CONST_FUN_OBJ_1(machine_timer_deinit_obj, machine_timer_deinit);
 
-STATIC mp_obj_t machine_timer_init(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
+static mp_obj_t machine_timer_init(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
     return machine_timer_init_helper(args[0], n_args - 1, args + 1, kw_args);
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_KW(machine_timer_init_obj, 1, machine_timer_init);
+static MP_DEFINE_CONST_FUN_OBJ_KW(machine_timer_init_obj, 1, machine_timer_init);
 
-STATIC mp_obj_t machine_timer_value(mp_obj_t self_in) {
+static mp_obj_t machine_timer_value(mp_obj_t self_in) {
     machine_timer_obj_t *self = self_in;
+    if (self->handle == NULL) {
+        mp_raise_ValueError(MP_ERROR_TEXT("timer not set"));
+    }
     uint64_t result = timer_ll_get_counter_value(self->hal_context.dev, self->index);
-    return MP_OBJ_NEW_SMALL_INT((mp_uint_t)(result / (TIMER_SCALE / 1000))); // value in ms
+    return MP_OBJ_NEW_SMALL_INT((mp_uint_t)(result / (machine_timer_freq_hz() / 1000))); // value in ms
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_timer_value_obj, machine_timer_value);
+static MP_DEFINE_CONST_FUN_OBJ_1(machine_timer_value_obj, machine_timer_value);
 
-STATIC const mp_rom_map_elem_t machine_timer_locals_dict_table[] = {
+static const mp_rom_map_elem_t machine_timer_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&machine_timer_deinit_obj) },
     { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&machine_timer_deinit_obj) },
     { MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&machine_timer_init_obj) },
     { MP_ROM_QSTR(MP_QSTR_value), MP_ROM_PTR(&machine_timer_value_obj) },
     { MP_ROM_QSTR(MP_QSTR_ONE_SHOT), MP_ROM_INT(false) },
     { MP_ROM_QSTR(MP_QSTR_PERIODIC), MP_ROM_INT(true) },
 };
-STATIC MP_DEFINE_CONST_DICT(machine_timer_locals_dict, machine_timer_locals_dict_table);
+static MP_DEFINE_CONST_DICT(machine_timer_locals_dict, machine_timer_locals_dict_table);
 
 MP_DEFINE_CONST_OBJ_TYPE(
     machine_timer_type,