Prepare for V6.

git-svn-id: https://svn.code.sf.net/p/freertos/code/trunk@884 1d2547de-c912-0410-9cb9-b8ca96c0e9e2

diff --git a/Source/queue.c b/Source/queue.c
index 495c8e3ae41d44645028246879368e6ece3ee085..f2fe31747d5c85de578fa2a6a3432aa2dcec1a2a 100644 (file)
--- a/Source/queue.c
+++ b/Source/queue.c
@@ -3,14 +3,14 @@
 \r
        This file is part of the FreeRTOS distribution.\r
 \r
 \r
        This file is part of the FreeRTOS distribution.\r
 \r

-       FreeRTOS is free software; you can redistribute it and/or modify it     under \r
-       the terms of the GNU General Public License (version 2) as published by the \r
+       FreeRTOS is free software; you can redistribute it and/or modify it     under\r
+       the terms of the GNU General Public License (version 2) as published by the\r

        Free Software Foundation and modified by the FreeRTOS exception.\r
        **NOTE** The exception to the GPL is included to allow you to distribute a\r
        Free Software Foundation and modified by the FreeRTOS exception.\r
        **NOTE** The exception to the GPL is included to allow you to distribute a\r

-       combined work that includes FreeRTOS without being obliged to provide the \r
-       source code for proprietary components outside of the FreeRTOS kernel.  \r
-       Alternative commercial license and support terms are also available upon \r
-       request.  See the licensing section of http://www.FreeRTOS.org for full \r
+       combined work that includes FreeRTOS without being obliged to provide the\r
+       source code for proprietary components outside of the FreeRTOS kernel.\r
+       Alternative commercial license and support terms are also available upon\r
+       request.  See the licensing section of http://www.FreeRTOS.org for full\r

        license details.\r
 \r
        FreeRTOS is distributed in the hope that it will be useful,     but WITHOUT\r
        license details.\r
 \r
        FreeRTOS is distributed in the hope that it will be useful,     but WITHOUT\r


@@ -24,10 +24,10 @@
 \r
 \r
        ***************************************************************************\r
 \r
 \r
        ***************************************************************************\r

-       *                                                                         *\r
-       * Looking for a quick start?  Then check out the FreeRTOS eBook!          *\r
-       * See http://www.FreeRTOS.org/Documentation for details                   *\r
-       *                                                                         *\r
+       *                                                                                                                                                *\r
+       * Looking for a quick start?  Then check out the FreeRTOS eBook!                  *\r
+       * See http://www.FreeRTOS.org/Documentation for details                            *\r
+       *                                                                                                                                                *\r

        ***************************************************************************\r
 \r
        1 tab == 4 spaces!\r
        ***************************************************************************\r
 \r
        1 tab == 4 spaces!\r


@@ -47,10 +47,18 @@
 \r
 #include <stdlib.h>\r
 #include <string.h>\r
 \r
 #include <stdlib.h>\r
 #include <string.h>\r

+\r
+/* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining\r
+all the API functions to use the MPU wrappers.  That should only be done when\r
+task.h is included from an application file. */\r
+#define MPU_WRAPPERS_INCLUDED_FROM_API_FILE\r
+\r

 #include "FreeRTOS.h"\r
 #include "task.h"\r
 #include "croutine.h"\r
 \r
 #include "FreeRTOS.h"\r
 #include "task.h"\r
 #include "croutine.h"\r
 \r

+#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE\r
+\r

 /*-----------------------------------------------------------\r
  * PUBLIC LIST API documented in list.h\r
  *----------------------------------------------------------*/\r
 /*-----------------------------------------------------------\r
  * PUBLIC LIST API documented in list.h\r
  *----------------------------------------------------------*/\r


@@ -114,32 +122,32 @@ typedef xQUEUE * xQueueHandle;
  * include the API header file (as it defines xQueueHandle differently).  These\r
  * functions are documented in the API header file.\r
  */\r
  * include the API header file (as it defines xQueueHandle differently).  These\r
  * functions are documented in the API header file.\r
  */\r

