event.c

Go to the documentation of this file.

/***************************************************************************
 * event.c
 * (C) 2010 Ivan Meleca
 * Based on original code written by Ruben Meleca
 * www.milos.it

#   This program 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.
#
#   This program 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 this program; if not, write to the Free Software
#   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

***************************************************************************/

#include "event.h"
#include "system.h"
#include <common/thlist.h>

__STATIC __VOID __eventQueueThread(__PEVENT ev, __PTHREAD th, u32 timeout)
{

    /* This function is called with disabled interrupts */

    /* Suspend the thread */
    th->th_wait = CPU_MS_TO_TICKS(timeout);
    __threadSuspend(th, __THSTS_WAITING);

    /* Insert the thread in the list */
    __thlAddEvtPrio(th, &ev->ev_threads);
}

__STATIC __VOID __eventDequeueThread(__PEVENT ev, __PTHREAD th)
{
    __thlRemoveEvtPrio(th, &ev->ev_threads);
}

__STATIC __VOID __eventSignal(__PEVENT ev, u8 val)
{
    __PTHREAD th;

    /* Signal the event */
    ev->ev_state = val;

    /* wake up the thread
     * (if any, we can be setting an event with no one waiting for it)
     */
    if (ev->ev_threads)
    {
        /* Disable interrupts */
        __systemStop();

        /* wake up each thread, schedule if one of these threads
         * has a higher priority than the current (running) one.
         * The worst case here is when ALL threads, except the running
         * one are waiting for this event.
         */

        /* If the first thread of the list has a higher priority of the current
         * one is enough to preempt (the list is ordered by priority)
         */
        if (__threadGetCurrent())
        {
            if (__threadGetCurrent()->th_priority > ev->ev_threads->th_priority)
            {
                /*
                 * Check if the current thread disabled the scheduler,
                 * if not, add the current thread to the ready list,
                 * __threadCurrent to __NULL and set scheduler.
                 */
                if (!__systemSchedulerDisabled())
                {

                    /* Add the current thread to the ready list */
                    __threadAddToReadyList(__threadGetCurrent());

                    /* We have no thread in execution */
                    __threadSetCurrent(__NULL);
                }

                /* Schedule context switch */
                __systemScheduleThreadChange();
            }
        } else {

            /* No thread running
             * Schedule context switch anyway
             */
            __systemScheduleThreadChange();
        }

        /* Scan the event's thread list */
        th = ev->ev_threads;
        while (th)
        {
            /* Here we will check if the thread is ready.
             * Can happen that a READY thread that went through timeout
             * it is being set as READY again and removed from suspended
             * and REINSERTED in the ready list TWICE.
             */
            if (th->th_status == __THSTS_WAITING)
            {
                __threadRemoveFromSuspended(th);
                __threadAddToReadyList(th);
            }

            th = th->th_evnext;
        }

        __systemStart();
    }
}

u8  __eventWait(__PEVENT ev, u32 timeout)
{
    u8 ret = 0;
    u32 irqs = 0;
    __PTHREAD th;

    /* Arrived here with interrupts disabled? */
    irqs = __systemGetIrqCount();
    if (!irqs)
    {
        /* Go critical */
        __systemStop();
    } else {
        /* Remove all pending irq enabled.
         * The next call to __systemStart (before switching context)
         * SHOULD really enable interrupts. So we save the interrupt-disabled
         * counter in irqs, to re-establish the __systemIrqCount counter on function
         * exit.
         */
        while (__systemGetIrqCount() != 1) __systemStart();
    }

    /* Check if the event is already set */
    if (ev->ev_state != __EV_RESET)
    {
        /*  Means the event was set before entering this function.
            That's why the __eventReset() function: it has to be called before waiting, because the event
            may be set before the call. So return the event was successfully signaled. */

        /* should return with disabled irq? */
        if (!irqs) {
            __systemStart();
        }
        return(__EVRET_SUCCESS);
    }

    th = __threadGetCurrent();

    /* Queue the current thread in the event's thread list */
    __eventQueueThread(ev, th, timeout);

    /* From now, we have no thread in execution */
    __threadSetCurrent(__NULL);

    /* Schedule context switch */
    __systemScheduleThreadChange();

    /* Enable interrupts */
    __systemStart();

    while (th->th_status != __THSTS_RUNNING);
    
    /* At this point the thread resumes. Test for state and
     * eventually timeout.
     */

    /* Critical again */
    __systemStop();

    /* Remove the current thread from the event's thread list */
    __eventDequeueThread(ev, th);

    /* should return with enabled irq? */
    if (irqs == 0) {
        __systemStart();
    } else {
        /* re-establish __systemIrqCount counter */
        while (__systemGetIrqCount() != irqs) __systemStop();
    }

    /* Check for timeout */
    if (timeout && !th->th_wait)
    {
        ret = __EVRET_TIMEOUT;
    } else
    {
        ret = __EVRET_SUCCESS;
    }

    if (ev->ev_state == __EV_ABORT)
    {
        ret = __EVRET_ABORT;
    }

    return ret;
}

__VOID  __eventSet(__PEVENT ev)
{
    __eventSignal(ev, __EV_SET);
}


__VOID __eventSetOne(__PEVENT ev)
{
    __systemStop();

    ev->ev_state = __EV_SET;

    /* wake up the thread
     * (if any, we can be setting an event with no one waiting for it)
     */
    if (ev->ev_threads)
    {
        if (__threadGetCurrent())
        {
            if (__threadGetCurrent()->th_priority > ev->ev_threads->th_priority)
            {
                /*
                 * Check if the current thread disabled the scheduler,
                 * if not, add the current thread to the ready list,
                 * __threadCurrent to __NULL and set scheduler.
                 */
                if (!__systemSchedulerDisabled())
                {
                    __threadAddToReadyList(__threadGetCurrent());
                    __threadSetCurrent(__NULL);
                    __systemScheduleThreadChange();
                }
            }
        } else {
            __systemScheduleThreadChange();
        }

        if (ev->ev_threads->th_status == __THSTS_WAITING)
        {
            __threadRemoveFromSuspended(ev->ev_threads);
            __threadAddToReadyList(ev->ev_threads);
        }

        __thlRemoveEvtPrio(ev->ev_threads, (__PTHREAD*) &ev->ev_threads);
    }

    __systemStart();
}

__VOID __eventReset(__PEVENT ev)
{
    __systemStop();
    ev->ev_state = __EV_RESET;
    __systemStart();
}

__VOID __eventAbort(__PEVENT ev)
{
    __eventSignal(ev, __EV_ABORT);
}

__PTHREAD __eventGetWaitingThreads(__PEVENT ev)
{
    return ev->ev_threads;
}