andreika-git
/
ChibiOS
mirror of https://github.com/andreika-git/ChibiOS.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Documentation reorganization. 

git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@1133 35acf78f-673a-0410-8e92-d51de3d6d3f4
This commit is contained in:
gdisirio 2009-08-30 06:59:43 +00:00
parent 255d1444ea
commit 397ccffac5
50 changed files with 811 additions and 352 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
docs/Doxyfile
View File

@ -574,9 +574,10 @@ WARN_LOGFILE =
# with spaces.
INPUT = ../docs/src \
../os/kernel \
../os/kernel/include \
../os/kernel/src \
../os/ports/templates \
../os/kernel/templates \
../os/ports/GCC/ARM7 \
../os/ports/GCC/ARM7/crt0.s \
../os/ports/GCC/ARM7/chcoreasm.s \

4
docs/src/concepts.dox
View File

@ -54,7 +54,7 @@
* - <b>Regular Interrupts</b>. Maskable interrupt sources that cannot
* preempt the kernel code and are thus able to invoke operating system APIs
* from within their handlers. The interrupt handlers belonging to this class
* must be written following some rules. See the @ref System APIs group and
* must be written following some rules. See the @ref system APIs group and
* @ref article_interrupts.
* - <b>Fast Interrupts</b>. Maskable interrupt sources with the ability
* to preempt the kernel code and thus have a lower latency and are less
@ -244,7 +244,7 @@
* - Interrupt Stack.
* - Internal Context.
* .
* See the @ref Core documentation for details, the area may change on
* See the @ref core documentation for details, the area may change on
* the various ports and some structures may not be present (or be zero-sized).
*
* @section architecture Architectural Diagram

282
docs/src/main.dox
View File

