\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
\r
#if ( CAN_DEV_ERROR_DETECT == STD_ON )\r
// Note!\r
// Could install handlers depending on HW objects to trap more errors\r
// in configuration\r
-#if defined(CFG_MPC5567)\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
- INSTALL_HANDLERS(Can_A, FLEXCAN_A_ESR_BOFF_INT, FLEXCAN_A_ESR_ERR_INT, FLEXCAN_A_IFLAG1_BUF0I, FLEXCAN_A_IFLAG1_BUF31_16I); break;\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
- INSTALL_HANDLERS(Can_B, FLEXCAN_B_ESR_BOFF_INT, FLEXCAN_B_ESR_ERR_INT, FLEXCAN_B_IFLAG1_BUF0I, FLEXCAN_B_IFLAG1_BUF31_16I); break;\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
- INSTALL_HANDLERS(Can_C, FLEXCAN_C_ESR_BOFF_INT, FLEXCAN_C_ESR_ERR_INT, FLEXCAN_C_IFLAG1_BUF0I, FLEXCAN_C_IFLAG1_BUF31_16I); break;\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
- INSTALL_HANDLERS(Can_D, FLEXCAN_D_ESR_BOFF_INT, FLEXCAN_D_ESR_ERR_INT, FLEXCAN_D_IFLAG1_BUF0I, FLEXCAN_D_IFLAG1_BUF31_16I); break;\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
- INSTALL_HANDLERS(Can_E, FLEXCAN_E_ESR_BOFF_INT, FLEXCAN_E_ESR_ERR_INT, FLEXCAN_E_IFLAG1_BUF0I, FLEXCAN_E_IFLAG1_BUF31_16I); break;\r
- default:\r
- assert(0);\r
- }\r
-#else\r
- switch( canHwConfig->CanControllerId ) {\r
- case CAN_CTRL_A:\r
- INSTALL_HANDLERS(Can_A, FLEXCAN_A_ESR_BOFF_INT, FLEXCAN_A_ESR_ERR_INT, FLEXCAN_A_IFLAG1_BUF0I, FLEXCAN_A_IFLAG1_BUF31_16I); break;\r
- case CAN_CTRL_B:\r
- INSTALL_HANDLERS(Can_B, FLEXCAN_B_ESR_BOFF_INT, FLEXCAN_B_ESR_ERR_INT, FLEXCAN_B_IFLAG1_BUF0I, FLEXCAN_B_IFLAG1_BUF31_16I); break;\r
- case CAN_CTRL_C:\r
- INSTALL_HANDLERS(Can_C, FLEXCAN_C_ESR_BOFF_INT, FLEXCAN_C_ESR_ERR_INT, FLEXCAN_C_IFLAG1_BUF0I, FLEXCAN_C_IFLAG1_BUF31_16I); break;\r
- case CAN_CTRL_D:\r
- INSTALL_HANDLERS(Can_D, FLEXCAN_D_ESR_BOFF_INT, FLEXCAN_D_ESR_ERR_INT, FLEXCAN_D_IFLAG1_BUF0I, FLEXCAN_D_IFLAG1_BUF31_16I); break;\r
- case CAN_CTRL_E:\r
- INSTALL_HANDLERS(Can_E, FLEXCAN_E_ESR_BOFF_INT, FLEXCAN_E_ESR_ERR_INT, FLEXCAN_E_IFLAG1_BUF0I, FLEXCAN_E_IFLAG1_BUF31_16I); break;\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
- INSTALL_HANDLERS(Can_F, FLEXCAN_F_ESR_BOFF_INT, FLEXCAN_F_ESR_ERR_INT, FLEXCAN_F_IFLAG1_BUF0I, FLEXCAN_F_IFLAG1_BUF31_16I); break;\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
assert(0);\r
}\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
\r
unsigned int Os_ArchGetScSize( void ) {\r
- return SC_SIZE;\r
-}\r
-\r
-extern void os_arch_setup_context_asm( void *context,unsigned int msr);\r
-\r
-// TODO: I have no clue why I wrote this????\r
-void os_arch_stack_to_small(OsPcbType *pcb ,uint32_t size_min) {\r
- OsPcbType *t;\r
- uint32_t min;\r
-\r
- while(1) {\r
- t = pcb;\r
- min = size_min;\r
- }\r
+ return FUNC_FRM_SIZE;\r
}\r
\r
-/*\r
- * Stack grows from high -> low addresses\r
- *\r
\r
+/**\r
+ * Setup a context for a task.\r
*\r
- *\r
-\r
-\r
- * ---------------- bottom of the stack( high address )\r
- * small context\r
- * ----------------\r
- *\r
- * ---------------- top of the stack( low address )\r
- *\r
+ * @param pcb Pointer to the pcb to setup\r
*/\r
- void Os_ArchSetupContext( OsPcbType *pcbPtr ) {\r
-\r
-void Os_ArchSetupContext( OsPcbType *pcb ) {\r
++void Os_ArchSetupContext( OsTaskVarType *pcbPtr ) {\r
+ Os_FuncFrameType *cPtr = (Os_FuncFrameType *)pcbPtr->stack.curr;\r
uint32_t msr;\r
-\r
msr = MSR_EE;\r
\r
#if defined(CFG_SPE)\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
- pcb->regs[0] = msr;\r
+ #endif\r
+#endif\r
+ pcbPtr->regs[0] = msr;\r
+\r
+ cPtr->pattern = FUNC_PATTERN;\r
}\r
\r
/**\r
* @param pcbPtr\r
*/\r
\r
--void Os_ArchSetTaskEntry(OsPcbType *pcbPtr ) {\r
- uint32_t *context = (uint32_t *)pcbPtr->stack.curr;\r
++void Os_ArchSetTaskEntry(OsTaskVarType *pcbPtr ) {\r
+ Os_FuncFrameType *cPtr = (Os_FuncFrameType *)pcbPtr->stack.curr;\r
\r
- context[C_CONTEXT_OFF/4] = SC_PATTERN;\r
-\r
- /* Set LR to start function */\r
-- if( pcbPtr->proc_type == PROC_EXTENDED ) {\r
- context[C_LR_OFF/4] = (uint32_t)Os_TaskStartExtended;\r
- } else if( pcbPtr->proc_type == PROC_BASIC ) {\r
- context[C_LR_OFF/4] = (uint32_t)Os_TaskStartBasic;\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
\r
-\r
-#define C_CONTEXT_OFF 12\r
-#define C_LR_OFF 16\r
-#define C_CR_OFF 20\r
-\r
-void os_arch_print_context( char *str, OsPcbType *pcb ) {\r
- uint32_t *stack;\r
-\r
- LDEBUG_PRINTF("%s CONTEXT: %d\n",str, pcb->pid);\r
- LDEBUG_PRINTF(" stack: curr=%p top=%p bottom=%p\n",\r
- pcb->stack.curr,\r
- pcb->stack.top,\r
- pcb->stack.top+ pcb->stack.size);\r
- stack = pcb->stack.curr;\r
- LDEBUG_PRINTF(" val : context=%08x LR=%08x CR=%08x\n",\r
- (unsigned)stack[C_CONTEXT_OFF/4],\r
- (unsigned)stack[C_LR_OFF/4],\r
- (unsigned)stack[C_CR_OFF/4]\r
- );\r
}\r
\r
-\r
void Os_ArchInit( void ) {\r
#if defined(CFG_SPE)\r
uint32_t msr = get_msr();\r
* you can use only 8-bit.\r
*/\r
\r
-#define LOCK() wrteei 0\r
-#define UNLOCK() wrteei 1\r
\r
+/* ----------------------------[includes]------------------------------------*/\r
+#define _ASSEMBLER_\r
+#include "asm_ppc.h"\r
+#include "arch_offset.h"\r
+#include "asm_offset.h"\r
+#include "arch_stack.h"\r
\r
-.extern os_proc_start_extended\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
-//-------------------------------------------------------------------\r
+#if defined(CFG_VLE)\r
+#define lis e_lis\r
+#define li se_li\r
+#define lwz e_lwz\r
+#define stwu e_stwu\r
+#define stw e_stw\r
+#define b e_b\r
+#define addi e_addi /* true ?*/\r
+#define subi e_subi /* true ?*/\r
+#endif \r
\r
- .global os_exception_IVOR8\r
- .balign 16\r
-os_exception_IVOR8:\r
- stwu sp,-(EXC_SIZE+VGPR_SIZE)(sp)\r
- stw r3,EXC_R3_OFF(r1)\r
- stw r4,EXC_R4_OFF(r1)\r
- SAVE_EXC_FRAME(3,1,0,SPR_SRR0,SPR_SRR1)\r
- SAVE_VGPR(1,EXC_SIZE);\r
- li r3,328\r
- stw r3,EXC_VECTOR_OFF(r1)\r
+/* ----------------------------[private define]------------------------------*/\r
\r
- rfi\r
++//#define OLD_CALL \r
+ \r
-dummy_int:\r
- b dummy_int\r
+#define INTC_IACKR_PRC0 0xfff48010 \r
+#define INTC_EOIR_PRC0 0xfff48018\r
+#define INTC_IACKR 0xfff48010\r
+#define INTC_EOIR 0xfff48018\r
+#define INTC_SSCIR0 0xfff48020\r
\r
-/*--------------------------------------------------------------------\r
- * void os_swap_context(pcb_t *old, pcb_t *new )\r
- *\r
- * Saves a small context on current stack, pops a new one from new context\r
- *\r
- * r3 - pcb for old process\r
- * r4 - pcb for new process\r
- *\r
- *--------------------------------------------------------------------*/\r
+/* ----------------------------[private macro]-------------------------------*/\r
+\r
+#define LOCK() wrteei 0\r
+#define UNLOCK() wrteei 1\r
+\r
+#define EXC_TABLE_CODE(_exc_nr) \\r
+ stwu sp,-EXC_FRM_SIZE(sp); \\r
+ stw r3,EXC_FRM_R3(sp); \\r
+ li r3,_exc_nr; \\r
+ b handleException \r
\r
-// TODO: this assumes that both are in user mode?.. can this happen under trusted functions?\r
-// When I get here we're ALWAYS in kernel mode\r
+#if ISR_FRM_PATTERN!=FUNC_FRM_PATTERN\r
+#error Context pattern must be in the same place\r
+#endif\r
+\r
+/* ----------------------------[private typedef]-----------------------------*/\r
+/* ----------------------------[private function prototypes]-----------------*/\r
+/* ----------------------------[private variables]---------------------------*/\r
+/* ----------------------------[private functions]---------------------------*/\r
+/* ----------------------------[public functions]----------------------------*/\r
+\r
+.extern Os_Isr\r
\r
-.global Os_ArchSwapContextToW\r
.global Os_ArchSwapContextTo\r
.global Os_ArchSwapContext\r
.global Os_ArchSetSpAndCall\r
mtlr r4\r
blr\r
\r
-Os_ArchSwapContextToW:\r
- mr r1,r5\r
- b Os_ArchSwapContextTo\r
-\r
+/**\r
+ * void Os_ArchSwapContext(pcb_t *old, pcb_t *new )\r
+ *\r
+ * Saves a function context on current stack, pops a new one from new context\r
+ *\r
+ * r3 - pcb for old task\r
+ * r4 - pcb for new task\r
+ *\r
+ */\r
Os_ArchSwapContext:\r
- // allocate space for context+nvgpr\r
- // (no need for proper stack-frame here)\r
- stwu r1,-(C_SIZE+NVGPR_SIZE)(r1)\r
- // save lr and cr */\r
- mflr r0\r
- stw r0,C_LR_OFF(sp)\r
- mfcr r0\r
- stw r0,C_CR_OFF(sp)\r
- // Save small-context pattern\r
- li r0,SC_PATTERN\r
- stw r0,C_CONTEXT_OFF(sp)\r
- // Save registers preserved by function call\r
- SAVE_NVGPR(sp,(C_SIZE-14*GPR_SIZE))\r
-// Save stack ptr...\r
- stw sp,PCB_STACK_CURR_P(r3)\r
-\r
-// Stack frame here\r
-// --------- bottom( high address )\r
-// SC_xxx\r
-// C_xxx\r
-// --------- <- stack.curr\r
-//\r
-// --------- top( low address )\r
-\r
-\r
-// TODO: If we change application we must change mmu setup\r
+ stwu sp,-FUNC_FRM_SIZE(sp)\r
+ mflr r0\r
+ stw r0,FUNC_FRM_LR(sp)\r
+ mfcr r0\r
+ stw r0,FUNC_FRM_CR(sp)\r
+ \r
+ /* Save context indicator */\r
+ li r0,FUNC_PATTERN\r
+ stw r0,FUNC_FRM_PATTERN(sp)\r
+\r
+#if defined(CFG_SPE)\r
+ stw r14, FUNC_FRM_R14(sp)\r
+ stw r15, FUNC_FRM_R15(sp)\r
+ stw r16, FUNC_FRM_R16(sp)\r
+ stw r17, FUNC_FRM_R17(sp)\r
+ stw r18, FUNC_FRM_R18(sp)\r
+ stw r19, FUNC_FRM_R19(sp)\r
+ stw r20, FUNC_FRM_R20(sp)\r
+ stw r21, FUNC_FRM_R21(sp)\r
+ stw r22, FUNC_FRM_R22(sp)\r
+ stw r23, FUNC_FRM_R23(sp)\r
+ stw r24, FUNC_FRM_R24(sp)\r
+ stw r25, FUNC_FRM_R25(sp)\r
+ stw r26, FUNC_FRM_R26(sp)\r
+ stw r27, FUNC_FRM_R27(sp)\r
+ stw r28, FUNC_FRM_R28(sp)\r
+ stw r29, FUNC_FRM_R29(sp)\r
+ stw r30, FUNC_FRM_R30(sp)\r
+ stw r31, FUNC_FRM_R31(sp)\r
+\r
+#else\r
+ /* Save registers preserved by function call */\r
+ stw r14, FUNC_FRM_R14(sp)\r
+ stw r15, FUNC_FRM_R15(sp)\r
+ stw r16, FUNC_FRM_R16(sp)\r
+ stw r17, FUNC_FRM_R17(sp)\r
+ stw r18, FUNC_FRM_R18(sp)\r
+ stw r19, FUNC_FRM_R19(sp)\r
+ stw r20, FUNC_FRM_R20(sp)\r
+ stw r21, FUNC_FRM_R21(sp)\r
+ stw r22, FUNC_FRM_R22(sp)\r
+ stw r23, FUNC_FRM_R23(sp)\r
+ stw r24, FUNC_FRM_R24(sp)\r
+ stw r25, FUNC_FRM_R25(sp)\r
+ stw r26, FUNC_FRM_R26(sp)\r
+ stw r27, FUNC_FRM_R27(sp)\r
+ stw r28, FUNC_FRM_R28(sp)\r
+ stw r29, FUNC_FRM_R29(sp)\r
+ stw r30, FUNC_FRM_R30(sp)\r
+ stw r31, FUNC_FRM_R31(sp)\r
+#endif\r
+\r
+ /* Save stack ptr... */\r
+ stw sp,PCB_STACK_CURR_P(r3)\r
+\r
+ /* TODO: Call Os_PretaskHook()? */ \r
+ \r
+ /* Flow down */\r
+ \r
+/**\r
+ * void Os_ArchSwapContextTo( NULL, pcb_t *new )\r
+ * r3 - always NULL\r
+ * r4 - The pcb to switch to.\r
+ */ \r
Os_ArchSwapContextTo:\r
-// Get stack for new task\r
- lwz sp,PCB_STACK_CURR_P(r4)\r
-\r
-// Set new current process\r
- LOAD_ADDR_32(3,os_sys)\r
- stw r4,SYS_CURR_PCB_P(r3)\r
-\r
-// Restore C context\r
- lwz r0,C_CR_OFF(sp)\r
- mtcr r0\r
- lwz r0,C_LR_OFF (sp)\r
- mtlr r0\r
-\r
-// Get the context type\r
- lwz r0,C_CONTEXT_OFF(sp)\r
- cmpli 0,r0,SC_PATTERN\r
- beq+ os_sc_restore\r
- cmpli 0,r0,LC_PATTERN\r
- beq+ os_lc_restore\r
- b os_bad_bad\r
-\r
-\r
-// SC_xxx\r
-// C_xxxx <- We point here\r
-\r
-os_sc_restore:\r
- RESTORE_NVGPR(sp,(C_SIZE-14*GPR_SIZE))\r
- addi sp,sp,(C_SIZE+NVGPR_SIZE)\r
- // TODO: The blr will not do the trick if swapping to a user land task.\r
- blr\r
-\r
-os_lc_restore:\r
- addi r1,r1,C_SIZE\r
- RESTORE_NVGPR(1,0)\r
- addi r1,r1,-C_SIZE\r
- RESTORE_VGPR(1,C_SIZE)\r
-\r
- RESTORE_WORK_AND_MORE\r
+ /* Get stack for new task */\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
+ lwz r0,FUNC_FRM_CR(sp)\r
+ mtcr r0\r
+ lwz r0,FUNC_FRM_LR (sp)\r
+ mtlr r0\r
+\r
+ /* Get the context type */\r
+ lwz r0, FUNC_FRM_PATTERN(sp)\r
+ cmpli 0, r0, FUNC_PATTERN\r
+ beq+ restoreFuncContext\r
+ cmpli 0, r0,ISR_PATTERN\r
+ beq+ restoreIsrContext\r
+ li r3, OS_ERR_BAD_CONTEXT\r
+ b Os_ArchPanic\r
+\r
+restoreFuncContext:\r
+#if defined(CFG_SPE)\r
+ evldd r14, FUNC_FRM_R14(sp)\r
+ evldd r15, FUNC_FRM_R15(sp)\r
+ evldd r16, FUNC_FRM_R16(sp)\r
+ evldd r17, FUNC_FRM_R17(sp)\r
+ evldd r18, FUNC_FRM_R18(sp)\r
+ evldd r19, FUNC_FRM_R19(sp)\r
+ evldd r20, FUNC_FRM_R20(sp)\r
+ evldd r21, FUNC_FRM_R21(sp)\r
+ evldd r22, FUNC_FRM_R22(sp)\r
+ evldd r23, FUNC_FRM_R23(sp)\r
+ evldd r24, FUNC_FRM_R24(sp)\r
+ evldd r25, FUNC_FRM_R25(sp)\r
+ evldd r26, FUNC_FRM_R26(sp)\r
+ evldd r27, FUNC_FRM_R27(sp)\r
+ evldd r28, FUNC_FRM_R28(sp)\r
+ evldd r29, FUNC_FRM_R29(sp)\r
+ evldd r30, FUNC_FRM_R30(sp)\r
+ evldd r31, FUNC_FRM_R31(sp)\r
+ addi sp,sp,(FUNC_FRM_SIZE)\r
+#else \r
+ lwz r14, FUNC_FRM_R14(sp)\r
+ lwz r15, FUNC_FRM_R15(sp)\r
+ lwz r16, FUNC_FRM_R16(sp)\r
+ lwz r17, FUNC_FRM_R17(sp)\r
+ lwz r18, FUNC_FRM_R18(sp)\r
+ lwz r19, FUNC_FRM_R19(sp)\r
+ lwz r20, FUNC_FRM_R20(sp)\r
+ lwz r21, FUNC_FRM_R21(sp)\r
+ lwz r22, FUNC_FRM_R22(sp)\r
+ lwz r23, FUNC_FRM_R23(sp)\r
+ lwz r24, FUNC_FRM_R24(sp)\r
+ lwz r25, FUNC_FRM_R25(sp)\r
+ lwz r26, FUNC_FRM_R26(sp)\r
+ lwz r27, FUNC_FRM_R27(sp)\r
+ lwz r28, FUNC_FRM_R28(sp)\r
+ lwz r29, FUNC_FRM_R29(sp)\r
+ lwz r30, FUNC_FRM_R30(sp)\r
+ lwz r31, FUNC_FRM_R31(sp)\r
+ addi sp,sp,(FUNC_FRM_SIZE)\r
+#endif \r
+ /* TODO: Call Os_PosttaskHook()? */\r
+ \r
+ blr\r
+\r
+\r
+/**\r
+ * External input exception handlers \r
+ */ \r
+ .global exception_IVOR4\r
+ .global restoreIsrContext\r
+ .balign 16\r
+exception_IVOR4:\r
+\r
+ /* Save the exception frame */\r
+ stwu sp,-EXC_FRM_SIZE(sp)\r
+\r
+ stw r3,EXC_FRM_R3(sp)\r
+\r
+ mfsrr0 r3\r
+ stw r3, EXC_FRM_SRR0(sp)\r
+ mfsrr1 r3\r
+ stw r3, EXC_FRM_SRR1(sp)\r
+\r
+ mfcr r3\r
+ stw r3, EXC_FRM_CR(sp) \r
+ mfxer r3 \r
+ stw r3, EXC_FRM_XER(sp)\r
+ mfctr r3\r
+ stw r3, EXC_FRM_CTR(sp)\r
+ mflr r3\r
+ stw r3, EXC_FRM_LR(sp) \r
+ \r
+ li r3,4\r
+ stw r3, EXC_FRM_VECTOR(sp)\r
+#if defined(CFG_SPE) \r
+\r
+ /* Enable SPE (exceptions turns it off) */\r
+ mfmsr r3\r
+ oris r3,r3,0x0200\r
+ mtmsr r3\r
+ isync\r
+\r
+ /* Create the frame */\r
+ addi sp,sp,-ISR_FRM_SIZE\r
+ evstdd r3, ISR_FRM_R3(sp) /* Save work reg */ \r
+ \r
+ /* SPEFSCR */\r
+ mfspr r3,SPR_SPEFSCR\r
+ clrlwi r3,r3,24 /* Mask off non-status bits */\r
+ stw r3,ISR_FRM_SPE_FSCR(sp)\r
+\r
+ /* Save SPE acc */\r
+ evsubfw r3,r3,r3 /* zero r3 */\r
+ evaddumiaaw r3,r3 /* Add r3 = r3 + acc -> r3 = acc */\r
+ evstdd r3,ISR_FRM_SPE_ACC(r1)\r
+ \r
+ evstdd r0, ISR_FRM_R0(sp)\r
+ evstdd r4, ISR_FRM_R4(sp)\r
+ evstdd r5, ISR_FRM_R5(sp)\r
+ evstdd r6, ISR_FRM_R6(sp)\r
+ evstdd r7, ISR_FRM_R7(sp)\r
+ evstdd r8, ISR_FRM_R8(sp)\r
+ evstdd r9, ISR_FRM_R9(sp)\r
+ evstdd r10, ISR_FRM_R10(sp)\r
+ evstdd r11, ISR_FRM_R11(sp)\r
+ evstdd r12, ISR_FRM_R12(sp)\r
+ evstdd r14, ISR_FRM_R14(sp)\r
+ evstdd r15, ISR_FRM_R15(sp)\r
+ evstdd r16, ISR_FRM_R16(sp)\r
+ evstdd r17, ISR_FRM_R17(sp)\r
+ evstdd r18, ISR_FRM_R18(sp)\r
+ evstdd r19, ISR_FRM_R19(sp)\r
+ evstdd r20, ISR_FRM_R20(sp)\r
+ evstdd r21, ISR_FRM_R21(sp)\r
+ evstdd r22, ISR_FRM_R22(sp)\r
+ evstdd r23, ISR_FRM_R23(sp)\r
+ evstdd r24, ISR_FRM_R24(sp)\r
+ evstdd r25, ISR_FRM_R25(sp)\r
+ evstdd r26, ISR_FRM_R26(sp)\r
+ evstdd r27, ISR_FRM_R27(sp)\r
+ evstdd r28, ISR_FRM_R28(sp)\r
+ evstdd r29, ISR_FRM_R29(sp)\r
+ evstdd r30, ISR_FRM_R30(sp)\r
+ addi sp,sp,8\r
+ evstdd r31, (ISR_FRM_R31-8)(sp)\r
+ addi sp,sp,-8\r
+#else\r
+ /* Save the ISR frame */\r
+ addi sp,sp,-ISR_FRM_SIZE\r
+ stw r0, ISR_FRM_R0(sp)\r
+ stw r4, ISR_FRM_R4(sp)\r
+ stw r5, ISR_FRM_R5(sp)\r
+ stw r6, ISR_FRM_R6(sp)\r
+ stw r7, ISR_FRM_R7(sp)\r
+ stw r8, ISR_FRM_R8(sp)\r
+ stw r9, ISR_FRM_R9(sp)\r
+ stw r10, ISR_FRM_R10(sp)\r
+ stw r11, ISR_FRM_R11(sp)\r
+ stw r12, ISR_FRM_R12(sp)\r
+ stw r14, ISR_FRM_R14(sp)\r
+ stw r15, ISR_FRM_R15(sp)\r
+ stw r16, ISR_FRM_R16(sp)\r
+ stw r17, ISR_FRM_R17(sp)\r
+ stw r18, ISR_FRM_R18(sp)\r
+ stw r19, ISR_FRM_R19(sp)\r
+ stw r20, ISR_FRM_R20(sp)\r
+ stw r21, ISR_FRM_R21(sp)\r
+ stw r22, ISR_FRM_R22(sp)\r
+ stw r23, ISR_FRM_R23(sp)\r
+ stw r24, ISR_FRM_R24(sp)\r
+ stw r25, ISR_FRM_R25(sp)\r
+ stw r26, ISR_FRM_R26(sp)\r
+ stw r27, ISR_FRM_R27(sp)\r
+ stw r28, ISR_FRM_R28(sp)\r
+ stw r29, ISR_FRM_R29(sp)\r
+ stw r30, ISR_FRM_R30(sp)\r
+ stw r31, ISR_FRM_R31(sp)\r
+#endif\r
+ \r
+ li r3,ISR_PATTERN\r
+ stw r3,ISR_FRM_PATTERN(sp)\r
+ /* Save the stack so it later can be saved in the pcb */ \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
+#if defined(CFG_MPC5516)\r
+ lis r6, INTC_IACKR_PRC0@ha\r
+ lwz r6, INTC_IACKR_PRC0@l(r6)\r
+#elif defined(CFG_MPC5554) || defined(CFG_MPC5567)\r
+ lis r6, INTC_IACKR@ha \r
+ lwz r6, INTC_IACKR@l(r6)\r
+#endif\r
+ /* Check for 0 entry */\r
+ mr r5,r6\r
+ cmpli 0,r5,0\r
+ bne+ vectorOk\r
+ /* The entry was 0, call panic */\r
+ li r3,OS_ERR_SPURIOUS_INTERRUPT\r
+ li r4, 0\r
+ mr r5,r1\r
+ b Os_ArchPanic\r
+ \r
+vectorOk:\r
+ extrwi r5,r5,9,21\r
+ /* Check for soft INT */\r
+ cmpli 0,r5,7\r
+ bgt noSoftInt\r
+ /* Clear soft interrupt */\r
+ li r0,1 \r
+ lis r3, INTC_SSCIR0@h\r
+ ori r3, r3, INTC_SSCIR0@l\r
+ stbx r0,r5,r3 \r
+ \r
+noSoftInt: \r
+\r
+ lis r3, Os_Isr@h\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
+ * The OS interrupt is ACK'd in Os_Isr(). For ISR1 it needs to call Irq_EOI()\r
+ */\r
+ \r
+ /* Irq_Entry have returned the stack we shall use */\r
+ mr sp,r3\r
+\r
+ /* Restore */\r
+restoreIsrContext:\r
+#if defined(CFG_SPE) \r
+\r
+ // Restore SPE control/status reg.\r
+ lwz r3,ISR_FRM_SPE_FSCR(sp)\r
+ mtspr SPR_CSRR0,r3\r
+\r
+ /* Restore SPE acc */\r
+ evldd r3,ISR_FRM_SPE_ACC(r1)\r
+ evmra r3,r3\r
+ \r
+\r
+ evldd r0, ISR_FRM_R0(sp)\r
+ evldd r3, ISR_FRM_R4(sp)\r
+ evldd r4, ISR_FRM_R4(sp)\r
+ evldd r5, ISR_FRM_R5(sp)\r
+ evldd r6, ISR_FRM_R6(sp)\r
+ evldd r7, ISR_FRM_R7(sp)\r
+ evldd r8, ISR_FRM_R8(sp)\r
+ evldd r9, ISR_FRM_R9(sp)\r
+ evldd r10, ISR_FRM_R10(sp)\r
+ evldd r11, ISR_FRM_R11(sp)\r
+ evldd r12, ISR_FRM_R12(sp)\r
+ evldd r14, ISR_FRM_R14(sp)\r
+ evldd r15, ISR_FRM_R15(sp)\r
+ evldd r16, ISR_FRM_R16(sp)\r
+ evldd r17, ISR_FRM_R17(sp)\r
+ evldd r18, ISR_FRM_R18(sp)\r
+ evldd r19, ISR_FRM_R19(sp)\r
+ evldd r20, ISR_FRM_R20(sp)\r
+ evldd r21, ISR_FRM_R21(sp)\r
+ evldd r22, ISR_FRM_R22(sp)\r
+ evldd r23, ISR_FRM_R23(sp)\r
+ evldd r24, ISR_FRM_R24(sp)\r
+ evldd r25, ISR_FRM_R25(sp)\r
+ evldd r26, ISR_FRM_R26(sp)\r
+ evldd r27, ISR_FRM_R27(sp)\r
+ evldd r28, ISR_FRM_R28(sp)\r
+ evldd r29, ISR_FRM_R29(sp)\r
+ evldd r30, ISR_FRM_R30(sp)\r
+ addi sp,sp,8\r
+ evldd r31, (ISR_FRM_R31-8)(sp)\r
+ addi sp,sp,-8\r
+#else\r
+ lwz r0, ISR_FRM_R0(sp)\r
+ lwz r4, ISR_FRM_R4(sp)\r
+ lwz r5, ISR_FRM_R5(sp)\r
+ lwz r6, ISR_FRM_R6(sp)\r
+ lwz r7, ISR_FRM_R7(sp)\r
+ lwz r8, ISR_FRM_R8(sp)\r
+ lwz r9, ISR_FRM_R9(sp)\r
+ lwz r10, ISR_FRM_R10(sp)\r
+ lwz r11, ISR_FRM_R11(sp)\r
+ lwz r12, ISR_FRM_R12(sp)\r
+ lwz r14, ISR_FRM_R14(sp)\r
+ lwz r15, ISR_FRM_R15(sp)\r
+ lwz r16, ISR_FRM_R16(sp)\r
+ lwz r17, ISR_FRM_R17(sp)\r
+ lwz r18, ISR_FRM_R18(sp)\r
+ lwz r19, ISR_FRM_R19(sp)\r
+ lwz r20, ISR_FRM_R20(sp)\r
+ lwz r21, ISR_FRM_R21(sp)\r
+ lwz r22, ISR_FRM_R22(sp)\r
+ lwz r23, ISR_FRM_R23(sp)\r
+ lwz r24, ISR_FRM_R24(sp)\r
+ lwz r25, ISR_FRM_R25(sp)\r
+ lwz r26, ISR_FRM_R26(sp)\r
+ lwz r27, ISR_FRM_R27(sp)\r
+ lwz r28, ISR_FRM_R28(sp)\r
+ lwz r29, ISR_FRM_R29(sp)\r
+ lwz r30, ISR_FRM_R30(sp)\r
+ lwz r31, ISR_FRM_R31(sp)\r
+#endif \r
+ \r
+ /* back to the exception frame */\r
+ addi sp,sp,ISR_FRM_SIZE\r
+ \r
+ lwz r3, EXC_FRM_LR(sp)\r
+ mtlr r3\r
+ lwz r3, EXC_FRM_CTR(sp)\r
+ mtctr r3\r
+ lwz r3, EXC_FRM_XER(sp)\r
+ mtxer r3\r
+ lwz r3, EXC_FRM_CR(sp)\r
+ mtcr r3\r
+ lwz r3, EXC_FRM_SRR0(sp)\r
+ mtsrr0 r3\r
+ lwz r3, EXC_FRM_SRR1(sp)\r
+ mtsrr1 r3\r
+ lwz r3, EXC_FRM_R3(sp)\r
+ addi sp,sp,EXC_FRM_SIZE\r
rfi\r
\r
-// When something really bad happens we end up here for the moment\r
-os_bad_bad:\r
- b os_bad_bad\r
-\r
-\r
\r
\r
-// ------------------------------------------------------------------\r
-\r
-/*\r
- * Trap interface !!!! See article http://www.linuxjournal.com/article/6516\r
- * http://www.osweekly.com/index.php?option=com_content&task=view&id=2229\r
+/**\r
+ * Decrementer exception. It just triggers soft interrupt 7.\r
+ *\r
*/\r
+exception_IVOR10:\r
+ stwu r3,-8(sp)\r
+ stw r4,4(sp)\r
\r
-/* The T32 instruction sim can't handle trap's so we have to make something\r
- * - write SRR0, SRR1, MSR\r
- * - jump to there routines\r
- */\r
+ /* ack dec int */\r
+ lis r3,0x0800\r
+ mtspr SPR_TSR,r3\r
\r
-// ------------------------------------------------------------------\r
+ /* Set soft int */\r
+ li r4,2\r
+ lis r3, INTC_SSCIR7@ha\r
+ stb r4, INTC_SSCIR7@l(r3)\r
\r
+ lwz r3,0(sp)\r
+ lwz r4,4(sp)\r
+ addi sp,sp,8\r
+ rfi\r
\r
-// System call, use this for trusted function ???\r
-// TODO: The example in autosar is not neccesary.. sc here here instead??\r
-//\r
-// NOTE!!!!!\r
-// Since the sc is a sync call, it should be enough to save NV regs(14->)\r
-// If I don't use the NV regs here I shouldn't need to save them\r
-// TODO: Inform compiler in SC_CALL() that I clobber volatile regs( r0, r3->\r
-// (since the compiler does not know it's a function call)\r
-// TODO: Could probably do this shorter....only NV regs that I use need saving\r
-// ( only cr2->cr4 according to e500 ABI )\r
\r
+/* Getting here means that the exception stack is started with:\r
+ * sp - saved\r
+ * r3 - saved and contains the exception number \r
+ */\r
+handleException:\r
+ b handleException \r
+ \r
+#if defined(__GNUC__) \r
+.section ".exception_tbl","ax"\r
+#elif defined(__CWCC__)\r
+.section .exception_tbl,4,"rw"\r
+#endif\r
+.balign 0x1000\r
+.global exception_tbl\r
+\r
+exception_tbl:\r
+ EXC_TABLE_CODE(0)\r
+ EXC_TABLE_CODE(1)\r
+ EXC_TABLE_CODE(2)\r
+ EXC_TABLE_CODE(3)\r
+ b exception_IVOR4\r
+ .skip +0xc\r
+ EXC_TABLE_CODE(5)\r
+ EXC_TABLE_CODE(6)\r
+ EXC_TABLE_CODE(7)\r
+ EXC_TABLE_CODE(8)\r
+ EXC_TABLE_CODE(9)\r
+ b exception_IVOR10\r
+ .skip +0xc\r
+ EXC_TABLE_CODE(11)\r
+ EXC_TABLE_CODE(12)\r
+ EXC_TABLE_CODE(13)\r
+ EXC_TABLE_CODE(14)\r
+#if defined(CFG_SPE)\r
+ EXC_TABLE_CODE(32)\r
+ EXC_TABLE_CODE(33)\r
+ EXC_TABLE_CODE(34)\r
+#endif\r
\r
\r
\r
* for more details.\r
* -------------------------------- Arctic Core ------------------------------*/\r
\r
+/* ----------------------------[includes]------------------------------------*/\r
+/* ----------------------------[private define]------------------------------*/\r
+/* ----------------------------[private macro]-------------------------------*/\r
+/* ----------------------------[private typedef]-----------------------------*/\r
+/* ----------------------------[private function prototypes]-----------------*/\r
+/* ----------------------------[private variables]---------------------------*/\r
+/* ----------------------------[private functions]---------------------------*/\r
+/* ----------------------------[public functions]----------------------------*/\r
+\r
+\r
+/* ----------------------------[includes]------------------------------------*/\r
+\r
#include "internal.h"\r
--#include "asm_book_e.h"\r
#include "irq_types.h"\r
#include "mpc55xx.h"\r
-#if !defined(USE_KERNEL)\r
-#include "Mcu.h"\r
-#endif\r
-\r
-#if defined(USE_KERNEL)\r
#include "pcb.h"\r
#include "sys.h"\r
#include "internal.h"\r
#include "task_i.h"\r
#include "hooks.h"\r
-\r
-#if 0\r
-#define INTC_SSCIR0_CLR7 7\r
-#define MLB_SERVICE_REQUEST 293\r
-#define CRITICAL_INPUT_EXCEPTION 320\r
-#define DEBUG_EXCEPTION 335\r
-#define NUMBER_OF_INTERRUPTS_AND_EXCEPTIONS 336\r
-#endif\r
-\r
#include "debug.h"\r
-#endif\r
-#include "irq.h"\r
-\r
-static void dump_exception_regs( uint32_t *regs );\r
+#include "isr.h"\r
- #include "irq_config.h"\r
+#include <stdint.h>\r
\r
+/* ----------------------------[private define]------------------------------*/\r
+/* ----------------------------[private macro]-------------------------------*/\r
+/* ----------------------------[private typedef]-----------------------------*/\r
typedef void (*f_t)( uint32_t *);\r
-//typedef void (*func_t)();\r
-//extern vfunc_t Irq_VectorTable[];\r
-extern void exception_tbl(void);\r
\r
+/* ----------------------------[private function prototypes]-----------------*/\r
+//extern uintptr_t Irq_VectorTable[NUMBER_OF_INTERRUPTS_AND_EXCEPTIONS];\r
+//extern uint8 Irq_IsrTypeTable[NUMBER_OF_INTERRUPTS_AND_EXCEPTIONS];\r
+//extern const OsIsrConstType *Irq_Map[NUMBER_OF_INTERRUPTS_AND_EXCEPTIONS];\r
\r
+static void dumpExceptionRegs( uint32_t *regs );\r
\r
-#if defined(USE_KERNEL)\r
-extern void * Irq_VectorTable[NUMBER_OF_INTERRUPTS_AND_EXCEPTIONS];\r
-extern uint8 Irq_IsrTypeTable[NUMBER_OF_INTERRUPTS_AND_EXCEPTIONS];\r
-#else\r
-extern func_t Irq_VectorTable[];\r
-#endif\r
+/* ----------------------------[private variables]---------------------------*/\r
+extern void exception_tbl(void);\r
+\r
+/* ----------------------------[private functions]---------------------------*/\r
+/* ----------------------------[public functions]----------------------------*/\r
\r
// write 0 to pop INTC stack\r
void Irq_Init( void ) {\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
}\r
}\r
\r
-#if defined(USE_KERNEL)\r
-\r
- if( Irq_GetIsrType(vector) == ISR_TYPE_1 ) {\r
- // It's a function, just call it.\r
- ((func_t)Irq_VectorTable[vector])();\r
+ isr = Os_IsrGet(exc_vector);\r
+ if( isr->type == ISR_TYPE_1 ) {\r
+ isr->entry();\r
return stack;\r
} else {\r
- // It's a PCB\r
- // Let the kernel handle the rest,\r
- return Os_Isr(stack, (void *)Irq_VectorTable[vector]);\r
- }\r
-\r
-\r
-#else\r
- //read address\r
- t = (func_t)Irq_VectorTable[vector];\r
-\r
- if( t == ((void *)0) )\r
- {\r
- while(1);\r
+ return Os_Isr(stack, vector);\r
}\r
-\r
- // Enable nestling interrupts\r
- Irq_Enable();\r
- t();\r
- Irq_Disable();\r
-\r
- if( vector < INTC_NUMBER_OF_INTERRUPTS )\r
- {\r
- // write 0 to pop INTC stack\r
- intc->EOIR_PRC0.R = 0;\r
- }\r
- return NULL;\r
-\r
-#endif\r
}\r
-\r
-\r
-\r
-#if defined(USE_KERNEL)\r
-\r
++#endif\r
+ \r
\r
static inline int osPrioToCpuPio( uint8_t prio ) {\r
assert(prio<32);\r
DET_STARTED\r
} Det_StateType;\r
\r
-static Det_StateType _detState = DET_UNINITIALIZED;\r
+static Det_StateType detState = DET_UNINITIALIZED;\r
\r
#if ( DET_USE_RAMLOG == STD_ON )\r
- #pragma section RW ".ramlog" ".ramlog"\r
- \r
+\r
// Ram log variables in uninitialized memory\r
-uint32 Det_RamlogIndex __attribute__ ((section (".ramlog")));\r
-Det_EntryType Det_RamLog[DET_RAMLOG_SIZE] __attribute__ ((section (".ramlog")));\r
+SECTION_RAMLOG uint32 Det_RamlogIndex;\r
+/*lint -esym(552,Det_RamLog)*/ /* PC-Lint OK. supress lintwarning about Det_Ramlog not being accessed */\r
+SECTION_RAMLOG Det_EntryType Det_RamLog[DET_RAMLOG_SIZE] ;\r
#endif\r
\r
#if ( DET_ENABLE_CALLBACKS == STD_ON )\r
\r
/* REQ:COMPILER040,049,051 */\r
#define AUTOMATIC\r
-#define _STATIC_ static\r
+#define STATIC static\r
#define NULL_PTR ((void *)0)\r
\r
+#if defined(__GNUC__)\r
+#define CC_EXTENSION __extension__\r
+#elif defined(__CWCC__)\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
-ApplicationType GetApplicationID( void );\r
ISRType GetISRID( void );\r
StatusType GetActiveApplicationMode( AppModeType* mode);\r
\r
--- /dev/null
- /*\r
- * This type should map against the AUTOSAR OsISR type\r
- */\r
+/* -------------------------------- Arctic Core ------------------------------\r
+ * Arctic Core - the open source AUTOSAR platform http://arccore.com\r
+ *\r
+ * Copyright (C) 2009 ArcCore AB <contact@arccore.com>\r
+ *\r
+ * This source code is free software; you can redistribute it and/or modify it\r
+ * under the terms of the GNU General Public License version 2 as published by the\r
+ * Free Software Foundation; See <http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt>.\r
+ *\r
+ * This program is distributed in the hope that it will be useful, but\r
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\r
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License\r
+ * for more details.\r
+ * -------------------------------- Arctic Core ------------------------------*/\r
+\r
+#ifndef ISR_H_\r
+#define ISR_H_\r
+\r
+/*\r
+ * INCLUDE "RULES"\r
+ * Since this types and methods defined here are used by the drivers, they should\r
+ * include it. E.g. #include "isr.h"\r
+ *\r
+ * This file is also used internally by the kernel\r
+ *\r
+ *\r
+ * irq_types.h ( Vector enums )\r
+ * irq.h ( Interface )\r
+ *\r
+ * Problem:\r
+ * Os_Cfg.h needs types from isr.h\r
+ *\r
+ */\r
+\r
+/* ----------------------------[includes]------------------------------------*/\r
+/* ----------------------------[define]--------------------------------------*/\r
+\r
+#define ISR_TYPE_1 0\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
+ uint32 size; /* The size of the stack */\r
+} OsIsrStackType;\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
+typedef struct {\r
+ const char *name;\r
+ uint8_t core;\r
+ int16_t vector;\r
+ int16_t type;\r
+ int16_t priority;\r
+ void (*entry)();\r
+ uint32_t appOwner;\r
+ /* Mapped against OsIsrResourceRef */\r
+ uint32_t resourceMask;\r
+#if ( OS_USE_ISR_TIMING_PROT == STD_ON )\r
+ /* Mapped against OsIsrTimingProtection[C] */\r
+ OsIsrTimingProtectionType *timingProtPtr;\r
+#else\r
+ void *timingProtPtr;\r
+#endif\r
+} OsIsrConstType;\r
+\r
+/*\r
+ *\r
+ */\r
+typedef struct {\r
++ ISRType id;\r
+ OsIsrStackType stack;\r
+ int state;\r
+ const OsIsrConstType *constPtr;\r
+} OsIsrVarType;\r
+\r
+\r
+/* ----------------------------[functions]-----------------------------------*/\r
+\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
\r
\r
// +1 here.. easy to have a reference..\r
-#define GEN_TRUSTEDFUNCTIONS_LIST trusted_func_t os_cfg_trusted_list[SERVICE_CNT];\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 OsRomApplicationType rom_app_list[] =\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_APPLICATON( _id,_name,_trusted,_startuphook,_shutdownhook, \\r
- _errorhook,_isr_mask,_scheduletable_mask, _alarm_mask, \\r
- _counter_mask,_resource_mask,_message_mask ) \\r
++#define GEN_APPLICATION( _id,_name, _core, _trusted,_startuphook,_shutdownhook, _errorhook, \\r
+ _restart_task ) \\r
{ \\r
- .application_id = _id, \\r
+ .appId = _id, \\r
.name = _name, \\r
++ .core = _core, \\r
.trusted = _trusted, \\r
.StartupHook = _startuphook, \\r
.ShutdownHook = _shutdownhook, \\r
.ErrorHook = _errorhook, \\r
- .isr_mask = _isr_mask, \\r
- .scheduletable_mask = _scheduletable_mask, \\r
- .alarm_mask = _alarm_mask, \\r
- .counter_mask = _counter_mask, \\r
- .resource_mask = _resource_mask, \\r
- .message_mask = _message_mask, \\r
+ .restartTaskId = _restart_task \\r
}\r
\r
- #define GEN_TASK_HEAD const OsTaskConstType Os_TaskConstList[OS_TASK_CNT] =\r
-\r
-#define GEN_TASK_HEAD const OsRomPcbType rom_pcb_list[] =\r
++#define GEN_TASK_HEAD const OsTaskConstType Os_TaskConstList[OS_TASK_CNT]\r
\r
\r
\r
.scheduling = _scheduling, \\r
.resourceAccess = _resource_mask, \\r
.activationLimit = _activation_limit, \\r
+ .applOwnerId = _appl_owner, \\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
-//#define GEN_PCB_LIST() uint8_t pcb_list[PCB_T_SIZE*ARRAY_SIZE(rom_pcb_list)];\r
-#define GEN_PCB_LIST() OsPcbType pcb_list[ARRAY_SIZE(rom_pcb_list)];\r
++#endif\r
+ \r
\r
-#define GEN_RESOURCE_HEAD OsResourceType resource_list[] =\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
+\r
+#define GEN_RESOURCE_HEAD OsResourceType resource_list[OS_RESOURCE_CNT] =\r
\r
\r
/**\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[] =\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[] =\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
- Irq_Init();\r
++ Os_IsrInit();\r
\r
// Determine PostBuild configuration\r
internal_data.config = EcuM_DeterminePbConfiguration();\r
#include "arc.h"\r
#include "arch.h"\r
\r
+/* ----------------------------[private define]------------------------------*/\r
+/* ----------------------------[private macro]-------------------------------*/\r
+#define APPL_ID_TO_MASK(_x) (1<<(_x))\r
+\r
+/* ----------------------------[private typedef]-----------------------------*/\r
+/* ----------------------------[private function prototypes]-----------------*/\r
+/* ----------------------------[private variables]---------------------------*/\r
+#if OS_APPLICATION_CNT!=0\r
+OsAppVarType Os_AppVar[OS_APPLICATION_CNT];\r
+#endif\r
+\r
+/* ----------------------------[private functions]---------------------------*/\r
+/* ----------------------------[public functions]----------------------------*/\r
+\r
+\r
+/* @req OS547\r
+ * Availability of AllowAccess(): Available in Scalability Classes 3 and 4.\r
+ * @req OS536\r
+ * Availability of TerminateApplication(): Available in Scalability Classes 3 and 4.\r
+ * @req OS520\r
+ * Availability of CheckObjectOwnership():Available in Scalability Classes 3 and 4.\r
+ *\r
+ */\r
+\r
+\r
+#if (OS_USE_APPLICATIONS == STD_ON)\r
+\r
+/**\r
+ * This service determines the currently running OS-Application (a unique\r
+ * identifier has to be allocated to each application).\r
+ *
+ * @return <identifier of running OS-Application> or INVALID_OSAPPLICATION
+ */\r
+\r
+ApplicationType GetApplicationID( void ) {\r
+ return Os_Sys.currApplId;\r
+}\r
+\r
+\r
+/**\r
+ * A (trusted or non-trusted) OS-Application uses this service to call a trusted\r
+ * function\r
+ *
+ * @param FunctionIndex Index of the function to be called.
+ * @param FunctionParams Pointer to the parameters for the function -\r
+ * specified by the FunctionIndex - to be called.\r
+ * If no parameters are provided, a NULL pointer has\r
+ * to be passed.
+ * @return
+ */\r
+StatusType CallTrustedFunction( TrustedFunctionIndexType FunctionIndex,\r
+ TrustedFunctionParameterRefType FunctionParams ) {\r
+\r
+\r
+ return E_OK;\r
+}\r
+\r
+\r
+\r
+/**\r
+ * This service checks if a memory region is write/read/execute accessible\r
+ * and also returns information if the memory region is part of the stack\r
+ * space.\r
+ *
+ * @param ISRID ISR reference
+ * @param Address Start of memory area
+ * @param Size Size of memory area
+ * @return
+ */\r
+AccessType CheckISRMemoryAccess( ISRType isrId,\r
+ MemoryStartAddressType address,\r
+ MemorySizeType size )\r
+{\r
+ ptrdiff_t addr = (ptrdiff_t)address;\r
+ (void)addr;\r
+ (void)size;\r
+\r
+ if( isrId > OS_TASK_CNT ) {\r
+ return 0;\r
+ }\r
+ return 0;\r
+}\r
+/**\r
+ * This service checks if a memory region is write/read/execute accessible\r
+ * and also returns information if the memory region is part of the stack\r
+ * space.\r
+ *\r
+ * Check returned accesstype with:\r
+ * OSMEMORY_IS_READABLE(<AccessType>)\r
+ * OSMEMORY_IS_WRITEABLE(<AccessType>)\r
+ * OSMEMORY_IS_EXECUTABLE(<AccessType>)\r
+ * OSMEMORY_IS_STACKSPACE(<AccessType>)\r
+ *\r
+ * TODO: Not really sure what this function is actually good for? Add a use-case!\r
+ *
+ * @param TaskID Task reference
+ * @param Address Start of memory area
+ * @param Size Size of memory area
+ * @return
+ */\r
+AccessType CheckTaskMemoryAccess( TaskType taskId,\r
+ MemoryStartAddressType address,\r
+ MemorySizeType size )\r
+{\r
+ ptrdiff_t addr = (ptrdiff_t)address;\r
+ (void)addr;\r
+ (void)size;\r
+\r
+ /* @req OS270:\r
+ * if the Task reference <TaskID> in a call of CheckTaskMemoryAccess() is\r
+ * not valid, CheckTaskMemoryAccess() shall yield no access rights.\r
+ */\r
+ if( taskId > OS_TASK_CNT ) {\r
+ return 0;\r
+ }\r
+\r
+ /* TODO: Add body :) */\r
+ return 0;\r
+}\r
+\r
+\r
+/**\r
+ * This service determines if the OS-Applications, given by ApplID,\r
+ * is allowed to use the IDs of a Task, ISR, Resource, Counter,\r
+ * Alarm or Schedule Table in API calls.\r
+ *\r
+ * @param ApplID OS-Application identifier
+ * @param ObjectType Type of the following parameter
+ * @param object The object to be examined
+ * @return ACCESS if the ApplID has access to the object\r
+ * NO_ACCESS otherwise
+ */\r
+ObjectAccessType CheckObjectAccess( ApplicationType ApplId,\r
+ ObjectTypeType ObjectType,\r
+ uint32_t objectId )\r
+{\r
+ uint32 appMask = APPL_ID_TO_MASK(ApplId);\r
+ ObjectAccessType orv;\r
+ _Bool rv = 0;\r
+\r
+\r
+ /* @req OS423\r
+ * If in a call of CheckObjectAccess() the object to be examined\r
+ * is not avalid object OR <ApplID> is invalid OR <ObjectType> is\r
+ * invalid THEN CheckObjectAccess() shall return NO_ACCESS.\r
+ */\r
+ if( ApplId > OS_APPLICATION_CNT ) {\r
+ return NO_ACCESS;\r
+ }\r
+\r
+ /* @req OS272\r
+ * If the OS-Application <ApplID> in a call of CheckObjectAccess() has no\r
+ * access to the queried object, CheckObjectAccess() shall return NO_ACCESS.\r
+ *\r
+ * TODO: Could be that OS450 comes into play here....and then this is wrong.\r
+ */\r
+ if( Os_AppVar[ApplId].state != APPLICATION_ACCESSIBLE ) {\r
+ return NO_ACCESS;\r
+ }\r
+\r
+ /* TODO: check id */\r
+ switch( ObjectType ) {\r
+ case OBJECT_ALARM:\r
+ rv = ((OsAlarmType *)objectId)->accessingApplMask & (appMask);\r
+ break;\r
+ case OBJECT_COUNTER:\r
+ rv = ((OsCounterType *)objectId)->accessingApplMask & (appMask);\r
+ break;\r
+ case OBJECT_ISR:\r
+ /* TODO: Add more things here for missing objects */\r
+ break;\r
+ case OBJECT_MESSAGE:\r
+ case OBJECT_RESOURCE:\r
+ case OBJECT_SCHEDULETABLE:\r
+ break;\r
+ case OBJECT_TASK:\r
+ rv = ((OsCounterType *)objectId)->accessingApplMask & (appMask);\r
+ break;\r
+ default:\r
+ /* @req OS423 */\r
+ rv = NO_ACCESS;\r
+ break;\r
+ }\r
\r
- #if 0\r
+ orv = rv ? ACCESS : NO_ACCESS;\r
+\r
+ return orv;\r
+}\r
+\r
+/**\r
+ * This service determines to which OS-Application a given Task, ISR, Resource,\r
+ * Counter, Alarm or Schedule Table belongs\r
+ *
+ * @param ObjectType Type of the following parameter
+ * @param object The object to be examined\r
+ * @return The OS-Application to which the object ObjectType belongs or\r
+ * INVALID_OSAPPLICATION if the object does not exists
+ */\r
+ApplicationType CheckObjectOwnership( ObjectTypeType ObjectType,\r
+ uint32_t objectId )\r
+{\r
+ ApplicationType rv = INVALID_OSAPPLICATION;\r
+\r
+ switch( ObjectType ) {\r
+ case OBJECT_ALARM:\r
+ break;\r
+ case OBJECT_COUNTER:\r
+ break;\r
+ case OBJECT_ISR:\r
+ break;\r
+ case OBJECT_MESSAGE:\r
+ break;\r
+ case OBJECT_RESOURCE:\r
+ break;\r
+ case OBJECT_SCHEDULETABLE:\r
+ break;\r
+ case OBJECT_TASK:\r
- rv = Os_TaskGet(objectId)\r
+ if( objectId < OS_TASK_CNT ) {\r
- \r
- \r
- OsTaskVarTypeapplOwnerId\r
- if( objectId > OS_MAX )\r
- #endif\r
++ rv = Os_TaskGetApplicationOwner((TaskType)objectId);\r
+ }\r
+ break;\r
+ default:\r
+ break;\r
+ }\r
+\r
+ return rv;\r
+}\r
+\r
+\r
+/**\r
+ * This service terminates the OS-Application to which the calling Task/Category 2\r
+ * ISR/application specific error hook belongs.\r
+ *
+ * @param Application - The identifier of the OS-Application to be terminated.\r
+ * If the caller belongs to <Application> the call results in a\r
+ * self termination.\r
+ *\r
+ * @param RestartOption - Either RESTART for doing a restart of the\r
+ * OS-Application or NO_RESTART if OS-Application shall not be restarted.\r
+ *
+ * @return E_OK: No errors\r
+ * E_OS_ID: <Application> was not valid\r
+ * E_OS_VALUE: <RestartOption> was neither RESTART nor NO_RESTART\r
+ * E_OS_ACCESS: The caller does not have the right to terminate <Application>\r
+ * E_OS_STATE: The state of <Application> does not allow terminating <Application>
+ */\r
+StatusType TerminateApplication( ApplicationType applId, RestartType restartOption ) {\r
+ (void)applId;\r
+ (void)restartOption;\r
+ return E_OK;\r
+}\r
+\r
+\r
+/**\r
+ * This service sets the own state of an OS-Application from\r
+ * APPLICATION_RESTARTING to APPLICATION_ACCESSIBLE.\r
+ *
+ * @return E_OK : No errors\r
+ * E_OS_STATE : The OS-Application of the caller is in the wrong\r
+state
+ */\r
+StatusType AllowAccess( void ) {\r
+ ApplicationType applId = Os_Sys.currApplId;\r
+\r
+ /* @req OS497 */\r
+ if( Os_AppVar[applId].state != APPLICATION_RESTARTING ) {\r
+ return E_OS_STATE;\r
+ }\r
+\r
+ /* @req OS498 */\r
+ Os_AppVar[applId].state = APPLICATION_ACCESSIBLE;\r
+ return E_OK;\r
+}\r
+\r
+/**\r
+ * This service returns the current state of an OS-Application.\r
+ * SC: SC3 and SC4\r
+ *
+ * @param ApplId The OS-Application from which the state is requested
+ * @param Value The current state of the application
+ * @return E_OK: No errors, E_OS_ID: <Application> is not valid
+ */\r
+StatusType GetApplicationState( ApplicationType applId, ApplicationStateRefType value ) {\r
+\r
+ if(applId > OS_APPLICATION_CNT ) {\r
+ return E_OS_ID;\r
+ }\r
+\r
+ *value = Os_AppVar[applId].state;\r
+\r
+ return E_OK;\r
+}\r
+\r
+\r
+/**\r
+ * TODO: Move somewhere else
+ * @param mode
+ * @return
+ */\r
StatusType GetActiveApplicationMode( AppModeType* mode) {\r
- *mode = os_sys.appMode;\r
+ *mode = Os_Sys.appMode;\r
return E_OK;\r
}\r
+\r
++\r
+/**\r
+ *
+ */\r
+void Os_ApplStart( void ) {\r
+ uint16_t i;\r
+\r
+ /* Call startuphooks for all applications */\r
+ for(i=0;i<OS_APPLICATION_CNT;i++) {\r
+\r
+ Os_AppVar[i].state = APPLICATION_ACCESSIBLE;\r
+\r
+ if( Os_AppConst[i].StartupHook != NULL ) {\r
+ Os_AppConst[i].StartupHook();\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
+ Os_Sys.tick++;\r
\r
cPtr->val = Os_CounterAdd( cPtr->val, Os_CounterGetMaxValue(cPtr), 1 );\r
\r
* defined, see chapter 9.2)\r
* ... */\r
\r
- dest_pcb->ev_set |= Mask;\r
-\r
- if( (Mask & dest_pcb->ev_wait)\r
-#if defined(USE_KERNEL_EXTRA)\r
- /* Don't dispatch if target task is sleeping */\r
- && !(dest_pcb->state & ST_SLEEPING)\r
-#endif\r
-\r
- ) {\r
- assert(dest_pcb->state & ST_WAITING );\r
-\r
- Os_TaskMakeReady(dest_pcb);\r
-\r
- currPcbPtr = Os_TaskGetCurrent();\r
- /* Checking "4.6.2 Non preemptive scheduling" it does not dispatch if NON */\r
- if( (os_sys.int_nest_cnt == 0) &&\r
- (currPcbPtr->scheduling == FULL) &&\r
- (dest_pcb->prio > currPcbPtr->prio) &&\r
- (Os_SchedulerResourceIsFree()) )\r
- {\r
- Os_Dispatch(OP_SET_EVENT);\r
+ destPcbPtr->ev_set |= Mask;\r
+\r
+ if( (Mask & destPcbPtr->ev_wait) ) {\r
+ /* We have an event match */\r
+ if( destPcbPtr->state & ST_WAITING) {\r
+ Os_TaskMakeReady(destPcbPtr);\r
+\r
+ currPcbPtr = Os_TaskGetCurrent();\r
+ /* Checking "4.6.2 Non preemptive scheduling" it does not dispatch if NON */\r
+ if( (Os_Sys.intNestCnt == 0) &&\r
+ (currPcbPtr->constPtr->scheduling == FULL) &&\r
+ (destPcbPtr->activePriority > currPcbPtr->activePriority) &&\r
+ (Os_SchedulerResourceIsFree()) )\r
+ {\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
}\r
}\r
\r
/* NON standard type.\r
* Used for ROM based parameters.... TODO\r
*/\r
-typedef struct OsRomApplication {\r
- uint32 application_id;\r
+typedef struct OsApplication {\r
+ uint32 appId;\r
char name[16];\r
- uint8 trusted;\r
+ _Bool trusted;\r
++ uint8_t core;\r
\r
- /* hooks */\r
+ /* hooks, the names are StartupHook_<name>(), etc. */\r
void (*StartupHook)( void );\r
- void (*ShutdownHook)( Std_ReturnType Error );\r
- void (*ErrorHook)( Std_ReturnType Error );\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
- uint32 isr_mask;\r
- uint32 scheduletable_mask;\r
- uint32 alarm_mask;\r
- uint32 counter_mask;\r
- uint32 resource_mask;\r
- uint32 message_mask;\r
+#if OS_APPLICATION_CNT!=0\r
+extern OsAppVarType Os_AppVar[OS_APPLICATION_CNT];\r
+#endif\r
\r
-} OsRomApplicationType;\r
++uint8_t Os_ApplGetCore( ApplicationType appl );\r
+ \r
-#endif /* ( OS_SC1 == STD_ON ) || ( OS_SC4 == STD_ON ) */\r
+#endif /* (OS_USE_APPLICATIONS == STD_ON) */\r
\r
\r
#endif /* APPLICATION_H_ */\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
+\r
typedef uint16_t state_t;\r
\r
/* from Os.h types */\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
- * OsIsrResourceRef: 0..1 Reference to OsResource\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
- * OsIsrResourceLock[C] 0..1\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(OsPcb) pcb_list; // TASK\r
+// TAILQ_ENTRY(OsTaskVar) pcb_list; // TASK\r
/* ready list */\r
- TAILQ_ENTRY(OsPcb) ready_list; // TASK\r
-} OsPcbType;\r
+ TAILQ_ENTRY(OsTaskVar) ready_list; // TASK\r
+} OsTaskVarType;\r
+\r
+/*-----------------------------------------------------------------*/\r
+\r
\r
/*-----------------------------------------------------------------*/\r
\r
OP_TERMINATE_TASK = 8,\r
OP_SCHEDULE = 16,\r
OP_CHAIN_TASK = 32,\r
- OP_RELEASE_RESOURCE = 64,\r
+ OP_RELEASE_RESOURCE = 64\r
+ OP_SLEEP = 128,\r
++\r
} OpType ;\r
\r
-typedef struct sys_s {\r
+/*\r
+ * Global system structure\r
+ */\r
+typedef struct Os_Sys {\r
// OsApplicationType *curr_application;\r
/* Current running task*/\r
- OsPcbType *curr_pcb;\r
+ OsTaskVarType *currTaskPtr;\r
+\r
/* List of all tasks */\r
- OsPcbType *pcb_list;\r
+ OsTaskVarType *pcb_list;\r
\r
- OsPcbType *chainedPcbPtr;\r
+ OsTaskVarType *chainedPcbPtr;\r
/* Interrupt nested count */\r
- uint32 int_nest_cnt;\r
+ uint32 intNestCnt;\r
/* The current operation */\r
uint8_t op;\r
/* Ptr to the interrupt stack */\r
\r
uint32_t task_cnt;\r
\r
- /* List of PCB's to be put in ready list when timeout */\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
\r
\r
\r
-extern OsPcbType pcb_list[];\r
-extern const OsRomPcbType rom_pcb_list[];\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 OsPcbType * os_get_pcb( OsTaskidType pid ) {\r
- return &pcb_list[pid];\r
++static inline OsTaskVarType * Os_TaskGet( TaskType pid ) {\r
+ return &Os_TaskVarList[pid];\r
}\r
\r
-static inline const OsRomPcbType * os_get_rom_pcb( OsTaskidType pid ) {\r
- return &rom_pcb_list[pid];\r
++static inline ApplicationType Os_TaskGetApplicationOwner( TaskType id ) {\r
++ return Os_TaskGet(id)->constPtr->applOwnerId;\r
+ }\r
+ \r
-static inline OsPriorityType os_pcb_set_prio( OsPcbType *pcb, OsPriorityType new_prio ) {\r
++\r
+#if 0\r
+extern const OsTaskConstType Os_TaskConstList[];\r
+static inline const OsTaskConstType * os_get_rom_pcb( OsTaskidType pid ) {\r
+ return & Os_TaskConstList[pid];\r
+}\r
+#endif\r
+\r
+\r
+#if 0\r
+static inline OsPriorityType os_pcb_set_prio( OsTaskVarType *pcb, OsPriorityType new_prio ) {\r
OsPriorityType old_prio;\r
old_prio = pcb->prio;\r
pcb->prio = new_prio;\r
Os_IntCounterType Os_IntSuspendAllCnt;
Os_IntCounterType Os_IntSuspendOsCnt;
- extern void Os_CfgGetInterruptStackInfo( OsStackType *stack );
+/* ----------------------------[private functions]---------------------------*/
+/* ----------------------------[public functions]----------------------------*/
+
+extern uint32_t McuE_GetSystemClock( void );
+extern OsTickType OsTickFreq;
+
/**
* Copy rom pcb data(r_pcb) to ram data
void InitOS( void ) {
int i;
- OsPcbType *tmp_pcb;
- OsStackType int_stack;
+ OsTaskVarType *tmpPcbPtr;
- OsStackType intStack;
++ OsIsrStackType intStack;
init_os_called = 1;
Os_ArchInit();
// Assign pcb list and init ready queue
- os_sys.pcb_list = pcb_list;
- TAILQ_INIT(& os_sys.ready_head);
- TAILQ_INIT(& os_sys.pcb_head);
+ 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_CfgGetInterruptStackInfo(&int_stack);
++ Os_IsrGetStackInfo(&intStack);
// TODO: 16 is arch dependent
- os_sys.int_stack = int_stack.top + int_stack.size - 16;
+ Os_Sys.intStack = (void *)((size_t)intStack.top + (size_t)intStack.size - 16);
// Init counter.. with alarms and schedule tables
#if OS_COUNTER_CNT!=0
* 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"
-#if 0
+//#include "irq_config.h"
-#include <stdint.h>
-#include <stdlib.h>
-#include <assert.h>
-#include <sys/queue.h>
-#include <string.h>
-#include "internal.h"
+extern const uint8_t Os_VectorToIsr[NUMBER_OF_INTERRUPTS_AND_EXCEPTIONS];
+extern const OsIsrConstType Os_IsrConstList[OS_ISR_CNT];
+#if OS_ISR_MAX_CNT!=0
+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"
return h;
}
-#if 0
-typedef void (*Os_IsrEntryType)(void);
+//extern TaskType Os_AddTask( OsTaskVarType *pcb );
+
+//static uint8 stackTop = 0x42;
-typedef Os_IsrInfo_s {
- Os_IsrEntryType entry;
- uint32_t vector;
- uint8_t priority;
-} Os_IsrInfoType;
-#endif
-extern TaskType Os_AddTask( OsPcbType *pcb );
+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]);
+ }
+}
-static uint8 stackTop = 0x42;
/**
- * Creates an ISR dynamically
- * @param entry
- * @param prio
- * @param name
+ * Adds an ISR to a list of Isr's. The ISRType (id) is returned
+ * for the "created" ISR.
*
- * @return The PID of the ISR created
+ * @param isrPtr Pointer to const data holding ISR information.
+ * @return
*/
-TaskType Os_Arc_CreateIsr( void (*entry)(void ), uint8_t prio, const char *name )
-{
- OsPcbType *pcb = os_alloc_new_pcb();
- strncpy(pcb->name,name,TASK_NAME_SIZE);
- pcb->vector = -1;
- pcb->prio = prio;
- /* TODO: map to interrupt controller priority */
- assert(prio<=OS_TASK_PRIORITY_MAX);
- pcb->proc_type = PROC_ISR2;
- pcb->state = ST_SUSPENDED;
- pcb->entry = entry;
- pcb->stack.top = &stackTop;
-
- return Os_AddTask(pcb);
+ISRType Os_IsrAdd( const OsIsrConstType * restrict isrPtr ) {
+ ISRType id;
+
+ id = Os_Sys.isrCnt++;
+ /* We have no VAR entires for ISR1 */
+ 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;
+}
+
+const OsIsrConstType * Os_IsrGet( int16_t vector) {
+ return &Os_IsrConstList[Os_VectorToIsr[vector]];
+}
+
+#if 0
+void Os_IsrDisable( ISRType isr) {
+
}
+void Os_IsrEnable( ISRType isr) {
+
+}
+#endif
+
+
+/*
+ * Resources:
+ * Irq_VectorTable[]
+ * Irq_IsrTypeTable[]
+ * Irq_PriorityTable[]
+ *
+ * exception table
+ * interrupt table
+ *
+ * Usual HW resources.
+ * - prio in HW (ppc and arm (even cortex m4))
+ *
+ *
+ * TOOL GENERATES ALL
+ * Irq_VectorTable CONST
+ * Irq_IsrTypeTable CONST
+ * Irq_PriorityTable CONST Can probably be a table with ISR_MAX number
+ * of for a CPU with prio registers. For masking
+ * CPUs it's better to keep an array to that indexing
+ * can be used.
+ *
+ * The problem with this approach is that the tool needs to know everything.
+ *
+ * TOOL GENERATES PART
+ * Irq_VectorTable VAR Since we must add vectors later
+ * Irq_IsrTypeTable VAR Since we must add vectors later
+ * Irq_PriorityTable VAR
+ *
+ * We move the
+ *
+ */
+
+
+
/**
* Before we have proper editor for ISR2 use this function to add resources
* to an ISR2
}
#endif
++/*-----------------------------------------------------------------*/
++
++void Os_IsrGetStackInfo( OsIsrStackType *stack ) {
++ stack->top = Os_IsrStack;
++ stack->size = sizeof(Os_IsrStack);
++}
++
+
/**
* Handle ISR type 2 interrupts from interrupt controller.
*
// arg 2-blaj\r
// arg 3-debug : 0 \r
\r
-- sim.load mpc55xx_sim.dll 20000 0 1\r
- ;sim.load C:\projects\t32sim\Debug\mpc55xx_sim.dll 20000 0 0\r
-; sim.load &dll 0xfff84000 0\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
\r
projects / arc.git / commitdiff