qkn.c

Go to the documentation of this file.

/*****************************************************************************
* Product: QK-nano implemenation
* Last Updated for Version: 4.3.00
* Date of the Last Update:  Oct 29, 2011
*
*                    Q u a n t u m     L e a P s
*                    ---------------------------
*                    innovating embedded systems
*
* Copyright (C) 2002-2011 Quantum Leaps, LLC. All rights reserved.
*
* This software may be distributed and modified under the terms of the GNU
* General Public License version 2 (GPL) as published by the Free Software
* Foundation and appearing in the file GPL.TXT included in the packaging of
* this file. Please note that GPL Section 2[b] requires that all works based
* on this software must also be made publicly available under the terms of
* the GPL ("Copyleft").
*
* Alternatively, this software may be distributed and modified under the
* terms of Quantum Leaps commercial licenses, which expressly supersede
* the GPL and are specifically designed for licensees interested in
* retaining the proprietary status of their code.
*
* Contact information:
* Quantum Leaps Web site:  http://www.quantum-leaps.com
* e-mail:                  info@quantum-leaps.com
*****************************************************************************/
#include "qpn_port.h"                                       /* QP-nano port */

Q_DEFINE_THIS_MODULE(qkn)


#ifndef QK_PREEMPTIVE
    #error "The required header file qkn.h is not included in qpn_port.h"
#endif

/* Global-scope objects ----------------------------------------------------*/
                                      /* start with the QK scheduler locked */
uint8_t volatile QK_currPrio_ = (uint8_t)(QF_MAX_ACTIVE + 1);

#ifdef QF_ISR_NEST
uint8_t volatile QK_intNest_;              /* start with nesting level of 0 */
#endif

#ifdef QK_MUTEX
uint8_t volatile QK_ceilingPrio_;            /* ceiling priority of a mutex */
#endif

/*..........................................................................*/
static void initialize(void) {
    uint8_t p;
    QActive *a;
                         /* set priorities all registered active objects... */
    for (p = (uint8_t)1; p <= (uint8_t)QF_MAX_ACTIVE; ++p) {
        a = (QActive *)Q_ROM_PTR(QF_active[p].act);
        Q_ASSERT(a != (QActive *)0);    /* QF_active[p] must be initialized */
        a->prio = p;               /* set the priority of the active object */
    }
         /* trigger initial transitions in all registered active objects... */
    for (p = (uint8_t)1; p <= (uint8_t)QF_MAX_ACTIVE; ++p) {
        a = (QActive *)Q_ROM_PTR(QF_active[p].act);
#ifndef QF_FSM_ACTIVE
        QHsm_init((QHsm *)a);                              /* initial tran. */
#else
        QFsm_init((QFsm *)a);                              /* initial tran. */
#endif
    }

    QF_INT_LOCK();
    QK_currPrio_ = (uint8_t)0;     /* set the priority for the QK idle loop */
    p = QK_schedPrio_();
    if (p != (uint8_t)0) {
        QK_sched_(p);                 /* process all events produced so far */
    }
    QF_INT_UNLOCK();
}
/*..........................................................................*/
void QF_run(void) {
    initialize();
    QF_onStartup();                              /* invoke startup callback */

    for (;;) {                                    /* enter the QK idle loop */
        QK_onIdle();                         /* invoke the on-idle callback */
    }
}
/* Local-scope objects -----------------------------------------------------*/
static uint8_t const Q_ROM Q_ROM_VAR l_log2Lkup[] = {
    0U, 1U, 2U, 2U, 3U, 3U, 3U, 3U, 4U, 4U, 4U, 4U, 4U, 4U, 4U, 4U
};