@ -100,249 +100,6 @@
* ChibiOS/RT ports.
*/
/**
* @defgroup Kernel Kernel
* Kernel related subsystems,
*/
/**
* @defgroup Config Configuration
* In @p chconf.h are defined the required subsystems for your application.
* @ingroup Kernel
*/
/**
* @defgroup Core Port Code Templates
* Non portable code templates. The function and the macros defined under this
* section are the non portable part of the kernel.
* @note The port code is not an API, the applications should not invoke it
* directly, use the equivalent system API instead.
* @ingroup Kernel
*/
/**
* @defgroup Types Types
* System types and macros.
* @ingroup Kernel
*/
/**
* @defgroup System System Management
* Initialization, Locks, Interrupt Handling, Power Management, Abnormal
* Termination.
* @ingroup Kernel
*/
/**
* @defgroup Debug Debug Support
* Debug APIs and procedures.
* @ingroup Kernel
*/
/**
* @defgroup Scheduler Low Level Scheduler
* ChibiOS/RT scheduler APIs and macros.
* @ingroup Kernel
*/
/**
* @defgroup ThreadLists Thread Lists and Queues
* ChibiOS/RT thread lists and queues utilities.
* @ingroup Kernel
*/
/**
* @defgroup Threads Threads
* Threads related APIs.
* @ingroup Kernel
*/
/**
* @defgroup Time Time and Virtual Timers
* Time and Virtual Timers related APIs.
* @ingroup Kernel
*/
/**
* @defgroup Synchronization Synchronization
* Synchronization services.
*/
/**
* @defgroup Semaphores Semaphores
* Semaphores and threads synchronization.
* <h2>Operation mode</h2>
* A semaphore is a threads synchronization object, some operations
* are defined on semaphores:
* - <b>Signal</b>: The semaphore counter is increased and if the result
* is non-positive then a waiting thread is removed from the semaphore
* queue and made ready for execution.
* - <b>Wait</b>: The semaphore counter is decreased and if the result
* becomes negative the thread is queued in the semaphore and suspended.
* - <b>Reset</b>: The semaphore counter is reset to a non-negative value
* and all the threads in the queue are released.
* .
* Semaphores can be used as guards for mutual exclusion code zones (note that
* mutexes are recommended for this kind of use) but also have other uses,
* queues guards and counters as example.<br>
* Semaphores usually use FIFO queues but it is possible to make them
* order threads by priority by specifying CH_USE_SEMAPHORES_PRIORITY in
* @p chconf.h.<br>
* In order to use the Semaphores APIs the @p CH_USE_SEMAPHORES
* option must be specified in @p chconf.h.<br><br>
* @ingroup Synchronization
*/
/**
* @defgroup Mutexes Mutexes
* Mutexes and threads synchronization.
* <h2>Operation mode</h2>
* A mutex is a threads synchronization object, some operations are defined
* on mutexes:
* - <b>Lock</b>: The mutex is checked, if the mutex is not owned by some
* other thread then it is locked else the current thread is queued on the
* mutex in a list ordered by priority.
* - <b>Unlock</b>: The mutex is released by the owner and the highest
* priority thread waiting in the queue, if any, is resumed and made owner
* of the mutex.
* .
* In order to use the Event APIs the @p CH_USE_MUTEXES option must be
* specified in @p chconf.h.<br>
*
* <h2>Constraints</h2>
* In ChibiOS/RT the Unlock operations are always performed in Lock-reverse
* order. The Unlock API does not even have a parameter, the mutex to unlock
* is taken from an internal stack of owned mutexes.
* This both improves the performance and is required by an efficient
* implementation of the priority inheritance mechanism.
*
* <h2>The priority inversion problem</h2>
* The mutexes in ChibiOS/RT implements the <b>full</b> priority
* inheritance mechanism in order handle the priority inversion problem.<br>
* When a thread is queued on a mutex, any thread, directly or indirectly,
* holding the mutex gains the same priority of the waiting thread (if their
* priority was not already equal or higher). The mechanism works with any
* number of nested mutexes and any number of involved threads. The algorithm
* complexity (worst case) is N with N equal to the number of nested mutexes.
* @ingroup Synchronization
*/
/**
* @defgroup CondVars Condition Variables
* Condition Variables and threads synchronization.
* <h2>Operation mode</h2>
* The condition variable is a synchronization object meant to be used inside
* a zone protected by a @p Mutex. Mutexes and CondVars together can implement
* a Monitor construct.<br>
* In order to use the Condition Variables APIs the @p CH_USE_CONDVARS
* option must be specified in @p chconf.h.<br><br>
* @ingroup Synchronization
*/
/**
* @defgroup Events Event Flags
* @brief Event Flags, Event Sources and Event Listeners.
* <h2>Operation mode</h2>
* Each thread has a mask of pending event flags inside its Thread structure.
* Several operations are defined:
* - <b>Wait</b>, the invoking thread goes to sleep until a certain AND/OR
* combination of event flags becomes pending.
* - <b>Clear</b>, a mask of event flags is cleared from the pending events
* mask, the cleared event flags mask is returned (only the flags that were
actually pending and then cleared).
* - <b>Signal</b>, an event mask is directly ORed to the mask of the signaled
* thread.
* - <b>Broadcast</b>, each thread registered on an Event Source is signaled
* with the event flags specified in its Event Listener.
* - <b>Dispatch</b>, an events mask is scanned and for each bit set to one
* an associated handler function is invoked. Bit masks are scanned from bit
* zero upward.
* .
* An Event Source is a special object that can be "broadcasted" by a thread or
* an interrupt service routine. Broadcasting an Event Source has the effect
* that all the threads registered on the Event Source will be signaled with
* and events mask.<br>
* An unlimited number of Event Sources can exists in a system and each
* thread can listen on an unlimited number of them.<br><br>
* In order to use the Event APIs the @p CH_USE_EVENTS option must be
* specified in @p chconf.h.
* @ingroup Synchronization
*/
/**
* @defgroup Messages Synchronous Messages
* Synchronous inter-thread messages.
* <h2>Operation Mode</h2>
* Synchronous messages are an easy to use and fast IPC mechanism, threads
* can both serve messages and send messages to other threads, the mechanism
* allows data to be carried in both directions. Data is not copied between
* the client and server threads but just a pointer passed so the exchange
* is very time efficient.<br>
* Messages are usually processed in FIFO order but it is possible to process
* them in priority order by specifying CH_USE_MESSAGES_PRIORITY
* in @p chconf.h.<br>
* Threads do not need to allocate space for message queues, the mechanism
* just requires two extra pointers in the @p Thread structure (the message
* queue header).<br>
* In order to use the Messages APIs the @p CH_USE_MESSAGES option must be
* specified in @p chconf.h.
* @ingroup Synchronization
*/
/**
* @defgroup Mailboxes Mailboxes
* Asynchronous messages.
* <h2>Operation mode</h2>
* A mailbox is an asynchronous communication mechanism.<br>
* The following operations are possible on a mailbox:
* - <b>Post</b>: Posts a message on the mailbox in FIFO order.
* - <b>Post Ahead</b>: Posts a message on the mailbox with high priority.
* - <b>Fetch</b>: A message is fetched from the mailbox and removed from
* the queue.
* - <b>Reset</b>: The mailbox is emptied and all the stored messages lost.
* .
* A message is a variable of type msg_t that is guaranteed to have the
* same size of and be compatible with pointers (an explicit cast is needed).
* If larger messages need to be exchanged then a pointer to a structure can
* be posted in the mailbox but the posting side has no predefined way to
* know when the message has been processed. A possible approach is to
* allocate memory (from a memory pool as example) from the posting side and
* free it on the fetching side. Another approach is to set a "done" flag into
* the structure pointed by the message.
* @ingroup Synchronization
*/
/**
* @defgroup Memory Memory Management
* Memory Management services.
*/
/**
* @defgroup Heap Heap
* Heap Allocator related APIs.
* <h2>Operation mode</h2>
* The heap allocator implements a first-fit strategy and its APIs are
* functionally equivalent to the usual @p malloc() and @p free(). The main
* difference is that the heap APIs are thread safe.<br>
* By enabling the @p CH_USE_MALLOC_HEAP option the heap manager will use the
* runtime-provided @p malloc() and @p free() as backend for the heap APIs
* instead of the system provided allocator.<br>
* In order to use the heap APIs the @p CH_USE_HEAP option must be specified
* in @p chconf.h.
* @ingroup Memory
*/
/**
* @defgroup MemoryPools Memory Pools
* Memory Pools related APIs.
* <h2>Operation mode</h2>
* The Memory Pools APIs allow to allocate/free fixed size objects in
* <b>constant time</b> and reliably without memory fragmentation problems.<br>
* In order to use the Time APIs the @p CH_USE_MEMPOOLS option must be
* specified in @p chconf.h.
* @ingroup Memory
*/
/**
* @defgroup IO I/O Support
* @brief I/O related services.
@ -375,45 +132,6 @@
* .
*/
/**
* @defgroup Channels I/O Abstract Channels
* @brief Abstract I/O Channels.
* @details This module defines an abstract interface for I/O channels. Note
* that no code is present, I/O channels are just abstract classes-like
* structures, you should look at the systems as to a set of abstract C++
* classes (even if written in C). Specific device drivers can use/extend
* the interfaces and implement them.<br>
* This system has the advantage to make the access to channels
* independent from the implementation logic. As example, an I/O channel
* interface can hide the access to a serial driver, to a networking socket
* and so on.
*
* @ingroup IO
*/
/**
* @defgroup IOQueues I/O Queues
* @brief I/O queues.
* @details ChibiOS/RT supports several kinds of queues. The queues are mostly
* used in serial-like device drivers. The device drivers are usually designed
* to have a lower side (lower driver, it is usually an interrupt service
* routine) and an upper side (upper driver, accessed by the application
* threads).<br>
* There are several kind of queues:<br>
* - <b>Input queue</b>, unidirectional queue where the writer is the
* lower side and the reader is the upper side.
* - <b>Output queue</b>, unidirectional queue where the writer is the
* upper side and the reader is the lower side.
* - <b>Full duplex queue</b>, bidirectional queue where read and write
* operations can happen at the same time. Full duplex queues
* are implemented by pairing an input queue and an output queue together.
* .
* In order to use the I/O queues the @p CH_USE_QUEUES option must
* be specified in @p chconf.h.<br>
*
* @ingroup IO
*/
/**
* @defgroup PAL I/O Ports Abstraction Layer (PAL)
* @brief I/O Ports Abstraction Layer

2
os/kernel/include/ch.h
View File

@ -20,7 +20,7 @@
/**
* @file ch.h
* @brief ChibiOS/RT main include file, it includes everything else.
* @addtogroup Kernel
* @addtogroup kernel_info
* @{
*/

