From 73642ca0cce31ed6982813a90b89e4de05da76cb Mon Sep 17 00:00:00 2001
From: gdisirio <gdisirio@35acf78f-673a-0410-8e92-d51de3d6d3f4>
Date: Sat, 13 Oct 2007 06:59:54 +0000
Subject: git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@48
 35acf78f-673a-0410-8e92-d51de3d6d3f4

---
 src/chdelta.c           | 27 +++++++++++++++------------
 src/chevents.c          |  8 ++++----
 src/chmsg.c             | 10 +++++-----
 src/chqueues.c          | 14 ++++----------
 src/chschd.c            |  6 +++---
 src/chsem.c             | 33 +++++++++++++++++----------------
 src/chsleep.c           |  4 ++--
 src/chthreads.c         | 10 +++++-----
 src/include/delta.h     |  3 +++
 src/include/scheduler.h |  6 +++---
 10 files changed, 61 insertions(+), 60 deletions(-)

(limited to 'src')

diff --git a/src/chdelta.c b/src/chdelta.c
index e627cbf19..f87aec5a9 100644
--- a/src/chdelta.c
+++ b/src/chdelta.c
@@ -39,7 +39,8 @@ void chVTInit(void) {
 /**
  * Enables a virtual timer.
  * @param vtp the \p VirtualTimer structure pointer
- * @param time the number of time ticks
+ * @param time the number of time ticks, the value zero is allowed with
+ *             meaning "infinite".
  * @param vtfunc the timer callback function. After invoking the callback
  *               the timer is disabled and the structure can be disposed or
  *               reused.
@@ -48,21 +49,23 @@ void chVTInit(void) {
  * @note The associated function is invoked by an interrupt handler.
  */
 void chVTSetI(VirtualTimer *vtp, t_time time, t_vtfunc vtfunc, void *par) {
-  VirtualTimer *p;
 
   vtp->vt_func = vtfunc;
   vtp->vt_par = par;
-  p = dlist.dl_next;
-  while (p->vt_dtime < time) {
-    time -= p->vt_dtime;
-    p = p->vt_next;
-  }
 
-  vtp->vt_prev = (vtp->vt_next = p)->vt_prev;
-  vtp->vt_prev->vt_next = p->vt_prev = vtp;
-  vtp->vt_dtime = time;
-  if (p != (VirtualTimer *)&dlist)
-    p->vt_dtime -= time;
+  if (time) {
+    VirtualTimer *p = dlist.dl_next;
+    while (p->vt_dtime < time) {
+      time -= p->vt_dtime;
+      p = p->vt_next;
+    }
+
+    vtp->vt_prev = (vtp->vt_next = p)->vt_prev;
+    vtp->vt_prev->vt_next = p->vt_prev = vtp;
+    vtp->vt_dtime = time;
+    if (p != (VirtualTimer *)&dlist)
+      p->vt_dtime -= time;
+  }
 }
 
 /**
diff --git a/src/chevents.c b/src/chevents.c
index 9094f45cd..a38975216 100644
--- a/src/chevents.c
+++ b/src/chevents.c
@@ -104,7 +104,7 @@ void chEvtSend(EventSource *esp) {
       chSchReadyI(tp);
     elp = elp->el_next;
   }
-  chSchRescheduleI();
+  chSchRescheduleS();
 
   chSysUnlock();
 }
@@ -112,7 +112,7 @@ void chEvtSend(EventSource *esp) {
 /**
  * Signals all the Event Listeners registered on the specified Event Source.
  * @param esp pointer to the \p EventSource structure
- * @note This function must be called with interrupts disabled.
+ * @note This function does not reschedule.
  */
 void chEvtSendI(EventSource *esp) {
   EventListener *elp;
@@ -153,7 +153,7 @@ t_eventid chEvtWait(t_eventmask ewmask,
 
   if ((currp->p_epending & ewmask) == 0) {
     currp->p_ewmask = ewmask;
-    chSchGoSleepI(PRWTEVENT);
+    chSchGoSleepS(PRWTEVENT);
   }
   i = 0, m = 1;
   while ((currp->p_epending & ewmask & m) == 0)
@@ -219,7 +219,7 @@ t_eventid chEvtWaitTimeout(t_eventmask ewmask,
 
     chVTSetI(&vt, time, unwait, currp);
     currp->p_ewmask = ewmask;
-    chSchGoSleepI(PRWTEVENT);
+    chSchGoSleepS(PRWTEVENT);
     if (!vt.vt_func) {
 
       chSysUnlock();
diff --git a/src/chmsg.c b/src/chmsg.c
index 7a25502b0..4140e3165 100644
--- a/src/chmsg.c
+++ b/src/chmsg.c
@@ -40,7 +40,7 @@ t_msg chMsgSend(Thread *tp, t_msg msg) {
   if (tp->p_state == PRWTMSG)
     chSchReadyI(tp);
   currp->p_msg = msg;
-  chSchGoSleepI(PRSNDMSG);
+  chSchGoSleepS(PRSNDMSG);
   msg = currp->p_rdymsg;
 
   chSysUnlock();
@@ -71,7 +71,7 @@ t_msg chMsgSendWithEvent(Thread *tp, t_msg msg, EventSource *esp) {
 //    chSchReadyI(tp);
   chEvtSendI(esp);
   currp->p_msg = msg;
-  chSchGoSleepI(PRSNDMSG);
+  chSchGoSleepS(PRSNDMSG);
   msg = currp->p_rdymsg;
 
   chSysUnlock();
@@ -113,7 +113,7 @@ t_msg chMsgSendTimeout(Thread *tp, t_msg msg, t_time time) {
   if (tp->p_state == PRWTMSG)
     chSchReadyI(tp);
   currp->p_msg = msg;
-  chSchGoSleepI(PRSNDMSG);
+  chSchGoSleepS(PRSNDMSG);
   msg = currp->p_rdymsg;
   if (vt.vt_func)
     chVTResetI(&vt);
@@ -138,7 +138,7 @@ t_msg chMsgWait(void) {
   chSysLock();
 
   if (!chMsgIsPendingI(currp))
-    chSchGoSleepI(PRWTMSG);
+    chSchGoSleepS(PRWTMSG);
   msg = chMsgGetI(currp);
 
   chSysUnlock();
@@ -183,7 +183,7 @@ void chMsgRelease(t_msg msg) {
   chSysLock();
 
 //  if (!chMsgIsPendingI(currp)
-  chSchWakeupI(fifo_remove(&currp->p_msgqueue), msg);
+  chSchWakeupS(fifo_remove(&currp->p_msgqueue), msg);
 
   chSysUnlock();
 }
diff --git a/src/chqueues.c b/src/chqueues.c
index 225492e60..88eac2184 100644
--- a/src/chqueues.c
+++ b/src/chqueues.c
@@ -145,10 +145,10 @@ t_msg chIQGetTimeout(Queue *qp, t_time time) {
  * is non-blocking and can return zero if the queue is empty.
  * @param qp pointer to a \p Queue structure
  * @param buffer the data buffer
- * @param n the maxium amount of data to be read
+ * @param n the maximum amount of data to be read
  * @return the number of bytes read
  * @note This function is the upper side endpoint of the input queue.
- * @note The function is not atomical, if you need atomicity it is suggested
+ * @note The function is not atomic, if you need atomicity it is suggested
  *       to use a semaphore for mutual exclusion.
  */
 t_size chIQRead(Queue *qp, BYTE8 *buffer, t_size n) {
@@ -167,9 +167,6 @@ t_size chIQRead(Queue *qp, BYTE8 *buffer, t_size n) {
     if (qp->q_rdptr >= qp->q_top)
       qp->q_rdptr = qp->q_buffer;
 
-//    if (qp->q_notify)
-//      qp->q_notify();
-
     chSysUnlock();
     r++;
   }
@@ -264,9 +261,9 @@ t_msg chOQGetI(Queue *qp) {
  * is non-blocking and can return zero if the queue is full.
  * @param qp pointer to a \p Queue structure
  * @param buffer the data buffer
- * @param n the maxium amount of data to be written
+ * @param n the maximum amount of data to be written
  * @note This function is the upper side endpoint of the output queue.
- * @note The function is not atomical, if you need atomicity it is suggested
+ * @note The function is not atomic, if you need atomicity it is suggested
  *       to use a semaphore for mutual exclusion.
  */
 t_size chOQWrite(Queue *qp, BYTE8 *buffer, t_size n) {
@@ -285,9 +282,6 @@ t_size chOQWrite(Queue *qp, BYTE8 *buffer, t_size n) {
     if (qp->q_wrptr >= qp->q_top)
       qp->q_wrptr = qp->q_buffer;
 
-//    if (qp->q_notify)
-//      qp->q_notify();
-
     chSysUnlock();
     w++;
   }
diff --git a/src/chschd.c b/src/chschd.c
index 254f87937..c95c0cd0e 100644
--- a/src/chschd.c
+++ b/src/chschd.c
@@ -98,7 +98,7 @@ static void nextready(void) {
  * @note The function must be called in the system mutex zone.
  * @note The function is not meant to be used in the user code directly.
  */
-void chSchGoSleepI(t_tstate newstate) {
+void chSchGoSleepS(t_tstate newstate) {
 
   currp->p_state = newstate;
   nextready();
@@ -115,7 +115,7 @@ void chSchGoSleepI(t_tstate newstate) {
  * @note It is equivalent to a \p chSchReadyI() followed by a
  *       \p chSchRescheduleI() but much more efficient.
  */
-void chSchWakeupI(Thread *tp, t_msg msg) {
+void chSchWakeupS(Thread *tp, t_msg msg) {
   Thread *ctp = currp;
 
   if (tp->p_prio <= ctp->p_prio)
@@ -134,7 +134,7 @@ void chSchWakeupI(Thread *tp, t_msg msg) {
  * ready list then it becomes running.
  * @note The function must be called in the system mutex zone.
  */
-void chSchRescheduleI(void) {
+void chSchRescheduleS(void) {
 
   if (isempty(&rlist.r_queue) || firstprio(&rlist.r_queue) <= currp->p_prio)
     return;
diff --git a/src/chsem.c b/src/chsem.c
index 70741c4f0..a58ee71b1 100644
--- a/src/chsem.c
+++ b/src/chsem.c
@@ -55,7 +55,7 @@ void chSemReset(Semaphore *sp, t_cnt n) {
   if (cnt < 0) {
     while (cnt++)
       chSchReadyI(fifo_remove(&sp->s_queue))->p_rdymsg = RDY_RESET;
-    chSchRescheduleI();
+    chSchRescheduleS();
   }
 
   chSysUnlock();
@@ -68,7 +68,7 @@ void chSemReset(Semaphore *sp, t_cnt n) {
  * @note The released threads can recognize they were waked up by a reset
  *       instead than a signal because the \p p_rdymsg field is set to
  *       \p RDY_RESET.
- * @note This function must be called with interrupts disabled.
+ * @note This function does not reschedule.
  */
 void chSemResetI(Semaphore *sp, t_cnt n) {
   t_cnt cnt;
@@ -90,7 +90,7 @@ void chSemWait(Semaphore *sp) {
   if (--sp->s_cnt < 0) {
     fifo_insert(currp, &sp->s_queue);
     currp->p_semp = sp;
-    chSchGoSleepI(PRWTSEM);
+    chSchGoSleepS(PRWTSEM);
   }
 
   chSysUnlock();
@@ -107,7 +107,7 @@ void chSemWaitS(Semaphore *sp) {
   if (--sp->s_cnt < 0) {
     fifo_insert(currp, &sp->s_queue);
     currp->p_semp = sp;
-    chSchGoSleepI(PRWTSEM);
+    chSchGoSleepS(PRWTSEM);
   }
 }
 
@@ -137,7 +137,7 @@ t_msg chSemWaitTimeout(Semaphore *sp, t_time time) {
     chVTSetI(&vt, time, unwait, currp);
     fifo_insert(currp, &sp->s_queue);
     currp->p_semp = sp;
-    chSchGoSleepI(PRWTSEM);
+    chSchGoSleepS(PRWTSEM);
     msg = currp->p_rdymsg;
     if (vt.vt_func)
       chVTResetI(&vt);
@@ -168,7 +168,7 @@ t_msg chSemWaitTimeoutS(Semaphore *sp, t_time time) {
     chVTSetI(&vt, time, unwait, currp);
     fifo_insert(currp, &sp->s_queue);
     currp->p_semp = sp;
-    chSchGoSleepI(PRWTSEM);
+    chSchGoSleepS(PRWTSEM);
     if (vt.vt_func)
       chVTResetI(&vt);
     return currp->p_rdymsg;
@@ -188,7 +188,7 @@ void chSemSignal(Semaphore *sp) {
   chSysLock();
 
   if (sp->s_cnt++ < 0)
-    chSchWakeupI(fifo_remove(&sp->s_queue), RDY_OK);
+    chSchWakeupS(fifo_remove(&sp->s_queue), RDY_OK);
 
   chSysUnlock();
 }
@@ -199,6 +199,7 @@ void chSemSignal(Semaphore *sp) {
  * @note This function must be called with interrupts disabled.
  * @note The function is available only if the \p CH_USE_SEMAPHORES
  *       option is enabled in \p chconf.h.
+ * @note This function does not reschedule.
  */
 void chSemSignalI(Semaphore *sp) {
 
@@ -224,10 +225,10 @@ void chSemSignalWait(Semaphore *sps, Semaphore *spw) {
   if (--spw->s_cnt < 0) {
     fifo_insert(currp, &spw->s_queue);
     currp->p_semp = spw;
-    chSchGoSleepI(PRWTSEM);
+    chSchGoSleepS(PRWTSEM);
   }
   else
-    chSchRescheduleI();
+    chSchRescheduleS();
 
   chSysUnlock();
 }
@@ -265,7 +266,7 @@ void chSemRaisePrioWait(Semaphore *sp) {
   if (--sp->s_cnt < 0) {
     prioenq(currp, &sp->s_queue);
     currp->p_semp = sp;
-    chSchGoSleepI(PRWTSEM);
+    chSchGoSleepS(PRWTSEM);
   }
 
   if (!currp->p_rtcnt++)
@@ -288,10 +289,10 @@ void chSemLowerPrioSignal(Semaphore *sp) {
     currp->p_prio -= MEPRIO;
     if (sp->s_cnt++ < 0)
       chSchReadyI(fifo_remove(&sp->s_queue));
-    chSchRescheduleI();
+    chSchRescheduleS();
   }
   else if (sp->s_cnt++ < 0)
-    chSchWakeupI(fifo_remove(&sp->s_queue), RDY_OK);
+    chSchWakeupS(fifo_remove(&sp->s_queue), RDY_OK);
 
   chSysUnlock();
 }
@@ -315,7 +316,7 @@ void chSemRaisePrioSignalWait(Semaphore *sps, Semaphore *spw) {
   if (--spw->s_cnt < 0) {
     prioenq(currp, &spw->s_queue);
     currp->p_semp = spw;
-    chSchGoSleepI(PRWTSEM);
+    chSchGoSleepS(PRWTSEM);
 
     if (!currp->p_rtcnt++)
       currp->p_prio += MEPRIO;
@@ -324,7 +325,7 @@ void chSemRaisePrioSignalWait(Semaphore *sps, Semaphore *spw) {
     if (!currp->p_rtcnt++)
       currp->p_prio += MEPRIO;
 
-    chSchRescheduleI(); // Really needed ?
+    chSchRescheduleS(); // Really needed ?
   }
 
   chSysUnlock();
@@ -351,10 +352,10 @@ void chSemLowerPrioSignalWait(Semaphore *sps, Semaphore *spw) {
   if (--spw->s_cnt < 0) {
     fifo_insert(currp, &spw->s_queue); // fifo_insert() because the spw is a normal sem.
     currp->p_semp = spw;
-    chSchGoSleepI(PRWTSEM);
+    chSchGoSleepS(PRWTSEM);
   }
   else
-    chSchRescheduleI();
+    chSchRescheduleS();
 
   chSysUnlock();
 }
diff --git a/src/chsleep.c b/src/chsleep.c
index 5814410f3..6c8cfc3c3 100644
--- a/src/chsleep.c
+++ b/src/chsleep.c
@@ -35,7 +35,7 @@ void chThdSleep(t_time time) {
   chSysLock();
 
   chVTSetI(&vt, time, (t_vtfunc)chSchReadyI, currp);
-  chSchGoSleepI(PRSLEEP);
+  chSchGoSleepS(PRSLEEP);
 
   chSysUnlock();
 }
@@ -67,7 +67,7 @@ void chThdSleepUntil(t_time time) {
   chSysLock();
 
   chVTSetI(&vt, (t_time)(time - stime), (t_vtfunc)chSchReadyI, currp);
-  chSchGoSleepI(PRSLEEP);
+  chSchGoSleepS(PRSLEEP);
 
   chSysUnlock();
 }
diff --git a/src/chthreads.c b/src/chthreads.c
index 28b276db5..00ae04778 100644
--- a/src/chthreads.c
+++ b/src/chthreads.c
@@ -91,7 +91,7 @@ Thread *chThdCreate(t_prio prio, t_tmode mode, void *workspace,
 #endif
     chSysLock();
 
-    chSchWakeupI(tp, RDY_OK);
+    chSchWakeupS(tp, RDY_OK);
 
     chSysUnlock();
 #ifdef CH_USE_RESUME
@@ -116,7 +116,7 @@ void chThdSetPriority(t_prio newprio) {
 #else
   currp->p_prio = newprio;
 #endif
-  chSchRescheduleI();
+  chSchRescheduleS();
 
   chSysUnlock();
 }
@@ -135,7 +135,7 @@ void chThdResume(Thread *tp) {
   chSysLock();
 
   if (tp->p_state == PRSUSPENDED)
-    chSchWakeupI(tp, RDY_OK);
+    chSchWakeupS(tp, RDY_OK);
 
   chSysUnlock();
 }
@@ -176,7 +176,7 @@ void chThdExit(t_msg msg) {
 #ifdef CH_USE_EXIT_EVENT
   chEvtSendI(&currp->p_exitesource);
 #endif
-  chSchGoSleepI(PREXIT);
+  chSchGoSleepS(PREXIT);
 
   chSysUnlock();                        /* Never executed.              */
 }
@@ -196,7 +196,7 @@ t_msg chThdWait(Thread *tp) {
 
   if (tp->p_state != PREXIT) {
     list_insert(currp, &tp->p_waiting);
-    chSchGoSleepI(PRWAIT);
+    chSchGoSleepS(PRWAIT);
   }
 
   chSysUnlock();
diff --git a/src/include/delta.h b/src/include/delta.h
index 46fd3b883..1af774959 100644
--- a/src/include/delta.h
+++ b/src/include/delta.h
@@ -81,6 +81,9 @@ extern DeltaList dlist;
     }                                                                   \
   }
 
+/** Infinite time specification.*/
+#define TIME_INFINITE 0
+
 /*
  * Virtual Timers APIs.
  */
diff --git a/src/include/scheduler.h b/src/include/scheduler.h
index 884b3936c..fccbfb446 100644
--- a/src/include/scheduler.h
+++ b/src/include/scheduler.h
@@ -50,9 +50,9 @@ extern "C" {
 #endif
   void chSchInit(void);
   Thread *chSchReadyI(Thread *tp);
-  void chSchGoSleepI(t_tstate newstate);
-  void chSchWakeupI(Thread *tp, t_msg msg);
-  void chSchRescheduleI(void);
+  void chSchGoSleepS(t_tstate newstate);
+  void chSchWakeupS(Thread *tp, t_msg msg);
+  void chSchRescheduleS(void);
   void chSchDoRescheduleI(void);
   BOOL chSchRescRequiredI(void);
   void chSchTimerHandlerI(void);
-- 
cgit v1.2.3