{\r
// TODO: make switch here... for now just call func.\r
Irq_Enable();\r
- os_sys.curr_pcb->entry();\r
+ Os_Sys.curr_pcb->entry();\r
}\r
\r
void *Os_ArchGetStackPtr( void ) {\r
{\r
// TODO: make switch here... for now just call func.\r
Irq_Enable();\r
- os_sys.curr_pcb->entry();\r
+ Os_Sys.curr_pcb->entry();\r
}\r
\r
void *Os_ArchGetStackPtr( void ) {\r
{\r
// TODO: make switch here... for now just call func.\r
Irq_Enable();\r
- os_sys.curr_pcb->entry();\r
+ Os_Sys.curr_pcb->entry();\r
}\r
\r
void *Os_ArchGetStackPtr( void ) {\r
* -------------------------------- Arctic Core ------------------------------*/\r
\r
\r
-\r
-\r
-\r
-\r
-\r
-\r
+/* ----------------------------[includes]------------------------------------*/\r
#include <assert.h>\r
#include <string.h>\r
#include "Std_Types.h"\r
#include "Os.h"\r
#include "irq.h"\r
\r
+/* ----------------------------[private define]------------------------------*/\r
//#define USE_TRACE 1\r
//#define USE_LDEBUG_PRINTF 1\r
#include "debug.h"\r
\r
#define SYSCLOCK_SELECT_PLL 0x2\r
\r
+/* ----------------------------[private macro]-------------------------------*/\r
+\r
#if defined(CFG_MPC5567)\r
#define CALC_SYSTEM_CLOCK(_extal,_emfd,_eprediv,_erfd) \\r
( (_extal) * ((_emfd)+4) / (((_eprediv)+1)*(1<<(_erfd))) )\r
( (_extal) * ((_emfd)+16) / (((_eprediv)+1)*((_erfd)+1)) )\r
#endif\r
\r
-typedef void (*vfunc_t)();\r
+/* Development error macros. */\r
+#if ( MCU_DEV_ERROR_DETECT == STD_ON )\r
+#define VALIDATE(_exp,_api,_err ) \\r
+ if( !(_exp) ) { \\r
+ Det_ReportError(MODULE_ID_MCU,0,_api,_err); \\r
+ return; \\r
+ }\r
\r
-/* Function declarations. */\r
-static void Mcu_ConfigureFlash(void);\r
+#define VALIDATE_W_RV(_exp,_api,_err,_rv ) \\r
+ if( !(_exp) ) { \\r
+ Det_ReportError(MODULE_ID_MCU,0,_api,_err); \\r
+ return (_rv); \\r
+ }\r
+#else\r
+#define VALIDATE(_exp,_api,_err )\r
+#define VALIDATE_W_RV(_exp,_api,_err,_rv )\r
+#endif\r
\r
\r
+/* ----------------------------[private typedef]-----------------------------*/\r
+typedef void (*vfunc_t)();\r
+\r
typedef struct {\r
uint32 lossOfLockCnt;\r
uint32 lossOfClockCnt;\r
\r
} Mcu_GlobalType;\r
\r
-/* Development error macros. */\r
-#if ( MCU_DEV_ERROR_DETECT == STD_ON )\r
-#define VALIDATE(_exp,_api,_err ) \\r
- if( !(_exp) ) { \\r
- Det_ReportError(MODULE_ID_MCU,0,_api,_err); \\r
- return; \\r
- }\r
\r
-#define VALIDATE_W_RV(_exp,_api,_err,_rv ) \\r
- if( !(_exp) ) { \\r
- Det_ReportError(MODULE_ID_MCU,0,_api,_err); \\r
- return (_rv); \\r
- }\r
-#else\r
-#define VALIDATE(_exp,_api,_err )\r
-#define VALIDATE_W_RV(_exp,_api,_err,_rv )\r
-#endif\r
+/* ----------------------------[private function prototypes]-----------------*/\r
+static void Mcu_ConfigureFlash(void);\r
+/* ----------------------------[private variables]---------------------------*/\r
\r
// Global config\r
Mcu_GlobalType Mcu_Global =\r
.config = &McuConfigData[0],\r
};\r
\r
-//-------------------------------------------------------------------\r
+/* ----------------------------[private functions]---------------------------*/\r
+/* ----------------------------[public functions]----------------------------*/\r
+\r
\r
+/**\r
+ * ISR wh
+ */\r
static void Mcu_LossOfLock( void ) {\r
#if defined(USE_DEM)\r
Dem_ReportErrorStatus(MCU_E_CLOCK_FAILURE, DEM_EVENT_STATUS_FAILED);\r
\r
}\r
\r
-//-------------------------------------------------------------------\r
-static void Mcu_LossOfCLock( void ) {\r
+/**\r
+ *
+ */\r
+static void Mcu_LossOfClock( void ) {\r
\r
/* Should report MCU_E_CLOCK_FAILURE with DEM here */\r
\r
\r
//-------------------------------------------------------------------\r
\r
-void Mcu_Init(const Mcu_ConfigType *configPtr)\r
-{\r
- VALIDATE( ( NULL != configPtr ), MCU_INIT_SERVICE_ID, MCU_E_PARAM_CONFIG );\r
+void Mcu_Init(const Mcu_ConfigType *configPtr) {\r
+ IRQ_DECL_ISR1( PLL_SYNSR_LOLF, CPU_CORE0, 10, Mcu_LossOfLock );\r
+ IRQ_DECL_ISR1( PLL_SYNSR_LOCF, CPU_CORE0, 10, Mcu_LossOfClock );\r
\r
- if( !SIMULATOR() ) {\r
- Mcu_CheckCpu();\r
- }\r
+ VALIDATE( ( NULL != configPtr ), MCU_INIT_SERVICE_ID, MCU_E_PARAM_CONFIG );\r
\r
- memset(&Mcu_Global.stats,0,sizeof(Mcu_Global.stats));\r
+ if (!SIMULATOR()) {\r
+ Mcu_CheckCpu();\r
+ }\r
\r
+ memset(&Mcu_Global.stats, 0, sizeof(Mcu_Global.stats));\r
\r
- //\r
- // Setup memories\r
- //\r
- Mcu_ConfigureFlash();\r
+ //\r
+ // Setup memories\r
+ //\r
+ Mcu_ConfigureFlash();\r
\r
- Mcu_Global.config = configPtr;\r
- Mcu_Global.initRun = 1;\r
+ Mcu_Global.config = configPtr;\r
+ Mcu_Global.initRun = 1;\r
\r
- if( Mcu_Global.config->McuClockSrcFailureNotification == TRUE ){\r
- // Enable loss of lock interrupt\r
+ if (Mcu_Global.config->McuClockSrcFailureNotification == TRUE) {\r
+ // Enable loss of lock interrupt\r
\r
- Irq_AttachIsr1(Mcu_LossOfLock, NULL, PLL_SYNSR_LOLF,10 );\r
+ Irq_Attach( &IRQ_NAME(PLL_SYNSR_LOLF) );\r
+// Irq_AttachIsr1(Mcu_LossOfLock, NULL, PLL_SYNSR_LOLF, 10);\r
#if defined(CFG_MPC5516)\r
-// FMPLL.SYNCR.B.LOCIRQ = 1; TODO: Kolla denna bortkommentering med Mårten.\r
- FMPLL.ESYNCR2.B.LOLIRQ = 1;\r
+ FMPLL.ESYNCR2.B.LOLIRQ = 1;\r
#elif defined(CFG_MPC5554) || defined(CFG_MPC5567)\r
- FMPLL.SYNCR.B.LOLIRQ = 1;\r
+ FMPLL.SYNCR.B.LOLIRQ = 1;\r
#endif\r
- Irq_AttachIsr1(Mcu_LossOfCLock, NULL, PLL_SYNSR_LOCF,10 );\r
+\r
+ Irq_Attach( &IRQ_NAME(PLL_SYNSR_LOLF));\r
+// Irq_AttachIsr1(Mcu_LossOfClock, NULL, PLL_SYNSR_LOCF, 10);\r
#if defined(CFG_MPC5516)\r
-// FMPLL.SYNCR.B.LOCIRQ = 1; TODO: Kolla denna bortkommentering med Mårten.\r
- FMPLL.ESYNCR2.B.LOCIRQ = 1;\r
+ FMPLL.ESYNCR2.B.LOCIRQ = 1;\r
#elif defined(CFG_MPC5554) || defined(CFG_MPC5567)\r
- FMPLL.SYNCR.B.LOCIRQ = 1;\r
+ FMPLL.SYNCR.B.LOCIRQ = 1;\r
#endif\r
- }\r
+ }\r
}\r
//-------------------------------------------------------------------\r
\r
\r
/**\r
* Get the peripheral clock in Hz for a specific device\r
+ *
+ * @param type
+ * @return
*/\r
-\r
uint32_t McuE_GetPeripheralClock(McuE_PeriperalClock_t type)\r
{\r
#if defined(CFG_MPC5567)\r
*/\r
void Os_SysTickInit( void ) {\r
TaskType tid;\r
+#if 1\r
+ IRQ_DECL_ISR2("MyIsr",10,CPU_CORE0, 10,MyIsr,HAVE_SC2_SC4(RES_ID_1),HAVE_SC2_SC4(timing));\r
+\r
+#else\r
tid = Os_Arc_CreateIsr(OsTick,6/*prio*/,"OsTick");\r
Irq_AttachIsr2(tid,NULL,7);\r
+#endif\r
}\r
\r
/**\r
\r
// Assume that regs[0] is setup before and contains the settings\r
// to switch to user mode.\r
- register uint32_t msr asm("r3") = os_sys.curr_pcb->regs[0];\r
- register void *ea asm("r4") = (void *) os_sys.curr_pcb->entry;\r
+ register uint32_t msr asm("r3") = Os_Sys.curr_pcb->regs[0];\r
+ register void *ea asm("r4") = (void *) Os_Sys.curr_pcb->entry;\r
\r
// Do the switch\r
asm volatile(\r
#else\r
// TODO: This really depends on if scheduling policy\r
Irq_Enable();\r
- os_sys.curr_pcb->entry();\r
+ Os_Sys.curr_pcb->entry();\r
#endif\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
+#include <stdint.h>\r
\r
-static void dump_exception_regs( uint32_t *regs );\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
\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
INTC.MCR.B.VTES = 0; // 4 byte offset between entries\r
#endif\r
\r
-\r
- // Pointless in software vector more???\r
-#if 0\r
- // Check alignment requirements for the INTC table\r
- assert( (((uint32_t)&Irq_VectorTable[0]) & 0x7ff) == 0 );\r
- #if defined(CFG_MPC5516)\r
- INTC.IACKR_PRC0.R = (uint32_t) & Irq_VectorTable[0]; // Set INTC ISR vector table\r
- #elif defined(CFG_MPC5554) || defined(CFG_MPC5567)\r
- INTC.IACKR.R = (uint32_t) & Irq_VectorTable[0]; // Set INTC ISR vector table\r
- #endif\r
-#endif\r
// Pop the FIFO queue\r
for (int i = 0; i < 15; i++)\r
{\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
// 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
- }\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
-\r
-\r
static inline int osPrioToCpuPio( uint8_t prio ) {\r
assert(prio<32);\r
return prio>>1; // Os have 32 -> 16\r
\r
\r
\r
+#if 0\r
/**\r
* Attach an ISR type 1 to the interrupt controller.\r
*\r
}\r
\r
}\r
+#endif\r
\r
+/**\r
+ *
+ * @param isrPtr
+ * @param type
+ * @param int_ctrl
+ */\r
+ISRType Irq_Attach( const OsIsrType_CONST *isrPtr ) {\r
+// Os_Sys.isrCnt\r
+ uint32_t vector = isrPtr->vector;\r
+\r
+ Irq_VectorTable[vector] = (uintptr_t)isrPtr;\r
+// Irq_IsrTypeTable[vector] = type;\r
+\r
+ if (vector < INTC_NUMBER_OF_INTERRUPTS) {\r
+ Irq_SetPriority(CPU_CORE0,vector + IRQ_INTERRUPT_OFFSET, osPrioToCpuPio(isrPtr->prio));\r
+ } else if ((vector >= CRITICAL_INPUT_EXCEPTION)\r
+ && (vector<= DEBUG_EXCEPTION)) {\r
+ } else {\r
+ /* Invalid vector! */\r
+ assert(0);\r
+ }\r
+ return 0;\r
+}\r
+\r
+#if 0\r
/**\r
* Attach a ISR type 2 to the interrupt controller.\r
*\r
assert(0);\r
}\r
}\r
-\r
-#endif /* defined(USE_KERNEL) */\r
-\r
-#if !defined(USE_KERNEL)\r
-/**\r
- * Installs a vector in intc vector table. It also sets the priority in the INTC\r
- * internal registers.\r
- *\r
- * This does NOT use the kernel\r
- *\r
- * @param func The function to install\r
- * @param vector INTC vector to install it to\r
- * @param priority INTC priority. 0 - Low prio. 15- Highest( NMI )\r
- * @param cpu\r
- */\r
-\r
-void Irq_InstallVector(void(*func)(), IrqType vector,\r
- uint8_t priority, Cpu_t cpu)\r
-{\r
- VALIDATE( ( 1 == Mcu_Global.initRun ), MCU_INTCVECTORINSTALL_SERVICE_ID, MCU_E_UNINIT );\r
- DEBUG(DEBUG_LOW,"Installing INTC vector:%d,prio:%d,cpu,%d\n",vector,priority,cpu);\r
- Irq_VectorTable[vector] = func;\r
-\r
- if (vector <= MLB_SERVICE_REQUEST)\r
- {\r
- INTC.PSR[vector].B.PRC_SEL = cpu;\r
- INTC.PSR[vector].B.PRI = priority;\r
-\r
- Irq_VectorTable[vector] = func;\r
- } else if ((vector >= CRITICAL_INPUT_EXCEPTION)\r
- && (vector <= DEBUG_EXCEPTION))\r
- {\r
- Irq_VectorTable[vector] = func;\r
- } else\r
- {\r
- /* Invalid vector! */\r
- assert(0);\r
- }\r
-}\r
#endif\r
\r
\r
-\r
/**\r
* Generates a soft interrupt\r
* @param vector\r
// ExceptionSave(srr0,srr1,esr,mcsr,dear;)\r
// CSRR0, CSSR1\r
// Nothing more\r
- dump_exception_regs(regs);\r
+ dumpExceptionRegs(regs);\r
while (1);\r
}\r
\r
{\r
// CSRR0, CSSR1\r
// MCSR - Source of machine check\r
- dump_exception_regs(regs);\r
+ dumpExceptionRegs(regs);\r
while (1);\r
}\r
// Data Storage Interrupt\r
{\r
// SRR0, SRR1\r
// ESR - lots of stuff\r
- dump_exception_regs(regs);\r
+ dumpExceptionRegs(regs);\r
while (1);\r
}\r
\r
{\r
// SRR0, SRR1\r
// ESR - lots of stuff\r
- dump_exception_regs(regs);\r
+ dumpExceptionRegs(regs);\r
while (1);\r
}\r
\r
// SRR0, SRR1\r
// ESR - lots of stuff\r
// DEAR - Address of load store that caused the exception\r
- dump_exception_regs(regs);\r
+ dumpExceptionRegs(regs);\r
while (1);\r
}\r
\r
{\r
// SRR0, SRR1\r
// ESR - lots of stuff\r
- dump_exception_regs(regs);\r
+ dumpExceptionRegs(regs);\r
while (1);\r
}\r
\r
void IVOR7Exception (uint32_t *regs)\r
{\r
// SRR0, SRR1\r
- dump_exception_regs(regs);\r
+ dumpExceptionRegs(regs);\r
while (1);\r
}\r
\r
{\r
// SRR0, SRR1\r
// ESR\r
- dump_exception_regs(regs);\r
+ dumpExceptionRegs(regs);\r
while (1);\r
}\r
\r
void IVOR9Exception (uint32_t *regs)\r
{\r
// Does not happen on e200\r
- dump_exception_regs(regs);\r
+ dumpExceptionRegs(regs);\r
while (1);\r
}\r
#if 0\r
void IVOR11Exception (uint32_t *regs)\r
{\r
// SRR0, SRR1\r
- dump_exception_regs(regs);\r
+ dumpExceptionRegs(regs);\r
while (1);\r
}\r
\r
void IVOR12Exception (uint32_t *regs)\r
{\r
// SRR0, SRR1\r
- dump_exception_regs(regs);\r
+ dumpExceptionRegs(regs);\r
while (1);\r
}\r
\r
{\r
// SRR0, SRR1\r
// ESR - MIF set, All others cleared\r
- dump_exception_regs(regs);\r
+ dumpExceptionRegs(regs);\r
while (1);\r
}\r
\r
void IVOR15Exception (uint32_t *regs)\r
{\r
// Debug\r
- dump_exception_regs(regs);\r
+ dumpExceptionRegs(regs);\r
while (1);\r
}\r
\r
\r
\r
\r
-static void dump_exception_regs( uint32_t *regs ) {\r
+static void dumpExceptionRegs( uint32_t *regs ) {\r
exc_stack_t *r = (exc_stack_t *)regs;\r
\r
LDEBUG_PRINTF("sp %08x srr0 %08x srr1 %08x\n",r->sp,r->srr0,r->srr1);\r
}\r
\r
#else\r
-static void dump_exception_regs( uint32_t *regs ) {\r
+static void dumpExceptionRegs( uint32_t *regs ) {\r
}\r
#endif\r
\r
-#if !defined(USE_KERNEL)\r
-func_t Irq_VectorTable[NUMBER_OF_INTERRUPTS_AND_EXCEPTIONS] __attribute__ ((aligned (0x800))) = {\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 00 - 04 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 05 - 09 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 10 - 14 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 15 - 19 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 20 - 24 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 25 - 29 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 30 - 34 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 35 - 39 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 40 - 44 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 45 - 49 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 50 - 54 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 55 - 59 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 60 - 64 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 55 - 69 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 70 - 74 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 75 - 79 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 80 - 84 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 85 - 89 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 90 - 94 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 95 - 99 */\r
-\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 100 - 104 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 105 - 109 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 110 - 114 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 115 - 119 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 120 - 124 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 125 - 129 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 130 - 134 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 135 - 139 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 140 - 144 */\r
- dummy, dummy, dummy, dummy, dummy /* PIT1 */, /* ISRs 145 - 149 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 150 - 154 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 155 - 159 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 160 - 164 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 155 - 169 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 170 - 174 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 175 - 179 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 180 - 184 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 185 - 189 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 190 - 194 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 195 - 199 */\r
-\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 200 - 204 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 205 - 209 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 210 - 214 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 215 - 219 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 220 - 224 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 225 - 229 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 230 - 234 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 235 - 239 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 240 - 244 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 245 - 249 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 250 - 254 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 255 - 259 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 260 - 264 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 255 - 269 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 270 - 274 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 275 - 279 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 280 - 284 */\r
- dummy, dummy, dummy, dummy, dummy, /* ISRs 285 - 289 */\r
- dummy, dummy, dummy, dummy, /* ISRs 290 - 293 */\r
-\r
- /* Some reserved vectors between INC interrupts and exceptions. */\r
- dummy, /* INTC_NUMBER_OF_INTERRUPTS */\r
-\r
- dummy, dummy, dummy, dummy, dummy,\r
- dummy, dummy, dummy, dummy, dummy,\r
- dummy, dummy, dummy, dummy, dummy,\r
- dummy, dummy, dummy, dummy, dummy,\r
- dummy, dummy, dummy, dummy, dummy,\r
-\r
- IVOR0Exception, /* CRITICAL_INPUT_EXCEPTION, */\r
- IVOR1Exception, /* MACHINE_CHECK_EXCEPTION */\r
- IVOR2Exception, /* DATA_STORAGE_EXCEPTION */\r
- IVOR3Exception, /* INSTRUCTION_STORAGE_EXCEPTION */\r
- dummy, /* EXTERNAL_INTERRUPT */\r
- /* This is the place where the "normal" interrupts will hit the CPU... */\r
- IVOR5Exception, /* ALIGNMENT_EXCEPTION */\r
- IVOR6Exception, /* PROGRAM_EXCEPTION */\r
- IVOR7Exception, /* FLOATING_POINT_EXCEPTION */\r
- IVOR8Exception, /* SYSTEM_CALL_EXCEPTION */\r
- dummy, /* AUX_EXCEPTION Not implemented in MPC5516. */\r
- dummy, /* DECREMENTER_EXCEPTION */\r
- IVOR11Exception, /* FIXED_INTERVAL_TIMER_EXCEPTION */\r
- IVOR12Exception, /* WATCHDOG_TIMER_EXCEPTION */\r
- IVOR13Exception, /* DATA_TLB_EXCEPTION */\r
- IVOR14Exception, /* INSTRUCTION_TLB_EXCEPTION */\r
- IVOR15Exception, /* DEBUG_EXCEPTION */\r
-};\r
-\r
-void dummy (void) {\r
- while (1){\r
- /* TODO: Rename and check for what spurious interrupt have happend */\r
- };\r
- }\r
-\r
-#endif\r
-\r
\r
/* Add data field */\r
mystrcat(buf, JSON_ListStart);\r
- TAILQ_FOREACH(iterPcbPtr,& os_sys.pcb_head,pcb_list) {\r
+ TAILQ_FOREACH(iterPcbPtr,& Os_Sys.pcb_head,pcb_list) {\r
if(iterPcbPtr->proc_type < 4)\r
{\r
if(first){\r
\r
/* Add data field */\r
char *arg = command->arguments + 1; /* add 1 for " */\r
- TAILQ_FOREACH(iterPcbPtr,& os_sys.pcb_head,pcb_list) {\r
+ TAILQ_FOREACH(iterPcbPtr,& Os_Sys.pcb_head,pcb_list) {\r
if(strncmp(arg, iterPcbPtr->name, strlen(command->arguments)-2) == 0)\r
{\r
break;\r
#define INVALID_OSAPPLICATION (-1)\r
\r
/* TODO, I have no idea what this should be*/\r
+#if (OS_SC3==STD_ON) || (OS_SC4==STD_ON)\r
typedef sint32 ApplicationType;\r
\r
+typedef enum {\r
+ APPLICATION_ACCESSIBLE,\r
+ APPLICATION_RESTARTING,\r
+ APPLICATION_TERMINATED\r
+} ApplicationStateType;\r
+\r
+typedef ApplicationStateType *ApplicationStateRefType;\r
+#endif\r
+\r
/* See oil config for defines */\r
typedef sint32 AppModeType;\r
\r
/*\r
* Class 2,3 and 4 API\r
*/\r
+#if (OS_SC3==STD_ON) || (OS_SC4==STD_ON)\r
ApplicationType GetApplicationID( void );\r
AccessType CheckISRMemoryAccess( ISRType ISRID,\r
MemoryStartAddressType Address,\r
MemoryStartAddressType Address,\r
MemorySizeType Size );\r
\r
+ObjectAccessType CheckObjectAccess( ApplicationType ApplID, ObjectTypeType ObjectType, uintptr_t objPtr);\r
+ApplicationType CheckObjectOwnership( ObjectTypeType ObjectType, uintptr_t objPtr );\r
+StatusType TerminateApplication( ApplicationType Application, RestartType RestartOption );\r
+StatusType AllowAccess( void );\r
+StatusType GetApplicationState( ApplicationType Application, ApplicationStateRefType Value );\r
StatusType CallTrustedFunction( TrustedFunctionIndexType FunctionIndex,\r
TrustedFunctionParameterRefType FunctionParams );\r
+#endif\r
\r
StatusType GetTaskID( TaskRefType TaskID );\r
StatusType GetTaskState( TaskType task_id, TaskStateRefType state);\r
#define ISR_TYPE_1 0\r
#define ISR_TYPE_2 1\r
\r
-typedef _Bool IsrType;\r
+typedef struct {\r
+ char name[16];\r
+ uint8_t prio;\r
+ uint8_t core;\r
+ int vector; // ISR\r
+ void (*entry)();\r
+} OsIsrType_CONST;\r
+\r
+#define IRQ_DECL_ISR1(_vector, _core, _prio, _entry ) \\r
+ const OsIsrType_CONST IrqVector ## _ ## _vector = { \\r
+ .name = "", \\r
+ .prio = (_prio), \\r
+ .vector = (_vector), \\r
+ .entry = (_entry), \\r
+ .core = (_core) \\r
+ }\r
+\r
+\r
+#if (OS_SC2==STD_ON) || (OS_SC4==STD_ON)\r
+#define HAVE_SC2_SC4(_value) _value\r
+#else\r
+#define HAVE_SC2_SC4(_value)\r
+#endif\r
+\r
+#define IRQ_NAME(_vector) IrqVector ## _ ## _vector\r
+\r
+#define IRQ_DECL_ISR2_TIMING_PROT( \\r
+ _name, \\r
+ _max_all_interrupt_lock_time, \\r
+ _exeution_budget, \\r
+ _os_interrupt_lock_budget, \\r
+ _time_frame, \\r
+ _resource_lock_list )\r
+\r
+#define IRQ_DECL_ISR2(_name, _vector, _core, _prio, _entry, _resource_mask, _timing_prot)\r
+\r
+/* Example:\r
+ * IRQ_DECL_ISR2_RESOURCE(res2, RES_ID_2, 500000U ); // Max 50us\r
+ * IRQ_DECL_ISR2_TIMING_PROT(timing,0,0,0,0,res2);\r
+ * IRQ_DECL_ISR2("MyIsr",10,10,MyIsr,HAVE_SC2_SC4(RES_ID_1),HAVE_SC2_SC4(timing));\r
+ *
+ */\r
+\r
+\r
+\r
+// typedef _Bool IsrType;\r
\r
/**\r
* Init the interrupt controller\r
*/\r
void *Irq_Entry( void *stack_p );\r
#endif\r
+\r
+ISRType Irq_Attach( const OsIsrType_CONST *isrPtr );\r
/**\r
* Attach an ISR type 1 to the interrupt controller.\r
*\r
* @param vector\r
* @param type\r
*/\r
-static inline void Irq_SetIsrType( IrqType vector, IsrType type ) {\r
+static inline void Irq_SetIsrType( IrqType vector, int8_t type ) {\r
Irq_IsrTypeTable[vector] = type;\r
}\r
\r
* @return 0 - Isr1\r
* 1 - Isr2\r
*/\r
-static inline IsrType Irq_GetIsrType( IrqType vector ) {\r
+static inline int8_t Irq_GetIsrType( IrqType vector ) {\r
return Irq_IsrTypeTable[vector];\r
}\r
\r
#endif\r
\r
/*-----------------------------------------------------------------*/\r
+#if 0\r
#if ( OS_SC3 == STD_ON) || ( OS_SC4==STD_ON)\r
-int Os_CfgGetApplCnt(void) {\r
- return APPLICATION_CNT;\r
-}\r
\r
-OsRomApplicationType *Os_CfgGetApplObj( ApplicationType application_id ) {\r
+OsRomApplicationType *Os_CfgGetApplObj( ApplicationType appId ) {\r
return &rom_app_list[application_id];\r
}\r
#endif\r
+#endif\r
\r
/*-----------------------------------------------------------------*/\r
\r
\r
#if ( OS_SC3 == STD_ON) || ( OS_SC4 == STD_ON)\r
uint32 Os_CfgGetServiceCnt( void ) {\r
- return SERVICE_CNT;\r
+ return OS_SERVICE_CNT;\r
}\r
#endif\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 OsRomApplicationType rom_app_list[] =\r
+#define GEN_APPLICATION_HEAD const OsAppConstType Os_AppConst[OS_APP_CNT] =\r
\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
+\r
+#define APP_ALARM_LIST(_id,...) const uint8_t Os_AppAlarmList ## _id[] = {__VA_ARGS__}\r
+#define APP_COUNTER(_id,...) const uint8_t Os_AppCounterList ## _id = { __VA_ARGS__ }\r
+#define APP_ISR_LIST(_id,...)\r
+#define APP_RESOURCE_LIST(_id,...)\r
+#define APP_SCHTBL_LIST(_id,...)\r
+#define APP_TASK_LIST(_id,...) const uint8_t Os_AppTaskList ## _id = { __VA_ARGS__ };\r
+\r
+#define APP_TASK_NAME(_id) (Os_AppTaskList ## _id)\r
+#define APP_ALARM_NAME(_id) (Os_AppAlarmList ## _id)\r
+#define APP_COUNTER_NAME(_id) (Os_AppCounterList ## _id)\r
+\r
+\r
+#define GEN_APPLICATION( _id,_name,_trusted,_startuphook,_shutdownhook, _errorhook, \\r
+ _alarm_list,_counter_list,_isr_list,_resource_list, \\r
+ _schtbl_list,_task_list, _restart_task ) \\r
{ \\r
- .application_id = _id, \\r
+ .appId = _id, \\r
.name = _name, \\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
+ .alarmRef = _alarm_list, \\r
+ .counterRef = _counter_list, \\r
+ .isrRef = _isr_list, \\r
+ .resourceRef = _resource_list, \\r
+ .schtblRef = _schtbl_list, \\r
+ .taskRef = _task_list, \\r
+ .restartTaskId = _restart_task \\r
}\r
\r
\r
\r
\r
#if ( OS_SC3 == STD_ON) || ( OS_SC4 == STD_ON)\r
-#error OLD or NOT implemented\r
#define GEN_HOOKS( _startup, _protection, _shutdown, _error, _pretask, _posttask ) \\r
struct OsHooks os_conf_global_hooks = { \\r
.StartupHook = _startup, \\r
\r
#endif\r
\r
+#if 0\r
+typedef union {\r
+ void (*isr1)(void); /* ISR1 is just a function call */\r
+\r
+} ;\r
+#endif\r
\r
#define GEN_IRQ_VECTOR_TABLE_HEAD \\r
- void * Irq_VectorTable[NUMBER_OF_INTERRUPTS_AND_EXCEPTIONS] =\r
+ uintptr_t Irq_VectorTable[NUMBER_OF_INTERRUPTS_AND_EXCEPTIONS] =\r
\r
#define GEN_IRQ_ISR_TYPE_TABLE_HEAD \\r
uint8_t Irq_IsrTypeTable[NUMBER_OF_INTERRUPTS_AND_EXCEPTIONS] =\r
# Warnings\r
cflags-y += -Wall\r
#cflags-y += -Winline # warn if inline failed\r
-#cflags-y += -pedantic\r
+cflags-y += -pedantic\r
\r
# Conformance\r
cflags-y += -fno-strict-aliasing\r
if (alarmPtr->autostartPtr != NULL) {\r
const OsAlarmAutostartType *autoPtr = alarmPtr->autostartPtr;\r
\r
- if (os_sys.appMode & autoPtr->appModeRef) {\r
+ if (Os_Sys.appMode & autoPtr->appModeRef) {\r
if (autoPtr->autostartType == ALARM_AUTOSTART_ABSOLUTE) {\r
SetAbsAlarm(j, autoPtr->alarmTime, autoPtr->cycleTime);\r
} else {\r
* for more details.\r
* -------------------------------- Arctic Core ------------------------------*/\r
\r
+/* ----------------------------[includes]------------------------------------*/\r
+\r
#include <stdlib.h>\r
#include "Os.h"\r
\r
#include "arc.h"\r
#include "arch.h"\r
\r
+/* ----------------------------[private define]------------------------------*/\r
+/* ----------------------------[private macro]-------------------------------*/\r
+/* ----------------------------[private typedef]-----------------------------*/\r
+/* ----------------------------[private function prototypes]-----------------*/\r
+/* ----------------------------[private variables]---------------------------*/\r
+#if OS_APP_CNT!=0\r
+const OsAppVarType Os_AppVar[OS_APP_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_SC3==STD_ON)||(OS_SC4_STD_ON))\r
+\r
+/* See 8.4.4 */\r
+AccessType CheckISRMemoryAccess( ISRType ISRID,\r
+ MemoryStartAddressType Address,\r
+ MemorySizeType Size )\r
+{\r
+ // get hold of application memory space\r
+\r
+\r
+}\r
+\r
+AccessType CheckTaskMemoryAccess( TaskType TaskID,\r
+ MemoryStartAddressType Address,\r
+ MemorySizeType Size )\r
+{\r
+\r
+\r
+}\r
+\r
+\r
+/**\r
+ * This service determines if the OS-Applications, given by ApplID, is allowed to\r
+ * use the IDs of a Task, ISR, Resource, Counter, Alarm or Schedule Table in API calls.\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
+ void *object )\r
+{\r
+ uint32 app_mask = (1<<ApplID);\r
+ uint32 rv;\r
+\r
+ /* TODO: check id */\r
+ switch( ObjectType ) {\r
+ case OBJECT_ALARM:\r
+ rv = ((OsAlarmType *)object)->app_mask & (app_mask);\r
+ break;\r
+ case OBJECT_COUNTER:\r
+ rv = ((OsCounterType *)object)->app_mask & (app_mask);\r
+ break;\r
+ case OBJECT_ISR:\r
+ break;\r
+ case OBJECT_MESSAGE:\r
+ case OBJECT_RESOURCE:\r
+ case OBJECT_SCHEDULETABLE:\r
+ break;\r
+ case OBJECT_TASK:\r
+ rv = ((OsCounterType *)object)->app_mask & (app_mask);\r
+ break;\r
+ default:\r
+ break;\r
+ }\r
+\r
+ return ACCESS;\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
+ void *object )\r
+{\r
+ switch( ObjectType ) {\r
+ case OBJECT_ALARM:\r
+ case OBJECT_COUNTER:\r
+ case OBJECT_ISR:\r
+ case OBJECT_MESSAGE:\r
+ case OBJECT_RESOURCE:\r
+ case OBJECT_SCHEDULETABLE:\r
+ case OBJECT_TASK:\r
+ default:\r
+ break;\r
+ }\r
+\r
+ return INVALID_OSAPPLICATION;\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 Application, RestartType RestartOption ) {\r
+\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
+\r
+ /* @req OS497 */\r
+ if( Os_AppVar[AppId].state != APPLICATION_RESTARTING ) {\r
+ return E_OS_STATE;\r
+ }\r
+\r
+ /* @req OS498 */\r
+ Os_AppVar[AppId].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 AppId 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 appId, ApplicationStateRefType value ) {\r
+ if(appId > OS_APP_CNT ) {\r
+ return E_OS_ID;\r
+ }\r
+\r
+ *value = Os_AppVar[AppId].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
+#endif\r
void asm_foo(void) {\r
DECLARE(PCB_STACK_CURR_P, offsetof(OsPcbType, stack));\r
DECLARE(PCB_ENTRY_P, offsetof(OsPcbType, entry));\r
- DECLARE(SYS_CURR_PCB_P, offsetof(sys_t, curr_pcb));\r
- DECLARE(SYS_INT_NEST_CNT, offsetof(sys_t, int_nest_cnt));\r
- DECLARE(SYS_INT_STACK, offsetof(sys_t, int_stack));\r
+ DECLARE(SYS_CURR_PCB_P, offsetof(Os_SysType, curr_pcb));\r
+ DECLARE(SYS_INT_NEST_CNT, offsetof(Os_SysType, int_nest_cnt));\r
+ DECLARE(SYS_INT_STACK, offsetof(Os_SysType, int_stack));\r
}\r
\r
\r
if( cPtr->type == COUNTER_TYPE_HARD ) {\r
if( cPtr->driver == NULL ) {\r
/* It's OSINTERNAL */\r
- *tick_ref = os_sys.tick;\r
+ *tick_ref = Os_Sys.tick;\r
} else {\r
#if 0\r
/* We support only GPT for now */\r
\r
OsCounterType *cPtr = Os_CfgGetCounter(Os_Arc_OsTickCounter);\r
\r
- os_sys.tick++;\r
+ Os_Sys.tick++;\r
\r
cPtr->val = Os_CounterAdd( cPtr->val, Os_CounterGetMaxValue(cPtr), 1 );\r
\r
- // os_sys.tick = cPtr->val;\r
+ // Os_Sys.tick = cPtr->val;\r
#if OS_ALARM_CNT!=0\r
Os_AlarmCheck(cPtr);\r
#endif\r
\r
OS_DEBUG(D_EVENT,"# WaitEvent %s\n",Os_TaskGetCurrent()->name);\r
\r
- if( os_sys.int_nest_cnt != 0 ) {\r
+ if( Os_Sys.int_nest_cnt != 0 ) {\r
rv = E_OS_CALLEVEL;\r
goto err;\r
}\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
+ if( (Os_Sys.int_nest_cnt == 0) &&\r
(currPcbPtr->scheduling == FULL) &&\r
(dest_pcb->prio > currPcbPtr->prio) &&\r
(Os_SchedulerResourceIsFree()) )\r
StatusType rv = E_OK;\r
OsPcbType *pcb;\r
\r
- if( os_sys.int_nest_cnt != 0 ) {\r
+ if( Os_Sys.int_nest_cnt != 0 ) {\r
rv = E_OS_CALLEVEL;\r
goto err;\r
}\r
} OsAlarmAutostartType;\r
\r
/* STD container : OsAlarm\r
- * OsAlarmAccessionApplication: 0..* Ref to OS application\r
+ * OsAlarmAccessingApplication: 0..* Ref to OS application\r
* OsAlamCounterRef: 1 Ref to counter\r
* OsAlarmAction[C] 1 Action when alarm expires\r
* OsAlarmAutostart[C] 0..1 Autostart\r
/* Reference to counter */\r
struct OsCounter *counter;\r
\r
+#if defined(SC3) || defined(SC4)\r
+ uint32 accessingAppMask;\r
+#endif\r
+\r
CounterType counter_id;\r
/* cycle, 0 = no cycle */\r
uint32 alarmtime;\r
#ifndef APPLICATION_H_\r
#define APPLICATION_H_\r
\r
+/*\r
+ * IMPLEMENTATION NOTES:\r
+ *\r
+ * OS448: The Operating System module shall prevent access of\r
+ * OS-Applications, trusted or non-trusted, to objects not belonging\r
+ * to this OS-Application, except access rights for such objects are\r
+ * explicitly granted by configuration.\r
+ *\r
+ * OS509: If a service call is made on an Operating System\r
+ * object that is owned by another OS-Application without state\r
+ * APPLICATION_ACCESSIBLE, then the Operating System module shall return E_OS_ACCESS.\r
+ *\r
+ * OS056: If an OS-object identifier is the parameter of an Operating System module\92s\r
+ * system service, and no sufficient access rights have been assigned to this OS-object\r
+ * at configuration time (Parameter Os[...]AccessingApplication) to the calling\r
+ * Task/Category 2 ISR, the Operating System module\92s system service shall return\r
+ * E_OS_ACCESS.\r
+ *\r
+ * OS311: If OsScalabilityClass is SC3 or SC4 AND a Task OR Category 2 ISR OR\r
+ * Resources OR Counters OR Alarms OR Schedule tables does not belong to exactly\r
+ * one OS-Application the consistency check shall issue an error.\r
+ *\r
+ * Page 52:\r
+ * It is assumed that the Operating System module itself is trusted.\r
+ *\r
+ * Sooo, that gives us:\r
+ * 1. For each\r
+ *\r
+ *\r
+ * 1. App1, NT\r
+ * Task11\r
+ * 2. App2, NT\r
+ * Task21\r
+ * 3. App3, T\r
+ * Task31\r
+ * 4. App4, T\r
+ * Task41\r
+ *\r
+ * * App2->App1: ActivateTask(Task11)\r
+ * This is OK as long as Task11 have granted access to it during configuration\r
+ * * App4->App3: ActivateTask(Task31)\r
+ * This is OK as long as Task31 have granted access to it during configuration\r
+ * * App1->App4: ActivateTask(Task41)\r
+ * It's not really clear if the OS automagically exports all services..\r
+ * But this could also be CallTrustedFunction(ServiceId_AcivateTask,???)\r
+ *
+ */\r
+\r
+\r
+\r
#if ( OS_SC3 == STD_ON) || ( OS_SC4 == STD_ON )\r
\r
/* STD container : OsApplicationHooks\r
* management issue, not an access issue.\r
* */\r
\r
-typedef struct OsApplication {\r
+typedef struct OsAppVar {\r
/* 0 - Non-trusted application\r
* 1 - Trusted application */\r
_Bool trusted;\r
\r
/* Trusted functions */\r
/* .... */\r
-} OsApplicationType;\r
+} OsAppVarType;\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
\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
\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
+ /* Ref is ~0U terminated */\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
\r
-} OsRomApplicationType;\r
+ int restartTaskId;\r
+} OsAppConstType;\r
\r
#endif /* ( OS_SC1 == STD_ON ) || ( OS_SC4 == STD_ON ) */\r
\r
// The counter value ( if software counter )\r
uint32_t val;\r
// Application mask, SWS OS317\r
- uint32_t app_mask;\r
+#if defined(SC3) || defined(SC4)\r
+ uint32 accessingAppMask;\r
+#endif\r
// hmm, strange to call it alarm base.... but see spec.\r
AlarmBaseType alarm_base;\r
/* Used only if we configure a GPT timer as os timer */\r
#endif\r
\r
#if ( OS_SC1 == STD_ON ) || ( OS_SC4 == STD_ON )\r
-int Os_CfgGetApplCnt(void);\r
+extern const OsAppConstType Os_AppConst[OS_APP_CNT];\r
+\r
struct OsRomApplication *Os_CfgGetApplObj( ApplicationType application_id );\r
#endif\r
-int Os_CfgGetTaskCnt(void);\r
void *Os_CfgGetIdleProcStack(void);\r
-int Os_CfgGetResourceCnt(void);\r
StatusType Os_CfgGetAlarmBase(AlarmType alarm_id, AlarmBaseRefType info);\r
-uint32 Os_CfgGetAlarmCnt(void);\r
struct OsAlarm *Os_CfgGetAlarmObj( AlarmType alarm_id );\r
struct OsCounter *Os_CfgGetCounter(CounterType);\r
-uint32 Os_CfgGetCounterCnt(void );\r
-uint32 Os_CfgGetSchedCnt( void );\r
struct OsSchTbl *Os_CfgGetSched( ScheduleTableType sched_id );\r
-uint32 Os_CfgGetServiceCnt( void ) ;\r
struct OsResource *Os_CfgGetResource( ResourceType resource );\r
-\r
struct OsMessage *Os_CfgGetMessage(MessageType message_id);\r
-uint32 Os_CfgGetMessageCnt(void );\r
void Os_CfgValidate( void );\r
\r
#endif /*EXT_CONFIG_H_*/\r
*/\r
\r
#define ERRORHOOK(x) \\r
- if( os_sys.hooks->ErrorHook != NULL ) { \\r
- os_sys.hooks->ErrorHook(x); \\r
+ if( Os_Sys.hooks->ErrorHook != NULL ) { \\r
+ Os_Sys.hooks->ErrorHook(x); \\r
}\r
\r
\r
#define PRETASKHOOK() \\r
- assert( os_sys.curr_pcb->state & ST_RUNNING ); \\r
- assert( os_sys.curr_pcb->flags == SYS_FLAG_HOOK_STATE_EXPECTING_PRE ); \\r
- os_sys.curr_pcb->flags = SYS_FLAG_HOOK_STATE_EXPECTING_POST; \\r
- if( os_sys.hooks->PreTaskHook != NULL ) { \\r
- os_sys.hooks->PreTaskHook(); \\r
+ assert( Os_Sys.curr_pcb->state & ST_RUNNING ); \\r
+ assert( Os_Sys.curr_pcb->flags == SYS_FLAG_HOOK_STATE_EXPECTING_PRE ); \\r
+ Os_Sys.curr_pcb->flags = SYS_FLAG_HOOK_STATE_EXPECTING_POST; \\r
+ if( Os_Sys.hooks->PreTaskHook != NULL ) { \\r
+ Os_Sys.hooks->PreTaskHook(); \\r
}\r
\r
#define POSTTASKHOOK() \\r
- assert( os_sys.curr_pcb->state & ST_RUNNING ); \\r
- assert( os_sys.curr_pcb->flags == SYS_FLAG_HOOK_STATE_EXPECTING_POST ); \\r
- os_sys.curr_pcb->flags = SYS_FLAG_HOOK_STATE_EXPECTING_PRE; \\r
- if( os_sys.hooks->PostTaskHook != NULL ) { \\r
- os_sys.hooks->PostTaskHook(); \\r
+ assert( Os_Sys.curr_pcb->state & ST_RUNNING ); \\r
+ assert( Os_Sys.curr_pcb->flags == SYS_FLAG_HOOK_STATE_EXPECTING_POST ); \\r
+ Os_Sys.curr_pcb->flags = SYS_FLAG_HOOK_STATE_EXPECTING_PRE; \\r
+ if( Os_Sys.hooks->PostTaskHook != NULL ) { \\r
+ Os_Sys.hooks->PostTaskHook(); \\r
}\r
\r
/*\r
*/\r
\r
static inline OsTaskidType get_curr_pid( void ) {\r
- return os_sys.curr_pcb->pid;\r
+ return Os_Sys.curr_pcb->pid;\r
}\r
\r
static inline OsPcbType *get_curr_pcb( void ) {\r
- return os_sys.curr_pcb;\r
+ return Os_Sys.curr_pcb;\r
}\r
\r
static inline void set_curr_pcb( OsPcbType *pcb ) {\r
- os_sys.curr_pcb = pcb;\r
+ Os_Sys.curr_pcb = pcb;\r
}\r
\r
static inline _Bool is_idle_task( OsPcbType *pcb ){\r
}\r
\r
static inline OsTaskidType get_curr_prio( void ){\r
- return os_sys.curr_pcb->prio;\r
+ return Os_Sys.curr_pcb->prio;\r
}\r
\r
static inline TickType get_os_tick( void ) {\r
- return os_sys.tick;\r
+ return Os_Sys.tick;\r
}\r
\r
-#if ( OS_SC3 == STD_ON ) || ( OS_SC4 == STD_ON )\r
-static inline OsApplicationType *get_curr_application( void ) {\r
- return get_curr_pcb()->application;\r
-}\r
-\r
-static inline uint32_t get_curr_application_id( void ) {\r
- return get_curr_pcb()->application->application_id;\r
-}\r
-#endif\r
-\r
static inline struct OsResource *os_get_resource_int_p( void ) {\r
return get_curr_pcb()->resource_int_p;\r
}\r
\r
/*\r
static inline void Os_GetSchedulerResource() {\r
- os_sys.scheduler_lock = 1;\r
+ Os_Sys.scheduler_lock = 1;\r
}\r
\r
static inline void Os_ReleaseSchedulerResource() {\r
- os_sys.scheduler_lock = 0;\r
+ Os_Sys.scheduler_lock = 0;\r
}\r
*/\r
/*\r
static inline _Bool Os_SchedulerResourceIsOccupied() {\r
#if 0\r
- return (os_sys.resScheduler.owner != NO_TASK_OWNER );\r
+ return (Os_Sys.resScheduler.owner != NO_TASK_OWNER );\r
#else\r
- return (os_sys.scheduler_lock == 1);\r
+ return (Os_Sys.scheduler_lock == 1);\r
#endif\r
}\r
*/\r
\r
static inline _Bool Os_SchedulerResourceIsFree() {\r
#if 1\r
- return (os_sys.resScheduler.owner == NO_TASK_OWNER );\r
+ return (Os_Sys.resScheduler.owner == NO_TASK_OWNER );\r
#else\r
- return (os_sys.scheduler_lock == 0);\r
+ return (Os_Sys.scheduler_lock == 0);\r
#endif\r
}\r
\r
/** @req OS068 */\r
ShutdownOS(E_OS_STACKFAULT);\r
#else\r
-#error SC3 or SC4 not supported. Protection hook should be called here\r
+#warning SC3 or SC4 not supported. Protection hook should be called here\r
#endif\r
}\r
#endif\r
\r
// What application may access this resource. A resource may only be\r
// accessed by one application\r
-#if ( OS_SC3 == STD_ON ) || ( OS_SC4 == STD_ON )\r
- uint32 application_owner_id;\r
+#if defined(SC3) || defined(SC4)\r
+ uint32 accessingAppMask;\r
#endif\r
// What tasks may access this resource. A resource may be be shared\r
// several tasks.\r
* OsIsrExecutionBudget 0..1 float\r
* OsIsrOsInterruptLockBudget 0..1 float\r
* OsIsrTimeFrame 0..1 float\r
- * OsIsrResourceLock[C] 0..1\r
+ * OsIsrResourceLock[C] 0..*\r
* */\r
\r
\r
int autostart:1; // TASK\r
OsStackType stack; // TASK\r
\r
- int vector; // ISR\r
char name[TASK_NAME_SIZE];\r
#if ( OS_SC2 == STD_ON ) || ( OS_SC4 == STD_ON )\r
OsTimingProtectionType *timing_protection;\r
TAILQ_ENTRY(OsPcb) ready_list; // TASK\r
} OsPcbType;\r
\r
+/*-----------------------------------------------------------------*/\r
+\r
+\r
+typedef struct {\r
+ int a;\r
+ int b;\r
+} OsIsrType_VAR;\r
+\r
+\r
/*-----------------------------------------------------------------*/\r
\r
typedef struct OsRomPcb {\r
uint8 autostart;\r
OsStackType stack;\r
int vector; // ISR\r
- ApplicationType application_id;\r
+#if defined(SC3) || defined(SC4)\r
+ uint32 accessingAppMask;\r
+#endif\r
char name[16];\r
enum OsTaskSchedule scheduling;\r
uint32_t resourceAccess;\r
/** @req OS413 */\r
_Bool repeating;\r
\r
+#if defined(SC3) || defined(SC4)\r
+ uint32 accessingAppMask;\r
+#endif\r
+\r
// pointer to this tables counter\r
// OsScheduleTableCounterRef\r
/** @req OS409 */\r
OP_RELEASE_RESOURCE = 64,\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
/* Current Application mode */\r
AppModeType appMode;\r
\r
-// uint32_t flags;\r
+#if (OS_SC3==STD_ON) || (OS_SC4==STD_ON)\r
+ ApplicationStateType currAppState;\r
+#endif\r
\r
uint32_t task_cnt;\r
+\r
+ uint32_t isrCnt;\r
/* List of all pcb's,\r
* Only needed for non-static configuration of the kernel\r
*/\r
\r
/* Occording to OSEK 8.3 RES_SCHEDULER is accessible to all tasks */\r
OsResourceType resScheduler;\r
-} sys_t;\r
+} Os_SysType;\r
\r
-extern sys_t os_sys;\r
+extern Os_SysType Os_Sys;\r
\r
static inline OsPcbType *Os_TaskGetCurrent( void ) {\r
- return os_sys.curr_pcb;\r
+ return Os_Sys.curr_pcb;\r
}\r
\r
#if 0\r
static uint32_t OSErrorGetServiceId( void ) {\r
- return os_sys.serviceId;\r
+ return Os_Sys.serviceId;\r
}\r
#endif\r
\r
OsPcbType *i_pcb;\r
int cnt = 0;\r
\r
- TAILQ_FOREACH(i_pcb,&os_sys.ready_head,ready_list) {\r
+ TAILQ_FOREACH(i_pcb,&Os_Sys.ready_head,ready_list) {\r
//printf("%02d: %02d %s\n",cnt,i_pcb->state,i_pcb->name);\r
cnt++;\r
// assert( i_pcb->state == ST_READY );\r
static inline void Os_TaskMakeReady( OsPcbType *pcb ) {\r
if( !( pcb->state & ( ST_READY | ST_RUNNING )) ) {\r
pcb->state = ST_READY;\r
- TAILQ_INSERT_TAIL(& os_sys.ready_head,pcb,ready_list);\r
+ TAILQ_INSERT_TAIL(& Os_Sys.ready_head,pcb,ready_list);\r
OS_DEBUG(D_TASK,"Added %s to ready list\n",pcb->name);\r
}\r
}\r
assert( pcb->state & (ST_READY|ST_RUNNING) );\r
\r
pcb->state = ST_WAITING;\r
- TAILQ_REMOVE(&os_sys.ready_head,pcb,ready_list);\r
+ TAILQ_REMOVE(&Os_Sys.ready_head,pcb,ready_list);\r
OS_DEBUG(D_TASK,"Removed %s from ready list\n",pcb->name);\r
}\r
\r
{\r
assert( pcb->state & (ST_READY|ST_RUNNING) );\r
pcb->state = ST_SUSPENDED;\r
- TAILQ_REMOVE(&os_sys.ready_head,pcb,ready_list);\r
+ TAILQ_REMOVE(&Os_Sys.ready_head,pcb,ready_list);\r
OS_DEBUG(D_TASK,"Removed %s from ready list\n",pcb->name);\r
}\r
\r
extern uint32_t McuE_GetSystemClock( void );
extern OsTickType OsTickFreq;
-sys_t os_sys;
+Os_SysType Os_Sys;
Os_IntCounterType Os_IntDisableAllCnt;
Os_IntCounterType Os_IntSuspendAllCnt;
pcb->pid = r_pcb->pid;
pcb->prio = r_pcb->prio;
#if ( OS_SC3 == STD_ON ) || ( OS_SC4 == STD_ON )
- pcb->application = Os_CfgGetApplObj(r_pcb->application_id);
+// pcb->accessingApp = Os_CfgGetApplObj(r_pcb->application_id);
#endif
pcb->entry = r_pcb->entry;
pcb->proc_type = r_pcb->proc_type;
DEBUG(DEBUG_LOW,"os_init");
/* Clear sys */
- memset(&os_sys,0,sizeof(sys_t));
+ memset(&Os_Sys,0,sizeof(Os_SysType));
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 = pcb_list;
+ TAILQ_INIT(& Os_Sys.ready_head);
+ TAILQ_INIT(& Os_Sys.pcb_head);
// Calc interrupt stack
Os_CfgGetInterruptStackInfo(&int_stack);
// TODO: 16 is arch dependent
- os_sys.int_stack = (void *)((size_t)int_stack.top + (size_t)int_stack.size - 16);
+ Os_Sys.int_stack = (void *)((size_t)int_stack.top + (size_t)int_stack.size - 16);
// Init counter.. with alarms and schedule tables
#if OS_COUNTER_CNT!=0
/* TODO: fix ugly */
/* Call the startup hook */
extern struct OsHooks os_conf_global_hooks;
- os_sys.hooks = &os_conf_global_hooks;
- if( os_sys.hooks->StartupHook!=NULL ) {
- os_sys.hooks->StartupHook();
+ Os_Sys.hooks = &os_conf_global_hooks;
+ if( Os_Sys.hooks->StartupHook!=NULL ) {
+ Os_Sys.hooks->StartupHook();
}
/* Alarm autostart */
OsPcbType *iterPcbPtr;
OsPriorityType topPrio = -1;
- TAILQ_FOREACH(iterPcbPtr,& os_sys.pcb_head,pcb_list) {
+ TAILQ_FOREACH(iterPcbPtr,& Os_Sys.pcb_head,pcb_list) {
if( iterPcbPtr->autostart ) {
if( iterPcbPtr->prio > topPrio ) {
tmp_pcb = iterPcbPtr;
// Swap in prio proc.
{
- // FIXME: Do this in a more structured way.. setting os_sys.curr_pcb manually is not the way to go..
- os_sys.curr_pcb = tmp_pcb;
+ // FIXME: Do this in a more structured way.. setting Os_Sys.curr_pcb manually is not the way to go..
+ Os_Sys.curr_pcb = tmp_pcb;
// register this auto-start activation
assert(tmp_pcb->activations < tmp_pcb->activationLimit);
noooo();
}
- os_sys.appMode = Mode;
+ Os_Sys.appMode = Mode;
Os_CfgValidate();
/** @req OS071 */
void ShutdownOS( StatusType Error ) {
- if( os_sys.hooks->ShutdownHook != NULL ) {
- os_sys.hooks->ShutdownHook(Error);
+ if( Os_Sys.hooks->ShutdownHook != NULL ) {
+ Os_Sys.hooks->ShutdownHook(Error);
}
Irq_Disable();
{
OsPcbType *pcb = os_alloc_new_pcb();
strncpy(pcb->name,name,TASK_NAME_SIZE);
- pcb->vector = -1;
+// pcb->vector = -1;
pcb->prio = prio;
/* TODO: map to interrupt controller priority */
assert(prio<=OS_TASK_PRIORITY_MAX);
return Os_AddTask(pcb);
}
+ISRType Os_AddIsr( const OsIsrType_CONST * restrict isrPtr ) {
+ ISRType iid;
+
+ iid = Os_Sys.isrCnt++;
+ return iid;
+}
+
+/*
+ * 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
+ *
+ */
+
+
+#if 0
+void apa( void ) {
+ ISRType iid;
+ static const OsIsrType_CONST isr = {
+ .name = "MyIsr",
+ .prio = 12,
+ .vector = 15,
+ .entry = MyIsr
+ };
+ iid = Irq_Attach(&isr, ISR_TYPE2, NULL );
+}
+#endif
+
+
/**
* Before we have proper editor for ISR2 use this function to add resources
* to an ISR2
Os_StackPerformCheck(new_pcb);
- if( (new_pcb == os_sys.curr_pcb) ||
- (os_sys.curr_pcb->scheduling == NON) ||
+ if( (new_pcb == Os_Sys.curr_pcb) ||
+ (Os_Sys.curr_pcb->scheduling == NON) ||
!Os_SchedulerResourceIsFree() )
{
/* Just bring the preempted task back to running */
- Os_TaskSwapContextTo(NULL,os_sys.curr_pcb);
+ Os_TaskSwapContextTo(NULL,Os_Sys.curr_pcb);
} else {
OS_DEBUG(D_TASK,"Found candidate %s\n",new_pcb->name);
Os_TaskSwapContextTo(NULL,new_pcb);
struct OsPcb *isrPtr;
- os_sys.int_nest_cnt++;
+ Os_Sys.int_nest_cnt++;
/* Grab the ISR "pcb" */
isrPtr = (struct OsPcb *)isr_p;
Irq_EOI();
- --os_sys.int_nest_cnt;
+ --Os_Sys.int_nest_cnt;
/* Scheduling is done in PendSV handler for ARM CM3 */
*((uint32_t volatile *)0xE000ED04) = 0x10000000; // PendSV
struct OsPcb *pPtr = NULL;
/* Check if we interrupted a task or ISR */
- if( os_sys.int_nest_cnt == 0 ) {
+ if( Os_Sys.int_nest_cnt == 0 ) {
/* We interrupted a task */
POSTTASKHOOK();
/* We interrupted an ISR */
}
- os_sys.int_nest_cnt++;
+ Os_Sys.int_nest_cnt++;
/* Grab the ISR "pcb" */
isrPtr = (struct OsPcb *)isr_p;
Irq_EOI();
- --os_sys.int_nest_cnt;
+ --Os_Sys.int_nest_cnt;
#if defined(CFG_ARM_CM3)
/* Scheduling is done in PendSV handler for ARM CM3 */
*((uint32_t volatile *)0xE000ED04) = 0x10000000; // PendSV
#else
// We have preempted a task
- if( (os_sys.int_nest_cnt == 0) ) {
+ if( (Os_Sys.int_nest_cnt == 0) ) {
OsPcbType *new_pcb = Os_TaskGetTop();
Os_StackPerformCheck(new_pcb);
- if( (new_pcb == os_sys.curr_pcb) ||
- (os_sys.curr_pcb->scheduling == NON) ||
+ if( (new_pcb == Os_Sys.curr_pcb) ||
+ (Os_Sys.curr_pcb->scheduling == NON) ||
!Os_SchedulerResourceIsFree() )
{
/* Just bring the preempted task back to running */
- os_sys.curr_pcb->state = ST_RUNNING;
+ Os_Sys.curr_pcb->state = ST_RUNNING;
PRETASKHOOK();
} else {
OS_DEBUG(D_TASK,"Found candidate %s\n",new_pcb->name);
#endif\r
DECLARE(PCB_STACK_CURR_P, offsetof(OsPcbType, stack));\r
DECLARE(PCB_ENTRY_P, offsetof(OsPcbType, entry));\r
- DECLARE(SYS_CURR_PCB_P, offsetof(sys_t, curr_pcb));\r
- DECLARE(SYS_INT_NEST_CNT, offsetof(sys_t, int_nest_cnt));\r
- DECLARE(SYS_INT_STACK, offsetof(sys_t, int_stack));\r
+ DECLARE(SYS_CURR_PCB_P, offsetof(Os_SysType, curr_pcb));\r
+ DECLARE(SYS_INT_NEST_CNT, offsetof(Os_SysType, int_nest_cnt));\r
+ DECLARE(SYS_INT_STACK, offsetof(Os_SysType, int_stack));\r
}\r
\r
\r
#include "Os.h"\r
\r
-\r
-/* See 8.4.4 */\r
-AccessType CheckISRMemoryAccess( ISRType ISRID,\r
- MemoryStartAddressType Address,\r
- MemorySizeType Size )\r
-{\r
- // get hold of application memory space\r
-\r
-\r
-}\r
-\r
-AccessType CheckTaskMemoryAccess( TaskType TaskID,\r
- MemoryStartAddressType Address,\r
- MemorySizeType Size )\r
-{\r
-\r
-\r
-}\r
-\r
-/* Object access\r
- *\r
- *\r
- * resource\r
- *\r
- *\r
- */\r
-\r
-\r
-\r
-\r
-/* This is probably macros */\r
-ObjectAccessType CheckObjectAccess( ApplicationType ApplID,\r
- ObjectTypeType ObjectType,\r
- void *object )\r
-{\r
- uint32 app_mask = (1<<ApplID);\r
- uint32 rv;\r
-\r
- /* TODO: check id */\r
- switch( ObjectType ) {\r
- case OBJECT_ALARM:\r
- rv = ((OsAlarmType *)object)->app_mask & (app_mask);\r
- break;\r
- case OBJECT_COUNTER:\r
- rv = ((OsCounterType *)object)->app_mask & (app_mask);\r
- break;\r
- case OBJECT_ISR:\r
- break;\r
- case OBJECT_MESSAGE:\r
- case OBJECT_RESOURCE:\r
- case OBJECT_SCHEDULETABLE:\r
- break;\r
- case OBJECT_TASK:\r
- rv = ((OsCounterType *)object)->app_mask & (app_mask);\r
- break;\r
- default:\r
- break;\r
- }\r
-\r
-\r
-\r
-\r
- return ACCESS;\r
-}\r
-\r
-/* return application id for object */\r
-ApplicationType CheckObjectOwnership( ObjectTypeType ObjectType,\r
- void *object )\r
-{\r
- switch( ObjectType ) {\r
- case OBJECT_ALARM:\r
- case OBJECT_COUNTER:\r
- case OBJECT_ISR:\r
- case OBJECT_MESSAGE:\r
- case OBJECT_RESOURCE:\r
- case OBJECT_SCHEDULETABLE:\r
- case OBJECT_TASK:\r
- default:\r
- break;\r
- }\r
-\r
- return (-1);\r
-}\r
\r
void Os_ArcTest_SetIrqNestLevel( int level ) {\r
\r
- os_sys.int_nest_cnt = level;\r
+ Os_Sys.int_nest_cnt = level;\r
\r
return;\r
}\r
\r
if( ResID == RES_SCHEDULER ) {\r
\r
- rPtr = &os_sys.resScheduler;\r
+ rPtr = &Os_Sys.resScheduler;\r
} else {\r
/* Check we can access it */\r
if( (pcbPtr->resourceAccess & (1<< ResID)) == 0 ) {\r
\r
Irq_Save(flags);\r
if( ResID == RES_SCHEDULER ) {\r
- rPtr = &os_sys.resScheduler;\r
+ rPtr = &Os_Sys.resScheduler;\r
} else {\r
/* Check we can access it */\r
if( (pcbPtr->resourceAccess & (1<< ResID)) == 0 ) {\r
\r
/* do a rescheduling (in some cases) (see OSEK OS 4.6.1) */\r
if ( (pcbPtr->scheduling == FULL) &&\r
- (os_sys.int_nest_cnt == 0) &&\r
+ (Os_Sys.int_nest_cnt == 0) &&\r
(Os_SchedulerResourceIsFree()) ) {\r
\r
OsPcbType* top_pcb = Os_TaskGetTop();\r
\r
\r
/* For now, assign the scheduler resource here */\r
- os_sys.resScheduler.ceiling_priority = OS_RES_SCHEDULER_PRIO;\r
- strcpy(os_sys.resScheduler.id,"RES_SCHEDULER");\r
- os_sys.resScheduler.nr = RES_SCHEDULER;\r
- os_sys.resScheduler.owner = NO_TASK_OWNER;\r
+ Os_Sys.resScheduler.ceiling_priority = OS_RES_SCHEDULER_PRIO;\r
+ strcpy(Os_Sys.resScheduler.id,"RES_SCHEDULER");\r
+ Os_Sys.resScheduler.nr = RES_SCHEDULER;\r
+ Os_Sys.resScheduler.owner = NO_TASK_OWNER;\r
\r
/* Calculate ceiling priority\r
* We make this as simple as possible. The ceiling priority\r
const struct OsSchTblAutostart *autoPtr = sPtr->autostartPtr;\r
\r
/* Check appmode */\r
- if( os_sys.appMode & autoPtr->appMode ) {\r
+ if( Os_Sys.appMode & autoPtr->appMode ) {\r
\r
/* Start the schedule table */\r
switch(autoPtr->type) {\r
OsPcbType *i_pcb;\r
\r
/* TODO: Implement this as an array */\r
- TAILQ_FOREACH(i_pcb,& os_sys.pcb_head,pcb_list) {\r
+ TAILQ_FOREACH(i_pcb,& Os_Sys.pcb_head,pcb_list) {\r
if(i_pcb->pid == tid ) {\r
return i_pcb;\r
}\r
\r
Irq_Save(msr); // Save irq status and disable interrupts\r
\r
- pcb->pid = os_sys.task_cnt;\r
+ pcb->pid = Os_Sys.task_cnt;\r
// Add to list of PCB's\r
- TAILQ_INSERT_TAIL(& os_sys.pcb_head,pcb,pcb_list);\r
- os_sys.task_cnt++;\r
+ TAILQ_INSERT_TAIL(& Os_Sys.pcb_head,pcb,pcb_list);\r
+ Os_Sys.task_cnt++;\r
+ Os_Sys.isrCnt++;\r
\r
Irq_Restore(msr); // Restore interrupts\r
return pcb->pid;\r
\r
// OS_DEBUG(D_TASK,"os_find_top_prio_proc\n");\r
\r
- TAILQ_FOREACH(i_pcb,& os_sys.ready_head,ready_list) {\r
+ TAILQ_FOREACH(i_pcb,& Os_Sys.ready_head,ready_list) {\r
// all ready task are canidates\r
if( i_pcb->state & (ST_READY|ST_RUNNING)) {\r
if( top_prio != PRIO_ILLEGAL ) {\r
OsPcbType *pcbPtr;\r
OsPcbType *currPcbPtr = Os_TaskGetCurrent();\r
\r
- assert(os_sys.int_nest_cnt == 0);\r
+ assert(Os_Sys.int_nest_cnt == 0);\r
assert(Os_SchedulerResourceIsFree());\r
\r
/* When calling post hook we must still be in ST_RUNNING */\r
} else if( op & OP_ACTIVATE_TASK ) {\r
Os_TaskMakeReady(currPcbPtr);\r
} else if( op & OP_CHAIN_TASK ) {\r
- assert( os_sys.chainedPcbPtr != NULL );\r
+ assert( Os_Sys.chainedPcbPtr != NULL );\r
\r
/* # from chain top\r
* ----------------------------------------------------------\r
*\r
* - Chained task is always READY when coming from ChainTask()\r
*/\r
- if( currPcbPtr != os_sys.chainedPcbPtr ) {\r
+ if( currPcbPtr != Os_Sys.chainedPcbPtr ) {\r
/* #3 and #4 */\r
--currPcbPtr->activations;\r
if( currPcbPtr->activations <= 0 ) {\r
}\r
/* Chained task is already in READY */\r
}\r
- os_sys.chainedPcbPtr = NULL;\r
+ Os_Sys.chainedPcbPtr = NULL;\r
\r
} else if( op & OP_TERMINATE_TASK ) {\r
/*@req OSEK TerminateTask\r
/* Swap if we found any process or are forced (multiple activations)*/\r
if( pcbPtr != currPcbPtr ) {\r
\r
- if( (op & OP_CHAIN_TASK) && ( currPcbPtr == os_sys.chainedPcbPtr ) ) {\r
+ if( (op & OP_CHAIN_TASK) && ( currPcbPtr == Os_Sys.chainedPcbPtr ) ) {\r
/* #2 */\r
Os_TaskRunningToReady(currPcbPtr);\r
}\r
/** @req OS068 */\r
ShutdownOS(E_OS_STACKFAULT);\r
#else\r
-#error SC3 or SC4 not supported. Protection hook should be called here\r
+#warning SC3 or SC4 not supported. Protection hook should be called here\r
#endif\r
}\r
#endif\r
\r
/* Test specification say return CALLEVEL if in ISR\r
* but impl. spec says otherwise */\r
- if( os_sys.int_nest_cnt == 0 ) {\r
- if( os_sys.curr_pcb->state & ST_RUNNING ) {\r
- *TaskID = os_sys.curr_pcb->pid;\r
+ if( Os_Sys.int_nest_cnt == 0 ) {\r
+ if( Os_Sys.curr_pcb->state & ST_RUNNING ) {\r
+ *TaskID = Os_Sys.curr_pcb->pid;\r
} else {\r
/* This is not a real error since this could\r
* be the case when called from ErrorHook */
ISRType GetISRID( void ) {\r
\r
/** @req OS264 */\r
- if(os_sys.int_nest_cnt == 0 ) {\r
+ if(Os_Sys.int_nest_cnt == 0 ) {\r
return INVALID_ISR;\r
}\r
\r
#endif\r
\r
Irq_Save(msr);\r
+#if (OS_SC3==STD_ON) || (OS_SC4==STD_ON)\r
+ /* @req OS504/ActivateTask\r
+ * The Operating System module shall deny access to Operating System\r
+ * objects from other OS-Applications to an OS-Application which is not in state\r
+ * APPLICATION_ACCESSIBLE.\r
+ * */\r
+\r
+ if( Os_TaskConst[TaskID].appOwnerId != Os_Sys.currAppId ) {\r
+ /* We are activating a task in another application */\r
+ if( Os_AppVar[Os_Sys.currAppId].state != APPLICATION_ACCESSIBLE ) {\r
+ rv=E_OS_ACCESS;\r
+ goto err;\r
+ }\r
+ }\r
+#endif\r
+\r
/* @req OS093 ActivateTask */\r
if( Os_IrqAnyDisabled() ) {\r
/* Standard */\r
\r
/* Preempt only if we are preemptable and target has higher prio than us */\r
if( (Os_TaskGetCurrent()->scheduling == FULL) &&\r
- (os_sys.int_nest_cnt == 0) &&\r
+ (Os_Sys.int_nest_cnt == 0) &&\r
(pcb->prio > Os_TaskGetCurrent()->prio) &&\r
(Os_SchedulerResourceIsFree()))\r
{\r
#if (OS_STATUS_EXTENDED == STD_ON )\r
\r
\r
- if( os_sys.int_nest_cnt != 0 ) {\r
+ if( Os_Sys.int_nest_cnt != 0 ) {\r
rv = E_OS_CALLEVEL;\r
goto err;\r
}\r
/* extended */\r
TASK_CHECK_ID(TaskId);\r
\r
- if( os_sys.int_nest_cnt != 0 ) {\r
+ if( Os_Sys.int_nest_cnt != 0 ) {\r
/* extended */\r
rv = E_OS_CALLEVEL;\r
goto err;\r
\r
}\r
\r
- os_sys.chainedPcbPtr = pcb;\r
+ Os_Sys.chainedPcbPtr = pcb;\r
\r
Os_Dispatch(OP_CHAIN_TASK);\r
\r
OS_DEBUG(D_TASK,"# Schedule %s\n",Os_TaskGetCurrent()->name);\r
\r
/* Check that we are not calling from interrupt context */\r
- if( os_sys.int_nest_cnt != 0 ) {\r
+ if( Os_Sys.int_nest_cnt != 0 ) {\r
rv = E_OS_CALLEVEL;\r
goto err;\r
}\r
projects / arc.git / commitdiff