2
os/kernel/include/channels.h
View File

@ -20,7 +20,7 @@
/**
* @file channels.h
* @brief I/O channels
* @addtogroup Channels
* @addtogroup io_channels
* @{
*/

2
os/kernel/include/condvars.h
View File

@ -24,7 +24,7 @@
/**
* @file condvars.h
* @brief Condition Variables macros and structures.
* @addtogroup CondVars
* @addtogroup condvars
* @{
*/

2
os/kernel/include/debug.h
View File

@ -20,7 +20,7 @@
/**
* @file debug.h
* @brief Debug macros and structures.
* @addtogroup Debug
* @addtogroup debug
* @{
*/

2
os/kernel/include/events.h
View File

@ -20,7 +20,7 @@
/**
* @file events.h
* @brief Events macros and structures.
* @addtogroup Events
* @addtogroup events
* @{
*/

2
os/kernel/include/heap.h
View File

@ -20,7 +20,7 @@
/**
* @file heap.h
* @brief Heap macros and structures.
* @addtogroup Heap
* @addtogroup heap
* @{
*/

2
os/kernel/include/inline.h
View File

@ -22,7 +22,7 @@
/**
* @file inline.h
* @brief Kernel inlined functions.
* @brief kernel inlined functions.
*/
/*

2
os/kernel/include/lists.h
View File

@ -20,7 +20,7 @@
/**
* @file lists.h
* @brief Thread queues/lists macros and structures.
* @addtogroup ThreadLists
* @addtogroup internals
* @{
*/

2
os/kernel/include/mailboxes.h
View File

@ -20,7 +20,7 @@
/**
* @file mailboxes.h
* @brief Mailboxes macros and structures.
* @addtogroup Mailboxes
* @addtogroup mailboxes
* @{
*/

2
os/kernel/include/mempools.h
View File

@ -20,7 +20,7 @@
/**
* @file mempools.h
* @brief Memory Pools macros and structures.
* @addtogroup MemoryPools
* @addtogroup pools
* @{
*/

2
os/kernel/include/messages.h
View File

@ -20,7 +20,7 @@
/**
* @file messages.h
* @brief Messages macros and structures.
* @addtogroup Messages
* @addtogroup messages
* @{
*/

2
os/kernel/include/mutexes.h
View File

@ -20,7 +20,7 @@
/**
* @file mutexes.h
* @brief Mutexes macros and structures.
* @addtogroup Mutexes
* @addtogroup mutexes
* @{
*/

2
os/kernel/include/queues.h
View File

@ -20,7 +20,7 @@
/**
* @file queues.h I/O
* @brief Queues macros and structures.
* @addtogroup IOQueues
* @addtogroup io_queues
* @{
*/

2
os/kernel/include/scheduler.h
View File

@ -20,7 +20,7 @@
/**
* @file scheduler.h
* @brief Scheduler macros and structures.
* @addtogroup Scheduler
* @addtogroup scheduler
* @{
*/

2
os/kernel/include/semaphores.h
View File

@ -20,7 +20,7 @@
/**
* @file semaphores.h
* @brief Semaphores macros and structures.
* @addtogroup Semaphores
* @addtogroup semaphores
* @{
*/

2
os/kernel/include/sys.h
View File

@ -20,7 +20,7 @@
/**
* @file sys.h
* @brief System related macros and structures.
* @addtogroup System
* @addtogroup system
* @{
*/

2
os/kernel/include/threads.h
View File

@ -20,7 +20,7 @@
/**
* @file threads.h
* @brief Threads macros and structures.
* @addtogroup Threads
* @addtogroup threads
* @{
*/

2
os/kernel/include/vt.h
View File

@ -20,7 +20,7 @@
/**
* @file vt.h
* @brief Time macros and structures.
* @addtogroup Time
* @addtogroup time
* @{
*/

2
os/kernel/src/chcond.c
View File

@ -24,7 +24,7 @@
/**
* @file chcond.c
* @brief Condition Variables code.
* @addtogroup CondVars
* @addtogroup condvars Condition Variables
* @{
*/

2
os/kernel/src/chdebug.c
View File

@ -20,7 +20,7 @@
/**
* @file chdebug.c
* @brief ChibiOS/RT Debug code.
* @addtogroup Debug
* @addtogroup debug
* @{
*/

2
os/kernel/src/chevents.c
View File

@ -20,7 +20,7 @@
/**
* @file chevents.c
* @brief Events code.
* @addtogroup Events
* @addtogroup events
* @{
*/
#include <ch.h>

2
os/kernel/src/chheap.c
View File

@ -20,7 +20,7 @@
/**
* @file chheap.c
* @brief Heap code.
* @addtogroup Heap
* @addtogroup heap
* @{
*/

2
os/kernel/src/chlists.c
View File

@ -20,7 +20,7 @@
/**
* @file chlists.c
* @brief Thread queues/lists code.
* @addtogroup ThreadLists
* @addtogroup internals
* @{
*/
#include <ch.h>

2
os/kernel/src/chmboxes.c
View File