-xQueueHandle xQueueCreate( unsigned portBASE_TYPE uxQueueLength, unsigned portBASE_TYPE uxItemSize );\r
-signed portBASE_TYPE xQueueGenericSend( xQueueHandle xQueue, const void * const pvItemToQueue, portTickType xTicksToWait, portBASE_TYPE xCopyPosition );\r
-unsigned portBASE_TYPE uxQueueMessagesWaiting( const xQueueHandle pxQueue );\r
-void vQueueDelete( xQueueHandle xQueue );\r
-signed portBASE_TYPE xQueueGenericSendFromISR( xQueueHandle pxQueue, const void * const pvItemToQueue, signed portBASE_TYPE *pxHigherPriorityTaskWoken, portBASE_TYPE xCopyPosition );\r
-signed portBASE_TYPE xQueueGenericReceive( xQueueHandle pxQueue, void * const pvBuffer, portTickType xTicksToWait, portBASE_TYPE xJustPeeking );\r
-signed portBASE_TYPE xQueueReceiveFromISR( xQueueHandle pxQueue, void * const pvBuffer, signed portBASE_TYPE *pxTaskWoken );\r
-xQueueHandle xQueueCreateMutex( void );\r
-xQueueHandle xQueueCreateCountingSemaphore( unsigned portBASE_TYPE uxCountValue, unsigned portBASE_TYPE uxInitialCount );\r
-portBASE_TYPE xQueueTakeMutexRecursive( xQueueHandle xMutex, portTickType xBlockTime );\r
-portBASE_TYPE xQueueGiveMutexRecursive( xQueueHandle xMutex );\r
-signed portBASE_TYPE xQueueAltGenericSend( xQueueHandle pxQueue, const void * const pvItemToQueue, portTickType xTicksToWait, portBASE_TYPE xCopyPosition );\r
-signed portBASE_TYPE xQueueAltGenericReceive( xQueueHandle pxQueue, void * const pvBuffer, portTickType xTicksToWait, portBASE_TYPE xJustPeeking );\r
-signed portBASE_TYPE xQueueIsQueueEmptyFromISR( const xQueueHandle pxQueue );\r
-signed portBASE_TYPE xQueueIsQueueFullFromISR( const xQueueHandle pxQueue );\r
-unsigned portBASE_TYPE uxQueueMessagesWaitingFromISR( const xQueueHandle pxQueue );\r
+xQueueHandle xQueueCreate( unsigned portBASE_TYPE uxQueueLength, unsigned portBASE_TYPE uxItemSize ) PRIVILEGED_FUNCTION;\r
+signed portBASE_TYPE xQueueGenericSend( xQueueHandle xQueue, const void * const pvItemToQueue, portTickType xTicksToWait, portBASE_TYPE xCopyPosition ) PRIVILEGED_FUNCTION;\r
+unsigned portBASE_TYPE uxQueueMessagesWaiting( const xQueueHandle pxQueue ) PRIVILEGED_FUNCTION;\r
+void vQueueDelete( xQueueHandle xQueue ) PRIVILEGED_FUNCTION;\r
+signed portBASE_TYPE xQueueGenericSendFromISR( xQueueHandle pxQueue, const void * const pvItemToQueue, signed portBASE_TYPE *pxHigherPriorityTaskWoken, portBASE_TYPE xCopyPosition ) PRIVILEGED_FUNCTION;\r
+signed portBASE_TYPE xQueueGenericReceive( xQueueHandle pxQueue, void * const pvBuffer, portTickType xTicksToWait, portBASE_TYPE xJustPeeking ) PRIVILEGED_FUNCTION;\r
+signed portBASE_TYPE xQueueReceiveFromISR( xQueueHandle pxQueue, void * const pvBuffer, signed portBASE_TYPE *pxTaskWoken ) PRIVILEGED_FUNCTION;\r
+xQueueHandle xQueueCreateMutex( void ) PRIVILEGED_FUNCTION;\r
+xQueueHandle xQueueCreateCountingSemaphore( unsigned portBASE_TYPE uxCountValue, unsigned portBASE_TYPE uxInitialCount ) PRIVILEGED_FUNCTION;\r
+portBASE_TYPE xQueueTakeMutexRecursive( xQueueHandle xMutex, portTickType xBlockTime ) PRIVILEGED_FUNCTION;\r
+portBASE_TYPE xQueueGiveMutexRecursive( xQueueHandle xMutex ) PRIVILEGED_FUNCTION;\r
+signed portBASE_TYPE xQueueAltGenericSend( xQueueHandle pxQueue, const void * const pvItemToQueue, portTickType xTicksToWait, portBASE_TYPE xCopyPosition ) PRIVILEGED_FUNCTION;\r
+signed portBASE_TYPE xQueueAltGenericReceive( xQueueHandle pxQueue, void * const pvBuffer, portTickType xTicksToWait, portBASE_TYPE xJustPeeking ) PRIVILEGED_FUNCTION;\r
+signed portBASE_TYPE xQueueIsQueueEmptyFromISR( const xQueueHandle pxQueue ) PRIVILEGED_FUNCTION;\r
+signed portBASE_TYPE xQueueIsQueueFullFromISR( const xQueueHandle pxQueue ) PRIVILEGED_FUNCTION;\r
+unsigned portBASE_TYPE uxQueueMessagesWaitingFromISR( const xQueueHandle pxQueue ) PRIVILEGED_FUNCTION;\r

 \r
 /*\r
  * Co-routine queue functions differ from task queue functions.  Co-routines are\r
  * an optional component.\r
  */\r
 #if configUSE_CO_ROUTINES == 1\r
 \r
 /*\r
  * Co-routine queue functions differ from task queue functions.  Co-routines are\r
  * an optional component.\r
  */\r
 #if configUSE_CO_ROUTINES == 1\r

