Clean up the code. Manage the reconnection. Use the lwip error, insted

[bertos.git] / bertos / mware / event.h

diff --git a/bertos/mware/event.h b/bertos/mware/event.h
index 94121413e5dd690d81ef32c701defd14f74f5803..6f88676346f2e70c1af213529652443fff12fe7f 100644 (file)
--- a/bertos/mware/event.h
+++ b/bertos/mware/event.h
@@ -132,47 +132,38 @@
  * \endcode
  *
  * \author Bernie Innocenti <bernie@codewiz.org>
+ *
+ * $WIZ$ module_name = "event"
  */
 
 #ifndef KERN_EVENT_H
 #define KERN_EVENT_H
 
-#include <cfg/compiler.h>
 #include "cfg/cfg_proc.h"
 #include "cfg/cfg_signal.h"
 #include "cfg/cfg_timer.h"
+#include <cfg/compiler.h>
 
 #include <cpu/power.h> /* cpu_relax() */
 
-#if CONFIG_KERN
-       #if defined(CONFIG_KERN_SIGNALS) && CONFIG_KERN_SIGNALS
-               #include <kern/signal.h>
-       #endif
-
-       /* Forward decl */
-       struct Process;
+#if CONFIG_KERN && CONFIG_KERN_SIGNALS
+#include <kern/signal.h>
+/* Forward decl */
+struct Process;
 #endif
 
