Problems while enabling nested interrupts on Zynq-7000

devil1989 wrote on Friday, July 21, 2017:

I am working with a Zynq-7000 and FreeRTOS 8.2.3. I would like to enable nested interrupts but I am experiencing some problems.

As Xilinx AR54128 ( says, I call XScuGic_CPUWriteReg(IntcInstancePtr, XSCGIC_BIN_PT_OFFSET,0x03) during the interrupt controller initialization, before the XilExceptionInit().
Then, my ISR routine is something like this:

void Handler()
	BaseType_t xTaskWokenByReceive = pdFALSE;
	BaseType_t xHigherPriorityTaskWoken = pdFALSE;

	if(xQueueReceiveFromISR(<argA>, <argB>, &xTaskWokenByReceive) == pdTRUE)
		vTaskNotifyGiveFromISR(<argC>, &xHigherPriorityTaskWoken);
	else if(xQueueReceiveFromISR(<argD>, <argE>, &xTaskWokenByReceive) == pdTRUE)
		vTaskNotifyGiveFromISR(<argF>, &xHigherPriorityTaskWoken);
		// Do nothing

/* If xHigherPriorityTaskWoken is now set to pdTRUE then a context switch
	 * should be performed to ensure the interrupt returns directly to the highest
	 * priority task.  The macro used for this purpose is dependent on the port in
	 * use and may be called portEND_SWITCHING_ISR().

The priority of the related interrupt is equal to configMAX_API_CALL_INTERRUPT_PRIORITY.
During the execution I get two assert errors:

  • Assert failed in file port.c, line 539
  • Assert failed in file port.c, line 424

The first one comes from the first configASSERT of the function vPortValidateInterruptPriority():

	void vPortValidateInterruptPriority( void )
		/* The following assertion will fail if a service routine (ISR) for
		an interrupt that has been assigned a priority above
		function.  ISR safe FreeRTOS API functions must *only* be called
		from interrupts that have been assigned a priority at or below

		Numerically low interrupt priority numbers represent logically high
		interrupt priorities, therefore the priority of the interrupt must
		be set to a value equal to or numerically *higher* than

		FreeRTOS maintains separate thread and ISR API functions to ensure
		interrupt entry is as fast and simple as possible. */

		/* Priority grouping:  The interrupt controller (GIC) allows the bits
		that define each interrupt's priority to be split between bits that
		define the interrupt's pre-emption priority bits and bits that define
		the interrupt's sub-priority.  For simplicity all bits must be defined
		to be pre-emption priority bits.  The following assertion will fail if
		this is not the case (if some bits represent a sub-priority).

		The priority grouping is configured by the GIC's binary point register
		(ICCBPR).  Writting 0 to ICCBPR will ensure it is set to its lowest
		possible value (which may be above 0). */

The second one from the last configASSERT of the function vPortEnterCritical():

void vPortEnterCritical( void )
	/* Mask interrupts up to the max syscall interrupt priority. */

	/* Now interrupts are disabled ulCriticalNesting can be accessed
	directly.  Increment ulCriticalNesting to keep a count of how many times
	portENTER_CRITICAL() has been called. */

	/* This is not the interrupt safe version of the enter critical function so
	assert() if it is being called from an interrupt context.  Only API
	functions that end in "FromISR" can be used in an interrupt.  Only assert if
	the critical nesting count is 1 to protect against recursive calls if the
	assert function also uses a critical section. */
	if( ulCriticalNesting == 1 )
		configASSERT( ulPortInterruptNesting == 0 );

Does anyone know why I get those errors?
Am I making some mistakes while setting the interrupt’s priority?
Thank you for the help!


rtel wrote on Friday, July 21, 2017:

I don’t know what the Xil_EnableNestedInterrupts() and
Xil_DisableNestedInterrupts() calls do, but have never had to use them
myself to use nested interrupts.

Have you read the section on interrupts on the following page:

  • in particular make sure the vApplicationIRQHandler() function is
    enabling interrupts again before calling the handler installed for the

devil1989 wrote on Monday, July 24, 2017:

Thanks for your answer.
I knew that page and I read the section on interrupts.
I do not have the function vApplicationIRQHandler() but I have another similar function that does similar things.

void FreeRTOS_ApplicationIRQHandler( uint32_t ulICCIAR )
extern const XScuGic_Config XScuGic_ConfigTable[];
static const XScuGic_VectorTableEntry *pxVectorTable = XScuGic_ConfigTable[ XPAR_SCUGIC_SINGLE_DEVICE_ID ].HandlerTable;
uint32_t ulInterruptID;
const XScuGic_VectorTableEntry *pxVectorEntry;

	/* The ID of the interrupt is obtained by bitwise anding the ICCIAR value
	with 0x3FF. */
	ulInterruptID = ulICCIAR & 0x3FFUL;
		/* Call the function installed in the array of installed handler functions. */
		pxVectorEntry = &( pxVectorTable[ ulInterruptID ] );
		pxVectorEntry->Handler( pxVectorEntry->CallBackRef );

It seems a bit different from the function shown in the link you provided, but I cannot re-define it in my application as it is not a weak function.

Am I missing something?
Thank you.

rtel wrote on Monday, July 24, 2017:

That handler is not re-enabling interrupts, so if you want to you nested
interrupts you will have to re-enable interrupts in the handler function
itself (that is, the function called by
FreeRTOS_ApplicationIRQHandler()). Refer to the code on the page I
linked to before to see how interrupts are re-enabled if you are not sure.