-       signed portBASE_TYPE xQueueCRSendFromISR( xQueueHandle pxQueue, const void *pvItemToQueue, signed portBASE_TYPE xCoRoutinePreviouslyWoken );\r
-       signed portBASE_TYPE xQueueCRReceiveFromISR( xQueueHandle pxQueue, void *pvBuffer, signed portBASE_TYPE *pxTaskWoken );\r
-       signed portBASE_TYPE xQueueCRSend( xQueueHandle pxQueue, const void *pvItemToQueue, portTickType xTicksToWait );\r
-       signed portBASE_TYPE xQueueCRReceive( xQueueHandle pxQueue, void *pvBuffer, portTickType xTicksToWait );\r
+       signed portBASE_TYPE xQueueCRSendFromISR( xQueueHandle pxQueue, const void *pvItemToQueue, signed portBASE_TYPE xCoRoutinePreviouslyWoken ) PRIVILEGED_FUNCTION;\r
+       signed portBASE_TYPE xQueueCRReceiveFromISR( xQueueHandle pxQueue, void *pvBuffer, signed portBASE_TYPE *pxTaskWoken ) PRIVILEGED_FUNCTION;\r
+       signed portBASE_TYPE xQueueCRSend( xQueueHandle pxQueue, const void *pvItemToQueue, portTickType xTicksToWait ) PRIVILEGED_FUNCTION;\r
+       signed portBASE_TYPE xQueueCRReceive( xQueueHandle pxQueue, void *pvBuffer, portTickType xTicksToWait ) PRIVILEGED_FUNCTION;\r

 #endif\r
 \r
 /*\r
 #endif\r
 \r
 /*\r


@@ -164,8 +172,8 @@ unsigned portBASE_TYPE uxQueueMessagesWaitingFromISR( const xQueueHandle pxQueue
 \r
        /* Removes a queue from the registry by simply setting the pcQueueName\r
        member to NULL. */\r
 \r
        /* Removes a queue from the registry by simply setting the pcQueueName\r
        member to NULL. */\r

