git.sur5r.net Git - freertos/blob - FreeRTOS/Source/include/mpu_wrappers.h

   1 /*\r
   2     FreeRTOS V9.0.0 - Copyright (C) 2016 Real Time Engineers Ltd.\r
   3     All rights reserved\r
   4 \r
   5     VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.\r
   6 \r
   7     This file is part of the FreeRTOS distribution.\r
   8 \r
   9     FreeRTOS is free software; you can redistribute it and/or modify it under\r
  10     the terms of the GNU General Public License (version 2) as published by the\r
  11     Free Software Foundation >>>> AND MODIFIED BY <<<< the FreeRTOS exception.\r
  12 \r
  13     ***************************************************************************\r
  14     >>!   NOTE: The modification to the GPL is included to allow you to     !<<\r
  15     >>!   distribute a combined work that includes FreeRTOS without being   !<<\r
  16     >>!   obliged to provide the source code for proprietary components     !<<\r
  17     >>!   outside of the FreeRTOS kernel.                                   !<<\r
  18     ***************************************************************************\r
  19 \r
  20     FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY\r
  21     WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS\r
  22     FOR A PARTICULAR PURPOSE.  Full license text is available on the following\r
  23     link: http://www.freertos.org/a00114.html\r
  24 \r
  25     ***************************************************************************\r
  26      *                                                                       *\r
  27      *    FreeRTOS provides completely free yet professionally developed,    *\r
  28      *    robust, strictly quality controlled, supported, and cross          *\r
  29      *    platform software that is more than just the market leader, it     *\r
  30      *    is the industry's de facto standard.                               *\r
  31      *                                                                       *\r
  32      *    Help yourself get started quickly while simultaneously helping     *\r
  33      *    to support the FreeRTOS project by purchasing a FreeRTOS           *\r
  34      *    tutorial book, reference manual, or both:                          *\r
  35      *    http://www.FreeRTOS.org/Documentation                              *\r
  36      *                                                                       *\r
  37     ***************************************************************************\r
  38 \r
  39     http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading\r
  40     the FAQ page "My application does not run, what could be wrong?".  Have you\r
  41     defined configASSERT()?\r
  42 \r
  43     http://www.FreeRTOS.org/support - In return for receiving this top quality\r
  44     embedded software for free we request you assist our global community by\r
  45     participating in the support forum.\r
  46 \r
  47     http://www.FreeRTOS.org/training - Investing in training allows your team to\r
  48     be as productive as possible as early as possible.  Now you can receive\r
  49     FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers\r
  50     Ltd, and the world's leading authority on the world's leading RTOS.\r
  51 \r
  52     http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,\r
  53     including FreeRTOS+Trace - an indispensable productivity tool, a DOS\r
  54     compatible FAT file system, and our tiny thread aware UDP/IP stack.\r
  55 \r
  56     http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.\r
  57     Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.\r
  58 \r
  59     http://www.OpenRTOS.com - Real Time Engineers ltd. license FreeRTOS to High\r
  60     Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS\r
  61     licenses offer ticketed support, indemnification and commercial middleware.\r
  62 \r
  63     http://www.SafeRTOS.com - High Integrity Systems also provide a safety\r
  64     engineered and independently SIL3 certified version for use in safety and\r
  65     mission critical applications that require provable dependability.\r
  66 \r
  67     1 tab == 4 spaces!\r
  68 */\r
  69 \r
  70 #ifndef MPU_WRAPPERS_H\r
  71 #define MPU_WRAPPERS_H\r
  72 \r
  73 /* This file redefines API functions to be called through a wrapper macro, but\r
  74 only for ports that are using the MPU. */\r
  75 #ifdef portUSING_MPU_WRAPPERS\r
  76 \r
  77         /* MPU_WRAPPERS_INCLUDED_FROM_API_FILE will be defined when this file is\r
  78         included from queue.c or task.c to prevent it from having an effect within\r
  79         those files. */\r
  80         #ifndef MPU_WRAPPERS_INCLUDED_FROM_API_FILE\r
  81 \r
  82                 /*\r
  83                  * Map standard (non MPU) API functions to equivalents that start\r
  84                  * "MPU_".  This will cause the application code to call the MPU_\r
  85                  * version, which wraps the non-MPU version with privilege promoting\r
  86                  * then demoting code, so the kernel code always runs will full\r
  87                  * privileges.\r
  88                  */\r
  89 \r
  90                 /* Map standard tasks.h API functions to the MPU equivalents. */\r
  91                 #define xTaskCreate                                                             MPU_xTaskCreate\r
  92                 #define xTaskCreateStatic                                               MPU_xTaskCreateStatic\r
  93                 #define xTaskCreateRestricted                                   MPU_xTaskCreateRestricted\r
  94                 #define vTaskAllocateMPURegions                                 MPU_vTaskAllocateMPURegions\r
  95                 #define vTaskDelete                                                             MPU_vTaskDelete\r
  96                 #define vTaskDelay                                                              MPU_vTaskDelay\r
  97                 #define vTaskDelayUntil                                                 MPU_vTaskDelayUntil\r
  98                 #define xTaskAbortDelay                                                 MPU_xTaskAbortDelay\r
  99                 #define uxTaskPriorityGet                                               MPU_uxTaskPriorityGet\r
 100                 #define eTaskGetState                                                   MPU_eTaskGetState\r
 101                 #define vTaskGetInfo                                                    MPU_vTaskGetInfo\r
 102                 #define vTaskPrioritySet                                                MPU_vTaskPrioritySet\r
 103                 #define vTaskSuspend                                                    MPU_vTaskSuspend\r
 104                 #define vTaskResume                                                             MPU_vTaskResume\r
 105                 #define vTaskSuspendAll                                                 MPU_vTaskSuspendAll\r
 106                 #define xTaskResumeAll                                                  MPU_xTaskResumeAll\r
 107                 #define xTaskGetTickCount                                               MPU_xTaskGetTickCount\r
 108                 #define uxTaskGetNumberOfTasks                                  MPU_uxTaskGetNumberOfTasks\r
 109                 #define pcTaskGetName                                                   MPU_pcTaskGetName\r
 110                 #define xTaskGetHandle                                                  MPU_xTaskGetHandle\r
 111                 #define uxTaskGetStackHighWaterMark                             MPU_uxTaskGetStackHighWaterMark\r
 112                 #define vTaskSetApplicationTaskTag                              MPU_vTaskSetApplicationTaskTag\r
 113                 #define xTaskGetApplicationTaskTag                              MPU_xTaskGetApplicationTaskTag\r
 114                 #define vTaskSetThreadLocalStoragePointer               MPU_vTaskSetThreadLocalStoragePointer\r
 115                 #define pvTaskGetThreadLocalStoragePointer              MPU_pvTaskGetThreadLocalStoragePointer\r
 116                 #define xTaskCallApplicationTaskHook                    MPU_xTaskCallApplicationTaskHook\r
 117                 #define xTaskGetIdleTaskHandle                                  MPU_xTaskGetIdleTaskHandle\r
 118                 #define uxTaskGetSystemState                                    MPU_uxTaskGetSystemState\r
 119                 #define vTaskList                                                               MPU_vTaskList\r
 120                 #define vTaskGetRunTimeStats                                    MPU_vTaskGetRunTimeStats\r
 121                 #define xTaskGenericNotify                                              MPU_xTaskGenericNotify\r
 122                 #define xTaskNotifyWait                                                 MPU_xTaskNotifyWait\r
 123                 #define ulTaskNotifyTake                                                MPU_ulTaskNotifyTake\r
 124                 #define xTaskNotifyStateClear                                   MPU_xTaskNotifyStateClear\r
 125 \r
 126                 #define xTaskGetCurrentTaskHandle                               MPU_xTaskGetCurrentTaskHandle\r
 127                 #define vTaskSetTimeOutState                                    MPU_vTaskSetTimeOutState\r
 128                 #define xTaskCheckForTimeOut                                    MPU_xTaskCheckForTimeOut\r
 129                 #define xTaskGetSchedulerState                                  MPU_xTaskGetSchedulerState\r
 130 \r
 131                 /* Map standard queue.h API functions to the MPU equivalents. */\r
 132                 #define xQueueGenericSend                                               MPU_xQueueGenericSend\r
 133                 #define xQueueReceive                                                   MPU_xQueueReceive\r
 134                 #define xQueuePeek                                                              MPU_xQueuePeek\r
 135                 #define xQueueSemaphoreTake                                             MPU_xQueueSemaphoreTake\r
 136                 #define uxQueueMessagesWaiting                                  MPU_uxQueueMessagesWaiting\r
 137                 #define uxQueueSpacesAvailable                                  MPU_uxQueueSpacesAvailable\r
 138                 #define vQueueDelete                                                    MPU_vQueueDelete\r
 139                 #define xQueueCreateMutex                                               MPU_xQueueCreateMutex\r
 140                 #define xQueueCreateMutexStatic                                 MPU_xQueueCreateMutexStatic\r
 141                 #define xQueueCreateCountingSemaphore                   MPU_xQueueCreateCountingSemaphore\r
 142                 #define xQueueCreateCountingSemaphoreStatic             MPU_xQueueCreateCountingSemaphoreStatic\r
 143                 #define xQueueGetMutexHolder                                    MPU_xQueueGetMutexHolder\r
 144                 #define xQueueTakeMutexRecursive                                MPU_xQueueTakeMutexRecursive\r
 145                 #define xQueueGiveMutexRecursive                                MPU_xQueueGiveMutexRecursive\r
 146                 #define xQueueGenericCreate                                             MPU_xQueueGenericCreate\r
 147                 #define xQueueGenericCreateStatic                               MPU_xQueueGenericCreateStatic\r
 148                 #define xQueueCreateSet                                                 MPU_xQueueCreateSet\r
 149                 #define xQueueAddToSet                                                  MPU_xQueueAddToSet\r
 150                 #define xQueueRemoveFromSet                                             MPU_xQueueRemoveFromSet\r
 151                 #define xQueueSelectFromSet                                             MPU_xQueueSelectFromSet\r
 152                 #define xQueueGenericReset                                              MPU_xQueueGenericReset\r
 153 \r
 154                 #if( configQUEUE_REGISTRY_SIZE > 0 )\r
 155                         #define vQueueAddToRegistry                                             MPU_vQueueAddToRegistry\r
 156                         #define vQueueUnregisterQueue                                   MPU_vQueueUnregisterQueue\r
 157                         #define pcQueueGetName                                                  MPU_pcQueueGetName\r
 158                 #endif\r
 159 \r
 160                 /* Map standard timer.h API functions to the MPU equivalents. */\r
 161                 #define xTimerCreate                                                    MPU_xTimerCreate\r
 162                 #define xTimerCreateStatic                                              MPU_xTimerCreateStatic\r
 163                 #define pvTimerGetTimerID                                               MPU_pvTimerGetTimerID\r
 164                 #define vTimerSetTimerID                                                MPU_vTimerSetTimerID\r
 165                 #define xTimerIsTimerActive                                             MPU_xTimerIsTimerActive\r
 166                 #define xTimerGetTimerDaemonTaskHandle                  MPU_xTimerGetTimerDaemonTaskHandle\r
 167                 #define xTimerPendFunctionCall                                  MPU_xTimerPendFunctionCall\r
 168                 #define pcTimerGetName                                                  MPU_pcTimerGetName\r
 169                 #define xTimerGetPeriod                                                 MPU_xTimerGetPeriod\r
 170                 #define xTimerGetExpiryTime                                             MPU_xTimerGetExpiryTime\r
 171                 #define xTimerGenericCommand                                    MPU_xTimerGenericCommand\r
 172 \r
 173                 /* Map standard event_group.h API functions to the MPU equivalents. */\r
 174                 #define xEventGroupCreate                                               MPU_xEventGroupCreate\r
 175                 #define xEventGroupCreateStatic                                 MPU_xEventGroupCreateStatic\r
 176                 #define xEventGroupWaitBits                                             MPU_xEventGroupWaitBits\r
 177                 #define xEventGroupClearBits                                    MPU_xEventGroupClearBits\r
 178                 #define xEventGroupSetBits                                              MPU_xEventGroupSetBits\r
 179                 #define xEventGroupSync                                                 MPU_xEventGroupSync\r
 180                 #define vEventGroupDelete                                               MPU_vEventGroupDelete\r
 181 \r
 182                 /* Remove the privileged function macro, but keep the PRIVILEGED_DATA\r
 183                 macro so applications can place data in privileged access sections\r
 184                 (useful when using statically allocated objects). */\r
 185                 #define PRIVILEGED_FUNCTION\r
 186                 #define PRIVILEGED_DATA __attribute__((section("privileged_data")))\r
 187 \r
 188         #else /* MPU_WRAPPERS_INCLUDED_FROM_API_FILE */\r
 189 \r
 190                 /* Ensure API functions go in the privileged execution section. */\r
 191                 #define PRIVILEGED_FUNCTION __attribute__((section("privileged_functions")))\r
 192                 #define PRIVILEGED_DATA __attribute__((section("privileged_data")))\r
 193 \r
 194         #endif /* MPU_WRAPPERS_INCLUDED_FROM_API_FILE */\r
 195 \r
 196 #else /* portUSING_MPU_WRAPPERS */\r
 197 \r
 198         #define PRIVILEGED_FUNCTION\r
 199         #define PRIVILEGED_DATA\r
 200         #define portUSING_MPU_WRAPPERS 0\r
 201 \r
 202 #endif /* portUSING_MPU_WRAPPERS */\r
 203 \r
 204 \r
 205 #endif /* MPU_WRAPPERS_H */\r
 206 \r