@ -20,7 +20,7 @@
/**
* @file chmboxes.c
* @brief Mailboxes code.
* @addtogroup Mailboxes
* @addtogroup mailboxes
* @{
*/

2
os/kernel/src/chmempools.c
View File

@ -20,7 +20,7 @@
/**
* @file chmempools.c
* @brief Memory Pools code.
* @addtogroup MemoryPools
* @addtogroup pools
* @{
*/

2
os/kernel/src/chmsg.c
View File

@ -20,7 +20,7 @@
/**
* @file chmsg.c
* @brief Messages code.
* @addtogroup Messages
* @addtogroup messages
* @{
*/

2
os/kernel/src/chmtx.c
View File

@ -20,7 +20,7 @@
/**
* @file chmtx.c
* @brief Mutexes code.
* @addtogroup Mutexes
* @addtogroup mutexes
* @{
*/

2
os/kernel/src/chqueues.c
View File

@ -20,7 +20,7 @@
/**
* @file chqueues.c
* @brief I/O Queues code.
* @addtogroup IOQueues
* @addtogroup io_queues
* @{
*/

2
os/kernel/src/chschd.c
View File

@ -20,7 +20,7 @@
/**
* @file chschd.c
* @brief Scheduler code.
* @addtogroup Scheduler
* @addtogroup scheduler
* @{
*/

2
os/kernel/src/chsem.c
View File

@ -20,7 +20,7 @@
/**
* @file chsem.c
* @brief Semaphores code.
* @addtogroup Semaphores
* @addtogroup semaphores
* @{
*/

2
os/kernel/src/chsys.c
View File

@ -20,7 +20,7 @@
/**
* @file chsys.c
* @brief System related code.
* @addtogroup System
* @addtogroup system
* @{
*/

2
os/kernel/src/chthreads.c
View File

@ -20,7 +20,7 @@
/**
* @file chthreads.c
* @brief Threads code.
* @addtogroup Threads
* @addtogroup threads
* @{
*/

2
os/kernel/src/chvt.c
View File

@ -20,7 +20,7 @@
/**
* @file chvt.c
* @brief Time and Virtual Timers related code.
* @addtogroup Time
* @addtogroup time
* @{
*/

378
os/kernel/templates/chconf.h Normal file
View File