-/// User defined callback type
-typedef void (*Hook)(void *);
-
 typedef struct Event
 {
        void (*action)(struct Event *);
        union
        {
-#if defined(CONFIG_KERN_SIGNALS) && CONFIG_KERN_SIGNALS
+#if CONFIG_KERN && CONFIG_KERN_SIGNALS
                struct
                {
                        struct Process *sig_proc;  /* Process to be signalled */
                        sigbit_t        sig_bit;   /* Signal to send */
+                       Signal          sig;       /* Local signal structure (used by generic event) */
                } Sig;
-
-               struct
-               {
-                       struct Process *sig_proc;  /* Process to be signalled */
-                       Signal          sig;       /* Signal structure */
-               } SigGen;
 #endif
                struct
                {
@@ -198,7 +189,6 @@ void event_hook_generic_signal(Event *event);
        ((e)->action = event_hook_ignore)
 
 /** Same as event_initNone(), but returns the initialized event */
-INLINE Event event_createNone(void);
 INLINE Event event_createNone(void)
 {
        Event e;
@@ -220,8 +210,7 @@ INLINE Event event_createSoftint(Hook func, void *user_data)
        return e;
 }
 
-#if defined(CONFIG_KERN_SIGNALS) && CONFIG_KERN_SIGNALS
-
+#if CONFIG_KERN && CONFIG_KERN_SIGNALS
 /** Initialize the event \a e with a signal (send signal \a s to process \a p) */
 #define event_initSignal(e,p,s) \
        ((e)->action = event_hook_signal,(e)->Ev.Sig.sig_proc = (p), (e)->Ev.Sig.sig_bit = (s))
@@ -236,24 +225,22 @@ INLINE Event event_createSignal(struct Process *proc, sigbit_t bit)
        return e;
 }
 
-#endif
+/**
+ * Signal used to implement generic events.
+ */
+#define EVENT_GENERIC_SIGNAL   SIG_SYSTEM6
 
-#if defined(CONFIG_KERN_SIGNALS) && CONFIG_KERN_SIGNALS
 /** Initialize the generic sleepable event \a e */
 #define event_initGeneric(e)                                   \
        ((e)->action = event_hook_generic_signal,               \
-               (e)->Ev.SigGen.sig_proc = proc_current(),       \
-               (e)->Ev.SigGen.sig.wait = 0, (e)->Ev.SigGen.sig.recv = 0)
+               (e)->Ev.Sig.sig_proc = proc_current(),          \
+               (e)->Ev.Sig.sig_bit = EVENT_GENERIC_SIGNAL,     \
+               (e)->Ev.Sig.sig.wait = 0, (e)->Ev.Sig.sig.recv = 0)
 #else
 #define event_initGeneric(e) \
        ((e)->action = event_hook_generic, (e)->Ev.Gen.completed = false)
 #endif
 
-/**
- * Signal used to implement generic events.
- */
-#define EVENT_GENERIC_SIGNAL   SIG_SYSTEM5
-
 /**
  * Create a generic sleepable event.
  *
@@ -275,9 +262,9 @@ INLINE Event event_createGeneric(void)
  */
 INLINE void event_wait(Event *e)
 {
-#if defined(CONFIG_KERN_SIGNALS) && CONFIG_KERN_SIGNALS
+#if CONFIG_KERN_SIGNALS
        e->Ev.Sig.sig_proc = proc_current();
-       sig_waitSignal(&e->Ev.SigGen.sig, EVENT_GENERIC_SIGNAL);
+       sig_waitSignal(&e->Ev.Sig.sig, EVENT_GENERIC_SIGNAL);
 #else
        while (ACCESS_SAFE(e->Ev.Gen.completed) == false)
                cpu_relax();
@@ -293,82 +280,19 @@ INLINE void event_wait(Event *e)
  * happened, -1 if the timeout expires.
  *
  * NOTE: timeout == 0 means no timeout.
+ *
+ * \attention The API is work in progress and may change in future versions.
  */
-#if defined(CONFIG_KERN_SIGNALS) && CONFIG_KERN_SIGNALS
-INLINE int event_select(Event **evs, int n, ticks_t timeout)
-{
-       sigmask_t mask = (1 << n) - 1;
-       int i;
-
-       ASSERT(n <= SIG_USER_MAX);
-       for (i = 0; i < n; i++)
-       {
-               Event *e = evs[i];
-               /* Map each event to a distinct signal bit */
-               event_initSignal(e, proc_current(), 1 << i);
-       }
-       mask = timeout ? sig_waitTimeout(mask, timeout) : sig_wait(mask);
-       i = UINT8_LOG2(mask);
-
-       return i < n ? i : -1;
-}
-#else
-INLINE int event_select(Event **evs, int n, ticks_t timeout)
-{
-       ticks_t end = timer_clock() + timeout;
-       int i;
-
-       while (1)
-       {
-               for (i = 0; i < n; i++)
-               {
-                       Event *e = evs[i];
-                       if (ACCESS_SAFE(e->Ev.Gen.completed) == true)
-                       {
-                               e->Ev.Gen.completed = false;
-                               MEMORY_BARRIER;
-                               return i;
-                       }
-               }
-               if (timeout && TIMER_AFTER(timer_clock(), end))
-                       break;
-               cpu_relax();
-       }
-       return -1;
-}
-#endif
-
-
-#if CONFIG_TIMER_EVENTS
-#include <drv/timer.h> /* timer_clock() */
+int event_select(Event **evs, int n, ticks_t timeout);
 
 /**
  * Wait the completion of event \a e or \a timeout elapses.
  *
+ * \return true if the event triggered, false if timed out
+ *
  * \note It's forbidden to use this function inside irq handling functions.
  */
-INLINE bool event_waitTimeout(Event *e, ticks_t timeout)
-{
-       bool ret;
-
-#if defined(CONFIG_KERN_SIGNALS) && CONFIG_KERN_SIGNALS
-       e->Ev.Sig.sig_proc = proc_current();
-       ret = (sig_waitTimeoutSignal(&e->Ev.SigGen.sig,
-                               EVENT_GENERIC_SIGNAL, timeout) & SIG_TIMEOUT) ?
-                               false : true;
-#else
-       ticks_t end = timer_clock() + timeout;
-
-       while ((ACCESS_SAFE(e->Ev.Gen.completed) == false) ||
-                       TIMER_AFTER(timer_clock(), end))
-               cpu_relax();
-       ret = e->Ev.Gen.completed;
-       e->Ev.Gen.completed = false;
-#endif
-       MEMORY_BARRIER;
-       return ret;
-}
-#endif /* CONFIG_TIMER_EVENTS */
+bool event_waitTimeout(Event *e, ticks_t timeout);
 
 /**
  * Trigger an event.