/*..........................................................................*/
/* NOTE: QK schePrio_() is entered and exited with interrupts LOCKED */
uint8_t QK_schedPrio_(void) Q_REENTRANT {
    uint8_t p;               /* highest-priority active object ready to run */

          /* determine the priority of the highest-priority AO ready to run */
#if (QF_MAX_ACTIVE > 4)
    if ((QF_readySet_ & 0xF0) != 0) {                 /* upper nibble used? */
        p = (uint8_t)(Q_ROM_BYTE(l_log2Lkup[QF_readySet_ >> 4]) + 4);
    }
    else                            /* upper nibble of QF_readySet_ is zero */
#endif
    {
        p = Q_ROM_BYTE(l_log2Lkup[QF_readySet_]);
    }

#ifdef QK_MUTEX                     /* QK priority-ceiling mutexes allowed? */
    if ((p > QK_currPrio_) && (p > QK_ceilingPrio_)) {
#else
    if (p > QK_currPrio_) {                     /* do we have a preemption? */
#endif                                                          /* QK_MUTEX */
        return p;
    }
    else {
        return (uint8_t)0;
    }
}
/*..........................................................................*/
/* NOTE: QK_sched_() is entered and exited with interrupts LOCKED */
void QK_sched_(uint8_t p) Q_REENTRANT {
    static uint8_t const Q_ROM Q_ROM_VAR invPow2Lkup[] = {
        0xFFU, 0xFEU, 0xFDU, 0xFBU, 0xF7U, 0xEFU, 0xDFU, 0xBFU, 0x7FU
    };

    uint8_t pin = QK_currPrio_;                /* save the initial priority */
    do {
        QActive *a;
        QActiveCB const Q_ROM *ao;

        QK_currPrio_ = p;      /* new priority becomes the current priority */
        QF_INT_UNLOCK();             /* it's safe to leave critical section */

        ao = &QF_active[p];
        a = (QActive *)Q_ROM_PTR(ao->act);                   /* map p to AO */

        QF_INT_LOCK();                     /* get ready to access the queue */
        Q_ASSERT(a->nUsed > 0);            /* some events must be available */
        --a->nUsed;
        if (a->nUsed == (uint8_t)0) {              /* queue becoming empty? */
            QF_readySet_ &= Q_ROM_BYTE(invPow2Lkup[p]);    /* clear the bit */
        }
        Q_SIG(a) =
            ((QEvent *)Q_ROM_PTR(ao->queue))[a->tail].sig;
#if (Q_PARAM_SIZE != 0)
        Q_PAR(a) =
            ((QEvent *)Q_ROM_PTR(ao->queue))[a->tail].par;
#endif
        if (a->tail == (uint8_t)0) {                        /* wrap around? */
            a->tail = Q_ROM_BYTE(ao->end);
        }
        --a->tail;
        QF_INT_UNLOCK();              /* unlock interrupts to launch a task */

                                      /* dispatch to HSM (execute RTC step) */
#ifndef QF_FSM_ACTIVE
        QHsm_dispatch((QHsm *)a);
#else
        QFsm_dispatch((QFsm *)a);
#endif

        QF_INT_LOCK();

                          /* determine the highest-priority AO ready to run */
#if (QF_MAX_ACTIVE > 4)
        if ((QF_readySet_ & 0xF0) != 0) {             /* upper nibble used? */
            p = (uint8_t)(Q_ROM_BYTE(l_log2Lkup[QF_readySet_ >> 4]) + 4);
        }
        else                        /* upper nibble of QF_readySet_ is zero */
#endif
        {
            p = Q_ROM_BYTE(l_log2Lkup[QF_readySet_]);
        }

#ifdef QK_MUTEX                     /* QK priority-ceiling mutexes allowed? */
    } while ((p > pin) && (p > QK_ceilingPrio_));
#else
    } while (p > pin);
#endif                                                          /* QK_MUTEX */

    QK_currPrio_ = pin;                     /* restore the initial priority */
}

#ifdef QK_MUTEX
/*..........................................................................*/
QMutex QK_mutexLock(uint8_t prioCeiling) {
    uint8_t mutex;
    QF_INT_LOCK();
    mutex = QK_ceilingPrio_;  /* the original QK priority ceiling to return */
    if (QK_ceilingPrio_ < prioCeiling) {
        QK_ceilingPrio_ = prioCeiling;     /* raise the QK priority ceiling */
    }
    QF_INT_UNLOCK();
    return mutex;
}
/*..........................................................................*/
void QK_mutexUnlock(QMutex mutex) {
    QF_INT_LOCK();
    if (QK_ceilingPrio_ > mutex) {
        QK_ceilingPrio_ = mutex;      /* restore the saved priority ceiling */
        mutex = = QK_schedPrio_();        /* reuse 'mutex' to hold priority */
        if (mutex != (uint8_t)0) {
            QK_sched_(mutex);
        }
    }
    QF_INT_UNLOCK();
}
#endif                                                   /* #ifdef QK_MUTEX */