@ -0,0 +1,378 @@
/*
ChibiOS/RT - Copyright (C) 2006-2007 Giovanni Di Sirio.
This file is part of ChibiOS/RT.
ChibiOS/RT 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 3 of the License, or
(at your option) any later version.
ChibiOS/RT 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, see <http://www.gnu.org/licenses/>.
*/
/**
* @file templates/chconf.h
* @brief Configuration file template.
* @addtogroup config
* @{
*/
#ifndef _CHCONF_H_
#define _CHCONF_H_
/*===========================================================================*/
/* Kernel parameters. */
/*===========================================================================*/
/**
* Frequency of the system timer that drives the system ticks. This also
* defines the system tick time unit.
*/
#if !defined(CH_FREQUENCY) || defined(__DOXYGEN__)
#define CH_FREQUENCY 1000
#endif
/**
* This constant is the number of system ticks allowed for the threads before
* preemption occurs. This option is only meaningful if the option
* @p CH_USE_ROUNDROBIN is also active.
*/
#if !defined(CH_TIME_QUANTUM) || defined(__DOXYGEN__)
#define CH_TIME_QUANTUM 20
#endif
/**
* If enabled then the use of nested @p chSysLock() / @p chSysUnlock()
* operations is allowed.<br>
* For performance and code size reasons the recommended setting is to leave
* this option disabled.<br>
* You can use this option if you need to merge ChibiOS/RT with external
* libraries that require nested lock/unlock operations.
* @note The default is @p FALSE.
*/
#if !defined(CH_USE_NESTED_LOCKS) || defined(__DOXYGEN__)
#define CH_USE_NESTED_LOCKS FALSE
#endif
/**
* If specified then the kernel performs the round robin scheduling algorithm
* on threads of equal priority.
* @note The default is @p TRUE.
*/
#if !defined(CH_USE_ROUNDROBIN) || defined(__DOXYGEN__)
#define CH_USE_ROUNDROBIN TRUE
#endif
/**
* Number of RAM bytes to use as system heap. If set to zero then the whole
* available RAM is used as system heap.
* @note In order to use the whole RAM as system heap the linker script must
* provide the @p __heap_base__ and @p __heap_end__ symbols.
* @note Requires @p CH_USE_HEAP.
*/
#if !defined(CH_HEAP_SIZE) || defined(__DOXYGEN__)
#define CH_HEAP_SIZE 0
#endif
/*===========================================================================*/
/* Performance options. */
/*===========================================================================*/
/**
* If specified then time efficient rather than space efficient code is used
* when two possible implementations exist.
* @note This is not related to the compiler optimization options.
* @note The default is @p TRUE.
*/
#if !defined(CH_OPTIMIZE_SPEED) || defined(__DOXYGEN__)
#define CH_OPTIMIZE_SPEED TRUE
#endif
/**
* If enabled defines a CPU register to be used as storage for the global
* @p currp variable. Caching this variable in a register can greatly
* improve both space and time efficiency of the generated code. Another side
* effect is that one less register has to be saved during the context switch
* resulting in lower RAM usage and faster code.
* @note This option is only usable with the GCC compiler and is only useful
* on processors with many registers like ARM cores.
* @note If this option is enabled then ALL the libraries linked to the
* ChibiOS/RT code <b>must</b> be recompiled with the GCC option @p
* -ffixed-@<reg@>.
* @note This option must be enabled in the Makefile, it is listed here for
* documentation.
*/
#if defined(__DOXYGEN__)
#define CH_CURRP_REGISTER_CACHE "reg"
#endif
/*===========================================================================*/
/* Subsystem options. */
/*===========================================================================*/
/**
* If specified then the @p chThdWait() function is included in the kernel.
* @note The default is @p TRUE.
*/
#if !defined(CH_USE_WAITEXIT) || defined(__DOXYGEN__)
#define CH_USE_WAITEXIT TRUE
#endif
/**
* If specified then the Semaphores APIs are included in the kernel.
* @note The default is @p TRUE.
*/
#if !defined(CH_USE_SEMAPHORES) || defined(__DOXYGEN__)
#define CH_USE_SEMAPHORES TRUE
#endif
/**
* If enabled then the threads are enqueued on semaphores by priority rather
* than FIFO order.
* @note The default is @p FALSE. Enable this if you have special requirements.
* @note Requires @p CH_USE_SEMAPHORES.
*/
#if !defined(CH_USE_SEMAPHORES_PRIORITY) || defined(__DOXYGEN__)
#define CH_USE_SEMAPHORES_PRIORITY FALSE
#endif
/**
* If specified then the Semaphores the @p chSemWaitSignal() API is included
* in the kernel.
* @note The default is @p TRUE.
* @note Requires @p CH_USE_SEMAPHORES.
*/
#if !defined(CH_USE_SEMSW) || defined(__DOXYGEN__)
#define CH_USE_SEMSW TRUE
#endif
/**
* If specified then the Mutexes APIs are included in the kernel.
* @note The default is @p TRUE.
*/
#if !defined(CH_USE_MUTEXES) || defined(__DOXYGEN__)
#define CH_USE_MUTEXES TRUE
#endif
/**
* If specified then the Conditional Variables APIs are included in the kernel.
* @note The default is @p TRUE.
* @note Requires @p CH_USE_MUTEXES.
*/
#if !defined(CH_USE_CONDVARS) || defined(__DOXYGEN__)
#define CH_USE_CONDVARS TRUE
#endif
/**
* If specified then the Conditional Variables APIs are included in the kernel.
* @note The default is @p TRUE.
* @note Requires @p CH_USE_CONDVARS.
*/
#if !defined(CH_USE_CONDVARS_TIMEOUT) || defined(__DOXYGEN__)
#define CH_USE_CONDVARS_TIMEOUT TRUE
#endif
/**
* If specified then the Event flags APIs are included in the kernel.
* @note The default is @p TRUE.
*/
#if !defined(CH_USE_EVENTS) || defined(__DOXYGEN__)
#define CH_USE_EVENTS TRUE
#endif
/**
* If specified then the @p chEvtWaitXXXTimeout() functions are included in
* the kernel.
* @note The default is @p TRUE.
* @note Requires @p CH_USE_EVENTS.
*/
#if !defined(CH_USE_EVENTS_TIMEOUT) || defined(__DOXYGEN__)
#define CH_USE_EVENTS_TIMEOUT TRUE
#endif
/**
* If specified then the Synchronous Messages APIs are included in the kernel.
* @note The default is @p TRUE.
*/
#if !defined(CH_USE_MESSAGES) || defined(__DOXYGEN__)
#define CH_USE_MESSAGES TRUE
#endif
/**
* If enabled then messages are served by priority rather than in FIFO order.
* @note The default is @p FALSE. Enable this if you have special requirements.
* @note Requires @p CH_USE_MESSAGES.
*/
#if !defined(CH_USE_MESSAGES_PRIORITY) || defined(__DOXYGEN__)
#define CH_USE_MESSAGES_PRIORITY FALSE
#endif
/**
* If specified then the Asynchronous Messages (Mailboxes) APIs are included
* in the kernel.
* @note The default is @p TRUE.
* @note Requires @p CH_USE_SEMAPHORES.
*/
#if !defined(CH_USE_MAILBOXES) || defined(__DOXYGEN__)
#define CH_USE_MAILBOXES TRUE
#endif
/**
* If specified then the I/O queues APIs are included in the kernel.
* @note The default is @p TRUE.
* @note Requires @p CH_USE_SEMAPHORES.
*/
#if !defined(CH_USE_QUEUES) || defined(__DOXYGEN__)
#define CH_USE_QUEUES TRUE
#endif
/**
* If specified then the memory heap allocator APIs are included in the kernel.
* @note The default is @p TRUE.
* @note Requires @p CH_USE_MUTEXES or @p CH_USE_SEMAPHORES.
* @note Mutexes are recommended.
*/
#if !defined(CH_USE_HEAP) || defined(__DOXYGEN__)
#define CH_USE_HEAP TRUE
#endif
/**
* If enabled enforces the use of the C-runtime @p malloc() and @p free()
* functions as backend for the system heap allocator.
* @note The default is @p FALSE.
* @note Requires @p CH_USE_HEAP.
*/
#if !defined(CH_USE_MALLOC_HEAP) || defined(__DOXYGEN__)
#define CH_USE_MALLOC_HEAP FALSE
#endif
/**
* If specified then the memory pools allocator APIs are included in the
* kernel.
* @note The default is @p TRUE.
*/
#if !defined(CH_USE_MEMPOOLS) || defined(__DOXYGEN__)
#define CH_USE_MEMPOOLS TRUE
#endif
/**
* If specified then the dynamic threads creation APIs are included in the
* kernel.
* @note The default is @p TRUE.
* @note Requires @p CH_USE_WAITEXIT.
*/
#if !defined(CH_USE_DYNAMIC) || defined(__DOXYGEN__)
#define CH_USE_DYNAMIC TRUE
#endif
/*===========================================================================*/
/* Debug options. */
/*===========================================================================*/
/**
* Debug option, if enabled then the checks on the API functions input
* parameters are activated.
* @note The default is @p FALSE.
*/
#if !defined(CH_DBG_ENABLE_CHECKS) || defined(__DOXYGEN__)
#define CH_DBG_ENABLE_CHECKS FALSE
#endif
/**
* Debug option, if enabled then all the assertions in the kernel code are
* activated. This includes consistency checks inside the kernel, runtime
* anomalies and port-defined checks.
* @note The default is @p FALSE.
*/
#if !defined(CH_DBG_ENABLE_ASSERTS) || defined(__DOXYGEN__)
#define CH_DBG_ENABLE_ASSERTS FALSE
#endif
/**
* Debug option, if enabled the context switch circular trace buffer is
* activated.
* @note The default is @p FALSE.
*/
#if !defined(CH_DBG_ENABLE_TRACE) || defined(__DOXYGEN__)
#define CH_DBG_ENABLE_TRACE FALSE
#endif
/**
* Debug option, if enabled a runtime stack check is performed.
* @note The stack check is performed in a architecture/port dependent way. It
* may not be implemented at all.
*/
#if !defined(CH_DBG_ENABLE_STACK_CHECK) || defined(__DOXYGEN__)
#define CH_DBG_ENABLE_STACK_CHECK FALSE
#endif
/**
* Debug option, if enabled the threads working area is filled with a byte
* pattern when a thread is created.
*/
#if !defined(CH_DBG_FILL_THREADS) || defined(__DOXYGEN__)
#define CH_DBG_FILL_THREADS FALSE
#endif
/**
* Debug option, if enabled a field is added to the @p Thread structure that
* counts the system ticks occurred while executing the thread.
*/
#if !defined(CH_DBG_THREADS_PROFILING) || defined(__DOXYGEN__)
#define CH_DBG_THREADS_PROFILING TRUE
#endif
/*===========================================================================*/
/* Kernel hooks. */
/*===========================================================================*/
/**
* User fields added to the end of the @p Thread structure.
*/
#if !defined(THREAD_EXT_FIELDS) || defined(__DOXYGEN__)
#define THREAD_EXT_FIELDS \
struct { \
/* Add thread custom fields here.*/ \
};
#endif
/**
* User initialization code added to the @p chThdInit() API.
* @note It is invoked from within @p chThdInit().
*/
#if !defined(THREAD_EXT_INIT) || defined(__DOXYGEN__)
#define THREAD_EXT_INIT(tp) { \
/* Add thread initialization code here.*/ \
}
#endif
/**
* User finalization code added to the @p chThdExit() API.
* @note It is inserted into lock zone.
*/
#if !defined(THREAD_EXT_EXIT) || defined(__DOXYGEN__)
#define THREAD_EXT_EXIT(tp) { \
/* Add thread finalization code here.*/ \
}
#endif
/**
* Code inserted inside the idle thread loop immediately after an interrupt
* resumed execution.
*/
#if !defined(IDLE_LOOP_HOOK) || defined(__DOXYGEN__)
#define IDLE_LOOP_HOOK() { \
/* Idle loop code here.*/ \
}
#endif
#endif /* _CHCONF_H_ */
/** @} */

