qk.h

Go to the documentation of this file.

/*****************************************************************************
* Product: QK/C platform-independent public interface
* Last Updated for Version: 4.4.00
* Date of the Last Update:  Jan 17, 2012
*
*                    Q u a n t u m     L e a P s
*                    ---------------------------
*                    innovating embedded systems
*
* Copyright (C) 2002-2012 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  QK_readySet_;         
#else
    extern QPSet64 QK_readySet_;         
#endif

/* 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_) do { \
        QPSet8_insert(&QK_readySet_, (me_)->prio); \
        if (QK_intNest_ == (uint8_t)0) { \
            uint8_t p = QK_schedPrio_(); \
            if (p != (uint8_t)0) { \
                QK_sched_(p); \
            } \
        } \
    } while (0)

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

    #define QACTIVE_EQUEUE_SIGNAL_(me_) do { \
        QPSet64_insert(&QK_readySet_, (me_)->prio); \
        if (QK_intNest_ == (uint8_t)0) { \
            uint8_t p = QK_schedPrio_(); \
            if (p != (uint8_t)0) { \
                QK_sched_(p); \
            } \
        } \
    } while (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_), (QMPoolSize)(evtSize_))

#define QF_EPOOL_EVENT_SIZE_(p_)    ((QEventSize)(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_sched_(uint8_t p);

void QK_schedExt_(uint8_t p);

uint8_t QK_schedPrio_(void);

/* public-scope objects */
extern uint8_t QK_currPrio_;           
extern uint8_t QK_intNest_;                    
/****************************************************************************/
void QK_init(void);

void QK_onIdle(void);

char_t const Q_ROM * Q_ROM_VAR QK_getVersion(void);

#ifndef QK_NO_MUTEX

    typedef uint8_t QMutex;

    QMutex QK_mutexLock(uint8_t prioCeiling);

    void QK_mutexUnlock(QMutex mutex);

#endif                                                          /* QK_MUTEX */

#endif                                                              /* qk_h */