3791e4a8ceffe5a0bd4edc316c579465626b11f6
[processor-sdk/pdk.git] / packages / ti / kernel / freertos / portable / TI_CGT / c66 / port.c
1 /*
2  * FreeRTOS Kernel V10.4.1
3  * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
4  *
5  * Permission is hereby granted, free of charge, to any person obtaining a copy of
6  * this software and associated documentation files (the "Software"), to deal in
7  * the Software without restriction, including without limitation the rights to
8  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
9  * the Software, and to permit persons to whom the Software is furnished to do so,
10  * subject to the following conditions:
11  *
12  * The above copyright notice and this permission notice shall be included in all
13  * copies or substantial portions of the Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
17  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
18  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
19  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21  *
22  * https://www.FreeRTOS.org
23  * https://github.com/FreeRTOS
24  *
25  * 1 tab == 4 spaces!
26  */
27 /*
28  *  Copyright (C) 2018-2021 Texas Instruments Incorporated
29  *
30  *  Redistribution and use in source and binary forms, with or without
31  *  modification, are permitted provided that the following conditions
32  *  are met:
33  *
34  *    Redistributions of source code must retain the above copyright
35  *    notice, this list of conditions and the following disclaimer.
36  *
37  *    Redistributions in binary form must reproduce the above copyright
38  *    notice, this list of conditions and the following disclaimer in the
39  *    documentation and/or other materials provided with the
40  *    distribution.
41  *
42  *    Neither the name of Texas Instruments Incorporated nor the names of
43  *    its contributors may be used to endorse or promote products derived
44  *    from this software without specific prior written permission.
45  *
46  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
47  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
48  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
49  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
50  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
51  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
52  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
53  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
54  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
55  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
56  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
57  */
58 #include <stdint.h>
59 #include <stdio.h>
60 #include <FreeRTOS.h>
61 #include <task.h>
62 #include <ti/osal/osal.h>
63 #include <ti/osal/HwiP.h>
64 #include <ti/osal/DebugP.h>
65 #include <ti/csl/soc.h>
66 #include <ti/csl/arch/csl_arch.h>
67 #include <ti/osal/src/nonos/Nonos_config.h>
69 /* Let the user override the pre-loading of the initial LR with the address of
70  * prvTaskExitError() in case is messes up unwinding of the stack in the
71  * debugger. */
72 #ifdef configTASK_RETURN_ADDRESS
73     #define portTASK_RETURN_ADDRESS    configTASK_RETURN_ADDRESS
74 #else
75     #define portTASK_RETURN_ADDRESS    prvTaskExitError
76 #endif
79 /* A critical section is exited when the critical section nesting count reaches
80  * this value. */
81 #define portNO_CRITICAL_NESTING          ( ( uint32_t ) 0 )
83 /* Tasks are not created with a floating point context, but can be given a
84  * floating point context after they have been created.  A variable is stored as
85  * part of the tasks context that holds portNO_FLOATING_POINT_CONTEXT if the task
86  * does not have an FPU context, or any other value if the task does have an FPU
87  * context. */
88 #define portNO_FLOATING_POINT_CONTEXT    ( ( StackType_t ) 0 )
90 /* A variable is used to keep track of the critical section nesting.  This
91  * variable has to be stored as part of the task context and must be initialised to
92  * a non zero value to ensure interrupts don't inadvertently become unmasked before
93  * the scheduler starts.  As it is stored as part of the task context it will
94  * automatically be set to 0 when the first task is started. */
95 volatile uint32_t ulCriticalNesting = 9999UL;
97 /* Saved as part of the task context.  If ulPortTaskHasFPUContext is non-zero then
98  * a floating point context must be saved and restored for the task. */
99 uint32_t ulPortTaskHasFPUContext = pdFALSE;
101 /* Set to 1 to pend a context switch from an ISR. */
102 uint32_t ulPortYieldRequired = pdFALSE;
104 /* Counts the interrupt nesting depth.  A context switch is only performed if
105  * if the nesting depth is 0. */
106 uint32_t ulPortInterruptNesting = 0UL;
108 /* set to true when schedular gets enabled in xPortStartScheduler */
109 uint32_t ulPortSchedularRunning = pdFALSE;
112 /* set to true when scheduler gets enabled in xPortStartScheduler */
113 uint32_t uxPortIncorrectYieldCount = 0UL;
115 /*
116  * Task control block.  A task control block (TCB) is allocated for each task,
117  * and stores task state information, including a pointer to the task's context
118  * (the task's run time environment, including register values)
119  */
120 /*
121  * Task control block.  A task control block (TCB) is allocated for each task,
122  * and stores task state information, including a pointer to the task's context
123  * (the task's run time environment, including register values)
124  */
125 typedef struct tskTaskControlBlock       /* The old naming convention is used to prevent breaking kernel aware debuggers. */
127     volatile StackType_t * pxTopOfStack; /*< Points to the location of the last item placed on the tasks stack.  THIS MUST BE THE FIRST MEMBER OF THE TCB STRUCT. */
129     #if ( portUSING_MPU_WRAPPERS == 1 )
130         xMPU_SETTINGS xMPUSettings; /*< The MPU settings are defined as part of the port layer.  THIS MUST BE THE SECOND MEMBER OF THE TCB STRUCT. */
131     #endif
133     ListItem_t xStateListItem;                  /*< The list that the state list item of a task is reference from denotes the state of that task (Ready, Blocked, Suspended ). */
134     ListItem_t xEventListItem;                  /*< Used to reference a task from an event list. */
135     UBaseType_t uxPriority;                     /*< The priority of the task.  0 is the lowest priority. */
136     StackType_t * pxStack;                      /*< Points to the start of the stack. */
137     char pcTaskName[ configMAX_TASK_NAME_LEN ]; /*< Descriptive name given to the task when created.  Facilitates debugging only. */ /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
139     #if ( ( portSTACK_GROWTH > 0 ) || ( configRECORD_STACK_HIGH_ADDRESS == 1 ) )
140         StackType_t * pxEndOfStack; /*< Points to the highest valid address for the stack. */
141     #endif
143     #if ( portCRITICAL_NESTING_IN_TCB == 1 )
144         UBaseType_t uxCriticalNesting; /*< Holds the critical section nesting depth for ports that do not maintain their own count in the port layer. */
145     #endif
147     #if ( configUSE_TRACE_FACILITY == 1 )
148         UBaseType_t uxTCBNumber;  /*< Stores a number that increments each time a TCB is created.  It allows debuggers to determine when a task has been deleted and then recreated. */
149         UBaseType_t uxTaskNumber; /*< Stores a number specifically for use by third party trace code. */
150     #endif
152     #if ( configUSE_MUTEXES == 1 )
153         UBaseType_t uxBasePriority; /*< The priority last assigned to the task - used by the priority inheritance mechanism. */
154         UBaseType_t uxMutexesHeld;
155     #endif
157     #if ( configUSE_APPLICATION_TASK_TAG == 1 )
158         TaskHookFunction_t pxTaskTag;
159     #endif
161     #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0 )
162         void * pvThreadLocalStoragePointers[ configNUM_THREAD_LOCAL_STORAGE_POINTERS ];
163     #endif
165     #if ( configGENERATE_RUN_TIME_STATS == 1 )
166         uint32_t ulRunTimeCounter; /*< Stores the amount of time the task has spent in the Running state. */
167     #endif
169     #if ( configUSE_NEWLIB_REENTRANT == 1 )
171         /* Allocate a Newlib reent structure that is specific to this task.
172          * Note Newlib support has been included by popular demand, but is not
173          * used by the FreeRTOS maintainers themselves.  FreeRTOS is not
174          * responsible for resulting newlib operation.  User must be familiar with
175          * newlib and must provide system-wide implementations of the necessary
176          * stubs. Be warned that (at the time of writing) the current newlib design
177          * implements a system-wide malloc() that must be provided with locks.
178          *
179          * See the third party link http://www.nadler.com/embedded/newlibAndFreeRTOS.html
180          * for additional information. */
181         struct  _reent xNewLib_reent;
182     #endif
184     #if ( configUSE_TASK_NOTIFICATIONS == 1 )
185         volatile uint32_t ulNotifiedValue[ configTASK_NOTIFICATION_ARRAY_ENTRIES ];
186         volatile uint8_t ucNotifyState[ configTASK_NOTIFICATION_ARRAY_ENTRIES ];
187     #endif
189     /* See the comments in FreeRTOS.h with the definition of
190      * tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE. */
191     #if ( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 ) /*lint !e731 !e9029 Macro has been consolidated for readability reasons. */
192         uint8_t ucStaticallyAllocated;                     /*< Set to pdTRUE if the task is a statically allocated to ensure no attempt is made to free the memory. */
193     #endif
195     #if ( INCLUDE_xTaskAbortDelay == 1 )
196         uint8_t ucDelayAborted;
197     #endif
199     #if ( configUSE_POSIX_ERRNO == 1 )
200         int iTaskErrno;
201     #endif
202 } tskTCB;
204 extern tskTCB * pxCurrentTCB;
205 /*
206  * Starts the first task executing.  This function is necessarily written in
207  * assembly code so is implemented in portASM.s.
208  */
209 extern void vPortRestoreTaskContext( void );
211 static void prvTaskExitError( void )
213     /* A function that implements a task must not exit or attempt to return to
214      * its caller as there is nothing to return to.  If a task wants to exit it
215      * should instead call vTaskDelete( NULL ).
216      *
217      * Force an assert() to be triggered if configASSERT() is
218      * defined, then stop here so application writers can catch the error. */
219     DebugP_assert(0);
222 #define TaskSupport_buildTaskStack ti_sysbios_family_c62_TaskSupport_buildTaskStack
224 typedef void (*Task_FuncPtr)(uint32_t arg1, uint32_t arg2);
226 typedef void (*TaskSupport_FuncPtr)(void);
229 extern void * TaskSupport_buildTaskStack(void * stack, Task_FuncPtr fxn, TaskSupport_FuncPtr exit, TaskSupport_FuncPtr enter, uint32_t arg0, uint32_t arg1);
230 /*
231  *  ======== Task_exit ========
232  */
233 void Task_exit(void)
235     prvTaskExitError();
238 void Task_enter(void)
243 void ti_sysbios_knl_Task_Func(uint32_t arg1, uint32_t arg2)
245     TaskFunction_t pxCode = (TaskFunction_t)arg2;
246     pxCode((void *)arg1);
249 #if ( portHAS_STACK_OVERFLOW_CHECKING == 1 )
250 StackType_t *pxPortInitialiseStack(StackType_t * pxTopOfStack, StackType_t * pxEndOfStack, TaskFunction_t pxCode, void * pvParameters )
251 #else
252 StackType_t *pxPortInitialiseStack(StackType_t * pxTopOfStack, TaskFunction_t pxCode, void * pvParameters )
253 #endif
255 #if ( portHAS_STACK_OVERFLOW_CHECKING == 1 )
256     {
257         (void) pxEndOfStack;
258     }
259 #endif
261     pxTopOfStack = (StackType_t *)TaskSupport_buildTaskStack(pxTopOfStack, ti_sysbios_knl_Task_Func, Task_exit, Task_enter, (uint32_t)pvParameters, (uint32_t)pxCode);
263     return pxTopOfStack;
266 extern void Hwi_switchFromBootStack(void);
267 extern void Hwi_Module_startup(void);
269 TimerP_Handle pTickTimerHandle = NULL;
271 static void prvPorttimerTickIsr(uintptr_t args)
273     void vPortTimerTickHandler();
275     vPortTimerTickHandler();
278 static void prvPortInitTickTimer(void)
281     TimerP_Params timerParams;
283     TimerP_Params_init(&timerParams);
284     timerParams.runMode    = TimerP_RunMode_CONTINUOUS;
285     timerParams.startMode  = TimerP_StartMode_USER;
286     timerParams.periodType = TimerP_PeriodType_MICROSECS;
287     timerParams.period     = (portTICK_PERIOD_MS * 1000);
288     timerParams.intNum     = configTIMER_INT_NUM;
290     pTickTimerHandle = TimerP_create(configTIMER_ID, &prvPorttimerTickIsr, &timerParams);
292     /* don't expect the handle to be null */
293     DebugP_assert (pTickTimerHandle != NULL);
297 static void prvPortStartTickTimer(void)
299     TimerP_Status status;
300     status = TimerP_start(pTickTimerHandle);
302     /* don't expect the handle to be null */
303     DebugP_assert (status == TimerP_OK);
307 BaseType_t xPortStartScheduler(void)
309     /* Interrupts are turned off in the CPU itself to ensure tick does
310      * not execute      while the scheduler is being started.  Interrupts are
311      * automatically turned back on in the CPU when the first task starts
312      * executing.
313      */
314     portDISABLE_INTERRUPTS();
316     Hwi_Module_startup();
317     prvPortInitTickTimer();
318     Hwi_switchFromBootStack();
319     
320     /* Start the ISR handling of the timer that generates the tick ISR. */
321     prvPortStartTickTimer();
322     ulPortSchedularRunning = pdTRUE;
324     /* Start the first task executing. */
325     vPortRestoreTaskContext();
327     /* Will only get here if vTaskStartScheduler() was called with the CPU in
328      * a non-privileged mode or the binary point register was not set to its lowest
329      * possible value.  prvTaskExitError() is referenced to prevent a compiler
330      * warning about it being defined but not referenced in the case that the user
331      * defines their own exit address. */
332     ( void ) prvTaskExitError;
334     return pdTRUE;
337 void vPortYeildFromISR( uint32_t xSwitchRequired )
339     if( xSwitchRequired != pdFALSE )
340     {
341         ulPortYieldRequired = pdTRUE;
342     }
345 void vPortTimerTickHandler()
347     if( ulPortSchedularRunning == pdTRUE )
348     {
349         /* Increment the RTOS tick. */
350         if( xTaskIncrementTick() != pdFALSE )
351         {
352             ulPortYieldRequired = pdTRUE;
353         }
354     }
357 void vPortTaskUsesFPU( void )
359     /* A task is registering the fact that it needs an FPU context.  Set the
360      * FPU flag (which is saved as part of the task context). */
361     ulPortTaskHasFPUContext = pdTRUE;
366 /* initialize high resolution timer for CPU and task load calculation */
367 void vPortConfigTimerForRunTimeStats()
370     /* we assume clock is initialized before the schedular is started */
371     /* start TSC */
372     TSCL = 0;
375 /* return current counter value of high speed counter in units of 10's of usecs */
376 uint32_t uiPortGetRunTimeCounterValue()
378     uint64_t ts = ((uint64_t)TSCL | ((uint64_t) TSCH << 32U));
379     uint64_t timeInUsecs;
381     timeInUsecs = (ts * 1000000) / configCPU_CLOCK_HZ;
382     /* note, there is no overflow protection for this 32b value in FreeRTOS
383      *
384      * Dividing by 10 to reduce the resolution and avoid overflow for longer duration
385      * This will overflow after
386      * ((0x100000000/1000000)/(60*60))*10 hours ~ 12 hrs
387      */
388     return (uint32_t)(timeInUsecs/10);
391 /* This is used to make sure we are using the FreeRTOS API from within a valid interrupt priority level
392  * In our R%F port this means IRQ.
393  * i.e FreeRTOS API should not be called from FIQ, however right now we dont enforce it by checking
394  * if we are in FIQ when this API is called.
395  */
396 void vPortValidateInterruptPriority()
400 /* This is called as part of vTaskEndScheduler(), in our port, there is nothing to do here.
401  * interrupt are disabled by FreeRTOS before calling this.
402  */
403 void vPortEndScheduler()
405     /* nothing to do */
408 /* configCHECK_FOR_STACK_OVERFLOW is set to 1, so the application must provide an
409  * implementation of vApplicationStackOverflowHook()
410  */
411 void vApplicationStackOverflowHook( TaskHandle_t xTask,
412                                     char * pcTaskName )
414     DebugP_log1("[FreeRTOS] Stack overflow detected for task [%s]", (uintptr_t)pcTaskName);
415     DebugP_assert(0);
418 /* configSUPPORT_STATIC_ALLOCATION is set to 1, so the application must provide an
419  * implementation of vApplicationGetIdleTaskMemory() to provide the memory that is
420  * used by the Idle task.
421  */
422 void vApplicationGetIdleTaskMemory( StaticTask_t **ppxIdleTaskTCBBuffer,
423                                     StackType_t **ppxIdleTaskStackBuffer,
424                                     uint32_t *pulIdleTaskStackSize )
426 /* If the buffers to be provided to the Idle task are declared inside this
427  * function then they must be declared static – otherwise they will be allocated on
428  * the stack and so not exists after this function exits.
429  */
430 static StaticTask_t xIdleTaskTCB;
431 static StackType_t uxIdleTaskStack[ configMINIMAL_STACK_SIZE ];
433     /* Pass out a pointer to the StaticTask_t structure in which the Idle task’s
434      * state will be stored.
435      */
436     *ppxIdleTaskTCBBuffer = &xIdleTaskTCB;
438     /* Pass out the array that will be used as the Idle task’s stack. */
439     *ppxIdleTaskStackBuffer = uxIdleTaskStack;
441     /* Pass out the size of the array pointed to by *ppxIdleTaskStackBuffer.
442      * Note that, as the array is necessarily of type StackType_t,
443      * configMINIMAL_STACK_SIZE is specified in words, not bytes.
444      */
445     *pulIdleTaskStackSize = configMINIMAL_STACK_SIZE;
448 /* configSUPPORT_STATIC_ALLOCATION and configUSE_TIMERS are both set to 1, so the
449  * application must provide an implementation of vApplicationGetTimerTaskMemory()
450  * to provide the memory that is used by the Timer service task.
451  */
452 void vApplicationGetTimerTaskMemory( StaticTask_t **ppxTimerTaskTCBBuffer,
453                                      StackType_t **ppxTimerTaskStackBuffer,
454                                      uint32_t *pulTimerTaskStackSize )
456 /* If the buffers to be provided to the Timer task are declared inside this
457  * function then they must be declared static – otherwise they will be allocated on
458  * the stack and so not exists after this function exits.
459  */
460 static StaticTask_t xTimerTaskTCB;
461 static StackType_t uxTimerTaskStack[ configTIMER_TASK_STACK_DEPTH ];
463     /* Pass out a pointer to the StaticTask_t structure in which the Timer
464      * task's state will be stored.
465      */
466     *ppxTimerTaskTCBBuffer = &xTimerTaskTCB;
468     /* Pass out the array that will be used as the Timer task’s stack. */
469     *ppxTimerTaskStackBuffer = uxTimerTaskStack;
471     /* Pass out the size of the array pointed to by *ppxTimerTaskStackBuffer.
472      * Note that, as the array is necessarily of type StackType_t,
473      * configTIMER_TASK_STACK_DEPTH is specified in words, not bytes.
474      */
475     *pulTimerTaskStackSize = configTIMER_TASK_STACK_DEPTH;
478 extern void ti_sysbios_family_c62_TaskSupport_swap__E( void **oldtskContext, void **newtskContext);
481 void vPortRestoreTaskContext()
483     void * dummyTaskSp;
485     ti_sysbios_family_c62_TaskSupport_swap__E( &dummyTaskSp,  (void **)(&pxCurrentTCB->pxTopOfStack));
488 void vPortYield( void )
490     void **oldSP;
491     void **newSP;
493     portDISABLE_INTERRUPTS();
494     oldSP = ( void ** )( &pxCurrentTCB->pxTopOfStack );
495     vTaskSwitchContext();
496     newSP = ( void ** )( &pxCurrentTCB->pxTopOfStack );
497     /* We should not be swapping from one task back to same task. Indicates bug in invocation of vPortYield */
498     if(oldSP != newSP)
499     {
500         ti_sysbios_family_c62_TaskSupport_swap__E( oldSP, newSP );
501     }
502     else
503     {
504         DebugP_log1("Doing switch to same task:%p",(uintptr_t)oldSP);
505         uxPortIncorrectYieldCount++;
506     }
507     if (pxCurrentTCB->uxCriticalNesting == 0)
508     {
509         /* Enable interrupts if task was preempted outside critical section */
510         portENABLE_INTERRUPTS();
511     }
514 void vPortYieldAsyncFromISR( void )
516     void **oldSP;
517     void **newSP;
519     oldSP = ( void ** )( &pxCurrentTCB->pxTopOfStack );
520     vTaskSwitchContext();
521     newSP = ( void ** )( &pxCurrentTCB->pxTopOfStack );
522     /* We should not be swapping from one task back to same task. Indicates bug in invocation of vPortYieldAsyncFromISR */
523     DebugP_assert(oldSP != newSP);
524     ti_sysbios_family_c62_TaskSupport_swap__E( oldSP, newSP );
525     /* Interrupts should be disabled in case of async yield from ISR */
526     /* Enable interrupts if task was preempted outside critical section */
527     portDISABLE_INTERRUPTS();
531 /*
532  * Returns true if the current core is in ISR context; low prio ISR, med prio ISR or timer tick ISR. High prio ISRs
533  * aren't detected here, but they normally cannot call C code, so that should not be an issue anyway.
534  */
535 BaseType_t xPortInIsrContext()
537     BaseType_t inISR = false;
538     if (ulPortInterruptNesting != 0)
539     {
540         inISR =  true;
541     }
542     return inISR;
545 void vPortAssertIfInISR()
547     if( xPortInIsrContext() )
548     {
549         DebugP_log0( "port_interruptNesting\n\n");
550     }
552     configASSERT( !xPortInIsrContext() );
555 void vPortCacheConfig(void)
557     DSPICFGCacheEnable(SOC_DSP_ICFG_BASE,
558                     DSPICFG_MEM_L1P,
559                     portCONFIGURE_CACHE_LIP_SIZE);
560     DSPICFGCacheEnable(SOC_DSP_ICFG_BASE,
561                     DSPICFG_MEM_L1D,
562                     portCONFIGURE_CACHE_LID_SIZE);
563     DSPICFGCacheEnable(SOC_DSP_ICFG_BASE,
564                     DSPICFG_MEM_L2,
565                     portCONFIGURE_CACHE_L2_SIZE);
568 /*****************************************************************************/
569 /* _SYSTEM_PRE_INIT() - _system_pre_init() is called in the C/C++ startup    */
570 /* routine (_c_int00()) and provides a mechanism for the user to             */
571 /* insert application specific low level initialization instructions prior   */
572 /* to calling main().  The return value of _system_pre_init() is used to     */
573 /* determine whether or not C/C++ global data initialization will be         */
574 /* performed (return value of 0 to bypass C/C++ auto-initialization).        */
575 /*                                                                           */
576 /* PLEASE NOTE THAT BYPASSING THE C/C++ AUTO-INITIALIZATION ROUTINE MAY      */
577 /* RESULT IN PROGRAM FAILURE.                                                */
578 /*                                                                           */
579 /* The version of _system_pre_init() below is skeletal and is provided to    */
580 /* illustrate the interface and provide default behavior.  To replace this   */
581 /* version rewrite the routine and include it as part of the current project.*/
582 /* The linker will include the updated version if it is linked in prior to   */
583 /* linking with the C/C++ runtime library.                                   */
584 /*****************************************************************************/
586 int _system_pre_init(void)
588     vPortCacheConfig();
589     return 1;
592 /*****************************************************************************/
593 /* _SYSTEM_POST_CINIT() - _system_post_cinit() is a hook function called in  */
594 /* the C/C++ auto-initialization function after cinit() and before pinit().  */
595 /*                                                                           */
596 /* The version of _system_post_cinit() below is skeletal and is provided to  */
597 /* illustrate the interface and provide default behavior.  To replace this   */
598 /* version rewrite the routine and include it as part of the current project.*/
599 /* The linker will include the updated version if it is linked in prior to   */
600 /* linking with the C/C++ runtime library.                                   */
601 /*****************************************************************************/
603 /*---------------------------------------------------------------------------*/
604 /* __TI_default_system_post_cinit indicates that the default                 */
606 void _system_post_cinit(void)
608     osalArch_Config_t cfg;
610     cfg.disableIrqOnInit = true;
611     osalArch_Init(&cfg);