qk.h

Go to the documentation of this file.

/*****************************************************************************
* Product: QK/C platform-independent public interface
* Last Updated for Version: 4.0.03
* Date of the Last Update:  Dec 26, 2008
*
*                    Q u a n t u m     L e a P s
*                    ---------------------------
*                    innovating embedded systems
*
* Copyright (C) 2002-2008 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
*****************************************************************************/
#ifndef qk_h
#define qk_h

#include "qequeue.h"       /* The QK kernel uses the native QF event queue  */
#include "qmpool.h"        /* The QK kernel uses the native QF memory pool  */
#include "qpset.h"         /* The QK kernel uses the native QF priority set */

/****************************************************************************/
/* QF configuration for QK */

#define QF_EQUEUE_TYPE             QEQueue

#if defined(QK_TLS) || defined(QK_EXT_SAVE)

    #define QF_OS_OBJECT_TYPE      uint8_t

    #define QF_THREAD_TYPE         void *
#endif                                             /* QK_TLS || QK_EXT_SAVE */

#if (QF_MAX_ACTIVE <= 8)
    extern QPSet8  volatile QK_readySet_;                 
#else
    extern QPSet64 volatile QK_readySet_;                 
#endif

/* public-scope objects */
extern uint8_t volatile QK_currPrio_;  
extern uint8_t volatile QK_intNest_;           
/* QK active object queue implementation ...................................*/

#define QACTIVE_EQUEUE_WAIT_(me_) \
    Q_ASSERT((me_)->eQueue.frontEvt != (QEvent *)0)

#if (QF_MAX_ACTIVE <= 8)
    #define QACTIVE_EQUEUE_SIGNAL_(me_) \
        QPSet8_insert(&QK_readySet_, (me_)->prio); \
        if (QK_intNest_ == (uint8_t)0) { \
            QK_SCHEDULE_(); \
        } \
        else ((void)0)

    #define QACTIVE_EQUEUE_ONEMPTY_(me_) \
        QPSet8_remove(&QK_readySet_, (me_)->prio)
#else

    #define QACTIVE_EQUEUE_SIGNAL_(me_) \
        QPSet64_insert(&QK_readySet_, (me_)->prio); \
        if (QK_intNest_ == (uint8_t)0) { \
            QK_SCHEDULE_(); \
        } \
        else ((void)0)

    #define QACTIVE_EQUEUE_ONEMPTY_(me_) \
        QPSet64_remove(&QK_readySet_, (me_)->prio)
#endif


/* QK event pool operations ................................................*/

#define QF_EPOOL_TYPE_              QMPool

#define QF_EPOOL_INIT_(p_, poolSto_, poolSize_, evtSize_) \
    QMPool_init(&(p_), poolSto_, poolSize_, evtSize_)

#define QF_EPOOL_EVENT_SIZE_(p_)    ((p_).blockSize)

#define QF_EPOOL_GET_(p_, e_)       ((e_) = (QEvent *)QMPool_get(&(p_)))

#define QF_EPOOL_PUT_(p_, e_)       (QMPool_put(&(p_), (e_)))

void QK_init(void);

void QK_onIdle(void);

char const Q_ROM * Q_ROM_VAR QK_getVersion(void);

char const Q_ROM * Q_ROM_VAR QK_getPortVersion(void);

#ifndef QK_NO_MUTEX

    typedef uint8_t QMutex;

    QMutex QK_mutexLock(uint8_t prioCeiling);

    void QK_mutexUnlock(QMutex mutex);

#endif                                                          /* QK_MUTEX */

/* QK scheduler and extended scheduler */
#ifndef QF_INT_KEY_TYPE
    void QK_schedule_(void);
    void QK_scheduleExt_(void);                    /* QK extended scheduler */

    #define QK_SCHEDULE_()      QK_schedule_()
#else

    void QK_schedule_(QF_INT_KEY_TYPE intLockKey);

    void QK_scheduleExt_(QF_INT_KEY_TYPE intLockKey); /* extended scheduler */

    #define QK_SCHEDULE_()      QK_schedule_(intLockKey_)
#endif

/****************************************************************************/
/* QS software tracing integration, only if enabled                         */
#ifdef Q_SPY                                /* QS software tracing enabled? */
    #ifndef qs_h
    #include "qs_port.h"                                 /* include QS port */
    #endif
#else
    #ifndef qs_dummy_h
    #include "qs_dummy.h"                /* disable the QS software tracing */
    #endif
#endif                                                             /* Q_SPY */

#endif                                                              /* qk_h */

---