-       static void vQueueUnregisterQueue( xQueueHandle xQueue );\r
-       void vQueueAddToRegistry( xQueueHandle xQueue, signed portCHAR *pcQueueName );\r
+       static void vQueueUnregisterQueue( xQueueHandle xQueue ) PRIVILEGED_FUNCTION;\r
+       void vQueueAddToRegistry( xQueueHandle xQueue, signed portCHAR *pcQueueName ) PRIVILEGED_FUNCTION;\r

 #endif\r
 \r
 /*\r
 #endif\r
 \r
 /*\r


@@ -176,32 +184,32 @@ unsigned portBASE_TYPE uxQueueMessagesWaitingFromISR( const xQueueHandle pxQueue
  * to indicate that a task may require unblocking.  When the queue in unlocked\r
  * these lock counts are inspected, and the appropriate action taken.\r
  */\r
  * to indicate that a task may require unblocking.  When the queue in unlocked\r
  * these lock counts are inspected, and the appropriate action taken.\r
  */\r

-static void prvUnlockQueue( xQueueHandle pxQueue );\r
+static void prvUnlockQueue( xQueueHandle pxQueue ) PRIVILEGED_FUNCTION;\r

 \r
 /*\r
  * Uses a critical section to determine if there is any data in a queue.\r
  *\r
  * @return pdTRUE if the queue contains no items, otherwise pdFALSE.\r
  */\r
 \r
 /*\r
  * Uses a critical section to determine if there is any data in a queue.\r
  *\r
  * @return pdTRUE if the queue contains no items, otherwise pdFALSE.\r
  */\r

-static signed portBASE_TYPE prvIsQueueEmpty( const xQueueHandle pxQueue );\r
+static signed portBASE_TYPE prvIsQueueEmpty( const xQueueHandle pxQueue ) PRIVILEGED_FUNCTION;\r

 \r
 /*\r
  * Uses a critical section to determine if there is any space in a queue.\r
  *\r
  * @return pdTRUE if there is no space, otherwise pdFALSE;\r
  */\r
 \r
 /*\r
  * Uses a critical section to determine if there is any space in a queue.\r
  *\r
  * @return pdTRUE if there is no space, otherwise pdFALSE;\r
  */\r

-static signed portBASE_TYPE prvIsQueueFull( const xQueueHandle pxQueue );\r
+static signed portBASE_TYPE prvIsQueueFull( const xQueueHandle pxQueue ) PRIVILEGED_FUNCTION;\r

 \r
 /*\r
  * Copies an item into the queue, either at the front of the queue or the\r
  * back of the queue.\r
  */\r
 \r
 /*\r
  * Copies an item into the queue, either at the front of the queue or the\r
  * back of the queue.\r
  */\r

-static void prvCopyDataToQueue( xQUEUE *pxQueue, const void *pvItemToQueue, portBASE_TYPE xPosition );\r
+static void prvCopyDataToQueue( xQUEUE *pxQueue, const void *pvItemToQueue, portBASE_TYPE xPosition ) PRIVILEGED_FUNCTION;\r

 \r
 /*\r
  * Copies an item out of a queue.\r
  */\r
 \r
 /*\r
  * Copies an item out of a queue.\r
  */\r

-static void prvCopyDataFromQueue( xQUEUE * const pxQueue, const void *pvBuffer );\r
+static void prvCopyDataFromQueue( xQUEUE * const pxQueue, const void *pvBuffer ) PRIVILEGED_FUNCTION;\r

 /*-----------------------------------------------------------*/\r
 \r
 /*\r
 /*-----------------------------------------------------------*/\r
 \r
 /*\r


@@ -264,7 +272,6 @@ size_t xQueueSizeInBytes;
                                vListInitialise( &( pxNewQueue->xTasksWaitingToReceive ) );\r
 \r
                                traceQUEUE_CREATE( pxNewQueue );\r
                                vListInitialise( &( pxNewQueue->xTasksWaitingToReceive ) );\r
 \r
                                traceQUEUE_CREATE( pxNewQueue );\r

-\r

                                return  pxNewQueue;\r
                        }\r
                        else\r
                                return  pxNewQueue;\r
                        }\r
                        else\r


@@ -357,7 +364,7 @@ size_t xQueueSizeInBytes;
                        {\r
                                /* Return the mutex.  This will automatically unblock any other\r
                                task that might be waiting to access the mutex. */\r
                        {\r
                                /* Return the mutex.  This will automatically unblock any other\r
                                task that might be waiting to access the mutex. */\r

-                xQueueGenericSend( pxMutex, NULL, queueMUTEX_GIVE_BLOCK_TIME, queueSEND_TO_BACK );\r
+                               xQueueGenericSend( pxMutex, NULL, queueMUTEX_GIVE_BLOCK_TIME, queueSEND_TO_BACK );\r

                        }\r
 \r
                        xReturn = pdPASS;\r
                        }\r
 \r
                        xReturn = pdPASS;\r


