From 52dbaa22cd3c168b55adfba1835ea851afb66b85 Mon Sep 17 00:00:00 2001
From: rtel <rtel@1d2547de-c912-0410-9cb9-b8ca96c0e9e2>
Date: Wed, 24 Dec 2014 09:40:58 +0000
Subject: [PATCH] Release candidate - this will be tagged as FreeRTOS V8.2.0rc1
 and a zip file provided. Minor lint changes.

git-svn-id: https://svn.code.sf.net/p/freertos/code/trunk@2320 1d2547de-c912-0410-9cb9-b8ca96c0e9e2
---
 .../NetworkInterface/SAM4E/NetworkInterface.c |  2 +-
 FreeRTOS/Demo/Common/Minimal/TaskNotify.c     |  2 +-
 FreeRTOS/Source/include/list.h                | 34 +++----
 FreeRTOS/Source/include/task.h                | 95 ++++++++-----------
 FreeRTOS/Source/list.c                        |  4 +-
 FreeRTOS/Source/tasks.c                       | 19 ++--
 6 files changed, 69 insertions(+), 87 deletions(-)

diff --git a/FreeRTOS-Plus/Source/FreeRTOS-Plus-UDP/portable/NetworkInterface/SAM4E/NetworkInterface.c b/FreeRTOS-Plus/Source/FreeRTOS-Plus-UDP/portable/NetworkInterface/SAM4E/NetworkInterface.c
index 0228e51d0..c25c0c31f 100644
--- a/FreeRTOS-Plus/Source/FreeRTOS-Plus-UDP/portable/NetworkInterface/SAM4E/NetworkInterface.c
+++ b/FreeRTOS-Plus/Source/FreeRTOS-Plus-UDP/portable/NetworkInterface/SAM4E/NetworkInterface.c
@@ -159,7 +159,7 @@ BaseType_t xHigherPriorityTaskWoken = pdFALSE;
 	/* Unblock the deferred interrupt handler task if the event was an Rx. */
 	if( ( ulStatus & GMAC_RSR_REC ) != 0 )
 	{
-		xTaskNotifyGiveFromISR( xMACEventHandlingTask, &xHigherPriorityTaskWoken );
+		vTaskNotifyGiveFromISR( xMACEventHandlingTask, &xHigherPriorityTaskWoken );
 	}
 
 	portEND_SWITCHING_ISR( xHigherPriorityTaskWoken );
diff --git a/FreeRTOS/Demo/Common/Minimal/TaskNotify.c b/FreeRTOS/Demo/Common/Minimal/TaskNotify.c
index ca2bf18fd..347eb30e6 100644
--- a/FreeRTOS/Demo/Common/Minimal/TaskNotify.c
+++ b/FreeRTOS/Demo/Common/Minimal/TaskNotify.c
@@ -489,7 +489,7 @@ const BaseType_t xCallInterval = pdMS_TO_TICKS( 50 );
 			/* It is time to 'give' the notification again. */
 			xCallCount = 0;
 
-			xTaskNotifyGiveFromISR( xTaskToNotify, NULL );
+			vTaskNotifyGiveFromISR( xTaskToNotify, NULL );
 			ulTimerNotificationsSent++;
 		}
 	}
diff --git a/FreeRTOS/Source/include/list.h b/FreeRTOS/Source/include/list.h
index dddf6c6ca..c03cb23de 100644
--- a/FreeRTOS/Source/include/list.h
+++ b/FreeRTOS/Source/include/list.h
@@ -171,26 +171,26 @@ memory.  They will not catch data errors caused by incorrect configuration or
 use of FreeRTOS.*/
 #if( configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES == 0 )
 	/* Define the macros to do nothing. */
-	#define listLIST_ITEM_INTEGRITY_CHECK_VALUE_1
-	#define listLIST_ITEM_INTEGRITY_CHECK_VALUE_2
-	#define listLIST_INTEGRITY_CHECK_VALUE_1
-	#define listLIST_INTEGRITY_CHECK_VALUE_2
-	#define listSET_LIST_ITEM_INTEGRITY_CHECK_1_VALUE( pxItem )
-	#define listSET_LIST_ITEM_INTEGRITY_CHECK_2_VALUE( pxItem )
+	#define listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE
+	#define listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE
+	#define listFIRST_LIST_INTEGRITY_CHECK_VALUE
+	#define listSECOND_LIST_INTEGRITY_CHECK_VALUE
+	#define listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem )
+	#define listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem )
 	#define listSET_LIST_INTEGRITY_CHECK_1_VALUE( pxList )
 	#define listSET_LIST_INTEGRITY_CHECK_2_VALUE( pxList )
 	#define listTEST_LIST_ITEM_INTEGRITY( pxItem )
 	#define listTEST_LIST_INTEGRITY( pxList )
 #else
 	/* Define macros that add new members into the list structures. */