133
os/kernel/templates/chcore.c Normal file
View File

@ -0,0 +1,133 @@
/*
ChibiOS/RT - Copyright (C) 2006-2007 Giovanni Di Sirio.
This file is part of ChibiOS/RT.
ChibiOS/RT 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 3 of the License, or
(at your option) any later version.
ChibiOS/RT 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, see <http://www.gnu.org/licenses/>.
*/
/**
* @file templates/chcore.c
* @brief Port related template code.
* @addtogroup core
* @{
*/
#include <ch.h>
/*
* This file is a template of the system driver functions provided by a port.
* Some of the following functions may be implemented as macros in chcore.h if
* the implementer decides that there is an advantage in doing so, as example
* because performance concerns.
*/
/**
* @brief Port-related initialization code.
*
* @note This function is usually empty.
*/
void port_init(void){
}
/**
* @brief Kernel-unlock action.
* @details Usually this function just disables interrupts but may perform more
* actions.
*/
void port_lock(void) {
}
/**
* @brief Kernel-unlock action.
* @details Usually this function just disables interrupts but may perform more
* actions.
*/
void port_unlock(void) {
}
/**
* @brief Kernel-lock action from an interrupt handler.
* @details This function is invoked before invoking I-class APIs from
* interrupt handlers. The implementation is architecture dependent, in its
* simplest form it is void.
*/
void port_lock_from_isr(void) {
}
/**
* @brief Kernel-unlock action from an interrupt handler.
* @details This function is invoked after invoking I-class APIs from interrupt
* handlers. The implementation is architecture dependent, in its simplest form
* it is void.
*/
void port_unlock_from_isr(void) {
}
/**
* @brief Disables all the interrupt sources.
*
* @note Of course non maskable interrupt sources are not included.
*/
void port_disable() {
}
/**
* @brief Disables the interrupt sources that are not supposed to preempt the kernel.
*/
void port_suspend(void) {
}
/**
* @brief Enables all the interrupt sources.
*/
void port_enable(void) {
}
/**
* @brief Enters an architecture-dependent halt mode.
* @details The function is meant to return when an interrupt becomes pending.
* The simplest implementation is an empty function but this will not take
* advantage of architecture-specific power saving modes.
*/
void port_wait_for_interrupt(void) {
}
/**
* @brief Halts the system.
* @details This function is invoked by the operating system when an
* unrecoverable error is detected (as example because a programming error in
* the application code that triggers an assertion while in debug mode).
*/
void port_halt(void) {
port_disable();
while (TRUE) {
}
}
/**
* @brief Performs a context switch between two threads.
* @details This is the most critical code in any port, this function
* is responsible for the context switch between 2 threads.
*
* @param otp the thread to be switched out
* @param ntp the thread to be switched in
* @note The implementation of this code affects <b>directly</b> the context
* switch performance so optimize here as much as you can.
*/
void port_switch(Thread *otp, Thread *ntp) {
}
/** @} */

159
os/kernel/templates/chcore.h Normal file
View File

