rewrite the device subsystem interfaces (#48)

[lunaix-os.git] / lunaix-os / kernel / time / timer.c

diff --git a/lunaix-os/kernel/time/timer.c b/lunaix-os/kernel/time/timer.c
index 981b64565fc458121e3f071d4ba65a1540621876..12c8e7fea2d2a74e835dc4c76832cee6b7f2a481 100644 (file)
--- a/lunaix-os/kernel/time/timer.c
+++ b/lunaix-os/kernel/time/timer.c
@@ -1,164 +1,81 @@
 /**
  * @file timer.c
  * @author Lunaixsky
 /**
  * @file timer.c
  * @author Lunaixsky

- * @brief A simple timer implementation based on APIC with adjustable frequency and subscribable "timerlets"
+ * @brief A simple timer implementation based on APIC with adjustable frequency
+ * and subscribable "timerlets"

  * @version 0.1
  * @date 2022-03-12
  * @version 0.1
  * @date 2022-03-12

- * 
+ *

  * @copyright Copyright (c) 2022
  * @copyright Copyright (c) 2022

- * 
+ *

  */
  */

-#include <arch/x86/interrupts.h>
-#include <hal/apic.h>
-#include <hal/rtc.h>

 
 

-#include <lunaix/mm/kalloc.h>
+#include <lunaix/mm/cake.h>
+#include <lunaix/mm/valloc.h>
+#include <lunaix/sched.h>

 #include <lunaix/spike.h>
 #include <lunaix/syslog.h>
 #include <lunaix/timer.h>
 #include <lunaix/spike.h>
 #include <lunaix/syslog.h>
 #include <lunaix/timer.h>

-#include <lunaix/sched.h>
-
-#define LVT_ENTRY_TIMER(vector, mode) (LVT_DELIVERY_FIXED | mode | vector)
+#include <lunaix/hart_state.h>

 
 

+#include <hal/hwtimer.h>

 
 LOG_MODULE("TIMER");
 
 static void
 
 LOG_MODULE("TIMER");
 
 static void

-temp_intr_routine_rtc_tick(const isr_param* param);
-
-static void
-temp_intr_routine_apic_timer(const isr_param* param);
-
-static void
-timer_update(const isr_param* param);
+timer_update();

 
 

-static volatile struct lx_timer_context* timer_ctx = NULL;
+static DEFINE_LLIST(timers);

 
 

-// Don't optimize them! Took me an half hour to figure that out...
+static volatile u32_t sched_ticks = 0;
+static volatile u32_t sched_ticks_counter = 0;

 
 

-static volatile uint32_t rtc_counter = 0;
-static volatile uint8_t apic_timer_done = 0;
-
-static volatile uint32_t sched_ticks = 0;
-static volatile uint32_t sched_ticks_counter = 0;
-
-#define APIC_CALIBRATION_CONST 0x100000
+static struct cake_pile* timer_pile;

 
 void
 timer_init_context()
 {
 
 void
 timer_init_context()
 {

-    timer_ctx =
-      (struct lx_timer_context*)lxmalloc(sizeof(struct lx_timer_context));
-
-    assert_msg(timer_ctx, "Fail to initialize timer contex");
-
-    timer_ctx->active_timers =
-      (struct lx_timer*)lxmalloc(sizeof(struct lx_timer));
-    llist_init_head(timer_ctx->active_timers);
-
+    timer_pile = cake_new_pile("timer", sizeof(struct lx_timer), 1, 0);

 }
 
 void
 }
 
 void

-timer_init(uint32_t frequency)
+timer_init()

 {
     timer_init_context();
 
 {
     timer_init_context();
 

-    cpu_disable_interrupt();
-
-    // Setup APIC timer
-
-    // Setup a one-shot timer, we will use this to measure the bus speed. So we
-    // can then calibrate apic timer to work at *nearly* accurate hz
-    apic_write_reg(APIC_TIMER_LVT,
-                   LVT_ENTRY_TIMER(APIC_TIMER_IV, LVT_TIMER_ONESHOT));
-
-    // Set divider to 64
-    apic_write_reg(APIC_TIMER_DCR, APIC_TIMER_DIV64);
-
-    /*
-        Timer calibration process - measure the APIC timer base frequency
-
-         step 1: setup a temporary isr for RTC timer which trigger at each tick
-                 (1024Hz) 
-         step 2: setup a temporary isr for #APIC_TIMER_IV 
-         step 3: setup the divider, APIC_TIMER_DCR 
-         step 4: Startup RTC timer 
-         step 5: Write a large value, v, to APIC_TIMER_ICR to start APIC timer (this must be
-                 followed immediately after step 4) 
-         step 6: issue a write to EOI and clean up.
-
-        When the APIC ICR counting down to 0 #APIC_TIMER_IV triggered, save the
-       rtc timer's counter, k, and disable RTC timer immediately (although the
-       RTC interrupts should be blocked by local APIC as we are currently busy
-       on handling #APIC_TIMER_IV)
-
-        So the apic timer frequency F_apic in Hz can be calculate as
-            v / F_apic = k / 1024
-            =>  F_apic = v / k * 1024
-
-    */
-
-    #ifdef __LUNAIXOS_DEBUG__
-    if (frequency < 1000) {
-        kprintf(KWARN "Frequency too low. Millisecond timer might be dodgy.");
-    }
-    #endif
-
-    timer_ctx->base_frequency = 0;
-    rtc_counter = 0;
-    apic_timer_done = 0;
-
-    intr_subscribe(APIC_TIMER_IV, temp_intr_routine_apic_timer);
-    intr_subscribe(RTC_TIMER_IV, temp_intr_routine_rtc_tick);
-
-    rtc_enable_timer();                                     // start RTC timer
-    apic_write_reg(APIC_TIMER_ICR, APIC_CALIBRATION_CONST); // start APIC timer
+    hwtimer_init(SYS_TIMER_FREQUENCY_HZ, timer_update);

 
 

-    // enable interrupt, just for our RTC start ticking!
-    cpu_enable_interrupt();
-
-    wait_until(apic_timer_done);
-
-
-    assert_msg(timer_ctx->base_frequency, "Fail to initialize timer (NOFREQ)");
-
-    kprintf(KINFO "Base frequency: %u Hz\n", timer_ctx->base_frequency);
-
-    timer_ctx->running_frequency = frequency;
-    timer_ctx->tphz = timer_ctx->base_frequency / frequency;
-
-    // cleanup
-    intr_unsubscribe(APIC_TIMER_IV, temp_intr_routine_apic_timer);
-    intr_unsubscribe(RTC_TIMER_IV, temp_intr_routine_rtc_tick);
-
-    apic_write_reg(APIC_TIMER_LVT,
-                   LVT_ENTRY_TIMER(APIC_TIMER_IV, LVT_TIMER_PERIODIC));
-    intr_subscribe(APIC_TIMER_IV, timer_update);
-
-    apic_write_reg(APIC_TIMER_ICR, timer_ctx->tphz);
-
-    sched_ticks = timer_ctx->running_frequency / 1000 * SCHED_TIME_SLICE;
+    sched_ticks = (SYS_TIMER_FREQUENCY_HZ * SCHED_TIME_SLICE) / 1000;

     sched_ticks_counter = 0;
 }
 
 struct lx_timer*
     sched_ticks_counter = 0;
 }
 
 struct lx_timer*

-timer_run_second(uint32_t second, void (*callback)(void*), void* payload, uint8_t flags)
+timer_run_second(u32_t second,
+                 void (*callback)(void*),
+                 void* payload,
+                 u8_t flags)

 {
 {

-    return timer_run(second * timer_ctx->running_frequency, callback, payload, flags);
+    ticks_t t = hwtimer_to_ticks(second, TIME_SEC);
+    return timer_run(t, callback, payload, flags);

 }
 
 struct lx_timer*
 }
 
 struct lx_timer*

-timer_run_ms(uint32_t millisecond, void (*callback)(void*), void* payload, uint8_t flags)
+timer_run_ms(u32_t millisecond,
+             void (*callback)(void*),
+             void* payload,
+             u8_t flags)

 {
 {

-    return timer_run(timer_ctx->running_frequency / 1000 * millisecond, callback, payload, flags);
+    ticks_t t = hwtimer_to_ticks(millisecond, TIME_MS);
+    return timer_run(t, callback, payload, flags);

 }
 
 struct lx_timer*
 }
 
 struct lx_timer*

-timer_run(ticks_t ticks, void (*callback)(void*), void* payload, uint8_t flags)
+timer_run(ticks_t ticks, void (*callback)(void*), void* payload, u8_t flags)

 {
 {

-    struct lx_timer* timer = (struct lx_timer*)lxmalloc(sizeof(struct lx_timer));
+    struct lx_timer* timer = (struct lx_timer*)cake_grab(timer_pile);

 
 

-    if (!timer) return NULL;
+    if (!timer)
+        return NULL;

 
     timer->callback = callback;
     timer->counter = ticks;
 
     timer->callback = callback;
     timer->counter = ticks;


@@ -166,25 +83,18 @@ timer_run(ticks_t ticks, void (*callback)(void*), void* payload, uint8_t flags)
     timer->payload = payload;
     timer->flags = flags;
 
     timer->payload = payload;
     timer->flags = flags;
 

-    llist_append(timer_ctx->active_timers, &timer->link);
+    llist_append(&timers, &timer->link);

 
     return timer;
 }
 
 static void
 
     return timer;
 }
 
 static void

-timer_update(const isr_param* param)
+timer_update()

 {
     struct lx_timer *pos, *n;
 {
     struct lx_timer *pos, *n;

-    struct lx_timer* timer_list_head = timer_ctx->active_timers;

 
 

-    llist_for_each(pos, n, &timer_list_head->link, link)
+    llist_for_each(pos, n, &timers, link)

     {
     {

-        if (!pos->counter) {
-            llist_delete(&pos->link);
-            lxfree(pos);
-            continue;
-        }
-        

         if (--(pos->counter)) {
             continue;
         }
         if (--(pos->counter)) {
             continue;
         }


@@ -193,38 +103,17 @@ timer_update(const isr_param* param)
 
         if ((pos->flags & TIMER_MODE_PERIODIC)) {
             pos->counter = pos->deadline;
 
         if ((pos->flags & TIMER_MODE_PERIODIC)) {
             pos->counter = pos->deadline;

+        } else {
+            llist_delete(&pos->link);
+            cake_release(timer_pile, pos);

         }
     }
         }
     }

-    
+

     sched_ticks_counter++;
 
     if (sched_ticks_counter >= sched_ticks) {
         sched_ticks_counter = 0;
     sched_ticks_counter++;
 
     if (sched_ticks_counter >= sched_ticks) {
         sched_ticks_counter = 0;

+        thread_stats_update_entering(false);

         schedule();
     }
 }
         schedule();
     }
 }

-
-static void
-temp_intr_routine_rtc_tick(const isr_param* param)
-{
-    rtc_counter++;
-
-    // dummy read on register C so RTC can send anther interrupt
-    //  This strange behaviour observed in virtual box & bochs
-    (void)rtc_read_reg(RTC_REG_C);
-}
-
-static void
-temp_intr_routine_apic_timer(const isr_param* param)
-{
-    timer_ctx->base_frequency =
-      APIC_CALIBRATION_CONST / rtc_counter * RTC_TIMER_BASE_FREQUENCY;
-    apic_timer_done = 1;
-
-    rtc_disable_timer();
-}
-
-struct lx_timer_context* 
-timer_context() {
-    return timer_ctx;
-}
\ No newline at end of file