@@ -394,7 +401,7 @@ size_t xQueueSizeInBytes;
                }\r
                else\r
                {\r
                }\r
                else\r
                {\r

-            xReturn = xQueueGenericReceive( pxMutex, NULL, xBlockTime, pdFALSE );\r
+                       xReturn = xQueueGenericReceive( pxMutex, NULL, xBlockTime, pdFALSE );\r

 \r
                        /* pdPASS will only be returned if we successfully obtained the mutex,\r
                        we may have blocked to reach here. */\r
 \r
                        /* pdPASS will only be returned if we successfully obtained the mutex,\r
                        we may have blocked to reach here. */\r


@@ -443,13 +450,12 @@ xTimeOutType xTimeOut;
        /* This function relaxes the coding standard somewhat to allow return\r
        statements within the function itself.  This is done in the interest\r
        of execution time efficiency. */\r
        /* This function relaxes the coding standard somewhat to allow return\r
        statements within the function itself.  This is done in the interest\r
        of execution time efficiency. */\r

-\r

        for( ;; )\r
        {\r
                taskENTER_CRITICAL();\r
                {\r
        for( ;; )\r
        {\r
                taskENTER_CRITICAL();\r
                {\r

-                       /* Is there room on the queue now?  To be running we must be\r
-                       the highest priority task wanting to access the queue. */\r
+                       /* Is there room on the queue now?  To be running we must be\r
+                       the highest priority task wanting to access the queue. */\r

                        if( pxQueue->uxMessagesWaiting < pxQueue->uxLength )\r
                        {\r
                                traceQUEUE_SEND( pxQueue );\r
                        if( pxQueue->uxMessagesWaiting < pxQueue->uxLength )\r
                        {\r
                                traceQUEUE_SEND( pxQueue );\r


@@ -465,11 +471,14 @@ xTimeOutType xTimeOut;
                                                our own so yield immediately.  Yes it is ok to do\r
                                                this from within the critical section - the kernel\r
                                                takes care of that. */\r
                                                our own so yield immediately.  Yes it is ok to do\r
                                                this from within the critical section - the kernel\r
                                                takes care of that. */\r

-                                               taskYIELD();\r
+                                               portYIELD_WITHIN_API();\r

                                        }\r
                                }\r
 \r
                                taskEXIT_CRITICAL();\r
                                        }\r
                                }\r
 \r
                                taskEXIT_CRITICAL();\r

+\r
+                               /* Return to the original privilege level before exiting the\r
+                               function. */\r

                                return pdPASS;\r
                        }\r
                        else\r
                                return pdPASS;\r
                        }\r
                        else\r


@@ -479,6 +488,9 @@ xTimeOutType xTimeOut;
                                        /* The queue was full and no block time is specified (or\r
                                        the block time has expired) so leave now. */\r
                                        taskEXIT_CRITICAL();\r
                                        /* The queue was full and no block time is specified (or\r
                                        the block time has expired) so leave now. */\r
                                        taskEXIT_CRITICAL();\r

+\r
+                                       /* Return to the original privilege level before exiting\r
+                                       the function. */\r

                                        traceQUEUE_SEND_FAILED( pxQueue );\r
                                        return errQUEUE_FULL;\r
                                }\r
                                        traceQUEUE_SEND_FAILED( pxQueue );\r
                                        return errQUEUE_FULL;\r
                                }\r


