\r
#define GET_CONTROLLER_CNT() (CAN_CONTROLLER_CNT)\r
\r
-\r
-#define _INSTALL_HANDLER(_can_entry, _unique, _vector,_priority,_core) \\r
+#if 0\r
+#define _INSTALL_HANDLER(_can_entry, _unique, _vector,_priority,_app ) \\r
do { \\r
const OsIsrConstType _can_entry ## _unique = { \\r
.vector = _vector, \\r
.type = ISR_TYPE_2, \\r
.priority = _priority, \\r
.entry = _can_entry, \\r
- .core = _core, \\r
.name = "Can", \\r
.resourceMask = 0, \\r
- .appOwner = 0, \\r
+ .timingProtPtr = NULL, \\r
+ .appOwner = _app, \\r
}; \\r
Os_IsrAdd( & _can_entry ## _unique); \\r
} while(0);\r
+#endif\r
\r
+#define INSTALL_HANDLER4(_name,_can_entry, _vector,_priority,_app)\\r
+ ISR_INSTALL_ISR2(_name,_can_entry, _vector+0,_priority,_app) \\r
+ ISR_INSTALL_ISR2(_name,_can_entry, _vector+1,_priority,_app) \\r
+ ISR_INSTALL_ISR2(_name,_can_entry, _vector+2,_priority,_app) \\r
+ ISR_INSTALL_ISR2(_name,_can_entry, _vector+3,_priority,_app)\r
\r
-\r
-#define INSTALL_HANDLER(_can_entry, _vector,_priority,_core) \\r
- _INSTALL_HANDLER(_can_entry, __LINE__, _vector,_priority,_core) \\r
-\r
-#define INSTALL_HANDLER4(_can_entry, _vector,_priority,_core)\\r
- INSTALL_HANDLER(_can_entry, _vector+0,_priority,_core) \\r
- INSTALL_HANDLER(_can_entry, _vector+1,_priority,_core) \\r
- INSTALL_HANDLER(_can_entry, _vector+2,_priority,_core) \\r
- INSTALL_HANDLER(_can_entry, _vector+3,_priority,_core)\r
-\r
-#define INSTALL_HANDLER16(_can_entry, _vector,_priority,_core)\\r
- INSTALL_HANDLER4(_can_entry, _vector+0,_priority,_core) \\r
- INSTALL_HANDLER4(_can_entry, _vector+4,_priority,_core) \\r
- INSTALL_HANDLER4(_can_entry, _vector+8,_priority,_core) \\r
- INSTALL_HANDLER4(_can_entry, _vector+12,_priority,_core)\r
+#define INSTALL_HANDLER16(_name,_can_entry, _vector,_priority,_app)\\r
+ INSTALL_HANDLER4(_name,_can_entry, _vector+0,_priority,_app) \\r
+ INSTALL_HANDLER4(_name,_can_entry, _vector+4,_priority,_app) \\r
+ INSTALL_HANDLER4(_name,_can_entry, _vector+8,_priority,_app) \\r
+ INSTALL_HANDLER4(_name,_can_entry, _vector+12,_priority,_app)\r
\r
\r
//-------------------------------------------------------------------\r
// in configuration\r
switch( canHwConfig->CanControllerId ) {\r
case CAN_CTRL_A:\r
- INSTALL_HANDLER( Can_A_BusOff, FLEXCAN_A_ESR_BOFF_INT, 2, CPU_CORE0 );\r
- INSTALL_HANDLER( Can_A_Err, FLEXCAN_A_ESR_ERR_INT, 2, CPU_CORE0 );\r
- INSTALL_HANDLER16( Can_A_Isr, FLEXCAN_A_IFLAG1_BUF0I, 2, CPU_CORE0 );\r
- INSTALL_HANDLER( Can_A_Isr, FLEXCAN_A_IFLAG1_BUF31_16I, 2, CPU_CORE0 );\r
+ ISR_INSTALL_ISR2( "Can", Can_A_BusOff, FLEXCAN_A_ESR_BOFF_INT, 2, 0);\r
+ ISR_INSTALL_ISR2( "Can", Can_A_Err, FLEXCAN_A_ESR_ERR_INT, 2, 0 );\r
+ INSTALL_HANDLER16( "Can", Can_A_Isr, FLEXCAN_A_IFLAG1_BUF0I, 2, 0 );\r
+ ISR_INSTALL_ISR2( "Can", Can_A_Isr, FLEXCAN_A_IFLAG1_BUF31_16I, 2, 0 );\r
break;\r
case CAN_CTRL_B:\r
- INSTALL_HANDLER( Can_B_BusOff, FLEXCAN_B_ESR_BOFF_INT, 2, CPU_CORE0 );\r
- INSTALL_HANDLER( Can_B_Err, FLEXCAN_B_ESR_ERR_INT, 2, CPU_CORE0 );\r
- INSTALL_HANDLER16( Can_B_Isr, FLEXCAN_B_IFLAG1_BUF0I, 2, CPU_CORE0 );\r
- INSTALL_HANDLER( Can_B_Isr, FLEXCAN_B_IFLAG1_BUF31_16I, 2, CPU_CORE0 );\r
+ ISR_INSTALL_ISR2( "Can", Can_B_BusOff, FLEXCAN_B_ESR_BOFF_INT, 2, 0 );\r
+ ISR_INSTALL_ISR2( "Can", Can_B_Err, FLEXCAN_B_ESR_ERR_INT, 2, 0 );\r
+ INSTALL_HANDLER16( "Can", Can_B_Isr, FLEXCAN_B_IFLAG1_BUF0I, 2, 0 );\r
+ ISR_INSTALL_ISR2( "Can", Can_B_Isr, FLEXCAN_B_IFLAG1_BUF31_16I, 2, 0 );\r
break;\r
case CAN_CTRL_C:\r
- INSTALL_HANDLER( Can_C_BusOff, FLEXCAN_C_ESR_BOFF_INT, 2, CPU_CORE0 );\r
- INSTALL_HANDLER( Can_C_Err, FLEXCAN_C_ESR_ERR_INT, 2, CPU_CORE0 );\r
- INSTALL_HANDLER16( Can_C_Isr, FLEXCAN_C_IFLAG1_BUF0I, 2, CPU_CORE0 );\r
- INSTALL_HANDLER( Can_C_Isr, FLEXCAN_C_IFLAG1_BUF31_16I, 2, CPU_CORE0 );\r
+ ISR_INSTALL_ISR2( "Can", Can_C_BusOff, FLEXCAN_C_ESR_BOFF_INT, 2, 0 );\r
+ ISR_INSTALL_ISR2( "Can", Can_C_Err, FLEXCAN_C_ESR_ERR_INT, 2, 0 );\r
+ INSTALL_HANDLER16( "Can", Can_C_Isr, FLEXCAN_C_IFLAG1_BUF0I, 2, 0 );\r
+ ISR_INSTALL_ISR2( "Can", Can_C_Isr, FLEXCAN_C_IFLAG1_BUF31_16I, 2, 0 );\r
break;\r
case CAN_CTRL_D:\r
- INSTALL_HANDLER( Can_D_BusOff, FLEXCAN_D_ESR_BOFF_INT, 2, CPU_CORE0 );\r
- INSTALL_HANDLER( Can_D_Err, FLEXCAN_D_ESR_ERR_INT, 2, CPU_CORE0 );\r
- INSTALL_HANDLER16( Can_D_Isr, FLEXCAN_D_IFLAG1_BUF0I, 2, CPU_CORE0 );\r
- INSTALL_HANDLER( Can_D_Isr, FLEXCAN_D_IFLAG1_BUF31_16I, 2, CPU_CORE0 );\r
+ ISR_INSTALL_ISR2( "Can", Can_D_BusOff, FLEXCAN_D_ESR_BOFF_INT, 2, 0 );\r
+ ISR_INSTALL_ISR2( "Can", Can_D_Err, FLEXCAN_D_ESR_ERR_INT, 2, 0 );\r
+ INSTALL_HANDLER16( "Can", Can_D_Isr, FLEXCAN_D_IFLAG1_BUF0I, 2, 0 );\r
+ ISR_INSTALL_ISR2( "Can", Can_D_Isr, FLEXCAN_D_IFLAG1_BUF31_16I, 2, 0 );\r
break;\r
case CAN_CTRL_E:\r
- INSTALL_HANDLER( Can_E_BusOff, FLEXCAN_E_ESR_BOFF_INT, 2, CPU_CORE0 );\r
- INSTALL_HANDLER( Can_E_Err, FLEXCAN_E_ESR_ERR_INT, 2, CPU_CORE0 );\r
- INSTALL_HANDLER16( Can_E_Isr, FLEXCAN_E_IFLAG1_BUF0I, 2, CPU_CORE0 );\r
- INSTALL_HANDLER( Can_E_Isr, FLEXCAN_E_IFLAG1_BUF31_16I, 2, CPU_CORE0 );\r
+ ISR_INSTALL_ISR2( "Can", Can_E_BusOff, FLEXCAN_E_ESR_BOFF_INT, 2, 0 );\r
+ ISR_INSTALL_ISR2( "Can", Can_E_Err, FLEXCAN_E_ESR_ERR_INT, 2, 0 );\r
+ INSTALL_HANDLER16( "Can", Can_E_Isr, FLEXCAN_E_IFLAG1_BUF0I, 2, 0 );\r
+ ISR_INSTALL_ISR2( "Can", Can_E_Isr, FLEXCAN_E_IFLAG1_BUF31_16I, 2, 0 );\r
break;\r
#if defined(CFG_MPC5516) || defined(CFG_MPC5517)\r
case CAN_CTRL_F:\r
- INSTALL_HANDLER( Can_F_BusOff, FLEXCAN_F_ESR_BOFF_INT, 2, CPU_CORE0 );\r
- INSTALL_HANDLER( Can_F_Err, FLEXCAN_F_ESR_ERR_INT, 2, CPU_CORE0 );\r
- INSTALL_HANDLER16( Can_F_Isr, FLEXCAN_F_IFLAG1_BUF0I, 2, CPU_CORE0 );\r
- INSTALL_HANDLER( Can_F_Isr, FLEXCAN_F_IFLAG1_BUF31_16I, 2, CPU_CORE0 );\r
+ ISR_INSTALL_ISR2( "Can", Can_F_BusOff, FLEXCAN_F_ESR_BOFF_INT, 2, 0 );\r
+ ISR_INSTALL_ISR2( "Can", Can_F_Err, FLEXCAN_F_ESR_ERR_INT, 2, 0 );\r
+ INSTALL_HANDLER16( "Can", Can_F_Isr, FLEXCAN_F_IFLAG1_BUF0I, 2, 0 );\r
+ ISR_INSTALL_ISR2( "Can", Can_F_Isr, FLEXCAN_F_IFLAG1_BUF31_16I, 2, 0 );\r
break;\r
#endif\r
default:\r
#else\r
// TODO: This really depends on if scheduling policy\r
Irq_Enable();\r
- os_sys.curr_pcb->entry();\r
+ Os_Sys.currTaskPtr->constPtr->entry();\r
+ //os_sys.curr_pcb->entry();\r
#endif\r
}\r
\r
*\r
* @param pcb Pointer to the pcb to setup\r
*/\r
-void Os_ArchSetupContext( OsPcbType *pcbPtr ) {\r
+void Os_ArchSetupContext( OsTaskVarType *pcbPtr ) {\r
Os_FuncFrameType *cPtr = (Os_FuncFrameType *)pcbPtr->stack.curr;\r
uint32_t msr;\r
msr = MSR_EE;\r
msr |= MSR_SPE;\r
#endif\r
\r
-#if ( OS_SC3 == STD_ON) || ( OS_SC4== STD_ON)\r
+#if (OS_USE_APPLICATIONS == STD_ON)\r
+#if 0\r
if( !pcb->application->trusted ) {\r
// Non-trusted = User mode..\r
msr |= MSR_PR | MSR_DS | MSR_IS;\r
}\r
+#endif\r
#endif\r
pcbPtr->regs[0] = msr;\r
\r
* @param pcbPtr\r
*/\r
\r
-void Os_ArchSetTaskEntry(OsPcbType *pcbPtr ) {\r
+void Os_ArchSetTaskEntry(OsTaskVarType *pcbPtr ) {\r
Os_FuncFrameType *cPtr = (Os_FuncFrameType *)pcbPtr->stack.curr;\r
\r
- if( pcbPtr->proc_type == PROC_EXTENDED ) {\r
+ if( pcbPtr->constPtr->proc_type == PROC_EXTENDED ) {\r
cPtr->lr = (uint32_t)Os_TaskStartExtended;\r
- } else if( pcbPtr->proc_type == PROC_BASIC ) {\r
+ } else if( pcbPtr->constPtr->proc_type == PROC_BASIC ) {\r
cPtr->lr = (uint32_t)Os_TaskStartBasic;\r
}\r
\r
// #include "asm_book_e.h"\r
.extern os_intc_pcb_tbl\r
.extern os_intc_types_tbl\r
-.extern os_sys\r
+.extern Os_Sys\r
.extern Os_ArchPanic\r
\r
#if defined(CFG_VLE)\r
\r
/* ----------------------------[private define]------------------------------*/\r
\r
+//#define OLD_CALL \r
+\r
#define INTC_IACKR_PRC0 0xfff48010 \r
#define INTC_EOIR_PRC0 0xfff48018\r
#define INTC_IACKR 0xfff48010\r
lwz sp,PCB_STACK_CURR_P(r4)\r
\r
/* Set new current task */\r
- LOAD_ADDR_32(3,os_sys)\r
+ LOAD_ADDR_32(3,Os_Sys)\r
stw r4,SYS_CURR_PCB_P(r3)\r
\r
/* Restore C context */\r
mr r4,sp \r
\r
/* Switch to interrupt stack if at depth 0 */\r
- /* Load the value os_sys.int_nest_cnt */\r
- LOAD_IND_32(r3,os_sys+SYS_INT_NEST_CNT)\r
+ /* Load the value Os_Sys.int_nest_cnt */\r
+ LOAD_IND_32(r3,Os_Sys+SYS_INT_NEST_CNT)\r
cmpli 0,r3,0\r
bne- on_int_stack\r
\r
/* Load the interrupt stack */\r
- LOAD_IND_32(r3,os_sys+SYS_INT_STACK)\r
+ LOAD_IND_32(r1,Os_Sys+SYS_INT_STACK)\r
\r
on_int_stack:\r
\r
ori r3, r3,Os_Isr@l\r
mtlr r3\r
mr r3,r4 /* "old" stack as arg1 */\r
+#if defined(OLD_CALL) \r
lwz r4, 0x0(r6) /* Read the address from the for function/pcb entry */\r
+#else\r
+ mr r4,r5\r
+#endif \r
blrl /* Call the entry */\r
\r
/* Notes!\r
/* ----------------------------[includes]------------------------------------*/\r
\r
#include "internal.h"\r
-#include "asm_book_e.h"\r
#include "irq_types.h"\r
#include "mpc55xx.h"\r
#include "pcb.h"\r
#include "hooks.h"\r
#include "debug.h"\r
#include "isr.h"\r
-#include "irq_config.h"\r
#include <stdint.h>\r
\r
/* ----------------------------[private define]------------------------------*/\r
\r
void Irq_EOI( void ) {\r
#if defined(CFG_MPC5516)\r
- struct INTC_tag *intc = &INTC;\r
+ volatile struct INTC_tag *intc = &INTC;\r
intc->EOIR_PRC0.R = 0;\r
#elif defined(CFG_MPC5554)||defined(CFG_MPC5567)\r
volatile struct INTC_tag *intc = &INTC;\r
#endif\r
}\r
\r
-\r
+#if 0\r
/**\r
*\r
* @param stack_p Ptr to the current stack.\r
return Os_Isr(stack, vector);\r
}\r
}\r
+#endif\r
+\r
\r
static inline int osPrioToCpuPio( uint8_t prio ) {\r
assert(prio<32);\r
\r
#if ( DET_USE_RAMLOG == STD_ON )\r
\r
-#pragma section RW ".ramlog" ".ramlog"\r
-\r
// Ram log variables in uninitialized memory\r
SECTION_RAMLOG uint32 Det_RamlogIndex;\r
/*lint -esym(552,Det_RamLog)*/ /* PC-Lint OK. supress lintwarning about Det_Ramlog not being accessed */\r
#define CC_EXTENSION\r
#endif\r
\r
+#if defined(__GNUC__)\r
+#define SECTION_BALIGN(_align ) __attribute__ ((aligned (_align)));\r
+#else\r
+#error SECTION_BALIGN not defined for compiler\r
+#endif\r
+\r
+\r
/* REQ:COMPILER005 */\r
/* TODO: skip the memclass for now */\r
#define FUNC(rettype,memclass) rettype\r
void InitOS( void );\r
void StartOS( AppModeType Mode );\r
\r
-\r
-\r
ISRType GetISRID( void );\r
StatusType GetActiveApplicationMode( AppModeType* mode);\r
\r
TickType Os_SysTickGetValue( void );\r
TickType Os_SysTickGetElapsedValue( TickType preValue );\r
\r
+#if defined(USE_KERNEL_EXTRA)\r
+StatusType Sleep( TickType ticks );\r
+#endif\r
+\r
+\r
/*-------------------------------------------------------------------\r
* Schedule Tables\r
*-----------------------------------------------------------------*/\r
#define ISR_TYPE_2 1\r
\r
/* ----------------------------[macro]---------------------------------------*/\r
+#define ISR_DECLARE_ISR2(_name, _entry, _unique, _vector,_priority,_app ) \\r
+ const OsIsrConstType _entry ## _unique = { \\r
+ .vector = _vector, \\r
+ .type = ISR_TYPE_2, \\r
+ .priority = _priority, \\r
+ .entry = _entry, \\r
+ .name = _name, \\r
+ .resourceMask = 0, \\r
+ .timingProtPtr = NULL, \\r
+ .appOwner = _app, \\r
+ }; \\r
+\r
+#define _ISR_INSTALL_ISR2(_name, _entry, _unique, _vector,_priority,_app ) \\r
+ do { \\r
+ const OsIsrConstType _entry ## _unique = { \\r
+ .vector = _vector, \\r
+ .type = ISR_TYPE_2, \\r
+ .priority = _priority, \\r
+ .entry = _entry, \\r
+ .name = _name, \\r
+ .resourceMask = 0, \\r
+ .timingProtPtr = NULL, \\r
+ .appOwner = _app, \\r
+ }; \\r
+ Os_IsrAdd( & _entry ## _unique); \\r
+ } while(0);\r
+\r
+#define ISR_INSTALL_ISR2(_name,_entry, _vector,_priority,_app) \\r
+ _ISR_INSTALL_ISR2(_name,_entry, __LINE__, _vector,_priority,_app)\r
+\r
+\r
/* ----------------------------[typedef]-------------------------------------*/\r
\r
\r
+\r
+/* STD container : OsIsrResourceLock\r
+ * Class: 2 and 4\r
+ *\r
+ * OsIsrResourceLockBudget 1 Float in seconds (MAXRESOURCELOCKINGTIME)\r
+ * OsIsrResourceLockResourceRef 1 Ref to OsResource\r
+ * */\r
+\r
+typedef struct OsIsrResourceLock {\r
+ uint32_t lockBudget;\r
+ uint32_t lockResourceRef; /* Wrong type */\r
+} OsIsrResourceLockType;\r
+\r
+\r
+/* STD container : OsIsrTimingProtection\r
+ * Class: 2 and 4\r
+ *\r
+ * OsIsrAllInterruptLockBudget 0..1 float\r
+ * OsIsrExecutionBudget 0..1 float\r
+ * OsIsrOsInterruptLockBudget 0..1 float\r
+ * OsIsrTimeFrame 0..1 float\r
+ * OsIsrResourceLock[C] 0..*\r
+ * */\r
+\r
+typedef struct OsIsrTimingProtection {\r
+ uint32_t allInterruptLockBudget;\r
+ uint32_t executionBudget;\r
+ uint32_t osInterruptLockBudget;\r
+ uint32_t timeFrame;\r
+ uint32_t resourceLock; /* Wrong type */\r
+} OsIsrTimingProtectionType;\r
+\r
typedef struct {\r
void *curr; /* Current stack ptr( at swap time ) */\r
void *top; /* Top of the stack( low address ) */\r
} OsIsrStackType;\r
\r
\r
-/*\r
- * This type should map against the AUTOSAR OsISR type\r
- */\r
+/* STD container : OsIsr\r
+ * Class: ALL\r
+ *\r
+ * OsIsrCategory: 1 CATEGORY_1 or CATEGORY_2\r
+ * OsIsrResourceRef: 0..* Reference to OsResources\r
+ * OsIsrTimingProtection[C] 0..1\r
+ * */\r
+\r
typedef struct {\r
const char *name;\r
uint8_t core;\r
*\r
*/\r
typedef struct {\r
+ ISRType id;\r
OsIsrStackType stack;\r
int state;\r
const OsIsrConstType *constPtr;\r
void Os_IsrInit( void );\r
ISRType Os_IsrAdd( const OsIsrConstType * restrict isrPtr );\r
const OsIsrConstType * Os_IsrGet( int16_t vector);\r
+void Os_IsrGetStackInfo( OsIsrStackType *stack );\r
\r
#endif /*ISR_H_*/\r
#endif\r
\r
\r
-/*-----------------------------------------------------------------*/\r
-\r
-void Os_CfgGetInterruptStackInfo( OsStackType *stack ) {\r
- stack->top = os_interrupt_stack;\r
- stack->size = sizeof(os_interrupt_stack);\r
-}\r
-\r
-\r
\r
\r
\r
// +1 here.. easy to have a reference..\r
#define GEN_TRUSTEDFUNCTIONS_LIST trusted_func_t os_cfg_trusted_list[OS_SERVICE_CNT];\r
\r
-#define GEN_APPLICATION_HEAD const OsAppConstType Os_AppConst[OS_APPLICATION_CNT] =\r
+#define GEN_APPLICATION_HEAD const OsAppConstType Os_AppConst[OS_APPLICATION_CNT]\r
\r
-#define GEN_APPLICATION( _id,_name,_trusted,_startuphook,_shutdownhook, _errorhook, \\r
+#define GEN_APPLICATION( _id,_name, _core, _trusted,_startuphook,_shutdownhook, _errorhook, \\r
_restart_task ) \\r
{ \\r
.appId = _id, \\r
.name = _name, \\r
+ .core = _core, \\r
.trusted = _trusted, \\r
.StartupHook = _startuphook, \\r
.ShutdownHook = _shutdownhook, \\r
.restartTaskId = _restart_task \\r
}\r
\r
-#define GEN_TASK_HEAD const OsTaskConstType Os_TaskConstList[OS_TASK_CNT] =\r
+#define GEN_TASK_HEAD const OsTaskConstType Os_TaskConstList[OS_TASK_CNT]\r
\r
\r
\r
.accessingApplMask = _accessing_appl_mask, \\r
}\r
\r
+#define GEN_ISR_HEAD const OsIsrConstType Os_IsrConstList[OS_ISR_CNT]\r
+\r
+#define GEN_ISR1( _name, _vector, _priority, _entry, _appOwner ) \\r
+{ \\r
+ .vector = _vector, \\r
+ .type = ISR_TYPE_1, \\r
+ .priority = _priority, \\r
+ .entry = _entry, \\r
+ .name = _name, \\r
+ .resourceMask = 0, \\r
+ .appOwner = _appOwner, \\r
+}\r
+\r
+#define GEN_ISR2( _name, _vector, _priority, _entry, _appOwner, _resourceMask ) \\r
+{ \\r
+ .vector = _vector, \\r
+ .type = ISR_TYPE_1, \\r
+ .priority = _priority, \\r
+ .entry = _entry, \\r
+ .name = _name, \\r
+ .resourceMask = _resourceMask, \\r
+ .appOwner = _appOwner, \\r
+}\r
+\r
+\r
+#define GEN_ISR_MAP const uint8_t Os_VectorToIsr[NUMBER_OF_INTERRUPTS_AND_EXCEPTIONS]\r
+\r
+\r
+#if 0\r
#define GEN_ISR_2( _id, _name, _entry, _priority, _vector ) \\r
{ \\r
.pid = _id, \\r
.proc_type = PROC_ISR1, \\r
.vector = _vector, \\r
}\r
+#endif\r
+\r
\r
//#define GEN_PCB_LIST() uint8_t Os_TaskVarList[PCB_T_SIZE*ARRAY_SIZE( Os_TaskConstList)];\r
#define GEN_PCB_LIST() OsTaskVarType Os_TaskVarList[ARRAY_SIZE( Os_TaskConstList)];\r
* NOT USED. Set to 0\r
*/\r
\r
-#define GEN_COUNTER_HEAD OsCounterType counter_list[OS_COUNTER_CNT] =\r
+#define GEN_COUNTER_HEAD OsCounterType counter_list[OS_COUNTER_CNT]\r
#define GEN_COUNTER( _id, _name, _type, _unit, \\r
_maxallowedvalue, \\r
_ticksperbase, \\r
.appModeRef = _app_mode \\r
}\r
\r
-#define GEN_ALARM_HEAD OsAlarmType alarm_list[OS_ALARM_CNT] =\r
+#define GEN_ALARM_HEAD OsAlarmType alarm_list[OS_ALARM_CNT]\r
\r
/**\r
* _id\r
InitOS();\r
\r
// Enable interrupts\r
- Isr_Init();\r
+ Os_IsrInit();\r
\r
// Determine PostBuild configuration\r
internal_data.config = EcuM_DeterminePbConfiguration();\r
case OBJECT_SCHEDULETABLE:\r
break;\r
case OBJECT_TASK:\r
-#if 0\r
if( objectId < OS_TASK_CNT ) {\r
- rv = Os_TaskGet(objectId)\r
+ rv = Os_TaskGetApplicationOwner((TaskType)objectId);\r
}\r
-\r
-\r
- OsTaskVarTypeapplOwnerId\r
- if( objectId > OS_MAX )\r
-#endif\r
break;\r
default:\r
break;\r
return E_OK;\r
}\r
\r
+\r
/**\r
*
*/\r
}\r
}\r
\r
+uint8_t Os_ApplGetCore( ApplicationType appl )\r
+{\r
+ return Os_AppConst[appl].core;\r
+}\r
+\r
+\r
#endif\r
if (Os_Arc_OsTickCounter >= 0) {\r
\r
OsCounterType *cPtr = Os_CfgGetCounter(Os_Arc_OsTickCounter);\r
+#if defined(USE_KERNEL_EXTRA)\r
+ OsPcbType *pcbPtr;\r
+#endif\r
\r
Os_Sys.tick++;\r
\r
cPtr->val = Os_CounterAdd( cPtr->val, Os_CounterGetMaxValue(cPtr), 1 );\r
\r
- // Os_Sys.tick = cPtr->val;\r
+#if defined(USE_KERNEL_EXTRA)\r
+ /* Check sleep() (ST_WAITING) tasks */\r
+ TAILQ_FOREACH(pcbPtr, &os_sys.timerHead, timerEntry ) {\r
+ --pcbPtr->timerDec;\r
+ if( pcbPtr->timerDec <= 0 ) {\r
+ /* Remove from the timer queue */\r
+ TAILQ_REMOVE(&os_sys.timerHead, pcbPtr, timerEntry);\r
+ /* ... and add to the ready queue */\r
+ Os_TaskMakeReady(pcbPtr);\r
+ }\r
+ }\r
+#endif\r
#if OS_ALARM_CNT!=0\r
Os_AlarmCheck(cPtr);\r
#endif\r
Os_Dispatch(OP_SET_EVENT);\r
}\r
\r
- } else if(destPcbPtr->state & (ST_READY|ST_RUNNING) ) {\r
+ } else if(destPcbPtr->state & (ST_READY|ST_RUNNING|ST_SLEEPING) ) {\r
/* Hmm, we do nothing */\r
} else {\r
assert( 0 );\r
uint32 appId;\r
char name[16];\r
_Bool trusted;\r
+ uint8_t core;\r
\r
/* hooks, the names are StartupHook_<name>(), etc. */\r
void (*StartupHook)( void );\r
void (*ShutdownHook)( StatusType Error );\r
void (*ErrorHook)( StatusType Error );\r
\r
- /* The application hooks */\r
-// OsAppHooksType hooks;\r
-\r
-\r
- /* Ref is ~0U terminated */\r
-#if 0\r
- const uint8_t *alarmRef;\r
- const uint8_t *counterRef;\r
- const uint8_t *isrRef;\r
- const uint8_t *resourceRef;\r
- const uint8_t *schtblRef;\r
- const uint8_t *taskRef;\r
-#endif\r
-\r
int restartTaskId;\r
} OsAppConstType;\r
\r
extern OsAppVarType Os_AppVar[OS_APPLICATION_CNT];\r
#endif\r
\r
+uint8_t Os_ApplGetCore( ApplicationType appl );\r
+\r
#endif /* (OS_USE_APPLICATIONS == STD_ON) */\r
\r
\r
#define ST_SUSPENDED (1<<2)\r
#define ST_RUNNING (1<<3)\r
#define ST_NOT_STARTED (1<<4)\r
+#define ST_SLEEPING (1<<5)\r
\r
#define ST_ISR_RUNNING 1\r
#define ST_ISR_NOT_RUNNING 2\r
#define TASK_NAME_SIZE 16\r
\r
\r
-/* STD container : OsIsr\r
- * Class: ALL\r
- *\r
- * OsIsrCategory: 1 CATEGORY_1 or CATEGORY_2\r
- * OsIsrResourceRef: 0..* Reference to OsResources\r
- * OsIsrTimingProtection[C] 0..1\r
- * */\r
-\r
-\r
-\r
-\r
-/* STD container : OsIsrResourceLock\r
- * Class: 2 and 4\r
- *\r
- * OsIsrResourceLockBudget 1 Float in seconds (MAXRESOURCELOCKINGTIME)\r
- * OsIsrResourceLockResourceRef 1 Ref to OsResource\r
- * */\r
-\r
-typedef struct OsIsrResourceLock {\r
- uint32_t lockBudget;\r
- uint32_t lockResourceRef; /* Wrong type */\r
-} OsIsrResourceLockType;\r
-\r
-\r
-/* STD container : OsIsrTimingProtection\r
- * Class: 2 and 4\r
- *\r
- * OsIsrAllInterruptLockBudget 0..1 float\r
- * OsIsrExecutionBudget 0..1 float\r
- * OsIsrOsInterruptLockBudget 0..1 float\r
- * OsIsrTimeFrame 0..1 float\r
- * OsIsrResourceLock[C] 0..*\r
- * */\r
-\r
-typedef struct OsIsrTimingProtection {\r
- uint32_t allInterruptLockBudget;\r
- uint32_t executionBudget;\r
- uint32_t osInterruptLockBudget;\r
- uint32_t timeFrame;\r
- uint32_t resourceLock; /* Wrong type */\r
-} OsIsrTimingProtectionType;\r
-\r
-\r
\r
/* STD container : OsHooks\r
* OsErrorHooks: 1\r
\r
/* TODO: Arch specific regs .. make space for them later...*/\r
uint32_t regs[16]; // TASK\r
+#if defined(USE_KERNEL_EXTRA)\r
+ TAILQ_ENTRY(OsPcb) timerEntry; // TASK\r
+ int32_t timerDec;\r
+#endif\r
/* List of PCB's */\r
// TAILQ_ENTRY(OsTaskVar) pcb_list; // TASK\r
/* ready list */\r
OP_SCHEDULE = 16,\r
OP_CHAIN_TASK = 32,\r
OP_RELEASE_RESOURCE = 64\r
+ OP_SLEEP = 128,\r
+\r
} OpType ;\r
\r
/*\r
uint32_t task_cnt;\r
\r
uint32_t isrCnt;\r
+#if defined(USE_KERNEL_EXTRA)\r
+\r
+/* List of PCB's to be put in ready list when timeout */\r
+ TAILQ_HEAD(,OsPcb) timerHead; // TASK\r
+#endif\r
+\r
/* List of all pcb's,\r
* Only needed for non-static configuration of the kernel\r
*/\r
extern OsTaskVarType Os_TaskVarList[OS_TASK_CNT];\r
extern OsTaskConstType Os_TaskConstList[OS_TASK_CNT];\r
\r
-static inline OsTaskVarType * Os_TaskGet( OsTaskidType pid ) {\r
+static inline OsTaskVarType * Os_TaskGet( TaskType pid ) {\r
return &Os_TaskVarList[pid];\r
}\r
\r
+static inline ApplicationType Os_TaskGetApplicationOwner( TaskType id ) {\r
+ return Os_TaskGet(id)->constPtr->applOwnerId;\r
+}\r
+\r
+\r
#if 0\r
extern const OsTaskConstType Os_TaskConstList[];\r
static inline const OsTaskConstType * os_get_rom_pcb( OsTaskidType pid ) {\r
/* ----------------------------[private functions]---------------------------*/
/* ----------------------------[public functions]----------------------------*/
-extern void Os_CfgGetInterruptStackInfo( OsStackType *stack );
extern uint32_t McuE_GetSystemClock( void );
extern OsTickType OsTickFreq;
void InitOS( void ) {
int i;
OsTaskVarType *tmpPcbPtr;
- OsStackType intStack;
+ OsIsrStackType intStack;
init_os_called = 1;
Os_Sys.pcb_list = Os_TaskVarList;
TAILQ_INIT(& Os_Sys.ready_head);
// TAILQ_INIT(& Os_Sys.pcb_head);
+#if defined(USE_KERNEL_EXTRA)
+ TAILQ_INIT(& os_sys.timerHead);
+#endif
// Calc interrupt stack
- Os_CfgGetInterruptStackInfo(&intStack);
+ Os_IsrGetStackInfo(&intStack);
// TODO: 16 is arch dependent
Os_Sys.intStack = (void *)((size_t)intStack.top + (size_t)intStack.size - 16);
* for more details.
* -------------------------------- Arctic Core ------------------------------*/
+
#include <sys/types.h>
#include <stdint.h>
#include <string.h>
+#include "Compiler.h"
#include "internal.h"
#include "isr.h"
#include "irq.h"
OsIsrVarType Os_IsrVarList[OS_ISR_MAX_CNT];
#endif
+SECTION_BALIGN(0x10) uint8_t Os_IsrStack[OS_INTERRUPT_STACK_SIZE];
+
// TODO: remove. Make soft links or whatever
#if defined(CFG_ARM_CM3)
#include "irq_types.h"
void Os_IsrInit( void ) {
+ Irq_Init();
+
/* Attach the interrupts */
for (int i = 0; i < sizeof(Os_IsrConstList) / sizeof(OsIsrConstType); i++) {
Os_IsrAdd(&Os_IsrConstList[i]);
if( isrPtr->type == ISR_TYPE_2) {
Os_IsrVarList[id].constPtr = isrPtr;
}
- Irq_EnableVector( isrPtr->vector, isrPtr->priority, isrPtr->core );
+
+ Irq_EnableVector( isrPtr->vector, isrPtr->priority, Os_ApplGetCore(isrPtr->appOwner ) );
return id;
}
}
#endif
+/*-----------------------------------------------------------------*/
+
+void Os_IsrGetStackInfo( OsIsrStackType *stack ) {
+ stack->top = Os_IsrStack;
+ stack->size = sizeof(Os_IsrStack);
+}
+
/**
* Handle ISR type 2 interrupts from interrupt controller.
obj-y += isr.o\r
obj-y += os_arctest.o\r
obj-y += application.o\r
+obj-$(USE_KERNEL_EXTRA) += sleep.o\r
+#obj-$(USE_KERNEL_EXTRA) += semaphore.o\r
\r
\r
# These are VERY cpu dependent.. remove\r
--- /dev/null
+/*\r
+ * semaphore.c\r
+ *\r
+ * Created on: 13 okt 2010\r
+ * Author: mahi\r
+ *\r
+ * Mutex usage:\r
+ * - Serialized access to a global resource. The same task\r
+ * ALWAYS first use Os_WaitMutex() and the Os_ReleaseMutex()\r
+ * Should mutex be as GetResource()/ReleaseResource() be able to\r
+ * tinker with priotities..\r
+ *\r
+ *\r
+ * Task1:\r
+ * Os_WaitMutex(my_mutex)\r
+ * ..\r
+ * Os_ReleaseMutex(my_mutex)\r
+\r
+ * Task2\r
+ * Os_WaitMutex(my_mutex)\r
+ * ..\r
+ * Os_ReleaseMutex(my_mutex)\r
+ *\r
+ * Semaphore usage:\r
+ * - Producer and consumer problems.\r
+ * Os_WaitSemaphore() and Os_SignalSemaphore().\r
+ *\r
+ * ISR:\r
+ * Os_SignalSemaphore(my_semaphore)\r
+\r
+ * Task:\r
+ * Os_WaitSemaphore(my_semaphore)\r
+ *\r
+ */\r
+\r
+StatusType WaitSemaphore( OsSemaphore *semPtr ) {\r
+ uint32_t flags;\r
+\r
+ Irq_Save(flags);\r
+\r
+ --semPtr->val;\r
+\r
+ if(semPtr->val < 0 ) {\r
+ /* Wait for the semaphore to be signaled */\r
+ Os_Dispatch(OP_WAIT_SEMAPHORE);\r
+ }\r
+\r
+ Irq_Restore(flags);\r
+\r
+ return E_OK;\r
+}\r
+\r
+/**\r
+ * Increate the semaphore value by 1.\r
+ *
+ * @param semPtr
+ */\r
+void SignalSemaphore( OsSemaphore *semPtr ) {\r
+ uint32_t flags;\r
+\r
+ Irq_Save(flags);\r
+\r
+ assert( semPtr != NULL );\r
+\r
+ ++semPtr->val;\r
+\r
+ if(semPtr->val <= 0 ) {\r
+ Os_Dispatch(OP_SIGNAL_SEMAPHORE);\r
+ }\r
+\r
+ Irq_Restore(flags);\r
+\r
+ return E_OK;\r
+}\r
+\r
+\r
+/*\r
+ * Usage:
+ */\r
+StatusType CreateSemaphore( OsSemaphore *, int initialCount ) {\r
+\r
+\r
+}\r
+\r
+\r
+/* With priority inheretance */\r
+StatusType CreateMutex( OsMutex *mutexPtr ) {\r
+\r
+\r
+}\r
+\r
+StatusType WaitMutex( OsMutex *mutexPtr ) {\r
+\r
+\r
+}\r
+\r
+StatusType Os_ReleaseMutex( OsMutex *mutexPtr ) {\r
+\r
+\r
+}\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
--- /dev/null
+\r
+#include "Os.h"\r
+#include "internal.h"\r
+#include <assert.h>\r
+#include <string.h>\r
+\r
+/**\r
+ * Will sleep for sleep ticks. This works only for extended\r
+ * tasks. If sleep is 0 it will just call the dispatcher to\r
+ * see if there is anything with higher priority to run.\r
+ *\r
+ *\r
+ *
+ * @param sleep
+ * @return E_OS_ACCESS if called from a basic task\r
+ * E_OS_RESOURCE called while holding a resource\r
+ *
+ */\r
+\r
+StatusType Sleep( TickType sleep ) {\r
+ OsPcbType *pcbPtr = Os_TaskGetCurrent();\r
+ uint32_t flags;\r
+\r
+ Irq_Save(flags);\r
+\r
+\r
+ if (pcbPtr->proc_type != PROC_EXTENDED) {\r
+ return E_OS_ACCESS;\r
+ }\r
+\r
+ if ( Os_TaskOccupiesResources(pcbPtr) ) {\r
+ return E_OS_RESOURCE;\r
+ }\r
+\r
+ if ( Os_SchedulerResourceIsFree() ) {\r
+ if( sleep != 0 ) {\r
+ TAILQ_INSERT_TAIL(&os_sys.timerHead,pcbPtr,timerEntry);\r
+ pcbPtr->timerDec = sleep;\r
+ Os_Dispatch(OP_SLEEP);\r
+ } else {\r
+ Os_Dispatch(OP_SCHEDULE);\r
+ }\r
+\r
+ }\r
+\r
+ Irq_Restore(flags);\r
+ return E_OK;\r
+}\r
/* Go the correct state for running task */\r
if( op & ( OP_SET_EVENT | OP_SCHEDULE | OP_RELEASE_RESOURCE )) {\r
Os_TaskRunningToReady(currPcbPtr);\r
- } else if( op & OP_WAIT_EVENT ) {\r
+ } else if( op & (OP_WAIT_EVENT )) {\r
Os_TaskMakeWaiting(currPcbPtr);\r
+ } else if( op & (OP_SLEEP )) {\r
+ Os_TaskMakeSleeping(currPcbPtr);\r
} else if( op & OP_ACTIVATE_TASK ) {\r
Os_TaskMakeReady(currPcbPtr);\r
} else if( op & OP_CHAIN_TASK ) {\r
// arg 2-blaj\r
// arg 3-debug : 0 \r
\r
- sim.load mpc55xx_sim.dll 20000 0 1\r
+ sim.load mpc55xx_sim.dll 20000 0 0\r
// sim.load C:\projects\workspace\t32_sim\Release\mpc55xx_sim.dll 20000 0 1\r
\r
enddo\r
projects / arc.git / commitdiff