Merge branch 'new/first-real-time-kernel/12'

prog/makefile.json

@@ -4,5 +4,9 @@
 
   "CPU-MHZ" : 180,
 
+  "TASK-COUNT" : 1,
+
+  "SERVICE-SCHEME" : "svc",
+
   "SECTION-SCHEME" : "disableInterrupt"
 }

prog/sources/reset-handler-sequential.s

@@ -4,12 +4,12 @@
 
 @----------------------------------------------------------------------------------------------------------------------*
 @                                                                                                                      *
-@                 R E S E T    H A N D L E R    ( D O U B L E    S T A C K    M O D E )                                *
+@                 R E S E T    H A N D L E R    ( D O U B L E    S T A C K    M O D E )    F O R    X T R              *
 @                                                                                                                      *
 @----------------------------------------------------------------------------------------------------------------------*
 
 @--- This is stack for background task
-   BACKGROUND.STACK.SIZE = 512
+   BACKGROUND.STACK.SIZE = 32
 
 	.section	.bss.background.task.stack, "aw", %nobits
   .align	  3   @ Stack should be aligned on a 8-byte boundary
@@ -40,14 +40,14 @@ reset.handler: @ Cortex M4 boots with interrupts enabled, in Thread mode
 @--- Software must use an ISB barrier instruction to ensure a write to the CONTROL register
 @ takes effect before the next instruction is executed.
   isb
