root / Whitix / branches / hybrid / kernel / timer.c

/*  This file is part of Whitix.
 *
 *  Whitix is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Whitix is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Whitix; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#include <timer.h>
#include <llist.h>
#include <console.h>
#include <module.h>
#include <error.h>
#include <task.h>
#include <malloc.h>

LIST_HEAD(timerList);
Spinlock timerLock;

/***********************************************************************
 *
 * FUNCTION: TimerAdd
 *
 * DESCRIPTION: Add a timer to the list.
 *
 * PARAMETERS: timer - timer in question.
 *
 * RETURNS: Usual error codes.
 *
 ***********************************************************************/

void TimerAdd(struct Timer* timer)
{
        SpinLockIrq(&timerLock);
        struct Timer* curr;

        if (ListEmpty(&timerList))
                ListAdd(&timer->list,&timerList);
        else{
                ListForEachEntry(curr,&timerList,list)
                {
                        if (curr->expires > timer->expires)
                        {
                                if (curr->list.prev != &timerList)
                                        timer->expires-=ListEntry(curr->list.prev,struct Timer,list)->expires;

                                curr->expires-=timer->expires;

                                /* Add before the current timer. */
                                DoListAdd(&timer->list,curr->list.prev,&curr->list);
                                goto out;
                        }
                }

                /* Add to end of list */
                if (curr->list.prev != &timerList)
                        timer->expires-=ListEntry(curr->list.prev,struct Timer,list)->expires;

                ListAddTail(&timer->list,&timerList);
        }

out:
        SpinUnlockIrq(&timerLock);
}

SYMBOL_EXPORT(TimerAdd);

/***********************************************************************
 *
 * FUNCTION: TimerRemove
 *
 * DESCRIPTION: Remove a timer and update other timers.
 *
 * PARAMETERS: timer - timer in question.
 *
 * RETURNS: Usual error codes.
 *
 ***********************************************************************/

int TimerRemove(struct Timer* timer)
{
        int err=0;
        SpinLockIrq(&timerLock);

        if (ListEmpty(&timerList))
                err=-EINVAL;
        else{
                struct Timer* curr,*curr2;
                ListForEachEntrySafe(curr,curr2,&timerList,list)
                {
                        if (curr == timer)
                        {
                                ListRemove(&curr->list);

                                if (timer->expires > 0)
                                        curr2->expires+=curr->expires;
                        }
                }
        }

        SpinUnlockIrq(&timerLock);

        return err;
}

SYMBOL_EXPORT(TimerRemove);

/***********************************************************************
 *
 * FUNCTION: UpdateTimers
 *
 * DESCRIPTION: Update the list of timers.
 *
 * PARAMETERS: None.
 *
 * RETURNS: Nothing.
 *
 ***********************************************************************/

/* TODO: Does it really need to run in an IRQ? */

void UpdateTimers()
{
        struct Timer* timer;

        if (ListEmpty(&timerList))
                return;

        /* Get head of the list */
        timer=ListEntry(timerList.next,struct Timer,list);
        timer->expires-=10; /* The timeslice */

        if (timer->expires <= 0)
        {
                ListRemove(&timer->list);
                timer->func(timer->data);
        }
}

static void SleepWakeup(void* data)
{
        struct Thread* thread=(struct Thread*)data;
        ThrStartThread(thread);
}

void Sleep(int milliSeconds)
{
        struct Timer timer;

        timer.func=SleepWakeup;
        timer.expires=milliSeconds;
        timer.data=currThread;

        TimerAdd(&timer);
        ThrSuspendThread(currThread);
        ThrSchedule();
}

SYMBOL_EXPORT(Sleep);