-	#define listLIST_ITEM_INTEGRITY_CHECK_VALUE_1				TickType_t xListItemIntegrityValue1;
-	#define listLIST_ITEM_INTEGRITY_CHECK_VALUE_2				TickType_t xListItemIntegrityValue2;
-	#define listLIST_INTEGRITY_CHECK_VALUE_1					TickType_t xListIntegrityValue1;
-	#define listLIST_INTEGRITY_CHECK_VALUE_2					TickType_t xListIntegrityValue2;
+	#define listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE				TickType_t xListItemIntegrityValue1;
+	#define listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE				TickType_t xListItemIntegrityValue2;
+	#define listFIRST_LIST_INTEGRITY_CHECK_VALUE					TickType_t xListIntegrityValue1;
+	#define listSECOND_LIST_INTEGRITY_CHECK_VALUE					TickType_t xListIntegrityValue2;
 
 	/* Define macros that set the new structure members to known values. */
-	#define listSET_LIST_ITEM_INTEGRITY_CHECK_1_VALUE( pxItem )	( pxItem )->xListItemIntegrityValue1 = pdINTEGRITY_CHECK_VALUE
-	#define listSET_LIST_ITEM_INTEGRITY_CHECK_2_VALUE( pxItem )	( pxItem )->xListItemIntegrityValue2 = pdINTEGRITY_CHECK_VALUE
+	#define listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem )		( pxItem )->xListItemIntegrityValue1 = pdINTEGRITY_CHECK_VALUE
+	#define listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem )	( pxItem )->xListItemIntegrityValue2 = pdINTEGRITY_CHECK_VALUE
 	#define listSET_LIST_INTEGRITY_CHECK_1_VALUE( pxList )		( pxList )->xListIntegrityValue1 = pdINTEGRITY_CHECK_VALUE
 	#define listSET_LIST_INTEGRITY_CHECK_2_VALUE( pxList )		( pxList )->xListIntegrityValue2 = pdINTEGRITY_CHECK_VALUE
 
