event.c

Go to the documentation of this file.

/*
 * Copyright (C) 2001-2006 by egnite Software GmbH. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the copyright holders nor the names of
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY EGNITE SOFTWARE GMBH AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL EGNITE
 * SOFTWARE GMBH OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * For additional information see http://www.ethernut.de/
 */

#include <cfg/os.h>

#include <compiler.h>
#include <sys/atom.h>
#include <sys/heap.h>
#include <sys/timer.h>
#include <sys/thread.h>
#include <sys/event.h>
#include <sys/nutdebug.h>

#ifdef NUTDEBUG
#include <sys/osdebug.h>
#include <stdio.h>
#endif

#ifdef NUTTRACER
#include <sys/tracer.h>
#endif



void NutEventTimeout(HANDLE timer, void *arg)
{
    NUTTHREADINFO *tqp;
    NUTTHREADINFO *volatile *tqpp = arg;

    NUTASSERT(tqpp != NULL);

    /* Get the queue's root atomically. */
    NutEnterCritical();
    tqp = *tqpp;
    NutExitCritical();

    /*
     * A signaled queue is an empty queue. So our
     * thread already left this queue.
     */
    if (tqp != SIGNALED) {

        /*
         * Walk down the linked list and identify
         * the thread by the timer id it is waiting
         * for.
         */
        while (tqp) {
            if (tqp->td_timer == timer) {
                /* Found the thread. Remove it from the event queue. */
                   
                NutEnterCritical();
                *tqpp = tqp->td_qnxt;
                if (tqp->td_qpec) {
                    if (tqp->td_qnxt) {
                        tqp->td_qnxt->td_qpec = tqp->td_qpec;
                    }
                    else {
                        *tqpp = SIGNALED;
                    }
                    tqp->td_qpec = 0;
                }
                NutExitCritical();

                /* Add it to the queue of threads, which are ready to run. */
                tqp->td_state = TDS_READY;
                NutThreadAddPriQueue(tqp, (NUTTHREADINFO **) & runQueue);

                /* Signal the timer entry in the thread's info structure.
                   This will tell the waiting thread, that it has been
                   woken up by a timeout. */
                tqp->td_timer = SIGNALED;
                break;
            }
            tqpp = &tqp->td_qnxt;
            tqp = tqp->td_qnxt;
        }
    }
}

int NutEventWait(volatile HANDLE * qhp, uint32_t ms)
{
    NUTTHREADINFO *tdp;

    NUTASSERT(qhp != NULL);

    /* Get the queue's root atomically. */
    NutEnterCritical();
    tdp = *qhp;
    NutExitCritical();

    /*
     * Check for posts on a previously empty queue. 
     */
    if (tdp == SIGNALED) {
        /* Clear the singaled state. */
        NutEnterCritical();
        *qhp = 0;
        NutExitCritical();
        
        /*
         * Even if already signaled, switch to any other thread, which 
         * is ready to run and has the same or higher priority.
         */
        NutThreadYield();
        return 0;
    }

    /*
     * Remove the current thread from the list of running threads 
     * and add it to the specified queue.
     */
    NutThreadRemoveQueue(runningThread, &runQueue);
    NutThreadAddPriQueue(runningThread, (NUTTHREADINFO **) qhp);

    /* Update our thread's state (sleeping + timer) */
    runningThread->td_state = TDS_SLEEP;
    if (ms) {
        runningThread->td_timer = NutTimerStart(ms, NutEventTimeout, (void *) qhp, TM_ONESHOT);
    }
    else {
        runningThread->td_timer = 0;
    }

    /*
     * Switch to the next thread, which is ready to run.
     */
#ifdef NUTTRACER
    TRACE_ADD_ITEM(TRACE_TAG_THREAD_WAIT,(int)runningThread);
#endif
    NutThreadResume();

    /* If our timer handle is signaled, we were woken up by a timeout. */
    if (runningThread->td_timer == SIGNALED) {
        runningThread->td_timer = 0;
        return -1;
    }
    return 0;
}

int NutEventWaitNext(volatile HANDLE * qhp, uint32_t ms)
{
    NUTASSERT(qhp != NULL);

    /*
     * Check for posts on a previously empty queue. 
     */
    NutEnterCritical();
    if (*qhp == SIGNALED)
        *qhp = 0;
    NutExitCritical();

    return NutEventWait(qhp, ms);
}

int NutEventPostAsync(volatile HANDLE * qhp)
{
    NUTTHREADINFO *td;

    NUTASSERT(qhp != NULL);

    NutEnterCritical();
    td = *qhp;
    NutExitCritical();

    /* Ignore signaled queues. */
    if (td != SIGNALED) {
        
        /* A thread is waiting. */
        if (td) {
            /* Remove the thread from the wait queue. */
            NutEnterCritical();
            *qhp = td->td_qnxt;
            if (td->td_qpec) {
                if (td->td_qnxt) {
                    td->td_qnxt->td_qpec = td->td_qpec;
                }
                else {
                    *qhp = SIGNALED;
                }
                td->td_qpec = 0;
            }
            NutExitCritical();

            /* Stop any running timeout timer. */
            if (td->td_timer) {
                NutTimerStop(td->td_timer);
                td->td_timer = 0;
            }
            /* The thread is ready to run. */
            td->td_state = TDS_READY;
            NutThreadAddPriQueue(td, (NUTTHREADINFO **) & runQueue);

            return 1;
        }
        
        /* No thread is waiting. Mark the queue signaled. */
        else {
            NutEnterCritical();
            *qhp = SIGNALED;
            NutExitCritical();
        }
    }
    return 0;
}

int NutEventPost(volatile HANDLE * qhp)
{
    int rc;

    rc = NutEventPostAsync(qhp);

    /*
     * If any thread with higher or equal priority is
     * ready to run, switch the context.
     */
    NutThreadYield();

    return rc;
}

int NutEventBroadcastAsync(volatile HANDLE * qhp)
{
    int rc = 0;
    NUTTHREADINFO *tdp;

    NUTASSERT(qhp != NULL);

    /* Get the queue's root atomically. */
    NutEnterCritical();
    tdp = *qhp;
    NutExitCritical();

    if (tdp == SIGNALED) {
        NutEnterCritical();
        *qhp = 0;
        NutExitCritical();
    }
    else if (tdp) {
        do {
            rc += NutEventPostAsync(qhp);
            /* Get the queue's updated root atomically. */
            NutEnterCritical();
            tdp = *qhp;
            NutExitCritical();
        } while (tdp && tdp != SIGNALED);
    }
    return rc;
}

int NutEventBroadcast(volatile HANDLE * qhp)
{
    int rc = NutEventBroadcastAsync(qhp);

    NutThreadYield();

    return rc;
}