@ -0,0 +1,159 @@
/*
ChibiOS/RT - Copyright (C) 2006-2007 Giovanni Di Sirio.
This file is part of ChibiOS/RT.
ChibiOS/RT 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 3 of the License, or
(at your option) any later version.
ChibiOS/RT 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, see <http://www.gnu.org/licenses/>.
*/
/**
* @file templates/chcore.h
* @brief Port related template macros and structures.
* @addtogroup core
* @{
*/
#ifndef _CHCORE_H_
#define _CHCORE_H_
/**
* Unique macro for the implemented architecture.
*/
#define CH_ARCHITECTURE_XXX
/**
* Name of the implemented architecture.
*/
#define CH_ARCHITECTURE_NAME ""
/**
* Base type for stack alignment.
* This type is used only for stack alignment reasons thus can be anything from
* a char to a double.
*/
typedef uint8_t stkalign_t;
/**
* @brief Interrupt saved context.
* @details This structure represents the stack frame saved during a
* preemption-capable interrupt handler.
*/
struct extctx {
};
/**
* @brief System saved context.
* @details This structure represents the inner stack frame during a context
* switching.
*/
struct intctx {
};
/**
* @brief Platform dependent part of the @p Thread structure.
* @details This structure usually contains just the saved stack pointer
* defined as a pointer to a @p intctx structure.
*/
struct context {
struct intctx *sp;
};
/**
* Platform dependent part of the @p chThdInit() API.
* This code usually setup the context switching frame represented by a
* @p intctx structure.
*/
#define SETUP_CONTEXT(workspace, wsize, pf, arg) { \
}
/**
* Stack size for the system idle thread.
* This size depends on the idle thread implementation, usually the idle
* thread should take no more space than those reserved
* by @p INT_REQUIRED_STACK.
*/
#ifndef IDLE_THREAD_STACK_SIZE
#define IDLE_THREAD_STACK_SIZE 0
#endif
/**
* Per-thread stack overhead for interrupts servicing, it is used in the
* calculation of the correct working area size.
* This value can be zero on those architecture where there is a separate
* interrupt stack and the stack space between @p intctx and @p extctx is
* known to be zero.
*/
#ifndef INT_REQUIRED_STACK
#define INT_REQUIRED_STACK 0
#endif
/**
* Enforces a correct alignment for a stack area size value.
*/
#define STACK_ALIGN(n) ((((n) - 1) | (sizeof(stkalign_t) - 1)) + 1)
/**
* Computes the thread working area global size.
*/
#define THD_WA_SIZE(n) STACK_ALIGN(sizeof(Thread) + \
sizeof(struct intctx) + \
sizeof(struct extctx) + \
(n) + (INT_REQUIRED_STACK))
/**
* Macro used to allocate a thread working area aligned as both position and
* size.
*/
#define WORKING_AREA(s, n) stkalign_t s[THD_WA_SIZE(n) / sizeof(stkalign_t)];
/**
* IRQ prologue code, inserted at the start of all IRQ handlers enabled to
* invoke system APIs.
*/
#define PORT_IRQ_PROLOGUE()
/**
* IRQ epilogue code, inserted at the end of all IRQ handlers enabled to
* invoke system APIs.
*/
#define PORT_IRQ_EPILOGUE()
/**
* IRQ handler function declaration.
* @note @p id can be a function name or a vector number depending on the
* port implementation.
*/
#define PORT_IRQ_HANDLER(id) void id(void)
#ifdef __cplusplus
extern "C" {
#endif
void port_init(void);
void port_lock(void);
void port_unlock(void);
void port_lock_from_isr(void);
void port_unlock_from_isr(void);
void port_disable(void);
void port_suspend(void);
void port_enable(void);
void port_wait_for_interrupt(void);
void port_halt(void);
void port_switch(Thread *otp, Thread *ntp);
#ifdef __cplusplus
}
#endif
#endif /* _CHCORE_H_ */
/** @} */

79
os/kernel/templates/chtypes.h Normal file
View File

@ -0,0 +1,79 @@
/*
ChibiOS/RT - Copyright (C) 2006-2007 Giovanni Di Sirio.
This file is part of ChibiOS/RT.
ChibiOS/RT 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 3 of the License, or
(at your option) any later version.
ChibiOS/RT 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, see <http://www.gnu.org/licenses/>.
*/
/**
* @file templates/chtypes.h
* @brief System types template.
* @addtogroup types
* @{
*/
#ifndef _CHTYPES_H_
#define _CHTYPES_H_
#define __need_NULL
#define __need_size_t
#include <stddef.h>
#if !defined(_STDINT_H) && !defined(__STDINT_H_)
#include <stdint.h>
#endif
/** Signed boolean. */
typedef int32_t bool_t;
/** Thread mode flags, uint8_t is ok. */
typedef uint8_t tmode_t;
/** Thread state, uint8_t is ok. */
typedef uint8_t tstate_t;
/** Priority, use the fastest unsigned type. */
typedef uint32_t tprio_t;
/** Message, use signed pointer equivalent.*/
typedef int32_t msg_t;
/** Event Id, use fastest signed.*/
typedef int32_t eventid_t;
/** Event Mask, recommended fastest unsigned.*/
typedef uint32_t eventmask_t;
/** System Time, recommended fastest unsigned.*/
typedef uint32_t systime_t;
/** Counter, recommended fastest signed.*/
typedef int32_t cnt_t;
/** Inline function modifier. */
#define INLINE inline
/** Packed structure modifier (within). */
#define PACK_STRUCT_STRUCT __attribute__((packed))
/** Packed structure modifier (before). */
#define PACK_STRUCT_BEGIN
/** Packed structure modifier (after). */
#define PACK_STRUCT_END
#endif /* _CHTYPES_H_ */
/** @} */

3
test/testdyn.c
View File

@ -29,8 +29,7 @@
* APIs.
*
* <h2>Objective</h2>
* Objective of the test module is to cover 100% of the dynamic APIs code
* as a necessary step in order to assess their maturity.
* Objective of the test module is to cover 100% of the dynamic APIs code.
*
* <h2>Preconditions</h2>
* The module requires the following kernel options:

5
test/testevt.c
View File