@@ -521,7 +533,7 @@ xTimeOutType xTimeOut;
                                is also a higher priority task in the pending ready list. */\r
                                if( !xTaskResumeAll() )\r
                                {\r
                                is also a higher priority task in the pending ready list. */\r
                                if( !xTaskResumeAll() )\r
                                {\r

-                                       taskYIELD();\r
+                                       portYIELD_WITHIN_API();\r

                                }\r
                        }\r
                        else\r
                                }\r
                        }\r
                        else\r


@@ -536,6 +548,9 @@ xTimeOutType xTimeOut;
                        /* The timeout has expired. */\r
                        prvUnlockQueue( pxQueue );\r
                        ( void ) xTaskResumeAll();\r
                        /* The timeout has expired. */\r
                        prvUnlockQueue( pxQueue );\r
                        ( void ) xTaskResumeAll();\r

+\r
+                       /* Return to the original privilege level before exiting the\r
+                       function. */\r

                        traceQUEUE_SEND_FAILED( pxQueue );\r
                        return errQUEUE_FULL;\r
                }\r
                        traceQUEUE_SEND_FAILED( pxQueue );\r
                        return errQUEUE_FULL;\r
                }\r


@@ -554,8 +569,8 @@ xTimeOutType xTimeOut;
                {\r
                        taskENTER_CRITICAL();\r
                        {\r
                {\r
                        taskENTER_CRITICAL();\r
                        {\r

-                               /* Is there room on the queue now?  To be running we must be\r
-                               the highest priority task wanting to access the queue. */\r
+                               /* Is there room on the queue now?  To be running we must be\r
+                               the highest priority task wanting to access the queue. */\r

                                if( pxQueue->uxMessagesWaiting < pxQueue->uxLength )\r
                                {\r
                                        traceQUEUE_SEND( pxQueue );\r
                                if( pxQueue->uxMessagesWaiting < pxQueue->uxLength )\r
                                {\r
                                        traceQUEUE_SEND( pxQueue );\r


@@ -569,7 +584,7 @@ xTimeOutType xTimeOut;
                                                {\r
                                                        /* The unblocked task has a priority higher than\r
                                                        our own so yield immediately. */\r
                                                {\r
                                                        /* The unblocked task has a priority higher than\r
                                                        our own so yield immediately. */\r

-                                                       taskYIELD();\r
+                                                       portYIELD_WITHIN_API();\r

                                                }\r
                                        }\r
 \r
                                                }\r
                                        }\r
 \r


@@ -600,7 +615,7 @@ xTimeOutType xTimeOut;
                                        {\r
                                                traceBLOCKING_ON_QUEUE_SEND( pxQueue );\r
                                                vTaskPlaceOnEventList( &( pxQueue->xTasksWaitingToSend ), xTicksToWait );\r
                                        {\r
                                                traceBLOCKING_ON_QUEUE_SEND( pxQueue );\r
                                                vTaskPlaceOnEventList( &( pxQueue->xTasksWaitingToSend ), xTicksToWait );\r

-                                               taskYIELD();\r
+                                               portYIELD_WITHIN_API();\r

                                        }\r
                                }\r
                                else\r
                                        }\r
                                }\r
                                else\r


@@ -658,7 +673,7 @@ xTimeOutType xTimeOut;
                                                {\r
                                                        if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) == pdTRUE )\r
                                                        {\r
                                                {\r
                                                        if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) == pdTRUE )\r
                                                        {\r

-                                                               taskYIELD();\r
+                                                               portYIELD_WITHIN_API();\r

                                                        }\r
                                                }\r
                                        }\r
                                                        }\r
                                                }\r
                                        }\r


@@ -679,7 +694,7 @@ xTimeOutType xTimeOut;
                                                        if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )\r
                                                        {\r
                                                                /* The task waiting has a higher priority than this task. */\r
                                                        if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )\r
                                                        {\r
                                                                /* The task waiting has a higher priority than this task. */\r

-                                                               taskYIELD();\r
+                                                               portYIELD_WITHIN_API();\r

                                                        }\r
                                                }\r
 \r
                                                        }\r
                                                }\r
 \r


