trying out distortos

13 files changed, 621 insertions, 0 deletions

diff --git a/include/distortos/architecture/InterruptMaskingLock.hpp b/include/distortos/architecture/InterruptMaskingLock.hpp
new file mode 100644
index 0000000..6f8253b
--- /dev/null
+++ b/include/distortos/architecture/InterruptMaskingLock.hpp
@@ -0,0 +1,34 @@
+/**
+ * \file
+ * \brief InterruptMaskingLock class header
+ *
+ * \author Copyright (C) 2014-2015 Kamil Szczygiel http://www.distortec.com http://www.freddiechopin.info
+ *
+ * \par License
+ * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not
+ * distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef INCLUDE_DISTORTOS_ARCHITECTURE_INTERRUPTMASKINGLOCK_HPP_
+#define INCLUDE_DISTORTOS_ARCHITECTURE_INTERRUPTMASKINGLOCK_HPP_
+
+#include "distortos/architecture/InterruptMaskingUnmaskingLock.hpp"
+#include "distortos/architecture/enableInterruptMasking.hpp"
+
+namespace distortos
+{
+
+namespace architecture
+{
+
+/// InterruptMaskingLock class is a RAII wrapper for enableInterruptMasking() / restoreInterruptMasking()
+class InterruptMaskingLock : private InterruptMaskingUnmaskingLock<enableInterruptMasking>
+{
+
+};
+
+}	// namespace architecture
+
+}	// namespace distortos
+
+#endif	// INCLUDE_DISTORTOS_ARCHITECTURE_INTERRUPTMASKINGLOCK_HPP_
diff --git a/include/distortos/architecture/InterruptMaskingUnmaskingLock.hpp b/include/distortos/architecture/InterruptMaskingUnmaskingLock.hpp
new file mode 100644
index 0000000..65bd0f0
--- /dev/null
+++ b/include/distortos/architecture/InterruptMaskingUnmaskingLock.hpp
@@ -0,0 +1,73 @@
+/**
+ * \file
+ * \brief InterruptMaskingUnmaskingLock class header
+ *
+ * \author Copyright (C) 2014-2015 Kamil Szczygiel http://www.distortec.com http://www.freddiechopin.info
+ *
+ * \par License
+ * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not
+ * distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef INCLUDE_DISTORTOS_ARCHITECTURE_INTERRUPTMASKINGUNMASKINGLOCK_HPP_
+#define INCLUDE_DISTORTOS_ARCHITECTURE_INTERRUPTMASKINGUNMASKINGLOCK_HPP_
+
+#include "distortos/architecture/restoreInterruptMasking.hpp"
+
+namespace distortos
+{
+
+namespace architecture
+{
+
+/**
+ * \brief InterruptMaskingUnmaskingLock class is a RAII wrapper for interrupt mask manipulation.
+ *
+ * \tparam Function is a reference to function which modifies interrupt mask and returns InterruptMask;
+ * enableInterruptMasking() or disableInterruptMasking() should be used
+ */
+
+template<InterruptMask (& Function)()>
+class InterruptMaskingUnmaskingLock
+{
+public:
+
+	/**
+	 * \brief InterruptMaskingUnmaskingLock's constructor
+	 *
+	 * Enables/disables interrupt masking, saving current interrupt mask for use in destructor.
+	 */
+
+	InterruptMaskingUnmaskingLock() :
+			interruptMask_{Function()}
+	{
+
+	}
+
+	/**
+	 * \brief InterruptMaskingUnmaskingLock's destructor
+	 *
+	 * Restores previous interrupt masking state by restoring interrupt mask saved in constructor.
+	 */
+
+	~InterruptMaskingUnmaskingLock()
+	{
+		restoreInterruptMasking(interruptMask_);
+	}
+
+	InterruptMaskingUnmaskingLock(const InterruptMaskingUnmaskingLock&) = delete;
+	InterruptMaskingUnmaskingLock(InterruptMaskingUnmaskingLock&&) = delete;
+	InterruptMaskingUnmaskingLock& operator=(const InterruptMaskingUnmaskingLock&) = delete;
+	InterruptMaskingUnmaskingLock& operator=(InterruptMaskingUnmaskingLock&&) = delete;
+
+private:
+
+	/// interrupt mask
+	const InterruptMask interruptMask_;
+};
+
+}	// namespace architecture
+
+}	// namespace distortos
+
+#endif	// INCLUDE_DISTORTOS_ARCHITECTURE_INTERRUPTMASKINGUNMASKINGLOCK_HPP_
diff --git a/include/distortos/architecture/InterruptUnmaskingLock.hpp b/include/distortos/architecture/InterruptUnmaskingLock.hpp
new file mode 100644
index 0000000..263bbea
--- /dev/null
+++ b/include/distortos/architecture/InterruptUnmaskingLock.hpp
@@ -0,0 +1,34 @@
+/**
+ * \file
+ * \brief InterruptUnmaskingLock class header
+ *
+ * \author Copyright (C) 2014-2015 Kamil Szczygiel http://www.distortec.com http://www.freddiechopin.info
+ *
+ * \par License
+ * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not
+ * distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef INCLUDE_DISTORTOS_ARCHITECTURE_INTERRUPTUNMASKINGLOCK_HPP_
+#define INCLUDE_DISTORTOS_ARCHITECTURE_INTERRUPTUNMASKINGLOCK_HPP_
+
+#include "distortos/architecture/InterruptMaskingUnmaskingLock.hpp"
+#include "distortos/architecture/disableInterruptMasking.hpp"
+
+namespace distortos
+{
+
+namespace architecture
+{
+
+/// InterruptUnmaskingLock class is a RAII wrapper for disableInterruptMasking() / restoreInterruptMasking()
+class InterruptUnmaskingLock : private InterruptMaskingUnmaskingLock<disableInterruptMasking>
+{
+
+};
+
+}	// namespace architecture
+
+}	// namespace distortos
+
+#endif	// INCLUDE_DISTORTOS_ARCHITECTURE_INTERRUPTUNMASKINGLOCK_HPP_
diff --git a/include/distortos/architecture/Stack.hpp b/include/distortos/architecture/Stack.hpp
new file mode 100644
index 0000000..bd23452
--- /dev/null
+++ b/include/distortos/architecture/Stack.hpp
@@ -0,0 +1,122 @@
+/**
+ * \file
+ * \brief Stack class header
+ *
+ * \author Copyright (C) 2014-2016 Kamil Szczygiel http://www.distortec.com http://www.freddiechopin.info
+ *
+ * \par License
+ * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not
+ * distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef INCLUDE_DISTORTOS_ARCHITECTURE_STACK_HPP_
+#define INCLUDE_DISTORTOS_ARCHITECTURE_STACK_HPP_
+
+#include <memory>
+
+namespace distortos
+{
+
+class Thread;
+
+namespace architecture
+{
+
+/// Stack class is an abstraction of architecture's stack
+class Stack
+{
+public:
+
+	/// unique_ptr (with deleter) to storage
+	using StorageUniquePointer = std::unique_ptr<void, void(&)(void*)>;
+
+	/**
+	 * \brief Stack's constructor
+	 *
+	 * This function initializes valid architecture-specific stack in provided storage. This requires following steps:
+	 * - adjustment of storage's address to suit architecture's alignment requirements,
+	 * - adjustment of storage's size to suit architecture's divisibility requirements,
+	 * - creating hardware and software stack frame in suitable place in the stack,
+	 * - calculation of stack pointer register value.
+	 *
+	 * After this constructor completes, stack is ready for context switching.
+	 *
+	 * \param [in] storageUniquePointer is a rvalue reference to StorageUniquePointer with storage for stack (\a size
+	 * bytes long) and appropriate deleter
+	 * \param [in] size is the size of stack's storage, bytes
+	 * \param [in] thread is a reference to Thread object passed to function
+	 * \param [in] run is a reference to Thread's "run" function
+	 * \param [in] preTerminationHook is a pointer to Thread's pre-termination hook, nullptr to skip
+	 * \param [in] terminationHook is a reference to Thread's termination hook
+	 */
+
+	Stack(StorageUniquePointer&& storageUniquePointer, size_t size, Thread& thread, void (& run)(Thread&),
+			void (* preTerminationHook)(Thread&), void (& terminationHook)(Thread&));
+
+	/**
+	 * \brief Stack's constructor
+	 *
+	 * This function adopts existing valid architecture-specific stack in provided storage. No adjustments are done,
+	 * no stack frame is created and stack pointer register's value is not calculated.
+	 *
+	 * This is meant to adopt main()'s stack.
+	 *
+	 * \param [in] storage is a pointer to stack's storage
+	 * \param [in] size is the size of stack's storage, bytes
+	 */
+
+	Stack(void* storage, size_t size);
+
+	/**
+	 * \brief Stack's destructor
+	 */
+
+	~Stack();
+
+	/**
+	 * \brief Gets current value of stack pointer.
+	 *
+	 * \return current value of stack pointer
+	 */
+
+	void* getStackPointer() const
+	{
+		return stackPointer_;
+	}
+
+	/**
+	 * \brief Sets value of stack pointer.
+	 *
+	 * \param [in] stackPointer is the new value of stack pointer
+	 */
+
+	void setStackPointer(void* const stackPointer)
+	{
+		stackPointer_ = stackPointer;
+	}
+
+	Stack(const Stack&) = delete;
+	Stack(Stack&&) = default;
+	const Stack& operator=(const Stack&) = delete;
+	Stack& operator=(Stack&&) = delete;
+
+private:
+
+	/// storage for stack
+	StorageUniquePointer storageUniquePointer_;
+
+	/// adjusted address of stack's storage
+	void* const adjustedStorage_;
+
+	/// adjusted size of stack's storage
+	const size_t adjustedSize_;
+
+	/// current value of stack pointer register
+	void* stackPointer_;
+};
+
+}	// namespace architecture
+
+}	// namespace distortos
+
+#endif	// INCLUDE_DISTORTOS_ARCHITECTURE_STACK_HPP_
diff --git a/include/distortos/architecture/disableInterruptMasking.hpp b/include/distortos/architecture/disableInterruptMasking.hpp
new file mode 100644
index 0000000..d82eda1
--- /dev/null
+++ b/include/distortos/architecture/disableInterruptMasking.hpp
@@ -0,0 +1,37 @@
+/**
+ * \file
+ * \brief disableInterruptMasking() declaration
+ *
+ * \author Copyright (C) 2014-2015 Kamil Szczygiel http://www.distortec.com http://www.freddiechopin.info
+ *
+ * \par License
+ * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not
+ * distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef INCLUDE_DISTORTOS_ARCHITECTURE_DISABLEINTERRUPTMASKING_HPP_
+#define INCLUDE_DISTORTOS_ARCHITECTURE_DISABLEINTERRUPTMASKING_HPP_
+
+#include "distortos/architecture/parameters.hpp"
+
+namespace distortos
+{
+
+namespace architecture
+{
+
+/**
+ * \brief Disables interrupt masking.
+ *
+ * Enables normal-priority interrupts.
+ *
+ * \return previous value of interrupts' mask, must be used for matched restoreInterruptMasking() call
+ */
+
+InterruptMask disableInterruptMasking();
+
+}	// namespace architecture
+
+}	// namespace distortos
+
+#endif	// INCLUDE_DISTORTOS_ARCHITECTURE_DISABLEINTERRUPTMASKING_HPP_
diff --git a/include/distortos/architecture/enableInterruptMasking.hpp b/include/distortos/architecture/enableInterruptMasking.hpp
new file mode 100644
index 0000000..8fb6566
--- /dev/null
+++ b/include/distortos/architecture/enableInterruptMasking.hpp
@@ -0,0 +1,40 @@
+/**
+ * \file
+ * \brief enableInterruptMasking() declaration
+ *
+ * \author Copyright (C) 2014-2015 Kamil Szczygiel http://www.distortec.com http://www.freddiechopin.info
+ *
+ * \par License
+ * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not
+ * distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef INCLUDE_DISTORTOS_ARCHITECTURE_ENABLEINTERRUPTMASKING_HPP_
+#define INCLUDE_DISTORTOS_ARCHITECTURE_ENABLEINTERRUPTMASKING_HPP_
+
+#include "distortos/architecture/parameters.hpp"
+
+namespace distortos
+{
+
+namespace architecture
+{
+
+/**
+ * \brief Enables interrupt masking.
+ *
+ * Disables normal-priority interrupts.
+ *
+ * \note High-priority interrupts are not controlled by distortos, so they may be left enabled. Support for that feature
+ * is architecture-dependent.
+ *
+ * \return previous value of interrupts' mask, must be used for matched restoreInterruptMasking() call
+ */
+
+InterruptMask enableInterruptMasking();
+
+}	// namespace architecture
+
+}	// namespace distortos
+
+#endif	// INCLUDE_DISTORTOS_ARCHITECTURE_ENABLEINTERRUPTMASKING_HPP_
diff --git a/include/distortos/architecture/getMainStack.hpp b/include/distortos/architecture/getMainStack.hpp
new file mode 100644
index 0000000..6f75c2b
--- /dev/null
+++ b/include/distortos/architecture/getMainStack.hpp
@@ -0,0 +1,37 @@
+/**
+ * \file
+ * \brief getMainStack() declaration
+ *
+ * \author Copyright (C) 2014-2015 Kamil Szczygiel http://www.distortec.com http://www.freddiechopin.info
+ *
+ * \par License
+ * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not
+ * distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef INCLUDE_DISTORTOS_ARCHITECTURE_GETMAINSTACK_HPP_
+#define INCLUDE_DISTORTOS_ARCHITECTURE_GETMAINSTACK_HPP_
+
+#include <utility>
+
+#include <cstddef>
+
+namespace distortos
+{
+
+namespace architecture
+{
+
+/**
+ * \brief Gets the stack used to run main().
+ *
+ * \return beginning of stack and its size in bytes
+ */
+
+std::pair<void*, size_t> getMainStack();
+
+}	// namespace architecture
+
+}	// namespace distortos
+
+#endif	// INCLUDE_DISTORTOS_ARCHITECTURE_GETMAINSTACK_HPP_
diff --git a/include/distortos/architecture/initializeStack.hpp b/include/distortos/architecture/initializeStack.hpp
new file mode 100644
index 0000000..6cc73ae
--- /dev/null
+++ b/include/distortos/architecture/initializeStack.hpp
@@ -0,0 +1,50 @@
+/**
+ * \file
+ * \brief initializeStack() declaration
+ *
+ * \author Copyright (C) 2014-2016 Kamil Szczygiel http://www.distortec.com http://www.freddiechopin.info
+ *
+ * \par License
+ * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not
+ * distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef INCLUDE_DISTORTOS_ARCHITECTURE_INITIALIZESTACK_HPP_
+#define INCLUDE_DISTORTOS_ARCHITECTURE_INITIALIZESTACK_HPP_
+
+#include <cstddef>
+
+namespace distortos
+{
+
+class Thread;
+
+namespace architecture
+{
+
+/**
+ * \brief Architecture-specific stack initialization.
+ *
+ * This function fills provided buffer with hardware and software stack frame and calculates value of stack pointer
+ * register. After this function completes, stack is ready for context switching.
+ *
+ * \attention buffer and size must be properly adjusted for architecture requirements
+ *
+ * \param [in] buffer is a pointer to stack's buffer
+ * \param [in] size is the size of stack's buffer, bytes
+ * \param [in] thread is a reference to Thread object passed to function
+ * \param [in] run is a reference to Thread's "run" function
+ * \param [in] preTerminationHook is a pointer to Thread's pre-termination hook, nullptr to skip
+ * \param [in] terminationHook is a reference to Thread's termination hook
+ *
+ * \return value that can be used as thread's stack pointer, ready for context switching
+ */
+
+void* initializeStack(void* buffer, size_t size, Thread& thread, void (& run)(Thread&),
+		void (* preTerminationHook)(Thread&), void (& terminationHook)(Thread&));
+
+}	// namespace architecture
+
+}	// namespace distortos
+
+#endif	// INCLUDE_DISTORTOS_ARCHITECTURE_INITIALIZESTACK_HPP_
diff --git a/include/distortos/architecture/lowLevelInitialization.hpp b/include/distortos/architecture/lowLevelInitialization.hpp
new file mode 100644
index 0000000..4c9d3d2
--- /dev/null
+++ b/include/distortos/architecture/lowLevelInitialization.hpp
@@ -0,0 +1,34 @@
+/**
+ * \file
+ * \brief lowLevelInitialization() declaration
+ *
+ * \author Copyright (C) 2014-2015 Kamil Szczygiel http://www.distortec.com http://www.freddiechopin.info
+ *
+ * \par License
+ * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not
+ * distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef INCLUDE_DISTORTOS_ARCHITECTURE_LOWLEVELINITIALIZATION_HPP_
+#define INCLUDE_DISTORTOS_ARCHITECTURE_LOWLEVELINITIALIZATION_HPP_
+
+namespace distortos
+{
+
+namespace architecture
+{
+
+/**
+ * \brief Low level architecture initialization.
+ *
+ * This function is called before constructors for global and static objects from __libc_init_array() via address in
+ * distortosPreinitArray[].
+ */
+
+void lowLevelInitialization();
+
+}	// namespace architecture
+
+}	// namespace distortos
+
+#endif	// INCLUDE_DISTORTOS_ARCHITECTURE_LOWLEVELINITIALIZATION_HPP_
diff --git a/include/distortos/architecture/requestContextSwitch.hpp b/include/distortos/architecture/requestContextSwitch.hpp
new file mode 100644
index 0000000..bc92b6b
--- /dev/null
+++ b/include/distortos/architecture/requestContextSwitch.hpp
@@ -0,0 +1,35 @@
+/**
+ * \file
+ * \brief requestContextSwitch() declaration
+ *
+ * \author Copyright (C) 2014-2015 Kamil Szczygiel http://www.distortec.com http://www.freddiechopin.info
+ *
+ * \par License
+ * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not
+ * distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef INCLUDE_DISTORTOS_ARCHITECTURE_REQUESTCONTEXTSWITCH_HPP_
+#define INCLUDE_DISTORTOS_ARCHITECTURE_REQUESTCONTEXTSWITCH_HPP_
+
+namespace distortos
+{
+
+namespace architecture
+{
+
+/**
+ * \brief Architecture-specific request for context switch.
+ *
+ * Causes the architecture to do context save, call scheduler::getScheduler().switchContext() and do context restore.
+ * The call to scheduler::getScheduler().switchContext() must be done from the context in which such call is valid
+ * (usually system interrupt).
+ */
+
+void requestContextSwitch();
+
+}	// namespace architecture
+
+}	// namespace distortos
+
+#endif	// INCLUDE_DISTORTOS_ARCHITECTURE_REQUESTCONTEXTSWITCH_HPP_
diff --git a/include/distortos/architecture/requestFunctionExecution.hpp b/include/distortos/architecture/requestFunctionExecution.hpp
new file mode 100644
index 0000000..69c9eda
--- /dev/null
+++ b/include/distortos/architecture/requestFunctionExecution.hpp
@@ -0,0 +1,53 @@
+/**
+ * \file
+ * \brief requestFunctionExecution() declaration
+ *
+ * \author Copyright (C) 2015 Kamil Szczygiel http://www.distortec.com http://www.freddiechopin.info
+ *
+ * \par License
+ * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not
+ * distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef INCLUDE_DISTORTOS_ARCHITECTURE_REQUESTFUNCTIONEXECUTION_HPP_
+#define INCLUDE_DISTORTOS_ARCHITECTURE_REQUESTFUNCTIONEXECUTION_HPP_
+
+namespace distortos
+{
+
+namespace internal
+{
+
+class ThreadControlBlock;
+
+}	// namespace internal
+
+namespace architecture
+{
+
+/**
+ * \brief Requests execution of provided function in the specified thread.
+ *
+ * Main use case for this function is to request execution of signals delivery function. In such case it is called when
+ * an unblocked signal, which is not ignored, is generated or queued for specified thread.
+ *
+ * It must arrange for given function to be executed in specified thread as soon as possible. This generally requires
+ * dealing with following scenarios:
+ * - current thread is sending the request to itself - in that case just execute function right away;
+ * - current thread is sending the request to non-current thread;
+ * - interrupt is sending the request to current thread;
+ * - interrupt is sending the request to non-current thread;
+ *
+ * \param [in] threadControlBlock is a reference to internal::ThreadControlBlock of thread in which \a function should
+ * be executed
+ * \param [in] function is a reference to function that should be executed in thread associated with
+ * \a threadControlBlock
+ */
+
+void requestFunctionExecution(internal::ThreadControlBlock& threadControlBlock, void (& function)());
+
+}	// namespace architecture
+
+}	// namespace distortos
+
+#endif	// INCLUDE_DISTORTOS_ARCHITECTURE_REQUESTFUNCTIONEXECUTION_HPP_
diff --git a/include/distortos/architecture/restoreInterruptMasking.hpp b/include/distortos/architecture/restoreInterruptMasking.hpp
new file mode 100644
index 0000000..268159b
--- /dev/null
+++ b/include/distortos/architecture/restoreInterruptMasking.hpp
@@ -0,0 +1,39 @@
+/**
+ * \file
+ * \brief restoreInterruptMasking() declaration
+ *
+ * \author Copyright (C) 2014-2015 Kamil Szczygiel http://www.distortec.com http://www.freddiechopin.info
+ *
+ * \par License
+ * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not
+ * distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef INCLUDE_DISTORTOS_ARCHITECTURE_RESTOREINTERRUPTMASKING_HPP_
+#define INCLUDE_DISTORTOS_ARCHITECTURE_RESTOREINTERRUPTMASKING_HPP_
+
+#include "distortos/architecture/parameters.hpp"
+
+namespace distortos
+{
+
+namespace architecture
+{
+
+/**
+ * \brief Restores interrupt masking.
+ *
+ * Restores previous interrupt masking state (before matching enableInterruptMasking() or disableInterruptMasking() was
+ * called), enabling some (maybe all, maybe none) interrupts.
+ *
+ * \param [in] interruptMask is the value of interrupts' mask, must come from previous call to enableInterruptMasking()
+ * or disableInterruptMasking()
+ */
+
+void restoreInterruptMasking(InterruptMask interruptMask);
+
+}	// namespace architecture
+
+}	// namespace distortos
+
+#endif	// INCLUDE_DISTORTOS_ARCHITECTURE_RESTOREINTERRUPTMASKING_HPP_
diff --git a/include/distortos/architecture/startScheduling.hpp b/include/distortos/architecture/startScheduling.hpp
new file mode 100644
index 0000000..20db514
--- /dev/null
+++ b/include/distortos/architecture/startScheduling.hpp
@@ -0,0 +1,33 @@
+/**
+ * \file
+ * \brief startScheduling() declaration
+ *
+ * \author Copyright (C) 2014-2015 Kamil Szczygiel http://www.distortec.com http://www.freddiechopin.info
+ *
+ * \par License
+ * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not
+ * distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef INCLUDE_DISTORTOS_ARCHITECTURE_STARTSCHEDULING_HPP_
+#define INCLUDE_DISTORTOS_ARCHITECTURE_STARTSCHEDULING_HPP_
+
+namespace distortos
+{
+
+namespace architecture
+{
+
+/**
+ * \brief Architecture-specific start of scheduling.
+ *
+ * Initializes all required hardware/software to perform context switching and starts the scheduling.
+ */
+
+void startScheduling();
+
+}	// namespace architecture
+
+}	// namespace distortos
+
+#endif	// INCLUDE_DISTORTOS_ARCHITECTURE_STARTSCHEDULING_HPP_