{\r
/* Now we can declare the local variables. These must be static. */\r
signed portCHAR cChar;\r
-portBASE_TYPE xTaskWokenByTx = pdFALSE, xTaskWokenByRx = pdFALSE;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
unsigned portLONG ulStatus;\r
\r
/* What caused the interrupt? */\r
{\r
/* The interrupt was caused by the THR becoming empty. Are there any\r
more characters to transmit? */\r
- if( xQueueReceiveFromISR( xCharsForTx, &cChar, &xTaskWokenByTx ) == pdTRUE )\r
+ if( xQueueReceiveFromISR( xCharsForTx, &cChar, &xHigherPriorityTaskWoken ) == pdTRUE )\r
{\r
/* A character was retrieved from the queue so can be sent to the\r
THR now. */\r
/* The interrupt was caused by the receiver getting data. */\r
cChar = AT91C_BASE_US0->US_RHR;\r
\r
- if (xQueueSendFromISR(xRxedChars, &cChar, pdFALSE))\r
- {\r
- xTaskWokenByRx = pdTRUE;\r
- }\r
+ xQueueSendFromISR(xRxedChars, &cChar, &xHigherPriorityTaskWoken);\r
}\r
\r
/* Acknowledge the interrupt at AIC level... */\r
ensure that the unblocked task is the task that executes when the interrupt\r
completes if the unblocked task has a priority higher than the interrupted\r
task. */\r
- if( xTaskWokenByTx || xTaskWokenByRx )\r
+ if( xHigherPriorityTaskWoken )\r
{\r
portYIELD_FROM_ISR();\r
}\r
\r
A special exception to the GPL can be applied should you wish to distribute\r
a combined work that includes FreeRTOS.org, without being obliged to provide\r
- the source code for any proprietary components. See the licensing section \r
+ the source code for any proprietary components. See the licensing section\r
of http://www.FreeRTOS.org for full details of how and when the exception\r
can be applied.\r
\r
Please ensure to read the configuration and relevant port sections of the\r
online documentation.\r
\r
- http://www.FreeRTOS.org - Documentation, latest information, license and \r
+ http://www.FreeRTOS.org - Documentation, latest information, license and\r
contact details.\r
\r
- http://www.SafeRTOS.com - A version that is certified for use in safety \r
+ http://www.SafeRTOS.com - A version that is certified for use in safety\r
critical systems.\r
\r
- http://www.OpenRTOS.com - Commercial support, development, porting, \r
+ http://www.OpenRTOS.com - Commercial support, development, porting,\r
licensing and training services.\r
*/\r
\r
/*\r
- Sample interrupt driven USB device driver. This is a minimal implementation \r
+ Sample interrupt driven USB device driver. This is a minimal implementation\r
for demonstration only. Although functional, it is not a full and compliant\r
- implementation. \r
+ implementation.\r
\r
The USB device enumerates as a simple 3 axis joystick, and once configured\r
transmits 3 axis of data which can be viewed from the USB host machine.\r
\r
- This file implements the USB interrupt service routine, and a demo FreeRTOS \r
- task. The interrupt service routine handles the USB hardware - taking a \r
+ This file implements the USB interrupt service routine, and a demo FreeRTOS\r
+ task. The interrupt service routine handles the USB hardware - taking a\r
snapshot of the USB status at the point of the interrupt. The task receives\r
the status information from the interrupt for processing at the task level.\r
\r
Changes from V2.5.5\r
\r
+ Descriptors that have a length that is an exact multiple of usbFIFO_LENGTH\r
- can now be transmitted. To this end an extra parameter has been \r
+ can now be transmitted. To this end an extra parameter has been\r
added to the prvSendControlData() function, and the state\r
eSENDING_EVEN_DESCRIPTOR has been introduced. Thanks to Scott Miller for\r
assisting with this contribution.\r
#define usbINTERFACE_STRING ( 4 )\r
\r
/* Data indexes for reading the request from the xISRStatus.ucFifoData[]\r
-into xUSB_REQUEST. The data order is designed for speed - so looks a \r
+into xUSB_REQUEST. The data order is designed for speed - so looks a\r
little odd. */\r
#define usbREQUEST_TYPE_INDEX ( 7 )\r
#define usbREQUEST_INDEX ( 6 )\r
} xISRStatus;\r
\r
/* Structure used to hold the received requests. */\r
-typedef struct \r
+typedef struct\r
{\r
unsigned portCHAR ucReqType;\r
unsigned portCHAR ucRequest;\r
\r
/*-----------------------------------------------------------*/\r
\r
-/* \r
+/*\r
* The USB interrupt service routine. This takes a snapshot of the USB\r
* device at the time of the interrupt, clears the interrupts, and posts\r
* the data to the USB processing task.\r
static void prvResetEndPoints( void );\r
\r
/*\r
- * Setup the USB hardware, install the interrupt service routine and \r
+ * Setup the USB hardware, install the interrupt service routine and\r
* initialise all the state variables.\r
*/\r
static void vInitUSBInterface( void );\r
*/\r
static void prvProcessEndPoint0Interrupt( xISRStatus *pxMessage );\r
\r
-/* \r
- * For simplicity requests are separated into device, interface, class \r
+/*\r
+ * For simplicity requests are separated into device, interface, class\r
* interface and end point requests.\r
*\r
* Decode and handle standard device requests originating on the control\r
- * end point. \r
+ * end point.\r
*/\r
static void prvHandleStandardDeviceRequest( xUSB_REQUEST *pxRequest );\r
\r
/*\r
- * For simplicity requests are separated into device, interface, class \r
+ * For simplicity requests are separated into device, interface, class\r
* interface and end point requests.\r
*\r
* Decode and handle standard interface requests originating on the control\r
static void prvHandleStandardInterfaceRequest( xUSB_REQUEST *pxRequest );\r
\r
/*\r
- * For simplicity requests are separated into device, interface, class \r
+ * For simplicity requests are separated into device, interface, class\r
* interface and end point requests.\r
*\r
* Decode and handle standard end point requests originating on the control\r
static void prvHandleStandardEndPointRequest( xUSB_REQUEST *pxRequest );\r
\r
/*\r
- * For simplicity requests are separated into device, interface, class \r
+ * For simplicity requests are separated into device, interface, class\r
* interface and end point requests.\r
*\r
* Decode and handle the class interface requests.\r
\r
/*\r
* Examine the Tx buffer to see if there is any more data to be transmitted.\r
- * \r
+ *\r
* If there is data to be transmitted then send the next segment. A segment\r
* can have a maximum of 8 bytes (this is defined as the maximum for the end\r
* point by the descriptor). The final segment may be less than 8 bytes if\r
/*\r
* A stall condition is forced each time the host makes a request that is not\r
* supported by this minimal implementation.\r
- * \r
+ *\r
* A stall is forced by setting the appropriate bit in the end points control\r
- * and status register. \r
+ * and status register.\r
*/\r
static void prvSendStall( void );\r
\r
/*\r
- * A NULL (or zero length packet) is transmitted in acknowledge the reception \r
+ * A NULL (or zero length packet) is transmitted in acknowledge the reception\r
* of certain events from the host.\r
*/\r
static void prvUSBTransmitNull( void );\r
\r
-/* \r
- * When the host requests a descriptor this function is called to determine \r
+/*\r
+ * When the host requests a descriptor this function is called to determine\r
* which descriptor is being requested and start its transmission.\r
*/\r
static void prvGetStandardInterfaceDescriptor( xUSB_REQUEST *pxRequest );\r
\r
/*\r
- * This demo USB device enumerates as a simple 3 axis joystick. Once \r
+ * This demo USB device enumerates as a simple 3 axis joystick. Once\r
* configured this function is periodically called to generate some sample\r
* joystick data.\r
*\r
- * The x and y axis are made to move in a square. The z axis is made to \r
+ * The x and y axis are made to move in a square. The z axis is made to\r
* repeatedly increment up to its maximum.\r
*/\r
static void prvTransmitSampleValues( void );\r
\r
/*\r
- * The created task to handle the USB demo functionality. \r
+ * The created task to handle the USB demo functionality.\r
*/\r
void vUSBDemoTask( void *pvParameters );\r
\r
0x09, 0x04\r
};\r
\r
-const portCHAR pxManufacturerStringDescriptor[] = \r
+const portCHAR pxManufacturerStringDescriptor[] =\r
{\r
18,\r
usbDESCRIPTOR_TYPE_STRING,\r
'S', 0x00 \r
};\r
\r
-const portCHAR pxProductStringDescriptor[] = \r
+const portCHAR pxProductStringDescriptor[] =\r
{\r
44,\r
usbDESCRIPTOR_TYPE_STRING,\r
'k', 0x00\r
};\r
\r
-const portCHAR pxConfigurationStringDescriptor[] = \r
+const portCHAR pxConfigurationStringDescriptor[] =\r
{\r
38,\r
usbDESCRIPTOR_TYPE_STRING,\r
'e', 0x00\r
};\r
\r
-const portCHAR pxInterfaceStringDescriptor[] = \r
+const portCHAR pxInterfaceStringDescriptor[] =\r
{\r
30,\r
usbDESCRIPTOR_TYPE_STRING,\r
0xc0 /* END_COLLECTION */\r
};\r
\r
-const char pxDeviceDescriptor[] = \r
+const char pxDeviceDescriptor[] =\r
{\r
/* Device descriptor */\r
0x12, /* bLength */\r
static xTX_MESSAGE pxCharsForTx;\r
\r
/* Queue used to pass messages between the ISR and the task. */\r
-static xQueueHandle xUSBInterruptQueue; \r
+static xQueueHandle xUSBInterruptQueue;\r
\r
/* ISR entry has to be written in the asm file as we want a context switch\r
to occur from within the ISR. See the port documentation on the FreeRTOS.org\r
\r
/*-----------------------------------------------------------*/\r
\r
-/* Macros to manipulate the control and status registers. These registers \r
-cannot be accessed using a direct read modify write operation outside of the \r
-ISR as some bits are left unchanged by writing with a 0, and some are left \r
+/* Macros to manipulate the control and status registers. These registers\r
+cannot be accessed using a direct read modify write operation outside of the\r
+ISR as some bits are left unchanged by writing with a 0, and some are left\r
unchanged by writing with a 1. */\r
\r
#define usbINT_CLEAR_MASK (AT91C_UDP_TXCOMP | AT91C_UDP_STALLSENT | AT91C_UDP_RXSETUP | AT91C_UDP_RX_DATA_BK0 | AT91C_UDP_RX_DATA_BK1 )\r
\r
__arm void vUSB_ISR( void )\r
{\r
-portBASE_TYPE xTaskWokenByPost = pdFALSE; \r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
static volatile unsigned portLONG ulNextMessage = 0;\r
xISRStatus *pxMessage;\r
unsigned portLONG ulTemp, ulRxBytes;\r
cleared separately as it does not appear in the mask register. */\r
AT91C_BASE_UDP->UDP_ICR = AT91C_BASE_UDP->UDP_IMR | AT91C_UDP_ENDBUSRES;\r
\r
- /* If there are bytes in the FIFO then we have to retrieve them here. \r
+ /* If there are bytes in the FIFO then we have to retrieve them here.\r
Ideally this would be done at the task level. However we need to clear the\r
RXSETUP interrupt before leaving the ISR, and this may cause the data in\r
the FIFO to be overwritten. Also the DIR bit has to be changed before the\r
ulRxBytes = ulTemp >> 16;\r
ulRxBytes &= usbRX_COUNT_MASK;\r
\r
- /* With this minimal implementation we are only interested in receiving \r
+ /* With this minimal implementation we are only interested in receiving\r
setup bytes on the control end point. */\r
if( ( ulRxBytes > 0 ) && ( ulTemp & AT91C_UDP_RXSETUP ) )\r
{\r
/* The message now contains the entire state and optional data from\r
the USB interrupt. This can now be posted on the Rx queue ready for\r
processing at the task level. */\r
- xTaskWokenByPost = xQueueSendFromISR( xUSBInterruptQueue, &pxMessage, xTaskWokenByPost );\r
+ xQueueSendFromISR( xUSBInterruptQueue, &pxMessage, &xHigherPriorityTaskWoken );\r
\r
/* We may want to switch to the USB task, if this message has made\r
it the highest priority task that is ready to execute. */\r
- portEND_SWITCHING_ISR( xTaskWokenByPost );\r
+ portEND_SWITCHING_ISR( xHigherPriorityTaskWoken );\r
\r
/* Clear the AIC ready for the next interrupt. */ \r
AT91C_BASE_AIC->AIC_EOICR = 0;\r
vInitUSBInterface();\r
portEXIT_CRITICAL();\r
\r
- /* Process interrupts as they arrive. The ISR takes a snapshot of the \r
+ /* Process interrupts as they arrive. The ISR takes a snapshot of the\r
interrupt status then posts the information on this queue for processing\r
at the task level. This simple demo implementation only processes\r
a few interrupt sources. */\r
{\r
if( pxMessage->ulCSR0 & AT91C_UDP_RX_DATA_BK0 )\r
{ \r
- /* We only expect to receive zero length data here as ACK's. \r
+ /* We only expect to receive zero length data here as ACK's.\r
Set the data pointer to the end of the current Tx packet to\r
ensure we don't send out any more data. */ \r
pxCharsForTx.ulNextCharIndex = pxCharsForTx.ulTotalDataLength;\r
xRequest.usLength <<= 8;\r
xRequest.usLength |= pxMessage->ucFifoData[ usbLENGTH_LOW_BYTE ];\r
\r
- /* Manipulate the ucRequestType and the ucRequest parameters to \r
- generate a zero based request selection. This is just done to \r
- break up the requests into subsections for clarity. The \r
+ /* Manipulate the ucRequestType and the ucRequest parameters to\r
+ generate a zero based request selection. This is just done to\r
+ break up the requests into subsections for clarity. The\r
alternative would be to have more huge switch statement that would\r
be difficult to optimise. */\r
ucRequest = ( ( xRequest.ucReqType & 0x60 ) >> 3 );\r
\r
case usbSET_CONFIGURATION_REQUEST:\r
\r
- /* Acknowledge the SET_CONFIGURATION, but (according to the manual) \r
- we cannot actually move to the configured state until we get a \r
+ /* Acknowledge the SET_CONFIGURATION, but (according to the manual)\r
+ we cannot actually move to the configured state until we get a\r
TXCOMP interrupt from this NULL packet. Therefore we just remember the\r
config and set our state so we know we have received the go ahead. */ \r
ucUSBConfig = ( unsigned portCHAR ) ( pxRequest->usValue & 0xff );\r
break;\r
\r
case usbGET_DESCRIPTOR_REQUEST:\r
- prvGetStandardInterfaceDescriptor( pxRequest ); \r
+ prvGetStandardInterfaceDescriptor( pxRequest );\r
break;\r
\r
/* This minimal implementation does not respond to these. */\r
{\r
/* This minimal implementation does not expect to respond to these. */\r
case usbGET_STATUS_REQUEST:\r
- case usbCLEAR_FEATURE_REQUEST: \r
+ case usbCLEAR_FEATURE_REQUEST:\r
case usbSET_FEATURE_REQUEST:\r
\r
default: \r
/* Setup the PIO for the USB pull up resistor. */\r
AT91F_PIO_CfgOutput(AT91C_BASE_PIOA,AT91C_PIO_PA16);\r
\r
- /* Start without the pullup - this will get set at the end of this \r
+ /* Start without the pullup - this will get set at the end of this\r
function. */\r
AT91F_PIO_SetOutput( AT91C_BASE_PIOA, AT91C_PIO_PA16 );\r
\r
/* Enable the transceiver. */\r
AT91C_UDP_TRANSCEIVER_ENABLE = 0;\r
\r
- /* Enable the USB interrupts - other interrupts get enabled as the \r
+ /* Enable the USB interrupts - other interrupts get enabled as the\r
enumeration process progresses. */\r
AT91F_AIC_ConfigureIt( AT91C_BASE_AIC, AT91C_ID_UDP, usbINTERRUPT_PRIORITY, AT91C_AIC_SRCTYPE_INT_LEVEL_SENSITIVE, ( void (*)( void ) ) vUSBISREntry );\r
AT91F_AIC_EnableIt( AT91C_BASE_AIC, AT91C_ID_UDP );\r
}\r
else if( ( ulLengthToSend < ( unsigned portLONG ) usRequestedLength ) && lSendingDescriptor )\r
{\r
- /* We are sending a descriptor. If the descriptor is an exact \r
+ /* We are sending a descriptor. If the descriptor is an exact\r
multiple of the FIFO length then it will have to be terminated\r
with a NULL packet. Set the state to indicate this if\r
necessary. */\r
(if it is greater than 8 bytes in length). */\r
memcpy( pxCharsForTx.ucTxBuffer, pucData, ulLengthToSend );\r
\r
- /* Reinitialise the buffer index so we start sending from the start of \r
+ /* Reinitialise the buffer index so we start sending from the start of\r
the data. */\r
pxCharsForTx.ulTotalDataLength = ulLengthToSend;\r
pxCharsForTx.ulNextCharIndex = ( unsigned portLONG ) 0;\r
\r
- /* Send the first 8 bytes now. The rest will get sent in response to \r
+ /* Send the first 8 bytes now. The rest will get sent in response to\r
TXCOMP interrupts. */\r
prvSendNextSegment();\r
}\r
}\r
else\r
{\r
- /* There is no data to send. If we were sending a descriptor and the \r
+ /* There is no data to send. If we were sending a descriptor and the\r
descriptor was an exact multiple of the max packet size then we need\r
to send a null to terminate the transmission. */\r
if( eDriverState == eSENDING_EVEN_DESCRIPTOR )\r
{\r
unsigned portLONG ulStatus;\r
signed portCHAR cChar;\r
-portBASE_TYPE xTaskWokenByTx = pdFALSE, xTaskWokenByPost = pdFALSE;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
\r
/* What caused the interrupt? */\r
ulStatus = serCOM0->US_CSR &= serCOM0->US_IMR;\r
{\r
/* The interrupt was caused by the THR becoming empty. Are there any\r
more characters to transmit? */\r
- if( xQueueReceiveFromISR( xCharsForTx, &cChar, &xTaskWokenByTx ) == pdTRUE )\r
+ if( xQueueReceiveFromISR( xCharsForTx, &cChar, &xHigherPriorityTaskWoken ) == pdTRUE )\r
{\r
/* A character was retrieved from the queue so can be sent to the\r
THR now. */\r
character from the RHR and place it in the queue or received \r
characters. */\r
cChar = serCOM0->US_RHR;\r
- xTaskWokenByPost = xQueueSendFromISR( xRxedChars, &cChar, xTaskWokenByPost );\r
+ xQueueSendFromISR( xRxedChars, &cChar, &xHigherPriorityTaskWoken );\r
}\r
\r
/* If a task was woken by either a character being received or a character \r
being transmitted then we may need to switch to another task. */\r
- portEND_SWITCHING_ISR( ( xTaskWokenByPost || xTaskWokenByTx ) );\r
+ portEND_SWITCHING_ISR( xHigherPriorityTaskWoken );\r
\r
/* End the interrupt in the AIC. */\r
AT91C_BASE_AIC->AIC_EOICR = 0;\r
\r
void vUSB_ISR_Handler( void )\r
{\r
-portBASE_TYPE xTaskWokenByPost = pdFALSE; \r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE; \r
static volatile unsigned portLONG ulNextMessage = 0;\r
xISRStatus *pxMessage;\r
unsigned portLONG ulTemp, ulRxBytes;\r
/* The message now contains the entire state and optional data from\r
the USB interrupt. This can now be posted on the Rx queue ready for\r
processing at the task level. */\r
- xTaskWokenByPost = xQueueSendFromISR( xUSBInterruptQueue, &pxMessage, xTaskWokenByPost );\r
+ xQueueSendFromISR( xUSBInterruptQueue, &pxMessage, &xHigherPriorityTaskWoken );\r
\r
/* We may want to switch to the USB task, if this message has made\r
it the highest priority task that is ready to execute. */\r
- if( xTaskWokenByPost )\r
+ if( xHigherPriorityTaskWoken )\r
{\r
portYIELD_FROM_ISR();\r
}\r
void vEMACISR_Handler( void )\r
{\r
volatile unsigned portLONG ulIntStatus, ulRxStatus;\r
-portBASE_TYPE xSwitchRequired = pdFALSE;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
\r
ulIntStatus = AT91C_BASE_EMAC->EMAC_ISR;\r
ulRxStatus = AT91C_BASE_EMAC->EMAC_RSR;\r
{\r
/* A frame has been received, signal the uIP task so it can process\r
the Rx descriptors. */\r
- xSwitchRequired = xSemaphoreGiveFromISR( xEMACSemaphore, pdFALSE );\r
+ xSemaphoreGiveFromISR( xEMACSemaphore, &xHigherPriorityTaskWoken );\r
AT91C_BASE_EMAC->EMAC_RSR = AT91C_EMAC_REC;\r
}\r
\r
AT91C_BASE_AIC->AIC_EOICR = 0;\r
\r
/* Switch to the uIP task. */\r
- if( xSwitchRequired )\r
+ if( xHigherPriorityTaskWoken )\r
{\r
/* If a task of higher priority than the interrupted task was\r
unblocked by the ISR then this call will ensure that the \r
void vUART_ISR_Handler( void )\r
{\r
signed portCHAR cChar;\r
-portBASE_TYPE xTaskWokenByTx = pdFALSE, xTaskWokenByRx = pdFALSE;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
\r
/* What caused the interrupt? */\r
switch( UART0_IIR & serINTERRUPT_SOURCE_MASK )\r
\r
case serSOURCE_THRE : /* The THRE is empty. If there is another\r
character in the Tx queue, send it now. */\r
- if( xQueueReceiveFromISR( xCharsForTx, &cChar, &xTaskWokenByTx ) == pdTRUE )\r
+ if( xQueueReceiveFromISR( xCharsForTx, &cChar, &xHigherPriorityTaskWoken ) == pdTRUE )\r
{\r
UART0_THR = cChar;\r
}\r
case serSOURCE_RX : /* A character was received. Place it in \r
the queue of received characters. */\r
cChar = UART0_RBR;\r
- if( xQueueSendFromISR( xRxedChars, &cChar, ( portBASE_TYPE ) pdFALSE ) ) \r
- {\r
- xTaskWokenByRx = pdTRUE;\r
- }\r
+ xQueueSendFromISR( xRxedChars, &cChar, &xHigherPriorityTaskWoken );\r
break;\r
\r
default : /* There is nothing to do, leave the ISR. */\r
break;\r
}\r
\r
- if( xTaskWokenByTx || xTaskWokenByRx )\r
+ if( xHigherPriorityTaskWoken )\r
{\r
portYIELD_FROM_ISR();\r
}\r
__arm void vSerialISR( void )\r
{\r
signed portCHAR cChar;\r
-portBASE_TYPE xTaskWokenByRx = pdFALSE, xTaskWokenByTx = pdFALSE;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
\r
/* What caused the interrupt? */\r
switch( U0IIR & serINTERRUPT_SOURCE_MASK )\r
\r
case serSOURCE_THRE : /* The THRE is empty. If there is another\r
character in the Tx queue, send it now. */\r
- if( xQueueReceiveFromISR( xCharsForTx, &cChar, &xTaskWokenByTx ) == pdTRUE )\r
+ if( xQueueReceiveFromISR( xCharsForTx, &cChar, &xHigherPriorityTaskWoken ) == pdTRUE )\r
{\r
U0THR = cChar;\r
}\r
case serSOURCE_RX : /* A character was received. Place it in\r
the queue of received characters. */\r
cChar = U0RBR;\r
- if( xQueueSendFromISR( xRxedChars, &cChar, pdFALSE ) )\r
- {\r
- xTaskWokenByRx = pdTRUE;\r
- }\r
+ xQueueSendFromISR( xRxedChars, &cChar, &xHigherPriorityTaskWoken );\r
break;\r
\r
default : /* There is nothing to do, leave the ISR. */\r
\r
/* Exit the ISR. If a task was woken by either a character being received\r
or transmitted then a context switch will occur. */\r
- portEND_SWITCHING_ISR( ( xTaskWokenByTx || xTaskWokenByRx ) );\r
+ portEND_SWITCHING_ISR( xHigherPriorityTaskWoken );\r
\r
/* Clear the ISR in the VIC. */\r
VICVectAddr = serCLEAR_VIC_INTERRUPT;\r
\r
/* Now we can declare the local variables. */\r
static signed portCHAR cChar;\r
- static portBASE_TYPE xTaskWokenByRx, xTaskWokenByTx;\r
+ static portBASE_TYPE xHigherPriorityTaskWoken;\r
\r
- xTaskWokenByTx = pdFALSE;\r
- xTaskWokenByRx = pdFALSE;\r
+ xHigherPriorityTaskWoken = pdFALSE;\r
\r
/* What caused the interrupt? */\r
switch( U0IIR & serINTERRUPT_SOURCE_MASK )\r
\r
case serSOURCE_THRE : /* The THRE is empty. If there is another\r
character in the Tx queue, send it now. */\r
- if( xQueueReceiveFromISR( xCharsForTx, &cChar, &xTaskWokenByTx ) == pdTRUE )\r
+ if( xQueueReceiveFromISR( xCharsForTx, &cChar, &xHigherPriorityTaskWoken ) == pdTRUE )\r
{\r
U0THR = cChar;\r
}\r
case serSOURCE_RX : /* A character was received. Place it in \r
the queue of received characters. */\r
cChar = U0RBR;\r
- if( xQueueSendFromISR( xRxedChars, &cChar, pdFALSE ) )\r
- {\r
- xTaskWokenByRx = pdTRUE;\r
- }\r
+ xQueueSendFromISR( xRxedChars, &cChar, &xHigherPriorityTaskWoken );\r
break;\r
\r
default : /* There is nothing to do, leave the ISR. */\r
\r
/* Exit the ISR. If a task was woken by either a character being received\r
or transmitted then a context switch will occur. */\r
- portEXIT_SWITCHING_ISR( ( xTaskWokenByTx || xTaskWokenByRx ) );\r
+ portEXIT_SWITCHING_ISR( xHigherPriorityTaskWoken );\r
}\r
/*-----------------------------------------------------------*/\r
\r
void vButtonHandler( void )\r
{\r
extern xSemaphoreHandle xButtonSemaphore;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
\r
- if( xSemaphoreGiveFromISR( xButtonSemaphore, pdFALSE ) )\r
+ xSemaphoreGiveFromISR( xButtonSemaphore, &xHigherPriorityTaskWoken );\r
+\r
+ if( xHigherPriorityTaskWoken )\r
{\r
/* We have woken a task. Calling "yield from ISR" here will ensure\r
the interrupt returns to the woken task if it has a priority higher\r
\r
void vEMAC_ISR_Handler( void )\r
{\r
-portBASE_TYPE xSwitchRequired = pdFALSE;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
\r
/* Clear the interrupt. */\r
MAC_INTCLEAR = 0xffff;\r
VICVectAddr = 0;\r
\r
/* Ensure the uIP task is not blocked as data has arrived. */\r
- if( xSemaphoreGiveFromISR( xEMACSemaphore, pdFALSE ) )\r
+ xSemaphoreGiveFromISR( xEMACSemaphore, &xHigherPriorityTaskWoken );\r
+\r
+ if( xHigherPriorityTaskWoken )\r
{\r
/* Giving the semaphore woke a task. */\r
portYIELD_FROM_ISR();\r
\r
void vEMAC_ISR_Handler( void )\r
{\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
+\r
/* Clear the interrupt. */\r
IntClear = 0xffff;\r
VICVectAddr = 0;\r
\r
/* Ensure the uIP task is not blocked as data has arrived. */\r
- if( xSemaphoreGiveFromISR( xEMACSemaphore, pdFALSE ) )\r
+ xSemaphoreGiveFromISR( xEMACSemaphore, &xHigherPriorityTaskWoken );\r
+\r
+ if( xHigherPriorityTaskWoken )\r
{\r
/* If the uIP task was unblocked then calling "Yield from ISR" here\r
will ensure the interrupt returns directly to the uIP task, if it\r
{\r
unsigned portSHORT usStatus;\r
signed portCHAR cChar;\r
-portBASE_TYPE xTaskWokenByTx = pdFALSE, xTaskWokenByPost = pdFALSE;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
\r
/* What caused the interrupt? */\r
usStatus = UART_FlagStatus( UART0 );\r
{\r
/* The interrupt was caused by the THR becoming empty. Are there any\r
more characters to transmit? */\r
- if( xQueueReceiveFromISR( xCharsForTx, &cChar, &xTaskWokenByTx ) == pdTRUE )\r
+ if( xQueueReceiveFromISR( xCharsForTx, &cChar, &xHigherPriorityTaskWoken ) == pdTRUE )\r
{\r
/* A character was retrieved from the queue so can be sent to the\r
THR now. */\r
character from the RHR and place it in the queue of received\r
characters. */\r
cChar = UART0->RxBUFR;\r
- xTaskWokenByPost = xQueueSendFromISR( xRxedChars, &cChar, xTaskWokenByPost );\r
+ xQueueSendFromISR( xRxedChars, &cChar, &xHigherPriorityTaskWoken );\r
}\r
\r
/* If a task was woken by either a character being received or a character\r
being transmitted then we may need to switch to another task. */\r
- portEND_SWITCHING_ISR( ( xTaskWokenByPost || xTaskWokenByTx ) );\r
+ portEND_SWITCHING_ISR( xHigherPriorityTaskWoken );\r
\r
/* End the interrupt in the EIC. */\r
portCLEAR_EIC();\r
void vSerialISR( void )\r
{\r
signed portCHAR cChar;\r
-portBASE_TYPE xTaskWokenByTx = pdFALSE, xTaskWokenByPost = pdFALSE;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
\r
do\r
{\r
{\r
/* The interrupt was caused by the THR becoming empty. Are there any\r
more characters to transmit? */\r
- if( xQueueReceiveFromISR( xCharsForTx, &cChar, &xTaskWokenByTx ) == pdTRUE )\r
+ if( xQueueReceiveFromISR( xCharsForTx, &cChar, &xHigherPriorityTaskWoken ) == pdTRUE )\r
{\r
/* A character was retrieved from the queue so can be sent to the\r
THR now. */\r
character from the RHR and place it in the queue of received\r
characters. */\r
cChar = UART0->DR;\r
- xTaskWokenByPost = xQueueSendFromISR( xRxedChars, &cChar, xTaskWokenByPost );\r
+ xQueueSendFromISR( xRxedChars, &cChar, &xHigherPriorityTaskWoken );\r
UART_ClearITPendingBit( UART0, UART_IT_Receive );\r
}\r
} while( UART0->MIS );\r
\r
/* If a task was woken by either a character being received or a character\r
being transmitted then we may need to switch to another task. */\r
- portEND_SWITCHING_ISR( ( xTaskWokenByPost || xTaskWokenByTx ) );\r
+ portEND_SWITCHING_ISR( xHigherPriorityTaskWoken );\r
}\r
\r
\r
__arm void vSerialISR( void )\r
{\r
signed portCHAR cChar;\r
-portBASE_TYPE xTaskWokenByTx = pdFALSE, xTaskWokenByPost = pdFALSE;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
\r
do\r
{\r
{\r
/* The interrupt was caused by the THR becoming empty. Are there any\r
more characters to transmit? */\r
- if( xQueueReceiveFromISR( xCharsForTx, &cChar, &xTaskWokenByTx ) == pdTRUE )\r
+ if( xQueueReceiveFromISR( xCharsForTx, &cChar, &xHigherPriorityTaskWoken ) == pdTRUE )\r
{\r
/* A character was retrieved from the queue so can be sent to the\r
THR now. */\r
character from the RHR and place it in the queue of received\r
characters. */\r
cChar = UART0->DR;\r
- xTaskWokenByPost = xQueueSendFromISR( xRxedChars, &cChar, xTaskWokenByPost );\r
+ xQueueSendFromISR( xRxedChars, &cChar, &xHigherPriorityTaskWoken );\r
UART_ClearITPendingBit( UART0, UART_IT_Receive );\r
}\r
} while( UART0->MIS );\r
\r
/* If a task was woken by either a character being received or a character\r
being transmitted then we may need to switch to another task. */\r
- portEND_SWITCHING_ISR( ( xTaskWokenByPost || xTaskWokenByTx ) );\r
+ portEND_SWITCHING_ISR( xHigherPriorityTaskWoken );\r
}\r
\r
\r
\r
void ENET_IRQHandler(void)\r
{\r
-portBASE_TYPE xSwitchRequired;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
\r
/* Give the semaphore in case the lwIP task needs waking. */\r
- xSwitchRequired = xSemaphoreGiveFromISR( s_xSemaphore, pdFALSE );\r
+ xSemaphoreGiveFromISR( s_xSemaphore, &xHigherPriorityTaskWoken );\r
\r
/* Clear the interrupt. */\r
ENET_DMA->ISR = DMI_RX_CURRENT_DONE;\r
\r
/* Switch tasks if necessary. */ \r
- portEND_SWITCHING_ISR( xSwitchRequired );\r
+ portEND_SWITCHING_ISR( xHigherPriorityTaskWoken );\r
}\r
/*-----------------------------------------------------------*/\r
\r
void UART1_IRQHandler( void )\r
{\r
signed portCHAR cChar;\r
-portBASE_TYPE xTaskWokenByTx = pdFALSE, xTaskWokenByPost = pdFALSE;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
\r
while( UART1->RIS & mainRXRIS )\r
{\r
character from the DR and place it in the queue of received\r
characters. */\r
cChar = UART1->DR;\r
- xTaskWokenByPost = xQueueSendFromISR( xRxedChars, &cChar, xTaskWokenByPost );\r
+ xQueueSendFromISR( xRxedChars, &cChar, &xHigherPriorityTaskWoken );\r
} \r
\r
if( UART1->RIS & mainTXRIS )\r
{\r
/* This interrupt was caused by space becoming available on the Tx\r
FIFO, wake any task that is waiting to post (if any). */\r
- xTaskWokenByTx = xSemaphoreGiveFromISR( xTxFIFOSemaphore, xTaskWokenByTx );\r
+ xSemaphoreGiveFromISR( xTxFIFOSemaphore, &xHigherPriorityTaskWoken );\r
lTaskWaiting = pdFALSE;\r
}\r
\r
\r
/* If a task was woken by either a character being received or a character\r
being transmitted then we may need to switch to another task. */\r
- portEND_SWITCHING_ISR( ( xTaskWokenByPost || xTaskWokenByTx ) );\r
+ portEND_SWITCHING_ISR( xHigherPriorityTaskWoken );\r
}\r
\r
\r
\r
void ENET_IRQHandler(void)\r
{\r
-portBASE_TYPE xSwitchRequired;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
\r
/* Give the semaphore in case the uIP task needs waking. */\r
- xSwitchRequired = xSemaphoreGiveFromISR( xSemaphore, pdFALSE );\r
+ xSemaphoreGiveFromISR( xSemaphore, &xHigherPriorityTaskWoken );\r
\r
/* Clear the interrupt. */\r
ENET_DMA->ISR = uipDMI_RX_CURRENT_DONE;\r
\r
/* Switch tasks if necessary. */ \r
- portEND_SWITCHING_ISR( xSwitchRequired );\r
+ portEND_SWITCHING_ISR( xHigherPriorityTaskWoken );\r
}\r
/*-----------------------------------------------------------*/\r
\r
"C:\Devtools\IAR Systems\Embedded Workbench 4.0\common\bin\cspybat" "C:\Devtools\IAR Systems\Embedded Workbench 4.0\avr32\bin\avr32proc.dll" "C:\Devtools\IAR Systems\Embedded Workbench 4.0\avr32\bin\avr32jtagicemkII.dll" %1 --plugin "C:\Devtools\IAR Systems\Embedded Workbench 4.0\avr32\bin\<libsupport_plugin>" --backend -B "--core" "avr32a" "--avr32_simd_instructions" "disabled" "--avr32_dsp_instructions" "enabled" "--avr32_rmw_instructions" "enabled" "-p" "C:\Devtools\IAR Systems\Embedded Workbench 4.0\avr32\config\iouc3a0512.ddf" "-d" "jtagicemkII" "--drv_communication" "USB" "--jtagice_clock" "100000" \r
\r
\r
-@REM loaded plugins:\r
+@REM Loaded plugins:\r
@REM avr32LibSupport.dll\r
@REM C:\Devtools\IAR Systems\Embedded Workbench 4.0\common\plugins\CodeCoverage\CodeCoverage.dll\r
@REM C:\Devtools\IAR Systems\Embedded Workbench 4.0\common\plugins\Profiling\Profiling.dll\r
{\r
/* Now we can declare the local variables. */\r
signed portCHAR cChar;\r
- portBASE_TYPE xTaskWokenByTx = pdFALSE, xTaskWokenByRx = pdFALSE;\r
+ portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
unsigned portLONG ulStatus;\r
volatile avr32_usart_t *usart = serialPORT_USART;\r
portBASE_TYPE retstatus;\r
Because FreeRTOS is not supposed to run with nested interrupts, put all OS\r
calls in a critical section . */\r
portENTER_CRITICAL();\r
- retstatus = xQueueReceiveFromISR( xCharsForTx, &cChar, &xTaskWokenByTx );\r
+ retstatus = xQueueReceiveFromISR( xCharsForTx, &cChar, &xHigherPriorityTaskWoken );\r
portEXIT_CRITICAL();\r
\r
if (retstatus == pdTRUE)\r
/* Because FreeRTOS is not supposed to run with nested interrupts, put all OS\r
calls in a critical section . */\r
portENTER_CRITICAL();\r
- retstatus = xQueueSendFromISR(xRxedChars, &cChar, pdFALSE);\r
+ retstatus = xQueueSendFromISR(xRxedChars, &cChar, &xHigherPriorityTaskWoken);\r
portEXIT_CRITICAL();\r
-\r
- if( retstatus )\r
- {\r
- xTaskWokenByRx = pdTRUE;\r
- }\r
}\r
\r
/* The return value will be used by portEXIT_SWITCHING_ISR() to know if it\r
should perform a vTaskSwitchContext(). */\r
- return ( xTaskWokenByTx || xTaskWokenByRx );\r
+ return ( xHigherPriorityTaskWoken );\r
}\r
/*-----------------------------------------------------------*/\r
\r
__interrupt void SIG_UART_RECV( void )\r
{\r
signed portCHAR cChar;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
\r
/* Get the character and post it on the queue of Rxed characters.\r
If the post causes a task to wake force a context switch as the woken task\r
may have a higher priority than the task we have interrupted. */\r
cChar = UDR;\r
\r
- if( xQueueSendFromISR( xRxedChars, &cChar, pdFALSE ) )\r
+ xQueueSendFromISR( xRxedChars, &cChar, &xHigherPriorityTaskWoken );\r
+\r
+ if( xHigherPriorityTaskWoken != pdFALSE )\r
{\r
taskYIELD();\r
}\r
vStartRegTestTasks();\r
\r
/* Create the tasks defined within this file. */\r
- xTaskCreate( vErrorChecks, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL );\r
+ xTaskCreate( vErrorChecks, ( signed portCHAR * ) "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL );\r
\r
/* Create the co-routines that flash the LED's. */\r
vStartFlashCoRoutines( mainNUM_FLASH_COROUTINES );\r
SIGNAL( SIG_UART_RECV )\r
{\r
signed portCHAR cChar;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
\r
/* Get the character and post it on the queue of Rxed characters.\r
If the post causes a task to wake force a context switch as the woken task\r
may have a higher priority than the task we have interrupted. */\r
cChar = UDR;\r
\r
- if( xQueueSendFromISR( xRxedChars, &cChar, pdFALSE ) )\r
+ xQueueSendFromISR( xRxedChars, &cChar, &xHigherPriorityTaskWoken );\r
+\r
+ if( xHigherPriorityTaskWoken != pdFALSE )\r
{\r
taskYIELD();\r
}\r
void vSerialISR( void ) interrupt 4\r
{\r
portCHAR cChar;\r
-portBASE_TYPE xTaskWokenByRx = pdFALSE, xTaskWokenByTx = pdFALSE;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
\r
/* 8051 port interrupt routines MUST be placed within a critical section\r
if taskYIELD() is used within the ISR! */\r
if( RI ) \r
{\r
/* Get the character and post it on the queue of Rxed characters.\r
- If the post causes a task to wake force a context switch as the woken task\r
- may have a higher priority than the task we have interrupted. */\r
+ If the post causes a task to wake force a context switch if the woken task\r
+ has a higher priority than the task we have interrupted. */\r
cChar = SBUF;\r
RI = 0;\r
\r
- if( xQueueSendFromISR( xRxedChars, &cChar, pdFALSE ) )\r
- {\r
- xTaskWokenByRx = ( portBASE_TYPE ) pdTRUE;\r
- }\r
+ xQueueSendFromISR( xRxedChars, &cChar, &xHigherPriorityTaskWoken );\r
}\r
\r
if( TI ) \r
{\r
- if( xQueueReceiveFromISR( xCharsForTx, &cChar, &xTaskWokenByTx ) == ( portBASE_TYPE ) pdTRUE )\r
+ if( xQueueReceiveFromISR( xCharsForTx, &cChar, &xHigherPriorityTaskWoken ) == ( portBASE_TYPE ) pdTRUE )\r
{\r
/* Send the next character queued for Tx. */\r
SBUF = cChar;\r
TI = 0;\r
}\r
\r
- if( xTaskWokenByRx || xTaskWokenByTx )\r
+ if( xHigherPriorityTaskWoken )\r
{\r
portYIELD();\r
}\r
{\r
unsigned portSHORT usStatusRegister;\r
portCHAR cChar;\r
-portBASE_TYPE xTaskWokenByPost = pdFALSE, xAnotherTaskWokenByPost = pdFALSE, xTaskWokenByTx = pdFALSE, xContinue = pdTRUE;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE, xContinue = pdTRUE;\r
\r
/* NOTE: THIS IS NOT AN EFFICIENT ISR AS IT IS DESIGNED SOLELY TO TEST\r
THE SCHEDULER FUNCTIONALITY. REAL APPLICATIONS SHOULD NOT USE THIS\r
if( usStatusRegister & serRX_READY )\r
{\r
cChar = ( portCHAR ) portINPUT_WORD( pxPort->usRxReg );\r
- xTaskWokenByPost = xQueueSendFromISR( pxPort->xRxedChars, &cChar, xTaskWokenByPost );\r
+ xQueueSendFromISR( pxPort->xRxedChars, &cChar, &xHigherPriorityTaskWoken );\r
\r
/* Also release the semaphore - this does nothing interesting and is just a test. */\r
- xAnotherTaskWokenByPost = xSemaphoreGiveFromISR( pxPort->xTestSem, xAnotherTaskWokenByPost );\r
+ xSemaphoreGiveFromISR( pxPort->xTestSem, &xHigherPriorityTaskWoken );\r
\r
/* We have performed an action this cycle - there may be other to perform. */\r
xContinue = pdTRUE;\r
\r
if( pxPort->sTxInterruptOn && ( usStatusRegister & serTX_EMPTY ) )\r
{\r
- if( xQueueReceiveFromISR( pxPort->xCharsForTx, &cChar, &xTaskWokenByTx ) == pdTRUE )\r
+ if( xQueueReceiveFromISR( pxPort->xCharsForTx, &cChar, &xHigherPriorityTaskWoken ) == pdTRUE )\r
{\r
portOUTPUT_WORD( pxPort->usTxReg, ( unsigned portSHORT ) cChar );\r
\r
/* If posting to the queue woke a task that was blocked on the queue we may\r
want to switch to the woken task - depending on its priority relative to\r
the task interrupted by this ISR. */\r
- if( xTaskWokenByPost || xAnotherTaskWokenByPost || xTaskWokenByTx)\r
- {\r
- return pdTRUE;\r
- }\r
- else\r
- {\r
- return pdFALSE;\r
- }\r
+ return xHigherPriorityTaskWoken;\r
}\r
\r
\r
\r
\r
\r
+\r
/* As this is a switching ISR the local variables must be declared as \r
static. */\r
static portCHAR cRxByte;\r
- static portBASE_TYPE xTaskWokenByPost;\r
+ static portBASE_TYPE xHigherPriorityTaskWoken;\r
+\r
+ xHigherPriorityTaskWoken = pdFALSE;\r
\r
/* Get the character. */\r
cRxByte = RDR1;\r
\r
/* Post the character onto the queue of received characters - noting\r
whether or not this wakes a task. */\r
- xTaskWokenByPost = xQueueSendFromISR( xRxedChars, &cRxByte, pdFALSE ); \r
+ xQueueSendFromISR( xRxedChars, &cRxByte, &xHigherPriorityTaskWoken );\r
\r
/* Clear the interrupt. */\r
SSR1 &= ~serRX_INTERRUPT;\r
/* This must be the last line in the function. We pass cTaskWokenByPost so \r
a context switch will occur if the received character woke a task that has\r
a priority higher than the task we interrupted. */\r
- portEXIT_SWITCHING_ISR( xTaskWokenByPost );\r
+ portEXIT_SWITCHING_ISR( xHigherPriorityTaskWoken );\r
}\r
/*-----------------------------------------------------------*/\r
\r
__interrupt void vCOM0_ISR( void )\r
{\r
volatile unsigned portCHAR ucByte, ucStatus;\r
-portBASE_TYPE xTaskWokenByPost = pdFALSE, xTaskWokenByTx = pdFALSE;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
\r
/* What caused the interrupt? */\r
ucStatus = SCI0SR1;\r
\r
/* Post the character onto the queue of received characters - noting\r
whether or not this wakes a task. */\r
- xTaskWokenByPost = xQueueSendFromISR( xRxedChars, ( void * ) &ucByte, pdFALSE ); \r
+ xQueueSendFromISR( xRxedChars, ( void * ) &ucByte, &xHigherPriorityTaskWoken );\r
}\r
\r
if( ( ucStatus & serTX_INTERRUPT ) && ( SCI0CR2_SCTIE ) )\r
{ \r
/* The interrupt was caused by a character being transmitted. */\r
- if( xQueueReceiveFromISR( xCharsForTx, ( void * ) &ucByte, &xTaskWokenByTx ) == pdTRUE )\r
+ if( xQueueReceiveFromISR( xCharsForTx, ( void * ) &ucByte, &xHigherPriorityTaskWoken ) == pdTRUE )\r
{\r
/* Clear the SCRF bit. */\r
SCI0DRL = ucByte;\r
}\r
}\r
\r
- if( ( xTaskWokenByPost ) || ( xTaskWokenByTx ) )\r
+ if( xHigherPriorityTaskWoken )\r
{\r
portYIELD();\r
}\r
void interrupt vButtonPush( void )\r
{\r
static unsigned portBASE_TYPE uxValToSend = 0;\r
+ static unsigned portLONG xHigherPriorityTaskWoken;\r
+\r
+ xHigherPriorityTaskWoken = pdFALSE;\r
\r
/* Send an incrementing value to the button push task each run. */\r
uxValToSend++; \r
blocked waiting for the data. As the button push task is high priority\r
it will wake and a context switch should be performed before leaving\r
the ISR. */\r
- if( xQueueSendFromISR( xButtonQueue, &uxValToSend, pdFALSE ) )\r
+ xQueueSendFromISR( xButtonQueue, &uxValToSend, &xHigherPriorityTaskWoken );\r
+\r
+ if( xHigherPriorityTaskWoken )\r
{\r
/* NOTE: This macro can only be used if there are no local\r
variables defined. This function uses a static variable so it's\r
void vCOM_ISR( void )\r
{\r
volatile unsigned portCHAR ucByte, ucStatus;\r
-portBASE_TYPE xTaskWokenByPost = pdFALSE, xTaskWokenByTx = pdFALSE;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
\r
/* What caused the interrupt? */\r
ucStatus = SCISR1;\r
\r
/* Post the character onto the queue of received characters - noting\r
whether or not this wakes a task. */\r
- xTaskWokenByPost = xQueueSendFromISR( xRxedChars, ( void * ) &ucByte, pdFALSE );\r
+ xQueueSendFromISR( xRxedChars, ( void * ) &ucByte, &xHigherPriorityTaskWoken );\r
}\r
\r
if( ( ucStatus & serTX_INTERRUPT ) && ( SCICR2 & 0x80 ) )\r
{ \r
/* The interrupt was caused by a character being transmitted. */\r
- if( xQueueReceiveFromISR( xCharsForTx, ( void * ) &ucByte, &xTaskWokenByTx ) == pdTRUE )\r
+ if( xQueueReceiveFromISR( xCharsForTx, ( void * ) &ucByte, &xHigherPriorityTaskWoken ) == pdTRUE )\r
{\r
/* Clear the SCRF bit. */\r
SCIDRL = ucByte;\r
}\r
}\r
\r
- if( ( xTaskWokenByPost ) || ( xTaskWokenByTx ) )\r
+ if( xHigherPriorityTaskWoken )\r
{\r
portYIELD();\r
}\r
-\r
}\r
\r
__interrupt void UART2_RxISR (void)\r
{\r
signed portCHAR cChar;\r
+ portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
\r
/* Get the character from the UART and post it on the queue of Rxed \r
characters. */\r
cChar = RDR02;\r
\r
- if( xQueueSendFromISR( xRxedChars, &cChar, pdFALSE ) )\r
+ xQueueSendFromISR( xRxedChars, &cChar, &xHigherPriorityTaskWoken );\r
+\r
+ if( xHigherPriorityTaskWoken )\r
{\r
/*If the post causes a task to wake force a context switch \r
as the woken task may have a higher priority than the task we have \r
__interrupt void UART5_RxISR( void )\r
{\r
unsigned portCHAR ch;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
\r
ch = RDR05;\r
- xQueueSendFromISR( xQueue, &ch, pdFALSE );\r
+ xQueueSendFromISR( xQueue, &ch, &xHigherPriorityTaskWoken );\r
}\r
__interrupt void UART0_RxISR( void )\r
{\r
volatile signed portCHAR cChar;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
\r
/* Get the character from the UART and post it on the queue of Rxed \r
characters. */\r
cChar = RDR0;\r
\r
- if( xQueueSendFromISR( xRxedChars, ( const void *const ) &cChar, (signed portBASE_TYPE) pdFALSE ) )\r
+ xQueueSendFromISR( xRxedChars, ( const void *const ) &cChar, &xHigherPriorityTaskWoken );\r
+\r
+ if( xHigherPriorityTaskWoken )\r
{\r
/*If the post causes a task to wake force a context switch \r
as the woken task may have a higher priority than the task we have \r
__interrupt void UART0_TraceRxISR( void )\r
{\r
unsigned portCHAR ch;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
\r
ch = RDR0;\r
- xQueueSendFromISR( xQueue, &ch, pdFALSE );\r
+ xQueueSendFromISR( xQueue, &ch, &xHigherPriorityTaskWoken );\r
}\r
prvSerialISR( void )\r
{\r
static signed portCHAR cChar;\r
- static portBASE_TYPE xTaskWokenByTx = pdFALSE, xTaskWokenByRx = pdFALSE;\r
+ static portBASE_TYPE xHigherPriorityTaskWoken;\r
\r
/* We have to remvoe the effect of the GCC. Please note that the\r
* __attribute__ ((interrupt_handler)) does not work here because we\r
* variable declarations.\r
*/\r
portENTER_SWITCHING_ISR();\r
+ xHigherPriorityTaskWoken = pdFALSE;\r
\r
/* Ready to send a character from the buffer. */\r
if( MCF_UART_USR0 & MCF_UART_USR_TXRDY )\r
{\r
/* Transmit buffer is ready. Test if there are characters available. */\r
- if( xQueueReceiveFromISR( xComPortIF[ 0 ].xTXChars, &cChar, &xTaskWokenByTx ) ==\r
+ if( xQueueReceiveFromISR( xComPortIF[ 0 ].xTXChars, &cChar, &xHigherPriorityTaskWoken ) ==\r
pdTRUE )\r
{\r
/* A character was retrieved from the queue so can be sent. */\r
if( MCF_UART_USR0 & MCF_UART_USR_RXRDY )\r
{\r
cChar = MCF_UART_URB0;\r
- xTaskWokenByRx =\r
- xQueueSendFromISR( xComPortIF[ 0].xRXChars, &cChar, xTaskWokenByRx );\r
+ xQueueSendFromISR( xComPortIF[ 0].xRXChars, &cChar, &xHigherPriorityTaskWoken );\r
}\r
/* Exit the ISR. If a task was woken by either a character being\r
* or transmitted then a context switch will occur.\r
*/\r
- portEXIT_SWITCHING_ISR( ( xTaskWokenByTx || xTaskWokenByRx ) );\r
+ portEXIT_SWITCHING_ISR( xHigherPriorityTaskWoken );\r
}\r
void vSerialISR( void *pvBaseAddress )\r
{\r
unsigned portLONG ulISRStatus;\r
-portBASE_TYPE xTaskWokenByTx = pdFALSE, xTaskWokenByRx = pdFALSE;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
portCHAR cChar;\r
\r
/* Determine the cause of the interrupt. */\r
characters. This might wake a task that was blocked waiting for \r
data. */\r
cChar = ( portCHAR )XIo_In32( XPAR_RS232_UART_BASEADDR + XUL_RX_FIFO_OFFSET );\r
- xTaskWokenByRx = xQueueSendFromISR( xRxedChars, &cChar, xTaskWokenByRx );\r
+ xQueueSendFromISR( xRxedChars, &cChar, &xHigherPriorityTaskWoken );\r
}\r
\r
if( ( ulISRStatus & XUL_SR_TX_FIFO_EMPTY ) != 0 )\r
/* There is space in the FIFO - if there are any characters queue for\r
transmission they can be send to the UART now. This might unblock a\r
task that was waiting for space to become available on the Tx queue. */\r
- if( xQueueReceiveFromISR( xCharsForTx, &cChar, &xTaskWokenByTx ) == pdTRUE )\r
+ if( xQueueReceiveFromISR( xCharsForTx, &cChar, &xHigherPriorityTaskWoken ) == pdTRUE )\r
{\r
XIo_Out32( XPAR_RS232_UART_BASEADDR + XUL_TX_FIFO_OFFSET, cChar );\r
}\r
}\r
\r
/* If we woke any tasks we may require a context switch. */\r
- if( xTaskWokenByTx || xTaskWokenByRx )\r
+ if( xHigherPriorityTaskWoken )\r
{\r
portYIELD_FROM_ISR();\r
}\r
void vSerialRxISR( void )\r
{\r
portCHAR cChar;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
\r
/* Get the character and post it on the queue of Rxed characters.\r
If the post causes a task to wake force a context switch as the woken task\r
RCSTAbits.CREN = serCONTINUOUS_RX; \r
}\r
\r
- if( xQueueSendFromISR( xRxedChars, ( const void * ) &cChar, pdFALSE ) )\r
+ xQueueSendFromISR( xRxedChars, ( const void * ) &cChar, &xHigherPriorityTaskWoken );\r
+\r
+ if( xHigherPriorityTaskWoken )\r
{\r
taskYIELD();\r
}\r
* because this SFR will be restored before exiting the ISR.\r
*/\r
extern portCHAR cChar;\r
+ extern portBASE_TYPE xHigherPriorityTaskWoken;\r
#pragma locate cChar &PRODL\r
\r
/*\r
bCREN = serCONTINUOUS_RX; \r
}\r
\r
- if( xQueueSendFromISR( xRxedChars, ( const void * ) &cChar, pdFALSE ) )\r
+ xHigherPriorityTaskWoken = pdFALSE;\r
+ xQueueSendFromISR( xRxedChars, ( const void * ) &cChar, &xHigherPriorityTaskWoken );\r
+\r
+ if( xHigherPriorityTaskWoken )\r
{\r
uxSwitchRequested = pdTRUE;\r
}\r
/* Queues to interface between comms API and interrupt routines. */\r
xQueueHandle xRxedChars; \r
xQueueHandle xCharsForTx;\r
+portBASE_TYPE xHigherPriorityTaskWoken;\r
\r
/*-----------------------------------------------------------*/\r
\r
void __attribute__((__interrupt__, auto_psv)) _U2RXInterrupt( void )\r
{\r
portCHAR cChar;\r
-portBASE_TYPE xYieldRequired = pdFALSE;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
\r
/* Get the character and post it on the queue of Rxed characters.\r
If the post causes a task to wake force a context switch as the woken task\r
while( U2STAbits.URXDA )\r
{\r
cChar = U2RXREG;\r
- xYieldRequired = xQueueSendFromISR( xRxedChars, &cChar, xYieldRequired );\r
+ xQueueSendFromISR( xRxedChars, &cChar, &xHigherPriorityTaskWoken );\r
}\r
\r
- if( xYieldRequired != pdFALSE )\r
+ if( xHigherPriorityTaskWoken != pdFALSE )\r
{\r
taskYIELD();\r
}\r
{\r
/* Declared static to minimise stack use. */\r
static portCHAR cChar;\r
-static portBASE_TYPE xYieldRequired;\r
+static portBASE_TYPE xHigherPriorityTaskWoken;\r
\r
- xYieldRequired = pdFALSE;\r
+ xHigherPriorityTaskWoken = pdFALSE;\r
\r
/* Are any Rx interrupts pending? */\r
if( mU2RXGetIntFlag() )\r
/* Retrieve the received character and place it in the queue of\r
received characters. */\r
cChar = U2RXREG;\r
- xYieldRequired = xQueueSendFromISR( xRxedChars, &cChar, xYieldRequired );\r
+ xQueueSendFromISR( xRxedChars, &cChar, &xHigherPriorityTaskWoken );\r
}\r
mU2RXClearIntFlag();\r
}\r
{\r
while( !( U2STAbits.UTXBF ) )\r
{\r
- if( xQueueReceiveFromISR( xCharsForTx, &cChar, &xYieldRequired ) == pdTRUE )\r
+ if( xQueueReceiveFromISR( xCharsForTx, &cChar, &xHigherPriorityTaskWoken ) == pdTRUE )\r
{\r
/* Send the next character queued for Tx. */\r
U2TXREG = cChar;\r
}\r
\r
/* If sending or receiving necessitates a context switch, then switch now. */\r
- portEND_SWITCHING_ISR( xYieldRequired );\r
+ portEND_SWITCHING_ISR( xHigherPriorityTaskWoken );\r
}\r
\r
\r
static void vSerialISR( XUartLite *pxUART )
{
unsigned portLONG ulISRStatus;
-portBASE_TYPE xTaskWokenByTx = pdFALSE, xTaskWokenByRx = pdFALSE, lDidSomething;
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE, lDidSomething;
portCHAR cChar;
do
characters. This might wake a task that was blocked waiting for
data. */
cChar = ( portCHAR ) XIo_In32( XPAR_RS232_UART_BASEADDR + XUL_RX_FIFO_OFFSET );
- xTaskWokenByRx = xQueueSendFromISR( xRxedChars, &cChar, xTaskWokenByRx );
+ xQueueSendFromISR( xRxedChars, &cChar, &xHigherPriorityTaskWoken );
lDidSomething = pdTRUE;
}
/* There is space in the FIFO - if there are any characters queue for
transmission they can be sent to the UART now. This might unblock a
task that was waiting for space to become available on the Tx queue. */
- if( xQueueReceiveFromISR( xCharsForTx, &cChar, &xTaskWokenByTx ) == pdTRUE )
+ if( xQueueReceiveFromISR( xCharsForTx, &cChar, &xHigherPriorityTaskWoken ) == pdTRUE )
{
XIo_Out32( XPAR_RS232_UART_BASEADDR + XUL_TX_FIFO_OFFSET, cChar );
lDidSomething = pdTRUE;
} while( lDidSomething == pdTRUE );
/* If we woke any tasks we may require a context switch. */
- if( xTaskWokenByTx || xTaskWokenByRx )
+ if( xHigherPriorityTaskWoken )
{
portYIELD_FROM_ISR();
}
void vEINT0_ISR_Handler( void )\r
{\r
extern xQueueHandle xTCPISRQueue;\r
-portBASE_TYPE xTaskWoken = pdFALSE;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
\r
/* Just wake the TCP task so it knows an ISR has occurred. */\r
- xTaskWoken = xQueueSendFromISR( xTCPISRQueue, ( void * ) &lDummyVariable, xTaskWoken ); \r
+ xQueueSendFromISR( xTCPISRQueue, ( void * ) &lDummyVariable, &xHigherPriorityTaskWoken ); \r
\r
/* We cannot carry on processing interrupts until the TCP task has \r
processed this one - so for now interrupts are disabled. The TCP task will\r
/* Clear the interrupt bit. */ \r
VICVectAddr = tcpCLEAR_VIC_INTERRUPT;\r
\r
- if( xTaskWoken )\r
+ if( xHigherPriorityTaskWoken )\r
{\r
portYIELD_FROM_ISR();\r
}\r
/* Holds the current transmission state. */ \r
static I2C_STATE eCurrentState = eSentStart;\r
static portLONG lMessageIndex = -i2cBUFFER_ADDRESS_BYTES; /* There are two address bytes to send prior to the data. */\r
-portBASE_TYPE xTaskWokenByTx = pdFALSE;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
portLONG lBytesLeft;\r
\r
/* The action taken for this interrupt depends on our current state. */\r
must 'give' the semaphore so the task is woken.*/\r
if( pxCurrentMessage->xMessageCompleteSemaphore )\r
{\r
- xTaskWokenByTx = xSemaphoreGiveFromISR( pxCurrentMessage->xMessageCompleteSemaphore, xTaskWokenByTx );\r
+ xSemaphoreGiveFromISR( pxCurrentMessage->xMessageCompleteSemaphore, &xHigherPriorityTaskWoken );\r
}\r
\r
/* Are there any other messages to transact? */\r
- if( xQueueReceiveFromISR( xMessagesForTx, &pxCurrentMessage, &xTaskWokenByTx ) == pdTRUE )\r
+ if( xQueueReceiveFromISR( xMessagesForTx, &pxCurrentMessage, &xHigherPriorityTaskWoken ) == pdTRUE )\r
{\r
/* Start the next message - which was\r
retrieved from the queue. */\r
semaphore must be 'given' to wake the task. */\r
if( pxCurrentMessage->xMessageCompleteSemaphore )\r
{\r
- xTaskWokenByTx = xSemaphoreGiveFromISR( pxCurrentMessage->xMessageCompleteSemaphore, xTaskWokenByTx );\r
+ xSemaphoreGiveFromISR( pxCurrentMessage->xMessageCompleteSemaphore, &xHigherPriorityTaskWoken );\r
}\r
\r
/* Are there any other messages to transact? */\r
- if( xQueueReceiveFromISR( xMessagesForTx, &pxCurrentMessage, &xTaskWokenByTx ) == pdTRUE )\r
+ if( xQueueReceiveFromISR( xMessagesForTx, &pxCurrentMessage, &xHigherPriorityTaskWoken ) == pdTRUE )\r
{\r
/* Start the next message from the Tx queue. */\r
I2C_I2CONSET = i2cSTA_BIT;\r
I2C_I2CONCLR = i2cSI_BIT;\r
VICVectAddr = i2cCLEAR_VIC_INTERRUPT;\r
\r
- if( xTaskWokenByTx )\r
+ if( xHigherPriorityTaskWoken )\r
{\r
portYIELD_FROM_ISR();\r
}\r
{\r
unsigned portSHORT usStatusRegister;\r
portCHAR cChar;\r
-portBASE_TYPE xTaskWokenByPost = pdFALSE, xAnotherTaskWokenByPost = pdFALSE, xTaskWokenByTx = pdFALSE;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
\r
/* NOTE: THIS IS NOT AN EFFICIENT ISR AS IT IS DESIGNED SOLELY TO TEST\r
THE SCHEDULER FUNCTIONALITY. REAL APPLICATIONS SHOULD NOT USE THIS\r
if( usStatusRegister & serRX_READY )\r
{\r
cChar = ( portCHAR ) portINPUT_WORD( pxPort->usRxReg );\r
- xTaskWokenByPost = xQueueSendFromISR( pxPort->xRxedChars, &cChar, xTaskWokenByPost );\r
+ xQueueSendFromISR( pxPort->xRxedChars, &cChar, &xHigherPriorityTaskWoken );\r
\r
/* Also release the semaphore - this does nothing interesting and is just a test. */\r
- xAnotherTaskWokenByPost = xSemaphoreGiveFromISR( pxPort->xTestSem, xAnotherTaskWokenByPost );\r
+ xSemaphoreGiveFromISR( pxPort->xTestSem, &xHigherPriorityTaskWoken );\r
}\r
else if( pxPort->sTxInterruptOn && ( usStatusRegister & serTX_EMPTY ) )\r
{\r
- if( xQueueReceiveFromISR( pxPort->xCharsForTx, &cChar, &xTaskWokenByTx ) == pdTRUE )\r
+ if( xQueueReceiveFromISR( pxPort->xCharsForTx, &cChar, &xHigherPriorityTaskWoken ) == pdTRUE )\r
{\r
portOUTPUT_WORD( pxPort->usTxReg, ( unsigned portSHORT ) cChar );\r
}\r
/* If posting to the queue woke a task that was blocked on the queue we may\r
want to switch to the woken task - depending on its priority relative to\r
the task interrupted by this ISR. */\r
- if( xTaskWokenByPost || xAnotherTaskWokenByPost || xTaskWokenByTx)\r
+ if( xHigherPriorityTaskWoken )\r
{\r
return pdTRUE;\r
}\r
{\r
unsigned char status;\r
extern xSemaphoreHandle xTCPSemaphore;\r
-portBASE_TYPE xSwitchRequired = pdFALSE;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
\r
#ifdef I2CHIP_WINDOW\r
u_int current_window = i2chip_get_window();\r
\r
if (status)\r
{\r
- xSwitchRequired = pdTRUE;\r
+ xHigherPriorityTaskWoken = pdTRUE;\r
// channel 0 interrupt(sysinit, sockinit, established, closed, timeout, send_ok, recv_ok)\r
if (status & 0x01)\r
{\r
i2chip_set_window(current_window);\r
#endif\r
\r
- if( xSwitchRequired == pdTRUE )\r
+ if( xHigherPriorityTaskWoken == pdTRUE )\r
{\r
- xSwitchRequired = xSemaphoreGiveFromISR( xTCPSemaphore, pdFALSE );\r
+ xSemaphoreGiveFromISR( xTCPSemaphore, &xHigherPriorityTaskWoken );\r
}\r
\r
- return xSwitchRequired;\r
+ return xHigherPriorityTaskWoken;\r
}\r
\r
void far interrupt in4_isr_i2chip(void)\r
void __attribute__((__interrupt__, auto_psv)) _U2RXInterrupt( void )\r
{\r
portCHAR cChar;\r
-portBASE_TYPE xYieldRequired = pdFALSE;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
\r
/* Get the character and post it on the queue of Rxed characters.\r
If the post causes a task to wake force a context switch as the woken task\r
while( U2STAbits.URXDA )\r
{\r
cChar = U2RXREG;\r
- xYieldRequired = xQueueSendFromISR( xRxedChars, &cChar, xYieldRequired );\r
+ xQueueSendFromISR( xRxedChars, &cChar, &xHigherPriorityTaskWoken );\r
}\r
\r
- if( xYieldRequired != pdFALSE )\r
+ if( xHigherPriorityTaskWoken != pdFALSE )\r
{\r
taskYIELD();\r
}\r
\r
// Variable definitions can be made now.\r
volatile unsigned long ulIntStatus, ulEventStatus;\r
- long xSwitchRequired = FALSE;\r
+ long xHigherPriorityTaskWoken = FALSE;\r
\r
// Find the cause of the interrupt.\r
ulIntStatus = AVR32_MACB.isr;\r
// the Rx descriptors.\r
portENTER_CRITICAL();\r
#ifdef FREERTOS_USED\r
- xSwitchRequired = xSemaphoreGiveFromISR( xSemaphore, FALSE );\r
+ xSemaphoreGiveFromISR( xSemaphore, &xHigherPriorityTaskWoken );\r
#else\r
DataToRead = TRUE; \r
#endif \r
AVR32_MACB.tsr;\r
}\r
\r
- return ( xSwitchRequired );\r
+ return ( xHigherPriorityTaskWoken );\r
}\r
\r
\r
{\r
/* Now we can declare the local variables. */\r
signed portCHAR cChar;\r
- portBASE_TYPE xTaskWokenByTx = pdFALSE, xTaskWokenByRx = pdFALSE;\r
+ portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
unsigned portLONG ulStatus;\r
volatile avr32_usart_t *usart0 = &AVR32_USART0;\r
portBASE_TYPE retstatus;\r
/* Because FreeRTOS is not supposed to run with nested interrupts, put all OS\r
calls in a critical section . */\r
portENTER_CRITICAL();\r
- retstatus = xQueueReceiveFromISR(xCharsForTx, &cChar, &xTaskWokenByTx);\r
+ retstatus = xQueueReceiveFromISR(xCharsForTx, &cChar, &xHigherPriorityTaskWoken);\r
portEXIT_CRITICAL();\r
if (retstatus == pdTRUE)\r
{\r
/* Because FreeRTOS is not supposed to run with nested interrupts, put all OS\r
calls in a critical section . */\r
portENTER_CRITICAL();\r
- retstatus = xQueueSendFromISR(xRxedChars, &cChar, pdFALSE);\r
+ xQueueSendFromISR(xRxedChars, &cChar, &xHigherPriorityTaskWoken);\r
portEXIT_CRITICAL();\r
- if (retstatus)\r
- {\r
- xTaskWokenByRx = pdTRUE;\r
- }\r
}\r
\r
/* The return value will be used by portEXIT_SWITCHING_ISR() to know if it\r
should perform a vTaskSwitchContext(). */\r
- return ( xTaskWokenByTx || xTaskWokenByRx );\r
+ return ( xHigherPriorityTaskWoken );\r
}\r
\r
\r
void vEMACISR_Handler( void )\r
{\r
volatile unsigned portLONG ulIntStatus, ulEventStatus;\r
-portBASE_TYPE xSwitchRequired = pdFALSE;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
extern void vClearEMACTxBuffer( void );\r
\r
/* Find the cause of the interrupt. */\r
{\r
/* A frame has been received, signal the lwIP task so it can process\r
the Rx descriptors. */\r
- xSwitchRequired = xSemaphoreGiveFromISR( xSemaphore, pdFALSE );\r
+ xSemaphoreGiveFromISR( xSemaphore, &xHigherPriorityTaskWoken );\r
AT91C_BASE_EMAC->EMAC_RSR = AT91C_EMAC_REC;\r
}\r
\r
switch to another task. If the unblocked task was of higher priority then\r
the interrupted task it will then execute immediately that the ISR\r
completes. */\r
- if( xSwitchRequired )\r
+ if( xHigherPriorityTaskWoken )\r
{\r
portYIELD_FROM_ISR();\r
}\r
\r
void vUSB_ISR_Handler( void )\r
{\r
-portCHAR cTaskWokenByPost = pdFALSE;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
static volatile unsigned portLONG ulNextMessage = 0;\r
xISRStatus *pxMessage;\r
unsigned portLONG ulRxBytes;\r
AT91C_BASE_UDP->UDP_CSR[ usbEND_POINT_3 ] &= ~usbINT_CLEAR_MASK;\r
\r
/* Post ISR data to queue for task-level processing */\r
- cTaskWokenByPost = xQueueSendFromISR( xUSBInterruptQueue, &pxMessage, cTaskWokenByPost );\r
+ xQueueSendFromISR( xUSBInterruptQueue, &pxMessage, &xHigherPriorityTaskWoken );\r
\r
/* Clear AIC to complete ISR processing */\r
AT91C_BASE_AIC->AIC_EOICR = 0;\r
\r
/* Do a task switch if needed */\r
- if( cTaskWokenByPost )\r
+ if( xHigherPriorityTaskWoken )\r
{\r
/* This call will ensure that the unblocked task will be executed\r
immediately upon completion of the ISR if it has a priority higher\r
void\r
mcf523xfec_rx_irq( void )\r
{\r
- static portBASE_TYPE xNeedSwitch = pdFALSE;\r
+ static portBASE_TYPE xHigherPriorityTaskWoken;\r
\r
/* Workaround GCC if frame pointers are enabled. This is an ISR and\r
* we must not modify the stack before portENTER_SWITCHING_ISR( )\r
* a call to the portENTER_SWITCHING_ISR() macro.\r
*/\r
portENTER_SWITCHING_ISR( );\r
-\r
+ xHigherPriorityTaskWoken = pdFALSE;\r
/* Set Debug PIN to high to measure RX latency. */\r
FEC_DEBUG_RX_TIMING( 1 );\r
\r
{\r
/* Clear interrupt from EIR register immediately */\r
MCF_FEC_EIR = ( MCF_FEC_EIR_RXB | MCF_FEC_EIR_RXF );\r
- xNeedSwitch = xSemaphoreGiveFromISR( fecif_g->rx_sem, pdFALSE );\r
+ xSemaphoreGiveFromISR( fecif_g->rx_sem, &xHigherPriorityTaskWoken );\r
}\r
- portEXIT_SWITCHING_ISR( xNeedSwitch );\r
+ portEXIT_SWITCHING_ISR( xHigherPriorityTaskWoken );\r
}\r
\r
void\r
prvSerialISR( void )\r
{\r
static signed portCHAR cChar;\r
- static portBASE_TYPE xTaskWokenByTx = pdFALSE, xTaskWokenByRx = pdFALSE;\r
+ static portBASE_TYPE xHigherPriorityTaskWoken;\r
\r
/* We have to remvoe the effect of the GCC. Please note that the\r
* __attribute__ ((interrupt_handler)) does not work here because we\r
* variable declarations.\r
*/\r
portENTER_SWITCHING_ISR();\r
+ xHigherPriorityTaskWoken = pdFALSE;\r
\r
/* Ready to send a character from the buffer. */\r
if( MCF_UART_USR0 & MCF_UART_USR_TXRDY )\r
{\r
/* Transmit buffer is ready. Test if there are characters available. */\r
- if( xQueueReceiveFromISR( xComPortIF[ 0 ].xTXChars, &cChar, &xTaskWokenByTx ) ==\r
+ if( xQueueReceiveFromISR( xComPortIF[ 0 ].xTXChars, &cChar, &xHigherPriorityTaskWoken ) ==\r
pdTRUE )\r
{\r
/* A character was retrieved from the queue so can be sent. */\r
if( MCF_UART_USR0 & MCF_UART_USR_RXRDY )\r
{\r
cChar = MCF_UART_URB0;\r
- xTaskWokenByRx =\r
- xQueueSendFromISR( xComPortIF[ 0].xRXChars, &cChar, xTaskWokenByRx );\r
+ xQueueSendFromISR( xComPortIF[ 0].xRXChars, &cChar, &xHigherPriorityTaskWoken );\r
}\r
/* Exit the ISR. If a task was woken by either a character being\r
* or transmitted then a context switch will occur.\r
*/\r
- portEXIT_SWITCHING_ISR( ( xTaskWokenByTx || xTaskWokenByRx ) );\r
+ portEXIT_SWITCHING_ISR( xHigherPriorityTaskWoken );\r
}\r
void vRxISR( void ) __interrupt[ UART1RX_VECTOR ]\r
{\r
signed portCHAR cChar;\r
+ portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
\r
/* Get the character from the UART and post it on the queue of Rxed \r
characters. */\r
cChar = U1RXBUF;\r
\r
- if( xQueueSendFromISR( xRxedChars, &cChar, pdFALSE ) )\r
+ xQueueSendFromISR( xRxedChars, &cChar, &xHigherPriorityTaskWoken );\r
+\r
+ if( xHigherPriorityTaskWoken )\r
{\r
/*If the post causes a task to wake force a context switch \r
as the woken task may have a higher priority than the task we have \r
void ISRCom1Rx( void )\r
{\r
signed portCHAR cChar;\r
+ portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
\r
/* Get the character from the UART and post it on the queue of Rxed \r
characters. */\r
cChar = U1RXBUF;\r
\r
- if( xQueueSendFromISR( xRxedChars, &cChar, pdFALSE ) )\r
+ xQueueSendFromISR( xRxedChars, &cChar, &xHigherPriorityTaskWoken );\r
+\r
+ if( xHigherPriorityTaskWoken )\r
{\r
/*If the post causes a task to wake force a context switch \r
as the woken task may have a higher priority than the task we have \r
interrupt (UART1RX_VECTOR) vRxISR( void )\r
{\r
signed portCHAR cChar;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
\r
/* Get the character from the UART and post it on the queue of Rxed \r
characters. */\r
cChar = U1RXBUF;\r
\r
- if( xQueueSendFromISR( xRxedChars, &cChar, pdFALSE ) )\r
+ xQueueSendFromISR( xRxedChars, &cChar, &xHigherPriorityTaskWoken );\r
+\r
+ if( xHigherPriorityTaskWoken )\r
{\r
/*If the post causes a task to wake force a context switch \r
as the woken task may have a higher priority than the task we have \r
__arm void vEMACISR( void )\r
{\r
volatile unsigned portLONG ulIntStatus, ulRxStatus;\r
-portBASE_TYPE xSwitchRequired = pdFALSE;\r
+portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
\r
ulIntStatus = AT91C_BASE_EMAC->EMAC_ISR;\r
ulRxStatus = AT91C_BASE_EMAC->EMAC_RSR;\r
{\r
/* A frame has been received, signal the uIP task so it can process\r
the Rx descriptors. */\r
- xSwitchRequired = xSemaphoreGiveFromISR( xSemaphore, pdFALSE );\r
+ xSemaphoreGiveFromISR( xSemaphore, &xHigherPriorityTaskWoken );\r
AT91C_BASE_EMAC->EMAC_RSR = AT91C_EMAC_REC;\r
}\r
\r
/* If a task was woken by either a character being received or a character\r
being transmitted then we may need to switch to another task. */\r
- portEND_SWITCHING_ISR( xSwitchRequired );\r
+ portEND_SWITCHING_ISR( xHigherPriorityTaskWoken );\r
\r
/* Clear the interrupt. */\r
AT91C_BASE_AIC->AIC_EOICR = 0;\r
projects / freertos / commitdiff