@@ -725,7 +740,7 @@ xTimeOutType xTimeOut;
                                                #endif\r
 \r
                                                vTaskPlaceOnEventList( &( pxQueue->xTasksWaitingToReceive ), xTicksToWait );\r
                                                #endif\r
 \r
                                                vTaskPlaceOnEventList( &( pxQueue->xTasksWaitingToReceive ), xTicksToWait );\r

-                                               taskYIELD();\r
+                                               portYIELD_WITHIN_API();\r

                                        }\r
                                }\r
                                else\r
                                        }\r
                                }\r
                                else\r


@@ -810,8 +825,8 @@ signed portCHAR *pcOriginalReadPosition;
        {\r
                taskENTER_CRITICAL();\r
                {\r
        {\r
                taskENTER_CRITICAL();\r
                {\r

-                       /* Is there data in the queue now?  To be running we must be\r
-                       the highest priority task wanting to access the queue. */\r
+                       /* Is there data in the queue now?  To be running we must be\r
+                       the highest priority task wanting to access the queue. */\r

                        if( pxQueue->uxMessagesWaiting > ( unsigned portBASE_TYPE ) 0 )\r
                        {\r
                                /* Remember our read position in case we are just peeking. */\r
                        if( pxQueue->uxMessagesWaiting > ( unsigned portBASE_TYPE ) 0 )\r
                        {\r
                                /* Remember our read position in case we are just peeking. */\r


@@ -841,7 +856,7 @@ signed portCHAR *pcOriginalReadPosition;
                                        {\r
                                                if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) == pdTRUE )\r
                                                {\r
                                        {\r
                                                if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) == pdTRUE )\r
                                                {\r

-                                                       taskYIELD();\r
+                                                       portYIELD_WITHIN_API();\r

                                                }\r
                                        }\r
                                }\r
                                                }\r
                                        }\r
                                }\r


@@ -862,7 +877,7 @@ signed portCHAR *pcOriginalReadPosition;
                                                if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )\r
                                                {\r
                                                        /* The task waiting has a higher priority than this task. */\r
                                                if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )\r
                                                {\r
                                                        /* The task waiting has a higher priority than this task. */\r

-                                                       taskYIELD();\r
+                                                       portYIELD_WITHIN_API();\r

                                                }\r
                                        }\r
 \r
                                                }\r
                                        }\r
 \r


@@ -922,7 +937,7 @@ signed portCHAR *pcOriginalReadPosition;
                                prvUnlockQueue( pxQueue );\r
                                if( !xTaskResumeAll() )\r
                                {\r
                                prvUnlockQueue( pxQueue );\r
                                if( !xTaskResumeAll() )\r
                                {\r

-                                       taskYIELD();\r
+                                       portYIELD_WITHIN_API();\r

                                }\r
                        }\r
                        else\r
                                }\r
                        }\r
                        else\r


@@ -1035,7 +1050,7 @@ static void prvCopyDataToQueue( xQUEUE *pxQueue, const void *pvItemToQueue, port
                        {\r
                                /* The mutex is no longer being held. */\r
                                vTaskPriorityDisinherit( ( void * ) pxQueue->pxMutexHolder );\r
                        {\r
                                /* The mutex is no longer being held. */\r
                                vTaskPriorityDisinherit( ( void * ) pxQueue->pxMutexHolder );\r

-                pxQueue->pxMutexHolder = NULL;\r
+                               pxQueue->pxMutexHolder = NULL;\r

                        }\r
                }\r
                #endif\r
                        }\r
                }\r
                #endif\r


@@ -1437,6 +1452,7 @@ signed portBASE_TYPE xReturn;
                                break;\r
                        }\r
                }\r
                                break;\r
                        }\r
                }\r

+\r

        }\r
 \r
 #endif\r
        }\r
 \r
 #endif\r