-@---------------------------------- Run init routines, interrupt disabled
-  cpsid i              @ Disable interrupts
-  bl    start.phase2
-  cpsie i              @ Enable interrupts
-@---------------------------------- Run setup, loop
-  bl    setup.function
-background.task:
-  bl    loop.function
+@---------------------------------- Init
+  svc   #0
+@---------------------------------- This is the background task: turn off activity led
+@  Activity led is connected to PORTC:5 (#13)
+background.task: @ Only use R0, R1, R2, R3 and R12. Other registers are not preserved
+  ldr   r0, =0x400FF088  @ Address of GPIOC_PCOR control register
+  movs  r1, # (1 << 5)   @ Port D13 is PORTC:5
+  str   r1, [r0]         @ Turn off
   b     background.task
 
 @----------------------------------------------------------------------------------------------------------------------*

prog/sources/setup-loop.cpp

@@ -1,27 +0,0 @@
-#include "all-headers.h"
-
-int ultimate_answer(42);
-bool clickHappened(false);
-
-void setup (USER_MODE) {
-	// Enable interruption triggered by encoder clic
-	PORTD_PCR (0) |= PORT_PCR_IRQC (10);
-	NVIC_ENABLE_IRQ (ISRSlot::PORTD);
-}
-
-void loop (USER_MODE) {
-	assertion (ultimate_answer == 42, 101, __FILE__, __LINE__) ;
-
-	if (clickHappened) {
-		printString(MODE_ "Clic! ");
-		clickHappened = false;
-	}
-}
-
-void clicInterruptSection(SECTION_MODE) {
-	clickHappened = true;
-
-	// Acquit interruption
-	PORTD_PCR (0) |= PORT_PCR_ISF ;
-	const uint32_t x __attribute__((unused)) = PORTD_PCR (0) ;
-}

prog/sources/setup-loop.h

@@ -1,17 +0,0 @@
-#pragma once
-
-#include "software-modes.h"
-
-void setup (USER_MODE) asm ("setup.function") ;
-
-void loop (USER_MODE) asm ("loop.function") ;
-
-//$section fonction.incrementations
-
-void incrementations (USER_MODE) asm ("fonction.incrementations") ;
-
-void section_incrementations (SECTION_MODE) asm ("section.fonction.incrementations") ;
-
-//$interrupt-section PORTD
-
-void clicInterruptSection(SECTION_MODE) asm ("interrupt.section.PORTD");

prog/sources/task-list-32-tasks.cpp

@@ -0,0 +1,68 @@
+#include "all-headers.h"
+
+
+#define ENABLE_TASK_LIST_ASSERTIONS
+
+
+#ifdef ENABLE_TASK_LIST_ASSERTIONS
+  #define TASK_LIST_ASSERT_NON_NULL_POINTER(ptr) assertNonNullPointer (ptr, __FILE__, __LINE__) ;
+#else
+  #define TASK_LIST_ASSERT_NON_NULL_POINTER(ptr)
+#endif
+
+
+#ifdef ENABLE_TASK_LIST_ASSERTIONS
+  #define TASK_LIST_ASSERT(condition,value) assertion (condition, value, __FILE__, __LINE__) ;
+#else
+  #define TASK_LIST_ASSERT(condition,value)
+#endif
+
+// ENTER TASK IN LIST: inTask should be not null
+
+void TaskList::enterTask (SECTION_MODE_ TaskControlBlock * inTaskPtr) {
+	TASK_LIST_ASSERT_NON_NULL_POINTER (inTaskPtr) ;
+	const uint32_t taskIndex = indexForDescriptorTask (inTaskPtr) ;
+	TASK_LIST_ASSERT (taskIndex < TASK_COUNT, taskIndex) ;
+	const uint32_t mask = 1U << taskIndex ;
+	mList |= mask ;
+}
+
+// REMOVE FIRST TASK FROM LIST: returns nullptr if list is empty                                                      *
+
+TaskControlBlock * TaskList::removeFirstTask (IRQ_MODE) {
+	TaskControlBlock * taskPtr = nullptr ;
+	if (mList != 0) {
+		const uint32_t taskIndex = (uint32_t) __builtin_ctz (mList) ;
+		TASK_LIST_ASSERT (taskIndex < TASK_COUNT, taskIndex) ;
+		const uint32_t mask = 1U << taskIndex ;
+		mList &= ~ mask ;
+		taskPtr = descriptorPointerForTaskIndex (taskIndex) ;
+	}
+	return taskPtr ;
+}
+
+// REMOVE A TASK FROM LIST
+
+void TaskList::removeTask (SECTION_MODE_ TaskControlBlock * inTaskPtr) {
+	TASK_LIST_ASSERT_NON_NULL_POINTER (inTaskPtr) ;
+	const uint32_t taskIndex = indexForDescriptorTask (inTaskPtr) ;
+	TASK_LIST_ASSERT (taskIndex < TASK_COUNT, taskIndex) ;
+	const uint32_t mask = 1U << taskIndex ;
+	mList &= ~ mask ;
+}
+
+// REMOVE FIRST TASK FROM LIST: returns nullptr if list is empty                                                      *
+
+TaskControlBlock * TaskList::Iterator::nextTask (IRQ_MODE) {
+	TaskControlBlock * taskPtr = nullptr ;
+	if (mIteratedList != 0) {
+		const uint32_t taskIndex = (uint32_t) __builtin_ctz (mIteratedList) ;
+		TASK_LIST_ASSERT (taskIndex < TASK_COUNT, taskIndex) ;
+		const uint32_t mask = 1U << taskIndex ;
+		mIteratedList &= ~ mask ;
+		taskPtr = descriptorPointerForTaskIndex (taskIndex) ;
+	}
+	return taskPtr ;
+}
+
+

prog/sources/task-list-32-tasks.h

@@ -0,0 +1,46 @@
+#pragma once
+
+
+#include "software-modes.h"
+
+
+struct TaskControlBlock ;
+
+// TASK LIST                                                                                                          *
+
+class TaskList {
+	// Default constructor
+	public: inline TaskList (void) : mList (0) {}
+
+	// Block a task in list
+	public: void enterTask (SECTION_MODE_ TaskControlBlock * inTaskPtr) ;
+
+	// Remove first task (returns nullptr if list is empty)
+	public: TaskControlBlock * removeFirstTask (IRQ_MODE) ;
+
+	// Remove a task from list
+	public: void removeTask (SECTION_MODE_ TaskControlBlock * inTaskPtr) ;
+
+	// Private property
+	private: uint32_t mList ;
+
+	// No copy
+	private: TaskList (const TaskList &) = delete ;
+	private: TaskList & operator = (const TaskList &) = delete ;
+
+	// Iterator
+	public: class Iterator {
+			public: inline Iterator (IRQ_MODE_ const TaskList & inTaskList) :
+				mIteratedList (inTaskList.mList) {
+				}
+
+			public: TaskControlBlock * nextTask (IRQ_MODE) ;
+
+			// Private property
+			private: uint32_t mIteratedList ;
+
+			// No copy
+			private: Iterator (const Iterator &) = delete ;
+			private: Iterator & operator = (const Iterator &) = delete ;
+		} ;
+} ;

prog/sources/user-tasks.cpp

@@ -0,0 +1,28 @@
+#include "all-headers.h"
+
+static uint64_t gStack1 [64] ;
+
+
+static uint32_t gDisplayTime = 0 ;
+
+static void task1 (USER_MODE) {
+	while (1) {
+		if (gDisplayTime <= millis (MODE)) {
+			const uint32_t s = systick (MODE) ;
+			gotoLineColumn (MODE_ 1, 0) ;
+			printUnsigned (MODE_ s) ;
+			gotoLineColumn (MODE_ 2, 0) ;
+			printUnsigned (MODE_ millis (MODE)) ;
+			gotoLineColumn (MODE_ 3, 0) ;
+			printUnsigned64 (MODE_ micros (MODE)) ;
+			gDisplayTime += 1000 ;
+		}
+	}
+}
+
+
+static void initTasks (INIT_MODE) {
+	kernel_createTask (MODE_ gStack1, sizeof (gStack1), task1) ;
+}
+
+MACRO_INIT_ROUTINE (initTasks) ;

prog/sources/xtr.cpp

@@ -0,0 +1,196 @@
+#include "all-headers.h"
+
+
+#define ENABLE_XTR_ASSERTIONS
+
+
+#ifdef ENABLE_XTR_ASSERTIONS
+  #define XTR_ASSERT_NON_NULL_POINTER(ptr) assertNonNullPointer (ptr, __FILE__, __LINE__) ;
+#else
+  #define XTR_ASSERT_NON_NULL_POINTER(ptr)
+#endif
+
+
+#ifdef ENABLE_XTR_ASSERTIONS
+  #define XTR_ASSERT(condition,value) assertion (condition, value, __FILE__, __LINE__) ;
+#else
+  #define XTR_ASSERT(condition,value)
+#endif
+
+// CORTEX-M4 EXCEPTION FRAME (WITHOUT FLOATING-POINT STORAGE)                                                          *
+//                                                                                                                     *
+//         PSP+32 -> |                            |                                                                    *
+//                   |----------------------------| \                                                                  *
+//         PSP+28 -> | xPSR                       |  |                                                                 *
+//                   |----------------------------|  |                                                                 *
+//         PSP+24 -> | PC (after SVC instruction) |  |                                                                 *
+//                   |----------------------------|  |                                                                 *
+//         PSP+20 -> | LR                         |  |                                                                 *
+//                   |----------------------------|  |                                                                 *
+//         PSP+16 -> | R12                        |  |  Saved by interrupt response                                    *
+//                   |----------------------------|  |                                                                 *
+//         PSP+12 -> | R3                         |  |                                                                 *
+//                   |----------------------------|  |                                                                 *
+//         PSP+8  -> | R2                         |  |                                                                 *
+//                   |----------------------------|  |                                                                 *
+//         PSP+4  -> | R1                         |  |                                                                 *
+//                   |----------------------------|  |                                                                 *
+//   /---- PSP ----> | R0                         |  |                                                                 *
+//   |               |----------------------------| /                                                                  *
+//   |                                                                                                                 *
+//   |                                               *---------------------*
+//   |                                               | LR return code      | +36 [ 9]
+//   |                                               *---------------------*
+//   \-----------------------------------------------| R13 (PSP)           | +32 [ 8]
+//                                                   *---------------------*
+//                                                   | R11                 | +28 [ 7]
+//                                                   *---------------------*
+//                                                   | R10                 | +24 [ 6]
+//                                                   *---------------------*
+//                                                   | R9                  | +20 [ 5]
+//                                                   *---------------------*
+//                                                   | R8                  | +16 [ 4]
+//                                                   *---------------------*
+//                                                   | R7                  | +12 [ 3]
+//                                                   *---------------------*
+//                                                   | R6                  | + 8 [ 2]
+//                                                   *---------------------*
+//                                                   | R5                  | + 4 [ 1]
+//  *---------------------------------------*        *---------------------*
+//  | var.running.task.control.block.ptr    +------> | R4                  | + 0 [ 0]
+//  *---------------------------------------*        *---------------------*
+//
+//----------------------------------------------------------------------------------------------------------------------
+
+typedef struct {
+	uint32_t mR0 ;
+	uint32_t mR1 ;
+	uint32_t mR2 ;
+	uint32_t mR3 ;
+	uint32_t mR12 ;
+	uint32_t mLR ;
+	uint32_t mPC ;
+	uint32_t mXPSR ;
+} ExceptionFrame_without_floatingPointStorage ;
+
+typedef struct {
+	uint32_t mR4 ;
+	uint32_t mR5 ;
+	uint32_t mR6 ;
+	uint32_t mR7 ;
+	uint32_t mR8 ;
+	uint32_t mR9 ;
+	uint32_t mR10 ;
+	uint32_t mR11 ;
+	ExceptionFrame_without_floatingPointStorage * mPSP ; // R13
+	uint32_t mLR_RETURN_CODE ;
+} TaskContext ;
+
+
+static void kernel_set_task_context (INIT_MODE_
+		TaskContext & ioTaskContext,
+		const uint32_t inStackBufferAddress,
+		const uint32_t inStackBufferSize,
+		RoutineTaskType inTaskRoutine) {
+
+	// Initialize LR
+	ioTaskContext.mLR_RETURN_CODE = 0xFFFFFFFD ;
+
+	// Stack Pointer initial value
+	uint32_t initialTopOfStack = inStackBufferAddress + inStackBufferSize ;
+	initialTopOfStack -= sizeof (ExceptionFrame_without_floatingPointStorage) ;
+
+	// Initialize SP
+	auto ptr = (ExceptionFrame_without_floatingPointStorage *) initialTopOfStack ;
+	ioTaskContext.mPSP = ptr ;
+
+	// Initialize PC
+	ptr->mPC = (uint32_t) inTaskRoutine ;
+
+	// Initialize CPSR
+	ptr->mXPSR = 1 << 24 ; // Thumb bit
+}
+
+// T A S K    C O N T R O L    B L O C K                                                                             *
+
+typedef struct TaskControlBlock {
+
+	// Context buffer
+	TaskContext mTaskContext ; // SHOULD BE THE FIRST FIELD
+
+	// Task index
+	uint8_t mTaskIndex ;
+} TaskControlBlock ;
+
+
+static TaskControlBlock gTaskDescriptorArray [TASK_COUNT] ;
+
+
+TaskControlBlock * descriptorPointerForTaskIndex (const uint8_t inTaskIndex) {
+	XTR_ASSERT (inTaskIndex < TASK_COUNT, inTaskIndex) ;
+	return & gTaskDescriptorArray [inTaskIndex] ;
+}
+
+
+uint8_t indexForDescriptorTask (const TaskControlBlock * inTaskPtr) { // should be not nullptr
+	XTR_ASSERT_NON_NULL_POINTER (inTaskPtr) ;
+	return inTaskPtr->mTaskIndex ;
+}
+
+// RUNNING TASK DESCRIPTOR POINTER
+
+TaskControlBlock * gRunningTaskControlBlockPtr asm ("var.running.task.control.block.ptr") ; // Shared with assembly code
+
+// SCHEDULER
+
+static TaskList gReadyTaskList ;
+
+
+static void kernel_makeTaskReady (IRQ_MODE_ TaskControlBlock * inTaskPtr) {
+	XTR_ASSERT_NON_NULL_POINTER (inTaskPtr) ;
+	gReadyTaskList.enterTask (MODE_ inTaskPtr) ;
+}
+
+
+void kernelSelectTaskToRun (IRQ_MODE) asm ("kernel.select.task.to.run") ; // Invoked from assembly
+
+void kernelSelectTaskToRun (IRQ_MODE) {
+	if (gRunningTaskControlBlockPtr != nullptr) {
+		gReadyTaskList.enterTask (MODE_ gRunningTaskControlBlockPtr) ;
+	}
+	gRunningTaskControlBlockPtr = gReadyTaskList.removeFirstTask (MODE) ;
+}
+
+// kernel_createTask
+
+static uint8_t gTaskIndex ;
+
+
+void kernel_createTask (INIT_MODE_
+		uint64_t * inStackBufferAddress,
+		uint32_t inStackBufferSize,
+		RoutineTaskType inTaskRoutine) {
+	XTR_ASSERT (gTaskIndex < TASK_COUNT, gTaskIndex) ;
+	TaskControlBlock * taskControlBlockPtr = & gTaskDescriptorArray [gTaskIndex] ;
+	taskControlBlockPtr->mTaskIndex = gTaskIndex ;
+
+	// Initialize properties
+	// As gTaskDescriptorArray is in bss, all properties are by default initialized to binary 0
+	// taskControlBlockPtr->mDeadline = 0 ; // statically initialized to 0
+	// taskControlBlockPtr->mUserResult = false ; // statically initialized to false
+	// taskControlBlockPtr->mGuardState = GUARD_EVALUATING_OR_OUTSIDE ; // statically initialized to GUARD_EVALUATING_OR_OUTSIDE
+	// taskControlBlockPtr->mGuardDescriptor.mCount = 0 ; // statically initialized to 0
+
+	// Initialize Context
+	kernel_set_task_context (MODE_
+			taskControlBlockPtr->mTaskContext,
+			(uint32_t) inStackBufferAddress,
+			inStackBufferSize,
+			inTaskRoutine) ;
+
+	// Make task ready
+	kernel_makeTaskReady (MODE_ taskControlBlockPtr) ;
+	gTaskIndex += 1 ;
+}
+
+

prog/sources/xtr.h

@@ -0,0 +1,24 @@
+#pragma once
+
+
+#include "software-modes.h"
+
+// Task routine type
+
+typedef void (* RoutineTaskType) (USER_MODE) ;
+
+// kernel_createTask
+
+void kernel_createTask (INIT_MODE_
+                        uint64_t * inStackBufferAddress,
+                        uint32_t inStackBufferSize,
+                        RoutineTaskType inTaskRoutine) ;
+
+
+struct TaskControlBlock ;
+
+TaskControlBlock * descriptorPointerForTaskIndex (const uint8_t inTaskIndex) ;
+
+uint8_t indexForDescriptorTask (const TaskControlBlock * inTaskPtr) ; // should be not nullptr
+
+