| /* |
| FreeRTOS V9.0.0rc2 - Copyright (C) 2016 Real Time Engineers Ltd. |
| All rights reserved |
| |
| VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION. |
| |
| This file is part of the FreeRTOS distribution. |
| |
| FreeRTOS is free software; you can redistribute it and/or modify it under |
| the terms of the GNU General Public License (version 2) as published by the |
| Free Software Foundation >>>> AND MODIFIED BY <<<< the FreeRTOS exception. |
| |
| *************************************************************************** |
| >>! NOTE: The modification to the GPL is included to allow you to !<< |
| >>! distribute a combined work that includes FreeRTOS without being !<< |
| >>! obliged to provide the source code for proprietary components !<< |
| >>! outside of the FreeRTOS kernel. !<< |
| *************************************************************************** |
| |
| FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY |
| WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS |
| FOR A PARTICULAR PURPOSE. Full license text is available on the following |
| link: http://www.freertos.org/a00114.html |
| |
| *************************************************************************** |
| * * |
| * FreeRTOS provides completely free yet professionally developed, * |
| * robust, strictly quality controlled, supported, and cross * |
| * platform software that is more than just the market leader, it * |
| * is the industry's de facto standard. * |
| * * |
| * Help yourself get started quickly while simultaneously helping * |
| * to support the FreeRTOS project by purchasing a FreeRTOS * |
| * tutorial book, reference manual, or both: * |
| * http://www.FreeRTOS.org/Documentation * |
| * * |
| *************************************************************************** |
| |
| http://www.FreeRTOS.org/FAQHelp.html - Having a problem? Start by reading |
| the FAQ page "My application does not run, what could be wrong?". Have you |
| defined configASSERT()? |
| |
| http://www.FreeRTOS.org/support - In return for receiving this top quality |
| embedded software for free we request you assist our global community by |
| participating in the support forum. |
| |
| http://www.FreeRTOS.org/training - Investing in training allows your team to |
| be as productive as possible as early as possible. Now you can receive |
| FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers |
| Ltd, and the world's leading authority on the world's leading RTOS. |
| |
| http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products, |
| including FreeRTOS+Trace - an indispensable productivity tool, a DOS |
| compatible FAT file system, and our tiny thread aware UDP/IP stack. |
| |
| http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate. |
| Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS. |
| |
| http://www.OpenRTOS.com - Real Time Engineers ltd. license FreeRTOS to High |
| Integrity Systems ltd. to sell under the OpenRTOS brand. Low cost OpenRTOS |
| licenses offer ticketed support, indemnification and commercial middleware. |
| |
| http://www.SafeRTOS.com - High Integrity Systems also provide a safety |
| engineered and independently SIL3 certified version for use in safety and |
| mission critical applications that require provable dependability. |
| |
| 1 tab == 4 spaces! |
| */ |
| |
| /****************************************************************************** |
| * NOTE 1: This project provides two demo applications. A simple blinky |
| * style project, and a more comprehensive test and demo application. The |
| * mainSELECTED_APPLICATION setting in main.c is used to select between the two. |
| * See the notes on using mainSELECTED_APPLICATION where it is defined below. |
| * |
| * NOTE 2: This file only contains the source code that is not specific to |
| * either the simply blinky or full demos - this includes initialisation code |
| * and callback functions. |
| */ |
| |
| /* Standard includes. */ |
| #include <stdio.h> |
| |
| /* Scheduler include files. */ |
| #include "FreeRTOS.h" |
| #include "task.h" |
| |
| /* Xilinx includes. */ |
| #include "platform.h" |
| #include "xparameters.h" |
| #include "xscugic.h" |
| #include "xil_printf.h" |
| |
| /* mainSELECTED_APPLICATION is used to select between two demo applications, |
| * as described at the top of this file. |
| * |
| * When mainSELECTED_APPLICATION is set to 0 the simple blinky example will |
| * be run. |
| * |
| * When mainSELECTED_APPLICATION is set to 1 the comprehensive test and demo |
| * application will be run. |
| */ |
| #define mainSELECTED_APPLICATION 0 |
| |
| /*-----------------------------------------------------------*/ |
| |
| /* |
| * Configure the hardware as necessary to run this demo. |
| */ |
| static void prvSetupHardware( void ); |
| |
| /* |
| * See the comments at the top of this file and above the |
| * mainSELECTED_APPLICATION definition. |
| */ |
| #if ( mainSELECTED_APPLICATION == 0 ) |
| extern void main_blinky( void ); |
| #elif ( mainSELECTED_APPLICATION == 1 ) |
| extern void main_full( void ); |
| #else |
| #error Invalid mainSELECTED_APPLICATION setting. See the comments at the top of this file and above the mainSELECTED_APPLICATION definition. |
| #endif |
| |
| /* Prototypes for the standard FreeRTOS callback/hook functions implemented |
| within this file. */ |
| void vApplicationMallocFailedHook( void ); |
| void vApplicationIdleHook( void ); |
| void vApplicationStackOverflowHook( TaskHandle_t pxTask, char *pcTaskName ); |
| void vApplicationTickHook( void ); |
| |
| /*-----------------------------------------------------------*/ |
| |
| /* The interrupt controller is initialised in this file, and made available to |
| other modules. */ |
| XScuGic xInterruptController; |
| |
| /*-----------------------------------------------------------*/ |
| |
| int main( void ) |
| { |
| /* Configure the hardware ready to run the demo. */ |
| prvSetupHardware(); |
| |
| /* The mainSELECTED_APPLICATION setting is described at the top |
| of this file. */ |
| #if( mainSELECTED_APPLICATION == 0 ) |
| { |
| main_blinky(); |
| } |
| #elif( mainSELECTED_APPLICATION == 1 ) |
| { |
| main_full(); |
| } |
| #endif |
| |
| /* Don't expect to reach here. */ |
| return 0; |
| } |
| /*-----------------------------------------------------------*/ |
| |
| static void prvSetupHardware( void ) |
| { |
| BaseType_t xStatus; |
| XScuGic_Config *pxGICConfig; |
| |
| /* Ensure no interrupts execute while the scheduler is in an inconsistent |
| state. Interrupts are automatically enabled when the scheduler is |
| started. */ |
| portDISABLE_INTERRUPTS(); |
| |
| init_platform(); |
| |
| /* Obtain the configuration of the GIC. */ |
| pxGICConfig = XScuGic_LookupConfig( XPAR_SCUGIC_SINGLE_DEVICE_ID ); |
| |
| /* Sanity check the FreeRTOSConfig.h settings are correct for the |
| hardware. */ |
| configASSERT( pxGICConfig ); |
| configASSERT( pxGICConfig->CpuBaseAddress == ( configINTERRUPT_CONTROLLER_BASE_ADDRESS + configINTERRUPT_CONTROLLER_CPU_INTERFACE_OFFSET ) ); |
| configASSERT( pxGICConfig->DistBaseAddress == configINTERRUPT_CONTROLLER_BASE_ADDRESS ); |
| |
| /* Install a default handler for each GIC interrupt. */ |
| xStatus = XScuGic_CfgInitialize( &xInterruptController, pxGICConfig, pxGICConfig->CpuBaseAddress ); |
| configASSERT( xStatus == XST_SUCCESS ); |
| ( void ) xStatus; /* Remove compiler warning if configASSERT() is not defined. */ |
| |
| /* Ensure the FPU is accessible by enabling access to CP 10 and 11. */ |
| __asm volatile( "MRC p15, 0, r0, c1, c0, 2 \n" \ |
| "ORR r0, r0, #(0xF << 20) \n" \ |
| "MCR p15, 0, r0, c1, c0, 2 \n" \ |
| "ISB " ); |
| |
| |
| /* Ensure the FPU is enabled. */ |
| __asm volatile( "VMRS r0, FPEXC \n" \ |
| "ORR r1, r0, #(1<<30) \n" \ |
| "VMSR FPEXC, r1 \n" \ |
| ::: "r0", "r1" ); |
| } |
| /*-----------------------------------------------------------*/ |
| |
| void vApplicationMallocFailedHook( void ) |
| { |
| /* Called if a call to pvPortMalloc() fails because there is insufficient |
| free memory available in the FreeRTOS heap. pvPortMalloc() is called |
| internally by FreeRTOS API functions that create tasks, queues, software |
| timers, and semaphores. The size of the FreeRTOS heap is set by the |
| configTOTAL_HEAP_SIZE configuration constant in FreeRTOSConfig.h. */ |
| taskDISABLE_INTERRUPTS(); |
| for( ;; ); |
| } |
| /*-----------------------------------------------------------*/ |
| |
| void vApplicationStackOverflowHook( TaskHandle_t pxTask, char *pcTaskName ) |
| { |
| ( void ) pcTaskName; |
| ( void ) pxTask; |
| |
| /* Run time stack overflow checking is performed if |
| configCHECK_FOR_STACK_OVERFLOW is defined to 1 or 2. This hook |
| function is called if a stack overflow is detected. */ |
| taskDISABLE_INTERRUPTS(); |
| for( ;; ); |
| } |
| /*-----------------------------------------------------------*/ |
| |
| void vApplicationIdleHook( void ) |
| { |
| volatile size_t xFreeHeapSpace; |
| |
| /* This is just a trivial example of an idle hook. It is called on each |
| cycle of the idle task. It must *NOT* attempt to block. In this case the |
| idle task just queries the amount of FreeRTOS heap that remains. See the |
| memory management section on the http://www.FreeRTOS.org web site for memory |
| management options. If there is a lot of heap memory free then the |
| configTOTAL_HEAP_SIZE value in FreeRTOSConfig.h can be reduced to free up |
| RAM. */ |
| xFreeHeapSpace = xPortGetFreeHeapSize(); |
| |
| /* Remove compiler warning about xFreeHeapSpace being set but never used. */ |
| ( void ) xFreeHeapSpace; |
| } |
| /*-----------------------------------------------------------*/ |
| |
| void vApplicationTickHook( void ) |
| { |
| #if( mainSELECTED_APPLICATION == 1 ) |
| { |
| /* Only the comprehensive demo actually uses the tick hook. */ |
| extern void vFullDemoTickHook( void ); |
| vFullDemoTickHook(); |
| } |
| #endif |
| } |
| /*-----------------------------------------------------------*/ |
| |
| /* configUSE_STATIC_ALLOCATION is set to 1, so the application must provide an |
| implementation of vApplicationGetIdleTaskMemory() to provide the memory that is |
| used by the Idle task. */ |
| void vApplicationGetIdleTaskMemory( StaticTask_t **ppxIdleTaskTCBBuffer, StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize ) |
| { |
| /* If the buffers to be provided to the Idle task are declared inside this |
| function then they must be declared static - otherwise they will be allocated on |
| the stack and so not exists after this function exits. */ |
| static StaticTask_t xIdleTaskTCB; |
| static StackType_t uxIdleTaskStack[ configMINIMAL_STACK_SIZE ]; |
| |
| /* Pass out a pointer to the StaticTask_t structure in which the Idle task's |
| state will be stored. */ |
| *ppxIdleTaskTCBBuffer = &xIdleTaskTCB; |
| |
| /* Pass out the array that will be used as the Idle task's stack. */ |
| *ppxIdleTaskStackBuffer = uxIdleTaskStack; |
| |
| /* Pass out the size of the array pointed to by *ppxIdleTaskStackBuffer. |
| Note that, as the array is necessarily of type StackType_t, |
| configMINIMAL_STACK_SIZE is specified in words, not bytes. */ |
| *pulIdleTaskStackSize = configMINIMAL_STACK_SIZE; |
| } |
| /*-----------------------------------------------------------*/ |
| |
| /* configUSE_STATIC_ALLOCATION and configUSE_TIMERS are both set to 1, so the |
| application must provide an implementation of vApplicationGetTimerTaskMemory() |
| to provide the memory that is used by the Timer service task. */ |
| void vApplicationGetTimerTaskMemory( StaticTask_t **ppxTimerTaskTCBBuffer, StackType_t **ppxTimerTaskStackBuffer, uint32_t *pulTimerTaskStackSize ) |
| { |
| /* If the buffers to be provided to the Timer task are declared inside this |
| function then they must be declared static - otherwise they will be allocated on |
| the stack and so not exists after this function exits. */ |
| static StaticTask_t xTimerTaskTCB; |
| static StackType_t uxTimerTaskStack[ configTIMER_TASK_STACK_DEPTH ]; |
| |
| /* Pass out a pointer to the StaticTask_t structure in which the Timer |
| task's state will be stored. */ |
| *ppxTimerTaskTCBBuffer = &xTimerTaskTCB; |
| |
| /* Pass out the array that will be used as the Timer task's stack. */ |
| *ppxTimerTaskStackBuffer = uxTimerTaskStack; |
| |
| /* Pass out the size of the array pointed to by *ppxTimerTaskStackBuffer. |
| Note that, as the array is necessarily of type StackType_t, |
| configMINIMAL_STACK_SIZE is specified in words, not bytes. */ |
| *pulTimerTaskStackSize = configTIMER_TASK_STACK_DEPTH; |
| } |
| /*-----------------------------------------------------------*/ |
| |
| void vMainAssertCalled( const char *pcFileName, uint32_t ulLineNumber ) |
| { |
| xil_printf( "ASSERT! Line %lu of file %s\r\n", ulLineNumber, pcFileName ); |
| taskENTER_CRITICAL(); |
| for( ;; ); |
| } |
| |
| |