@@ -206,19 +206,19 @@ use of FreeRTOS.*/
  */
 struct xLIST_ITEM
 {
-	listLIST_ITEM_INTEGRITY_CHECK_VALUE_1				/*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
+	listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE				/*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
 	configLIST_VOLATILE TickType_t xItemValue;			/*< The value being listed.  In most cases this is used to sort the list in descending order. */
 	struct xLIST_ITEM * configLIST_VOLATILE pxNext;		/*< Pointer to the next ListItem_t in the list. */
 	struct xLIST_ITEM * configLIST_VOLATILE pxPrevious;	/*< Pointer to the previous ListItem_t in the list. */
 	void * pvOwner;										/*< Pointer to the object (normally a TCB) that contains the list item.  There is therefore a two way link between the object containing the list item and the list item itself. */
 	void * configLIST_VOLATILE pvContainer;				/*< Pointer to the list in which this list item is placed (if any). */
-	listLIST_ITEM_INTEGRITY_CHECK_VALUE_2				/*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
+	listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE				/*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
 };
 typedef struct xLIST_ITEM ListItem_t;					/* For some reason lint wants this as two separate definitions. */
 
 struct xMINI_LIST_ITEM
 {
-	listLIST_ITEM_INTEGRITY_CHECK_VALUE_1				/*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
+	listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE				/*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
 	configLIST_VOLATILE TickType_t xItemValue;
 	struct xLIST_ITEM * configLIST_VOLATILE pxNext;
 	struct xLIST_ITEM * configLIST_VOLATILE pxPrevious;
@@ -230,11 +230,11 @@ typedef struct xMINI_LIST_ITEM MiniListItem_t;
  */
 typedef struct xLIST
 {
-	listLIST_INTEGRITY_CHECK_VALUE_1				/*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
+	listFIRST_LIST_INTEGRITY_CHECK_VALUE				/*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
 	configLIST_VOLATILE UBaseType_t uxNumberOfItems;
 	ListItem_t * configLIST_VOLATILE pxIndex;		/*< Used to walk through the list.  Points to the last item returned by a call to listGET_OWNER_OF_NEXT_ENTRY (). */
 	MiniListItem_t xListEnd;						/*< List item that contains the maximum possible item value meaning it is always at the end of the list and is therefore used as a marker. */
-	listLIST_INTEGRITY_CHECK_VALUE_2				/*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
+	listSECOND_LIST_INTEGRITY_CHECK_VALUE				/*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
 } List_t;
 
 /*
diff --git a/FreeRTOS/Source/include/task.h b/FreeRTOS/Source/include/task.h
index 5c0011cc9..fa7f731a7 100644
--- a/FreeRTOS/Source/include/task.h
+++ b/FreeRTOS/Source/include/task.h
@@ -147,7 +147,7 @@ typedef enum
 /* Actions that can be performed when vTaskNotify() is called. */
 typedef enum
 {
-	eNoAction,					/* Notify the task without updating its notify value. */
+	eNoAction = 0,				/* Notify the task without updating its notify value. */
 	eSetBits,					/* Set bits in the task's notification value. */
 	eIncrement,					/* Increment the task's notification value. */
 	eSetValueWithOverwrite,		/* Set the task's notification value to a specific value even if the previous value has not yet been read by the task. */
@@ -1410,8 +1410,8 @@ void vTaskGetRunTimeStats( char *pcWriteBuffer ) PRIVILEGED_FUNCTION; /*lint !e9
  * task. h
  * <PRE>BaseType_t xTaskNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction );</PRE>
  *
- * configUSE_TASK_NOTIFICATIONS must be defined as 1 for this function to be
- * available.
+ * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this
+ * function to be available.
  *
  * When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private
  * "notification value", which is a 32-bit unsigned integer (uint32_t).
@@ -1433,14 +1433,11 @@ void vTaskGetRunTimeStats( char *pcWriteBuffer ) PRIVILEGED_FUNCTION; /*lint !e9
  * (unblocked) and the notification cleared.
  *
  * A task can use xTaskNotifyWait() to [optionally] block to wait for a
- * notification to be pending, or xTaskNotifyTake() to [optionally] block
+ * notification to be pending, or ulTaskNotifyTake() to [optionally] block
  * to wait for its notification value to have a non-zero value.  The task does
  * not consume any CPU time while it is in the Blocked state.
  *
- * See http://www.FreeRTOS.org/RTOS_task_notifications.html for details of when
- * it is best to use a task notification to send an event to a task compared to
- * when it is best to use an intermediary object (such as a queue, semaphore,
- * mutex or event group) to send an event to a task.
+ * See http://www.FreeRTOS.org/RTOS-task-notifications.html for details.
  *
  * @param xTaskToNotify The handle of the task being notified.  The handle to a
  * task can be returned from the xTaskCreate() API function used to create the
@@ -1490,8 +1487,8 @@ BaseType_t xTaskNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAct
  * task. h
  * <PRE>BaseType_t xTaskNotifyFromISR( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, BaseType_t *pxHigherPriorityTaskWoken );</PRE>
  *
- * configUSE_TASK_NOTIFICATIONS must be defined as 1 for this function to be
- * available.
+ * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this
+ * function to be available.
  *
  * When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private
  * "notification value", which is a 32-bit unsigned integer (uint32_t).
@@ -1516,14 +1513,11 @@ BaseType_t xTaskNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAct
  * (unblocked) and the notification cleared.
  *
  * A task can use xTaskNotifyWait() to [optionally] block to wait for a
- * notification to be pending, or xTaskNotifyTake() to [optionally] block
+ * notification to be pending, or ulTaskNotifyTake() to [optionally] block
  * to wait for its notification value to have a non-zero value.  The task does
  * not consume any CPU time while it is in the Blocked state.
  *
- * See http://www.FreeRTOS.org/RTOS_task_notifications.html for details of when
- * it is best to use a task notification to send an event to a task compared to
- * when it is best to use an intermediary object (such as a queue, semaphore,
- * mutex or event group) to send an event to a task.
+ * See http://www.FreeRTOS.org/RTOS-task-notifications.html for details.
  *
  * @param xTaskToNotify The handle of the task being notified.  The handle to a
  * task can be returned from the xTaskCreate() API function used to create the
@@ -1580,10 +1574,10 @@ BaseType_t xTaskNotifyFromISR( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNo
 
 /**
  * task. h
- * <PRE>BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, BaseType_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait );</pre>
+ * <PRE>BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait );</pre>
  *
- * configUSE_TASK_NOTIFICATIONS must be defined as 1 for this function to be
- * available.
+ * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this
+ * function to be available.
  *
  * When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private
  * "notification value", which is a 32-bit unsigned integer (uint32_t).
@@ -1605,14 +1599,11 @@ BaseType_t xTaskNotifyFromISR( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNo
  * (unblocked) and the notification cleared.
  *
  * A task can use xTaskNotifyWait() to [optionally] block to wait for a
- * notification to be pending, or xTaskNotifyTake() to [optionally] block
+ * notification to be pending, or ulTaskNotifyTake() to [optionally] block
  * to wait for its notification value to have a non-zero value.  The task does
  * not consume any CPU time while it is in the Blocked state.
  *
- * See http://www.FreeRTOS.org/RTOS_task_notifications.html for details of when
- * it is best to use a task notification to send an event to a task compared to
- * when it is best to use an intermediary object (such as a queue, semaphore,
- * mutex or event group) to send an event to a task.
+ * See http://www.FreeRTOS.org/RTOS-task-notifications.html for details.
  *
  * @param ulBitsToClearOnEntry Bits that are set in ulBitsToClearOnEntry value
  * will be cleared in the calling task's notification value before the task
@@ -1654,14 +1645,14 @@ BaseType_t xTaskNotifyFromISR( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNo
  * \defgroup xTaskNotifyWait xTaskNotifyWait
  * \ingroup TaskNotifications
  */
-BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, BaseType_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait );
+BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait );
 
 /**
  * task. h
- * <PRE>BaseType_t xTaskNotifyGive( TaskHandle_t xTaskHandle, BaseType_t *pxHigherPriorityTaskWoken );
+ * <PRE>BaseType_t xTaskNotifyGive( TaskHandle_t xTaskToNotify );</PRE>
  *
- * configUSE_TASK_NOTIFICATIONS must be defined as 1 for this macro to be
- * available.
+ * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this macro
+ * to be available.
  *
  * When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private
  * "notification value", which is a 32-bit unsigned integer (uint32_t).
@@ -1687,7 +1678,7 @@ BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, BaseType_t ulBitsToCl
  * using the ulTaskNotificationTake() API function rather than the
  * xTaskNotifyWait() API function.
  *
- * See http://www.FreeRTOS.org/RTOS_task_notifications.html for more details.
+ * See http://www.FreeRTOS.org/RTOS-task-notifications.html for more details.
  *
  * @param xTaskToNotify The handle of the task being notified.  The handle to a
  * task can be returned from the xTaskCreate() API function used to create the
@@ -1704,10 +1695,10 @@ BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, BaseType_t ulBitsToCl
 
 /**
  * task. h
- * <PRE>BaseType_t xTaskNotifyGiveFromISR( TaskHandle_t xTaskHandle, BaseType_t *pxHigherPriorityTaskWoken );
+ * <PRE>void vTaskNotifyGiveFromISR( TaskHandle_t xTaskHandle, BaseType_t *pxHigherPriorityTaskWoken );
  *
- * configUSE_TASK_NOTIFICATIONS must be defined as 1 for this macro to be
- * available.
+ * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this macro
+ * to be available.
  *
  * When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private
  * "notification value", which is a 32-bit unsigned integer (uint32_t).
@@ -1725,47 +1716,44 @@ BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, BaseType_t ulBitsToCl
  * task notifications can be used to send data to a task, or be used as light
  * weight and fast binary or counting semaphores.
  *
- * xTaskNotifyGiveFromISR() is a helper macro intended for use when task
- * notifications are used as light weight and faster binary or counting
- * semaphore equivalents.  Actual FreeRTOS semaphores are given from an ISR
- * using the xSemaphoreGiveFromISR() API function, the equivalent action that
- * instead uses a task notification is xTaskNotifyGiveFromISR().
+ * vTaskNotifyGiveFromISR() is intended for use when task notifications are
+ * used as light weight and faster binary or counting semaphore equivalents.
+ * Actual FreeRTOS semaphores are given from an ISR using the
+ * xSemaphoreGiveFromISR() API function, the equivalent action that instead uses
+ * a task notification is vTaskNotifyGiveFromISR().
  *
  * When task notifications are being used as a binary or counting semaphore
  * equivalent then the task being notified should wait for the notification
  * using the ulTaskNotificationTake() API function rather than the
  * xTaskNotifyWait() API function.
  *
- * See http://www.FreeRTOS.org/RTOS_task_notifications.html for more details.
+ * See http://www.FreeRTOS.org/RTOS-task-notifications.html for more details.
  *
  * @param xTaskToNotify The handle of the task being notified.  The handle to a
  * task can be returned from the xTaskCreate() API function used to create the
  * task, and the handle of the currently running task can be obtained by calling
  * xTaskGetCurrentTaskHandle().
  *
- * @param pxHigherPriorityTaskWoken  xTaskNotifyGiveFromISR() will set
+ * @param pxHigherPriorityTaskWoken  vTaskNotifyGiveFromISR() will set
  * *pxHigherPriorityTaskWoken to pdTRUE if sending the notification caused the
  * task to which the notification was sent to leave the Blocked state, and the
  * unblocked task has a priority higher than the currently running task.  If
- * xTaskNotifyGiveFromISR() sets this value to pdTRUE then a context switch
+ * vTaskNotifyGiveFromISR() sets this value to pdTRUE then a context switch
  * should be requested before the interrupt is exited.  How a context switch is
  * requested from an ISR is dependent on the port - see the documentation page
  * for the port in use.
  *
- * @return xTaskNotifyGiveFromISR() is a macro that calls xTaskNotifyFromISR()
- * with the eAction parameter set to eIncrement - so pdPASS is always returned.
- *
  * \defgroup xTaskNotifyWait xTaskNotifyWait
  * \ingroup TaskNotifications
  */
-BaseType_t xTaskNotifyGiveFromISR( TaskHandle_t xTaskToNotify, BaseType_t *pxHigherPriorityTaskWoken );
+void vTaskNotifyGiveFromISR( TaskHandle_t xTaskToNotify, BaseType_t *pxHigherPriorityTaskWoken );
 
 /**
  * task. h
  * <PRE>uint32_t ulTaskNotifyTake( BaseType_t xClearCountOnExit, TickType_t xTicksToWait );</pre>
  *
- * configUSE_TASK_NOTIFICATIONS must be defined as 1 for this function to be
- * available.
+ * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this
+ * function to be available.
  *
  * When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private
  * "notification value", which is a 32-bit unsigned integer (uint32_t).
@@ -1784,30 +1772,27 @@ BaseType_t xTaskNotifyGiveFromISR( TaskHandle_t xTaskToNotify, BaseType_t *pxHig
  * faster and lighter weight binary or counting semaphore alternative.  Actual
  * FreeRTOS semaphores are taken using the xSemaphoreTake() API function, the
  * equivalent action that instead uses a task notification is
- * xTaskNotifyTake().
+ * ulTaskNotifyTake().
  *
  * When a task is using its notification value as a binary or counting semaphore
  * other tasks should send notifications to it using the xTaskNotifyGive()
  * macro, or xTaskNotify() function with the eAction parameter set to
  * eIncrement.
  *
- * xTaskNotifyTake() can either clear the task's notification value to
+ * ulTaskNotifyTake() can either clear the task's notification value to
  * zero on exit, in which case the notification value acts like a binary
  * semaphore, or decrement the task's notification value on exit, in which case
  * the notification value acts like a counting semaphore.
  *
- * A task can use xTaskNotifyTake() to [optionally] block to wait for a
- * the tasks notification value to be non-zero.  The task does not consume any
+ * A task can use ulTaskNotifyTake() to [optionally] block to wait for a
+ * the task's notification value to be non-zero.  The task does not consume any
  * CPU time while it is in the Blocked state.
  *
  * Where as xTaskNotifyWait() will return when a notification is pending,
- * xTaskNotifyTake() will return when the task's notification value is
+ * ulTaskNotifyTake() will return when the task's notification value is
  * not zero.
  *
- * See http://www.FreeRTOS.org/RTOS_task_notifications.html for details of when
- * it is best to use a task notification to send an event to a task compared to
- * when it is best to use an intermediary object (such as a queue, semaphore,
- * mutex or event group) to send an event to a task.
+ * See http://www.FreeRTOS.org/RTOS-task-notifications.html for details.
  *
  * @param xClearCountOnExit if xClearCountOnExit is pdFALSE then the task's
  * notification value is decremented when the function exits.  In this way the
@@ -1819,7 +1804,7 @@ BaseType_t xTaskNotifyGiveFromISR( TaskHandle_t xTaskToNotify, BaseType_t *pxHig
  * @param xTicksToWait The maximum amount of time that the task should wait in
  * the Blocked state for the task's notification value to be greater than zero,
  * should the count not already be greater than zero when
- * xTaskNotifyTake() was called.  The task will not consume any processing
+ * ulTaskNotifyTake() was called.  The task will not consume any processing
  * time while it is in the Blocked state.  This is specified in kernel ticks,
  * the macro pdMS_TO_TICSK( value_in_ms ) can be used to convert a time
  * specified in milliseconds to a time specified in ticks.
diff --git a/FreeRTOS/Source/list.c b/FreeRTOS/Source/list.c
index 533a31383..3d8a9835b 100644
--- a/FreeRTOS/Source/list.c
+++ b/FreeRTOS/Source/list.c
@@ -134,8 +134,8 @@ void vListInitialiseItem( ListItem_t * const pxItem )
 
 	/* Write known values into the list item if
 	configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
-	listSET_LIST_ITEM_INTEGRITY_CHECK_1_VALUE( pxItem );
-	listSET_LIST_ITEM_INTEGRITY_CHECK_2_VALUE( pxItem );
+	listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem );
+	listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem );
 }
 /*-----------------------------------------------------------*/
 
diff --git a/FreeRTOS/Source/tasks.c b/FreeRTOS/Source/tasks.c
index c421e521c..35a7a1137 100644
--- a/FreeRTOS/Source/tasks.c
+++ b/FreeRTOS/Source/tasks.c
@@ -147,7 +147,7 @@ functions but without including stdio.h here. */
 /* Value that can be assigned to the eNotifyState member of the TCB. */
 typedef enum
 {
-	eNotWaitingNotification,
+	eNotWaitingNotification = 0,
 	eWaitingNotification,
 	eNotified
 } eNotifyValue;
@@ -3846,7 +3846,7 @@ TickType_t uxReturn;
 				/* Mark this task as waiting for a notification. */
 				pxCurrentTCB->eNotifyState = eWaitingNotification;
 
-				if( xTicksToWait > 0 )
+				if( xTicksToWait > ( TickType_t ) 0 )
 				{
 					/* The task is going to block.  First it must be removed
 					from the ready list. */
@@ -3915,7 +3915,7 @@ TickType_t uxReturn;
 		{
 			ulReturn = pxCurrentTCB->ulNotifiedValue;
 
-			if( ulReturn != 0 )
+			if( ulReturn != 0UL )
 			{
 				if( xClearCountOnExit != pdFALSE )
 				{
@@ -3943,7 +3943,7 @@ TickType_t uxReturn;
 
 #if( configUSE_TASK_NOTIFICATIONS == 1 )
 
-	BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, BaseType_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait )
+	BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait )
 	{
 	TickType_t xTimeToWake;
 	BaseType_t xReturn;
@@ -3961,7 +3961,7 @@ TickType_t uxReturn;
 				/* Mark this task as waiting for a notification. */
 				pxCurrentTCB->eNotifyState = eWaitingNotification;
 
-				if( xTicksToWait > 0 )
+				if( xTicksToWait > ( TickType_t ) 0 )
 				{
 					/* The task is going to block.  First it must be removed
 					from the	ready list. */
@@ -4105,7 +4105,7 @@ TickType_t uxReturn;
 					}
 					break;
 
-				default :
+				case eNoAction:
 					/* The task is being notified without its notify value being
 					updated. */
 					break;
@@ -4209,7 +4209,7 @@ TickType_t uxReturn;
 					}
 					break;
 
-				default :
+				case eNoAction :
 					/* The task is being notified without its notify value being
 					updated. */
 					break;
@@ -4260,11 +4260,10 @@ TickType_t uxReturn;
 
 #if( configUSE_TASK_NOTIFICATIONS == 1 )
 
-	BaseType_t xTaskNotifyGiveFromISR( TaskHandle_t xTaskToNotify, BaseType_t *pxHigherPriorityTaskWoken )
+	void vTaskNotifyGiveFromISR( TaskHandle_t xTaskToNotify, BaseType_t *pxHigherPriorityTaskWoken )
 	{
 	TCB_t * pxTCB;
 	eNotifyValue eOriginalNotifyState;
-	BaseType_t xReturn = pdPASS;
 	UBaseType_t uxSavedInterruptStatus;
 
 		configASSERT( xTaskToNotify );
@@ -4333,8 +4332,6 @@ TickType_t uxReturn;
 			}
 		}
 		portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
-
-		return xReturn;
 	}
 
 #endif /* configUSE_TASK_NOTIFICATIONS */
-- 
2.39.5