Import Mbed OS hard-float snapshot

targets/TARGET_ARM_SSG/TARGET_CM3DS_MPS2/cmsdk_ticker.c

@@ -0,0 +1,166 @@
+/*
+ * Copyright (c) 2018 ARM Limited
+ *
+ * Licensed under the Apache License Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing software
+ * distributed under the License is distributed on an "AS IS" BASIS
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file cmsdk_ticker.c
+ * Two abstracted functionalities for CMSDK APB Timers
+ *   1. Measure elapsed time
+ *   2. Timer interval interrupt
+ *
+ *   Passed \ref tick_drv_data_t should be initialized by the caller
+ *   for using these services accordingly.
+ *   See details \ref tick_cfg_t and \ref tick_data_t.
+ */
+
+#include "cmsdk_ticker.h"
+
+void cmsdk_ticker_init(const struct tick_drv_data_t* timer_data)
+{
+    if (!timer_data->data->is_initialized) {
+        timer_cmsdk_init(timer_data->cfg->timer_driver);
+        timer_cmsdk_set_reload_value(timer_data->cfg->timer_driver,
+                                     TIMER_CMSDK_MAX_RELOAD);
+        timer_cmsdk_enable_interrupt(timer_data->cfg->timer_driver);
+        NVIC_EnableIRQ(timer_data->cfg->irq_n);
+
+        timer_data->data->max_interval_time =
+                timer_data->cfg->convert_tick_to_time(TIMER_CMSDK_MAX_RELOAD);
+        timer_data->data->reload_time = timer_data->data->max_interval_time;
+        timer_data->data->is_initialized = true;
+        timer_cmsdk_enable(timer_data->cfg->timer_driver);
+    }
+}
+
+uint32_t cmsdk_ticker_read(const struct tick_drv_data_t* timer_data)
+{
+    uint32_t current_elapsed = 0;
+
+    if (!timer_data->data->is_initialized) {
+        cmsdk_ticker_init(timer_data);
+    }
+    current_elapsed = timer_cmsdk_get_elapsed_value(timer_data->cfg->timer_driver);
+    /*
+     * If for the same reload cycle (ie. cumulated_time is the same) the
+     * current elapsed time is lower than the previous one, it means that the
+     * timer has wrapped around without the system logging it. To ensure that
+     * we are always returning an increasing time in those condition, we return
+     * the time perviously read.
+     */
+    if ((timer_data->data->previous_cumulated_time ==
+         timer_data->data->cumulated_time) &&
+        (current_elapsed < timer_data->data->previous_elapsed)) {
+        current_elapsed = timer_data->data->previous_elapsed;
+    }
+
+    timer_data->data->previous_elapsed = current_elapsed;
+    timer_data->data->previous_cumulated_time =
+                                               timer_data->data->cumulated_time;
+
+    return (timer_data->data->cumulated_time +
+            timer_data->cfg->convert_tick_to_time(current_elapsed));
+}
+
+void cmsdk_ticker_set_interrupt(const struct tick_drv_data_t* timer_data,
+                                uint32_t timestamp)
+{
+    uint32_t interval = 0;
+    uint32_t interval_reload_tick = 0;
+
+    /* Stop before read to avoid race condition with IRQ. */
+    timer_cmsdk_disable(timer_data->cfg->timer_driver);
+    uint32_t current_time = cmsdk_ticker_read(timer_data);
+
+    timer_data->data->interval_callback_enabled = true;
+
+    /*
+     * We always assume that the event is in the future, even if this
+     * substraction underflows it is still corect.
+     */
+    interval = (timestamp - current_time);
+
+    if (interval >= timer_data->data->max_interval_time) {
+        /* Event will be in the future but the time is too big: set max */
+        interval_reload_tick = TIMER_CMSDK_MAX_RELOAD;
+        timer_data->data->reload_time = timer_data->data->max_interval_time;
+    } else {
+        /* Event will be in the future in a time that can be set */
+        interval_reload_tick =
+        timer_data->cfg->convert_time_to_tick(interval);
+        timer_data->data->reload_time = interval;
+    }
+
+    /* Store the current elapsed time, before reset the timer */
+    timer_data->data->cumulated_time = current_time;
+    /* Reset the timer with new reload value */
+    timer_cmsdk_set_reload_value(timer_data->cfg->timer_driver,
+                                 interval_reload_tick);
+    timer_cmsdk_reset(timer_data->cfg->timer_driver);
+
+    timer_cmsdk_enable(timer_data->cfg->timer_driver);
+}
+
+void cmsdk_ticker_disable_interrupt(const struct tick_drv_data_t* timer_data)
+{
+    if (!timer_data->data->is_initialized) {
+        cmsdk_ticker_init(timer_data);
+    }
+
+    timer_data->data->interval_callback_enabled = false;
+
+    /* Stop before read to avoid race condition with IRQ. */
+    timer_cmsdk_disable(timer_data->cfg->timer_driver);
+    /* If interval interrupt is disabled, restore the default max interval,
+     * but save the current elapsed time before changing the timer. */
+    timer_data->data->cumulated_time = cmsdk_ticker_read(timer_data);
+    /* Reset the timer with default reload value */
+    timer_cmsdk_set_reload_value(timer_data->cfg->timer_driver,
+                                 TIMER_CMSDK_MAX_RELOAD);
+    timer_data->data->reload_time = timer_data->data->max_interval_time;
+
+    timer_cmsdk_reset(timer_data->cfg->timer_driver);
+    timer_cmsdk_enable(timer_data->cfg->timer_driver);
+}
+
+void cmsdk_ticker_clear_interrupt(const struct tick_drv_data_t* timer_data)
+{
+    timer_cmsdk_clear_interrupt(timer_data->cfg->timer_driver);
+}
+
+void cmsdk_ticker_fire_interrupt(const struct tick_drv_data_t* timer_data)
+{
+    NVIC_SetPendingIRQ(timer_data->cfg->irq_n);
+}
+
+void cmsdk_ticker_irq_handler(const struct tick_drv_data_t* timer_data)
+{
+    uint32_t reload_val = 0;
+    /* If timer's internal interrupt status is not active, then not overflow,
+     * but explicit interrupt request was fired by cmsdk_ticker_fire_interrupt.
+     */
+    if (timer_cmsdk_is_interrupt_active(timer_data->cfg->timer_driver)) {
+    /* 1. Calculate cumulated time by overflow */
+        timer_cmsdk_clear_interrupt(timer_data->cfg->timer_driver);
+        reload_val = timer_cmsdk_get_reload_value(timer_data->cfg->timer_driver);
+        timer_data->data->cumulated_time +=
+                timer_data->cfg->convert_tick_to_time(reload_val);
+    }
+
+    /* 2. Call mbed interval interrupt handler if it's required */
+    if (timer_data->data->interval_callback_enabled) {
+        cmsdk_ticker_disable_interrupt(timer_data);
+        timer_data->cfg->interval_callback();
+    }
+}