@ -25,11 +25,10 @@
* @page test_events Events test
*
* <h2>Description</h2>
* This module implements the test sequence for the @ref Events subsystem.
* This module implements the test sequence for the @ref events subsystem.
*
* <h2>Objective</h2>
* Objective of the test module is to cover 100% of the @ref Events subsystem
* code as a necessary step in order to assess its maturity level.
* Objective of the test module is to cover 100% of the @ref events subsystem.
*
* <h2>Preconditions</h2>
* The module requires the following kernel options:

5
test/testheap.c
View File

@ -25,11 +25,10 @@
* @page test_heap Memory Heap test
*
* <h2>Description</h2>
* This module implements the test sequence for the @ref Heap subsystem.
* This module implements the test sequence for the @ref heap subsystem.
*
* <h2>Objective</h2>
* Objective of the test module is to cover 100% of the @ref Heap subsystem
* code as a necessary step in order to assess its maturity level.
* Objective of the test module is to cover 100% of the @ref heap subsystem.
*
* <h2>Preconditions</h2>
* The module requires the following kernel options:

9
test/testmbox.c
View File

@ -25,13 +25,12 @@
* @page test_mbox Mailboxes test
*
* <h2>Description</h2>
* This module implements the test sequence for the @ref Mailboxes subsystem.
* This module implements the test sequence for the @ref mailboxes subsystem.
*
* <h2>Objective</h2>
* Objective of the test module is to cover 100% of the @ref Mailboxes
* subsystem code as a necessary step in order to assess its maturity
* level.<br>
* Note that the @ref Mailboxes subsystem depends on the @ref Semaphores
* Objective of the test module is to cover 100% of the @ref mailboxes
* subsystem code.<br>
* Note that the @ref mailboxes subsystem depends on the @ref semaphores
* subsystem that has to met its testing objectives as well.
*
* <h2>Preconditions</h2>

6
test/testmsg.c
View File

@ -25,11 +25,11 @@
* @page test_msg Messages test
*
* <h2>Description</h2>
* This module implements the test sequence for the @ref Messages subsystem.
* This module implements the test sequence for the @ref messages subsystem.
*
* <h2>Objective</h2>
* Objective of the test module is to cover 100% of the @ref Messages
* subsystem code as a necessary step in order to assess its maturity level.
* Objective of the test module is to cover 100% of the @ref messages
* subsystem code.
*
* <h2>Preconditions</h2>
* The module requires the following kernel options:

7
test/testmtx.c
View File

@ -25,14 +25,13 @@
* @page test_mtx Mutexes test
*
* <h2>Description</h2>
* This module implements the test sequence for the @ref Mutexes and
* @ref CondVars subsystems.<br>
* This module implements the test sequence for the @ref mutexes and
* @ref condvars subsystems.<br>
* Tests on those subsystems are particularly critical because the system-wide
* implications of the Priority Inheritance mechanism.
*
* <h2>Objective</h2>
* Objective of the test module is to cover 100% of the subsystem code
* as a necessary step in order to assess their maturity level.
* Objective of the test module is to cover 100% of the subsystems code.
*
* <h2>Preconditions</h2>
* The module requires the following kernel options:

5
test/testpools.c
View File

@ -25,11 +25,10 @@
* @page test_pools Memory Pools test
*
* <h2>Description</h2>
* This module implements the test sequence for the @ref MemoryPools subsystem.
* This module implements the test sequence for the @ref pools subsystem.
*
* <h2>Objective</h2>
* Objective of the test module is to cover 100% of the @ref MemoryPools
* code as a necessary step in order to assess its maturity level.<br>
* Objective of the test module is to cover 100% of the @ref pools code.
*
* <h2>Preconditions</h2>
* The module requires the following kernel options:

7
test/testqueues.c
View File

@ -25,15 +25,14 @@
* @page test_queues I/O Queues test
*
* <h2>Description</h2>
* This module implements the test sequence for the @ref IOQueues subsystem.
* This module implements the test sequence for the @ref io_queues subsystem.
* The tests are performed by inserting and removing data from queues and by
* checking both the queues status and the correct sequence of the extracted
* data.
*
* <h2>Objective</h2>
* Objective of the test module is to cover 100% of the @ref IOQueues code
* as a necessary step in order to assess its maturity level.<br>
* Note that the @ref IOQueues subsystem depends on the @ref Semaphores
* Objective of the test module is to cover 100% of the @ref io_queues code.<br>
* Note that the @ref io_queues subsystem depends on the @ref semaphores
* subsystem that has to met its testing objectives as well.
*
* <h2>Preconditions</h2>

5
test/testsem.c
View File

@ -25,11 +25,10 @@
* @page test_sem Semaphores test
*
* <h2>Description</h2>
* This module implements the test sequence for the @ref Semaphores subsystem.
* This module implements the test sequence for the @ref semaphores subsystem.
*
* <h2>Objective</h2>
* Objective of the test module is to cover 100% of the @ref Semaphores
* code as a necessary step in order to assess its maturity level.<br>
* Objective of the test module is to cover 100% of the @ref semaphores code.
*
* <h2>Preconditions</h2>
* The module requires the following kernel options:

7
test/testthd.c
View File

@ -25,15 +25,14 @@
* @page test_threads Threads and Scheduler test
*
* <h2>Description</h2>
* This module implements the test sequence for the @ref Scheduler,
* @ref Threads and @ref Time subsystems.<br>
* This module implements the test sequence for the @ref scheduler,
* @ref threads and @ref time subsystems.<br>
* Note that the tests on those subsystems are formally required but most of
* their functionality is already demonstrated because the test suite itself
* depends on them, anyway double check is good.
*
* <h2>Objective</h2>
* Objective of the test module is to cover 100% of the subsystems code
* as a necessary step in order to assess their maturity level.
* Objective of the test module is to cover 100% of the subsystems code.
*
* <h2>Preconditions</h2>
* None.